@flyingrobots/graft 0.6.0 → 0.7.0

package/src/cli/index-cmd.ts

@@ -1,7 +1,8 @@
 import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
 import { nodeGit } from "../adapters/node-git.js";
+import { nodePathOps } from "../adapters/node-paths.js";
 import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
-import { indexCommits } from "../warp/indexer.js";
+import { indexHead } from "../warp/index-head.js";
 import { openWarp } from "../warp/open.js";
 import { writeCliError } from "./cli-error.js";
 import {
@@ -39,33 +40,31 @@ export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
   const stderr = options.stderr ?? process.stderr;
 
   try {
-    const { json, from } = parseIndexCommandArgs(args);
-    const warp = await openWarp({ cwd });
-    const result = await indexCommits(warp, {
+    const { json, paths } = parseIndexCommandArgs(args);
+    const app = await openWarp({ cwd });
+    const ctx = { app, strandId: null };
+    const result = await indexHead({
       cwd,
       git: nodeGit,
-      ...(from !== null ? { from } : {}),
+      pathOps: nodePathOps,
+      ctx,
+      ...(paths.length > 0 ? { paths } : {}),
     });
 
-    if (!result.ok) {
-      throw new Error(result.error);
-    }
-
     if (json) {
       emitIndexJson(buildIndexCliSuccess({
         cwd,
-        from,
-        commitsIndexed: result.commitsIndexed,
-        patchesWritten: result.patchesWritten,
+        filesIndexed: result.filesIndexed,
+        nodesEmitted: result.nodesEmitted,
       }), stdout);
       return;
     }
 
     writeLine(stdout);
-    writeLine(stdout, `Indexing structural history in ${cwd}`);
+    writeLine(stdout, `Indexing HEAD in ${cwd}`);
     writeLine(stdout);
-    writeLine(stdout, `  commits indexed: ${String(result.commitsIndexed)}`);
-    writeLine(stdout, `  patches written: ${String(result.patchesWritten)}`);
+    writeLine(stdout, `  files indexed: ${String(result.filesIndexed)}`);
+    writeLine(stdout, `  nodes emitted: ${String(result.nodesEmitted)}`);
     writeLine(stdout);
     writeLine(stdout, "Done.");
     writeLine(stdout);
@@ -76,19 +75,16 @@ export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
       try {
         return parseIndexCommandArgs(args);
       } catch {
-        return {
-          json: args.includes("--json"),
-          from: args.find((arg) => arg !== "--json" && !arg.startsWith("--")) ?? null,
-        };
+        return { json: args.includes("--json") };
       }
     })();
     if (parsed.json) {
-      emitIndexJson(buildIndexCliFailure({ cwd, from: parsed.from, error: message }), stdout);
+      emitIndexJson(buildIndexCliFailure({ cwd, error: message }), stdout);
       return;
     }
     writeCliError(stderr, message, {
-      usage: "graft index [<from-ref>] [--json]",
-      nextSteps: ["Use `--json` if you want a machine-readable indexing report."],
+      usage: "graft index [--path <path>] [--json]",
+      nextSteps: ["Use `--path <path>` for lazy per-file indexing and `--json` for machine-readable output."],
     });
   }
 }

package/src/cli/index-model.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 
 const indexCommandArgsSchema = z.object({
   json: z.boolean(),
-  from: z.string().nullable(),
+  paths: z.array(z.string()),
 });
 
 export type IndexCommandArgs = z.infer<typeof indexCommandArgsSchema>;
@@ -10,15 +10,13 @@ export type IndexCommandArgs = z.infer<typeof indexCommandArgsSchema>;
 const indexSuccessSchema = z.object({
   ok: z.literal(true),
   cwd: z.string(),
-  from: z.string().nullable(),
-  commitsIndexed: z.number().int().nonnegative(),
-  patchesWritten: z.number().int().nonnegative(),
+  filesIndexed: z.number().int().nonnegative(),
+  nodesEmitted: z.number().int().nonnegative(),
 });
 
 const indexFailureSchema = z.object({
   ok: z.literal(false),
   cwd: z.string(),
-  from: z.string().nullable(),
   error: z.string(),
 });
 
@@ -28,49 +26,50 @@ export type IndexCliResult = z.infer<typeof indexCliResultSchema>;
 
 export function parseIndexCommandArgs(args: readonly string[]): IndexCommandArgs {
   let json = false;
-  let from: string | null = null;
+  const paths: string[] = [];
 
-  for (const arg of args) {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === undefined) continue;
     if (arg === "--json") {
       json = true;
       continue;
     }
-    if (arg.startsWith("--")) {
-      throw new Error(`Unknown index arguments: ${arg}`);
-    }
-    if (from !== null) {
-      throw new Error(`Unknown index arguments: ${arg}`);
+    if (arg === "--path") {
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --path");
+      }
+      paths.push(value);
+      index++;
+      continue;
     }
-    from = arg;
+    throw new Error(`Unknown index arguments: ${arg}`);
   }
 
-  return indexCommandArgsSchema.parse({ json, from });
+  return indexCommandArgsSchema.parse({ json, paths });
 }
 
 export function buildIndexCliSuccess(input: {
   readonly cwd: string;
-  readonly from: string | null;
-  readonly commitsIndexed: number;
-  readonly patchesWritten: number;
+  readonly filesIndexed: number;
+  readonly nodesEmitted: number;
 }): IndexCliResult {
   return indexSuccessSchema.parse({
     ok: true,
     cwd: input.cwd,
-    from: input.from,
-    commitsIndexed: input.commitsIndexed,
-    patchesWritten: input.patchesWritten,
+    filesIndexed: input.filesIndexed,
+    nodesEmitted: input.nodesEmitted,
   });
 }
 
 export function buildIndexCliFailure(input: {
   readonly cwd: string;
-  readonly from: string | null;
   readonly error: string;
 }): IndexCliResult {
   return indexFailureSchema.parse({
     ok: false,
     cwd: input.cwd,
-    from: input.from,
     error: input.error,
   });
 }

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.");