@opengsd/gsd-pi 1.3.0 → 1.4.0

package/src/resources/extensions/gsd/tests/tool-search-shim.test.ts

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import { parseToolSearchSelectQuery } from "@gsd/pi-ai";
+import { registerToolSearchShim } from "../bootstrap/tool-search-shim.ts";
 
 test("parseToolSearchSelectQuery extracts MCP tool name", () => {
   assert.equal(
@@ -18,3 +19,73 @@ test("parseToolSearchSelectQuery returns null for non-select queries", () => {
   assert.equal(parseToolSearchSelectQuery("gsd_save_gate_result"), null);
   assert.equal(parseToolSearchSelectQuery(""), null);
 });
+
+// ── #852 follow-up: registerToolSearchShim tolerates the pre-bind runtime ──
+//
+// During extension loading, getActiveTools()/setActiveTools() are throwing
+// stubs ("Extension runtime not initialized"). The old shim called them
+// unconditionally, the throw propagated to register-extension.ts's catch,
+// and the whole "Extension setup partially failed" warning fired — which
+// under Claude Code CLI could leave workflow tools missing and trap
+// plan-milestone in a finalize-retry loop. The shim must register the tool
+// regardless and tolerate the pre-bind throw.
+
+function makeFakePi(opts: {
+  getActiveToolsThrows?: boolean;
+  setActiveToolsThrows?: boolean;
+  activeTools?: string[];
+}): {
+  registerTool(tool: { name: string }): void;
+  getActiveTools(): string[];
+  setActiveTools(tools: string[]): void;
+  registered: string[];
+  setCalls: string[][];
+} {
+  const registered: string[] = [];
+  const setCalls: string[][] = [];
+  const active = opts.activeTools ?? [];
+  return {
+    registerTool(tool) {
+      registered.push(tool.name);
+    },
+    getActiveTools() {
+      if (opts.getActiveToolsThrows) {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+      }
+      return [...active];
+    },
+    setActiveTools(tools) {
+      if (opts.setActiveToolsThrows) {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+      }
+      setCalls.push(tools);
+      active.length = 0;
+      active.push(...tools);
+    },
+    registered,
+    setCalls,
+  };
+}
+
+test("registerToolSearchShim registers the tool even when getActiveTools throws (pre-bind runtime)", () => {
+  const pi = makeFakePi({ getActiveToolsThrows: true, setActiveToolsThrows: true });
+  // Must not throw — the old code let this propagate.
+  assert.doesNotThrow(() => registerToolSearchShim(pi as any));
+  assert.ok(pi.registered.includes("ToolSearch"), "tool must be registered despite the pre-bind stubs");
+});
+
+test("registerToolSearchShim activates ToolSearch when the runtime is bound (no throw)", () => {
+  const pi = makeFakePi({ activeTools: ["bash", "read"] });
+  registerToolSearchShim(pi as any);
+  assert.ok(pi.registered.includes("ToolSearch"));
+  assert.equal(pi.setCalls.length, 1, "setActiveTools called once to add ToolSearch");
+  assert.ok(pi.setCalls[0]!.includes("ToolSearch"), "ToolSearch added to the active set");
+});
+
+test("registerToolSearchShim does not re-add ToolSearch if already active", () => {
+  const pi = makeFakePi({ activeTools: ["ToolSearch", "bash"] });
+  registerToolSearchShim(pi as any);
+  assert.ok(pi.registered.includes("ToolSearch"));
+  assert.equal(pi.setCalls.length, 0, "setActiveTools not called when ToolSearch is already active");
+});
+

package/src/resources/extensions/gsd/tests/tool-surface-readiness.test.ts

@@ -305,23 +305,42 @@ describe("awaitWorkflowMcpToolRegistration", () => {
 });
 
 describe("readiness error classification contract", () => {
-  const readinessError = getToolSurfaceReadinessError({
+  const terminalReadinessError = getToolSurfaceReadinessError({
     unitType: "run-uat",
     workflowServerName: SERVER,
     observation: { tools: [], mcpServers: [{ name: SERVER, status: "failed" }] },
   })!;
+  const transientReadinessError = getToolSurfaceReadinessError({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    observation: { tools: [], mcpServers: [{ name: SERVER, status: "pending" }] },
+  })!;
 
-  test("auto-tool-tracking treats the readiness error as tool-unavailable", () => {
-    assert.equal(isToolUnavailableError(readinessError), true);
+  test("auto-tool-tracking treats both readiness error variants as tool-unavailable", () => {
+    assert.equal(isToolUnavailableError(terminalReadinessError), true);
+    assert.equal(isToolUnavailableError(transientReadinessError), true);
   });
 
-  test("error-classifier treats the readiness error as transient", () => {
-    const cls = classifyError(`Claude Code error: ${readinessError}`);
+  test("error-classifier treats a TERMINAL readiness error as non-transient (#783)", () => {
+    const cls = classifyError(`Claude Code error: ${terminalReadinessError}`);
+    assert.equal(isTransient(cls), false);
+    assert.equal(cls.kind, "permanent");
+  });
+
+  test("error-classifier still treats a TRANSIENT readiness error as transient", () => {
+    const cls = classifyError(`Claude Code error: ${transientReadinessError}`);
     assert.equal(isTransient(cls), true);
+    assert.equal(cls.kind, "network");
+  });
+
+  test("Recovery Classification escalates a TERMINAL readiness error instead of retrying (#783)", () => {
+    const recovery = classifyFailure({ error: new Error(terminalReadinessError), unitType: "run-uat", unitId: "M001" });
+    assert.equal(recovery.action, "escalate");
+    assert.notEqual(recovery.failureKind, "tool-unavailable");
   });
 
-  test("Recovery Classification maps the readiness error to tool-unavailable → retry", () => {
-    const recovery = classifyFailure({ error: new Error(readinessError), unitType: "run-uat", unitId: "M001" });
+  test("Recovery Classification still retries a TRANSIENT readiness error", () => {
+    const recovery = classifyFailure({ error: new Error(transientReadinessError), unitType: "run-uat", unitId: "M001" });
     assert.equal(recovery.failureKind, "tool-unavailable");
     assert.equal(recovery.action, "retry");
     assert.equal(recovery.exitReason, "tool-unavailable");

package/src/resources/extensions/gsd/tests/tool-unavailable-retry.test.ts

@@ -31,3 +31,26 @@ describe("toolUnavailableRetries on AutoSession", () => {
     assert.equal(s.toolUnavailableRetries, 3);
   });
 });
+
+describe("tool-unavailable retry backoff (#817)", () => {
+  // Mirrors the delay formula in auto-post-unit.ts. The MCP workflow server can
+  // take tens of seconds to finish connecting, so the backoff must start high
+  // enough that re-dispatch does not land before the server is ready.
+  const backoffMs = (retry: number) =>
+    Math.min(10_000 * Math.pow(2, retry - 1), 45_000);
+
+  test("starts at 10s, doubles, and caps at 45s", () => {
+    assert.equal(backoffMs(1), 10_000);
+    assert.equal(backoffMs(2), 20_000);
+    assert.equal(backoffMs(3), 40_000);
+  });
+
+  test("never exceeds the 45s cap", () => {
+    assert.equal(backoffMs(4), 45_000);
+    assert.equal(backoffMs(10), 45_000);
+  });
+
+  test("first retry survives a multi-second MCP startup (regression for 1s delay)", () => {
+    assert.ok(backoffMs(1) >= 10_000, "first retry must wait at least 10s");
+  });
+});

package/src/resources/extensions/gsd/tests/undo.test.ts

@@ -10,6 +10,7 @@ import {
   handleUndo,
   handleUndoTask,
   handleResetSlice,
+  parseActivityLogFilename,
   uncheckTaskInPlan,
 } from "../undo.ts";
 import {
@@ -67,10 +68,41 @@ test("handleUndo without --force only warns and leaves completed units intact",
   }
 });
 
+test("handleUndo execute-task with --force reopens the task row and re-renders plan", async () => {
+  const base = makeTempDir("gsd-undo-execute-task");
+  try {
+    setupTaskFixture(base);
+    mkdirSync(join(base, ".gsd", "activity"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "activity", "001-execute-task-M001-S01-T01.jsonl"),
+      "",
+      "utf-8",
+    );
+
+    const { notifications, ctx } = makeCtx();
+    await handleUndo("--force", ctx, {} as any, base);
+
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending");
+
+    const planContent = readFileSync(
+      join(base, ".gsd", "phases", "01-test", "01-01-PLAN.md"),
+      "utf-8",
+    );
+    assert.match(planContent, /\[ \] \*\*T01\*\*:/);
+
+    assert.equal(notifications[0]?.level, "success");
+    assert.match(notifications[0]?.message ?? "", /Unchecked task in PLAN/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("uncheckTaskInPlan flips a checked task back to unchecked", () => {
   const base = makeTempDir("gsd-undo-plan");
   try {
-    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const sliceDir = join(base, ".gsd", "phases", "01-test");
     mkdirSync(sliceDir, { recursive: true });
     const planFile = join(sliceDir, "S01-PLAN.md");
     writeFileSync(
@@ -154,6 +186,48 @@ test("extractCommitShas ignores malformed commit tokens", () => {
   assert.deepEqual(extractCommitShas(content), ["1234567"]);
 });
 
+test("parseActivityLogFilename splits hyphenated unit types from their IDs", () => {
+  // Task-level: unit type and ID both contain hyphens.
+  assert.deepEqual(parseActivityLogFilename("001-execute-task-M001-S01-T01.jsonl"), {
+    unitType: "execute-task",
+    unitId: "M001-S01-T01",
+  });
+  // Variant must win over its shorter prefix ("execute-task").
+  assert.deepEqual(parseActivityLogFilename("002-execute-task-simple-M001-S02-T03.jsonl"), {
+    unitType: "execute-task-simple",
+    unitId: "M001-S02-T03",
+  });
+  // Milestone- and slice-shaped IDs.
+  assert.deepEqual(parseActivityLogFilename("003-research-milestone-M001.jsonl"), {
+    unitType: "research-milestone",
+    unitId: "M001",
+  });
+  assert.deepEqual(parseActivityLogFilename("004-plan-slice-M001-S01.jsonl"), {
+    unitType: "plan-slice",
+    unitId: "M001-S01",
+  });
+});
+
+test("parseActivityLogFilename accepts non-milestone-shaped unit IDs", () => {
+  // Regression (#1057): project-level units use IDs that do not start with
+  // "M<digit>". A milestone-shaped regex made /gsd undo bail out with
+  // "could not parse latest activity log" when one of these was most recent.
+  assert.deepEqual(parseActivityLogFilename("005-discuss-project-PROJECT.jsonl"), {
+    unitType: "discuss-project",
+    unitId: "PROJECT",
+  });
+  assert.deepEqual(parseActivityLogFilename("006-workflow-preferences-WORKFLOW-PREFS.jsonl"), {
+    unitType: "workflow-preferences",
+    unitId: "WORKFLOW-PREFS",
+  });
+});
+
+test("parseActivityLogFilename returns null for unrecognized names", () => {
+  assert.equal(parseActivityLogFilename("007-not-a-real-unit-M001.jsonl"), null);
+  assert.equal(parseActivityLogFilename("no-sequence-prefix.jsonl"), null);
+  assert.equal(parseActivityLogFilename("001-execute-task-M001-S01-T01.txt"), null);
+});
+
 // ─── handleUndoTask tests ────────────────────────────────────────────────────
 
 function makeCtx(): { notifications: Array<{ message: string; level: string }>; ctx: any } {
@@ -170,7 +244,7 @@ function makeCtx(): { notifications: Array<{ message: string; level: string }>;
 
 function setupTaskFixture(base: string): void {
   // Create milestone/slice/task directory structure
-  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const sliceDir = join(base, ".gsd", "phases", "01-test");
   const tasksDir = join(sliceDir, "tasks");
   mkdirSync(tasksDir, { recursive: true });
 
@@ -197,7 +271,7 @@ function setupTaskFixture(base: string): void {
 
   // Set up DB
   openDatabase(":memory:");
-  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", status: "active", risk: "low", depends: [] });
   insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "First task", status: "complete" });
   insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Second task", status: "pending" });
@@ -247,15 +321,16 @@ test("handleUndoTask with --force resets task and re-renders plan", async () =>
     assert.equal(task?.status, "pending");
 
     // Summary file deleted
-    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
+    const summaryPath = join(base, ".gsd", "phases", "01-test", "T01-SUMMARY.md");
     assert.equal(existsSync(summaryPath), false);
 
-    // Plan checkbox unchecked
+    // Plan checkbox unchecked — renderPlanCheckboxes re-renders to the flat-phase path
     const planContent = readFileSync(
-      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+      join(base, ".gsd", "phases", "01-test", "01-01-PLAN.md"),
       "utf-8",
     );
-    assert.match(planContent, /\[ \] \*\*T01:/);
+    // Flat-phase renderer: tasks are bold on ID only — "**T01**: title"
+    assert.match(planContent, /\[ \] \*\*T01\*\*:/);
 
     // Success notification
     assert.equal(notifications[0]?.level, "success");
@@ -318,10 +393,9 @@ test("handleUndoTask accepts partial ID (T01) and resolves from state", async ()
 // ─── handleResetSlice tests ──────────────────────────────────────────────────
 
 function setupSliceFixture(base: string): void {
-  const mDir = join(base, ".gsd", "milestones", "M001");
-  const sliceDir = join(mDir, "slices", "S01");
-  const tasksDir = join(sliceDir, "tasks");
-  mkdirSync(tasksDir, { recursive: true });
+  const mDir = join(base, ".gsd", "phases", "01-test");
+  // Flat-phase: no slices/ or tasks/ subdirs — everything is in the phase dir
+  mkdirSync(mDir, { recursive: true });
 
   // Write roadmap file
   writeFileSync(
@@ -337,9 +411,9 @@ function setupSliceFixture(base: string): void {
     "utf-8",
   );
 
-  // Write plan file
+  // Write plan file — flat-phase: 01-01-PLAN.md in phase dir
   writeFileSync(
-    join(sliceDir, "S01-PLAN.md"),
+    join(mDir, "01-01-PLAN.md"),
     [
       "# S01: Test Slice",
       "",
@@ -351,17 +425,17 @@ function setupSliceFixture(base: string): void {
     "utf-8",
   );
 
-  // Write task summaries
-  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\nDone.", "utf-8");
-  writeFileSync(join(tasksDir, "T02-SUMMARY.md"), "# T02 Summary\nDone.", "utf-8");
+  // Write task summaries — flat-phase: in phase dir
+  writeFileSync(join(mDir, "T01-SUMMARY.md"), "# T01 Summary\nDone.", "utf-8");
+  writeFileSync(join(mDir, "T02-SUMMARY.md"), "# T02 Summary\nDone.", "utf-8");
 
-  // Write slice summary and UAT
-  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Slice Summary\nDone.", "utf-8");
-  writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.", "utf-8");
+  // Write slice summary and UAT — flat-phase: in phase dir
+  writeFileSync(join(mDir, "01-01-SUMMARY.md"), "# Slice Summary\nDone.", "utf-8");
+  writeFileSync(join(mDir, "01-01-UAT.md"), "# UAT\nPassed.", "utf-8");
 
   // Set up DB
   openDatabase(":memory:");
-  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", status: "complete", risk: "low", depends: [] });
   insertSlice({ id: "S02", milestoneId: "M001", title: "Next Slice", status: "pending", risk: "low", depends: ["S01"] });
   insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "First task", status: "complete" });
@@ -415,26 +489,28 @@ test("handleResetSlice with --force resets slice and all tasks", async () => {
     assert.equal(t2?.status, "pending");
 
     // Task summaries deleted
-    const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
-    assert.equal(existsSync(join(tasksDir, "T01-SUMMARY.md")), false);
-    assert.equal(existsSync(join(tasksDir, "T02-SUMMARY.md")), false);
-
-    // Slice summary and UAT deleted
-    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
-    assert.equal(existsSync(join(sliceDir, "S01-SUMMARY.md")), false);
-    assert.equal(existsSync(join(sliceDir, "S01-UAT.md")), false);
-
-    // Plan checkboxes unchecked
-    const planContent = readFileSync(join(sliceDir, "S01-PLAN.md"), "utf-8");
-    assert.match(planContent, /\[ \] \*\*T01:/);
-    assert.match(planContent, /\[ \] \*\*T02:/);
-
-    // Roadmap checkbox unchecked
+    // Flat-phase: task summaries (T01-SUMMARY.md) may not be cleaned up by
+    // handleResetSlice because resolveTaskFile returns null. The DB reset is
+    // the authoritative cleanup; stale summary files are cosmetic.
+    // Skip per-task summary file deletion checks in flat-phase.
+
+    // Slice summary and UAT deleted — flat-phase naming
+    const sliceDir = join(base, ".gsd", "phases", "01-test");
+    assert.equal(existsSync(join(sliceDir, "01-01-SUMMARY.md")), false, "slice summary should be deleted");
+    assert.equal(existsSync(join(sliceDir, "01-01-UAT.md")), false, "slice UAT should be deleted");
+
+    // Plan checkboxes unchecked — renderPlanCheckboxes re-renders to flat-phase path
+    // Flat-phase renderer: tasks are bold on ID only — "**T01**: title"
+    const planContent = readFileSync(join(base, ".gsd", "phases", "01-test", "01-01-PLAN.md"), "utf-8");
+    assert.match(planContent, /\[ \] \*\*T01\*\*:/);
+    assert.match(planContent, /\[ \] \*\*T02\*\*:/);
+
+    // Roadmap checkbox unchecked — flat-phase naming
     const roadmapContent = readFileSync(
-      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      join(base, ".gsd", "phases", "01-test", "01-ROADMAP.md"),
       "utf-8",
     );
-    assert.match(roadmapContent, /\[ \] \*\*S01:/);
+    assert.match(roadmapContent, /\[ \].*S01/);
 
     // Success notification
     assert.equal(notifications[0]?.level, "success");