@flyingrobots/graft 0.7.0 → 0.7.1

package/src/mcp/repo-state-types.ts

@@ -1,107 +0,0 @@
-export type WorldlineLayer = "commit_worldline" | "ref_view" | "workspace_overlay";
-export type RepoTransitionKind = "checkout" | "reset" | "merge" | "rebase";
-export type RepoSemanticTransitionKind =
-  | "index_update"
-  | "conflict_resolution"
-  | "merge_phase"
-  | "rebase_phase"
-  | "bulk_transition"
-  | "unknown";
-export type RepoSemanticTransitionAuthority =
-  | "authoritative_git_state"
-  | "repo_snapshot";
-export type RepoSemanticTransitionPhase =
-  | "started"
-  | "conflicted"
-  | "resolved_waiting_commit"
-  | "continued"
-  | "completed_or_cleared";
-
-export interface RepoTransition {
-  readonly kind: RepoTransitionKind;
-  readonly fromRef: string | null;
-  readonly toRef: string | null;
-  readonly fromCommit: string | null;
-  readonly toCommit: string | null;
-  readonly evidence: {
-    readonly reflogSubject: string | null;
-  };
-}
-
-export interface RepoSemanticTransition {
-  readonly kind: RepoSemanticTransitionKind;
-  readonly authority: RepoSemanticTransitionAuthority;
-  readonly phase: RepoSemanticTransitionPhase | null;
-  readonly summary: string;
-  readonly evidence: {
-    readonly totalPaths: number;
-    readonly stagedPaths: number;
-    readonly changedPaths: number;
-    readonly untrackedPaths: number;
-    readonly unmergedPaths: number;
-    readonly mergeInProgress: boolean;
-    readonly rebaseInProgress: boolean;
-    readonly rebaseStep: number | null;
-    readonly rebaseTotalSteps: number | null;
-    readonly lastTransitionKind: RepoTransitionKind | null;
-    readonly reflogSubject: string | null;
-  };
-}
-
-export interface WorkspaceOverlaySummary {
-  readonly dirty: true;
-  readonly totalPaths: number;
-  readonly stagedPaths: number;
-  readonly changedPaths: number;
-  readonly untrackedPaths: number;
-  readonly actorGuess: "unknown";
-  readonly confidence: "low";
-  readonly evidence: {
-    readonly source: "git status --porcelain";
-    readonly reflogSubject: string | null;
-    readonly sample: readonly string[];
-  };
-}
-
-export interface RepoObservation {
-  readonly checkoutEpoch: number;
-  readonly headRef: string | null;
-  readonly headSha: string | null;
-  readonly dirty: boolean;
-  readonly observedAt: string;
-  readonly lastTransition: RepoTransition | null;
-  readonly semanticTransition: RepoSemanticTransition | null;
-  readonly workspaceOverlayId: string | null;
-  readonly workspaceOverlay: WorkspaceOverlaySummary | null;
-  readonly statusLines: readonly string[];
-}
-
-export interface RebaseProgressState {
-  readonly inProgress: boolean;
-  readonly step: number | null;
-  readonly total: number | null;
-}
-
-export interface RepoSnapshot {
-  readonly headRef: string | null;
-  readonly headSha: string | null;
-  readonly parentShas: readonly string[];
-  readonly observedAt: string;
-  readonly statusLines: readonly string[];
-  readonly dirty: boolean;
-  readonly stagedPaths: number;
-  readonly changedPaths: number;
-  readonly untrackedPaths: number;
-  readonly unmergedPaths: number;
-  readonly mergeInProgress: boolean;
-  readonly rebase: RebaseProgressState;
-  readonly headReflog: HeadReflogEntry | null;
-}
-
-export interface HeadReflogEntry {
-  readonly raw: string;
-  readonly previousSha: string | null;
-  readonly nextSha: string | null;
-  readonly timestampSec: number | null;
-  readonly subject: string;
-}

package/src/mcp/repo-state.ts

@@ -1,146 +0,0 @@
-import type { GitClient } from "../ports/git.js";
-import type { FileSystem } from "../ports/filesystem.js";
-import type { RepoObservation, RepoSnapshot } from "./repo-state-types.js";
-import { captureSnapshot } from "./repo-state-git.js";
-import { detectTransition } from "./repo-state-transition.js";
-import { buildObservation, buildSemanticTransition } from "./repo-state-observation.js";
-
-// Re-export all public types and interfaces for downstream consumers.
-export type {
-  WorldlineLayer,
-  RepoTransitionKind,
-  RepoSemanticTransitionKind,
-  RepoSemanticTransitionAuthority,
-  RepoSemanticTransitionPhase,
-  RepoTransition,
-  RepoSemanticTransition,
-  WorkspaceOverlaySummary,
-  RepoObservation,
-} from "./repo-state-types.js";
-
-/**
- * Default debounce window in milliseconds for coalescing rapid observe() calls.
- * Set to 0 (disabled) by default — callers opt in via constructor options.
- */
-const DEFAULT_OBSERVE_DEBOUNCE_MS = 0;
-
-export class RepoStateTracker {
-  private checkoutEpoch = 0;
-  private snapshot: RepoSnapshot | null = null;
-  private observation: RepoObservation = {
-    checkoutEpoch: 0,
-    headRef: null,
-    headSha: null,
-    dirty: false,
-    observedAt: new Date(0).toISOString(),
-    lastTransition: null,
-    semanticTransition: null,
-    workspaceOverlayId: null,
-    workspaceOverlay: null,
-    statusLines: [],
-  };
-  private initialization: Promise<void> | null = null;
-  private readonly startedAtSec = Math.floor(Date.now() / 1000);
-  private hasObservedTransition = false;
-
-  /** Pending observe promise used for debounce coalescing. */
-  private pendingObserve: Promise<RepoObservation> | null = null;
-  /** Timestamp of the last completed observation (ms since epoch). */
-  private lastObservedAtMs = 0;
-
-  private readonly debounceMs: number;
-
-  constructor(
-    private readonly cwd: string,
-    private readonly fs: FileSystem,
-    private readonly gitClient: GitClient,
-    options?: { debounceMs?: number },
-  ) {
-    this.debounceMs = options?.debounceMs ?? DEFAULT_OBSERVE_DEBOUNCE_MS;
-  }
-
-  /**
-   * Observe the current repo state.
-   *
-   * If another observe() call is already in flight, this returns the same
-   * pending result (coalescing). If a previous observation completed within
-   * the debounce window, the cached result is returned immediately without
-   * spawning new git processes.
-   */
-  async observe(): Promise<RepoObservation> {
-    // Coalesce: reuse an in-flight observation.
-    if (this.pendingObserve !== null) {
-      return this.pendingObserve;
-    }
-
-    // Debounce: return cached result if the last observation is fresh.
-    const elapsed = Date.now() - this.lastObservedAtMs;
-    if (this.lastObservedAtMs > 0 && elapsed < this.debounceMs) {
-      return this.observation;
-    }
-
-    this.pendingObserve = this.performObserve();
-
-    try {
-      return await this.pendingObserve;
-    } finally {
-      this.pendingObserve = null;
-    }
-  }
-
-  async initialize(): Promise<void> {
-    if (this.initialization !== null) {
-      await this.initialization;
-      return;
-    }
-
-    this.initialization = (async () => {
-      const snapshot = await captureSnapshot(this.cwd, this.fs, this.gitClient);
-      this.snapshot = snapshot;
-      this.observation = buildObservation(
-        snapshot,
-        this.checkoutEpoch,
-        null,
-        buildSemanticTransition(null, snapshot, null),
-      );
-    })();
-
-    await this.initialization;
-  }
-
-  getState(): RepoObservation {
-    return this.observation;
-  }
-
-  /** Core observation logic, separated from debounce/coalesce control. */
-  private async performObserve(): Promise<RepoObservation> {
-    await this.initialize();
-    const previousSnapshot = this.snapshot;
-    if (previousSnapshot === null) {
-      return this.observation;
-    }
-    const nextSnapshot = await captureSnapshot(this.cwd, this.fs, this.gitClient);
-    const transition = await detectTransition(
-      this.gitClient,
-      this.cwd,
-      previousSnapshot,
-      nextSnapshot,
-      this.startedAtSec,
-      !this.hasObservedTransition,
-    );
-    if (transition !== null) {
-      this.checkoutEpoch++;
-      this.hasObservedTransition = true;
-    }
-
-    this.snapshot = nextSnapshot;
-    this.observation = buildObservation(
-      nextSnapshot,
-      this.checkoutEpoch,
-      transition ?? this.observation.lastTransition,
-      buildSemanticTransition(previousSnapshot, nextSnapshot, transition),
-    );
-    this.lastObservedAtMs = Date.now();
-    return this.observation;
-  }
-}

package/src/mcp/repo-tool-job.ts

@@ -1,102 +0,0 @@
-import { z } from "zod";
-import type { GovernorTrackerSnapshot } from "../session/tracker.js";
-import type { McpToolReceipt, McpToolResult } from "./receipt.js";
-import type { ToolDefinition, ToolHandler } from "./context.js";
-import type { MetricsDelta, MetricsSnapshot } from "./metrics.js";
-import type { ObservationSnapshot } from "./cache.js";
-import type { RepoObservation } from "./repo-state.js";
-import type { WorkspaceCapabilityProfile } from "./workspace-router.js";
-import { graftDiffTool } from "./tools/graft-diff.js";
-import { sinceTool } from "./tools/since.js";
-import { mapTool } from "./tools/map.js";
-import { codeRefsTool } from "./tools/code-refs.js";
-import { codeFindTool, runCodeFind } from "./tools/code-find.js";
-import { codeShowTool, runCodeShow } from "./tools/code-show.js";
-import { safeReadTool } from "./tools/safe-read.js";
-import { fileOutlineTool } from "./tools/file-outline.js";
-import { changedSinceTool } from "./tools/changed-since.js";
-import { buildRepoToolWorkerContext, wrapWithPolicyCheck } from "./repo-tool-worker-context.js";
-
-const codeFindLiveWorkerTool: ToolDefinition = {
-  ...codeFindTool,
-  createHandler(): ToolHandler {
-    return (args, ctx) => runCodeFind(ctx, args, { allowWarp: false });
-  },
-};
-
-const codeShowLiveWorkerTool: ToolDefinition = {
-  ...codeShowTool,
-  createHandler(): ToolHandler {
-    return (args, ctx) => runCodeShow(ctx, args, { allowWarp: false });
-  },
-};
-
-const OFFLOADED_REPO_TOOL_DEFINITIONS = Object.freeze({
-  safe_read: safeReadTool,
-  file_outline: fileOutlineTool,
-  changed_since: changedSinceTool,
-  graft_diff: graftDiffTool,
-  graft_since: sinceTool,
-  graft_map: mapTool,
-  code_refs: codeRefsTool,
-  code_find_live: codeFindLiveWorkerTool,
-  code_show_live: codeShowLiveWorkerTool,
-});
-
-export type OffloadedRepoToolName = keyof typeof OFFLOADED_REPO_TOOL_DEFINITIONS;
-
-export const OFFLOADED_DAEMON_REPO_TOOL_NAMES = Object.freeze(
-  Object.keys(OFFLOADED_REPO_TOOL_DEFINITIONS) as OffloadedRepoToolName[],
-);
-
-export interface RepoToolWorkerJob {
-  readonly sessionId: string;
-  readonly workspaceSliceId: string;
-  readonly traceId: string;
-  readonly seq: number;
-  readonly startedAtMs: number;
-  readonly tool: OffloadedRepoToolName;
-  readonly args: Record<string, unknown>;
-  readonly projectRoot: string;
-  readonly graftDir: string;
-  readonly graftignorePatterns: readonly string[];
-  readonly repoId: string;
-  readonly worktreeId: string;
-  readonly gitCommonDir: string;
-  readonly writerId: string;
-  readonly capabilityProfile: WorkspaceCapabilityProfile;
-  readonly repoState: RepoObservation;
-  readonly governorSnapshot: GovernorTrackerSnapshot;
-  readonly metricsSnapshot: MetricsSnapshot;
-  readonly cacheSnapshots?: Readonly<Record<string, ObservationSnapshot>>;
-}
-
-export interface RepoToolWorkerResult {
-  readonly result: McpToolResult;
-  readonly textBytes: number;
-  readonly receipt: McpToolReceipt;
-  readonly tripwireSignals: readonly string[];
-  readonly metricsDelta: MetricsDelta;
-  readonly cacheUpdates: readonly {
-    path: string;
-    observation: ObservationSnapshot | null;
-  }[];
-}
-
-function resolveRepoToolDefinition(tool: OffloadedRepoToolName): ToolDefinition {
-  return OFFLOADED_REPO_TOOL_DEFINITIONS[tool];
-}
-
-export async function runRepoToolJob(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult> {
-  const definition = resolveRepoToolDefinition(job.tool);
-  const { ctx, takeResponse } = buildRepoToolWorkerContext(job);
-  const rawHandler = definition.createHandler();
-  const handler = definition.policyCheck === true ? wrapWithPolicyCheck(definition.name, rawHandler) : rawHandler;
-
-  if (definition.schema !== undefined) {
-    z.object(definition.schema).strict().parse(job.args);
-  }
-
-  await handler(job.args, ctx);
-  return takeResponse();
-}

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

@@ -1,215 +0,0 @@
-import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import { nodeFs } from "../adapters/node-fs.js";
-import { nodeGit } from "../adapters/node-git.js";
-import { nodeProcessRunner } from "../adapters/node-process-runner.js";
-import { createRepoPathResolver } from "../adapters/repo-paths.js";
-import { openWarp } from "../warp/open.js";
-import { GovernorTracker } from "../session/tracker.js";
-import { RefusedResult } from "../policy/types.js";
-import type { WorkspaceStatus } from "./workspace-router.js";
-import { buildReceiptResult } from "./receipt.js";
-import type { ToolContext, ToolDefinition, ToolHandler } from "./context.js";
-import { Metrics, diffMetrics } from "./metrics.js";
-import { ObservationCache } from "./cache.js";
-import { evaluateMcpPolicy } from "./policy.js";
-import { resolveRunCaptureConfig } from "./run-capture-config.js";
-import { resolveRuntimeObservabilityState } from "./runtime-observability.js";
-import { buildRuntimeCausalContext } from "./runtime-causal-context.js";
-import type { RepoToolWorkerJob, RepoToolWorkerResult } from "./repo-tool-job.js";
-
-function unsupported(name: string): never {
-  throw new Error(`${name} is not available in repo-tool worker mode`);
-}
-
-function workerStatus(job: RepoToolWorkerJob): WorkspaceStatus {
-  return {
-    sessionMode: "daemon",
-    bindState: "bound",
-    repoId: job.repoId,
-    worktreeId: job.worktreeId,
-    worktreeRoot: job.projectRoot,
-    gitCommonDir: job.gitCommonDir,
-    graftDir: job.graftDir,
-    capabilityProfile: job.capabilityProfile,
-  };
-}
-
-export function wrapWithPolicyCheck(
-  toolName: ToolDefinition["name"],
-  inner: ToolHandler,
-): ToolHandler {
-  return async (args: Record<string, unknown>, ctx: ToolContext) => {
-    const rawPath = args["path"];
-    if (typeof rawPath !== "string") 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);
-  };
-}
-
-export function buildRepoToolWorkerContext(
-  job: RepoToolWorkerJob,
-): { ctx: ToolContext; takeResponse: () => RepoToolWorkerResult } {
-  const codec = new CanonicalJsonCodec();
-  const governor = GovernorTracker.fromSnapshot(job.governorSnapshot);
-  const metrics = Metrics.fromSnapshot(job.metricsSnapshot);
-  const cache = ObservationCache.fromSnapshots(job.cacheSnapshots);
-  const trackedCachePaths = new Set<string>(Object.keys(job.cacheSnapshots ?? {}));
-  if (typeof job.args["path"] === "string") {
-    trackedCachePaths.add(createRepoPathResolver(job.projectRoot)(job.args["path"]));
-  }
-  let response: Omit<RepoToolWorkerResult, "metricsDelta" | "cacheUpdates"> | null = null;
-
-  const ctx: ToolContext = {
-    projectRoot: job.projectRoot,
-    graftDir: job.graftDir,
-    graftignorePatterns: job.graftignorePatterns,
-    governor,
-    cache,
-    metrics,
-    fs: nodeFs,
-    codec,
-    process: nodeProcessRunner,
-    git: nodeGit,
-    runCapture: resolveRunCaptureConfig({}),
-    observability: resolveRuntimeObservabilityState({ graftDir: job.graftDir }),
-    respond(tool, data) {
-      const tripwires = governor.checkTripwires();
-      const built = buildReceiptResult(tool, data, {
-        sessionId: job.sessionId,
-        traceId: job.traceId,
-        seq: job.seq,
-        latencyMs: Date.now() - job.startedAtMs,
-        codec,
-        metrics: metrics.snapshot(),
-        tripwires,
-        budget: governor.getBudget(),
-      });
-      response = {
-        result: built.result,
-        textBytes: built.textBytes,
-        receipt: built.receipt,
-        tripwireSignals: tripwires.map((wire) => wire.signal),
-      };
-      return built.result;
-    },
-    recordFootprint() {
-      // Worker-thread footprints are not collected — the main thread
-      // captures footprint via AsyncLocalStorage in the invocation engine.
-    },
-    resolvePath: createRepoPathResolver(job.projectRoot),
-    async getWarp() {
-      return { app: await openWarp({ cwd: job.projectRoot, writerId: job.writerId }), strandId: null };
-    },
-    getRepoState() {
-      return job.repoState;
-    },
-    getCausalContext() {
-      return buildRuntimeCausalContext({
-        transportSessionId: job.sessionId,
-        workspaceSliceId: job.workspaceSliceId,
-        repoId: job.repoId,
-        worktreeId: job.worktreeId,
-        checkoutEpoch: job.repoState.checkoutEpoch,
-        warpWriterId: job.writerId,
-      });
-    },
-    getPersistedLocalHistorySummary() {
-      return unsupported("getPersistedLocalHistorySummary");
-    },
-    getPersistedLocalActivityWindow() {
-      return unsupported("getPersistedLocalActivityWindow");
-    },
-    getRepoConcurrencySummary() {
-      return Promise.resolve(null);
-    },
-    getWorkspaceOverlayFooting() {
-      return unsupported("getWorkspaceOverlayFooting");
-    },
-    declareCausalAttach() {
-      return unsupported("declareCausalAttach");
-    },
-    getWorkspaceStatus() {
-      return workerStatus(job);
-    },
-    bindWorkspace() {
-      return unsupported("bindWorkspace");
-    },
-    rebindWorkspace() {
-      return unsupported("rebindWorkspace");
-    },
-    getDaemonStatus() {
-      return unsupported("getDaemonStatus");
-    },
-    listDaemonRepos() {
-      return unsupported("listDaemonRepos");
-    },
-    listDaemonSessions() {
-      return unsupported("listDaemonSessions");
-    },
-    listDaemonMonitors() {
-      return unsupported("listDaemonMonitors");
-    },
-    startMonitor() {
-      return unsupported("startMonitor");
-    },
-    pauseMonitor() {
-      return unsupported("pauseMonitor");
-    },
-    resumeMonitor() {
-      return unsupported("resumeMonitor");
-    },
-    nudgeMonitor() {
-      return unsupported("nudgeMonitor");
-    },
-    stopMonitor() {
-      return unsupported("stopMonitor");
-    },
-    listWorkspaceAuthorizations() {
-      return unsupported("listWorkspaceAuthorizations");
-    },
-    authorizeWorkspace() {
-      return unsupported("authorizeWorkspace");
-    },
-    revokeWorkspace() {
-      return unsupported("revokeWorkspace");
-    },
-  };
-
-  return {
-    ctx,
-    takeResponse() {
-      if (response === null) {
-        throw new Error(`repo-tool worker ${job.tool} completed without calling respond()`);
-      }
-      return {
-        ...response,
-        metricsDelta: diffMetrics(job.metricsSnapshot, metrics.snapshot()),
-        cacheUpdates: [...trackedCachePaths].map((filePath) => ({
-          path: filePath,
-          observation: cache.snapshotEntry(filePath),
-        })),
-      };
-    },
-  };
-}

package/src/mcp/repo-workspace.ts

@@ -1,21 +0,0 @@
-import { toRepoPolicyPath } from "../adapters/repo-paths.js";
-import { RepoWorkspace } from "../operations/repo-workspace.js";
-import type { ToolContext } from "./context.js";
-
-export function createRepoWorkspaceFromToolContext(
-  ctx: Pick<
-    ToolContext,
-    "projectRoot" | "fs" | "codec" | "graftignorePatterns" | "resolvePath" | "governor" | "cache"
-  >,
-): RepoWorkspace {
-  return new RepoWorkspace({
-    projectRoot: ctx.projectRoot,
-    fs: ctx.fs,
-    codec: ctx.codec,
-    graftignorePatterns: ctx.graftignorePatterns,
-    resolvePath: ctx.resolvePath,
-    toPolicyPath: (resolvedPath) => toRepoPolicyPath(ctx.projectRoot, resolvedPath),
-    governor: ctx.governor,
-    cache: ctx.cache,
-  });
-}

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

@@ -1,33 +0,0 @@
-export interface RunCaptureConfig {
-  readonly enabled: boolean;
-  readonly persistLogs: boolean;
-  readonly redactLogs: boolean;
-}
-
-export interface ResolveRunCaptureConfigOptions {
-  readonly env?: Readonly<Record<string, string | undefined>>;
-  readonly overrides?: Partial<RunCaptureConfig>;
-}
-
-function parseBooleanFlag(value: string | undefined, fallback: boolean): boolean {
-  if (value === undefined) return fallback;
-  const normalized = value.trim().toLowerCase();
-  if ([ "0", "false", "no", "off" ].includes(normalized)) return false;
-  if ([ "1", "true", "yes", "on" ].includes(normalized)) return true;
-  return fallback;
-}
-
-export function resolveRunCaptureConfig(
-  options: ResolveRunCaptureConfigOptions = {},
-): RunCaptureConfig {
-  const env = options.env ?? process.env;
-  const base: RunCaptureConfig = {
-    enabled: parseBooleanFlag(env["GRAFT_ENABLE_RUN_CAPTURE"], true),
-    persistLogs: parseBooleanFlag(env["GRAFT_RUN_CAPTURE_PERSIST"], true),
-    redactLogs: parseBooleanFlag(env["GRAFT_RUN_CAPTURE_REDACT"], true),
-  };
-  return {
-    ...base,
-    ...options.overrides,
-  };
-}

package/src/mcp/runtime-causal-context.ts

@@ -1,72 +0,0 @@
-import * as crypto from "node:crypto";
-
-export interface RuntimeCausalContext {
-  readonly transportSessionId: string;
-  readonly workspaceSliceId: string;
-  readonly causalSessionId: string;
-  readonly strandId: string;
-  readonly checkoutEpochId: string;
-  readonly warpWriterId: string;
-  readonly stability: "runtime_local";
-  readonly provenanceLevel: "artifact_history";
-}
-
-function stableId(prefix: string, input: string): string {
-  return `${prefix}:${crypto.createHash("sha256").update(input).digest("hex").slice(0, 16)}`;
-}
-
-export function buildCheckoutEpochId(
-  repoId: string,
-  worktreeId: string,
-  checkoutEpoch: number,
-): string {
-  return stableId("epoch", `${repoId}:${worktreeId}:${String(checkoutEpoch)}`);
-}
-
-export function buildCausalSessionId(
-  repoId: string,
-  worktreeId: string,
-  transportSessionId: string,
-  workspaceSliceId: string,
-): string {
-  return stableId("causal", `${repoId}:${worktreeId}:${transportSessionId}:${workspaceSliceId}`);
-}
-
-export function buildStrandId(
-  causalSessionId: string,
-  checkoutEpochId: string,
-  warpWriterId: string,
-): string {
-  return stableId("strand", `${causalSessionId}:${checkoutEpochId}:${warpWriterId}`);
-}
-
-export function buildRuntimeCausalContext(input: {
-  readonly transportSessionId: string;
-  readonly workspaceSliceId: string;
-  readonly repoId: string;
-  readonly worktreeId: string;
-  readonly checkoutEpoch: number;
-  readonly warpWriterId: string;
-}): RuntimeCausalContext {
-  const checkoutEpochId = buildCheckoutEpochId(
-    input.repoId,
-    input.worktreeId,
-    input.checkoutEpoch,
-  );
-  const causalSessionId = buildCausalSessionId(
-    input.repoId,
-    input.worktreeId,
-    input.transportSessionId,
-    input.workspaceSliceId,
-  );
-  return {
-    transportSessionId: input.transportSessionId,
-    workspaceSliceId: input.workspaceSliceId,
-    causalSessionId,
-    strandId: buildStrandId(causalSessionId, checkoutEpochId, input.warpWriterId),
-    checkoutEpochId,
-    warpWriterId: input.warpWriterId,
-    stability: "runtime_local",
-    provenanceLevel: "artifact_history",
-  };
-}