@stigmer/runner 3.15.3-dev.20260914100347 → 3.15.3-dev.20260916211208

package/src/shared/workspace/__tests__/git-source.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { mockWorkspaceBackend } from "../../../__test-utils__/mock-workspace.js";
 import { provisionGit } from "../sources/git.js";
-import { SourceType, WorkspaceProvisionError } from "../types.js";
+import { WorkspaceProvisionError } from "../types.js";
 
 /**
  * Command-routing mock for `backend.execute`.
@@ -55,7 +55,7 @@ describe("provisionGit", () => {
 
   it("returns GIT_REPO source type", async () => {
     const result = await provisionGit(makeOptions());
-    expect(result.sourceType).toBe(SourceType.GIT_REPO);
+    expect(result.sourceType).toBe("git_repo");
   });
 
   it("clones in place (init/remote/fetch/checkout) instead of git clone", async () => {
@@ -119,7 +119,7 @@ describe("provisionGit", () => {
     });
 
     const result = await provisionGit(makeOptions({ backend }));
-    expect(result.sourceType).toBe(SourceType.GIT_REPO);
+    expect(result.sourceType).toBe("git_repo");
     expect(result.workspaceDescription).toContain("existing repo detected");
 
     expect(calls(backend).some((c) => c.includes("git init"))).toBe(false);

package/src/shared/workspace/__tests__/provisioner.test.ts

@@ -3,7 +3,7 @@ import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readlinkSync } from
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { WorkspaceProvisioner } from "../provisioner.js";
-import { SourceType, WorkspaceProvisionError } from "../types.js";
+import { WorkspaceProvisionError } from "../types.js";
 import { LocalWorkspaceBackend } from "../local-backend.js";
 
 function makeTempDir(): string {
@@ -22,7 +22,7 @@ describe("WorkspaceProvisioner", () => {
       const root = makeTempDir();
       const backend = new LocalWorkspaceBackend(root);
       const result = await provisioner.provision(undefined, backend, {}, true);
-      expect(result.sourceType).toBe(SourceType.EMPTY);
+      expect(result.sourceType).toBe("empty");
       expect(result.rootDir).toBe(root);
       expect(result.consumedKeys).toEqual([]);
     });
@@ -34,7 +34,7 @@ describe("WorkspaceProvisioner", () => {
         { source: { case: undefined, value: undefined } },
         backend, {}, true,
       );
-      expect(result.sourceType).toBe(SourceType.EMPTY);
+      expect(result.sourceType).toBe("empty");
     });
   });
 
@@ -47,7 +47,7 @@ describe("WorkspaceProvisioner", () => {
         { source: { case: "localPath", value: { path: projectDir } } },
         backend, {}, true,
       );
-      expect(result.sourceType).toBe(SourceType.LOCAL_PATH);
+      expect(result.sourceType).toBe("local_path");
       expect(result.rootDir).toBe(projectDir);
     });
 
@@ -102,7 +102,7 @@ describe("WorkspaceProvisioner", () => {
       );
       expect(results).toHaveLength(1);
       expect(results[0].entryName).toBe("app");
-      expect(results[0].sourceType).toBe(SourceType.EMPTY);
+      expect(results[0].sourceType).toBe("empty");
     });
   });
 

package/src/shared/workspace/__tests__/session-provision.test.ts

@@ -2,8 +2,8 @@
  * Pins session workspace provisioning: git-repo workspace entries are cloned
  * locally (never delegated to a cloud agent), local-path entries are
  * mounted, and a session with no entries gets its own empty per-session root.
- * Harness-agnostic; the Cursor activity is today's only caller and the turn
- * runtime takes it over in S2 M3.
+ * Harness-agnostic; the Cursor activity was its only caller until the turn
+ * runtime took it over in #1070.
  *
  * Uses a real, hermetic local git repository (no network, no harness API) so
  * the clone is deterministic.

package/src/shared/workspace/__tests__/writeback-coordinator.integration.test.ts

@@ -20,9 +20,8 @@ import { WorkspaceWriteBackPhase } from "@stigmer/protos/ai/stigmer/agentic/agen
 import { GitWriteBackMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import { WriteBackCoordinator } from "../writeback-coordinator.js";
 import { LocalWorkspaceBackend } from "../local-backend.js";
-import { statusProtoWriter, type ExecutionStatusWriter } from "../../execution-status-writer.js";
+import { TranscriptBuilder } from "../../../harness/transcript/builder.js";
 import type { ProvisionResult } from "../types.js";
-import { SourceType } from "../types.js";
 import { AGENT_GIT_AUTHOR_EMAIL } from "../git-identity.js";
 
 const SESSION_ID = "ses-int-01";
@@ -52,11 +51,11 @@ function git(cwd: string, args: string[]): string {
 
 function makeCoordinator(
   executionId: string,
-  writer: ExecutionStatusWriter,
+  writeBacks: TranscriptBuilder,
 ): WriteBackCoordinator {
   const provisionResult: ProvisionResult = {
     rootDir: workDir,
-    sourceType: SourceType.GIT_REPO,
+    sourceType: "git_repo",
     consumedKeys: [],
     workspaceDescription: "integration",
     entryName: "repo",
@@ -68,7 +67,7 @@ function makeCoordinator(
     },
   };
   return new WriteBackCoordinator({
-    statusWriter: writer,
+    writeBacks,
     executionId,
     sessionId: SESSION_ID,
     githubToken: "ghp_test",
@@ -139,7 +138,7 @@ describe("WriteBackCoordinator against real git", () => {
       // ── Turn 1: the agent created a file; the review kept it. ──
       writeFileSync(join(workDir, "notes.md"), "approved content\n");
       const status1 = create(AgentExecutionStatusSchema, {});
-      const coord1 = makeCoordinator("exec-turn-1", statusProtoWriter(status1));
+      const coord1 = makeCoordinator("exec-turn-1", new TranscriptBuilder("exec-int", status1));
       await coord1.finalize();
 
       const wb1 = status1.workspaceWriteBacks[0];
@@ -163,7 +162,7 @@ describe("WriteBackCoordinator against real git", () => {
       rmSync(join(workDir, "rejected.md")); // the reconcile's snap-back
 
       const status2 = create(AgentExecutionStatusSchema, {});
-      const coord2 = makeCoordinator("exec-turn-2", statusProtoWriter(status2));
+      const coord2 = makeCoordinator("exec-turn-2", new TranscriptBuilder("exec-int", status2));
       await coord2.finalize();
 
       const wb2 = status2.workspaceWriteBacks[0];
@@ -200,7 +199,7 @@ describe("WriteBackCoordinator against real git", () => {
       writeFileSync(join(workDir, "notes.md"), "turn one\n");
       const coord1 = makeCoordinator(
         "exec-a",
-        statusProtoWriter(create(AgentExecutionStatusSchema, {})),
+        new TranscriptBuilder("exec-int", create(AgentExecutionStatusSchema, {})),
       );
       await coord1.finalize();
 
@@ -214,7 +213,7 @@ describe("WriteBackCoordinator against real git", () => {
       // new one from main (which would orphan turn 1's commit).
       writeFileSync(join(workDir, "more.md"), "turn two\n");
       const status2 = create(AgentExecutionStatusSchema, {});
-      const coord2 = makeCoordinator("exec-b", statusProtoWriter(status2));
+      const coord2 = makeCoordinator("exec-b", new TranscriptBuilder("exec-int", status2));
       await coord2.finalize();
 
       expect(status2.workspaceWriteBacks[0].branchName).toBe(SESSION_BRANCH);

package/src/shared/workspace/__tests__/writeback-coordinator.test.ts

@@ -1,18 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { create } from "@bufbuild/protobuf";
-import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { type AgentExecutionStatus, AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { WorkspaceWriteBackPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/writeback_pb";
 import { GitWriteBackMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
-import {
-  statusProtoWriter,
-  type ExecutionStatusWriter,
-} from "../../execution-status-writer.js";
+import { TranscriptBuilder } from "../../../harness/transcript/builder.js";
 import {
   WriteBackCoordinator,
   parseGithubRepo,
 } from "../writeback-coordinator.js";
 import type { WorkspaceBackend, ProvisionResult } from "../types.js";
-import { SourceType } from "../types.js";
 import {
   AGENT_GIT_AUTHOR_NAME,
   AGENT_GIT_AUTHOR_EMAIL,
@@ -21,16 +17,19 @@ import {
 const SESSION_ID = "ses-01test";
 const SESSION_BRANCH = `stigmer/${SESSION_ID}`;
 
-// The shared proto-backed writer — the same implementation the Cursor harness
-// wires in, and upsert-compatible with the deep-agent V3StatusBuilder.
-function makeStatusBuilder(): ExecutionStatusWriter {
-  return statusProtoWriter(create(AgentExecutionStatusSchema, {}));
+// The writer production wires in: the turn's transcript builder, whose
+// `addWriteBack` owns the upsert-by-entry rule these arms read the result of
+// (the coordinator itself only registers records through `WriteBackSink`).
+/** A builder and the status it builds into: the test writes through `sb` and reads `status`, as production reads `TurnSink.status`. */
+function makeStatusBuilder(): { sb: TranscriptBuilder; status: AgentExecutionStatus } {
+  const status = create(AgentExecutionStatusSchema, {});
+  return { sb: new TranscriptBuilder("exec-test", status), status };
 }
 
 function makeProvisionResult(overrides: Partial<ProvisionResult> = {}): ProvisionResult {
   return {
     rootDir: "/workspace/my-app",
-    sourceType: SourceType.GIT_REPO,
+    sourceType: "git_repo",
     consumedKeys: [],
     workspaceDescription: "test",
     entryName: "my-app",
@@ -92,7 +91,7 @@ function mockWorkspaceBackend(responses: Record<string, string> = {}): Workspace
 }
 
 function makeCoordinator(opts: {
-  sb: ExecutionStatusWriter;
+  sb: TranscriptBuilder;
   backend?: WorkspaceBackend;
   executionId?: string;
   sessionId?: string;
@@ -101,7 +100,7 @@ function makeCoordinator(opts: {
   workspaceEntries?: any[];
 }): WriteBackCoordinator {
   return new WriteBackCoordinator({
-    statusWriter: opts.sb,
+    writeBacks: opts.sb,
     executionId: opts.executionId ?? "exec-12345678rest",
     sessionId: opts.sessionId ?? SESSION_ID,
     githubToken: opts.githubToken ?? "ghp_plumbed_token",
@@ -139,10 +138,11 @@ function mockGithubApi(opts: {
 const originalFetch = globalThis.fetch;
 
 describe("WriteBackCoordinator", () => {
-  let sb: ExecutionStatusWriter;
+  let sb: TranscriptBuilder;
+  let status: AgentExecutionStatus;
 
   beforeEach(() => {
-    sb = makeStatusBuilder();
+    ({ sb, status } = makeStatusBuilder());
     mockGithubApi();
   });
 
@@ -155,7 +155,7 @@ describe("WriteBackCoordinator", () => {
   it("filters out non-git workspace entries", () => {
     const coord = makeCoordinator({
       sb,
-      provisionResults: [makeProvisionResult({ sourceType: SourceType.LOCAL_PATH })],
+      provisionResults: [makeProvisionResult({ sourceType: "local_path" })],
     });
     expect(coord.hasEligibleEntries).toBe(false);
   });
@@ -186,7 +186,7 @@ describe("WriteBackCoordinator", () => {
   // ── Full cycle ──────────────────────────────────────────────────────
 
   // Every cycle below runs through `finalize()`, the coordinator's one entry
-  // point since S3 M2b (Q-M1-1; the per-file `onFileModified` went with the
+  // point since #1096 (the per-file `onFileModified` went with the
   // native stream loop that called it). The mechanics it pins are the same.
   it("performs full cycle on the SESSION branch: branch -> commit -> push -> PR", async () => {
     const backend = mockWorkspaceBackend();
@@ -194,7 +194,7 @@ describe("WriteBackCoordinator", () => {
 
     await coord.finalize();
 
-    const wbs = sb.currentStatus.workspaceWriteBacks;
+    const wbs = status.workspaceWriteBacks;
     expect(wbs).toHaveLength(1);
     expect(wbs[0].branchName).toBe(SESSION_BRANCH);
     expect(wbs[0].baseBranch).toBe("main");
@@ -238,7 +238,7 @@ describe("WriteBackCoordinator", () => {
 
     await coord.finalize();
 
-    expect(sb.currentStatus.workspaceWriteBacks).toHaveLength(0);
+    expect(status.workspaceWriteBacks).toHaveLength(0);
   });
 
   // ── Session-branch idempotency ──────────────────────────────────────
@@ -317,7 +317,7 @@ describe("WriteBackCoordinator", () => {
 
     await coord.finalize();
 
-    const wbs = sb.currentStatus.workspaceWriteBacks;
+    const wbs = status.workspaceWriteBacks;
     expect(wbs[0].pullRequestNumber).toBe(7);
     expect(wbs[0].pullRequestUrl).toBe("https://github.com/acme/my-app/pull/7");
     expect(wbs[0].phase).toBe(WorkspaceWriteBackPhase.WORKSPACE_WRITE_BACK_PR_CREATED);
@@ -355,7 +355,7 @@ describe("WriteBackCoordinator", () => {
 
     await coord.finalize();
 
-    const wbs = sb.currentStatus.workspaceWriteBacks;
+    const wbs = status.workspaceWriteBacks;
     expect(wbs).toHaveLength(1);
     expect(wbs[0].phase).toBe(WorkspaceWriteBackPhase.WORKSPACE_WRITE_BACK_FAILED);
     expect(wbs[0].error).toContain("commit failed");
@@ -369,7 +369,7 @@ describe("WriteBackCoordinator", () => {
 
     await coord.finalize();
 
-    const wbs = sb.currentStatus.workspaceWriteBacks;
+    const wbs = status.workspaceWriteBacks;
     expect(wbs).toHaveLength(1);
     expect(wbs[0].phase,
       "a pushed branch must never be reported FAILED for a PR-step error",
@@ -386,7 +386,7 @@ describe("WriteBackCoordinator", () => {
 
     await coord.finalize();
 
-    const wbs = sb.currentStatus.workspaceWriteBacks;
+    const wbs = status.workspaceWriteBacks;
     expect(wbs).toHaveLength(1);
     expect(wbs[0].phase).toBe(WorkspaceWriteBackPhase.WORKSPACE_WRITE_BACK_PUSHED);
     expect(wbs[0].error).toContain("No GitHub token");
@@ -401,8 +401,8 @@ describe("WriteBackCoordinator", () => {
 
     await coord.finalize();
 
-    expect(sb.currentStatus.workspaceWriteBacks).toHaveLength(1);
-    expect(sb.currentStatus.workspaceWriteBacks[0].phase).toBe(
+    expect(status.workspaceWriteBacks).toHaveLength(1);
+    expect(status.workspaceWriteBacks[0].phase).toBe(
       WorkspaceWriteBackPhase.WORKSPACE_WRITE_BACK_PR_CREATED,
     );
   });

package/src/shared/workspace/provisioner.ts

@@ -15,7 +15,7 @@
  */
 
 import type { ProvisionResult, WorkspaceBackend } from "./types.js";
-import { SourceType, WorkspaceProvisionError } from "./types.js";
+import { WorkspaceProvisionError } from "./types.js";
 import { provisionEmpty } from "./sources/empty.js";
 import { provisionLocalPath } from "./sources/local-path.js";
 import { provisionGit } from "./sources/git.js";

package/src/shared/workspace/session-provision.ts

@@ -3,7 +3,7 @@
  *
  * Harness-agnostic: the turn runtime's workspace phase, serving both
  * adapters (the native orchestrator's twin, `provisionWorkspace`, retired
- * with it at S3 M2b; Q-S3-8 carried its one difference). Agents run LOCAL
+ * with it in #1096, which also carried its one difference). Agents run LOCAL
  * (cloud is disabled — see execute-cursor/cursor-mode.ts), so the runner
  * must clone git-repo workspace entries itself and mount local-path entries
  * before the agent runs. Cloud agents previously cloned git repos

package/src/shared/workspace/sources/empty.ts

@@ -5,12 +5,12 @@
  * This handler simply records the fact and returns the existing root.
  */
 
-import { SourceType, type ProvisionResult, type WorkspaceBackend } from "../types.js";
+import type { ProvisionResult, WorkspaceBackend } from "../types.js";
 
 export function provisionEmpty(backend: WorkspaceBackend): ProvisionResult {
   return {
     rootDir: backend.rootDir,
-    sourceType: SourceType.EMPTY,
+    sourceType: "empty",
     consumedKeys: [],
     workspaceDescription:
       "Your workspace is empty. " +

package/src/shared/workspace/sources/git.ts

@@ -12,7 +12,6 @@
 
 import { join } from "node:path";
 import {
-  SourceType,
   WorkspaceProvisionError,
   type ProvisionResult,
   type GitMetadata,
@@ -63,7 +62,7 @@ export async function provisionGit(options: GitProvisionOptions): Promise<Provis
       ? message.replaceAll(githubToken, "***")
       : message;
     throw new WorkspaceProvisionError(
-      SourceType.GIT_REPO,
+      "git_repo",
       `Git clone failed: ${sanitized}`,
       { cause: err instanceof Error ? err : undefined, transient: true },
     );
@@ -82,7 +81,7 @@ export async function provisionGit(options: GitProvisionOptions): Promise<Provis
 
   return {
     rootDir: cloneDir,
-    sourceType: SourceType.GIT_REPO,
+    sourceType: "git_repo",
     consumedKeys,
     workspaceDescription:
       `Your workspace is a git clone of ${url}` +
@@ -113,7 +112,7 @@ async function reuseExistingRepo(
 
   return {
     rootDir: cloneDir,
-    sourceType: SourceType.GIT_REPO,
+    sourceType: "git_repo",
     consumedKeys: [],
     workspaceDescription:
       `Your workspace is a git clone of ${url}` +

package/src/shared/workspace/sources/local-path.ts

@@ -12,7 +12,6 @@ import { existsSync, statSync, symlinkSync, readlinkSync, unlinkSync, mkdirSync
 import { join, isAbsolute } from "node:path";
 import { realpathSync } from "node:fs";
 import {
-  SourceType,
   WorkspaceProvisionError,
   type ProvisionResult,
 } from "../types.js";
@@ -29,7 +28,7 @@ export function provisionLocalPath(options: LocalPathProvisionOptions): Provisio
 
   if (!isLocalMode) {
     throw new WorkspaceProvisionError(
-      SourceType.LOCAL_PATH,
+      "local_path",
       "LocalPathSource is only supported in local mode. " +
       "Use git_repo for cloud deployments.",
     );
@@ -37,21 +36,21 @@ export function provisionLocalPath(options: LocalPathProvisionOptions): Provisio
 
   if (!isAbsolute(path)) {
     throw new WorkspaceProvisionError(
-      SourceType.LOCAL_PATH,
+      "local_path",
       `Path must be absolute, got relative path: '${path}'`,
     );
   }
 
   if (!existsSync(path)) {
     throw new WorkspaceProvisionError(
-      SourceType.LOCAL_PATH,
+      "local_path",
       `Path does not exist: '${path}'`,
     );
   }
 
   if (!statSync(path).isDirectory()) {
     throw new WorkspaceProvisionError(
-      SourceType.LOCAL_PATH,
+      "local_path",
       `Path is not a directory: '${path}'`,
     );
   }
@@ -62,7 +61,7 @@ export function provisionLocalPath(options: LocalPathProvisionOptions): Provisio
 
   return {
     rootDir: path,
-    sourceType: SourceType.LOCAL_PATH,
+    sourceType: "local_path",
     consumedKeys: [],
     workspaceDescription:
       `Your workspace is the user's project directory: ${path}\n` +

package/src/shared/workspace/stigmer-link.ts

@@ -17,7 +17,7 @@
  *   working-tree mutation, and re-pointing it while another session's turn is
  *   running on a shared tree would redirect that turn's reads mid-flight.
  *   the turn runtime creates it in its skill and attachment phases (which
- *   run after lock acquisition), for both harnesses; until S3 M2a the native
+ *   run after lock acquisition), for both harnesses; until #1096 the native
  *   orchestrator created it unconditionally right after the lock.
  * - Removed at turn end ({@link removeStigmerSymlink} in the activity's
  *   cleanup), so a real repo is left untouched once the turn ends; a

package/src/shared/workspace/types.ts

@@ -5,11 +5,8 @@
  * harness-agnostic and used by both ExecuteCursor and ExecuteDeepAgent.
  */
 
-export enum SourceType {
-  GIT_REPO = "git_repo",
-  LOCAL_PATH = "local_path",
-  EMPTY = "empty",
-}
+/** Where a provisioned workspace came from; the same strings the error prefix and the prompt builder read. */
+export type SourceType = "git_repo" | "local_path" | "empty";
 
 export interface GitMetadata {
   readonly repoUrl: string;

package/src/shared/workspace/writeback-coordinator.ts

@@ -18,7 +18,7 @@
  * (`harness/run-turn.ts`) — in capture mode on the APPROVED tree after the
  * review decisions reconcile, so speculative mid-turn edits never reach
  * GitHub; on a non-capture git turn on whatever the turn left in the tree.
- * Until S3 M2b (Q-M1-1) an incremental path also existed — `onFileModified`,
+ * Until #1096 an incremental path also existed — `onFileModified`,
  * a commit-and-push per file-modifying tool call on non-capture turns — and
  * was reachable in no supported posture (every git workspace with artifact
  * storage is a capture workspace, `shared/filereview/capture.ts`
@@ -29,18 +29,29 @@
  */
 
 import { create } from "@bufbuild/protobuf";
-import {
-  WorkspaceWriteBackSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/writeback_pb";
 import {
   WorkspaceWriteBackPhase,
+  WorkspaceWriteBackSchema,
+  type WorkspaceWriteBack,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/writeback_pb";
 import { GitWriteBackMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import type { WorkspaceBackend, ProvisionResult } from "./types.js";
-import { SourceType } from "./types.js";
 import { gitCommitAsAgent } from "./git-identity.js";
-import type { ExecutionStatusWriter } from "../execution-status-writer.js";
+
+/**
+ * Where a write-back record is registered: the one member of the turn's
+ * transcript builder this coordinator needs (`harness/transcript/builder.ts`
+ * `addWriteBack`, which owns the upsert-by-entry rule — each git-backed
+ * workspace entry carries at most one record, progressing through phases).
+ * Declared here as the narrow view this consumer needs, never the whole
+ * builder, so `shared/` keeps importing nothing from `harness/` (the
+ * `SessionProvisionConfig` rule: a shared helper is handed a narrowed view,
+ * never the other way round).
+ */
+export interface WriteBackSink {
+  addWriteBack(wb: WorkspaceWriteBack): void;
+}
 
 const WRITE_BACK_ENABLED_MODES = new Set([
   GitWriteBackMode.GIT_WRITE_BACK_MODE_UNSPECIFIED,
@@ -68,7 +79,7 @@ interface EligibleEntry {
 }
 
 export class WriteBackCoordinator {
-  private readonly statusWriter: ExecutionStatusWriter;
+  private readonly writeBacks: WriteBackSink;
   private readonly executionId: string;
   private readonly workspaceBackend: WorkspaceBackend;
   private readonly branchName: string;
@@ -85,7 +96,7 @@ export class WriteBackCoordinator {
   private readonly state = new Map<string, EntryState>();
 
   constructor(opts: {
-    statusWriter: ExecutionStatusWriter;
+    writeBacks: WriteBackSink;
     executionId: string;
     /** The owning session's id — the branch/PR are session-scoped. */
     sessionId: string;
@@ -94,7 +105,7 @@ export class WriteBackCoordinator {
     workspaceEntries: readonly WorkspaceEntry[];
     workspaceBackend: WorkspaceBackend;
   }) {
-    this.statusWriter = opts.statusWriter;
+    this.writeBacks = opts.writeBacks;
     this.executionId = opts.executionId;
     this.workspaceBackend = opts.workspaceBackend;
     this.githubToken = opts.githubToken;
@@ -143,7 +154,7 @@ export class WriteBackCoordinator {
     }
 
     for (const pr of provisionResults) {
-      if (pr.sourceType !== SourceType.GIT_REPO) continue;
+      if (pr.sourceType !== "git_repo") continue;
       if (!pr.gitMetadata) continue;
       if (!pr.gitMetadata.gitCredentialsConfigured) continue;
 
@@ -222,7 +233,7 @@ export class WriteBackCoordinator {
         wb.pullRequestUrl = entryState.prUrl;
         wb.pullRequestNumber = entryState.prNumber;
       }
-      this.statusWriter.addWriteBack(wb);
+      this.writeBacks.addWriteBack(wb);
       return;
     }
 
@@ -466,7 +477,7 @@ export class WriteBackCoordinator {
       error: prError,
     });
 
-    this.statusWriter.addWriteBack(wb);
+    this.writeBacks.addWriteBack(wb);
   }
 
 }

package/dist/activities/execute-cursor/delta-enricher.d.ts

@@ -1,87 +0,0 @@
-/**
- * DeltaEnricher processes Cursor SDK InteractionUpdate events to provide
- * real-time enrichments that the stream channel alone cannot deliver.
- *
- * The Cursor SDK provides two concurrent event channels:
- *   - run.stream() (SDKMessage) — coarse-grained, post-hoc events
- *   - onDelta (InteractionUpdate) — fine-grained, real-time deltas
- *
- * The stream channel remains the source of truth for message construction.
- * The delta channel provides supplementary real-time signals:
- *   - shell-output-delta: live stdout/stderr from running shell commands
- *   - tool-call-started/completed: precise lifecycle timestamps
- *   - thinking-completed: accurate thinking duration from the SDK
- *
- * Concurrency model: Node.js is single-threaded. The onDelta callback fires
- * between iterations of the for-await stream loop (during event loop yields).
- * The enricher buffers data internally; the stream loop calls
- * applyEnrichments() on each iteration to flush buffered state onto the
- * message array. No locks needed — access is always sequential.
- *
- * Design invariant: The enricher never creates messages or tool calls.
- * It only mutates existing ones that the MessageAccumulator has created.
- * If a delta arrives before its corresponding stream event (e.g.,
- * shell-output-delta before tool_call running), the data is buffered
- * and applied retroactively on the next applyEnrichments() call that
- * finds the matching ToolCall.
- */
-import type { AgentMessage } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import type { InteractionUpdate } from "@cursor/sdk";
-export declare class DeltaEnricher {
-    private shellOutputByCallId;
-    private timingByCallId;
-    private thinkingDurationMs;
-    private _isDirty;
-    private lastPersistTime;
-    private lastShellCallId;
-    /**
-     * Minimum interval between persist-triggering dirty flags (milliseconds).
-     * Prevents excessive backend writes during rapid shell output bursts.
-     * Matches the Python agent-runner's update_scheduler interval.
-     */
-    static readonly PERSIST_DEBOUNCE_MS = 500;
-    /**
-     * Process a single InteractionUpdate from the onDelta callback.
-     * Buffers enrichment data for later application by applyEnrichments().
-     *
-     * Called from the onDelta callback (between stream loop iterations).
-     */
-    processDelta(update: InteractionUpdate): void;
-    /**
-     * Apply all buffered enrichments to the current message array.
-     * Called from the stream loop after each processEvent() iteration.
-     *
-     * Returns true if any enrichments were applied (messages were mutated).
-     */
-    applyEnrichments(messages: AgentMessage[]): boolean;
-    /**
-     * Whether the enricher has pending data that warrants an immediate persist.
-     * Only returns true when meaningful UI-visible data has arrived AND the
-     * debounce interval has elapsed since the last persist.
-     */
-    get isDirty(): boolean;
-    /**
-     * Acknowledge that a persist has occurred. Resets the dirty flag and
-     * records the persist timestamp for debounce calculations.
-     */
-    markPersisted(): void;
-    /**
-     * Finalize streaming state and reconcile tool call statuses.
-     *
-     * Called after the stream loop ends (alongside accumulator.finalize()).
-     * Two passes:
-     *   1. Clear `isStreaming` on all tool calls (existing behavior).
-     *   2. Reconciliation sweep: any tool call still RUNNING with evidence
-     *      of completion (completedAt set or result non-empty) is promoted
-     *      to COMPLETED. This is the catch-all safety net — when the stream
-     *      ends, no tool call should remain in a non-terminal status.
-     */
-    finalize(messages: AgentMessage[]): void;
-    private handleShellOutputDelta;
-    private handleToolCallStarted;
-    private handleToolCallCompleted;
-    private getOrCreateTiming;
-    private applyShellOutput;
-    private applyTiming;
-    private applyThinkingDuration;
-}