@flyingrobots/graft 0.6.0 → 0.7.0

package/src/git/diff.ts

@@ -48,6 +48,67 @@ async function objectExists(ref: string, filePath: string, cwd: string, gitClien
  * Throws GitError for invalid refs or non-git directories.
  * Returns empty array only when there are genuinely no changes.
  */
+
+export type ChangedFileStatus = "added" | "modified" | "deleted" | "renamed";
+
+export interface ChangedFile {
+  readonly path: string;
+  readonly status: ChangedFileStatus;
+  readonly oldPath?: string;
+}
+
+const STATUS_MAP: Record<string, ChangedFileStatus> = {
+  A: "added",
+  M: "modified",
+  D: "deleted",
+  R: "renamed",
+};
+
+function parseNameStatus(output: string): ChangedFile[] {
+  if (output === "") return [];
+  const lines = output.split("\n");
+  const result: ChangedFile[] = [];
+  for (const line of lines) {
+    const statusCode = line[0];
+    if (statusCode === undefined) continue;
+    const baseStatus = statusCode === "R" || statusCode === "C" ? statusCode : statusCode;
+    const status = STATUS_MAP[baseStatus] ?? "modified";
+    const parts = line.split("\t");
+    if (statusCode === "R" || statusCode === "C") {
+      const oldPath = parts[1];
+      const newPath = parts[2];
+      if (oldPath !== undefined && newPath !== undefined) {
+        result.push({ path: newPath, status, oldPath });
+      }
+    } else {
+      const filePath = parts[1];
+      if (filePath !== undefined) {
+        result.push({ path: filePath, status });
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * List files changed between two refs with rename detection.
+ * Returns structured data including status and old path for renames.
+ */
+export async function getChangedFilesWithStatus(opts: ChangedFilesOptions): Promise<ChangedFile[]> {
+  const base = opts.base ?? "HEAD";
+  const args = opts.head !== undefined
+    ? ["diff-tree", "--no-commit-id", "--name-status", "-M", "-r", base, opts.head]
+    : ["diff-index", "--name-status", "-M", base, "--"];
+
+  try {
+    const output = (await git(opts.git, args, opts.cwd)).trim();
+    return parseNameStatus(output);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitError(`git diff failed: ${msg}`);
+  }
+}
+
 export async function getChangedFiles(opts: ChangedFilesOptions): Promise<string[]> {
   const base = opts.base ?? "HEAD";
   const args = opts.head !== undefined

package/src/mcp/burden.ts

@@ -15,6 +15,7 @@ const ZERO_BUCKET: BurdenBucket = Object.freeze({ calls: 0, bytesReturned: 0 });
 
 const TOOL_BURDEN_KIND: Record<McpToolName, BurdenKind> = {
   safe_read: "read",
+  graft_edit: "state",
   file_outline: "read",
   read_range: "read",
   changed_since: "read",
@@ -31,6 +32,7 @@ const TOOL_BURDEN_KIND: Record<McpToolName, BurdenKind> = {
   monitor_start: "diagnostic",
   monitor_pause: "diagnostic",
   monitor_resume: "diagnostic",
+  monitor_nudge: "diagnostic",
   monitor_stop: "diagnostic",
   workspace_authorize: "diagnostic",
   workspace_authorizations: "diagnostic",
@@ -48,6 +50,13 @@ const TOOL_BURDEN_KIND: Record<McpToolName, BurdenKind> = {
   explain: "diagnostic",
   doctor: "diagnostic",
   stats: "diagnostic",
+  graft_churn: "search",
+  graft_exports: "search",
+  graft_log: "search",
+  graft_blame: "search",
+  graft_difficulty: "search",
+  graft_review: "search",
+  knowledge_map: "diagnostic",
 };
 
 export function emptyBurdenByKind(): BurdenByKind {

package/src/mcp/context.ts

@@ -2,8 +2,7 @@
 // ToolContext — shared dependencies injected into every tool handler
 // ---------------------------------------------------------------------------
 
-import * as fs from "node:fs";
-import * as path from "node:path";
+import { createRepoPathResolver } from "../adapters/repo-paths.js";
 import type { ObservationCache } from "./cache.js";
 import type { Metrics } from "./metrics.js";
 import type { GovernorTracker } from "../session/tracker.js";
@@ -12,7 +11,7 @@ import type { FileSystem } from "../ports/filesystem.js";
 import type { JsonCodec } from "../ports/codec.js";
 import type { ProcessRunner } from "../ports/process-runner.js";
 import type { GitClient } from "../ports/git.js";
-import type { WarpHandle } from "../ports/warp.js";
+import type { WarpContext } from "../warp/context.js";
 import type { RepoObservation } from "./repo-state.js";
 import type { RunCaptureConfig } from "./run-capture-config.js";
 import type { RuntimeObservabilityState, ToolCallFootprintRegion } from "./runtime-observability.js";
@@ -81,7 +80,7 @@ export interface ToolContext {
     readonly regions?: readonly ToolCallFootprintRegion[];
   }): void;
   resolvePath(relative: string): string;
-  getWarp(): Promise<WarpHandle>;
+  getWarp(): Promise<WarpContext>;
   getRepoState(): RepoObservation;
   getCausalContext(): RuntimeCausalContext;
   getWorkspaceOverlayFooting(): Promise<RuntimeWorkspaceOverlayFooting | null>;
@@ -100,6 +99,7 @@ export interface ToolContext {
   pauseMonitor(request: WorkspaceBindRequest): Promise<MonitorActionResult>;
   resumeMonitor(request: WorkspaceBindRequest): Promise<MonitorActionResult>;
   stopMonitor(request: WorkspaceBindRequest): Promise<MonitorActionResult>;
+  nudgeMonitor(request: WorkspaceBindRequest): Promise<MonitorActionResult>;
   listWorkspaceAuthorizations(): Promise<readonly AuthorizedWorkspaceView[]>;
   authorizeWorkspace(request: WorkspaceAuthorizeRequest): Promise<WorkspaceAuthorizeResult>;
   revokeWorkspace(request: WorkspaceBindRequest): Promise<WorkspaceRevokeResult>;
@@ -111,44 +111,7 @@ export interface ToolContext {
  * Symlinks are resolved before the confinement check to prevent escapes.
  */
 export function createPathResolver(projectRoot: string): (input: string) => string {
-  const normalizedRoot = path.resolve(projectRoot);
-
-  // Resolve the project root itself through symlinks for consistent comparison
-  let realProjectRoot: string;
-  try {
-    realProjectRoot = fs.realpathSync(normalizedRoot);
-  } catch {
-    realProjectRoot = normalizedRoot;
-  }
-
-  return (input: string): string => {
-    // Resolve: absolute paths are taken as-is, relative paths join to projectRoot
-    const resolved = path.isAbsolute(input)
-      ? path.resolve(input)
-      : path.resolve(normalizedRoot, input);
-
-    // Logical confinement check (catches ".." traversal without needing fs access)
-    const logicalRel = path.relative(normalizedRoot, resolved);
-    if (logicalRel.startsWith("..") || path.isAbsolute(logicalRel)) {
-      throw new Error(`Path traversal blocked: ${input}`);
-    }
-
-    // Resolve symlinks before a second confinement check to prevent symlink escapes
-    let real: string;
-    try {
-      real = fs.realpathSync(resolved);
-    } catch {
-      // Target doesn't exist yet — return the logical path (already passed confinement)
-      return resolved;
-    }
-
-    // Symlink confinement check: the real path must be within the real project root
-    const realRel = path.relative(realProjectRoot, real);
-    if (realRel.startsWith("..") || path.isAbsolute(realRel)) {
-      throw new Error(`Path traversal blocked: ${input}`);
-    }
-    return resolved;
-  };
+  return createRepoPathResolver(projectRoot);
 }
 
 /**

package/src/mcp/daemon-server.ts

@@ -34,6 +34,8 @@ export interface StartDaemonServerOptions {
   readonly env?: Readonly<Record<string, string | undefined>> | undefined;
   readonly runCapture?: Partial<RunCaptureConfig> | undefined;
   readonly runtimeObservability?: Partial<RuntimeObservabilityState> | undefined;
+  readonly workerPoolSize?: number | undefined;
+  readonly persistedLocalHistoryGraph?: boolean | undefined;
 }
 
 export interface GraftDaemonServer {
@@ -55,7 +57,9 @@ export async function startDaemonServer(options: StartDaemonServerOptions = {}):
     graftDir,
   });
   const daemonScheduler = new DaemonJobScheduler();
-  const daemonWorkerPool = new ChildProcessDaemonWorkerPool();
+  const daemonWorkerPool = new ChildProcessDaemonWorkerPool({
+    ...(options.workerPoolSize !== undefined ? { size: options.workerPoolSize } : {}),
+  });
   const monitorRuntime = new PersistentMonitorRuntime({
     fs: nodeFs,
     codec: new CanonicalJsonCodec(),
@@ -103,6 +107,9 @@ export async function startDaemonServer(options: StartDaemonServerOptions = {}):
     ...(options.runtimeObservability !== undefined
       ? { runtimeObservability: options.runtimeObservability }
       : {}),
+    ...(options.persistedLocalHistoryGraph !== undefined
+      ? { persistedLocalHistoryGraph: options.persistedLocalHistoryGraph }
+      : {}),
   });
 
   const httpServer = http.createServer((req, res) => {

package/src/mcp/daemon-session-host.ts

@@ -40,6 +40,7 @@ export interface CreateDaemonSessionHostOptions {
   readonly env?: Readonly<Record<string, string | undefined>> | undefined;
   readonly runCapture?: Partial<RunCaptureConfig> | undefined;
   readonly runtimeObservability?: Partial<RuntimeObservabilityState> | undefined;
+  readonly persistedLocalHistoryGraph?: boolean | undefined;
 }
 
 export interface DaemonSessionHost {
@@ -125,6 +126,9 @@ async function createDaemonSession(
     ...(options.runtimeObservability !== undefined
       ? { runtimeObservability: options.runtimeObservability }
       : {}),
+    ...(options.persistedLocalHistoryGraph !== undefined
+      ? { persistedLocalHistoryGraph: options.persistedLocalHistoryGraph }
+      : {}),
   });
   const session: DaemonSession = {
     id: newSessionId,

package/src/mcp/daemon-stdio-bridge.ts

@@ -176,6 +176,7 @@ function internalErrorResponse(
 
 export interface StartDaemonBackedStdioBridgeOptions {
   socketPath?: string;
+  spawnIfMissing?: boolean;
   ensureReady?: ((options?: EnsureDaemonReadyOptions) => Promise<string>) | undefined;
 }
 
@@ -184,6 +185,7 @@ export async function startDaemonBackedStdioBridge(
 ): Promise<void> {
   const socketPath = await (options.ensureReady ?? ensureDaemonReady)({
     ...(options.socketPath !== undefined ? { socketPath: options.socketPath } : {}),
+    ...(options.spawnIfMissing !== undefined ? { spawnIfMissing: options.spawnIfMissing } : {}),
   });
   const stdioTransport = new StdioServerTransport();
   const daemonTransport = new StreamableHTTPClientTransport(

package/src/mcp/monitor-tick-job.ts

@@ -1,5 +1,6 @@
-import { indexCommits } from "../warp/indexer.js";
+import { DEFAULT_INDEX_MAX_FILES_PER_CALL, indexHead } from "../warp/index-head.js";
 import { nodeGit } from "../adapters/node-git.js";
+import { nodePathOps } from "../adapters/node-paths.js";
 import { openWarp } from "../warp/open.js";
 
 export interface MonitorTickWorkerJob {
@@ -7,6 +8,7 @@ export interface MonitorTickWorkerJob {
   readonly worktreeRoot: string;
   readonly writerId: string;
   readonly lastIndexedCommit: string | null;
+  readonly maxFilesPerBatch?: number | undefined;
 }
 
 export type MonitorTickWorkerResult =
@@ -26,8 +28,8 @@ export type MonitorTickWorkerResult =
     readonly backlogCommits: number;
   };
 
-async function readGit(cwd: string, args: readonly string[]): Promise<string | null> {
-  const result = await nodeGit.run({ cwd, args });
+async function readHeadCommit(cwd: string): Promise<string | null> {
+  const result = await nodeGit.run({ cwd, args: ["rev-parse", "--verify", "HEAD"] });
   if (result.error !== undefined || result.status !== 0) {
     return null;
   }
@@ -35,68 +37,117 @@ async function readGit(cwd: string, args: readonly string[]): Promise<string | n
   return trimmed.length === 0 ? null : trimmed;
 }
 
-async function readHeadCommit(cwd: string): Promise<string | null> {
-  return readGit(cwd, ["rev-parse", "--verify", "HEAD"]);
+function parseGitPathList(output: string): readonly string[] {
+  const seen = new Set<string>();
+  const paths: string[] = [];
+  for (const line of output.split("\n")) {
+    const filePath = line.trim();
+    if (filePath.length === 0 || seen.has(filePath)) continue;
+    seen.add(filePath);
+    paths.push(filePath);
+  }
+  return paths;
 }
 
-async function countPendingCommits(
-  cwd: string,
-  from: string | null,
-  to: string | null,
-): Promise<number> {
-  if (to === null) return 0;
-  const range = from === null ? to : `${from}..${to}`;
-  const output = await readGit(cwd, ["rev-list", "--count", range]);
-  if (output === null) return 0;
-  const parsed = Number.parseInt(output, 10);
-  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+async function listTrackedPaths(cwd: string): Promise<readonly string[]> {
+  const result = await nodeGit.run({ cwd, args: ["ls-files"] });
+  if (result.error !== undefined || result.status !== 0) {
+    throw result.error ?? new Error(result.stderr.trim() || `git ls-files exited with status ${String(result.status)}`);
+  }
+  return parseGitPathList(result.stdout);
+}
+
+async function listChangedPaths(cwd: string, base: string, head: string): Promise<readonly string[] | null> {
+  const result = await nodeGit.run({ cwd, args: ["diff", "--name-only", `${base}..${head}`] });
+  if (result.error !== undefined || result.status !== 0) {
+    return null;
+  }
+  return parseGitPathList(result.stdout);
+}
+
+async function monitorIndexPaths(input: {
+  readonly cwd: string;
+  readonly currentHead: string | null;
+  readonly lastIndexedCommit: string | null;
+}): Promise<readonly string[]> {
+  if (input.currentHead === null) return [];
+  if (input.lastIndexedCommit !== null) {
+    const changedPaths = await listChangedPaths(input.cwd, input.lastIndexedCommit, input.currentHead);
+    if (changedPaths !== null) return changedPaths;
+  }
+  return listTrackedPaths(input.cwd);
+}
+
+function pathBatches(paths: readonly string[], size: number): readonly (readonly string[])[] {
+  const batches: (readonly string[])[] = [];
+  for (let index = 0; index < paths.length; index += size) {
+    batches.push(paths.slice(index, index + size));
+  }
+  return batches;
 }
 
 export async function runMonitorTickJob(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult> {
   const headAtStart = await readHeadCommit(job.worktreeRoot);
 
+  // ── Tick ceiling: skip indexing when HEAD hasn't moved ───────────
+  // When HEAD equals the last indexed commit (including both null for
+  // empty repos), there is nothing to index. Short-circuit before
+  // opening WARP or calling indexCommits to keep idle ticks near-zero-cost.
+  if (headAtStart === job.lastIndexedCommit) {
+    return {
+      ok: true,
+      headAtStart,
+      currentHead: headAtStart,
+      lastIndexedCommit: job.lastIndexedCommit,
+      backlogCommits: 0,
+      commitsIndexed: 0,
+      patchesWritten: 0,
+    };
+  }
+
   try {
-    const warp = await openWarp({
+    const app = await openWarp({
       cwd: job.worktreeRoot,
       writerId: job.writerId,
     });
-    const result = await indexCommits(warp, {
+    const ctx = { app, strandId: null };
+    const paths = await monitorIndexPaths({
       cwd: job.worktreeRoot,
-      git: nodeGit,
-      ...(job.lastIndexedCommit !== null ? { from: job.lastIndexedCommit } : {}),
-      ...(headAtStart !== null ? { to: headAtStart } : {}),
+      currentHead: headAtStart,
+      lastIndexedCommit: job.lastIndexedCommit,
     });
-    if (!result.ok) {
-      throw new Error(result.error);
+    let commitsIndexed = 0;
+    let patchesWritten = 0;
+    const maxFilesPerBatch = job.maxFilesPerBatch ?? DEFAULT_INDEX_MAX_FILES_PER_CALL;
+    for (const batch of pathBatches(paths, maxFilesPerBatch)) {
+      const result = await indexHead({
+        cwd: job.worktreeRoot,
+        git: nodeGit,
+        pathOps: nodePathOps,
+        ctx,
+        paths: batch,
+        maxFilesPerCall: maxFilesPerBatch,
+      });
+      commitsIndexed += result.filesIndexed;
+      patchesWritten += result.nodesEmitted;
     }
     const currentHead = await readHeadCommit(job.worktreeRoot);
-    const lastIndexedCommit = headAtStart ?? job.lastIndexedCommit;
-    const backlogCommits = await countPendingCommits(
-      job.worktreeRoot,
-      lastIndexedCommit,
-      currentHead,
-    );
     return {
       ok: true,
       headAtStart,
       currentHead,
-      lastIndexedCommit,
-      backlogCommits,
-      commitsIndexed: result.commitsIndexed,
-      patchesWritten: result.patchesWritten,
+      lastIndexedCommit: headAtStart,
+      backlogCommits: 0,
+      commitsIndexed,
+      patchesWritten,
     };
   } catch (error) {
     const currentHead = await readHeadCommit(job.worktreeRoot);
-    const backlogCommits = await countPendingCommits(
-      job.worktreeRoot,
-      job.lastIndexedCommit,
-      currentHead,
-    );
     return {
       ok: false,
       error: error instanceof Error ? error.message : String(error),
       currentHead,
-      backlogCommits,
+      backlogCommits: 0,
     };
   }
 }

package/src/mcp/monitor-types.ts

@@ -18,7 +18,7 @@ export const DEFAULT_POLL_INTERVAL_MS = 5_000;
 export type MonitorLifecycleState = "running" | "paused" | "stopped";
 export type MonitorHealth = "ok" | "lagging" | "error" | "unauthorized" | "paused" | "stopped";
 export type MonitorWorkerKind = "git_poll_indexer";
-export type MonitorAction = "start" | "pause" | "resume" | "stop";
+export type MonitorAction = "start" | "pause" | "resume" | "stop" | "nudge";
 
 // ── Persistence schemas ────────────────────────────────────────────
 

package/src/mcp/persisted-local-history-graph.ts

@@ -6,10 +6,11 @@ import type {
   CausalRegion,
   Evidence,
 } from "../contracts/causal-ontology.js";
-import type { WarpHandle } from "../ports/warp.js";
+import type { WarpContext } from "../warp/context.js";
+import { patchGraph } from "../warp/context.js";
 import type { RuntimeStagedTargetFullFile } from "./runtime-staged-target.js";
 
-export type PersistedLocalHistoryGraphWarp = Pick<WarpHandle, "hasNode" | "observer" | "patch">;
+export type PersistedLocalHistoryGraphWarp = WarpContext;
 
 export interface PersistedLocalHistoryGraphContext {
   readonly warp: PersistedLocalHistoryGraphWarp;
@@ -161,10 +162,10 @@ async function commitAccumulator(
   const ids = [...accumulator.nodes.keys()];
   const existence = new Map<string, boolean>();
   for (const id of ids) {
-    existence.set(id, await graph.warp.hasNode(id));
+    existence.set(id, await graph.warp.app.core().hasNode(id));
   }
 
-  await graph.warp.patch((patch) => {
+  await patchGraph(graph.warp, (patch) => {
     for (const [id, props] of accumulator.nodes.entries()) {
       const exists = existence.get(id) ?? false;
       if (!exists) {

package/src/mcp/persisted-local-history.ts

@@ -462,7 +462,7 @@ async function loadObservedLocalHistoryGraph(
     return null;
   }
 
-  const observer = await graph.warp.observer({
+  const observer = await graph.warp.app.observer({
     match: [...LOCAL_HISTORY_GRAPH_MATCH],
     expose: [...LOCAL_HISTORY_GRAPH_EXPOSE],
   });
@@ -980,7 +980,7 @@ async function hasLocalHistoryEventNode(
   graph: PersistedLocalHistoryGraphContext,
   eventId: string,
 ): Promise<boolean> {
-  return graph.warp.hasNode(`lh:event:${eventId}`);
+  return graph.warp.app.core().hasNode(`lh:event:${eventId}`);
 }
 
 export async function migrateLegacyPersistedLocalHistoryToGraph(input: {

package/src/mcp/persistent-monitor-runtime.ts

@@ -200,6 +200,43 @@ export class PersistentMonitorRuntime {
     return this.transitionMonitor("stop", request, "stopped");
   }
 
+  async nudgeMonitor(request: WorkspaceBindRequest): Promise<MonitorActionResult> {
+    await this.ensureLoaded();
+    const resolved = await this.resolveAuthorizedRepo(request);
+    if ("errorCode" in resolved) {
+      return {
+        ok: false,
+        action: "nudge",
+        created: false,
+        changed: false,
+        errorCode: resolved.errorCode,
+        error: resolved.error,
+      };
+    }
+    const { repoId } = resolved;
+    const record = this.records.get(repoId);
+    if (record?.lifecycleState !== "running") {
+      return {
+        ok: false,
+        action: "nudge",
+        created: false,
+        changed: false,
+        errorCode: "not_running",
+        error: "Monitor is not running — start it first.",
+      };
+    }
+    // Fire an immediate tick without changing lifecycle state
+    await this.runTick(repoId).catch(() => undefined);
+    return {
+      ok: true,
+      action: "nudge" as MonitorAction,
+      created: false,
+      changed: false,
+      status: await this.getStatusByRepoId(repoId),
+    };
+  }
+
+
   // ── Private: lifecycle transitions ─────────────────────────────
 
   private async transitionMonitor(

package/src/mcp/repo-tool-worker-context.ts

@@ -118,8 +118,8 @@ export function buildRepoToolWorkerContext(
       // captures footprint via AsyncLocalStorage in the invocation engine.
     },
     resolvePath: createRepoPathResolver(job.projectRoot),
-    getWarp() {
-      return openWarp({ cwd: job.projectRoot, writerId: job.writerId });
+    async getWarp() {
+      return { app: await openWarp({ cwd: job.projectRoot, writerId: job.writerId }), strandId: null };
     },
     getRepoState() {
       return job.repoState;
@@ -179,6 +179,9 @@ export function buildRepoToolWorkerContext(
     resumeMonitor() {
       return unsupported("resumeMonitor");
     },
+    nudgeMonitor() {
+      return unsupported("nudgeMonitor");
+    },
     stopMonitor() {
       return unsupported("stopMonitor");
     },

package/src/mcp/server-context.ts

@@ -3,7 +3,7 @@ import type { CanonicalJsonCodec } from "../adapters/canonical-json.js";
 import type { FileSystem } from "../ports/filesystem.js";
 import type { ProcessRunner } from "../ports/process-runner.js";
 import type { GitClient } from "../ports/git.js";
-import type { WarpHandle } from "../ports/warp.js";
+import type { WarpContext } from "../warp/context.js";
 import type { ToolContext, ToolDefinition } from "./context.js";
 import type { McpToolResult } from "./receipt.js";
 import type { RunCaptureConfig } from "./run-capture-config.js";
@@ -92,7 +92,7 @@ export function buildToolContext(deps: ToolContextDeps): ToolContext {
     git: deps.git,
     runCapture: deps.runCapture,
     observability: deps.observability,
-    getWarp(): Promise<WarpHandle> {
+    getWarp(): Promise<WarpContext> {
       return getActiveExecutionContext()?.getWarp() ?? workspaceRouter.getWarp();
     },
     getRepoState() {
@@ -195,6 +195,19 @@ export function buildToolContext(deps: ToolContextDeps): ToolContext {
       }
       return monitorRuntime.resumeMonitor(request);
     },
+    nudgeMonitor(request) {
+      if (monitorRuntime === null) {
+        return Promise.resolve({
+          ok: false,
+          action: "nudge",
+          created: false,
+          changed: false,
+          errorCode: "no_daemon",
+          error: "Monitor runtime is not available.",
+        });
+      }
+      return monitorRuntime.nudgeMonitor(request);
+    },
     stopMonitor(request) {
       if (monitorRuntime === null) {
         throw new Error("monitor_stop is only available in daemon mode");

package/src/mcp/server-tool-access.ts

@@ -1,5 +1,6 @@
 import type { McpToolResult } from "./receipt.js";
-import { parseJsonTextObject, type JsonObject } from "../contracts/json-object.js";
+import type { JsonObject } from "../contracts/json-object.js";
+import { parseJsonTextObject } from "../adapters/json-text-decoder.js";
 import { evaluateMcpPolicy } from "./policy.js";
 import { RefusedResult } from "../policy/types.js";
 import { OFFLOADED_DAEMON_REPO_TOOL_NAMES, type OffloadedRepoToolName } from "./repo-tool-job.js";
@@ -18,6 +19,7 @@ const daemonAlwaysAvailableTools = new Set<string>([
   "monitor_start",
   "monitor_pause",
   "monitor_resume",
+  "monitor_nudge",
   "monitor_stop",
   "workspace_authorize",
   "workspace_authorizations",
@@ -37,6 +39,7 @@ export const repoStateOptionalTools = new Set<string>([
   "monitor_start",
   "monitor_pause",
   "monitor_resume",
+  "monitor_nudge",
   "monitor_stop",
   "workspace_authorize",
   "workspace_authorizations",

package/src/mcp/server.ts

@@ -10,6 +10,7 @@ import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
 import { nodeProcessRunner } from "../adapters/node-process-runner.js";
 import type { ProcessRunner } from "../ports/process-runner.js";
 import { nodeGit } from "../adapters/node-git.js";
+import type { GitClient } from "../ports/git.js";
 import { openWarp } from "../warp/open.js";
 import type { RunCaptureConfig } from "./run-capture-config.js";
 import { resolveRunCaptureConfig } from "./run-capture-config.js";
@@ -64,6 +65,8 @@ export interface CreateGraftServerOptions {
   daemonWorkerPool?: DaemonWorkerPool;
   daemonRuntime?: (() => DaemonRuntimeDescriptor) | undefined;
   processRunner?: ProcessRunner;
+  git?: GitClient;
+  persistedLocalHistoryGraph?: boolean;
 }
 
 export function createGraftServer(options: CreateGraftServerOptions = {}): GraftServer {
@@ -88,6 +91,7 @@ export function createGraftServer(options: CreateGraftServerOptions = {}): Graft
     ...(options.env !== undefined ? { env: options.env } : {}),
     ...(options.runtimeObservability !== undefined ? { overrides: options.runtimeObservability } : {}),
   });
+  const gitClient = options.git ?? nodeGit;
   const runtimeLogger = new RuntimeEventLogger({
     fs: nodeFs,
     codec,
@@ -107,7 +111,7 @@ export function createGraftServer(options: CreateGraftServerOptions = {}): Graft
     ? (options.daemonControlPlane ?? new DaemonControlPlane({
       fs: nodeFs,
       codec,
-      git: nodeGit,
+      git: gitClient,
       graftDir,
     }))
     : null;
@@ -116,7 +120,7 @@ export function createGraftServer(options: CreateGraftServerOptions = {}): Graft
     : (options.monitorRuntime ?? new PersistentMonitorRuntime({
       fs: nodeFs,
       codec,
-      git: nodeGit,
+      git: gitClient,
       graftDir,
       controlPlane: daemonControlPlane,
       scheduler: daemonScheduler,
@@ -139,7 +143,7 @@ export function createGraftServer(options: CreateGraftServerOptions = {}): Graft
   const workspaceRouter = new WorkspaceRouter({
     mode,
     fs: nodeFs,
-    git: nodeGit,
+    git: gitClient,
     graftDir,
     ...(projectRoot !== undefined ? { projectRoot } : {}),
     warpPool,
@@ -148,6 +152,7 @@ export function createGraftServer(options: CreateGraftServerOptions = {}): Graft
     ...(daemonControlPlane !== null ? { authorizationPolicy: daemonControlPlane } : {}),
     ...(daemonControlPlane !== null ? { sharedAttachPolicy: daemonControlPlane } : {}),
     persistedLocalHistory,
+    persistedLocalHistoryGraph: options.persistedLocalHistoryGraph ?? true,
   });
   const daemonRepoOverview = daemonControlPlane !== null && monitorRuntime !== null
     ? new DaemonRepoOverview({