Refactor VM lifecycle around capabilities

Make host-integrated VM features fit a standard Go extension path instead of adding more one-off branches through vm.go. This is the enabling refactor for future work like shared mounts, not the /work feature itself.

Add a daemon capability pipeline plus a structured guest-config builder, then move the existing /root work-disk mount, built-in DNS, and NAT wiring onto those hooks. Generalize Firecracker drive config at the same time so later storage features can extend machine setup without another hardcoded path.

Add banger doctor on top of the shared readiness checks, update the docs to describe the new architecture, and cover the new seams with guest-config, capability, report, CLI, and full go test verification. Also verify make build and a real ./banger doctor run on the host.

internal/cli/banger.go

@@ -16,6 +16,7 @@ import (
 
 	"banger/internal/api"
 	"banger/internal/config"
+	"banger/internal/daemon"
 	"banger/internal/hostnat"
 	"banger/internal/model"
 	"banger/internal/paths"
@@ -31,6 +32,7 @@ var (
 	daemonExePath   = func(pid int) string {
 		return filepath.Join("/proc", fmt.Sprintf("%d", pid), "exe")
 	}
+	doctorFunc = daemon.Doctor
 )
 
 func NewBangerCommand() *cobra.Command {
@@ -42,10 +44,31 @@ func NewBangerCommand() *cobra.Command {
 		RunE:          helpNoArgs,
 	}
 	root.CompletionOptions.DisableDefaultCmd = true
-	root.AddCommand(newDaemonCommand(), newVMCommand(), newImageCommand(), newTUICommand(), newInternalCommand())
+	root.AddCommand(newDaemonCommand(), newDoctorCommand(), newVMCommand(), newImageCommand(), newTUICommand(), newInternalCommand())
 	return root
 }
 
+func newDoctorCommand() *cobra.Command {
+	return &cobra.Command{
+		Use:   "doctor",
+		Short: "Check host and runtime readiness",
+		Args:  noArgsUsage("usage: banger doctor"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			report, err := doctorFunc(cmd.Context())
+			if err != nil {
+				return err
+			}
+			if err := printDoctorReport(cmd.OutOrStdout(), report); err != nil {
+				return err
+			}
+			if report.HasFailures() {
+				return errors.New("doctor found failing checks")
+			}
+			return nil
+		},
+	}
+}
+
 func newInternalCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:    "internal",
@@ -994,6 +1017,21 @@ func printImageSummary(out anyWriter, image model.Image) error {
 	return err
 }
 
+func printDoctorReport(out anyWriter, report system.Report) error {
+	for _, check := range report.Checks {
+		status := strings.ToUpper(string(check.Status))
+		if _, err := fmt.Fprintf(out, "%s\t%s\n", status, check.Name); err != nil {
+			return err
+		}
+		for _, detail := range check.Details {
+			if _, err := fmt.Fprintf(out, "  - %s\n", detail); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 type anyWriter interface {
 	Write(p []byte) (n int, err error)
 }

internal/cli/cli_test.go

@@ -3,6 +3,7 @@ package cli
 import (
 	"bytes"
 	"context"
+	"errors"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -12,6 +13,7 @@ import (
 
 	"banger/internal/api"
 	"banger/internal/model"
+	"banger/internal/system"
 )
 
 func TestNewBangerCommandHasExpectedSubcommands(t *testing.T) {
@@ -20,12 +22,62 @@ func TestNewBangerCommandHasExpectedSubcommands(t *testing.T) {
 	for _, sub := range cmd.Commands() {
 		names = append(names, sub.Name())
 	}
-	want := []string{"daemon", "image", "internal", "tui", "vm"}
+	want := []string{"daemon", "doctor", "image", "internal", "tui", "vm"}
 	if !reflect.DeepEqual(names, want) {
 		t.Fatalf("subcommands = %v, want %v", names, want)
 	}
 }
 
+func TestDoctorCommandPrintsReportAndFailsOnHardFailures(t *testing.T) {
+	original := doctorFunc
+	t.Cleanup(func() {
+		doctorFunc = original
+	})
+	doctorFunc = func(context.Context) (system.Report, error) {
+		return system.Report{
+			Checks: []system.CheckResult{
+				{Name: "runtime bundle", Status: system.CheckStatusPass, Details: []string{"runtime dir /tmp/runtime"}},
+				{Name: "feature nat", Status: system.CheckStatusFail, Details: []string{"missing iptables"}},
+			},
+		}, nil
+	}
+
+	cmd := NewBangerCommand()
+	var stdout bytes.Buffer
+	cmd.SetOut(&stdout)
+	cmd.SetErr(&stdout)
+	cmd.SetArgs([]string{"doctor"})
+
+	err := cmd.Execute()
+	if err == nil || !strings.Contains(err.Error(), "doctor found failing checks") {
+		t.Fatalf("Execute() error = %v, want doctor failure", err)
+	}
+	output := stdout.String()
+	if !strings.Contains(output, "PASS\truntime bundle") {
+		t.Fatalf("output = %q, want runtime bundle pass", output)
+	}
+	if !strings.Contains(output, "FAIL\tfeature nat") {
+		t.Fatalf("output = %q, want feature nat fail", output)
+	}
+}
+
+func TestDoctorCommandReturnsUnderlyingError(t *testing.T) {
+	original := doctorFunc
+	t.Cleanup(func() {
+		doctorFunc = original
+	})
+	doctorFunc = func(context.Context) (system.Report, error) {
+		return system.Report{}, errors.New("load failed")
+	}
+
+	cmd := NewBangerCommand()
+	cmd.SetArgs([]string{"doctor"})
+	err := cmd.Execute()
+	if err == nil || !strings.Contains(err.Error(), "load failed") {
+		t.Fatalf("Execute() error = %v, want load failed", err)
+	}
+}
+
 func TestInternalNATFlagsExist(t *testing.T) {
 	root := NewBangerCommand()
 	internal, _, err := root.Find([]string{"internal"})