@flyingrobots/graft 0.4.0 → 0.6.0

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

@@ -0,0 +1,145 @@
+import type { McpToolResult } from "./receipt.js";
+import { parseJsonTextObject, type JsonObject } from "../contracts/json-object.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";
+import {
+  WorkspaceBindingRequiredError,
+  WorkspaceCapabilityDeniedError,
+  type WorkspaceStatus,
+} from "./workspace-router.js";
+import type { ToolContext, ToolDefinition, ToolHandler } from "./context.js";
+
+const daemonAlwaysAvailableTools = new Set<string>([
+  "daemon_repos",
+  "daemon_status",
+  "daemon_sessions",
+  "daemon_monitors",
+  "monitor_start",
+  "monitor_pause",
+  "monitor_resume",
+  "monitor_stop",
+  "workspace_authorize",
+  "workspace_authorizations",
+  "workspace_revoke",
+  "workspace_bind",
+  "workspace_status",
+  "causal_status",
+  "workspace_rebind",
+  "explain",
+]);
+
+export const repoStateOptionalTools = new Set<string>([
+  "daemon_repos",
+  "daemon_status",
+  "daemon_sessions",
+  "daemon_monitors",
+  "monitor_start",
+  "monitor_pause",
+  "monitor_resume",
+  "monitor_stop",
+  "workspace_authorize",
+  "workspace_authorizations",
+  "workspace_revoke",
+  "workspace_bind",
+  "workspace_status",
+  "workspace_rebind",
+  "explain",
+]);
+
+export const daemonScheduledRepoTools = new Set<string>([
+  "safe_read",
+  "file_outline",
+  "changed_since",
+  "graft_diff",
+  "graft_since",
+  "graft_map",
+  "code_show",
+  "code_find",
+  "code_refs",
+]);
+
+export const attributedReadTools = new Set<string>([
+  "safe_read",
+  "file_outline",
+  "read_range",
+]);
+
+function isOffloadedRepoTool(name: string): name is OffloadedRepoToolName {
+  return OFFLOADED_DAEMON_REPO_TOOL_NAMES.includes(name as OffloadedRepoToolName);
+}
+
+export function enforceDaemonToolAccess(input: {
+  readonly mode: "repo_local" | "daemon";
+  readonly name: string;
+  readonly isBound: boolean;
+  readonly status: WorkspaceStatus;
+}): void {
+  if (input.mode !== "daemon") return;
+  if (daemonAlwaysAvailableTools.has(input.name)) {
+    return;
+  }
+  if (!input.isBound) {
+    throw new WorkspaceBindingRequiredError(input.name);
+  }
+  if (input.name === "run_capture" && input.status.capabilityProfile?.runCapture !== true) {
+    throw new WorkspaceCapabilityDeniedError(input.name);
+  }
+}
+
+export function resolveDaemonOffloadedRepoTool(
+  name: string,
+  parsed: JsonObject,
+  dirty: boolean,
+): OffloadedRepoToolName | null {
+  if (name === "code_find") {
+    return dirty ? "code_find_live" : null;
+  }
+  if (name === "code_show") {
+    return parsed["ref"] === undefined ? "code_show_live" : null;
+  }
+  return isOffloadedRepoTool(name) ? name : null;
+}
+
+export function parseToolPayload(result: McpToolResult): JsonObject | null {
+  const textBlock = result.content.find((entry) => entry.type === "text");
+  if (textBlock === undefined) {
+    return null;
+  }
+  try {
+    return parseJsonTextObject(textBlock.text, "MCP tool result");
+  } catch {
+    return null;
+  }
+}
+
+export function wrapWithPolicyCheck(
+  toolName: ToolDefinition["name"],
+  inner: ToolHandler,
+): ToolHandler {
+  return async (args: JsonObject, ctx: ToolContext) => {
+    const rawPath = args["path"] as string | undefined;
+    if (rawPath === undefined) return inner(args, ctx);
+    const filePath = ctx.resolvePath(rawPath);
+    let content: string;
+    try {
+      content = await ctx.fs.readFile(filePath, "utf-8");
+    } catch {
+      return inner(args, ctx);
+    }
+    const actual = { lines: content.split("\n").length, bytes: Buffer.byteLength(content) };
+    const policy = evaluateMcpPolicy(ctx, filePath, actual);
+    if (policy instanceof RefusedResult) {
+      ctx.metrics.recordRefusal();
+      return ctx.respond(toolName, {
+        path: filePath,
+        projection: "refused",
+        reason: policy.reason,
+        reasonDetail: policy.reasonDetail,
+        next: [...policy.next],
+        actual,
+      });
+    }
+    return inner(args, ctx);
+  };
+}

package/src/mcp/server.ts

@@ -2,140 +2,211 @@ import * as crypto from "node:crypto";
 import * as path from "node:path";
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { SessionTracker } from "../session/tracker.js";
-import { Metrics } from "./metrics.js";
-import { ObservationCache } from "./cache.js";
-import { buildReceiptResult } from "./receipt.js";
-import type { ToolHandler, ToolContext, ToolDefinition } from "./context.js";
-import { createPathResolver } from "./context.js";
+import type { JsonObject } from "../contracts/json-object.js";
+import type { ToolHandler, ToolContext } from "./context.js";
 import type { McpToolResult } from "./receipt.js";
 import { nodeFs } from "../adapters/node-fs.js";
 import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import { evaluatePolicy } from "../policy/evaluate.js";
-import { RefusedResult } from "../policy/types.js";
-import type WarpApp from "@git-stunts/git-warp";
+import { nodeProcessRunner } from "../adapters/node-process-runner.js";
+import type { ProcessRunner } from "../ports/process-runner.js";
+import { nodeGit } from "../adapters/node-git.js";
 import { openWarp } from "../warp/open.js";
-
-// Tool definitions — each file exports a ToolDefinition object
-import { safeReadTool } from "./tools/safe-read.js";
-import { fileOutlineTool } from "./tools/file-outline.js";
-import { readRangeTool } from "./tools/read-range.js";
-import { changedSinceTool } from "./tools/changed-since.js";
-import { graftDiffTool } from "./tools/graft-diff.js";
-import { runCaptureTool } from "./tools/run-capture.js";
-import { stateSaveTool, stateLoadTool } from "./tools/state.js";
-import { doctorTool } from "./tools/doctor.js";
-import { statsTool } from "./tools/stats.js";
-import { explainTool } from "./tools/explain.js";
-import { setBudgetTool } from "./tools/budget.js";
-import { sinceTool } from "./tools/since.js";
-import { mapTool } from "./tools/map.js";
+import type { RunCaptureConfig } from "./run-capture-config.js";
+import { resolveRunCaptureConfig } from "./run-capture-config.js";
+import {
+  WorkspaceRouter,
+  type WorkspaceMode,
+} from "./workspace-router.js";
+import { DaemonControlPlane, type DaemonRuntimeDescriptor } from "./daemon-control-plane.js";
+import { DaemonRepoOverview } from "./daemon-repos.js";
+import { DaemonJobScheduler } from "./daemon-job-scheduler.js";
+import { InlineDaemonWorkerPool, type DaemonWorkerPool } from "./daemon-worker-pool.js";
+import { PersistentMonitorRuntime } from "./persistent-monitor-runtime.js";
+import {
+  RuntimeEventLogger,
+  ensureGraftDirExcluded,
+  resolveRuntimeObservabilityState,
+  type RuntimeObservabilityState,
+} from "./runtime-observability.js";
+import { InMemoryWarpPool, type WarpPool } from "./warp-pool.js";
+import { buildSessionWarpWriterId } from "../warp/writer-id.js";
+import { PersistedLocalHistoryStore } from "./persisted-local-history.js";
+import { GRAFT_VERSION } from "../version.js";
+import { ALL_TOOL_REGISTRY, TOOL_REGISTRY } from "./tool-registry.js";
+import { wrapWithPolicyCheck } from "./server-tool-access.js";
+import { buildToolContext } from "./server-context.js";
+import { createInvocationEngine, recordFootprint } from "./server-invocation.js";
 
 export type { McpToolResult, ToolHandler, ToolContext };
-
-/** All registered tool definitions. Add new tools here. */
-const TOOL_REGISTRY: readonly ToolDefinition[] = [
-  safeReadTool,
-  fileOutlineTool,
-  readRangeTool,
-  changedSinceTool,
-  graftDiffTool,
-  runCaptureTool,
-  stateSaveTool,
-  stateLoadTool,
-  doctorTool,
-  statsTool,
-  explainTool,
-  setBudgetTool,
-  sinceTool,
-  mapTool,
-];
+export { ALL_TOOL_REGISTRY, TOOL_REGISTRY } from "./tool-registry.js";
 
 export interface GraftServer {
   getRegisteredTools(): string[];
-  callTool(name: string, args: Record<string, unknown>): Promise<McpToolResult>;
+  callTool(name: string, args: JsonObject): Promise<McpToolResult>;
   injectSessionMessages(count: number): void;
+  getWorkspaceStatus(): import("./workspace-router.js").WorkspaceStatus;
+  getRuntimeCausalContext(): import("./runtime-causal-context.js").RuntimeCausalContext | null;
   getMcpServer(): McpServer;
 }
 
-export function createGraftServer(): GraftServer {
-  const mcpServer = new McpServer({ name: "graft", version: "0.0.0" });
-  const session = new SessionTracker();
-  const sessionId = crypto.randomUUID();
-  const projectRoot = process.cwd();
-  const graftDir = path.join(projectRoot, ".graft");
-  const metrics = new Metrics();
-  const cache = new ObservationCache();
+export interface CreateGraftServerOptions {
+  mode?: WorkspaceMode;
+  sessionId?: string;
+  projectRoot?: string;
+  graftDir?: string;
+  env?: Readonly<Record<string, string | undefined>>;
+  runCapture?: Partial<RunCaptureConfig>;
+  runtimeObservability?: Partial<RuntimeObservabilityState>;
+  warpPool?: WarpPool;
+  daemonControlPlane?: DaemonControlPlane;
+  monitorRuntime?: PersistentMonitorRuntime;
+  daemonScheduler?: DaemonJobScheduler;
+  daemonWorkerPool?: DaemonWorkerPool;
+  daemonRuntime?: (() => DaemonRuntimeDescriptor) | undefined;
+  processRunner?: ProcessRunner;
+}
+
+export function createGraftServer(options: CreateGraftServerOptions = {}): GraftServer {
+  const mcpServer = new McpServer({ name: "graft", version: GRAFT_VERSION });
+  const sessionId = options.sessionId ?? crypto.randomUUID();
+  const mode = options.mode ?? "repo_local";
+  const sessionWarpWriterId = mode === "daemon" ? buildSessionWarpWriterId(sessionId) : undefined;
+  const env = options.env ?? process.env;
+  const projectRoot = mode === "repo_local" ? (options.projectRoot ?? env["GRAFT_PROJECT_ROOT"]?.trim() ?? process.cwd()) : options.projectRoot;
+  const graftDir = options.graftDir
+    ?? (mode === "repo_local" && projectRoot !== undefined ? path.join(projectRoot, ".graft") : undefined);
+  if (graftDir === undefined) {
+    throw new Error("daemon mode requires an explicit graftDir");
+  }
   const codec = new CanonicalJsonCodec();
+  const runCapture = resolveRunCaptureConfig({
+    ...(options.env !== undefined ? { env: options.env } : {}),
+    ...(options.runCapture !== undefined ? { overrides: options.runCapture } : {}),
+  });
+  const observability = resolveRuntimeObservabilityState({
+    graftDir,
+    ...(options.env !== undefined ? { env: options.env } : {}),
+    ...(options.runtimeObservability !== undefined ? { overrides: options.runtimeObservability } : {}),
+  });
+  const runtimeLogger = new RuntimeEventLogger({
+    fs: nodeFs,
+    codec,
+    logPath: observability.logPath,
+    maxBytes: observability.maxBytes,
+  });
+  const warpPool = options.warpPool ?? new InMemoryWarpPool((cwd, writerId) => openWarp({ cwd, writerId }));
+  const processRunner = options.processRunner ?? nodeProcessRunner;
+  const persistedLocalHistory = new PersistedLocalHistoryStore({
+    fs: nodeFs,
+    codec,
+    graftDir,
+  });
+  const daemonScheduler = mode === "daemon" ? (options.daemonScheduler ?? new DaemonJobScheduler()) : null;
+  const daemonWorkerPool = mode === "daemon" ? (options.daemonWorkerPool ?? new InlineDaemonWorkerPool()) : null;
+  const daemonControlPlane = mode === "daemon"
+    ? (options.daemonControlPlane ?? new DaemonControlPlane({
+      fs: nodeFs,
+      codec,
+      git: nodeGit,
+      graftDir,
+    }))
+    : null;
+  const monitorRuntime = mode !== "daemon" || daemonControlPlane === null || daemonScheduler === null || daemonWorkerPool === null
+    ? null
+    : (options.monitorRuntime ?? new PersistentMonitorRuntime({
+      fs: nodeFs,
+      codec,
+      git: nodeGit,
+      graftDir,
+      controlPlane: daemonControlPlane,
+      scheduler: daemonScheduler,
+      workerPool: daemonWorkerPool,
+    }));
+  const daemonStartedAt = new Date().toISOString();
+  const daemonRuntime = options.daemonRuntime ?? (() => {
+    return {
+      transport: "unix_socket",
+      sameUserOnly: true,
+      socketPath: graftDir,
+      mcpPath: "/mcp",
+      healthPath: "/healthz",
+      activeWarpRepos: warpPool.size(),
+      startedAt: daemonStartedAt,
+    };
+  });
   const handlers = new Map<string, ToolHandler>();
   const schemas = new Map<string, z.ZodObject>();
-  let seq = 0;
+  const workspaceRouter = new WorkspaceRouter({
+    mode,
+    fs: nodeFs,
+    git: nodeGit,
+    graftDir,
+    ...(projectRoot !== undefined ? { projectRoot } : {}),
+    warpPool,
+    transportSessionId: sessionId,
+    ...(sessionWarpWriterId !== undefined ? { warpWriterId: sessionWarpWriterId } : {}),
+    ...(daemonControlPlane !== null ? { authorizationPolicy: daemonControlPlane } : {}),
+    ...(daemonControlPlane !== null ? { sharedAttachPolicy: daemonControlPlane } : {}),
+    persistedLocalHistory,
+  });
+  const daemonRepoOverview = daemonControlPlane !== null && monitorRuntime !== null
+    ? new DaemonRepoOverview({
+      controlPlane: daemonControlPlane,
+      monitorRuntime,
+    })
+    : null;
+  const runtimeReady = (async () => {
+    if (mode === "repo_local" && projectRoot !== undefined) {
+      await ensureGraftDirExcluded(projectRoot, graftDir, nodeFs);
+    }
+    await workspaceRouter.initialize();
+    await Promise.all([
+      daemonControlPlane?.initialize() ?? Promise.resolve(),
+      monitorRuntime?.initialize() ?? Promise.resolve(),
+    ]);
+  })().then(() => undefined);
 
-  function respond(tool: string, data: Record<string, unknown>): McpToolResult {
-    seq++;
-    const { result, textBytes } = buildReceiptResult(tool, data, {
-      sessionId, seq, codec,
-      metrics: metrics.snapshot(),
-      tripwires: session.checkTripwires(),
-      budget: session.getBudget(),
-    });
-    metrics.addBytesReturned(textBytes);
-    session.recordBytesConsumed(textBytes);
-    return result;
-  }
+  // --- Invocation engine: AsyncLocalStorage, respond(), invokeTool() ---
 
-  // Lazy WARP initialization — only loaded when a WARP-backed tool needs it.
-  // Single pending promise prevents duplicate instances from concurrent calls.
-  // On rejection, clear cache so subsequent calls can retry.
-  let warpPromise: Promise<WarpApp> | null = null;
-  function getWarp(): Promise<WarpApp> {
-    warpPromise ??= openWarp({ cwd: projectRoot }).catch((err: unknown) => {
-      warpPromise = null;
-      throw err;
-    });
-    return warpPromise;
-  }
+  const engine = createInvocationEngine({
+    sessionId,
+    mode,
+    codec,
+    observability,
+    runtimeLogger,
+    workspaceRouter,
+    daemonScheduler,
+    daemonWorkerPool,
+    runtimeReady,
+  });
 
-  const ctx: ToolContext = { projectRoot, graftDir, session, cache, metrics, respond, resolvePath: createPathResolver(projectRoot), fs: nodeFs, codec, getWarp };
+  // --- ToolContext: lazy-getter facade over workspace router + execution context ---
 
-  function wrapWithPolicyCheck(toolName: string, inner: ToolHandler): ToolHandler {
-    return (args: Record<string, unknown>) => {
-      const rawPath = args["path"] as string | undefined;
-      if (rawPath === undefined) return inner(args);
-      const filePath = ctx.resolvePath(rawPath);
-      let content: string;
-      try {
-        content = ctx.fs.readFileSync(filePath, "utf-8");
-      } catch {
-        // File unreadable — let the inner handler deal with the error
-        return inner(args);
-      }
-      const actual = { lines: content.split("\n").length, bytes: Buffer.byteLength(content) };
-      const budget = session.getBudget();
-      const policy = evaluatePolicy(
-        { path: filePath, lines: actual.lines, bytes: actual.bytes },
-        {
-          sessionDepth: session.getSessionDepth(),
-          budgetRemaining: budget?.remaining,
-        },
-      );
-      if (policy instanceof RefusedResult) {
-        metrics.recordRefusal();
-        return respond(toolName, {
-          path: filePath,
-          projection: "refused",
-          reason: policy.reason,
-          reasonDetail: policy.reasonDetail,
-          next: [...policy.next],
-          actual,
-        });
-      }
-      return inner(args);
-    };
-  }
+  const ctx: ToolContext = buildToolContext({
+    workspaceRouter,
+    fs: nodeFs,
+    codec,
+    processRunner,
+    git: nodeGit,
+    runCapture,
+    observability,
+    daemonControlPlane,
+    daemonRepoOverview,
+    daemonScheduler,
+    daemonWorkerPool,
+    monitorRuntime,
+    daemonRuntime,
+    getActiveExecutionContext: engine.getActiveExecutionContext,
+    respond: engine.respond,
+    recordFootprint: (entry) => { recordFootprint(engine.invocationStorage, entry); },
+  });
 
-  for (const def of TOOL_REGISTRY) {
-    const rawHandler = def.createHandler(ctx);
+  // --- Tool registration ---
+
+  const activeToolRegistry = mode === "daemon" ? ALL_TOOL_REGISTRY : TOOL_REGISTRY;
+
+  for (const def of activeToolRegistry) {
+    const rawHandler = def.createHandler();
     const handler = def.policyCheck === true ? wrapWithPolicyCheck(def.name, rawHandler) : rawHandler;
     handlers.set(def.name, handler);
 
@@ -143,39 +214,49 @@ export function createGraftServer(): GraftServer {
       const zodSchema = z.object(def.schema).strict();
       schemas.set(def.name, zodSchema);
       mcpServer.registerTool(def.name, { description: def.description, inputSchema: def.schema }, async (args) => {
-        session.recordMessage();
-        session.recordToolCall(def.name);
-        const parsed: Record<string, unknown> = zodSchema.parse(args);
-        return handler(parsed);
+        return engine.invokeTool(def.name, handler, args, ctx, zodSchema);
       });
     } else {
       mcpServer.registerTool(def.name, { description: def.description }, async () => {
-        session.recordMessage();
-        session.recordToolCall(def.name);
-        return handler({});
+        return engine.invokeTool(def.name, handler, {}, ctx);
       });
     }
   }
 
+  if (observability.enabled) {
+    void engine.emitRuntimeEvent({
+      event: "session_started",
+      sessionId,
+      logPath: observability.logPath,
+      logPolicy: observability.logPolicy,
+    });
+  }
+
   return {
     getRegisteredTools(): string[] {
       return [...handlers.keys()];
     },
-    async callTool(name: string, args: Record<string, unknown>): Promise<McpToolResult> {
+    async callTool(name: string, args: JsonObject): Promise<McpToolResult> {
       const handler = handlers.get(name);
       if (handler === undefined) {
         throw new Error(`Unknown tool: ${name}`);
       }
-      session.recordMessage();
-      session.recordToolCall(name);
       const schema = schemas.get(name);
-      const parsed: Record<string, unknown> = schema !== undefined ? schema.parse(args) : args;
-      return handler(parsed);
+      return engine.invokeTool(name, handler, args, ctx, schema);
     },
     injectSessionMessages(count: number): void {
       for (let i = 0; i < count; i++) {
-        session.recordMessage();
+        workspaceRouter.governor.recordMessage();
+      }
+    },
+    getWorkspaceStatus() {
+      return workspaceRouter.getStatus();
+    },
+    getRuntimeCausalContext() {
+      if (workspaceRouter.getStatus().bindState !== "bound") {
+        return null;
       }
+      return workspaceRouter.captureExecutionContext().getCausalContext();
     },
     getMcpServer(): McpServer {
       return mcpServer;

package/src/mcp/stdio-server.ts

@@ -0,0 +1,26 @@
+import * as path from "node:path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createGraftServer } from "./server.js";
+
+export interface StartStdioServerOptions {
+  readonly runtime: "stdio" | "daemon";
+  readonly socketPath?: string;
+}
+
+function resolveProjectRoot(cwd: string): string {
+  const fromEnv = process.env["GRAFT_PROJECT_ROOT"]?.trim();
+  if (fromEnv !== undefined && fromEnv.length > 0) {
+    return path.resolve(fromEnv);
+  }
+  return cwd;
+}
+
+export async function startStdioServer(cwd = process.cwd()): Promise<void> {
+  const projectRoot = resolveProjectRoot(cwd);
+  const graft = createGraftServer({
+    projectRoot,
+    graftDir: path.join(projectRoot, ".graft"),
+  });
+  const transport = new StdioServerTransport();
+  await graft.getMcpServer().connect(transport);
+}

package/src/mcp/stdio.ts

@@ -1,6 +1,3 @@
-import { createGraftServer } from "./server.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { startStdioServer } from "./stdio-server.js";
 
-const graft = createGraftServer();
-const transport = new StdioServerTransport();
-await graft.getMcpServer().connect(transport);
+await startStdioServer();

package/src/mcp/tool-registry.ts

@@ -0,0 +1,80 @@
+import type { ToolDefinition } from "./context.js";
+
+import { safeReadTool } from "./tools/safe-read.js";
+import { fileOutlineTool } from "./tools/file-outline.js";
+import { readRangeTool } from "./tools/read-range.js";
+import { changedSinceTool } from "./tools/changed-since.js";
+import { graftDiffTool } from "./tools/graft-diff.js";
+import { runCaptureTool } from "./tools/run-capture.js";
+import { stateSaveTool, stateLoadTool } from "./tools/state.js";
+import { doctorTool } from "./tools/doctor.js";
+import { statsTool } from "./tools/stats.js";
+import { explainTool } from "./tools/explain.js";
+import { setBudgetTool } from "./tools/budget.js";
+import { sinceTool } from "./tools/since.js";
+import { mapTool } from "./tools/map.js";
+import { codeShowTool } from "./tools/code-show.js";
+import { codeFindTool } from "./tools/code-find.js";
+import { codeRefsTool } from "./tools/code-refs.js";
+import { daemonMonitorsTool } from "./tools/daemon-monitors.js";
+import { daemonReposTool } from "./tools/daemon-repos.js";
+import { daemonSessionsTool } from "./tools/daemon-sessions.js";
+import { daemonStatusTool } from "./tools/daemon-status.js";
+import { monitorPauseTool } from "./tools/monitor-pause.js";
+import { monitorResumeTool } from "./tools/monitor-resume.js";
+import { monitorStartTool } from "./tools/monitor-start.js";
+import { monitorStopTool } from "./tools/monitor-stop.js";
+import { activityViewTool } from "./tools/activity-view.js";
+import { causalStatusTool } from "./tools/causal-status.js";
+import { causalAttachTool } from "./tools/causal-attach.js";
+import { workspaceAuthorizeTool } from "./tools/workspace-authorize.js";
+import { workspaceAuthorizationsTool } from "./tools/workspace-authorizations.js";
+import { workspaceBindTool } from "./tools/workspace-bind.js";
+import { workspaceRevokeTool } from "./tools/workspace-revoke.js";
+import { workspaceStatusTool } from "./tools/workspace-status.js";
+import { workspaceRebindTool } from "./tools/workspace-rebind.js";
+
+export const TOOL_REGISTRY: readonly ToolDefinition[] = [
+  safeReadTool,
+  fileOutlineTool,
+  readRangeTool,
+  changedSinceTool,
+  graftDiffTool,
+  runCaptureTool,
+  stateSaveTool,
+  stateLoadTool,
+  doctorTool,
+  activityViewTool,
+  causalStatusTool,
+  causalAttachTool,
+  statsTool,
+  explainTool,
+  setBudgetTool,
+  sinceTool,
+  mapTool,
+  codeShowTool,
+  codeFindTool,
+  codeRefsTool,
+];
+
+export const DAEMON_TOOL_REGISTRY: readonly ToolDefinition[] = [
+  daemonReposTool,
+  daemonStatusTool,
+  daemonSessionsTool,
+  daemonMonitorsTool,
+  monitorStartTool,
+  monitorPauseTool,
+  monitorResumeTool,
+  monitorStopTool,
+  workspaceAuthorizeTool,
+  workspaceAuthorizationsTool,
+  workspaceRevokeTool,
+  workspaceBindTool,
+  workspaceStatusTool,
+  workspaceRebindTool,
+];
+
+export const ALL_TOOL_REGISTRY: readonly ToolDefinition[] = [
+  ...TOOL_REGISTRY,
+  ...DAEMON_TOOL_REGISTRY,
+];