gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/deferred-milestone-dir-4996.test.ts

@@ -1,14 +1,10 @@
 // GSD Extension — Regression test for #4996: deferred milestone dir creation
-// Verifies that showHeadlessMilestoneCreation does not pre-create the milestone
-// directory before the discuss flow runs. The dir should only appear after a
-// writer (saveArtifactToDb / atomicWriteAsync) emits the first artifact.
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, existsSync, rmSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { mkdtempSync, mkdirSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 
 import { isReusableGhostMilestone } from "../state.ts";
 import { nextMilestoneIdReserved } from "../milestone-id-reservation.ts";
@@ -16,47 +12,12 @@ import { clearReservedMilestoneIds, findMilestoneIds } from "../milestone-ids.ts
 import { invalidateAllCaches } from "../cache.ts";
 import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
-
-function getShowHeadlessBody(): string {
-  const source = readFileSync(GUIDED_FLOW_PATH, "utf-8");
-  const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
-  assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist in guided-flow.ts");
-  const nextExport = source.indexOf("\nexport ", fnStart + 1);
-  return source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
-}
-
 function makeBase(prefix = "gsd-deferred-dir-"): string {
   const base = mkdtempSync(join(tmpdir(), prefix));
   mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
   return base;
 }
 
-describe("showHeadlessMilestoneCreation source guard (#4996)", () => {
-  it("does not call mkdirSync in the headless milestone creation path", () => {
-    const body = getShowHeadlessBody();
-    assert.doesNotMatch(
-      body,
-      /\bmkdirSync\s*\(/,
-      "showHeadlessMilestoneCreation must not pre-create milestone directories",
-    );
-  });
-
-  it("does not call mkdir or mkdirp before dispatchWorkflow", () => {
-    const body = getShowHeadlessBody();
-    const dispatchIdx = body.indexOf("dispatchWorkflow");
-    assert.ok(dispatchIdx > -1, "dispatchWorkflow must be present");
-
-    const beforeDispatch = body.slice(0, dispatchIdx);
-    assert.doesNotMatch(
-      beforeDispatch,
-      /\b(?:mkdir|mkdirp)\s*\(/,
-      "showHeadlessMilestoneCreation must defer directory creation until artifact write",
-    );
-  });
-});
-
 describe("deferred milestone dir creation (#4996)", () => {
   let base: string;
 
@@ -74,43 +35,31 @@ describe("deferred milestone dir creation (#4996)", () => {
   it("(a) fresh project: milestones dir has no M001 entry before any discuss flow", () => {
     base = makeBase();
     const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should choose M001 for a fresh project");
+    assert.equal(nextId, "M001");
 
     const ids = findMilestoneIds(base);
-    assert.equal(ids.length, 0, "no milestone dirs should exist before any discuss flow");
-
-    // And specifically M001 should not exist
-    const m001Dir = join(base, ".gsd", "milestones", "M001");
-    assert.ok(!existsSync(m001Dir), "M001 dir must not exist before the discuss flow runs");
+    assert.equal(ids.length, 0);
+    assert.ok(!existsSync(join(base, ".gsd", "milestones", "M001")));
   });
 
-  it("(b) abandoned discuss flow leaves no orphan: isReusableGhostMilestone returns false for non-existent dir", () => {
+  it("(b) abandoned discuss flow leaves no orphan", () => {
     base = makeBase();
     const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should not require a pre-created directory");
+    assert.equal(nextId, "M001");
 
     const m001Dir = join(base, ".gsd", "milestones", "M001");
-    assert.ok(!existsSync(m001Dir), "no M001 dir should exist");
-    assert.equal(isReusableGhostMilestone(base, "M001"), false, "non-existent milestone should not be reusable");
-    // findMilestoneIds only returns dirs that exist
-    const ids = findMilestoneIds(base);
-    assert.ok(!ids.includes("M001"), "M001 should not appear in findMilestoneIds when no dir exists");
+    assert.ok(!existsSync(m001Dir));
+    assert.equal(isReusableGhostMilestone(base, "M001"), false);
+    assert.ok(!findMilestoneIds(base).includes("M001"));
   });
 
-  it("(c) a stub dir left from a previous bug IS reusable but a newly-generated ID with no dir is not in the ghost list", () => {
+  it("(c) a stub dir left from a previous bug is reusable", () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
-    // Create a stub to represent a pre-existing phantom
     mkdirSync(join(base, ".gsd", "milestones", "M001", "slices"), { recursive: true });
 
-    // isReusableGhostMilestone identifies the orphaned stub
-    assert.ok(isReusableGhostMilestone(base, "M001"), "pre-existing stub should be identified as reusable ghost");
-    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should reuse the pre-existing ghost");
-
-    // The new ID (M002, which would be max+1 in this scenario but ghost reuse returns M001)
-    // should not have a dir
-    const m002Dir = join(base, ".gsd", "milestones", "M002");
-    assert.ok(!existsSync(m002Dir), "a freshly-requested ID should have no dir until first artifact write");
+    assert.equal(isReusableGhostMilestone(base, "M001"), true);
+    assert.equal(nextMilestoneIdReserved(findMilestoneIds(base), false, base), "M001");
+    assert.ok(!existsSync(join(base, ".gsd", "milestones", "M002")));
   });
 });

package/src/resources/extensions/gsd/tests/discuss-tool-scoping.test.ts

@@ -16,15 +16,12 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const promptsDir = join(__dirname, "..", "prompts");
-const guidedFlowPath = join(__dirname, "..", "guided-flow.ts");
+import { _dispatchWorkflowForTest } from "../guided-flow.ts";
 
 // ─── Heavy tools that should NOT be in discuss scope ─────────────────────────
 
@@ -95,36 +92,46 @@ describe("discuss tool scoping (#2949)", () => {
     );
   });
 
-  test("guided-discuss-slice.md references gsd_summary_save", () => {
-    const prompt = readFileSync(join(promptsDir, "guided-discuss-slice.md"), "utf-8");
-    assert.ok(
-      prompt.includes("gsd_summary_save"),
-      "guided-discuss-slice.md should reference gsd_summary_save",
-    );
-  });
-
-  test("discuss.md references gsd_plan_milestone and gsd_decision_save", () => {
-    const prompt = readFileSync(join(promptsDir, "discuss.md"), "utf-8");
-    assert.ok(
-      prompt.includes("gsd_plan_milestone"),
-      "discuss.md should reference gsd_plan_milestone",
-    );
-    assert.ok(
-      prompt.includes("gsd_decision_save"),
-      "discuss.md should reference gsd_decision_save",
-    );
-  });
+  test("dispatchWorkflow scopes and restores tools for discuss unit types", async () => {
+    const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-tools-"));
+    const workflowPath = join(tmp, "GSD-WORKFLOW.md");
+    writeFileSync(workflowPath, "# Workflow\n");
+    const setCalls: string[][] = [];
+    const sent: unknown[] = [];
+    let sentTools: string[] = [];
+    let activeTools = ["gsd_summary_save", "gsd_complete_task", "bash"];
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+    try {
+      await _dispatchWorkflowForTest(
+        {
+          getActiveTools: () => [...activeTools],
+          setActiveTools: (tools: string[]) => {
+            setCalls.push([...tools]);
+            activeTools = [...tools];
+          },
+          sendMessage: (message: unknown) => {
+            sent.push(message);
+            sentTools = [...activeTools];
+          },
+        } as any,
+        "Discuss the project",
+        "gsd-run",
+        undefined,
+        "discuss-milestone",
+      );
+    } finally {
+      if (originalWorkflowPath === undefined) delete process.env.GSD_WORKFLOW_PATH;
+      else process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+      rmSync(tmp, { recursive: true, force: true });
+    }
 
-  test("dispatchWorkflow source code scopes tools for discuss unit types", () => {
-    const source = readFileSync(guidedFlowPath, "utf-8");
-    // Verify that dispatchWorkflow references the allowlist for tool scoping
-    assert.ok(
-      source.includes("DISCUSS_TOOLS_ALLOWLIST"),
-      "guided-flow.ts should reference DISCUSS_TOOLS_ALLOWLIST for tool scoping",
-    );
-    assert.ok(
-      source.includes("setActiveTools"),
-      "guided-flow.ts should call setActiveTools to scope tools during discuss",
-    );
+    assert.deepEqual(setCalls[0], ["gsd_summary_save", "bash"]);
+    assert.deepEqual(setCalls.at(-1), ["gsd_summary_save", "gsd_complete_task", "bash"]);
+    assert.ok(sentTools.length > 0, "dispatch should queue a message");
+    assert.ok(sentTools.includes("gsd_summary_save"), "dispatch keeps the discuss save tool");
+    assert.ok(!sentTools.includes("gsd_complete_task"), "dispatch removes heavy completion tools");
+    assert.equal(sent.length, 1);
+    assert.match(String((sent[0] as { content?: unknown }).content), /Discuss the project/);
   });
 });

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -1,58 +1,76 @@
 /**
  * dispatch-complete-milestone-guard.test.ts — #4324
- *
- * Verify that the completing-milestone dispatch rule has a defense-in-depth
- * DB status guard. When the DB marks a milestone as closed, the rule must
- * return skip instead of dispatching a redundant complete-milestone unit.
- * This prevents silent data loss when the legacy filesystem state-derivation
- * path produces a stale completing-milestone phase.
  */
 
-import { describe, test } from "node:test";
+import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "auto-dispatch.ts");
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-complete-dispatch-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "ROADMAP.md"), "# M001\n\n## Slices\n\n- [x] **S01**: Done\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "SUMMARY.md"), "# Summary\n");
+  writeFileSync(join(base, "implementation.txt"), "done\n");
+  return base;
+}
+
+function buildDispatchCtx(basePath: string): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Milestone One",
+    state: {
+      activeMilestone: { id: "M001", title: "Milestone One" },
+      activeSlice: null,
+      activeTask: null,
+      phase: "completing-milestone",
+      recentDecisions: [],
+      blockers: [],
+      nextAction: "",
+      registry: [{ id: "M001", title: "Milestone One", status: "active" }],
+      requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+      progress: { milestones: { done: 0, total: 1 } },
+    },
+    prefs: undefined,
+  };
+}
 
 describe("completing-milestone dispatch guard (#4324)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+  let base = "";
+  const rule = DISPATCH_RULES.find((candidate) => candidate.name === "completing-milestone → complete-milestone");
+  assert.ok(rule, "complete-milestone dispatch rule should exist");
 
-  test("imports isClosedStatus from status-guards", () => {
-    assert.match(source, /import\s*\{[^}]*isClosedStatus[^}]*\}\s*from\s*["']\.\/status-guards/);
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    if (base) rmSync(base, { recursive: true, force: true });
+    base = "";
   });
 
-  test("checks DB milestone status before dispatching complete-milestone", () => {
-    assert.match(source, /isClosedStatus\(milestone\.status\)/);
-  });
+  test("skips complete-milestone dispatch when the DB milestone is already closed", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
 
-  test("isClosedStatus guard appears in the completing-milestone rule", () => {
-    // The completing-milestone phase check and the isClosedStatus guard
-    // must both appear in the same rule, with the guard before dispatch.
-    const phaseCheck = source.indexOf('phase !== "completing-milestone"');
-    assert.ok(phaseCheck > -1, "completing-milestone phase check should exist");
+    const result = await rule.match(buildDispatchCtx(base));
 
-    // Find the isClosedStatus guard after the phase check
-    const guardIdx = source.indexOf("isClosedStatus(milestone.status)", phaseCheck);
-    assert.ok(guardIdx > -1, "isClosedStatus guard should appear after the phase check");
+    assert.equal(result?.action, "skip");
+  });
 
-    // Find the skip return after the guard
-    const skipIdx = source.indexOf('action: "skip"', guardIdx);
-    assert.ok(skipIdx > -1, "skip action should follow the isClosedStatus guard");
+  test("dispatches complete-milestone when the DB milestone is still active", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
 
-    // The skip should come before the dispatch in this rule
-    const dispatchIdx = source.indexOf('unitType: "complete-milestone"', skipIdx);
-    assert.ok(dispatchIdx > -1, "complete-milestone dispatch should exist after the skip guard");
-  });
+    const result = await rule.match(buildDispatchCtx(base));
 
-  test("does not reconcile DB from SUMMARY.md projection (#4658 superseded)", () => {
-    const phaseCheck = source.indexOf('phase !== "completing-milestone"');
-    assert.ok(phaseCheck > -1, "completing-milestone phase check should exist");
-    const ruleTail = source.slice(phaseCheck, source.indexOf('name:', phaseCheck + 1));
-    assert.doesNotMatch(ruleTail, /resolveMilestoneFile\(basePath,\s*mid,\s*"SUMMARY"\)/);
-    assert.doesNotMatch(ruleTail, /classifyMilestoneSummaryContent/);
-    assert.doesNotMatch(ruleTail, /updateMilestoneStatus\(mid,\s*"complete"/);
+    assert.equal(result?.action, "dispatch");
+    assert.equal(result?.unitType, "complete-milestone");
+    assert.equal(result?.unitId, "M001");
   });
 });

package/src/resources/extensions/gsd/tests/dispatch-guard-closed-status.test.ts

@@ -1,33 +1,43 @@
 /**
  * dispatch-guard-closed-status.test.ts — #3653
  *
- * Verify that the dispatch guard uses isClosedStatus() instead of a raw
- * `status === "complete"` check when determining whether a slice is done.
+ * Verify that the dispatch guard treats all closed DB slice statuses as done.
  * Reconciled slices may carry statuses like "skipped" or "cancelled" which
  * are also closed — the raw check caused false dispatch blocks.
  */
 
-import { describe, test } from "node:test";
+import { afterEach, beforeEach, describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "dispatch-guard.ts");
+import { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 describe("dispatch-guard isClosedStatus migration (#3653)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+  let base: string;
 
-  test("imports isClosedStatus from status-guards", () => {
-    assert.match(source, /import\s*\{[^}]*isClosedStatus[^}]*\}\s*from\s*["']\.\/status-guards/);
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-closed-"));
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "CONTEXT.md"), "# M001\n");
+    openDatabase(join(base, ".gsd", "gsd.db"));
   });
 
-  test("uses isClosedStatus() for slice done check instead of raw comparison", () => {
-    assert.match(source, /done:\s*isClosedStatus\(r\.status\)/);
+  afterEach(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
   });
 
-  test("does not use raw status === 'complete' for DB slice rows", () => {
-    assert.doesNotMatch(source, /done:\s*r\.status\s*===\s*["']complete["']/);
+  test("skipped prior DB slices do not block later slice dispatch", () => {
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Skipped Slice", status: "skipped", depends: [] });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Next Slice", status: "pending", depends: [] });
+
+    assert.equal(
+      getPriorSliceCompletionBlocker(base, "main", "execute-task", "M001-S02-T01"),
+      null,
+    );
   });
 });

package/src/resources/extensions/gsd/tests/dispatcher-stuck-planning.test.ts

@@ -6,32 +6,50 @@
  * planning/import APIs.
  */
 
-import { describe, test } from "node:test";
+import { afterEach, beforeEach, describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "state.ts");
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
 
 describe("dispatcher DB-authoritative planning boundary", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+  let base: string;
 
-  test("does not import insertTask into state derivation", () => {
-    assert.doesNotMatch(source, /import\s*\{[^}]*insertTask[^}]*\}\s*from/);
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "gsd-dispatcher-planning-"));
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "S01"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "CONTEXT.md"), "# M001\n");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "ROADMAP.md"), [
+      "## Slices",
+      "- [ ] **S01: Build** `risk:low` `depends:[]`",
+    ].join("\n"));
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "S01", "PLAN.md"), [
+      "## Tasks",
+      "- [ ] **T01: Projection-only task**",
+    ].join("\n"));
+    openDatabase(join(base, ".gsd", "gsd.db"));
   });
 
-  test("does not contain plan-file task reconciliation block", () => {
-    assert.doesNotMatch(source, /dbTaskIds\.has\(t\.id\)/);
-    assert.match(source, /Slice \$\{activeSlice\.id\} has no DB tasks/);
+  afterEach(() => {
+    closeDatabase();
+    invalidateStateCache();
+    rmSync(base, { recursive: true, force: true });
   });
 
-  test("does not call insertTask from state derivation", () => {
-    assert.doesNotMatch(source, /insertTask\(\{/);
-  });
+  test("PLAN.md projection tasks are not imported into runtime DB state", async () => {
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Build", status: "active", depends: [] });
+
+    const state = await deriveStateFromDb(base);
 
-  test("documents markdown projections as non-authoritative", () => {
-    assert.match(source, /Markdown files are projections only/);
+    assert.equal(state.phase, "planning");
+    assert.equal(state.activeTask, null);
+    assert.match(
+      state.nextAction ?? "",
+      /Slice S01 has no DB tasks\. Plan slice tasks before execution\./,
+    );
   });
 });

package/src/resources/extensions/gsd/tests/error-success-mask.test.ts

@@ -8,30 +8,25 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
+import { resolveAgentEndErrorDisplay } from "../bootstrap/agent-end-recovery.ts";
 
 describe("error-success mask detection (#3664)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
-
-  test("detects useless errorMessage values with regex", () => {
-    assert.match(source, /success\|ok\|true\|error\|unknown/i);
-  });
-
-  test("extracts display message from content text block", () => {
-    assert.match(source, /textBlock/);
-    assert.match(source, /\.text\.slice\(0,\s*300\)/);
-  });
-
-  test("classifies using rawErrorMsg, not displayMsg", () => {
-    assert.match(source, /classifyError\(rawErrorMsg/);
+  test("falls back to assistant text when errorMessage is uninformative", () => {
+    assert.equal(
+      resolveAgentEndErrorDisplay("success", [
+        { type: "tool_use", name: "noop" },
+        { type: "text", text: "provider failed with a useful message" },
+      ]),
+      "provider failed with a useful message",
+    );
   });
 
-  test("references issue #3588 in comments", () => {
-    assert.match(source, /#3588/);
+  test("keeps informative raw error messages", () => {
+    assert.equal(
+      resolveAgentEndErrorDisplay("rate limit exceeded", [
+        { type: "text", text: "prose should not replace useful raw error" },
+      ]),
+      "rate limit exceeded",
+    );
   });
 });

package/src/resources/extensions/gsd/tests/est-annotation-timeout.test.ts

@@ -8,46 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const timersSrcPath = join(import.meta.dirname, "..", "auto-timers.ts");
-const timersSrc = readFileSync(timersSrcPath, "utf-8");
-
-// ─── Source analysis: parseEstimateMinutes exists and is exported ────────────
-
-test("#2243: auto-timers.ts should export parseEstimateMinutes", () => {
-  assert.ok(
-    timersSrc.includes("export function parseEstimateMinutes"),
-    "parseEstimateMinutes should be exported from auto-timers.ts",
-  );
-});
-
-// ─── Inline unit test of parseEstimateMinutes logic ─────────────────────────
-// Since importing the module pulls in heavy deps, test the parsing logic inline.
-
-function parseEstimateMinutes(estimate: string): number | null {
-  if (!estimate || typeof estimate !== "string") return null;
-  const trimmed = estimate.trim();
-  if (!trimmed) return null;
-
-  let totalMinutes = 0;
-  let matched = false;
-
-  const hoursMatch = trimmed.match(/(\d+)\s*h/i);
-  if (hoursMatch) {
-    totalMinutes += Number(hoursMatch[1]) * 60;
-    matched = true;
-  }
-
-  const minutesMatch = trimmed.match(/(\d+)\s*m/i);
-  if (minutesMatch) {
-    totalMinutes += Number(minutesMatch[1]);
-    matched = true;
-  }
-
-  return matched ? totalMinutes : null;
-}
+import { parseEstimateMinutes, resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 
 test("#2243: parseEstimateMinutes parses '30m' correctly", () => {
   assert.equal(parseEstimateMinutes("30m"), 30);
@@ -73,48 +34,20 @@ test("#2243: parseEstimateMinutes returns null for invalid string", () => {
   assert.equal(parseEstimateMinutes("not a time"), null);
 });
 
-// ─── Source analysis: startUnitSupervision uses task estimates ───────────────
-
-test("#2243: startUnitSupervision should reference task estimates for timeout scaling", () => {
-  const usesEstimate =
-    timersSrc.includes("parseEstimateMinutes") &&
-    timersSrc.includes("estimateMinutes") &&
-    timersSrc.includes("taskEstimate");
-
-  assert.ok(
-    usesEstimate,
-    "startUnitSupervision should use task estimate annotations for timeout scaling",
+test("#2243: estimate scale affects soft and hard timeouts but not idle timeout", () => {
+  const result = resolveUnitSupervisionTimeouts(
+    "execute-task",
+    {
+      soft_timeout_minutes: 10,
+      idle_timeout_minutes: 5,
+      hard_timeout_minutes: 20,
+    },
+    3,
   );
-});
-
-test("#2243: SupervisionContext should accept an optional taskEstimate field", () => {
-  const ctxIdx = timersSrc.indexOf("SupervisionContext");
-  assert.ok(ctxIdx !== -1, "SupervisionContext interface exists");
 
-  const ctxEnd = timersSrc.indexOf("}", ctxIdx);
-  const ctxBlock = timersSrc.slice(ctxIdx, ctxEnd);
-
-  assert.ok(
-    ctxBlock.includes("taskEstimate"),
-    "SupervisionContext should include a taskEstimate field",
-  );
-});
-
-test("#2243: timeouts should be scaled by estimate (timeoutScale in source)", () => {
-  assert.ok(
-    timersSrc.includes("timeoutScale"),
-    "auto-timers.ts should use a timeoutScale factor derived from est: annotations",
-  );
-});
-
-test("#2243: idle timeout should NOT be scaled (idle is idle regardless of estimate)", () => {
-  // Find the idleTimeoutMs line
-  const idleIdx = timersSrc.indexOf("const idleTimeoutMs");
-  assert.ok(idleIdx !== -1, "idleTimeoutMs variable exists");
-  
-  const idleLine = timersSrc.slice(idleIdx, timersSrc.indexOf("\n", idleIdx));
-  assert.ok(
-    !idleLine.includes("timeoutScale"),
-    "idleTimeoutMs should NOT be scaled — idle is idle",
-  );
+  assert.deepEqual(result, {
+    softTimeoutMs: 30 * 60 * 1000,
+    idleTimeoutMs: 5 * 60 * 1000,
+    hardTimeoutMs: 60 * 60 * 1000,
+  });
 });