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

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -206,6 +206,83 @@ test("session_start does NOT call setFooter or suppress gsd-health when isAutoAc
   assert.equal(healthWidgetHideCount, 0, "gsd-health must NOT be hidden when isAutoActive() is false");
 });
 
+test("session_start installs the welcome screen as the TUI header", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-welcome-header-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, "bin"), { recursive: true });
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(join(dir, "bin", "welcome-screen.js"), "export const stale = true;\n", "utf-8");
+  writeFileSync(
+    join(dir, "dist", "welcome-screen.js"),
+    [
+      "export function buildWelcomeScreenLines(opts) {",
+      "  return [`welcome ${opts.version} ${opts.remoteChannel ?? 'none'} ${opts.width}`];",
+      "}",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const originalCwd = process.cwd();
+  const originalGsdPkgRoot = process.env.GSD_PKG_ROOT;
+  const originalGsdBinPath = process.env.GSD_BIN_PATH;
+  const originalGsdVersion = process.env.GSD_VERSION;
+  const originalFirstRunBanner = process.env.GSD_FIRST_RUN_BANNER;
+  process.chdir(dir);
+  process.env.GSD_PKG_ROOT = dir;
+  process.env.GSD_BIN_PATH = join(dir, "bin", "loader.js");
+  process.env.GSD_VERSION = "9.9.9-test";
+  delete process.env.GSD_FIRST_RUN_BANNER;
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdPkgRoot === undefined) delete process.env.GSD_PKG_ROOT;
+    else process.env.GSD_PKG_ROOT = originalGsdPkgRoot;
+    if (originalGsdBinPath === undefined) delete process.env.GSD_BIN_PATH;
+    else process.env.GSD_BIN_PATH = originalGsdBinPath;
+    if (originalGsdVersion === undefined) delete process.env.GSD_VERSION;
+    else process.env.GSD_VERSION = originalGsdVersion;
+    if (originalFirstRunBanner === undefined) delete process.env.GSD_FIRST_RUN_BANNER;
+    else process.env.GSD_FIRST_RUN_BANNER = originalFirstRunBanner;
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const sessionStart = handlers.get("session_start");
+  assert.ok(sessionStart, "session_start handler must be registered");
+
+  let headerFactory: ((tui: unknown, theme: unknown) => { render(width: number): string[] }) | undefined;
+  await sessionStart!({}, {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setFooter: () => {},
+      setHeader: (factory: typeof headerFactory) => {
+        headerFactory = factory;
+      },
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: () => {},
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+  } as any);
+
+  assert.equal(typeof headerFactory, "function", "session_start should install a header factory");
+  const header = headerFactory!({}, {});
+  assert.deepEqual(header.render(123), ["welcome 9.9.9-test none 123"]);
+});
+
 test("session_start and session_switch apply disabled model provider policy from current preferences", async (t) => {
   const dir = join(
     tmpdir(),

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

@@ -0,0 +1,166 @@
+// 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,
+  isClaudeCodeSessionSwitchAbortMessage,
+} from "../bootstrap/agent-end-recovery.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("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/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 });