gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/extensions/gsd/tests/schema-v27-v28-sequence.test.ts

@@ -0,0 +1,156 @@
+// gsd-2 / V27 + V28 schema migration regression tests
+//
+// Same bug class as #4591 (schema-v21-sequence): a migration block can be
+// added but the SCHEMA_VERSION constant left unchanged, causing fresh-install
+// + upgrade paths to silently skip the column add. This file pins both V27
+// (artifacts.content_hash) and V28 (memories.last_hit_at) at the schema and
+// write-path level on fresh-install DBs.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  _getAdapter,
+  insertArtifact,
+  insertMemoryRow,
+  incrementMemoryHitCount,
+  SCHEMA_VERSION,
+} from "../gsd-db.ts";
+
+function makeTmp(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "gsd-v27v28-"));
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { fs.rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("SCHEMA_VERSION constant is at least 28 (V28 migration committed)", () => {
+  assert.ok(
+    SCHEMA_VERSION >= 28,
+    `SCHEMA_VERSION must be ≥ 28 after V28 migration; got ${SCHEMA_VERSION}`,
+  );
+});
+
+test("fresh-install DB has artifacts.content_hash column (V27)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const cols = db.prepare("PRAGMA table_info(artifacts)").all() as Array<Record<string, unknown>>;
+    const colNames = new Set(cols.map((c) => c["name"] as string));
+    assert.ok(
+      colNames.has("content_hash"),
+      "V27 must add content_hash column to artifacts on fresh install",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("fresh-install DB has memories.last_hit_at column (V28)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const cols = db.prepare("PRAGMA table_info(memories)").all() as Array<Record<string, unknown>>;
+    const colNames = new Set(cols.map((c) => c["name"] as string));
+    assert.ok(
+      colNames.has("last_hit_at"),
+      "V28 must add last_hit_at column to memories on fresh install",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("fresh-install DB stamps SCHEMA_VERSION (≥28) in schema_version table", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get() as Record<string, unknown> | undefined;
+    const max = (row?.["v"] as number) ?? 0;
+    assert.ok(max >= 28, `fresh install must record schema_version ≥ 28; got ${max}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("insertArtifact populates content_hash with SHA-256 of full_content (V27 write-path)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    insertArtifact({
+      path: "M001/PROJECT.md",
+      artifact_type: "PROJECT",
+      milestone_id: "M001",
+      slice_id: null,
+      task_id: null,
+      full_content: "hello world",
+    });
+
+    const db = _getAdapter()!;
+    const row = db
+      .prepare("SELECT content_hash FROM artifacts WHERE path = :p")
+      .get({ ":p": "M001/PROJECT.md" }) as Record<string, unknown> | undefined;
+    const hash = row?.["content_hash"] as string | null | undefined;
+
+    // SHA-256 of "hello world" hex-encoded:
+    const expected = "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9";
+    assert.equal(hash, expected, "content_hash must be SHA-256 hex of full_content");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("incrementMemoryHitCount sets last_hit_at alongside hit_count (V28 write-path)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+
+    const created = "2026-01-01T00:00:00.000Z";
+    insertMemoryRow({
+      id: "MEM001",
+      category: "gotcha",
+      content: "test memory",
+      confidence: 0.9,
+      sourceUnitType: null,
+      sourceUnitId: null,
+      createdAt: created,
+      updatedAt: created,
+      scope: "project",
+      tags: [],
+      structuredFields: null,
+    });
+
+    // Before increment: last_hit_at should be NULL
+    const db = _getAdapter()!;
+    const before = db
+      .prepare("SELECT last_hit_at FROM memories WHERE id = :id")
+      .get({ ":id": "MEM001" }) as Record<string, unknown>;
+    assert.equal(before["last_hit_at"], null, "last_hit_at starts NULL on fresh insert");
+
+    const hitTime = "2026-02-01T00:00:00.000Z";
+    incrementMemoryHitCount("MEM001", hitTime);
+
+    const after = db
+      .prepare("SELECT hit_count, last_hit_at FROM memories WHERE id = :id")
+      .get({ ":id": "MEM001" }) as Record<string, unknown>;
+    assert.equal(after["hit_count"], 1, "hit_count increments");
+    assert.equal(after["last_hit_at"], hitTime, "last_hit_at set to provided timestamp");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/select-resumable-milestone.test.ts

@@ -0,0 +1,96 @@
+// GSD-2 + src/resources/extensions/gsd/tests/select-resumable-milestone.test.ts
+// Regression: bootstrap must rederive `currentMilestoneId` from an unmerged
+// completed milestone branch when in-memory state was lost across a process
+// restart (#5538-followup).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _selectResumableMilestone } from "../auto-start.js";
+
+const ALL_COMPLETE = (_id: string) => true;
+const NEVER_COMPLETE = (_id: string) => false;
+const HAS_COMMITS = (_branch: string) => 1;
+const NO_COMMITS = (_branch: string) => 0;
+
+test("returns null when no branches exist", () => {
+  const result = _selectResumableMilestone([], new Set(), ALL_COMPLETE, HAS_COMMITS);
+  assert.equal(result, null);
+});
+
+test("returns null when every milestone branch is already merged", () => {
+  const branches = ["milestone/M001", "milestone/M002"];
+  const merged = new Set(branches);
+  const result = _selectResumableMilestone(branches, merged, ALL_COMPLETE, HAS_COMMITS);
+  assert.equal(result, null);
+});
+
+test("returns null when no candidate milestones are complete", () => {
+  const branches = ["milestone/M002"];
+  const result = _selectResumableMilestone(branches, new Set(), NEVER_COMPLETE, HAS_COMMITS);
+  assert.equal(result, null);
+});
+
+test("returns null when no branch has commits ahead", () => {
+  const branches = ["milestone/M002"];
+  const result = _selectResumableMilestone(branches, new Set(), ALL_COMPLETE, NO_COMMITS);
+  assert.equal(result, null);
+});
+
+test("returns the unmerged completed milestone (regression: M002 stranded after restart)", () => {
+  // Repro of test12345 state: M001 ✅ merged, M002 ✅ unmerged, M003 🔄.
+  // Bootstrap must seed currentMilestoneId = "M002" so the loop's transition
+  // guard fires when the next iteration sees mid="M003".
+  const branches = ["milestone/M002", "milestone/M003"];
+  const merged = new Set<string>(); // none merged from this list
+  const isComplete = (id: string) => id === "M002"; // M003 still in progress
+  const result = _selectResumableMilestone(branches, merged, isComplete, HAS_COMMITS);
+  assert.equal(result, "M002");
+});
+
+test("picks the lex-greatest milestone when multiple candidates exist", () => {
+  // M001, M002 both unmerged complete -> pick M002 (the most recent).
+  const branches = ["milestone/M001", "milestone/M002"];
+  const result = _selectResumableMilestone(
+    branches,
+    new Set(),
+    ALL_COMPLETE,
+    HAS_COMMITS,
+  );
+  assert.equal(result, "M002");
+});
+
+test("ignores branch names that don't follow the milestone/ prefix", () => {
+  const branches = ["feature/something", "milestone/M002", "fix/bug-1"];
+  const result = _selectResumableMilestone(
+    branches,
+    new Set(),
+    ALL_COMPLETE,
+    HAS_COMMITS,
+  );
+  assert.equal(result, "M002");
+});
+
+test("isComplete callback throwing skips that milestone but does not crash", () => {
+  const branches = ["milestone/M001", "milestone/M002"];
+  const isComplete = (id: string) => {
+    if (id === "M001") throw new Error("db unavailable for M001");
+    return true;
+  };
+  // Implementation choice: a thrown isComplete is propagated. Wrapping in
+  // try/catch happens at the production wrapper level (findUnmergedCompletedMilestone).
+  // Verify the helper itself surfaces the error so callers see real failures.
+  assert.throws(() => _selectResumableMilestone(branches, new Set(), isComplete, HAS_COMMITS));
+});
+
+test("commitsAhead callback throwing for one branch falls through to others", () => {
+  // Production wrapper: commits-ahead failures should not abort the search.
+  // The helper catches throws from commitsAhead per-branch and treats as 0.
+  const branches = ["milestone/M001", "milestone/M002"];
+  const commitsAhead = (branch: string) => {
+    if (branch === "milestone/M001") throw new Error("rev-walk failed");
+    return 5;
+  };
+  const result = _selectResumableMilestone(branches, new Set(), ALL_COMPLETE, commitsAhead);
+  assert.equal(result, "M002");
+});

package/src/resources/extensions/gsd/tests/session-model-override.test.ts

@@ -1,7 +1,5 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 
 import {
   clearSessionModelOverride,
@@ -9,8 +7,6 @@ import {
   setSessionModelOverride,
 } from "../session-model-override.js";
 
-const phasesSource = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
-
 test("setSessionModelOverride stores provider/model for the session", () => {
   const sessionId = `session-override-${Date.now()}`;
   setSessionModelOverride(sessionId, { provider: "openai-codex", id: "gpt-5.4" });
@@ -27,9 +23,18 @@ test("clearSessionModelOverride removes the session override", () => {
   assert.equal(getSessionModelOverride(sessionId), undefined);
 });
 
-test("auto dispatch threads manual session model override into selectAndApplyModel", () => {
-  assert.ok(
-    phasesSource.includes("s.manualSessionModelOverride"),
-    "auto/phases.ts should pass s.manualSessionModelOverride into selectAndApplyModel",
-  );
+test("session model overrides are isolated by session id", () => {
+  const first = `session-first-${Date.now()}`;
+  const second = `session-second-${Date.now()}`;
+  setSessionModelOverride(first, { provider: "openai-codex", id: "gpt-5.4" });
+  setSessionModelOverride(second, { provider: "anthropic", id: "claude-sonnet-4-6" });
+
+  assert.deepEqual(getSessionModelOverride(first), {
+    provider: "openai-codex",
+    id: "gpt-5.4",
+  });
+  assert.deepEqual(getSessionModelOverride(second), {
+    provider: "anthropic",
+    id: "claude-sonnet-4-6",
+  });
 });

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,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");
+});