gsd-pi 2.74.0-dev.28a6415 → 2.74.0-dev.658744a

package/src/resources/extensions/gsd/tests/artifacts-table-preserved-on-cache-invalidate.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Regression test: invalidateAllCaches() must NOT wipe the artifacts table.
+ *
+ * Prior to this fix, `cache.ts` bundled `clearArtifacts()` (which runs
+ * `DELETE FROM artifacts`) into `invalidateAllCaches()`. That helper fires
+ * on every post-unit pass, so rows written by `saveArtifactToDb` and
+ * `writeAndStore` (RESEARCH, CONTEXT, VALIDATION, ASSESSMENT, PLAN,
+ * ROADMAP, task PLAN, task SUMMARY) got deleted within seconds of being
+ * written. The milestone completed on disk, but `SELECT COUNT(*) FROM
+ * artifacts` returned 0, and the agent fell into a "file exists but DB
+ * record missing" recovery loop.
+ *
+ * The artifacts table is a write-through store, not a read cache. Routine
+ * cache invalidation must preserve its contents.
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertArtifact,
+  isDbAvailable,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+afterEach(() => {
+  if (isDbAvailable()) {
+    try {
+      closeDatabase();
+    } catch {
+      /* best-effort teardown */
+    }
+  }
+});
+
+describe("invalidateAllCaches() must preserve the artifacts table", () => {
+  test("rows survive a single invalidate call", () => {
+    const opened = openDatabase(":memory:");
+    assert.equal(opened, true, "in-memory DB must open");
+
+    insertArtifact({
+      path: "milestones/M001/slices/S01/S01-RESEARCH.md",
+      artifact_type: "RESEARCH",
+      milestone_id: "M001",
+      slice_id: "S01",
+      task_id: null,
+      full_content: "# Research\n\nFindings go here.\n",
+    });
+
+    invalidateAllCaches();
+
+    const adapter = _getAdapter();
+    assert.ok(adapter, "adapter should be available");
+    const row = adapter!
+      .prepare(
+        "SELECT path, artifact_type, length(full_content) AS len FROM artifacts WHERE path = :path",
+      )
+      .get({ ":path": "milestones/M001/slices/S01/S01-RESEARCH.md" }) as
+      | { path: string; artifact_type: string; len: number }
+      | undefined;
+
+    assert.ok(
+      row,
+      "artifact row must still exist after invalidateAllCaches — this is the Phase B bug",
+    );
+    assert.equal(row!.artifact_type, "RESEARCH");
+    assert.ok((row!.len ?? 0) > 0, "full_content must not be truncated");
+  });
+
+  test("multiple rows for a full milestone survive repeated invalidates", () => {
+    openDatabase(":memory:");
+
+    const inserts = [
+      {
+        path: "milestones/M001/M001-ROADMAP.md",
+        artifact_type: "ROADMAP",
+        milestone_id: "M001",
+        slice_id: null,
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/S01-RESEARCH.md",
+        artifact_type: "RESEARCH",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/S01-PLAN.md",
+        artifact_type: "PLAN",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/tasks/T01-PLAN.md",
+        artifact_type: "PLAN",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: "T01",
+      },
+      {
+        path: "milestones/M001/slices/S01/tasks/T01-SUMMARY.md",
+        artifact_type: "SUMMARY",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: "T01",
+      },
+      {
+        path: "milestones/M001/M001-SUMMARY.md",
+        artifact_type: "SUMMARY",
+        milestone_id: "M001",
+        slice_id: null,
+        task_id: null,
+      },
+    ];
+
+    for (const i of inserts) {
+      insertArtifact({ ...i, full_content: `# ${i.artifact_type} content\n` });
+    }
+
+    // Simulate a full milestone's worth of post-unit cycles.
+    for (let i = 0; i < 10; i++) {
+      invalidateAllCaches();
+    }
+
+    const adapter = _getAdapter()!;
+    const count = (
+      adapter.prepare("SELECT COUNT(*) AS n FROM artifacts").get() as { n: number }
+    ).n;
+
+    assert.equal(
+      count,
+      inserts.length,
+      `all ${inserts.length} artifact rows must survive repeated invalidate calls; got ${count}`,
+    );
+  });
+});
+
+describe("cache.ts must not re-import clearArtifacts into invalidateAllCaches", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "cache.ts"),
+    "utf-8",
+  );
+
+  test("clearArtifacts is not imported from gsd-db", () => {
+    assert.ok(
+      !/import\s*\{[^}]*clearArtifacts[^}]*\}\s*from\s*['"]\.\/gsd-db/.test(src),
+      "cache.ts must not import clearArtifacts — it causes the artifacts-table-wipe regression",
+    );
+  });
+
+  test("invalidateAllCaches does not call clearArtifacts", () => {
+    const fnIdx = src.indexOf("function invalidateAllCaches");
+    assert.ok(fnIdx !== -1);
+    const body = src.slice(fnIdx, fnIdx + 1000);
+    assert.ok(
+      !/\bclearArtifacts\s*\(/.test(body),
+      "invalidateAllCaches must not call clearArtifacts() — it wipes the write-through store",
+    );
+  });
+
+  test("cache.ts documents why clearArtifacts is not bundled here", () => {
+    // Future reviewers need to see the rationale or they'll re-add it.
+    assert.ok(
+      /artifacts.*NOT included|write-through store/i.test(src),
+      "cache.ts must explain why the artifacts table is NOT invalidated here",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/auto-retry-mcp-churn-fixes.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Regression tests for PR #4288 — auto-retry bug, .mcp.json churn, and MCP
+ * worktree routing fixes.
+ *
+ * Covers four source-file changes:
+ *   1. src/resources/extensions/gsd/safety/evidence-collector.ts (functional)
+ *   2. src/resources/extensions/gsd/bootstrap/register-hooks.ts (source shape)
+ *   3. src/resources/extensions/gsd/auto-recovery.ts (source shape)
+ *   4. packages/mcp-server/src/workflow-tools.ts (source shape)
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import {
+  resetEvidence,
+  getEvidence,
+  recordToolCall,
+  recordToolResult,
+  type BashEvidence,
+} from "../safety/evidence-collector.js";
+
+// ─── 1. evidence-collector: functional ─────────────────────────────────────
+
+describe("evidence-collector: toolCallId-based matching (A-3)", () => {
+  beforeEach(() => {
+    resetEvidence();
+  });
+
+  it("records bash calls with their toolCallId at dispatch time", () => {
+    recordToolCall("tc-1", "bash", { command: "ls -la" });
+    recordToolCall("tc-2", "bash", { command: "git status" });
+
+    const entries = getEvidence();
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].toolCallId, "tc-1");
+    assert.equal(entries[1].toolCallId, "tc-2");
+  });
+
+  it("matches results to the correct entry by toolCallId, not insertion order", () => {
+    // Simulate two parallel bash calls dispatched in order tc-1, tc-2.
+    recordToolCall("tc-1", "bash", { command: "slow-thing" });
+    recordToolCall("tc-2", "bash", { command: "fast-thing" });
+
+    // Results arrive out of order: tc-2 first (fast), then tc-1 (slow).
+    // With the old empty-string-matching strategy, tc-2's result would be
+    // stapled to tc-1's entry because findLastUnresolved scanned backwards
+    // for empty ids. Now we match by id directly.
+    recordToolResult("tc-2", "bash", "Command exited with code 0\nfast-output", false);
+    recordToolResult("tc-1", "bash", "Command exited with code 1\nslow-failure", true);
+
+    const entries = getEvidence() as readonly BashEvidence[];
+    const tc1 = entries.find(e => e.toolCallId === "tc-1") as BashEvidence | undefined;
+    const tc2 = entries.find(e => e.toolCallId === "tc-2") as BashEvidence | undefined;
+
+    assert.ok(tc1, "tc-1 entry must exist");
+    assert.ok(tc2, "tc-2 entry must exist");
+
+    // The original command stays attached to the entry it was recorded with,
+    // and the result matches the id it was reported for.
+    assert.equal(tc1.command, "slow-thing");
+    assert.equal(tc1.exitCode, 1);
+    assert.ok(tc1.outputSnippet.includes("slow-failure"));
+
+    assert.equal(tc2.command, "fast-thing");
+    assert.equal(tc2.exitCode, 0);
+    assert.ok(tc2.outputSnippet.includes("fast-output"));
+  });
+
+  it("ignores results with unknown toolCallIds rather than corrupting nearby entries", () => {
+    recordToolCall("tc-1", "bash", { command: "real" });
+    recordToolResult("tc-UNKNOWN", "bash", "Command exited with code 0\n", false);
+
+    const entries = getEvidence() as readonly BashEvidence[];
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].toolCallId, "tc-1");
+    // tc-1 must be untouched — no result was reported for it.
+    assert.equal(entries[0].exitCode, -1);
+    assert.equal(entries[0].outputSnippet, "");
+  });
+
+  it("records write/edit entries with their toolCallId", () => {
+    recordToolCall("tc-write", "write", { file_path: "/tmp/a.md" });
+    recordToolCall("tc-edit", "edit", { file_path: "/tmp/b.md" });
+
+    const entries = getEvidence();
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].kind, "write");
+    assert.equal(entries[0].toolCallId, "tc-write");
+    assert.equal(entries[1].kind, "edit");
+    assert.equal(entries[1].toolCallId, "tc-edit");
+  });
+});
+
+// ─── 2. register-hooks: MCP auto-prep gated inside auto-worktrees (A-1) ────
+
+describe("register-hooks: skip prepareWorkflowMcpForProject inside auto-worktrees (A-1)", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "bootstrap", "register-hooks.ts"),
+    "utf-8",
+  );
+
+  it("session_start hook is gated on isInAutoWorktree", () => {
+    const idx = src.indexOf('pi.on("session_start"');
+    assert.ok(idx !== -1, "session_start handler must exist");
+    const block = src.slice(idx, idx + 2500);
+    assert.ok(
+      block.includes("isInAutoWorktree"),
+      "session_start must consult isInAutoWorktree before preparing MCP",
+    );
+    assert.ok(
+      block.includes("prepareWorkflowMcpForProject"),
+      "session_start still prepares MCP for non-worktree paths",
+    );
+  });
+
+  it("session_switch hook is gated on isInAutoWorktree", () => {
+    const idx = src.indexOf('pi.on("session_switch"');
+    assert.ok(idx !== -1, "session_switch handler must exist");
+    const block = src.slice(idx, idx + 2500);
+    assert.ok(
+      block.includes("isInAutoWorktree"),
+      "session_switch must consult isInAutoWorktree before preparing MCP",
+    );
+  });
+
+  it("tool_call hook forwards event.toolCallId into safetyRecordToolCall (A-3)", () => {
+    // Find the call site (skip the import line by looking for the opening paren).
+    const idx = src.indexOf("safetyRecordToolCall(");
+    assert.ok(idx !== -1, "safetyRecordToolCall call must exist");
+    const line = src.slice(idx, src.indexOf("\n", idx));
+    assert.ok(
+      line.includes("event.toolCallId"),
+      "safetyRecordToolCall must receive event.toolCallId as the first argument",
+    );
+  });
+});
+
+// ─── 3. auto-recovery: verify-fail instrumentation ─────────────────────────
+
+describe("verifyExpectedArtifact: verify-fail exit-point logging (Phase B diag)", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "auto-recovery.ts"),
+    "utf-8",
+  );
+
+  it("logs a verify-fail warning on the null-absPath exit", () => {
+    assert.ok(
+      src.includes('verify-fail ${unitType} ${unitId}: resolveExpectedArtifactPath returned null'),
+      "null-absPath branch must emit a diagnostic line",
+    );
+  });
+
+  it("logs a verify-fail warning on the existsSync-false exit", () => {
+    assert.ok(
+      src.includes("verify-fail ${unitType} ${unitId}: existsSync false"),
+      "existsSync-false branch must emit a diagnostic line",
+    );
+  });
+
+  it("logs a verify-fail warning on the plan-slice no-task-entry exit", () => {
+    assert.ok(
+      src.includes("verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading"),
+      "plan-slice no-task branch must emit a diagnostic line",
+    );
+  });
+
+  it("plan-slice task-plan-files check fails fast on missing tasks dir (hardening)", () => {
+    // The original check silently passed when resolveTasksDir returned null.
+    // The new check returns false with a diagnostic, which is correct — if
+    // the tool successfully planned tasks, the tasks/ dir must exist.
+    const idx = src.indexOf('verify-fail ${unitType} ${unitId}: resolveTasksDir returned null');
+    assert.ok(
+      idx !== -1,
+      "resolveTasksDir-null branch must emit a diagnostic and return false",
+    );
+  });
+});
+
+// ─── 4. workflow-tools (mcp-server): guard + optional projectDir + routing ─
+
+describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "packages", "mcp-server", "src", "workflow-tools.ts"),
+    "utf-8",
+  );
+
+  it("projectDirParam is optional and documents the default", () => {
+    const idx = src.indexOf("const projectDirParam");
+    assert.ok(idx !== -1, "projectDirParam definition must exist");
+    const block = src.slice(idx, idx + 600);
+    assert.ok(
+      block.includes(".optional()"),
+      "projectDirParam must be optional so the agent stops deliberating",
+    );
+    assert.ok(
+      /Omit this field/i.test(block),
+      "description must tell the agent to omit the field",
+    );
+  });
+
+  it("parseWorkflowArgs defaults projectDir to process.cwd() when omitted", () => {
+    const idx = src.indexOf("function parseWorkflowArgs");
+    assert.ok(idx !== -1, "parseWorkflowArgs must exist");
+    const block = src.slice(idx, idx + 1500);
+    assert.ok(
+      block.includes("parsed.projectDir ?? process.cwd()"),
+      "parseWorkflowArgs must fall back to process.cwd() when projectDir is omitted",
+    );
+  });
+
+  it("validateProjectDir accepts external-state worktree paths via .gsd symlink target", () => {
+    const idx = src.indexOf("function validateProjectDir");
+    assert.ok(idx !== -1, "validateProjectDir must exist");
+    const block = src.slice(idx, idx + 2500);
+    assert.ok(
+      block.includes("resolveExternalStateRoot"),
+      "validateProjectDir must consult resolveExternalStateRoot for external-state layouts",
+    );
+
+    const helperIdx = src.indexOf("function resolveExternalStateRoot");
+    assert.ok(helperIdx !== -1, "resolveExternalStateRoot helper must exist");
+    const helperBlock = src.slice(helperIdx, helperIdx + 600);
+    assert.ok(
+      helperBlock.includes("realpathSync"),
+      "resolveExternalStateRoot must use realpathSync to follow the symlink",
+    );
+    assert.ok(
+      /join\([^)]*\.gsd/.test(helperBlock),
+      "resolveExternalStateRoot must resolve <allowedRoot>/.gsd",
+    );
+  });
+
+  it("parseWorkflowArgs routes tool writes to the active worktree when one exists", () => {
+    // This is the Phase B root-cause fix: when the tool call is scoped to a
+    // milestone that has an auto-worktree at <projectRoot>/.gsd/worktrees/<MID>/,
+    // tool writes must go to the worktree .gsd rather than the shared project .gsd.
+    const parseIdx = src.indexOf("function parseWorkflowArgs");
+    const parseBlock = src.slice(parseIdx, parseIdx + 2500);
+    assert.ok(
+      parseBlock.includes("resolveActiveWorktreeBasePath"),
+      "parseWorkflowArgs must consult resolveActiveWorktreeBasePath",
+    );
+    assert.ok(
+      parseBlock.includes("extractMilestoneId"),
+      "parseWorkflowArgs must extract the milestoneId to locate the worktree",
+    );
+  });
+
+  it("resolveActiveWorktreeBasePath checks .git presence to avoid hijacking stray directories", () => {
+    const idx = src.indexOf("function resolveActiveWorktreeBasePath");
+    assert.ok(idx !== -1, "resolveActiveWorktreeBasePath helper must exist");
+    const block = src.slice(idx, idx + 1200);
+    assert.ok(
+      block.includes('existsSync(join(wtPath, ".git"))'),
+      "resolveActiveWorktreeBasePath must verify a .git file exists in the worktree",
+    );
+  });
+
+  it("extractMilestoneId handles camelCase, snake_case, and short aliases", () => {
+    const idx = src.indexOf("function extractMilestoneId");
+    assert.ok(idx !== -1, "extractMilestoneId helper must exist");
+    const block = src.slice(idx, idx + 600);
+    assert.ok(block.includes("milestoneId"), "must check milestoneId");
+    assert.ok(block.includes("milestone_id"), "must check milestone_id");
+    assert.ok(block.includes("mid"), "must check mid");
+  });
+});

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -0,0 +1,117 @@
+// GSD Extension — Regression tests for auto-mode warning noise (PR #4294)
+//
+// Three independent bug fixes, three regression tests:
+//
+//   1. auto-model-selection.ts — buildFlatRateContext detached
+//      getProviderAuthMode from its receiver, losing `this` and throwing
+//      "Cannot read properties of undefined (reading 'registeredProviders')".
+//      Runtime test: pass a registry whose method actually uses `this` and
+//      verify the returned authMode survives (proves the method is called
+//      with correct binding).
+//
+//   2. auto-worktree.ts — isSamePath logged every error as a warning,
+//      including ENOENT when a worktree's .gsd dir hadn't been created yet.
+//      Source-check test: the catch block must short-circuit on ENOENT
+//      before hitting logWarning. Follows the same style as
+//      copy-planning-artifacts-samepath.test.ts.
+//
+//   3. guided-flow.ts — checkAutoStartAfterDiscuss unconditionally tried
+//      to unlink DISCUSSION-MANIFEST.json and warned on ENOENT even when
+//      the milestone never had a discussion phase. Source-check test:
+//      the unlink must be guarded with existsSync, matching the
+//      CONTEXT-DRAFT.md cleanup pattern two lines above.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { buildFlatRateContext } from "../auto-model-selection.ts";
+
+// ─── Bug 2: this-binding regression ─────────────────────────────────────
+
+test("buildFlatRateContext invokes getProviderAuthMode with correct `this`", () => {
+  // Mimics ModelRegistry: getProviderAuthMode reads from an instance field.
+  // Detaching the method to a local variable would break this — the old code
+  // did `const fn = ctx.modelRegistry.getProviderAuthMode; fn(provider)`,
+  // which called the method with `this === undefined` and threw.
+  const providerData = new Map<string, string>([
+    ["claude-code", "externalCli"],
+    ["anthropic", "apiKey"],
+  ]);
+  const registry = {
+    _providers: providerData,
+    getProviderAuthMode(provider: string): string {
+      // Access via `this` — fails loudly if the method was called unbound.
+      const map = this._providers;
+      return map.get(provider) ?? "apiKey";
+    },
+  };
+
+  const ctx = buildFlatRateContext("claude-code", { modelRegistry: registry });
+  assert.equal(
+    ctx.authMode,
+    "externalCli",
+    "authMode should be extracted when getProviderAuthMode is called as a method",
+  );
+
+  const ctx2 = buildFlatRateContext("anthropic", { modelRegistry: registry });
+  assert.equal(ctx2.authMode, "apiKey");
+});
+
+// ─── Bug 1: isSamePath source check ─────────────────────────────────────
+
+test("isSamePath short-circuits ENOENT before logging a warning", () => {
+  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  const fnIdx = src.indexOf("function isSamePath");
+  assert.ok(fnIdx !== -1, "isSamePath function exists");
+
+  // Grab the function body (enough to cover the catch block).
+  const fnBody = src.slice(fnIdx, fnIdx + 600);
+
+  const catchIdx = fnBody.indexOf("catch");
+  assert.ok(catchIdx !== -1, "isSamePath has a catch block");
+
+  const enoentIdx = fnBody.indexOf("ENOENT", catchIdx);
+  const warnIdx = fnBody.indexOf("logWarning", catchIdx);
+
+  assert.ok(enoentIdx !== -1, "catch block must handle ENOENT explicitly");
+  assert.ok(warnIdx !== -1, "catch block still warns on non-ENOENT errors");
+  assert.ok(
+    enoentIdx < warnIdx,
+    "ENOENT early-return must precede the logWarning call",
+  );
+});
+
+// ─── Bug 3: guided-flow manifest unlink source check ────────────────────
+
+test("checkAutoStartAfterDiscuss guards DISCUSSION-MANIFEST.json unlink with existsSync", () => {
+  const srcPath = join(import.meta.dirname, "..", "guided-flow.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  const fnIdx = src.indexOf("function checkAutoStartAfterDiscuss");
+  assert.ok(fnIdx !== -1, "checkAutoStartAfterDiscuss function exists");
+
+  // Locate the manifest cleanup comment and its surrounding block.
+  const cleanupIdx = src.indexOf(
+    "remove discussion manifest after auto-start",
+    fnIdx,
+  );
+  assert.ok(cleanupIdx !== -1, "manifest cleanup block still exists");
+
+  // Everything from the comment to a short distance below should contain
+  // the existsSync guard before the unlinkSync call.
+  const block = src.slice(cleanupIdx, cleanupIdx + 400);
+
+  const existsIdx = block.indexOf("existsSync(manifestPath)");
+  const unlinkIdx = block.indexOf("unlinkSync(manifestPath)");
+
+  assert.ok(existsIdx !== -1, "manifest unlink must be guarded by existsSync");
+  assert.ok(unlinkIdx !== -1, "manifest unlink still happens when file exists");
+  assert.ok(
+    existsIdx < unlinkIdx,
+    "existsSync guard must precede the unlinkSync call",
+  );
+});

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -198,7 +198,7 @@ test("session_start bootstraps the health widget alongside notifications", async
     },
   } as any;
 
-  registerHooks(pi);
+  registerHooks(pi, []);
   const sessionStart = handlers.get("session_start");
   assert.ok(sessionStart, "session_start handler is registered");
 

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -595,13 +595,13 @@ test("unit-end event contains errorContext when unit is cancelled with structure
   const unitPromise = runUnitPhase(ic, iterData, loopState);
   await new Promise(r => setTimeout(r, 50));
 
-  // Resolve with errorContext (simulates a timeout cancel)
+  // Resolve with errorContext (simulates a unit hard timeout — not session creation)
   resolveAgentEndCancelled({ message: "Hard timeout error: exceeded limit", category: "timeout", isTransient: true });
 
   const result = await unitPromise;
-  // Transient timeout cancellations pause (recoverable) instead of hard-stopping
+  // Unit hard timeouts pause (recoverable) without auto-resume
   assert.equal(result.action, "break");
-  assert.equal((result as any).reason, "session-timeout");
+  assert.equal((result as any).reason, "unit-hard-timeout");
   assert.equal(pauseCalls, 1, "timeout cancellations should pause auto-mode exactly once");
   assert.equal(commitCalls, 1, "timeout cancellations should flush a unit auto-commit once");