@flyingrobots/graft 0.6.1 → 0.7.0

package/src/contracts/output-schemas.ts

@@ -78,6 +78,34 @@ const tripwireSchema = z.object({
   recommendation: z.string(),
 }).strict();
 
+const graftEditReasonSchema = z.enum([
+  "NOT_FOUND",
+  "OLD_STRING_NOT_FOUND",
+  "OLD_STRING_AMBIGUOUS",
+  "BINARY",
+  "LOCKFILE",
+  "MINIFIED",
+  "BUILD_OUTPUT",
+  "SECRET",
+  "GRAFTIGNORE",
+]);
+
+const graftEditDriftWarningSchema = z.object({
+  kind: z.literal("structural_pattern_reintroduced"),
+  severity: z.literal("advisory"),
+  pattern: z.literal("jsdoc_typedef"),
+  basis: z.literal("session_local_graft_edit"),
+  message: z.string(),
+  current: z.object({
+    path: z.string(),
+    direction: z.literal("added"),
+  }).strict(),
+  previous: z.object({
+    path: z.string(),
+    direction: z.literal("removed"),
+  }).strict(),
+}).strict();
+
 const outlineEntrySchema: z.ZodType = z.lazy(() => z.object({
   _brand: z.literal("OutlineEntry").optional(),
   kind: z.string(),
@@ -120,6 +148,7 @@ const diffEntrySchema: z.ZodType = z.lazy(() => z.object({
   _brand: z.literal("DiffEntry").optional(),
   name: z.string(),
   kind: z.string(),
+  exported: z.boolean().optional(),
   signature: z.string().optional(),
   oldSignature: z.string().optional(),
   childDiff: outlineDiffSchema.optional(),
@@ -141,6 +170,45 @@ const burdenByKindSchema = z.object({
   diagnostic: burdenBucketSchema,
 }).strict();
 
+const sludgeSignalSchema = z.object({
+  kind: z.enum([
+    "phantom_shape",
+    "cast_density",
+    "homeless_constructor",
+    "free_function_data_behavior",
+    "god_file",
+  ]),
+  severity: z.enum(["low", "medium", "high"]),
+  message: z.string(),
+  line: z.number().int().positive().optional(),
+  symbol: z.string().optional(),
+  evidence: z.string(),
+}).strict();
+
+const sludgeFileReportSchema = z.object({
+  path: z.string(),
+  score: z.number().int().nonnegative(),
+  metrics: z.object({
+    typedefCount: z.number().int().nonnegative(),
+    typeCastCount: z.number().int().nonnegative(),
+    classCount: z.number().int().nonnegative(),
+    functionCount: z.number().int().nonnegative(),
+    symbolCount: z.number().int().nonnegative(),
+    homelessConstructorCount: z.number().int().nonnegative(),
+    freeFunctionDataBehaviorCount: z.number().int().nonnegative(),
+  }).strict(),
+  signals: z.array(sludgeSignalSchema),
+}).strict();
+
+const sludgeReportSchema = z.object({
+  scannedFiles: z.number().int().nonnegative(),
+  filesWithSignals: z.number().int().nonnegative(),
+  totalSignals: z.number().int().nonnegative(),
+  score: z.number().int().nonnegative(),
+  files: z.array(sludgeFileReportSchema),
+  summary: z.string(),
+}).strict();
+
 const receiptSchema = z.object({
   sessionId: z.string(),
   traceId: z.string(),
@@ -193,6 +261,33 @@ const runtimeLocalProvenanceSchema = z.object({
   provenanceLevel: z.literal("artifact_history"),
 }).strict();
 
+const gitGraftEnhanceBodySchema = z.object({
+  range: z.object({
+    since: z.string(),
+    head: z.string(),
+  }).strict(),
+  structural: z.object({
+    changedFiles: z.number().int().nonnegative(),
+    addedSymbols: z.number().int().nonnegative(),
+    removedSymbols: z.number().int().nonnegative(),
+    changedSymbols: z.number().int().nonnegative(),
+    topFilesByChangeCount: z.array(z.object({
+      path: z.string(),
+      status: z.string(),
+      changeCount: z.number().int().nonnegative(),
+      summary: z.string(),
+    }).strict()),
+  }).strict(),
+  exports: z.object({
+    changed: z.boolean(),
+    semverImpact: z.enum(["major", "minor", "patch", "none"]),
+    addedExports: z.number().int().nonnegative(),
+    removedExports: z.number().int().nonnegative(),
+    changedExports: z.number().int().nonnegative(),
+  }).strict(),
+  warnings: z.array(z.string()),
+}).strict();
+
 const runtimeStagedTargetSchema = z.discriminatedUnion("availability", [
   runtimeLocalProvenanceSchema.extend({
     availability: z.literal("none"),
@@ -540,7 +635,7 @@ const activeCausalWorkspaceSchema = z.object({
   latestReadEvent: readEventSchema.nullable(),
   latestStageEvent: stageEventSchema.nullable(),
   latestTransitionEvent: transitionEventSchema.nullable(),
-  repoConcurrency: repoConcurrencySummarySchema,
+  repoConcurrency: repoConcurrencySummarySchema.nullable(),
   checkoutEpoch: z.number().int().nonnegative(),
   lastTransition: repoTransitionSchema.nullable(),
   semanticTransition: repoSemanticTransitionSchema.nullable(),
@@ -693,7 +788,7 @@ const monitorStatusSchema = z.object({
 
 const monitorActionSchema = z.object({
   ok: z.boolean(),
-  action: z.enum(["start", "pause", "resume", "stop"]),
+  action: z.enum(["start", "pause", "resume", "stop", "nudge"]),
   created: z.boolean(),
   changed: z.boolean(),
   status: monitorStatusSchema.optional(),
@@ -818,6 +913,20 @@ const mcpOutputBodySchemas: Record<McpToolName, z.ZodType> = {
     lastReadAt: z.string().optional(),
     diff: outlineDiffSchema.optional(),
   }).strict(),
+  graft_edit: z.object({
+    path: z.string(),
+    operation: z.literal("replace"),
+    projection: z.enum(["edited", "refused"]),
+    status: z.enum(["edited", "refused"]),
+    changed: z.boolean(),
+    matches: z.number().int().nonnegative(),
+    replacements: z.number().int().nonnegative(),
+    reason: graftEditReasonSchema.optional(),
+    reasonDetail: z.string().optional(),
+    next: z.array(z.string()).optional(),
+    actual: actualSchema.optional(),
+    driftWarnings: z.array(graftEditDriftWarningSchema).optional(),
+  }).strict(),
   file_outline: z.union([
     z.object({
       path: z.string(),
@@ -949,6 +1058,7 @@ const mcpOutputBodySchemas: Record<McpToolName, z.ZodType> = {
   monitor_start: monitorActionSchema,
   monitor_pause: monitorActionSchema,
   monitor_resume: monitorActionSchema,
+  monitor_nudge: monitorActionSchema,
   monitor_stop: monitorActionSchema,
   workspace_authorize: workspaceAuthorizeSchema,
   workspace_authorizations: z.object({
@@ -1018,6 +1128,7 @@ const mcpOutputBodySchemas: Record<McpToolName, z.ZodType> = {
     attribution: attributionSummarySchema,
     persistedLocalHistory: persistedLocalHistorySummarySchema,
     recommendedNextAction: causalSurfaceNextActionSchema,
+    sludge: sludgeReportSchema.optional(),
   }).strict(),
   stats: z.object({
     totalReads: z.number().int().nonnegative(),
@@ -1029,10 +1140,170 @@ const mcpOutputBodySchemas: Record<McpToolName, z.ZodType> = {
     totalNonReadBytesReturned: z.number().int().nonnegative(),
     burdenByKind: burdenByKindSchema,
   }).strict(),
+  graft_churn: z.object({
+    entries: z.array(z.object({
+      symbol: z.string(),
+      filePath: z.string(),
+      kind: z.string(),
+      changeCount: z.number().int().positive(),
+      lastChangedSha: z.string(),
+      lastChangedDate: z.string(),
+    }).strict()),
+    totalSymbols: z.number().int().nonnegative(),
+    totalCommitsAnalyzed: z.number().int().nonnegative(),
+    summary: z.string(),
+  }).strict(),
+  graft_exports: z.object({
+    base: z.string(),
+    head: z.string(),
+    added: z.array(z.object({
+      symbol: z.string(),
+      filePath: z.string(),
+      kind: z.string(),
+      changeType: z.literal("added"),
+      signature: z.string().optional(),
+    }).strict()),
+    removed: z.array(z.object({
+      symbol: z.string(),
+      filePath: z.string(),
+      kind: z.string(),
+      changeType: z.literal("removed"),
+      signature: z.string().optional(),
+    }).strict()),
+    changed: z.array(z.object({
+      symbol: z.string(),
+      filePath: z.string(),
+      kind: z.string(),
+      changeType: z.literal("signature_changed"),
+      signature: z.string().optional(),
+      previousSignature: z.string().optional(),
+    }).strict()),
+    semverImpact: z.enum(["major", "minor", "patch", "none"]),
+    summary: z.string(),
+  }).strict(),
+  graft_log: z.object({
+    entries: z.array(z.object({
+      sha: z.string(),
+      message: z.string(),
+      author: z.string(),
+      date: z.string(),
+      symbols: z.object({
+        added: z.array(z.object({
+          name: z.string(),
+          kind: z.string(),
+          signature: z.string().optional(),
+          exported: z.boolean(),
+          filePath: z.string(),
+        }).strict()),
+        removed: z.array(z.object({
+          name: z.string(),
+          kind: z.string(),
+          signature: z.string().optional(),
+          exported: z.boolean(),
+          filePath: z.string(),
+        }).strict()),
+        changed: z.array(z.object({
+          name: z.string(),
+          kind: z.string(),
+          signature: z.string().optional(),
+          exported: z.boolean(),
+          filePath: z.string(),
+        }).strict()),
+      }).strict(),
+      summary: z.string(),
+    }).strict()),
+    count: z.number().int().nonnegative(),
+    layer: z.literal("commit_worldline"),
+  }).strict(),
+  graft_blame: z.object({
+    symbol: z.string(),
+    filePath: z.string(),
+    changeCount: z.number().int().nonnegative(),
+    createdInCommit: z.string().nullable(),
+    lastSignatureChange: z.string().nullable(),
+    referenceCount: z.number().int().nonnegative(),
+    history: z.array(z.object({
+      sha: z.string(),
+      tick: z.number(),
+      changeKind: z.string(),
+      present: z.boolean(),
+      signature: z.string().nullable(),
+    }).strict()),
+  }).strict(),
+  graft_difficulty: z.object({
+    symbol: z.string(),
+    path: z.string().optional(),
+    entries: z.array(z.object({
+      symbol: z.string(),
+      filePath: z.string(),
+      kind: z.string(),
+      score: z.number().nonnegative(),
+      risk: z.enum(["low", "medium", "high"]),
+      recommendation: z.enum(["refactor_freely", "refactor_with_tests", "plan_before_refactor"]),
+      curvature: z.object({
+        changeCount: z.number().int().nonnegative(),
+        signatureChangeCount: z.number().int().nonnegative(),
+        score: z.number().nonnegative(),
+      }).strict(),
+      friction: z.object({
+        referenceCount: z.number().int().nonnegative(),
+        referencingFiles: z.array(z.string()),
+        score: z.number().nonnegative(),
+      }).strict(),
+    }).strict()),
+    total: z.number().int().nonnegative(),
+    summary: z.string(),
+  }).strict(),
+  graft_review: z.object({
+    base: z.string(),
+    head: z.string(),
+    totalFiles: z.number().int().nonnegative(),
+    categories: z.object({
+      structural: z.number().int().nonnegative(),
+      formatting: z.number().int().nonnegative(),
+      test: z.number().int().nonnegative(),
+      docs: z.number().int().nonnegative(),
+      config: z.number().int().nonnegative(),
+    }).strict(),
+    files: z.array(z.object({
+      path: z.string(),
+      category: z.enum(["structural", "formatting", "test", "docs", "config"]),
+      structuralChanges: z.object({
+        added: z.number().int().nonnegative(),
+        removed: z.number().int().nonnegative(),
+        changed: z.number().int().nonnegative(),
+      }).strict().optional(),
+    }).strict()),
+    breakingChanges: z.array(z.object({
+      symbol: z.string(),
+      kind: z.string(),
+      filePath: z.string(),
+      changeType: z.enum(["removed_export", "signature_changed", "type_changed"]),
+      previousSignature: z.string().optional(),
+      newSignature: z.string().optional(),
+      impactedFiles: z.number().int().nonnegative(),
+      impactedFilePaths: z.array(z.string()),
+    }).strict()),
+    summary: z.string(),
+  }).strict(),
+  knowledge_map: z.object({
+    totalFiles: z.number().int().nonnegative(),
+    totalSymbols: z.number().int().nonnegative(),
+    files: z.array(z.object({
+      path: z.string(),
+      symbols: z.array(z.string()),
+      readCount: z.number().int().positive(),
+      lastReadAt: z.string(),
+      stale: z.boolean(),
+    }).strict()),
+    staleFiles: z.array(z.string()),
+    directoryCoverage: z.record(z.string(), z.number().int().nonnegative()),
+  }).strict(),
 };
 
 export const MCP_OUTPUT_SCHEMAS: Record<McpToolName, z.ZodType> = {
   safe_read: withMcpCommon("safe_read", mcpOutputBodySchemas.safe_read),
+  graft_edit: withMcpCommon("graft_edit", mcpOutputBodySchemas.graft_edit),
   file_outline: withMcpCommon("file_outline", mcpOutputBodySchemas.file_outline),
   read_range: withMcpCommon("read_range", mcpOutputBodySchemas.read_range),
   changed_since: withMcpCommon("changed_since", mcpOutputBodySchemas.changed_since),
@@ -1049,6 +1320,7 @@ export const MCP_OUTPUT_SCHEMAS: Record<McpToolName, z.ZodType> = {
   monitor_start: withMcpCommon("monitor_start", mcpOutputBodySchemas.monitor_start),
   monitor_pause: withMcpCommon("monitor_pause", mcpOutputBodySchemas.monitor_pause),
   monitor_resume: withMcpCommon("monitor_resume", mcpOutputBodySchemas.monitor_resume),
+  monitor_nudge: withMcpCommon("monitor_nudge", mcpOutputBodySchemas.monitor_nudge),
   monitor_stop: withMcpCommon("monitor_stop", mcpOutputBodySchemas.monitor_stop),
   workspace_authorize: withMcpCommon("workspace_authorize", mcpOutputBodySchemas.workspace_authorize),
   workspace_authorizations: withMcpCommon(
@@ -1069,6 +1341,13 @@ export const MCP_OUTPUT_SCHEMAS: Record<McpToolName, z.ZodType> = {
   explain: withMcpCommon("explain", mcpOutputBodySchemas.explain),
   doctor: withMcpCommon("doctor", mcpOutputBodySchemas.doctor),
   stats: withMcpCommon("stats", mcpOutputBodySchemas.stats),
+  graft_churn: withMcpCommon("graft_churn", mcpOutputBodySchemas.graft_churn),
+  graft_exports: withMcpCommon("graft_exports", mcpOutputBodySchemas.graft_exports),
+  graft_log: withMcpCommon("graft_log", mcpOutputBodySchemas.graft_log),
+  graft_blame: withMcpCommon("graft_blame", mcpOutputBodySchemas.graft_blame),
+  graft_difficulty: withMcpCommon("graft_difficulty", mcpOutputBodySchemas.graft_difficulty),
+  graft_review: withMcpCommon("graft_review", mcpOutputBodySchemas.graft_review),
+  knowledge_map: withMcpCommon("knowledge_map", mcpOutputBodySchemas.knowledge_map),
 };
 
 const initActionSchema = z.object({
@@ -1100,7 +1379,16 @@ const suggestedMcpServerSchema = z.object({
   mcpServers: z.object({
     graft: z.object({
       command: z.literal("npx"),
-      args: z.tuple([z.literal("-y"), z.literal("@flyingrobots/graft"), z.literal("serve")]),
+      args: z.union([
+        z.tuple([z.literal("-y"), z.literal("@flyingrobots/graft"), z.literal("serve")]),
+        z.tuple([
+          z.literal("-y"),
+          z.literal("@flyingrobots/graft"),
+          z.literal("serve"),
+          z.literal("--runtime"),
+          z.literal("daemon"),
+        ]),
+      ]),
     }).strict(),
   }).strict(),
 }).strict();
@@ -1117,9 +1405,8 @@ export const CLI_OUTPUT_SCHEMAS: Record<CliCommandName, z.ZodType> = {
   index: withCliCommon("index", z.object({
     ok: z.boolean(),
     cwd: z.string(),
-    from: z.string().nullable(),
-    commitsIndexed: z.number().int().nonnegative().optional(),
-    patchesWritten: z.number().int().nonnegative().optional(),
+    filesIndexed: z.number().int().nonnegative().optional(),
+    nodesEmitted: z.number().int().nonnegative().optional(),
     error: z.string().optional(),
   }).strict()),
   read_safe: withCliPeerCommon("read_safe", mcpOutputBodySchemas.safe_read),
@@ -1131,6 +1418,12 @@ export const CLI_OUTPUT_SCHEMAS: Record<CliCommandName, z.ZodType> = {
   struct_map: withCliPeerCommon("struct_map", mcpOutputBodySchemas.graft_map),
   symbol_show: withCliPeerCommon("symbol_show", mcpOutputBodySchemas.code_show),
   symbol_find: withCliPeerCommon("symbol_find", mcpOutputBodySchemas.code_find),
+  struct_churn: withCliPeerCommon("struct_churn", mcpOutputBodySchemas.graft_churn),
+  struct_exports: withCliPeerCommon("struct_exports", mcpOutputBodySchemas.graft_exports),
+  struct_log: withCliPeerCommon("struct_log", mcpOutputBodySchemas.graft_log),
+  symbol_blame: withCliPeerCommon("symbol_blame", mcpOutputBodySchemas.graft_blame),
+  symbol_difficulty: withCliPeerCommon("symbol_difficulty", mcpOutputBodySchemas.graft_difficulty),
+  struct_review: withCliPeerCommon("struct_review", mcpOutputBodySchemas.graft_review),
   diag_doctor: withCliPeerCommon("diag_doctor", mcpOutputBodySchemas.doctor),
   diag_activity: withCliPeerCommon("diag_activity", mcpOutputBodySchemas.activity_view),
   diag_explain: withCliPeerCommon("diag_explain", mcpOutputBodySchemas.explain),
@@ -1167,6 +1460,7 @@ export const CLI_OUTPUT_SCHEMAS: Record<CliCommandName, z.ZodType> = {
     edges: z.array(z.record(z.string(), z.unknown())),
     error: z.string().optional(),
   }).strict()),
+  git_graft_enhance: withCliCommon("git_graft_enhance", gitGraftEnhanceBodySchema),
 };
 
 export function getMcpOutputSchemaMeta(tool: McpToolName): OutputSchemaMeta {

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(