@flyingrobots/graft 0.6.1 → 0.7.0

package/src/cli/cli-error.ts

@@ -39,29 +39,50 @@ export function describeCliFailure(argv: readonly string[]): CliErrorDetails {
 
   if (group === "serve") {
     return {
-      usage: "graft serve",
-      nextSteps: ["Run `graft help` to see the explicit transport entrypoints."],
+      usage: "graft serve [--runtime <repo-local|daemon>] [--socket <path>] [--no-autostart]",
+      nextSteps: [
+        "`graft serve` is repo-local stdio. Use `graft serve --runtime daemon` for the daemon-backed stdio bridge.",
+      ],
     };
   }
 
   if (group === "daemon") {
+    if (subcommand === "status") {
+      return {
+        usage: "graft daemon status [--socket <path>]",
+        nextSteps: ["Start the daemon with `graft daemon` or target another daemon with `--socket <path>`."],
+      };
+    }
     return {
-      usage: "graft daemon [--socket <path>]",
-      nextSteps: ["Run `graft help` to see the daemon and grouped command surfaces."],
+      usage: "graft daemon [--socket <path>] | graft daemon status [--socket <path>]",
+      nextSteps: ["Run `graft daemon status` to inspect an already-running daemon without mutating daemon state."],
     };
   }
 
+  if (group === "doctor") {
+    return { usage: "graft doctor [--sludge] [--path <path>] [--json]" };
+  }
+
   if (group === "index") {
     return {
-      usage: "graft index [<from-ref>] [--json]",
-      nextSteps: ["Use `--json` for machine-readable output."],
+      usage: "graft index [--path <path>] [--json]",
+      nextSteps: ["Use `--path <path>` for lazy per-file indexing and `--json` for machine-readable output."],
+    };
+  }
+
+  if (group === "enhance") {
+    return {
+      usage: "git-graft enhance --since <ref> [--head <ref>] [--json]",
+      nextSteps: [
+        "Use `git graft enhance --since <ref>` after package install, or `git-graft enhance --since <ref>` via the direct binary.",
+      ],
     };
   }
 
   if (group === "init") {
     return {
       usage:
-        "graft init [--json] [--write-claude-mcp] [--write-claude-hooks] "
+        "graft init [--json] [--mcp-runtime <repo-local|daemon>] [--write-claude-mcp] [--write-claude-hooks] "
         + "[--write-target-git-hooks] [--write-codex-mcp] [--write-cursor-mcp] "
         + "[--write-windsurf-mcp] [--write-continue-mcp] [--write-cline-mcp]",
       nextSteps: ["Run `graft help` to confirm the repo-local bootstrap surfaces."],
@@ -97,8 +118,20 @@ export function describeCliFailure(argv: readonly string[]): CliErrorDetails {
     if (subcommand === "map") {
       return { usage: "graft struct map [<directory>] [--json]" };
     }
+    if (subcommand === "churn") {
+      return { usage: "graft struct churn [--path <path>] [--limit <n>] [--json]" };
+    }
+    if (subcommand === "exports") {
+      return { usage: "graft struct exports [<base-ref> <head-ref>] [--json]" };
+    }
+    if (subcommand === "log") {
+      return { usage: "graft struct log [--path <path>] [--limit <n>] [--json]" };
+    }
+    if (subcommand === "review") {
+      return { usage: "graft struct review [--base <ref>] [--head <ref>] [--json]" };
+    }
     return {
-      usage: "graft struct <diff|since|map> ...",
+      usage: "graft struct <diff|since|map|churn|exports|log|review> ...",
       nextSteps: ["Run `graft help` to see the available structural subcommands."],
     };
   }
@@ -110,8 +143,14 @@ export function describeCliFailure(argv: readonly string[]): CliErrorDetails {
     if (subcommand === "show") {
       return { usage: "graft symbol show <symbol> [--path <path>] [--ref <ref>] [--json]" };
     }
+    if (subcommand === "blame") {
+      return { usage: "graft symbol blame <symbol> [--path <path>] [--json]" };
+    }
+    if (subcommand === "difficulty") {
+      return { usage: "graft symbol difficulty <symbol> [--path <path>] [--limit <n>] [--json]" };
+    }
     return {
-      usage: "graft symbol <find|show> ...",
+      usage: "graft symbol <find|show|blame|difficulty> ...",
       nextSteps: ["Run `graft help` to see the available symbol subcommands."],
     };
   }
@@ -130,7 +169,7 @@ export function describeCliFailure(argv: readonly string[]): CliErrorDetails {
       return { usage: "graft diag local-history-dag [--limit <n>] [--json]" };
     }
     if (subcommand === "doctor") {
-      return { usage: "graft diag doctor [--json]" };
+      return { usage: "graft diag doctor [--sludge] [--path <path>] [--json]" };
     }
     if (subcommand === "explain") {
       return { usage: "graft diag explain <reason-code> [--json]" };

package/src/cli/command-parser.ts

@@ -12,6 +12,19 @@ export interface ParsedCommand {
   args: Record<string, unknown>;
 }
 
+export type ServeRuntime = "repo-local" | "daemon";
+
+export interface ParsedServeCommand {
+  readonly runtime: ServeRuntime;
+  readonly socketPath?: string | undefined;
+  readonly spawnIfMissing?: boolean | undefined;
+}
+
+export interface ParsedDaemonCommand {
+  readonly action: "start" | "status";
+  readonly socketPath?: string | undefined;
+}
+
 export function resolveEntrypointArgs(
   args: readonly string[],
   stdinIsTTY: boolean | undefined,
@@ -65,10 +78,50 @@ function parsePositiveInt(raw: string | undefined, flag: string): number {
   return value;
 }
 
-export function parseDaemonCommand(cwd: string, argv: string[]): { socketPath?: string } {
+export function parseDaemonCommand(cwd: string, argv: string[]): ParsedDaemonCommand {
+  const action = argv[0] === "status" ? "status" : "start";
+  if (action === "status") {
+    argv.shift();
+  }
   const socketPath = consumeOption(argv, "--socket");
   expectNoArgs(argv);
-  return socketPath !== undefined ? { socketPath: path.resolve(cwd, socketPath) } : {};
+  return {
+    action,
+    ...(socketPath !== undefined ? { socketPath: path.resolve(cwd, socketPath) } : {}),
+  };
+}
+
+function parseServeRuntime(raw: string | undefined): ServeRuntime {
+  if (raw === undefined || raw === "repo-local") {
+    return "repo-local";
+  }
+  if (raw === "daemon") {
+    return "daemon";
+  }
+  throw new Error(`--runtime must be repo-local or daemon, got ${raw}`);
+}
+
+export function parseServeCommand(cwd: string, argv: string[]): ParsedServeCommand {
+  const runtime = parseServeRuntime(consumeOption(argv, "--runtime"));
+  const socketPath = consumeOption(argv, "--socket");
+  const noAutostart = consumeFlag(argv, "--no-autostart");
+  expectNoArgs(argv);
+
+  if (runtime === "repo-local") {
+    if (socketPath !== undefined) {
+      throw new Error("--socket requires --runtime daemon");
+    }
+    if (noAutostart) {
+      throw new Error("--no-autostart requires --runtime daemon");
+    }
+    return { runtime };
+  }
+
+  return {
+    runtime,
+    ...(socketPath !== undefined ? { socketPath: path.resolve(cwd, socketPath) } : {}),
+    ...(noAutostart ? { spawnIfMissing: false } : {}),
+  };
 }
 
 export function parseGlobalOptions(
@@ -161,6 +214,62 @@ function parseStructCommand(argv: string[]): ParsedCommand {
     };
   }
 
+  if (subcommand === "churn") {
+    const filePath = consumeOption(argv, "--path");
+    const limitRaw = consumeOption(argv, "--limit");
+    expectNoArgs(argv);
+    return {
+      command: "struct_churn",
+      json,
+      args: {
+        ...(filePath !== undefined ? { path: filePath } : {}),
+        ...(limitRaw !== undefined ? { limit: parsePositiveInt(limitRaw, "--limit") } : {}),
+      },
+    };
+  }
+
+  if (subcommand === "exports") {
+    const base = argv[0]?.startsWith("--") === false ? consumePositional(argv, "base ref") : undefined;
+    const head = argv[0]?.startsWith("--") === false ? consumePositional(argv, "head ref") : undefined;
+    expectNoArgs(argv);
+    return {
+      command: "struct_exports",
+      json,
+      args: {
+        ...(base !== undefined ? { base } : {}),
+        ...(head !== undefined ? { head } : {}),
+      },
+    };
+  }
+
+  if (subcommand === "log") {
+    const filePath = consumeOption(argv, "--path");
+    const limitRaw = consumeOption(argv, "--limit");
+    expectNoArgs(argv);
+    return {
+      command: "struct_log",
+      json,
+      args: {
+        ...(filePath !== undefined ? { path: filePath } : {}),
+        ...(limitRaw !== undefined ? { limit: parsePositiveInt(limitRaw, "--limit") } : {}),
+      },
+    };
+  }
+
+  if (subcommand === "review") {
+    const base = consumeOption(argv, "--base");
+    const head = consumeOption(argv, "--head");
+    expectNoArgs(argv);
+    return {
+      command: "struct_review",
+      json,
+      args: {
+        ...(base !== undefined ? { base } : {}),
+        ...(head !== undefined ? { head } : {}),
+      },
+    };
+  }
+
   throw new Error(`Unknown struct subcommand: ${subcommand}`);
 }
 
@@ -200,6 +309,36 @@ function parseSymbolCommand(argv: string[]): ParsedCommand {
     };
   }
 
+  if (subcommand === "blame") {
+    const symbol = consumePositional(argv, "symbol");
+    const filePath = consumeOption(argv, "--path");
+    expectNoArgs(argv);
+    return {
+      command: "symbol_blame",
+      json,
+      args: {
+        symbol,
+        ...(filePath !== undefined ? { path: filePath } : {}),
+      },
+    };
+  }
+
+  if (subcommand === "difficulty") {
+    const symbol = consumePositional(argv, "symbol");
+    const filePath = consumeOption(argv, "--path");
+    const limitRaw = consumeOption(argv, "--limit");
+    expectNoArgs(argv);
+    return {
+      command: "symbol_difficulty",
+      json,
+      args: {
+        symbol,
+        ...(filePath !== undefined ? { path: filePath } : {}),
+        ...(limitRaw !== undefined ? { limit: parsePositiveInt(limitRaw, "--limit") } : {}),
+      },
+    };
+  }
+
   throw new Error(`Unknown symbol subcommand: ${subcommand}`);
 }
 
@@ -224,8 +363,17 @@ function parseDiagCommand(argv: string[]): ParsedCommand {
   const json = consumeFlag(argv, "--json");
 
   if (subcommand === "doctor") {
+    const sludge = consumeFlag(argv, "--sludge");
+    const filePath = consumeOption(argv, "--path");
     expectNoArgs(argv);
-    return { command: "diag_doctor", json, args: {} };
+    return {
+      command: "diag_doctor",
+      json,
+      args: {
+        ...(sludge ? { sludge } : {}),
+        ...(filePath !== undefined ? { path: filePath } : {}),
+      },
+    };
   }
 
   if (subcommand === "activity") {
@@ -289,14 +437,48 @@ function parseDiagCommand(argv: string[]): ParsedCommand {
   throw new Error(`Unknown diag subcommand: ${subcommand}`);
 }
 
+function parseEnhanceCommand(argv: string[]): ParsedCommand {
+  const json = consumeFlag(argv, "--json");
+  const since = consumeOption(argv, "--since");
+  const head = consumeOption(argv, "--head");
+  if (since === undefined) {
+    expectNoArgs(argv);
+    throw new Error("Missing --since");
+  }
+  expectNoArgs(argv);
+  return {
+    command: "git_graft_enhance",
+    json,
+    args: {
+      since,
+      ...(head !== undefined ? { head } : {}),
+    },
+  };
+}
+
 export function parseCommand(argv: string[]): ParsedCommand {
   const group = consumePositional(argv, "command");
 
+  if (group === "doctor") {
+    const json = consumeFlag(argv, "--json");
+    const sludge = consumeFlag(argv, "--sludge");
+    const filePath = consumeOption(argv, "--path");
+    expectNoArgs(argv);
+    return {
+      command: "diag_doctor",
+      json,
+      args: {
+        ...(sludge ? { sludge } : {}),
+        ...(filePath !== undefined ? { path: filePath } : {}),
+      },
+    };
+  }
   if (group === "read") return parseReadCommand(argv);
   if (group === "struct") return parseStructCommand(argv);
   if (group === "symbol") return parseSymbolCommand(argv);
   if (group === "migrate") return parseMigrateCommand(argv);
   if (group === "diag") return parseDiagCommand(argv);
+  if (group === "enhance") return parseEnhanceCommand(argv);
 
   throw new Error(`Unknown command: ${group}`);
 }

package/src/cli/daemon-status-model.ts

@@ -0,0 +1,238 @@
+import * as path from "node:path";
+import { type z } from "zod";
+import { mcpOutputBodySchemas } from "../contracts/output-schema-mcp.js";
+
+export type DaemonStatusPayload = z.output<typeof mcpOutputBodySchemas.daemon_status>;
+export type DaemonSessionsPayload = z.output<typeof mcpOutputBodySchemas.daemon_sessions>;
+export type DaemonReposPayload = z.output<typeof mcpOutputBodySchemas.daemon_repos>;
+export type DaemonMonitorsPayload = z.output<typeof mcpOutputBodySchemas.daemon_monitors>;
+export type WorkspaceStatusPayload = z.output<typeof mcpOutputBodySchemas.workspace_status>;
+export type WorkspaceAuthorizationsPayload = z.output<typeof mcpOutputBodySchemas.workspace_authorizations>;
+
+export interface DaemonStatusReadSnapshot {
+  readonly status: DaemonStatusPayload;
+  readonly sessions?: DaemonSessionsPayload | undefined;
+  readonly currentRepo?: DaemonReposPayload | undefined;
+  readonly monitors?: DaemonMonitorsPayload | undefined;
+  readonly workspaceStatus?: WorkspaceStatusPayload | undefined;
+  readonly authorizations?: WorkspaceAuthorizationsPayload | undefined;
+}
+
+export type UnknownCount = number | "unknown";
+export type DaemonHealth = "ok" | "degraded";
+export type DaemonCurrentAuthorization = "authorized" | "not_authorized" | "unknown";
+export type DaemonCurrentBindState = "bound" | "unbound" | "unknown";
+export type DaemonSchedulerPressure = "idle" | "running" | "queued" | "saturated";
+export type DaemonWorkerPressure = "idle" | "busy" | "saturated" | "unknown";
+
+export interface DaemonStatusModel {
+  readonly command: "daemon_status";
+  readonly cwd: string;
+  readonly daemon: {
+    readonly health: DaemonHealth;
+    readonly transport: DaemonStatusPayload["transport"];
+    readonly socketPath: string;
+    readonly mcpPath: string;
+    readonly healthPath: string;
+    readonly startedAt: string;
+    readonly sameUserOnly: true;
+    readonly activeWarpRepos: number;
+  };
+  readonly sessions: {
+    readonly total: number;
+    readonly bound: number;
+    readonly unbound: number;
+    readonly listed: UnknownCount;
+  };
+  readonly workspaces: {
+    readonly authorized: number;
+    readonly authorizedRepos: number;
+    readonly bound: UnknownCount;
+    readonly current: {
+      readonly cwd: string;
+      readonly authorization: DaemonCurrentAuthorization;
+      readonly bindState: DaemonCurrentBindState;
+      readonly repoId: string | null;
+      readonly worktreeRoot: string | null;
+      readonly activeSessions: number | null;
+    };
+  };
+  readonly monitors: {
+    readonly total: number;
+    readonly running: number;
+    readonly paused: number;
+    readonly stopped: number;
+    readonly failing: number;
+    readonly backlog: number;
+    readonly listed: UnknownCount;
+  };
+  readonly scheduler: {
+    readonly maxConcurrentJobs: number;
+    readonly activeJobs: number;
+    readonly queuedJobs: number;
+    readonly interactiveQueuedJobs: number;
+    readonly backgroundQueuedJobs: number;
+    readonly longestQueuedWaitMs: number;
+    readonly pressure: DaemonSchedulerPressure;
+  };
+  readonly workers: {
+    readonly mode: DaemonStatusPayload["workers"]["mode"];
+    readonly totalWorkers: number;
+    readonly busyWorkers: number;
+    readonly idleWorkers: number;
+    readonly queuedTasks: number;
+    readonly pressure: DaemonWorkerPressure;
+  };
+  readonly degraded: readonly string[];
+}
+
+interface CurrentWorkspacePosture {
+  readonly authorization: DaemonCurrentAuthorization;
+  readonly repoId: string | null;
+  readonly worktreeRoot: string | null;
+  readonly activeSessions: number | null;
+}
+
+function normalizePath(value: string): string {
+  return path.resolve(value);
+}
+
+function schedulerPressure(status: DaemonStatusPayload): DaemonSchedulerPressure {
+  if (status.scheduler.queuedJobs > 0) return "queued";
+  if (status.scheduler.activeJobs >= status.scheduler.maxConcurrentJobs) return "saturated";
+  if (status.scheduler.activeJobs > 0) return "running";
+  return "idle";
+}
+
+function workerPressure(status: DaemonStatusPayload): DaemonWorkerPressure {
+  if (status.workers.totalWorkers === 0) return "unknown";
+  if (status.workers.queuedTasks > 0 || status.workers.busyWorkers >= status.workers.totalWorkers) {
+    return "saturated";
+  }
+  if (status.workers.busyWorkers > 0) return "busy";
+  return "idle";
+}
+
+function buildDegradedReasons(status: DaemonStatusPayload): string[] {
+  const reasons: string[] = [];
+  if (status.failingMonitors > 0) reasons.push("failing_monitors");
+  if (status.backlogMonitors > 0) reasons.push("monitor_backlog");
+  if (status.scheduler.queuedJobs > 0) reasons.push("scheduler_queue");
+  if (status.scheduler.failedJobs > 0) reasons.push("scheduler_failures");
+  if (status.workers.queuedTasks > 0) reasons.push("worker_queue");
+  if (status.workers.failedTasks > 0) reasons.push("worker_failures");
+  return reasons;
+}
+
+function currentPosture(
+  cwd: string,
+  snapshot: DaemonStatusReadSnapshot,
+): CurrentWorkspacePosture {
+  const normalizedCwd = normalizePath(cwd);
+  const currentRepo = snapshot.currentRepo?.repos[0];
+  const currentWorktree = currentRepo?.worktrees.find((worktree) => {
+    return normalizePath(worktree.worktreeRoot) === normalizedCwd;
+  }) ?? currentRepo?.worktrees[0];
+
+  const exactAuthorization = snapshot.authorizations?.workspaces.find((workspace) => {
+    return normalizePath(workspace.worktreeRoot) === normalizedCwd;
+  });
+
+  if (currentRepo !== undefined || exactAuthorization !== undefined) {
+    return {
+      authorization: "authorized",
+      repoId: currentRepo?.repoId ?? exactAuthorization?.repoId ?? null,
+      worktreeRoot: currentWorktree?.worktreeRoot ?? exactAuthorization?.worktreeRoot ?? null,
+      activeSessions: currentWorktree?.activeSessions ?? exactAuthorization?.activeSessions ?? null,
+    };
+  }
+
+  if (snapshot.authorizations !== undefined || snapshot.currentRepo !== undefined) {
+    return {
+      authorization: "not_authorized",
+      repoId: null,
+      worktreeRoot: null,
+      activeSessions: null,
+    };
+  }
+
+  return {
+    authorization: "unknown",
+    repoId: null,
+    worktreeRoot: null,
+    activeSessions: null,
+  };
+}
+
+export function buildDaemonStatusModel(input: {
+  readonly cwd: string;
+  readonly snapshot: DaemonStatusReadSnapshot;
+}): DaemonStatusModel {
+  const { cwd, snapshot } = input;
+  const { status } = snapshot;
+  const degraded = buildDegradedReasons(status);
+  const current = currentPosture(cwd, snapshot);
+
+  return {
+    command: "daemon_status",
+    cwd,
+    daemon: {
+      health: degraded.length === 0 ? "ok" : "degraded",
+      transport: status.transport,
+      socketPath: status.socketPath,
+      mcpPath: status.mcpPath,
+      healthPath: status.healthPath,
+      startedAt: status.startedAt,
+      sameUserOnly: status.sameUserOnly,
+      activeWarpRepos: status.activeWarpRepos,
+    },
+    sessions: {
+      total: status.activeSessions,
+      bound: status.boundSessions,
+      unbound: status.unboundSessions,
+      listed: snapshot.sessions?.sessions.length ?? "unknown",
+    },
+    workspaces: {
+      authorized: status.authorizedWorkspaces,
+      authorizedRepos: status.authorizedRepos,
+      bound: snapshot.authorizations === undefined
+        ? "unknown"
+        : snapshot.authorizations.workspaces.filter((workspace) => workspace.activeSessions > 0).length,
+      current: {
+        cwd,
+        authorization: current.authorization,
+        bindState: snapshot.workspaceStatus?.bindState ?? "unknown",
+        repoId: current.repoId,
+        worktreeRoot: current.worktreeRoot,
+        activeSessions: current.activeSessions,
+      },
+    },
+    monitors: {
+      total: status.totalMonitors,
+      running: status.runningMonitors,
+      paused: status.pausedMonitors,
+      stopped: status.stoppedMonitors,
+      failing: status.failingMonitors,
+      backlog: status.backlogMonitors,
+      listed: snapshot.monitors?.monitors.length ?? "unknown",
+    },
+    scheduler: {
+      maxConcurrentJobs: status.scheduler.maxConcurrentJobs,
+      activeJobs: status.scheduler.activeJobs,
+      queuedJobs: status.scheduler.queuedJobs,
+      interactiveQueuedJobs: status.scheduler.interactiveQueuedJobs,
+      backgroundQueuedJobs: status.scheduler.backgroundQueuedJobs,
+      longestQueuedWaitMs: status.scheduler.longestQueuedWaitMs,
+      pressure: schedulerPressure(status),
+    },
+    workers: {
+      mode: status.workers.mode,
+      totalWorkers: status.workers.totalWorkers,
+      busyWorkers: status.workers.busyWorkers,
+      idleWorkers: status.workers.idleWorkers,
+      queuedTasks: status.workers.queuedTasks,
+      pressure: workerPressure(status),
+    },
+    degraded,
+  };
+}

package/src/cli/daemon-status-render.ts

@@ -0,0 +1,102 @@
+import { headerBox, table } from "@flyingrobots/bijou";
+import { initDefaultContext } from "@flyingrobots/bijou-node";
+import type { DaemonStatusModel, UnknownCount } from "./daemon-status-model.js";
+
+function count(value: UnknownCount): string {
+  return typeof value === "number" ? String(value) : value;
+}
+
+function currentAuthLabel(value: DaemonStatusModel["workspaces"]["current"]["authorization"]): string {
+  if (value === "authorized") return "ok";
+  if (value === "not_authorized") return "none";
+  return "unknown";
+}
+
+export function renderDaemonStatus(model: DaemonStatusModel): string {
+  const ctx = initDefaultContext();
+  const rows = [
+    [
+      "runtime",
+      [
+        `transport ${model.daemon.transport}`,
+        `started ${model.daemon.startedAt}`,
+        `warp repos ${String(model.daemon.activeWarpRepos)}`,
+      ].join("; "),
+    ],
+    [
+      "sessions",
+      [
+        `total ${String(model.sessions.total)}`,
+        `bound ${String(model.sessions.bound)}`,
+        `unbound ${String(model.sessions.unbound)}`,
+        `listed ${count(model.sessions.listed)}`,
+      ].join("; "),
+    ],
+    [
+      "workspaces",
+      [
+        `auth ${String(model.workspaces.authorized)}`,
+        `repos ${String(model.workspaces.authorizedRepos)}`,
+        `bound ${count(model.workspaces.bound)}`,
+        `current ${currentAuthLabel(model.workspaces.current.authorization)}`,
+        `status-session ${model.workspaces.current.bindState}`,
+        `active ${model.workspaces.current.activeSessions === null ? "unknown" : String(model.workspaces.current.activeSessions)}`,
+      ].join("; "),
+    ],
+    [
+      "monitors",
+      [
+        `total ${String(model.monitors.total)}`,
+        `running ${String(model.monitors.running)}`,
+        `paused ${String(model.monitors.paused)}`,
+        `stopped ${String(model.monitors.stopped)}`,
+        `failing ${String(model.monitors.failing)}`,
+        `backlog ${String(model.monitors.backlog)}`,
+        `listed ${count(model.monitors.listed)}`,
+      ].join("; "),
+    ],
+    [
+      "scheduler",
+      [
+        model.scheduler.pressure,
+        `active ${String(model.scheduler.activeJobs)}/${String(model.scheduler.maxConcurrentJobs)}`,
+        `queued ${String(model.scheduler.queuedJobs)}`,
+        `interactive ${String(model.scheduler.interactiveQueuedJobs)}`,
+        `background ${String(model.scheduler.backgroundQueuedJobs)}`,
+        `longest wait ${String(model.scheduler.longestQueuedWaitMs)}ms`,
+      ].join("; "),
+    ],
+    [
+      "workers",
+      [
+        model.workers.pressure,
+        model.workers.mode,
+        `busy ${String(model.workers.busyWorkers)}/${String(model.workers.totalWorkers)}`,
+        `idle ${String(model.workers.idleWorkers)}`,
+        `queued ${String(model.workers.queuedTasks)}`,
+      ].join("; "),
+    ],
+  ];
+
+  return [
+    headerBox("Daemon Status", {
+      detail: `health: ${model.daemon.health}`,
+      width: 80,
+      ctx,
+    }),
+    `cwd: ${model.cwd}`,
+    `socket: ${model.daemon.socketPath}`,
+    `mcp: ${model.daemon.mcpPath}`,
+    "",
+    table({
+      ctx,
+      columns: [
+        { header: "Surface" },
+        { header: "State" },
+      ],
+      rows,
+    }),
+    "",
+    `degraded: ${model.degraded.length === 0 ? "none" : model.degraded.join(", ")}`,
+  ].join("\n").trimEnd();
+}