gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -0,0 +1,222 @@
+// GSD-2 + src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts
+// Regression: session-transition aborts must not be classified as user cancellations.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  _handleSessionSwitchAgentEnd,
+  isBareClaudeCodeStreamAbortPlaceholder,
+  isClaudeCodeSessionSwitchAbortMessage,
+} from "../bootstrap/agent-end-recovery.js";
+import { shouldIgnoreAgentEndForActiveUnit } from "../auto/unit-runner-events.js";
+import type { ErrorContext } from "../auto/types.js";
+
+test("user-abort message during session-switch is dropped (not propagated as cancellation)", () => {
+  // The Anthropic SDK emits this exact string when newSession() aborts an
+  // in-flight stream during a unit-to-unit session transition. Before the fix
+  // this was misclassified as a user cancellation and killed auto-mode with
+  // "Auto-mode stopped — Unit aborted: Claude Code process aborted by user".
+  let cancelledWith: ErrorContext | null = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "Claude Code process aborted by user" },
+    resolveCancelled,
+  );
+  assert.equal(cancelledWith, null, "SDK user-abort during session-switch must not propagate cancellation");
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "Request aborted by user" },
+    resolveCancelled,
+  );
+  assert.equal(cancelledWith, null, "proxy user-abort during session-switch must not propagate cancellation");
+});
+
+test("genuine stopReason='aborted' with errorMessage during session-switch still propagates", () => {
+  // Regression guard for prior behavior: genuine aborts with diagnostic content
+  // continue to surface as cancellations so transient-pause recovery can run.
+  let cancelledWith: { message: string; category: string; isTransient?: boolean } | null = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      errorMessage: "stream torn down mid-flight",
+      content: [{ type: "text", text: "partial output" }],
+    },
+    resolveCancelled,
+  );
+
+  assert.deepEqual(cancelledWith, {
+    message: "stream torn down mid-flight",
+    category: "aborted",
+    isTransient: true,
+  });
+});
+
+test("Claude Code stream-aborted placeholder during session-switch is dropped", () => {
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("late bare Claude Code stream-aborted placeholder is classified as internal", () => {
+  // Reproduces the M003/S04 failure shape from testingapp1: the previous unit
+  // completed, the next unit was dispatched, then Claude Code emitted a
+  // zero-token stream-aborted placeholder. That marker belongs to session
+  // transition cleanup, not the active unit.
+  assert.equal(
+    isBareClaudeCodeStreamAbortPlaceholder({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    }),
+    true,
+  );
+
+  assert.equal(
+    isBareClaudeCodeStreamAbortPlaceholder({
+      stopReason: "aborted",
+      errorMessage: "stream torn down mid-flight",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    }),
+    false,
+    "diagnostic aborts must stay on the normal cancelled path",
+  );
+
+  assert.equal(
+    isBareClaudeCodeStreamAbortPlaceholder({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Request aborted by user" }],
+    }),
+    false,
+    "user abort markers outside the session-switch path must not be swallowed",
+  );
+});
+
+test("typed session-transition abort events are classified as internal", () => {
+  assert.equal(
+    shouldIgnoreAgentEndForActiveUnit({
+      abortOrigin: "session-transition",
+    }),
+    true,
+  );
+
+  assert.equal(
+    shouldIgnoreAgentEndForActiveUnit({
+      abortOrigin: "user",
+    }),
+    false,
+  );
+
+  assert.equal(
+    shouldIgnoreAgentEndForActiveUnit({}),
+    false,
+  );
+});
+
+test("Claude Code session-switch abort detection is narrow", () => {
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "error",
+      content: [{ type: "text", text: "Claude Code error: Claude Code process aborted by user" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    }),
+    true,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "partial output before network failure" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Request aborted by user\nAPI Error: 529 overloaded" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "error",
+      errorMessage: "Request aborted by user",
+      content: [{ type: "text", text: "Claude Code process aborted by user" }],
+    }),
+    true,
+  );
+});
+
+test("empty-content aborted during session-switch is silently ignored", () => {
+  // Empty-content aborted is a non-fatal LLM stop; we must not pause/cancel.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "aborted", content: [] },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("non-abort errors during session-switch are not propagated through this helper", () => {
+  // Real provider errors (rate-limit, network, unsupported-model) are handled
+  // by the post-switch retry pipeline — not by the in-flight switch handler.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "rate limit exceeded" },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("malformed lastMsg is rejected gracefully", () => {
+  let calls = 0;
+  const resolveCancelled = (_ctx: unknown) => {
+    calls += 1;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(undefined, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd(null, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd("not an object", resolveCancelled as never);
+  _handleSessionSwitchAgentEnd({}, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd({ stopReason: "completed" }, resolveCancelled as never);
+
+  assert.equal(calls, 0, "malformed or non-abort lastMsg must not invoke cancellation");
+});

package/src/resources/extensions/gsd/tests/show-config-command.test.ts

@@ -1,56 +1,58 @@
 /**
- * /gsd show-config command — structural tests.
- *
- * Verifies the config overlay class and command handler exist
- * with correct structure.
+ * /gsd show-config command behavior tests.
  */
 
 import 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 overlaySrc = readFileSync(join(__dirname, "..", "config-overlay.ts"), "utf-8");
-const coreSrc = readFileSync(join(__dirname, "..", "commands", "handlers", "core.ts"), "utf-8");
-
-// ─── Config overlay ───────────────────────────────────────────────────────
-
-test("GSDConfigOverlay class is exported", () => {
-  assert.ok(
-    overlaySrc.includes("export class GSDConfigOverlay"),
-    "GSDConfigOverlay should be exported",
+import { GSDConfigOverlay, formatConfigText } from "../config-overlay.ts";
+import { handleCoreCommand } from "../commands/handlers/core.ts";
+
+const theme = {
+  bold: (s: string) => s,
+  fg: (_name: string, s: string) => s,
+};
+
+test("GSDConfigOverlay renders and responds to input", () => {
+  let renderRequests = 0;
+  let closed = false;
+  const overlay = new GSDConfigOverlay(
+    { requestRender: () => { renderRequests++; } },
+    theme as any,
+    () => { closed = true; },
   );
-});
 
-test("GSDConfigOverlay implements Component interface methods", () => {
-  assert.ok(overlaySrc.includes("render("), "should have render method");
-  assert.ok(overlaySrc.includes("handleInput("), "should have handleInput method");
-  assert.ok(overlaySrc.includes("invalidate("), "should have invalidate method");
-  assert.ok(overlaySrc.includes("dispose("), "should have dispose method");
-});
+  const lines = overlay.render(60);
+  assert.ok(lines.some((line) => line.includes("GSD Configuration")));
 
-test("formatConfigText function is exported", () => {
-  assert.ok(
-    overlaySrc.includes("export function formatConfigText"),
-    "formatConfigText should be exported for non-overlay fallback",
-  );
-});
+  overlay.handleInput("j");
+  assert.equal(renderRequests, 1);
 
-// ─── Command handler ──────────────────────────────────────────────────────
+  overlay.handleInput("q");
+  assert.equal(closed, true);
+});
 
-test("core handler routes show-config command", () => {
-  assert.ok(
-    coreSrc.includes('"show-config"'),
-    "core handler should match show-config command",
-  );
+test("formatConfigText provides a text fallback", () => {
+  const text = formatConfigText();
+  assert.match(text, /GSD Configuration/);
+  assert.match(text, /SOURCES/);
 });
 
-test("show-config has text fallback via formatConfigText", () => {
-  assert.ok(
-    coreSrc.includes("formatConfigText"),
-    "show-config should use formatConfigText as fallback",
-  );
+test("core handler routes show-config to overlay with text fallback", async () => {
+  const notifications: Array<{ message: string; level: string }> = [];
+  const ctx = {
+    ui: {
+      custom: async () => undefined,
+      notify: (message: string, level: string) => {
+        notifications.push({ message, level });
+      },
+    },
+  };
+
+  const handled = await handleCoreCommand("show-config", ctx as any);
+
+  assert.equal(handled, true);
+  assert.equal(notifications.length, 1);
+  assert.equal(notifications[0]?.level, "info");
+  assert.match(notifications[0]?.message ?? "", /GSD Configuration/);
 });

package/src/resources/extensions/gsd/tests/signal-handlers.test.ts

@@ -101,3 +101,30 @@ test("registerSigtermHandler deregisters previous handler from all signals", ()
   // Clean up
   deregisterSigtermHandler(handler2);
 });
+
+test("registered signal handler runs best-effort cleanup before exiting", () => {
+  let cleanupCalled = false;
+  let exitCode: number | string | null | undefined;
+  const originalExit = process.exit;
+  const handler = registerSigtermHandler(
+    "/tmp/test-signal-cleanup",
+    null,
+    () => {
+      cleanupCalled = true;
+    },
+  );
+
+  (process as any).exit = ((code?: number | string | null) => {
+    exitCode = code;
+    throw new Error("process.exit intercepted");
+  }) as never;
+
+  try {
+    assert.throws(() => handler(), /process\.exit intercepted/);
+    assert.equal(cleanupCalled, true);
+    assert.equal(exitCode, 0);
+  } finally {
+    (process as any).exit = originalExit;
+    deregisterSigtermHandler(handler);
+  }
+});

package/src/resources/extensions/gsd/tests/skip-slice-state-rebuild.test.ts

@@ -1,31 +1,63 @@
 /**
- * Regression test for #3477: gsd_skip_slice tool must rebuild STATE.md
- * after updating the DB so auto-mode reads the correct state.
+ * Regression test for #3477: gsd_skip_slice updates DB state and rebuilds
+ * the projected STATE.md artifact.
  */
-import { test } from "node:test";
+
+import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-test("gsd_skip_slice tool calls rebuildState after DB update (#3477)", () => {
-  const src = readFileSync(
-    join(import.meta.dirname, "..", "bootstrap", "db-tools.ts"),
-    "utf-8",
-  );
-  // The fix adds a rebuildState call after updateSliceStatus in skip_slice
-  assert.ok(
-    src.includes("rebuildState"),
-    "gsd_skip_slice must call rebuildState after updating slice status",
-  );
-});
+import { registerDbTools } from "../bootstrap/db-tools.ts";
+import {
+  closeDatabase,
+  getSlice,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
+
+test("gsd_skip_slice marks a slice skipped and refreshes STATE.md", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-skip-slice-"));
+  const tools = new Map<string, any>();
+  const pi = { registerTool: (tool: any) => tools.set(tool.name, tool) };
+
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Skip Test", status: "active", depends_on: [] });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Skipped slice",
+      status: "pending",
+      risk: "low",
+      depends: [],
+      demo: "",
+      sequence: 1,
+    });
+
+    registerDbTools(pi as any);
+    const skipSlice = tools.get("gsd_skip_slice");
+    assert.ok(skipSlice, "gsd_skip_slice is registered");
+
+    const result = await skipSlice.execute(
+      "tool-call",
+      { milestoneId: "M001", sliceId: "S01", reason: "descoped" },
+      undefined,
+      undefined,
+      { cwd: base },
+    );
+
+    assert.equal(result.details.operation, "skip_slice");
+    assert.equal(getSlice("M001", "S01")?.status, "skipped");
 
-test("rethink prompt warns against markdown-only edits for skip (#3477)", () => {
-  const prompt = readFileSync(
-    join(import.meta.dirname, "..", "prompts", "rethink.md"),
-    "utf-8",
-  );
-  assert.ok(
-    prompt.includes("MUST") && prompt.includes("gsd_skip_slice"),
-    "Rethink prompt must emphasize gsd_skip_slice tool requirement",
-  );
+    const statePath = join(base, ".gsd", "STATE.md");
+    assert.equal(existsSync(statePath), true, "STATE.md should be rebuilt");
+    assert.match(readFileSync(statePath, "utf-8"), /Active Slice:\*\* None/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/skipped-validation-db-atomicity.test.ts

@@ -1,17 +1,57 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import { DISPATCH_RULES } from "../auto-dispatch.ts";
+import {
+  closeDatabase,
+  getLatestAssessmentByScope,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
 
-test("skipped validation DB persistence stays atomic", () => {
-  const source = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+test("skipped validation dispatch persists the validation file and DB assessment together", async () => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-skip-validation-"));
+  const milestoneDir = join(basePath, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  const rule = DISPATCH_RULES.find((r) => r.name === "validating-milestone → validate-milestone");
+  assert.ok(rule, "validate-milestone rule is registered");
 
-  assert.match(
-    source,
-    /if \(isDbAvailable\(\)\) \{\s+transaction\(\(\) => \{\s+insertAssessment\([\s\S]*?insertMilestoneValidationGates\(/,
-    "skipped validation DB writes must remain inside a single transaction",
-  );
+  try {
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# S01 Summary\n", "utf-8");
+    openDatabase(join(basePath, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Validation", status: "active", depends_on: [] });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Done slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+      demo: "",
+      sequence: 1,
+    });
+
+    const action = await rule.match({
+      state: { phase: "validating-milestone" },
+      mid: "M001",
+      midTitle: "Validation",
+      basePath,
+      prefs: { phases: { skip_milestone_validation: true } },
+    } as any);
+
+    assert.deepEqual(action, { action: "skip" });
+    assert.equal(existsSync(join(milestoneDir, "M001-VALIDATION.md")), true);
+    assert.equal(
+      getLatestAssessmentByScope("M001", "milestone-validation")?.status,
+      "pass",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/slice-cadence.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Slice-cadence merge and resquash tests.
 /**
  * Tests for slice-cadence collapse — #4765.
  *
@@ -20,6 +22,7 @@ import {
 } from "../slice-cadence.ts";
 import { MergeConflictError } from "../git-service.ts";
 import { summarizeWorktreeTelemetry } from "../worktree-telemetry.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 function git(args: string[], cwd: string): string {
   return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -81,6 +84,7 @@ describe("mergeSliceToMain", () => {
 
   afterEach(() => {
     try { process.chdir(originalCwd); } catch { /* */ }
+    closeDatabase();
     rmSync(dir, { recursive: true, force: true });
   });
 
@@ -109,6 +113,25 @@ describe("mergeSliceToMain", () => {
     assert.equal(summary.sliceMergeConflicts, 0);
   });
 
+  test("slice-cadence commit messages include milestone and slice names", () => {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "M001: Backend foundation", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "S01: Core API", status: "complete" });
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "feature.txt", "slice 1 work\n", "feat: S01 work");
+
+    process.chdir(dir);
+    mergeSliceToMain(dir, "M001", "S01");
+
+    const subject = git(["log", "-1", "--format=%s", "main"], dir);
+    const body = git(["log", "-1", "--format=%B", "main"], dir);
+    assert.equal(subject, "feat: Core API - S01 of M001 (slice-cadence)");
+    assert.ok(body.includes("Slice: S01 - Core API"));
+    assert.ok(body.includes("Milestone: M001 - Backend foundation"));
+    assert.ok(body.includes("GSD-Slice: S01"));
+    assert.ok(body.includes("GSD-Milestone: M001"));
+  });
+
   test("merges slices to the recorded integration branch", () => {
     git(["checkout", "-b", "develop"], dir);
     mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });