@flyingrobots/graft 0.7.0 → 0.7.1

package/src/mcp/tools/refactor-difficulty.ts

@@ -1,42 +0,0 @@
-import { z } from "zod";
-import { toJsonObject } from "../../operations/result-dto.js";
-import { refactorDifficultyFromGraph } from "../../warp/refactor-difficulty.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const refactorDifficultyTool: ToolDefinition = {
-  name: "graft_difficulty",
-  description:
-    "Refactor difficulty score for a symbol. Combines WARP aggregate " +
-    "churn curvature with WARP reference-edge friction so agents can " +
-    "choose refactor vs workaround.",
-  schema: {
-    symbol: z.string(),
-    path: z.string().optional(),
-    limit: z.number().int().positive().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const symbol = args["symbol"];
-      const rawPath = args["path"];
-      const rawLimit = args["limit"];
-
-      if (typeof symbol !== "string" || symbol.trim().length === 0) {
-        throw new Error("graft_difficulty: symbol must be a non-empty string");
-      }
-
-      const warp = await ctx.getWarp();
-      const result = await refactorDifficultyFromGraph(warp, {
-        symbol,
-        ...(typeof rawPath === "string" ? { path: rawPath } : {}),
-        ...(typeof rawLimit === "number" ? { limit: rawLimit } : {}),
-      });
-
-      ctx.recordFootprint({
-        symbols: [symbol.trim()],
-        paths: result.entries.map((entry) => entry.filePath),
-      });
-
-      return ctx.respond("graft_difficulty", toJsonObject(result));
-    };
-  },
-};

package/src/mcp/tools/run-capture.ts

@@ -1,149 +0,0 @@
-import * as path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext, ToolHandler } from "../context.js";
-
-const RUN_CAPTURE_POLICY_BOUNDARY = {
-  kind: "shell_escape_hatch",
-  boundedReadContract: false,
-  policyEnforced: false,
-} as const;
-
-const PRIVATE_KEY_BLOCK_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
-const SECRET_ASSIGNMENT_RE = /(\b(?:api[_-]?key|access[_-]?token|auth(?:orization)?|bearer|token|secret|password|passwd|private[_-]?key|client[_-]?secret|session[_-]?key)\b\s*[:=]\s*)([^\r\n]+)/gi;
-const BEARER_TOKEN_RE = /(\bbearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi;
-
-function tailOutput(output: string, tail: number): {
-  readonly tailed: string;
-  readonly totalLines: number;
-} {
-  const lines = output.split("\n");
-  return {
-    tailed: lines.slice(-tail).join("\n"),
-    totalLines: lines.length,
-  };
-}
-
-function renderCaptureError(result: {
-  readonly status: number | null;
-  readonly stderr: string;
-  readonly error?: Error;
-}): string {
-  if (result.error !== undefined) {
-    return result.error.message;
-  }
-  const stderr = result.stderr.trim();
-  if (stderr.length > 0) {
-    return stderr;
-  }
-  return `Command exited with status ${String(result.status)}`;
-}
-
-function redactForLog(output: string): {
-  readonly value: string;
-  readonly redactions: number;
-} {
-  let redactions = 0;
-  let value = output.replace(PRIVATE_KEY_BLOCK_RE, () => {
-    redactions++;
-    return "[REDACTED PRIVATE KEY BLOCK]";
-  });
-  value = value.replace(SECRET_ASSIGNMENT_RE, (_match, prefix: string) => {
-    redactions++;
-    return `${prefix}[REDACTED]`;
-  });
-  value = value.replace(BEARER_TOKEN_RE, (_match, prefix: string) => {
-    redactions++;
-    return `${prefix}[REDACTED]`;
-  });
-  return { value, redactions };
-}
-
-async function persistCaptureLog(ctx: ToolContext, output: string): Promise<{
-  readonly logPath: string | null;
-  readonly logRedactions: number;
-}> {
-  if (!ctx.runCapture.persistLogs) {
-    return { logPath: null, logRedactions: 0 };
-  }
-
-  const logPath = path.join(ctx.graftDir, "logs", "capture.log");
-  const persisted = ctx.runCapture.redactLogs ? redactForLog(output) : { value: output, redactions: 0 };
-
-  try {
-    await ctx.fs.mkdir(path.dirname(logPath), { recursive: true });
-    await ctx.fs.writeFile(logPath, persisted.value, "utf-8");
-    return {
-      logPath,
-      logRedactions: persisted.redactions,
-    };
-  } catch {
-    return { logPath: null, logRedactions: 0 };
-  }
-}
-
-export const runCaptureTool: ToolDefinition = {
-  name: "run_capture",
-  description:
-    "Execute a shell command and return the last N lines of output " +
-    "(default 60). Responses include an explicit policy boundary. " +
-    "Persisted logs can be disabled and obvious secrets are redacted " +
-    "before writing to .graft/logs/capture.log.",
-  schema: { command: z.string(), tail: z.number().optional() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const command = args["command"] as string;
-      const tail = Math.max(1, Math.floor((args["tail"] as number | undefined) ?? 60));
-      if (!ctx.runCapture.enabled) {
-        return ctx.respond("run_capture", {
-          output: "",
-          totalLines: 0,
-          tailedLines: 0,
-          logPath: null,
-          logRedactions: 0,
-          logPersistenceEnabled: false,
-          truncated: false,
-          disabled: true,
-          error: "run_capture is disabled by configuration",
-          policyBoundary: RUN_CAPTURE_POLICY_BOUNDARY,
-        });
-      }
-      const result = ctx.process.run({
-        command: "sh",
-        args: ["-c", command],
-        cwd: ctx.projectRoot,
-        timeoutMs: 30000,
-        maxBufferBytes: 10 * 1024 * 1024,
-      });
-
-      if (result.error !== undefined || result.status !== 0) {
-        const tailedOutput = tailOutput(result.stdout, tail);
-        return ctx.respond("run_capture", {
-          error: renderCaptureError(result),
-          output: tailedOutput.tailed,
-          totalLines: tailedOutput.totalLines,
-          tailedLines: Math.min(tail, tailedOutput.totalLines),
-          logPath: null,
-          logRedactions: 0,
-          logPersistenceEnabled: ctx.runCapture.persistLogs,
-          truncated: tailedOutput.totalLines > tail,
-          stderr: result.stderr.slice(0, 2000),
-          policyBoundary: RUN_CAPTURE_POLICY_BOUNDARY,
-        });
-      }
-
-      const output = result.stdout;
-      const tailedOutput = tailOutput(output, tail);
-      const persisted = await persistCaptureLog(ctx, output);
-      return ctx.respond("run_capture", {
-        output: tailedOutput.tailed,
-        totalLines: tailedOutput.totalLines,
-        tailedLines: Math.min(tail, tailedOutput.totalLines),
-        logPath: persisted.logPath,
-        logRedactions: persisted.logRedactions,
-        logPersistenceEnabled: ctx.runCapture.persistLogs,
-        truncated: tailedOutput.totalLines > tail,
-        policyBoundary: RUN_CAPTURE_POLICY_BOUNDARY,
-      });
-    };
-  },
-};

package/src/mcp/tools/safe-read.ts

@@ -1,148 +0,0 @@
-import { z } from "zod";
-import { safeRead, type SafeReadResult } from "../../operations/safe-read.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-import { RefusedResult } from "../../policy/types.js";
-import { diffOutlines } from "../../parser/diff.js";
-import { CachedFile } from "../cached-file.js";
-import type { Metrics } from "../metrics.js";
-import { evaluateMcpPolicy } from "../policy.js";
-import { toRepoPolicyPath } from "../../adapters/repo-paths.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-const PROJECTION_METRICS: Readonly<Record<string, ((m: Metrics) => void) | undefined>> = {
-  content: (m) => { m.recordRead(); },
-  outline: (m) => { m.recordOutline(); },
-  refused: (m) => { m.recordRefusal(); },
-};
-
-const CACHEABLE_PROJECTIONS: ReadonlySet<SafeReadResult["projection"]> = new Set(["content", "outline"]);
-
-export const safeReadTool: ToolDefinition = {
-  name: "safe_read",
-  description:
-    "Policy-enforced file read. Returns full content for small files, " +
-    "structural outline with jump table for large files, or refusal with " +
-    "reason code for banned files. Detects re-reads and returns cached " +
-    "outlines or structural diffs.",
-  schema: { path: z.string(), intent: z.string().optional() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const filePath = ctx.resolvePath(args["path"] as string);
-      ctx.recordFootprint({ paths: [filePath] });
-
-      // Build CachedFile once — all consumers share the same snapshot,
-      // eliminating TOCTOU races where the file changes between reads.
-      let cf: CachedFile | null = null;
-      try {
-        const rawContent = await ctx.fs.readFile(filePath, "utf-8");
-        cf = new CachedFile(filePath, rawContent);
-      } catch {
-        // File doesn't exist or can't be read — proceed to safeRead for error handling
-      }
-
-      // Check cache if we could read the file
-      if (cf?.supportsOutline === true) {
-        const cacheResult = ctx.cache.check(filePath, cf.rawContent);
-        if (cacheResult.hit) {
-          // Defense: re-check policy before returning cached data.
-          const policy = evaluateMcpPolicy(ctx, filePath, cf.actual);
-          if (policy instanceof RefusedResult) {
-            ctx.metrics.recordRefusal();
-            return ctx.respond("safe_read", {
-              path: filePath,
-              projection: "refused",
-              reason: policy.reason,
-              reasonDetail: policy.reasonDetail,
-              next: [...policy.next],
-              actual: cf.actual,
-            });
-          }
-
-          cacheResult.obs.touch(ctx.cache.now());
-          ctx.metrics.recordCacheHit(cf.actual.bytes);
-          ctx.recordFootprint({
-            symbols: cacheResult.obs.outline.map((e) => e.name),
-          });
-          return ctx.respond("safe_read", {
-            path: filePath,
-            projection: "cache_hit",
-            reason: "REREAD_UNCHANGED",
-            outline: cacheResult.obs.outline,
-            jumpTable: cacheResult.obs.jumpTable,
-            actual: cf.actual,
-            readCount: cacheResult.obs.readCount,
-            estimatedBytesAvoided: cf.actual.bytes,
-            lastReadAt: cacheResult.obs.lastReadAt,
-          });
-        }
-
-        // File changed since last observation — compute structural diff
-        if (cacheResult.stale !== null) {
-          // Defense: re-check policy before returning structural data.
-          const policy = evaluateMcpPolicy(ctx, filePath, cf.actual);
-          if (policy instanceof RefusedResult) {
-            ctx.metrics.recordRefusal();
-            return ctx.respond("safe_read", {
-              path: filePath,
-              projection: "refused",
-              reason: policy.reason,
-              reasonDetail: policy.reasonDetail,
-              next: [...policy.next],
-              actual: cf.actual,
-            });
-          }
-
-          const diff = diffOutlines(cacheResult.stale.outline, cf.outline);
-          const newReadCount = cacheResult.stale.readCount + 1;
-          ctx.cache.record(filePath, cf.hash, cf.outline, cf.jumpTable, cf.actual);
-          ctx.recordFootprint({
-            symbols: cf.outline.map((e) => e.name),
-          });
-          const updatedObs = ctx.cache.get(filePath);
-          return ctx.respond("safe_read", {
-            path: filePath,
-            projection: "diff",
-            reason: "CHANGED_SINCE_LAST_READ",
-            diff,
-            outline: cf.outline,
-            jumpTable: cf.jumpTable,
-            actual: cf.actual,
-            readCount: newReadCount,
-            lastReadAt: updatedObs?.lastReadAt ?? ctx.cache.now(),
-          });
-        }
-      }
-
-      // First read — pass rawContent to avoid double-read (TOCTOU)
-      const result = await safeRead(filePath, {
-        fs: ctx.fs,
-        codec: ctx.codec,
-        content: cf?.rawContent,
-        intent: args["intent"] as string | undefined,
-        policyPath: toRepoPolicyPath(ctx.projectRoot, filePath),
-        graftignorePatterns: [...ctx.graftignorePatterns],
-        sessionDepth: ctx.governor.getGovernorDepth(),
-        budgetRemaining: ctx.governor.getBudget()?.remaining,
-      });
-
-      PROJECTION_METRICS[result.projection]?.(ctx.metrics);
-      if (result.outline !== undefined) {
-        ctx.recordFootprint({ symbols: result.outline.map((e) => e.name) });
-      }
-
-      // Record observation for cacheable projections — uses CachedFile
-      // outline (no re-read) to eliminate the snapshot race.
-      if (
-        cf !== null &&
-        cf.supportsOutline &&
-        result.actual !== undefined &&
-        CACHEABLE_PROJECTIONS.has(result.projection) &&
-        result.reason !== "UNSUPPORTED_LANGUAGE"
-      ) {
-        ctx.cache.record(filePath, cf.hash, cf.outline, cf.jumpTable, result.actual);
-      }
-
-      return ctx.respond("safe_read", toJsonObject(result));
-    };
-  },
-};

package/src/mcp/tools/since.ts

@@ -1,53 +0,0 @@
-import { z } from "zod";
-import { graftDiff } from "../../operations/graft-diff.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-import { evaluateMcpRefusal } from "../policy.js";
-
-export const sinceTool: ToolDefinition = {
-  name: "graft_since",
-  description:
-    "Structural changes since a git ref. Shows symbols added, removed, " +
-    "and changed per file — not line hunks. Includes per-file summary " +
-    "lines for quick triage. Defaults to HEAD as the comparison target.",
-  schema: {
-    base: z.string(),
-    head: z.string().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const base = args["base"] as string;
-      const head = (args["head"] as string | undefined) ?? "HEAD";
-
-      const result = await graftDiff({
-        cwd: ctx.projectRoot,
-        fs: ctx.fs,
-        git: ctx.git,
-        resolveWorkingTreePath: (filePath) => ctx.resolvePath(filePath),
-        base,
-        head,
-        refusalCheck: (filePath, actual) => evaluateMcpRefusal(ctx, filePath, actual),
-      });
-
-      // Aggregate symbol-level changes across all files
-      let totalAdded = 0;
-      let totalRemoved = 0;
-      let totalChanged = 0;
-
-      for (const file of result.files) {
-        totalAdded += file.diff.added.length;
-        totalRemoved += file.diff.removed.length;
-        totalChanged += file.diff.changed.length;
-      }
-
-      ctx.recordFootprint({
-        paths: result.files.map((f) => f.path),
-      });
-
-      return ctx.respond("graft_since", {
-        ...result,
-        summary: `+${String(totalAdded)} added, -${String(totalRemoved)} removed, ~${String(totalChanged)} changed across ${String(result.files.length)} files`,
-        layer: "ref_view",
-      });
-    };
-  },
-};

package/src/mcp/tools/state.ts

@@ -1,39 +0,0 @@
-import * as path from "node:path";
-import { z } from "zod";
-import { STATE_FILENAME, stateSave, stateLoad } from "../../operations/state.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-
-export const stateSaveTool: ToolDefinition = {
-  name: "state_save",
-  description:
-    "Save session working state (max 8 KB). Use for session bookmarks: " +
-    "current task, files modified, next planned actions.",
-  schema: { content: z.string() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const result = await stateSave(args["content"] as string, {
-        stateDir: ctx.graftDir,
-        statePath: path.join(ctx.graftDir, STATE_FILENAME),
-        fs: ctx.fs,
-      });
-      return ctx.respond("state_save", toJsonObject(result));
-    };
-  },
-};
-
-export const stateLoadTool: ToolDefinition = {
-  name: "state_load",
-  description:
-    "Load previously saved session state. Returns null if no state has " +
-    "been saved.",
-  createHandler(): ToolHandler {
-    return async (_args, ctx) => {
-      const result = await stateLoad({
-        statePath: path.join(ctx.graftDir, STATE_FILENAME),
-        fs: ctx.fs,
-      });
-      return ctx.respond("state_load", toJsonObject(result));
-    };
-  },
-};

package/src/mcp/tools/stats.ts

@@ -1,24 +0,0 @@
-import { totalNonReadBytesReturned } from "../burden.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const statsTool: ToolDefinition = {
-  name: "stats",
-  description:
-    "Decision metrics for the current session. Total reads, outlines, " +
-    "refusals, cache hits, bytes avoided, and burden by tool kind.",
-  createHandler(): ToolHandler {
-    return (_args, ctx) => {
-      const snap = ctx.metrics.snapshot();
-      return ctx.respond("stats", {
-        totalReads: snap.reads,
-        totalOutlines: snap.outlines,
-        totalRefusals: snap.refusals,
-        totalCacheHits: snap.cacheHits,
-        totalBytesReturned: snap.bytesReturned,
-        totalBytesAvoidedByCache: snap.bytesAvoided,
-        totalNonReadBytesReturned: totalNonReadBytesReturned(snap.burdenByKind),
-        burdenByKind: snap.burdenByKind,
-      });
-    };
-  },
-};

package/src/mcp/tools/structural-blame.ts

@@ -1,55 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-import { structuralBlameFromGraph } from "../../warp/warp-structural-blame.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-
-export const structuralBlameTool: ToolDefinition = {
-  name: "graft_blame",
-  description:
-    "Symbol-level blame: who last changed a symbol's signature, when " +
-    "it was created, and its full change history. Returns creation " +
-    "commit, last signature change, change count, reference count, " +
-    "and chronological history.",
-  schema: {
-    symbol: z.string(),
-    path: z.string().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const symbol = args["symbol"];
-      const rawPath = args["path"];
-
-      if (typeof symbol !== "string" || symbol.trim().length === 0) {
-        throw new Error("graft_blame: symbol must be a non-empty string");
-      }
-
-      const symbolName = symbol.trim();
-      const filePath = typeof rawPath === "string" ? rawPath : undefined;
-      const warp = await ctx.getWarp();
-
-      const blame = await structuralBlameFromGraph(
-        warp,
-        symbolName,
-        filePath ?? "",
-      );
-
-      ctx.recordFootprint({ symbols: [symbolName] });
-
-      return ctx.respond("graft_blame", toJsonObject({
-        symbol: blame.symbol,
-        filePath: blame.filePath,
-        changeCount: blame.changeCount,
-        createdInCommit: blame.createdInCommit ?? null,
-        lastSignatureChange: blame.lastSignatureChange ?? null,
-        referenceCount: blame.referenceCount,
-        history: blame.history.map((v) => ({
-          sha: v.sha,
-          tick: v.tick,
-          changeKind: v.changeKind,
-          present: v.present,
-          signature: v.signature ?? null,
-        })),
-      }));
-    };
-  },
-};

package/src/mcp/tools/structural-churn.ts

@@ -1,28 +0,0 @@
-import { z } from "zod";
-import { toJsonObject } from "../../operations/result-dto.js";
-import { structuralChurnFromGraph } from "../../warp/warp-structural-churn.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const structuralChurnTool: ToolDefinition = {
-  name: "graft_churn",
-  description:
-    "Structural churn report — which symbols change most frequently? " +
-    "Identifies maintenance hotspots by walking indexed commits and " +
-    "counting per-symbol change frequency.",
-  schema: {
-    path: z.string().optional(),
-    limit: z.number().int().positive().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const warp = await ctx.getWarp();
-      const options: { path?: string; limit?: number } = {};
-      const pathArg = args["path"];
-      const limitArg = args["limit"];
-      if (typeof pathArg === "string") options.path = pathArg;
-      if (typeof limitArg === "number") options.limit = limitArg;
-      const result = await structuralChurnFromGraph(warp, options);
-      return ctx.respond("graft_churn", toJsonObject(result));
-    };
-  },
-};

package/src/mcp/tools/structural-log.ts

@@ -1,41 +0,0 @@
-import { z } from "zod";
-import { structuralLogFromGraph } from "../../warp/warp-structural-log.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const structuralLogTool: ToolDefinition = {
-  name: "graft_log",
-  description:
-    "Structural git log — shows symbol-level changes (added, removed, " +
-    "changed) per commit. Like `git log` but for code structure, not lines.",
-  schema: {
-    path: z.string().optional(),
-    limit: z.number().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const filePath = args["path"] as string | undefined;
-      const limit = args["limit"] as number | undefined;
-      const warp = await ctx.getWarp();
-
-      const options: { path?: string; limit?: number } = {};
-      if (filePath !== undefined) options.path = filePath;
-      if (limit !== undefined) options.limit = limit;
-      const entries = await structuralLogFromGraph(warp, options);
-
-      ctx.recordFootprint({
-        symbols: entries.flatMap((e) => [
-          ...e.symbols.added.map((s) => s.name),
-          ...e.symbols.removed.map((s) => s.name),
-          ...e.symbols.changed.map((s) => s.name),
-        ]),
-      });
-
-      return ctx.respond("graft_log", toJsonObject({
-        entries,
-        count: entries.length,
-        layer: "commit_worldline",
-      }));
-    };
-  },
-};

package/src/mcp/tools/structural-review.ts

@@ -1,63 +0,0 @@
-import { z } from "zod";
-import { structuralReview, type ReferenceCountResult } from "../../operations/structural-review.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-import type { ToolContext, ToolDefinition, ToolHandler } from "../context.js";
-import { countSymbolReferencesFromGraph } from "../../warp/warp-reference-count.js";
-import { nodePathOps } from "../../adapters/node-paths.js";
-import { countNamedImportReferencesAtRef } from "../../operations/import-reference-impact.js";
-
-async function countReviewReferences(
-  ctx: ToolContext,
-  symbolName: string,
-  filePath: string,
-  headRef: string,
-): Promise<ReferenceCountResult> {
-  const warpCtx = await ctx.getWarp();
-  const graphResult = await countSymbolReferencesFromGraph(warpCtx, symbolName, filePath);
-  if (graphResult.referenceCount > 0) {
-    return graphResult;
-  }
-
-  try {
-    const fallbackResult = await countNamedImportReferencesAtRef({
-      cwd: ctx.projectRoot,
-      git: ctx.git,
-      pathOps: nodePathOps,
-      symbolName,
-      filePath,
-      ref: headRef,
-    });
-    return fallbackResult.referenceCount > 0 ? fallbackResult : graphResult;
-  } catch {
-    return graphResult;
-  }
-}
-
-export const structuralReviewTool: ToolDefinition = {
-  name: "graft_review",
-  description:
-    "Zero-noise structural PR review. Categorizes changed files as " +
-    "structural, formatting, test, docs, or config. Detects breaking " +
-    "changes (removed exports, changed signatures) with impact counts.",
-  schema: { base: z.string().optional(), head: z.string().optional() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const head = args["head"] as string | undefined;
-      const result = await structuralReview({
-        cwd: ctx.projectRoot,
-        fs: ctx.fs,
-        git: ctx.git,
-        resolveWorkingTreePath: (filePath) => ctx.resolvePath(filePath),
-        base: args["base"] as string | undefined,
-        head,
-        countReferences: async (symbolName, filePath) => {
-          return countReviewReferences(ctx, symbolName, filePath, head ?? "HEAD");
-        },
-      });
-      ctx.recordFootprint({
-        paths: result.files.map((f) => f.path),
-      });
-      return ctx.respond("graft_review", toJsonObject(result));
-    };
-  },
-};

package/src/mcp/tools/workspace-authorizations.ts

@@ -1,14 +0,0 @@
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceAuthorizationsTool: ToolDefinition = {
-  name: "workspace_authorizations",
-  description:
-    "List daemon-authorized workspaces, their capability posture, and active bound-session counts.",
-  createHandler(): ToolHandler {
-    return async (_args, ctx) => {
-      return ctx.respond("workspace_authorizations", {
-        workspaces: await ctx.listWorkspaceAuthorizations(),
-      });
-    };
-  },
-};

package/src/mcp/tools/workspace-authorize.ts

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceAuthorizeTool: ToolDefinition = {
-  name: "workspace_authorize",
-  description:
-    "Authorize a workspace for daemon binding and optionally change its daemon capability posture.",
-  schema: {
-    cwd: z.string(),
-    runCapture: z.boolean().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      return ctx.respond("workspace_authorize", { ...await ctx.authorizeWorkspace({
-        cwd: args["cwd"] as string,
-        runCapture: args["runCapture"] as boolean | undefined,
-      }) });
-    };
-  },
-};