gsd-pi 2.78.0-dev.aeeb2ca00 → 2.78.1-dev.0fdacd524

package/src/resources/extensions/gsd/tests/google-search-stub.test.ts

@@ -11,26 +11,23 @@ test("google-search stub: default export is a function", async (_t) => {
   assert.equal(typeof stubFn, "function");
 });
 
-test("google-search stub: registers session_start handler", async (_t) => {
-  // STUB-01: stub calls pi.on("session_start", ...)
+test("google-search stub: registers no event handlers", async (_t) => {
+  // STUB-01: deprecation notice is suppressed — stub must not call pi.on() at all
   const mod = await import("../../google-search/index.ts");
   const stubFn = mod.default;
 
-  let capturedEvent: string | undefined;
-  let capturedHandler: unknown;
+  let onCallCount = 0;
 
   const mockPi = {
-    on(event: string, handler: unknown) {
-      capturedEvent = event;
-      capturedHandler = handler;
+    on(_event: string, _handler: unknown) {
+      onCallCount++;
     },
     registerTool: () => {},
   };
 
   stubFn(mockPi as never);
 
-  assert.equal(capturedEvent, "session_start");
-  assert.equal(typeof capturedHandler, "function");
+  assert.equal(onCallCount, 0, "stub should not register any event handlers");
 });
 
 test("google-search stub: does NOT call registerTool", async (_t) => {
@@ -50,82 +47,45 @@ test("google-search stub: does NOT call registerTool", async (_t) => {
   assert.equal(registerToolCalled, false);
 });
 
-test("google-search stub: session_start warning contains package name", async (_t) => {
-  // STUB-01: warning includes @gsd-extensions/google-search
+test("google-search stub: does not emit any notifications", async (_t) => {
+  // STUB-01: deprecation notice is suppressed — stub must not call ctx.ui.notify()
   const mod = await import("../../google-search/index.ts");
   const stubFn = mod.default;
 
-  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+  let notifyCallCount = 0;
 
   const mockPi = {
-    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
-      capturedHandler = handler;
-    },
+    on(_event: string, _handler: unknown) {},
     registerTool: () => {},
   };
 
+  // Verify no notify is emitted by the stub itself (it registers no handlers,
+  // so there is nothing to invoke — this simply confirms no top-level notify call).
   stubFn(mockPi as never);
 
-  assert.ok(capturedHandler, "session_start handler should have been registered");
-
-  let capturedMessage: string | undefined;
-  const mockCtx = {
-    ui: {
-      notify(message: string, _level: string) {
-        capturedMessage = message;
-      },
-    },
-  };
-
-  await capturedHandler!({}, mockCtx);
-
-  assert.ok(
-    capturedMessage?.includes("@gsd-extensions/google-search"),
-    `Expected message to include "@gsd-extensions/google-search", got: "${capturedMessage}"`,
-  );
+  assert.equal(notifyCallCount, 0, "stub should not emit any notifications");
 });
 
-test("google-search stub: session_start warning explains package is not yet published", async (_t) => {
-  // STUB-01: stub must NOT advise `gsd extensions install` — the replacement
-  // package is not yet on npm, so that command would 404. The message must
-  // explain the extraction is in progress and no user action is required.
+test("google-search stub: is a complete no-op (no handlers, no tools, no notifications)", async (_t) => {
+  // STUB-01: the deprecation notice is suppressed until @gsd-extensions/google-search
+  // ships. The stub must call nothing on the ExtensionAPI.
   const mod = await import("../../google-search/index.ts");
   const stubFn = mod.default;
 
-  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+  let onCallCount = 0;
+  let registerToolCallCount = 0;
 
   const mockPi = {
-    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
-      capturedHandler = handler;
+    on(_event: string, _handler: unknown) {
+      onCallCount++;
+    },
+    registerTool: () => {
+      registerToolCallCount++;
     },
-    registerTool: () => {},
   };
 
   stubFn(mockPi as never);
 
-  assert.ok(capturedHandler, "session_start handler should have been registered");
-
-  let capturedMessage: string | undefined;
-  const mockCtx = {
-    ui: {
-      notify(message: string, _level: string) {
-        capturedMessage = message;
-      },
-    },
-  };
-
-  await capturedHandler!({}, mockCtx);
-
-  assert.ok(
-    !capturedMessage?.includes("gsd extensions install"),
-    `Expected message NOT to include unpublished install command, got: "${capturedMessage}"`,
-  );
-  assert.ok(
-    capturedMessage?.includes("not yet published"),
-    `Expected message to include "not yet published", got: "${capturedMessage}"`,
-  );
-  assert.ok(
-    capturedMessage?.includes("No action needed"),
-    `Expected message to include "No action needed", got: "${capturedMessage}"`,
-  );
+  assert.equal(onCallCount, 0, "stub should not register any event handlers");
+  assert.equal(registerToolCallCount, 0, "stub should not register any tools");
 });

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

@@ -18,6 +18,8 @@ import {
   getActiveDecisions,
   getActiveRequirements,
   transaction,
+  readTransaction,
+  isInTransaction,
   _getAdapter,
   _resetProvider,
   insertMilestone,
@@ -383,6 +385,34 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test('gsd-db: failed BEGIN does not poison transaction depth', () => {
+    openDatabase(':memory:');
+    const adapter = _getAdapter()!;
+
+    const assertFailedBeginLeavesDepthClear = (label: string, fn: () => void) => {
+      adapter.exec('BEGIN');
+      try {
+        let threw = false;
+        try {
+          fn();
+        } catch {
+          threw = true;
+        }
+        assert.equal(threw, true, `${label} should surface the SQLite BEGIN failure`);
+        assert.equal(isInTransaction(), false, `${label} failed BEGIN must not leave depth active`);
+      } finally {
+        adapter.exec('ROLLBACK');
+      }
+    };
+
+    try {
+      assertFailedBeginLeavesDepthClear('transaction', () => transaction(() => undefined));
+      assertFailedBeginLeavesDepthClear('readTransaction', () => readTransaction(() => undefined));
+    } finally {
+      closeDatabase();
+    }
+  });
+
   test('gsd-db: recreates missing verification evidence dedup index after removing duplicate rows', () => {
     const dbPath = tempDbPath();
     openDatabase(dbPath);

package/src/resources/extensions/gsd/tests/gsd-no-project-error-runtime.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Runtime regression — `projectRoot()` throws `GSDNoProjectError` when
+ * invoked outside a project directory (#4902).
+ *
+ * The deleted `gsd-no-project-error.test.ts` was a source-grep check.
+ * This rewrite chdirs to $HOME, calls the real `projectRoot()`, and
+ * asserts a `GSDNoProjectError` is thrown with the project-required
+ * message.
+ */
+
+import { describe, test, after } from 'node:test';
+import assert from 'node:assert/strict';
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { projectRoot, GSDNoProjectError } from '../commands/context.ts';
+
+const ORIGINAL_CWD = process.cwd();
+
+after(() => {
+  try { process.chdir(ORIGINAL_CWD); } catch { /* swallow */ }
+});
+
+describe('projectRoot() throws GSDNoProjectError outside a project (#4902)', () => {
+  test('throws GSDNoProjectError when cwd is $HOME', () => {
+    const home = os.homedir();
+    process.chdir(home);
+    try {
+      assert.throws(
+        () => projectRoot(),
+        (err: unknown) => {
+          assert.ok(err instanceof GSDNoProjectError, 'should throw GSDNoProjectError');
+          assert.match(
+            (err as Error).message,
+            /home directory|project directory/i,
+            'error message should mention home/project directory',
+          );
+          return true;
+        },
+      );
+    } finally {
+      process.chdir(ORIGINAL_CWD);
+    }
+  });
+
+  test('throws GSDNoProjectError when cwd is the system tmpdir root', () => {
+    // Use realpath to dodge symlinks blocking the cwd
+    const tmpRoot = fs.realpathSync(os.tmpdir());
+    // Some systems make tmpdir a subdirectory; only run when it normalizes
+    // to a known-blocked root. validateDirectory blocks /tmp + /var/folders
+    // tmp roots; build a small subdir under tmp and then assert that the
+    // raw tmpdir root itself blocks. We just use it directly.
+    process.chdir(tmpRoot);
+    try {
+      // Behaviour: either we get a GSDNoProjectError (blocked tmpdir root) or
+      // we don't — but in the case where we don't (tmpdir is somehow allowed
+      // as a project root on this machine), the test is vacuously satisfied
+      // by the prior $HOME case. We assert the type-narrowing path instead:
+      let threw: unknown = null;
+      try { projectRoot(); } catch (err) { threw = err; }
+      if (threw !== null) {
+        assert.ok(
+          threw instanceof GSDNoProjectError,
+          'if projectRoot throws, it must be a GSDNoProjectError (typed)',
+        );
+      }
+    } finally {
+      process.chdir(ORIGINAL_CWD);
+    }
+  });
+});
+
+describe('GSDNoProjectError shape (#4902)', () => {
+  test('GSDNoProjectError extends Error and carries its name', () => {
+    const err = new GSDNoProjectError('test reason');
+    assert.ok(err instanceof Error);
+    assert.equal(err.name, 'GSDNoProjectError');
+    assert.equal(err.message, 'test reason');
+  });
+});

package/src/resources/extensions/gsd/tests/headless-answers.test.ts

@@ -6,7 +6,7 @@
  * secrets, stats, and unused warnings).
  */
 
-import test from 'node:test';
+import test, { mock } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
@@ -164,7 +164,15 @@ test('tryHandle matches by question ID — single select', (t) => {
   assert.strictEqual(injector.getStats().questionsAnswered, 1);
 });
 
-test('tryHandle unknown question deferred — first_option timeout', async (t) => {
+test('tryHandle unknown question deferred — first_option timeout', (t) => {
+  // Use Node's MockTimers instead of a real-time setTimeout race. The
+  // production class schedules an internal setTimeout to default the
+  // answer when no metadata arrives — driving virtual time advances that
+  // timer deterministically, regardless of the literal ms value the
+  // production code chose.
+  mock.timers.enable({ apis: ['setTimeout'] });
+  t.after(() => { mock.timers.reset(); });
+
   const injector = new AnswerInjector({ defaults: { strategy: 'first_option' } });
 
   const captured: string[] = [];
@@ -177,8 +185,10 @@ test('tryHandle unknown question deferred — first_option timeout', async (t) =
   assert.strictEqual(handled, true);
   assert.strictEqual(captured.length, 0, 'nothing sent immediately');
 
-  // Wait for the 500ms deferred timeout to fire
-  await new Promise((resolve) => setTimeout(resolve, 600));
+  // Advance virtual time past any internal defer timeout (well above any
+  // reasonable defer cap). MockTimers fires synchronously, so by the time
+  // tick() returns the deferred handler has run.
+  mock.timers.tick(60_000);
 
   assert.strictEqual(captured.length, 1);
   const response = JSON.parse(captured[0].trim());

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -66,16 +66,22 @@ test("detectHealthWidgetProjectState: milestone without metrics returns active",
   assert.equal(detectHealthWidgetProjectState(dir), "active");
 });
 
-test("buildHealthLines: none state shows onboarding copy", (t) => {
-  assert.deepEqual(buildHealthLines(activeData({ projectState: "none" })), [
-    "  GSD  No project loaded — run /gsd to start",
-  ]);
+test("buildHealthLines: none state shows single onboarding line pointing at /gsd", (t) => {
+  const lines = buildHealthLines(activeData({ projectState: "none" }));
+  assert.equal(lines.length, 1, "renders exactly one line");
+  // Should not show System OK / Budget / Last commit chrome when there's no project.
+  assert.ok(!/System OK|Budget|Last commit/.test(lines[0]!), "no active-project chrome");
+  // Should direct user to bootstrap via /gsd.
+  assert.match(lines[0]!, /\/gsd/);
 });
 
-test("buildHealthLines: initialized state shows continue setup copy", (t) => {
-  assert.deepEqual(buildHealthLines(activeData({ projectState: "initialized" })), [
-    "  GSD  Project initialized — run /gsd to continue setup",
-  ]);
+test("buildHealthLines: initialized state shows single setup line pointing at /gsd", (t) => {
+  const lines = buildHealthLines(activeData({ projectState: "initialized" }));
+  assert.equal(lines.length, 1, "renders exactly one line");
+  assert.ok(!/System OK|Budget|Last commit/.test(lines[0]!), "no active-project chrome");
+  // Distinct from "none" — must mention initialized/setup language and /gsd.
+  assert.match(lines[0]!, /\/gsd/);
+  assert.match(lines[0]!, /initiali[sz]ed|setup/i);
 });
 
 test("buildHealthLines: active state with ledger-driven spend shows spent summary", (t) => {
@@ -115,16 +121,20 @@ test("buildHealthLines: shows last commit with relative time and message", (t) =
   assert.match(lines[0]!, /feat\(widget\): add health display/);
 });
 
-test("buildHealthLines: truncates long commit messages", (t) => {
+test("buildHealthLines: truncates long commit messages with ellipsis", (t) => {
   const epoch = Math.floor(Date.now() / 1000) - 60;
-  const longMsg = "a".repeat(80);
+  const longMsg = "a".repeat(200); // far longer than any reasonable widget cap
   const lines = buildHealthLines(activeData({
     lastCommitEpoch: epoch,
     lastCommitMessage: longMsg,
   }));
   assert.equal(lines.length, 1);
-  assert.match(lines[0]!, /a{49}…/);
-  assert.ok(!lines[0]!.includes("a".repeat(51)), "message is truncated");
+  // Behavioural contract: rendered output is shorter than the input message
+  // and ends the message portion with the ellipsis character.
+  const aRun = lines[0]!.match(/a+…/);
+  assert.ok(aRun, "rendered output contains a run of a-chars terminated by an ellipsis");
+  assert.ok(aRun![0].length - 1 < longMsg.length, "truncated message is shorter than input");
+  assert.ok(!lines[0]!.includes("a".repeat(longMsg.length)), "untruncated message must not appear in output");
 });
 
 test("buildHealthLines: no last commit section when epoch is null", (t) => {

package/src/resources/extensions/gsd/tests/help-menu-coverage.test.ts

@@ -0,0 +1,57 @@
+// GSD-2 — Verify /gsd help menu covers all registered commands
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { TOP_LEVEL_SUBCOMMANDS } from "../commands/catalog.ts";
+
+/**
+ * Extracts command names from the showHelp("full") lines array.
+ * Each help line follows the pattern: "  /gsd <cmd>  ..."
+ */
+function extractHelpCommands(lines: string[]): Set<string> {
+  const cmds = new Set<string>();
+  for (const line of lines) {
+    const m = line.match(/^\s+\/gsd\s+(\S+)/);
+    if (m) cmds.add(m[1]);
+  }
+  return cmds;
+}
+
+describe("help menu coverage", () => {
+  test("every TOP_LEVEL_SUBCOMMAND appears in showHelp(\"full\") output", async () => {
+    // Import showHelp and capture its output via a mock ctx
+    const lines: string[] = [];
+    const mockCtx = {
+      ui: {
+        notify(message: string) {
+          lines.push(...message.split("\n"));
+        },
+        custom: async () => {},
+      },
+    };
+
+    const { showHelp } = await import("../commands/handlers/core.ts");
+    showHelp(mockCtx as any, "full");
+
+    const helpCmds = extractHelpCommands(lines);
+
+    // "help" is the command that shows the menu — it doesn't list itself
+    const SELF_REFERENTIAL = new Set(["help"]);
+
+    const missing: string[] = [];
+    for (const entry of TOP_LEVEL_SUBCOMMANDS) {
+      if (SELF_REFERENTIAL.has(entry.cmd)) continue;
+      if (!helpCmds.has(entry.cmd)) {
+        missing.push(entry.cmd);
+      }
+    }
+
+    assert.deepStrictEqual(
+      missing,
+      [],
+      `Commands registered in TOP_LEVEL_SUBCOMMANDS but missing from /gsd help full:\n  ${missing.join(", ")}`,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/home-dir.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Tests for getHomeDir() — cross-platform home directory resolution.
+ *
+ * @see https://github.com/gsd-build/gsd-2/issues/5015
+ */
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+
+describe("getHomeDir", () => {
+  let savedHome: string | undefined;
+  let savedUserProfile: string | undefined;
+  let getHomeDir: () => string;
+
+  beforeEach(async () => {
+    savedHome = process.env.HOME;
+    savedUserProfile = process.env.USERPROFILE;
+    const mod = await import("../home-dir.ts");
+    getHomeDir = mod.getHomeDir;
+  });
+
+  afterEach(() => {
+    if (savedHome !== undefined) {
+      process.env.HOME = savedHome;
+    } else {
+      delete process.env.HOME;
+    }
+    if (savedUserProfile !== undefined) {
+      process.env.USERPROFILE = savedUserProfile;
+    } else {
+      delete process.env.USERPROFILE;
+    }
+  });
+
+  it("returns HOME when set", () => {
+    process.env.HOME = "/test/home";
+    delete process.env.USERPROFILE;
+    assert.equal(getHomeDir(), "/test/home");
+  });
+
+  it("falls back to USERPROFILE when HOME is unset", () => {
+    delete process.env.HOME;
+    process.env.USERPROFILE = String.raw`C:\Users\test`;
+    assert.equal(getHomeDir(), String.raw`C:\Users\test`);
+  });
+
+  it("falls back to os.homedir() when both HOME and USERPROFILE are unset", () => {
+    delete process.env.HOME;
+    delete process.env.USERPROFILE;
+    assert.equal(getHomeDir(), homedir());
+  });
+});

package/src/resources/extensions/gsd/tests/import-done-milestones-runtime.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Runtime regression — milestones with all-done roadmap slices import as
+ * `complete` (#3699 / #3390 / #3379), follow-up #4902.
+ *
+ * The deleted `import-done-milestones.test.ts` was a source-grep check
+ * for the literal `roadmap.slices.every(s => s.done)`. This rewrite
+ * exercises `migrateHierarchyToDb()` against a fixture roadmap whose
+ * slices are all `[x]` and asserts the milestone row's `status` is
+ * `complete` — the actual behaviour the every() check exists to
+ * produce.
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  getAllMilestones,
+} from '../gsd-db.ts';
+import { migrateHierarchyToDb } from '../md-importer.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-import-done-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, '.gsd', relativePath);
+  mkdirSync(join(full, '..'), { recursive: true });
+  writeFileSync(full, content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+const ROADMAP_ALL_DONE = `# M001: Finished Milestone
+
+**Vision:** Done work.
+
+## Slices
+
+- [x] **S01: First Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+
+- [x] **S02: Second Slice** \`risk:medium\` \`depends:[S01]\`
+  > After this: Also done.
+`;
+
+const ROADMAP_PARTIAL = `# M002: In-Progress Milestone
+
+**Vision:** Mid-flight.
+
+## Slices
+
+- [x] **S01: Done Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+
+- [ ] **S02: Pending Slice** \`risk:medium\` \`depends:[S01]\`
+  > After this: TBD.
+`;
+
+const ROADMAP_EMPTY = `# M003: Empty Milestone
+
+**Vision:** No slices yet.
+
+## Slices
+
+`;
+
+describe('migrateHierarchyToDb: all-done milestones import as complete (#4902)', () => {
+  test('milestone with all [x] slices and no SUMMARY imports as complete', () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+      // No SUMMARY.md — the all-done roadmap check is the authoritative signal.
+
+      openDatabase(':memory:');
+      migrateHierarchyToDb(base);
+
+      const milestones = getAllMilestones();
+      const m001 = milestones.find((m) => m.id === 'M001');
+      assert.ok(m001, 'M001 should be imported');
+      assert.equal(
+        m001!.status,
+        'complete',
+        'milestone with all-done slices must import as complete',
+      );
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('milestone with one pending slice imports as active (negative case)', () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M002/M002-ROADMAP.md', ROADMAP_PARTIAL);
+
+      openDatabase(':memory:');
+      migrateHierarchyToDb(base);
+
+      const milestones = getAllMilestones();
+      const m002 = milestones.find((m) => m.id === 'M002');
+      assert.ok(m002, 'M002 should be imported');
+      assert.equal(
+        m002!.status,
+        'active',
+        'milestone with at least one pending slice must NOT be marked complete',
+      );
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('milestone with empty slice list does not import as complete', () => {
+    // Guards the `roadmap.slices.length > 0` precondition: an empty roadmap
+    // must not be misread as "everything is done" (vacuous truth bug).
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M003/M003-ROADMAP.md', ROADMAP_EMPTY);
+
+      openDatabase(':memory:');
+      migrateHierarchyToDb(base);
+
+      const milestones = getAllMilestones();
+      const m003 = milestones.find((m) => m.id === 'M003');
+      assert.ok(m003, 'M003 should be imported');
+      assert.notEqual(
+        m003!.status,
+        'complete',
+        'empty roadmap (no slices) must not import as complete',
+      );
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+});