@flyingrobots/graft 0.6.1 → 0.7.1

package/src/mcp/server.ts

@@ -1,265 +0,0 @@
-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 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 { 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";
-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 };
-export { ALL_TOOL_REGISTRY, TOOL_REGISTRY } from "./tool-registry.js";
-
-export interface GraftServer {
-  getRegisteredTools(): string[];
-  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 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>();
-  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);
-
-  // --- Invocation engine: AsyncLocalStorage, respond(), invokeTool() ---
-
-  const engine = createInvocationEngine({
-    sessionId,
-    mode,
-    codec,
-    observability,
-    runtimeLogger,
-    workspaceRouter,
-    daemonScheduler,
-    daemonWorkerPool,
-    runtimeReady,
-  });
-
-  // --- ToolContext: lazy-getter facade over workspace router + execution context ---
-
-  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); },
-  });
-
-  // --- 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);
-
-    if (def.schema !== undefined) {
-      const zodSchema = z.object(def.schema).strict();
-      schemas.set(def.name, zodSchema);
-      mcpServer.registerTool(def.name, { description: def.description, inputSchema: def.schema }, async (args) => {
-        return engine.invokeTool(def.name, handler, args, ctx, zodSchema);
-      });
-    } else {
-      mcpServer.registerTool(def.name, { description: def.description }, async () => {
-        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: JsonObject): Promise<McpToolResult> {
-      const handler = handlers.get(name);
-      if (handler === undefined) {
-        throw new Error(`Unknown tool: ${name}`);
-      }
-      const schema = schemas.get(name);
-      return engine.invokeTool(name, handler, args, ctx, schema);
-    },
-    injectSessionMessages(count: number): void {
-      for (let i = 0; i < count; i++) {
-        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

@@ -1,26 +0,0 @@
-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,3 +0,0 @@
-import { startStdioServer } from "./stdio-server.js";
-
-await startStdioServer();

package/src/mcp/tool-registry.ts

@@ -1,80 +0,0 @@
-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,
-];

package/src/mcp/tools/activity-view.ts

@@ -1,325 +0,0 @@
-import { z } from "zod";
-import { buildRuntimeStagedTarget } from "../runtime-staged-target.js";
-import { deriveCausalSurfaceNextAction } from "../semantic-transition-guidance.js";
-import type { PersistedLocalActivityItem } from "../persisted-local-history.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-const limitSchema = z.number().int().positive().max(50).optional();
-
-type ActivityGroupKind = "transition" | "stage" | "continuity" | "read";
-
-const GROUP_ORDER: readonly ActivityGroupKind[] = [
-  "transition",
-  "stage",
-  "continuity",
-  "read",
-];
-
-function classifyActivityItem(item: PersistedLocalActivityItem): ActivityGroupKind {
-  if ("itemKind" in item) {
-    return "continuity";
-  }
-  if (item.eventKind === "transition") {
-    return "transition";
-  }
-  if (item.eventKind === "stage") {
-    return "stage";
-  }
-  return "read";
-}
-
-function groupLabel(kind: ActivityGroupKind): string {
-  switch (kind) {
-    case "transition":
-      return "semantic transitions";
-    case "stage":
-      return "staged activity";
-    case "continuity":
-      return "workspace continuity";
-    case "read":
-      return "read activity";
-  }
-}
-
-function buildAnchor(workspaceBound: boolean, headRef: string | null, headSha: string | null) {
-  if (!workspaceBound) {
-    return {
-      posture: "unknown" as const,
-      headRef: null,
-      headSha: null,
-      reason: "workspace_unbound" as const,
-    };
-  }
-  if (headSha === null) {
-    return {
-      posture: "unknown" as const,
-      headRef,
-      headSha: null,
-      reason: "missing_head_commit" as const,
-    };
-  }
-  return {
-    posture: "head_commit" as const,
-    headRef,
-    headSha,
-  };
-}
-
-function unique(values: readonly string[]): string[] {
-  return [...new Set(values)];
-}
-
-function pluralize(count: number, singular: string, plural = `${singular}s`): string {
-  return count === 1 ? singular : plural;
-}
-
-function countText(count: number): string {
-  return String(count);
-}
-
-function shortSha(sha: string | null): string {
-  return sha === null ? "unknown" : sha.slice(0, 7);
-}
-
-function describeAnchor(anchor: ReturnType<typeof buildAnchor>): string {
-  if (anchor.posture === "unknown") {
-    return anchor.reason === "workspace_unbound"
-      ? "Anchor to the current Git commit is unavailable because no workspace is bound."
-      : "Anchor to the current Git commit is unavailable because HEAD could not be resolved.";
-  }
-
-  const refLabel = anchor.headRef ?? "HEAD";
-  return `Current commit anchor is ${refLabel} @ ${shortSha(anchor.headSha)}. This view summarizes recent bounded local artifact history for the active checkout epoch, not a complete since-commit ledger.`;
-}
-
-function describeStagedTarget(
-  stagedTarget: ReturnType<typeof buildRuntimeStagedTarget>,
-): string {
-  switch (stagedTarget.availability) {
-    case "none":
-      return "No staged target is active.";
-    case "full_file":
-      return `Staged target is a full-file selection across ${countText(stagedTarget.target.selectionEntries.length)} ${pluralize(
-        stagedTarget.target.selectionEntries.length,
-        "path",
-      )}.`;
-    case "ambiguous":
-      return `Staged target is ambiguous across ${countText(stagedTarget.observedStagedPaths)} staged ${pluralize(
-        stagedTarget.observedStagedPaths,
-        "path",
-      )}.`;
-  }
-}
-
-function describeWorkspace(
-  repoConcurrency: { posture: string; summary: string } | null,
-  semanticTransitionSummary: string | null,
-  stagedTarget: ReturnType<typeof buildRuntimeStagedTarget>,
-): string {
-  return [
-    repoConcurrency === null
-      ? "Repo concurrency posture is unknown."
-      : `Repo concurrency posture is ${repoConcurrency.posture}. ${repoConcurrency.summary}`,
-    semanticTransitionSummary ?? "No active semantic transition is recorded.",
-    describeStagedTarget(stagedTarget),
-  ].join(" ");
-}
-
-function summarizeTransitionGroup(items: PersistedLocalActivityItem[]): string {
-  const transitionItems = items.filter((item) => "eventKind" in item && item.eventKind === "transition");
-  const latest = transitionItems[0];
-  if (latest === undefined) {
-    return "No semantic transitions are recorded.";
-  }
-  if (transitionItems.length === 1) {
-    return `1 semantic transition recorded: ${latest.payload.summary}.`;
-  }
-  return `${countText(transitionItems.length)} semantic transitions recorded, latest: ${latest.payload.summary}.`;
-}
-
-function summarizeStageGroup(items: PersistedLocalActivityItem[]): string {
-  const stageItems = items.filter((item) => "eventKind" in item && item.eventKind === "stage");
-  const uniquePaths = new Set<string>();
-  for (const item of stageItems) {
-    for (const path of item.footprint.paths) {
-      uniquePaths.add(path);
-    }
-  }
-  return `${countText(stageItems.length)} staging ${pluralize(stageItems.length, "event")} across ${countText(uniquePaths.size)} ${pluralize(
-    uniquePaths.size,
-    "path",
-  )}.`;
-}
-
-function summarizeContinuityGroup(items: PersistedLocalActivityItem[]): string {
-  const continuityItems = items.filter((item) => "itemKind" in item);
-  const operations = unique(continuityItems.map((item) => item.operation));
-  return `${countText(continuityItems.length)} continuity ${pluralize(continuityItems.length, "change")} (${operations.join(", ")}).`;
-}
-
-function summarizeReadGroup(items: PersistedLocalActivityItem[]): string {
-  const readItems = items.filter((item) => "eventKind" in item && item.eventKind === "read");
-  const uniquePaths = new Set<string>();
-  for (const item of readItems) {
-    for (const path of item.footprint.paths) {
-      uniquePaths.add(path);
-    }
-  }
-  const latest = readItems[0];
-  if (latest === undefined) {
-    return "No read activity is recorded.";
-  }
-  return `${countText(readItems.length)} reads across ${countText(uniquePaths.size)} ${pluralize(
-    uniquePaths.size,
-    "path",
-  )}, latest via ${latest.payload.surface}.`;
-}
-
-function summarizeGroup(
-  kind: ActivityGroupKind,
-  items: PersistedLocalActivityItem[],
-): string {
-  switch (kind) {
-    case "transition":
-      return summarizeTransitionGroup(items);
-    case "stage":
-      return summarizeStageGroup(items);
-    case "continuity":
-      return summarizeContinuityGroup(items);
-    case "read":
-      return summarizeReadGroup(items);
-  }
-}
-
-function buildHeadline(
-  returned: number,
-  truncated: boolean,
-): string {
-  const headline = `Showing ${countText(returned)} recent ${pluralize(returned, "activity item")} from bounded local artifact history for the active line of work.`;
-  return truncated ? `${headline} Results are truncated to the requested window.` : headline;
-}
-
-export const activityViewTool: ToolDefinition = {
-  name: "activity_view",
-  description:
-    "Inspect recent bounded local artifact history for the active workspace, anchored to the current commit when possible.",
-  schema: {
-    limit: limitSchema,
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const limit = limitSchema.parse(args["limit"]) ?? 20;
-      const workspaceStatus = ctx.getWorkspaceStatus();
-
-      if (workspaceStatus.bindState === "unbound") {
-        return ctx.respond("activity_view", {
-          ...workspaceStatus,
-          truthClass: "artifact_history",
-          anchor: buildAnchor(false, null, null),
-          summary: {
-            headline: buildHeadline(0, false),
-            anchor: "Anchor to the current Git commit is unavailable because no workspace is bound.",
-            workspace: "No active causal workspace is available until a workspace is bound.",
-            groups: [],
-          },
-          activeCausalWorkspace: null,
-          activityWindow: {
-            historyPath: null,
-            limit,
-            returned: 0,
-            totalMatchingItems: 0,
-            truncated: false,
-            missingSignalKinds: ["write_events_not_captured"],
-            groups: [],
-          },
-          degradedReasons: ["workspace_unbound", "anchor_unknown"],
-          nextAction: "bind_workspace_to_begin_local_history",
-        });
-      }
-
-      const repoState = ctx.getRepoState();
-      const causalContext = ctx.getCausalContext();
-      const persistedLocalHistory = await ctx.getPersistedLocalHistorySummary();
-      const activityWindow = await ctx.getPersistedLocalActivityWindow(limit);
-      const workspaceOverlayFooting = await ctx.getWorkspaceOverlayFooting();
-      const repoConcurrency = await ctx.getRepoConcurrencySummary();
-      const nextAction = deriveCausalSurfaceNextAction(
-        persistedLocalHistory.nextAction,
-        repoState.semanticTransition,
-        repoConcurrency,
-      );
-      const stagedTarget = buildRuntimeStagedTarget(
-        workspaceStatus,
-        causalContext,
-        repoState,
-        persistedLocalHistory.attribution,
-      );
-      const anchor = buildAnchor(true, repoState.headRef, repoState.headSha);
-      const workspaceOverlayDegradedReason = workspaceOverlayFooting?.degradedReason ?? null;
-
-      const groups = GROUP_ORDER.map((groupKind) => {
-        const items = activityWindow.items.filter((item) => classifyActivityItem(item) === groupKind);
-        if (items.length === 0) {
-          return null;
-        }
-        return {
-          groupKind,
-          label: groupLabel(groupKind),
-          summary: summarizeGroup(groupKind, items),
-          count: items.length,
-          items,
-        };
-      }).filter((group) => group !== null);
-
-      const degradedReasons = unique([
-        ...(anchor.posture === "unknown" ? ["anchor_unknown"] : []),
-        ...(workspaceOverlayDegradedReason === null ? [] : [workspaceOverlayDegradedReason]),
-        ...(stagedTarget.availability === "ambiguous" ? ["staged_target_ambiguous"] : []),
-        ...(repoConcurrency !== null && repoConcurrency.posture !== "exclusive"
-          ? [repoConcurrency.posture]
-          : []),
-      ]);
-
-      return ctx.respond("activity_view", {
-        ...workspaceStatus,
-        truthClass: "artifact_history",
-        anchor,
-        summary: {
-          headline: buildHeadline(activityWindow.items.length, activityWindow.truncated),
-          anchor: describeAnchor(anchor),
-          workspace: describeWorkspace(
-            repoConcurrency === null
-              ? null
-              : { posture: repoConcurrency.posture, summary: repoConcurrency.summary },
-            repoState.semanticTransition?.summary ?? null,
-            stagedTarget,
-          ),
-          groups: groups.map((group) => group.summary),
-        },
-        activeCausalWorkspace: {
-          causalContext,
-          attribution: persistedLocalHistory.attribution,
-          repoConcurrency,
-          checkoutEpoch: repoState.checkoutEpoch,
-          lastTransition: repoState.lastTransition,
-          semanticTransition: repoState.semanticTransition,
-          workspaceOverlayId: repoState.workspaceOverlayId,
-          workspaceOverlay: repoState.workspaceOverlay,
-          workspaceOverlayFooting,
-          stagedTarget,
-        },
-        activityWindow: {
-          historyPath: activityWindow.historyPath,
-          limit: activityWindow.limit,
-          returned: activityWindow.items.length,
-          totalMatchingItems: activityWindow.totalMatchingItems,
-          truncated: activityWindow.truncated,
-          missingSignalKinds: ["write_events_not_captured"],
-          groups,
-        },
-        degradedReasons,
-        nextAction,
-      });
-    };
-  },
-};