@flyingrobots/graft 0.6.1 → 0.7.0

package/src/cli/init-client-config.ts

@@ -3,8 +3,12 @@ import * as path from "node:path";
 import {
   GRAFT_HOOKS_CONFIG,
   GRAFT_MCP_SERVER,
+  GraftMcpServer,
   InitAction,
+  isGraftMcpServerEntryForRuntime,
   type GraftHookMatcher,
+  type JsonObjectValue,
+  type JsonValue,
 } from "./init-model.js";
 import {
   JsonArrayNode,
@@ -14,28 +18,33 @@ import {
 class JsonMcpConfigDocument {
   constructor(
     private readonly document: JsonObjectDocument,
-    private readonly server: typeof GRAFT_MCP_SERVER,
+    private readonly server: GraftMcpServer,
+    private readonly updateExisting: boolean,
   ) {}
 
   static create(
     filePath: string,
     label: string,
-    server: typeof GRAFT_MCP_SERVER,
+    server: GraftMcpServer,
+    updateExisting: boolean,
   ): JsonMcpConfigDocument {
     return new JsonMcpConfigDocument(
       JsonObjectDocument.create(filePath, label, server.toJsonMcpConfig()),
       server,
+      updateExisting,
     );
   }
 
   static open(
     filePath: string,
     label: string,
-    server: typeof GRAFT_MCP_SERVER,
+    server: GraftMcpServer,
+    updateExisting: boolean,
   ): JsonMcpConfigDocument {
     return new JsonMcpConfigDocument(
       JsonObjectDocument.open(filePath, label),
       server,
+      updateExisting,
     );
   }
 
@@ -46,6 +55,15 @@ class JsonMcpConfigDocument {
   ensureGraftServer(): InitAction {
     const root = this.document.root();
     const servers = root.ensureObject("mcpServers");
+    const existing = servers.toJsonValue()[this.server.name];
+    if (existing !== undefined) {
+      if (isGraftMcpServerEntryForRuntime(existing, this.server.runtime) || !this.updateExisting) {
+        return InitAction.exists(this.document.label, "already has graft mcp server");
+      }
+      servers.set(this.server.name, this.server.toJsonServerEntry());
+      this.document.write();
+      return InitAction.append(this.document.label, `updated graft mcp server runtime to ${this.server.runtime}`);
+    }
     if (servers.has(this.server.name)) {
       return InitAction.exists(this.document.label, "already has graft mcp server");
     }
@@ -58,28 +76,33 @@ class JsonMcpConfigDocument {
 class ContinueMcpConfigDocument {
   constructor(
     private readonly document: JsonObjectDocument,
-    private readonly server: typeof GRAFT_MCP_SERVER,
+    private readonly server: GraftMcpServer,
+    private readonly updateExisting: boolean,
   ) {}
 
   static create(
     filePath: string,
     label: string,
-    server: typeof GRAFT_MCP_SERVER,
+    server: GraftMcpServer,
+    updateExisting: boolean,
   ): ContinueMcpConfigDocument {
     return new ContinueMcpConfigDocument(
       JsonObjectDocument.create(filePath, label, server.toContinueConfig()),
       server,
+      updateExisting,
     );
   }
 
   static open(
     filePath: string,
     label: string,
-    server: typeof GRAFT_MCP_SERVER,
+    server: GraftMcpServer,
+    updateExisting: boolean,
   ): ContinueMcpConfigDocument {
     return new ContinueMcpConfigDocument(
       JsonObjectDocument.open(filePath, label),
       server,
+      updateExisting,
     );
   }
 
@@ -90,11 +113,16 @@ class ContinueMcpConfigDocument {
   ensureGraftServer(): InitAction {
     const root = this.document.root();
     const servers = root.ensureArray("mcpServers");
-    const exists = servers
-      .objectItems()
-      .some((entry) => entry.stringValue("name") === this.server.name);
-    if (exists) {
-      return InitAction.exists(this.document.label, "already has graft mcp server");
+    const existingEntries = servers.objectEntries();
+    const existing = existingEntries
+      .find((entry) => entry.node.stringValue("name") === this.server.name);
+    if (existing !== undefined) {
+      if (isContinueServerEntryForRuntime(existing.node.toJsonValue(), this.server.runtime) || !this.updateExisting) {
+        return InitAction.exists(this.document.label, "already has graft mcp server");
+      }
+      servers.set(existing.index, this.server.toContinueServerEntry());
+      this.document.write();
+      return InitAction.append(this.document.label, `updated graft mcp server runtime to ${this.server.runtime}`);
     }
     servers.push(this.server.toContinueServerEntry());
     this.document.write();
@@ -180,12 +208,15 @@ class ClaudeHooksDocument {
 export function ensureCodexStartupTimeout(
   existing: string,
 ): { content: string; changed: boolean } {
+  const ensured = ensureCodexMcpServerBlock(existing, GRAFT_MCP_SERVER, false);
+  return { content: ensured.content, changed: ensured.changed };
+}
+
+function codexBlockBounds(lines: readonly string[]): { start: number; end: number } | undefined {
   const marker = "[mcp_servers.graft]";
-  const timeoutLine = `startup_timeout_sec = ${String(GRAFT_MCP_SERVER.codexStartupTimeoutSec)}`;
-  const lines = existing.split("\n");
   const blockStart = lines.findIndex((line) => line.trim() === marker);
   if (blockStart === -1) {
-    return { content: existing, changed: false };
+    return undefined;
   }
 
   let blockEnd = lines.length;
@@ -197,53 +228,143 @@ export function ensureCodexStartupTimeout(
     }
   }
 
+  return { start: blockStart, end: blockEnd };
+}
+
+function replaceOrInsertLine(
+  lines: string[],
+  bounds: { readonly start: number; readonly end: number },
+  predicate: (line: string) => boolean,
+  value: string,
+): { end: number; changed: boolean } {
+  const index = lines
+    .slice(bounds.start + 1, bounds.end)
+    .findIndex(predicate);
+  if (index === -1) {
+    lines.splice(bounds.end, 0, value);
+    return { end: bounds.end + 1, changed: true };
+  }
+
+  const absoluteIndex = bounds.start + 1 + index;
+  if (lines[absoluteIndex] === value) {
+    return { end: bounds.end, changed: false };
+  }
+
+  lines[absoluteIndex] = value;
+  return { end: bounds.end, changed: true };
+}
+
+export function ensureCodexMcpServerBlock(
+  existing: string,
+  server: GraftMcpServer,
+  updateExisting: boolean,
+): { content: string; changed: boolean; detail?: string | undefined } {
+  const lines = existing.split("\n");
+  const bounds = codexBlockBounds(lines);
+  if (bounds === undefined) {
+    return { content: existing, changed: false };
+  }
+
+  let changed = false;
+  let runtimeChanged = false;
+  let blockEnd = bounds.end;
+  if (updateExisting) {
+    const command = replaceOrInsertLine(
+      lines,
+      { start: bounds.start, end: blockEnd },
+      (line) => line.trim().startsWith("command"),
+      `command = "${server.command}"`,
+    );
+    runtimeChanged = command.changed;
+    changed = command.changed;
+    blockEnd = command.end;
+
+    const args = replaceOrInsertLine(
+      lines,
+      { start: bounds.start, end: blockEnd },
+      (line) => line.trim().startsWith("args"),
+      server.toCodexTomlArgsLine(),
+    );
+    runtimeChanged = runtimeChanged || args.changed;
+    changed = changed || args.changed;
+    blockEnd = args.end;
+  }
+
   const hasTimeout = lines
-    .slice(blockStart + 1, blockEnd)
+    .slice(bounds.start + 1, blockEnd)
     .some((line) => line.trim().startsWith("startup_timeout_sec"));
-  if (hasTimeout) {
-    return { content: existing, changed: false };
+  if (!hasTimeout) {
+    lines.splice(blockEnd, 0, `startup_timeout_sec = ${String(server.codexStartupTimeoutSec)}`);
+    changed = true;
   }
 
-  lines.splice(blockEnd, 0, timeoutLine);
   return {
     content: lines.join("\n"),
-    changed: true,
+    changed,
+    ...(runtimeChanged ? { detail: `updated graft mcp server runtime to ${server.runtime}` } : {}),
   };
 }
 
-function ensureJsonMcpConfig(filePath: string, label: string): InitAction {
+function isContinueServerEntryForRuntime(value: JsonObjectValue, runtime: GraftMcpServer["runtime"]): boolean {
+  const { name, ...entry } = value;
+  void name;
+  return isGraftMcpServerEntryForRuntime(entry as JsonValue, runtime);
+}
+
+function ensureJsonMcpConfig(
+  filePath: string,
+  label: string,
+  server: GraftMcpServer,
+  updateExisting: boolean,
+): InitAction {
   if (!fs.existsSync(filePath)) {
-    const created = JsonMcpConfigDocument.create(filePath, label, GRAFT_MCP_SERVER);
+    const created = JsonMcpConfigDocument.create(filePath, label, server, updateExisting);
     created.write();
     return InitAction.create(label, "wrote graft mcp server");
   }
   return JsonMcpConfigDocument
-    .open(filePath, label, GRAFT_MCP_SERVER)
+    .open(filePath, label, server, updateExisting)
     .ensureGraftServer();
 }
 
-export function mergeClaudeMcpConfig(cwd: string): InitAction {
+export function mergeClaudeMcpConfig(
+  cwd: string,
+  server = GRAFT_MCP_SERVER,
+  updateExisting = false,
+): InitAction {
   const label = ".mcp.json";
   const filePath = path.join(cwd, label);
-  return ensureJsonMcpConfig(filePath, label);
+  return ensureJsonMcpConfig(filePath, label, server, updateExisting);
 }
 
-export function mergeCursorMcpConfig(cwd: string): InitAction {
+export function mergeCursorMcpConfig(
+  cwd: string,
+  server = GRAFT_MCP_SERVER,
+  updateExisting = false,
+): InitAction {
   const label = ".cursor/mcp.json";
   const filePath = path.join(cwd, ".cursor", "mcp.json");
-  return ensureJsonMcpConfig(filePath, label);
+  return ensureJsonMcpConfig(filePath, label, server, updateExisting);
 }
 
-export function mergeWindsurfMcpConfig(cwd: string): InitAction {
+export function mergeWindsurfMcpConfig(
+  cwd: string,
+  server = GRAFT_MCP_SERVER,
+  updateExisting = false,
+): InitAction {
   const label = ".codeium/windsurf/mcp_config.json";
   const filePath = path.join(cwd, ".codeium", "windsurf", "mcp_config.json");
-  return ensureJsonMcpConfig(filePath, label);
+  return ensureJsonMcpConfig(filePath, label, server, updateExisting);
 }
 
-export function mergeClineMcpConfig(cwd: string): InitAction {
+export function mergeClineMcpConfig(
+  cwd: string,
+  server = GRAFT_MCP_SERVER,
+  updateExisting = false,
+): InitAction {
   const label = ".vscode/cline_mcp_settings.json";
   const filePath = path.join(cwd, ".vscode", "cline_mcp_settings.json");
-  return ensureJsonMcpConfig(filePath, label);
+  return ensureJsonMcpConfig(filePath, label, server, updateExisting);
 }
 
 export function mergeClaudeHooksConfig(cwd: string): InitAction {
@@ -257,35 +378,43 @@ export function mergeClaudeHooksConfig(cwd: string): InitAction {
   return ClaudeHooksDocument.open(filePath, label, GRAFT_HOOKS_CONFIG).ensureGraftHooks();
 }
 
-export function mergeContinueMcpConfig(cwd: string): InitAction {
+export function mergeContinueMcpConfig(
+  cwd: string,
+  server = GRAFT_MCP_SERVER,
+  updateExisting = false,
+): InitAction {
   const label = ".continue/config.json";
   const filePath = path.join(cwd, ".continue", "config.json");
   if (!fs.existsSync(filePath)) {
-    const created = ContinueMcpConfigDocument.create(filePath, label, GRAFT_MCP_SERVER);
+    const created = ContinueMcpConfigDocument.create(filePath, label, server, updateExisting);
     created.write();
     return InitAction.create(label, "wrote graft mcp server");
   }
   return ContinueMcpConfigDocument
-    .open(filePath, label, GRAFT_MCP_SERVER)
+    .open(filePath, label, server, updateExisting)
     .ensureGraftServer();
 }
 
-export function mergeCodexMcpConfig(cwd: string): InitAction {
+export function mergeCodexMcpConfig(
+  cwd: string,
+  server = GRAFT_MCP_SERVER,
+  updateExisting = false,
+): InitAction {
   const label = ".codex/config.toml";
   const filePath = path.join(cwd, ".codex", "config.toml");
   const marker = "[mcp_servers.graft]";
   if (!fs.existsSync(filePath)) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, GRAFT_MCP_SERVER.toCodexTomlBlock());
+    fs.writeFileSync(filePath, server.toCodexTomlBlock());
     return InitAction.create(label, "wrote graft mcp server");
   }
 
   const existing = fs.readFileSync(filePath, "utf-8");
   if (existing.includes(marker)) {
-    const ensured = ensureCodexStartupTimeout(existing);
+    const ensured = ensureCodexMcpServerBlock(existing, server, updateExisting);
     if (ensured.changed) {
       fs.writeFileSync(filePath, ensured.content);
-      return InitAction.append(label, "added graft startup timeout");
+      return InitAction.append(label, ensured.detail ?? "added graft startup timeout");
     }
     return InitAction.exists(label, "already has graft mcp server");
   }
@@ -293,7 +422,7 @@ export function mergeCodexMcpConfig(cwd: string): InitAction {
   const separator = existing.endsWith("\n") ? "\n" : "\n\n";
   fs.writeFileSync(
     filePath,
-    `${existing}${separator}${GRAFT_MCP_SERVER.toCodexTomlBlock()}`,
+    `${existing}${separator}${server.toCodexTomlBlock()}`,
   );
   return InitAction.append(label, "appended graft mcp server");
 }

package/src/cli/init-model.ts

@@ -7,6 +7,7 @@ export interface JsonObjectValue {
 }
 
 type InitActionKind = "exists" | "create" | "append";
+export type GraftMcpRuntime = "repo-local" | "daemon";
 
 export class InitAction {
   constructor(
@@ -54,9 +55,33 @@ function consumeFlag(args: string[], flag: string): boolean {
   return true;
 }
 
+function consumeOption(args: string[], flag: string): string | undefined {
+  const index = args.indexOf(flag);
+  if (index === -1) {
+    return undefined;
+  }
+  if (index === args.length - 1) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  const [value] = args.splice(index, 2).slice(1);
+  return value;
+}
+
+function parseMcpRuntime(raw: string | undefined): { runtime: GraftMcpRuntime; explicit: boolean } {
+  if (raw === undefined) {
+    return { runtime: "repo-local", explicit: false };
+  }
+  if (raw === "repo-local" || raw === "daemon") {
+    return { runtime: raw, explicit: true };
+  }
+  throw new Error(`--mcp-runtime must be repo-local or daemon, got ${raw}`);
+}
+
 export class ParsedInitArgs {
   constructor(
     readonly json: boolean,
+    readonly mcpRuntime: GraftMcpRuntime,
+    readonly mcpRuntimeExplicit: boolean,
     readonly writeClaudeMcp: boolean,
     readonly writeClaudeHooks: boolean,
     readonly writeTargetGitHooks: boolean,
@@ -69,8 +94,11 @@ export class ParsedInitArgs {
 
   static parse(rawArgs: readonly string[]): ParsedInitArgs {
     const args = [...rawArgs];
+    const runtime = parseMcpRuntime(consumeOption(args, "--mcp-runtime"));
     const parsed = new ParsedInitArgs(
       consumeFlag(args, "--json"),
+      runtime.runtime,
+      runtime.explicit,
       consumeFlag(args, "--write-claude-mcp"),
       consumeFlag(args, "--write-claude-hooks"),
       consumeFlag(args, "--write-target-git-hooks"),
@@ -101,9 +129,16 @@ export class ParsedInitArgs {
 export class GraftMcpServer {
   readonly name = "graft";
   readonly command = "npx";
-  readonly args = ["-y", "@flyingrobots/graft", "serve"] as const;
   readonly codexStartupTimeoutSec = 120;
 
+  constructor(readonly runtime: GraftMcpRuntime = "repo-local") {}
+
+  get args(): readonly string[] {
+    return this.runtime === "daemon"
+      ? ["-y", "@flyingrobots/graft", "serve", "--runtime", "daemon"]
+      : ["-y", "@flyingrobots/graft", "serve"];
+  }
+
   toJsonServerEntry(): JsonObjectValue {
     return {
       command: this.command,
@@ -137,11 +172,15 @@ export class GraftMcpServer {
     return [
       "[mcp_servers.graft]",
       "command = \"npx\"",
-      "args = [\"-y\", \"@flyingrobots/graft\", \"serve\"]",
+      this.toCodexTomlArgsLine(),
       `startup_timeout_sec = ${String(this.codexStartupTimeoutSec)}`,
       "",
     ].join("\n");
   }
+
+  toCodexTomlArgsLine(): string {
+    return `args = [${this.args.map((arg) => `"${arg}"`).join(", ")}]`;
+  }
 }
 
 export class GraftHookCommand {
@@ -227,3 +266,19 @@ export function isJsonObjectValue(value: unknown): value is JsonObjectValue {
 export function cloneJsonValue<T>(value: T): T {
   return JSON.parse(JSON.stringify(value)) as T;
 }
+
+export function isGraftMcpServerEntryForRuntime(
+  value: JsonValue | undefined,
+  runtime: GraftMcpRuntime,
+): boolean {
+  if (!isJsonObjectValue(value)) {
+    return false;
+  }
+  const command = value["command"];
+  const args = value["args"];
+  const expected = new GraftMcpServer(runtime);
+  return command === expected.command
+    && Array.isArray(args)
+    && args.length === expected.args.length
+    && args.every((arg, index) => arg === expected.args[index]);
+}

package/src/cli/init-render.ts

@@ -1,6 +1,6 @@
 import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
 import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
-import { GRAFT_HOOKS_CONFIG, GRAFT_MCP_SERVER, InitFailure, InitResult, ParsedInitArgs, type JsonObjectValue } from "./init-model.js";
+import { GRAFT_HOOKS_CONFIG, InitFailure, InitResult, ParsedInitArgs, type JsonObjectValue } from "./init-model.js";
 
 const codec = new CanonicalJsonCodec();
 
@@ -37,7 +37,7 @@ export function renderInitText(result: InitResult, args: ParsedInitArgs, writer:
   if (!args.writesAnyMcpConfig) {
     writeLine(writer, "Done. Add graft to your MCP config:");
     writeLine(writer);
-    writeLine(writer, indentJson(GRAFT_MCP_SERVER.toJsonMcpConfig()));
+    writeLine(writer, indentJson(result.suggestedMcpServer.toJsonMcpConfig()));
     writeLine(writer);
     writeLine(writer, "Use explicit --write-*-mcp flags or --write-claude-hooks");
     writeLine(writer, "or --write-target-git-hooks for one-step bootstrap into project-local config files.");

package/src/cli/init.ts

@@ -1,7 +1,7 @@
 import * as path from "node:path";
 import { appendIfMissing, ensureTargetGitHooks, mergeClaudeHooksConfig, mergeClaudeMcpConfig, mergeClineMcpConfig, mergeCodexMcpConfig, mergeContinueMcpConfig, mergeCursorMcpConfig, mergeWindsurfMcpConfig, writeIfMissing } from "./init-bootstrap.js";
 import { writeCliError } from "./cli-error.js";
-import { GRAFT_HOOKS_CONFIG, GRAFT_MCP_SERVER, InitFailure, InitResult, ParsedInitArgs } from "./init-model.js";
+import { GRAFT_HOOKS_CONFIG, GraftMcpServer, InitFailure, InitResult, ParsedInitArgs } from "./init-model.js";
 import { emitInitJson, renderInitText } from "./init-render.js";
 
 const GRAFTIGNORE_TEMPLATE = `# Graft ignore patterns — files matching these are refused by safe_read.
@@ -45,6 +45,8 @@ export interface RunInitOptions {
 }
 
 function initProject(cwd: string, args: ParsedInitArgs): InitResult {
+  const mcpServer = new GraftMcpServer(args.mcpRuntime);
+  const updateExistingMcp = args.mcpRuntimeExplicit;
   const actions = [
     writeIfMissing(path.join(cwd, ".graftignore"), GRAFTIGNORE_TEMPLATE, ".graftignore"),
     appendIfMissing(path.join(cwd, ".gitignore"), ".graft/", GITIGNORE_ENTRY, ".gitignore"),
@@ -52,7 +54,7 @@ function initProject(cwd: string, args: ParsedInitArgs): InitResult {
   ];
 
   if (args.writeClaudeMcp) {
-    actions.push(mergeClaudeMcpConfig(cwd));
+    actions.push(mergeClaudeMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
   if (args.writeClaudeHooks) {
     actions.push(mergeClaudeHooksConfig(cwd));
@@ -61,7 +63,7 @@ function initProject(cwd: string, args: ParsedInitArgs): InitResult {
     actions.push(...ensureTargetGitHooks(cwd));
   }
   if (args.writeCodexMcp) {
-    actions.push(mergeCodexMcpConfig(cwd));
+    actions.push(mergeCodexMcpConfig(cwd, mcpServer, updateExistingMcp));
     actions.push(
       appendIfMissing(
         path.join(cwd, "AGENTS.md"),
@@ -72,19 +74,19 @@ function initProject(cwd: string, args: ParsedInitArgs): InitResult {
     );
   }
   if (args.writeCursorMcp) {
-    actions.push(mergeCursorMcpConfig(cwd));
+    actions.push(mergeCursorMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
   if (args.writeWindsurfMcp) {
-    actions.push(mergeWindsurfMcpConfig(cwd));
+    actions.push(mergeWindsurfMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
   if (args.writeContinueMcp) {
-    actions.push(mergeContinueMcpConfig(cwd));
+    actions.push(mergeContinueMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
   if (args.writeClineMcp) {
-    actions.push(mergeClineMcpConfig(cwd));
+    actions.push(mergeClineMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
 
-  return new InitResult(cwd, actions, GRAFT_HOOKS_CONFIG, GRAFT_MCP_SERVER);
+  return new InitResult(cwd, actions, GRAFT_HOOKS_CONFIG, mcpServer);
 }
 
 export function runInit(options: RunInitOptions = {}): void {
@@ -110,7 +112,7 @@ export function runInit(options: RunInitOptions = {}): void {
     }
     writeCliError(stderr, message, {
       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: [

package/src/cli/json-document.ts

@@ -36,9 +36,20 @@ export class JsonArrayNode {
     );
   }
 
+  objectEntries(): { index: number; node: JsonObjectNode }[] {
+    return this.value.map((item, index) => ({
+      index,
+      node: JsonObjectNode.fromUnknown(item, this.label, [...this.pointer, `[${String(index)}]`]),
+    }));
+  }
+
   push(value: JsonValue): void {
     this.value.push(cloneJsonValue(value));
   }
+
+  set(index: number, value: JsonValue): void {
+    this.value[index] = cloneJsonValue(value);
+  }
 }
 
 export class JsonObjectNode {

package/src/cli/main.ts

@@ -7,13 +7,19 @@ import {
   cliCommandMcpTool,
 } from "../contracts/output-schemas.js";
 import { startDaemonServer, type GraftDaemonServer } from "../mcp/daemon-server.js";
+import { startDaemonBackedStdioBridge, type StartDaemonBackedStdioBridgeOptions } from "../mcp/daemon-stdio-bridge.js";
 import { startStdioServer } from "../mcp/stdio-server.js";
 import {
   parseCommand,
   parseDaemonCommand,
   parseGlobalOptions,
+  parseServeCommand,
 } from "./command-parser.js";
 import { describeCliFailure, writeCliError } from "./cli-error.js";
+import { readDaemonStatusSnapshot, type ReadDaemonStatusOptions } from "./daemon-status.js";
+import { buildDaemonStatusModel, type DaemonStatusReadSnapshot } from "./daemon-status-model.js";
+import { renderDaemonStatus } from "./daemon-status-render.js";
+import { runGitGraftEnhance, type GitGraftEnhancePeerInvoker } from "./git-graft-enhance.js";
 import { runIndex } from "./index-cmd.js";
 import { runInit } from "./init.js";
 import { runLocalHistoryDag } from "./local-history-dag.js";
@@ -28,7 +34,10 @@ export interface RunCliOptions {
   stdout?: Writer | undefined;
   stderr?: Writer | undefined;
   startServer?: ((cwd: string) => Promise<void>) | undefined;
+  startDaemonBridge?: ((options: StartDaemonBackedStdioBridgeOptions) => Promise<void>) | undefined;
   startDaemon?: ((options: { socketPath?: string | undefined }) => Promise<GraftDaemonServer>) | undefined;
+  readDaemonStatus?: ((options: ReadDaemonStatusOptions) => Promise<DaemonStatusReadSnapshot>) | undefined;
+  invokeGitGraftEnhancePeer?: GitGraftEnhancePeerInvoker | undefined;
 }
 
 function renderHelp(writer: Writer): void {
@@ -39,8 +48,11 @@ function renderHelp(writer: Writer): void {
   writeLine(writer, "Global options:");
   writeLine(writer, "  --cwd <path>    Run a command against another repo root");
   writeLine(writer, "  help            Show this help");
-  writeLine(writer, "  serve           Start the MCP stdio server");
+  writeLine(writer, "  serve           Start the repo-local MCP stdio server");
+  writeLine(writer, "  serve --runtime daemon");
+  writeLine(writer, "                  Start stdio bridge to the local graft daemon");
   writeLine(writer, "  daemon          Start the local MCP daemon");
+  writeLine(writer, "  daemon status   Show read-only daemon status");
   writeLine(writer);
 
   const grouped = new Map<string, { path: readonly string[]; description: string }[]>();
@@ -96,18 +108,37 @@ export async function runCli(options: RunCliOptions = {}): Promise<void> {
   }
 
   if (argv[0] === "serve") {
-    if (argv.length > 1) {
+    try {
+      const parsedServe = parseServeCommand(cwd, argv.slice(1));
+      if (parsedServe.runtime === "daemon") {
+        await (options.startDaemonBridge ?? startDaemonBackedStdioBridge)({
+          ...(parsedServe.socketPath !== undefined ? { socketPath: parsedServe.socketPath } : {}),
+          ...(parsedServe.spawnIfMissing !== undefined ? { spawnIfMissing: parsedServe.spawnIfMissing } : {}),
+        });
+        return;
+      }
+      await (options.startServer ?? startStdioServer)(cwd);
+    } catch (err: unknown) {
       process.exitCode = 1;
-      writeCliError(stderr, `Unexpected arguments: ${argv.slice(1).join(" ")}`, describeCliFailure(argv));
-      return;
+      writeCliError(stderr, err instanceof Error ? err.message : String(err), describeCliFailure(argv));
     }
-    await (options.startServer ?? startStdioServer)(cwd);
     return;
   }
 
   if (argv[0] === "daemon") {
     try {
-      const daemon = await (options.startDaemon ?? startDaemonServer)(parseDaemonCommand(cwd, argv.slice(1)));
+      const parsedDaemon = parseDaemonCommand(cwd, argv.slice(1));
+      if (parsedDaemon.action === "status") {
+        const snapshot = await (options.readDaemonStatus ?? readDaemonStatusSnapshot)({
+          cwd,
+          ...(parsedDaemon.socketPath !== undefined ? { socketPath: parsedDaemon.socketPath } : {}),
+        });
+        writeLine(stdout, renderDaemonStatus(buildDaemonStatusModel({ cwd, snapshot })));
+        return;
+      }
+      const daemon = await (options.startDaemon ?? startDaemonServer)(
+        parsedDaemon.socketPath === undefined ? {} : { socketPath: parsedDaemon.socketPath },
+      );
       writeLine(stdout, `Daemon listening on ${daemon.socketPath}`);
     } catch (err: unknown) {
       process.exitCode = 1;
@@ -137,6 +168,22 @@ export async function runCli(options: RunCliOptions = {}): Promise<void> {
       });
       return;
     }
+    if (parsed.command === "git_graft_enhance") {
+      const since = parsed.args["since"];
+      const head = parsed.args["head"];
+      if (typeof since !== "string") {
+        throw new Error("Missing --since");
+      }
+      await runGitGraftEnhance({
+        cwd,
+        since,
+        ...(typeof head === "string" ? { head } : {}),
+        json: parsed.json,
+        stdout,
+        invokePeer: options.invokeGitGraftEnhancePeer,
+      });
+      return;
+    }
     const tool = cliCommandMcpTool(parsed.command);
     if (tool === null) {
       throw new Error(`Command ${cliCommandKey(cliCommandPath(parsed.command))} has no MCP peer`);