@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/replan-handler.test.ts

@@ -21,7 +21,7 @@ import { parsePlan } from '../parsers-legacy.ts';
 
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-replan-'));
-  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'phases', '01-test'), { recursive: true });
   return base;
 }
 
@@ -230,11 +230,11 @@ test('handleReplanSlice succeeds when modifying only incomplete tasks', async ()
     assert.equal(t01?.status, 'complete');
 
     // Verify rendered PLAN.md exists on disk
-    const planPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-01-PLAN.md');
     assert.ok(existsSync(planPath), 'PLAN.md should be rendered to disk');
 
     // Verify REPLAN.md exists on disk
-    const replanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-REPLAN.md');
+    const replanPath = join(base, '.gsd', 'phases', '01-test', '01-01-REPLAN.md');
     assert.ok(existsSync(replanPath), 'REPLAN.md should be rendered to disk');
     const replanContent = readFileSync(replanPath, 'utf-8');
     assert.ok(replanContent.includes('Blocker Description'), 'REPLAN.md should contain blocker section');
@@ -272,7 +272,7 @@ test('handleReplanSlice cache invalidation: re-parsing PLAN.md reflects mutation
     assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
 
     // Re-parse PLAN.md from disk to verify cache invalidation worked
-    const planPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-01-PLAN.md');
     const content = readFileSync(planPath, 'utf-8');
     const parsed = parsePlan(content);
 

package/src/resources/extensions/gsd/tests/resume-missing-worktree-warning.test.ts

@@ -114,19 +114,19 @@ describe("resume: missing worktree warning emission", () => {
     assert.equal(peekLogs().length, 0);
   });
 
-  test("warning message mentions project-root fallback action", () => {
+  test("warning message mentions project-root fallback and worktree recreation", () => {
     const missingPath = join(projectDir, ".gsd", "worktrees", "M099-deleted");
     _warnIfWorktreeMissingForTest(missingPath, "M099");
 
     const logs = peekLogs();
     assert.equal(logs.length, 1);
     assert.ok(
-      logs[0].message.includes("project-root mode"),
-      "warning should mention project-root mode fallback",
+      logs[0].message.includes("project root"),
+      "warning should mention project-root fallback",
     );
     assert.ok(
-      logs[0].message.includes("gsd-debug"),
-      "warning should suggest /gsd-debug recovery action",
+      logs[0].message.includes("/gsd next"),
+      "warning should suggest /gsd next to recreate the worktree",
     );
   });
 });

package/src/resources/extensions/gsd/tests/round-trip-property.test.ts

@@ -0,0 +1,137 @@
+// Project/App: gsd-pi
+// File Purpose: Round-trip property test — for any gsd-core .gsd/ fixture,
+// import → render → import must produce a stable hierarchy snapshot, and
+// re-rendering must produce stable markdown. Catches lossy-projection bugs
+// that would otherwise silently destroy state across cross-tool round-trips.
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { cpSync, mkdtempSync, rmSync, readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+import { openDatabase, closeDatabase, getAllMilestones, getMilestoneSlices, getSliceTasks } from "../gsd-db.ts";
+import { migrateHierarchyToDb } from "../md-importer.ts";
+import { renderAllFromDb } from "../markdown-renderer.ts";
+import { invalidateStateCache } from "../state.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURE_ROOT = join(__dirname, "__fixtures__", "round-trip");
+
+const tmpDirs: string[] = [];
+afterEach(() => {
+  closeDatabase();
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+function copyFixture(name: string): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-rt-${randomUUID()}`));
+  cpSync(join(FIXTURE_ROOT, name), base, { recursive: true });
+  tmpDirs.push(base);
+  return base;
+}
+
+interface HierarchySnapshot {
+  milestones: Array<{ id: string; title: string; status: string }>;
+  slices: Array<{ mid: string; id: string; title: string; status: string }>;
+  tasks: Array<{ mid: string; sid: string; id: string; title: string; status: string }>;
+}
+
+function snapshotHierarchy(): HierarchySnapshot {
+  const milestones = getAllMilestones().map((m) => ({ id: m.id, title: m.title, status: m.status }));
+  const slices: HierarchySnapshot["slices"] = [];
+  const tasks: HierarchySnapshot["tasks"] = [];
+  for (const m of milestones) {
+    for (const s of getMilestoneSlices(m.id)) {
+      slices.push({ mid: m.id, id: s.id, title: s.title, status: s.status });
+      for (const t of getSliceTasks(m.id, s.id)) {
+        tasks.push({ mid: m.id, sid: s.id, id: t.id, title: t.title, status: t.status });
+      }
+    }
+  }
+  // Sort for stable comparison across DB row-order variations.
+  const cmp = <T extends { id: string }>(a: T, b: T) => a.id.localeCompare(b.id);
+  milestones.sort(cmp);
+  slices.sort((a, b) => `${a.mid}/${a.id}`.localeCompare(`${b.mid}/${b.id}`));
+  tasks.sort((a, b) => `${a.mid}/${a.sid}/${a.id}`.localeCompare(`${b.mid}/${b.sid}/${b.id}`));
+  return { milestones, slices, tasks };
+}
+
+test("round-trip is stable: import → render → import produces the same hierarchy snapshot", async () => {
+  // Only .gsd/-bearing fixtures — the .planning/ fixtures belong to the
+  // planning round-trip suite (different layout, no .gsd/ to import from).
+  const fixtures = readdirSync(FIXTURE_ROOT, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && existsSync(join(FIXTURE_ROOT, d.name, ".gsd")))
+    .map((d) => d.name);
+
+  assert.ok(fixtures.length > 0, "expected at least one round-trip fixture");
+
+  for (const name of fixtures) {
+    const base = copyFixture(name);
+    openDatabase(join(base, ".gsd", "gsd.db"));
+
+    // Pass 1: import fixture markdown → DB
+    migrateHierarchyToDb(base);
+    invalidateStateCache();
+    const snapshot1 = snapshotHierarchy();
+    assert.ok(snapshot1.milestones.length > 0, `fixture ${name}: expected at least one milestone after import`);
+
+    // Render DB → markdown (projection)
+    const render1 = await renderAllFromDb(base);
+    assert.deepEqual(render1.errors, [], `pass 1 render errors for ${name}: ${JSON.stringify(render1.errors)}`);
+
+    // Pass 2: re-import the projected markdown → DB. migrateHierarchyToDb is
+    // an idempotent upsert (INSERT OR IGNORE), so this simulates a second tool
+    // opening the re-projected files and importing them.
+    migrateHierarchyToDb(base);
+    invalidateStateCache();
+    const snapshot2 = snapshotHierarchy();
+
+    // Property: hierarchy must be stable across the round-trip.
+    assert.deepEqual(
+      snapshot2,
+      snapshot1,
+      `round-trip drift for fixture ${name}: hierarchy changed across import → render → import`,
+    );
+  }
+});
+
+test("round-trip is idempotent: rendering twice produces stable markdown", async () => {
+  const fixtures = readdirSync(FIXTURE_ROOT, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && existsSync(join(FIXTURE_ROOT, d.name, ".gsd")))
+    .map((d) => d.name);
+
+  for (const name of fixtures) {
+    const base = copyFixture(name);
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    migrateHierarchyToDb(base);
+    invalidateStateCache();
+    await renderAllFromDb(base);
+
+    // Snapshot all rendered markdown files (normalized: CRLF→LF, trailing
+    // whitespace trimmed) so cosmetic differences don't false-positive.
+    const snapshotFiles = (b: string): Record<string, string> => {
+      const out: Record<string, string> = {};
+      const walk = (dir: string) => {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+          const p = join(dir, e.name);
+          if (e.isDirectory()) walk(p);
+          else if (e.name.endsWith(".md")) {
+            out[p.replace(b + "/", "")] = readFileSync(p, "utf-8").replace(/\r\n/g, "\n").replace(/[ \t]+\n/g, "\n");
+          }
+        }
+      };
+      walk(join(b, ".gsd"));
+      return out;
+    };
+    const after1 = snapshotFiles(base);
+
+    // Render again
+    await renderAllFromDb(base);
+    const after2 = snapshotFiles(base);
+
+    assert.deepEqual(after2, after1, `re-rendering changed markdown for fixture ${name}`);
+  }
+});

package/src/resources/extensions/gsd/tests/session-lock-transient-read.test.ts

@@ -8,6 +8,7 @@
  *
  * Tests:
  *   - readExistingLockDataWithRetry retries on transient read failure
+ *   - readExistingLockDataWithRetry sleeps between retries without CPU spin
  *   - readExistingLockDataWithRetry returns data when file becomes readable after retries
  *   - readExistingLockDataWithRetry returns null only when ALL retries exhausted
  *   - onCompromised does not declare compromise when lock file is transiently unreadable
@@ -75,6 +76,31 @@ async function main(): Promise<void> {
     }
   }
 
+  // ─── 2b. Retry delay sleeps without CPU spin ──────────────────────────────
+  console.log('\n=== 2b. readExistingLockDataWithRetry sleeps between retry attempts ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-transient-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+    const originalWait = Atomics.wait;
+    const waits: Array<number | undefined> = [];
+
+    try {
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      Atomics.wait = ((_typedArray: Int32Array, _index: number, _value: number, timeout?: number) => {
+        waits.push(timeout);
+        return 'timed-out';
+      }) as typeof Atomics.wait;
+
+      const result = readExistingLockDataWithRetry(lockFile, { maxAttempts: 3, delayMs: 17 });
+      assertEq(result, null, 'null for missing file after instrumented retries');
+      assertEq(waits.length, 2, 'sleep called only between failed attempts');
+      assertEq(waits, [17, 17], 'sleep preserves delayMs across retries');
+    } finally {
+      Atomics.wait = originalWait;
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
   // ─── 3. readExistingLockDataWithRetry recovers after transient rename ──────
   console.log('\n=== 3. readExistingLockDataWithRetry recovers after transient unavailability ===');
   {
@@ -96,8 +122,8 @@ async function main(): Promise<void> {
 
       // Simulate transient unavailability: move file away, spawn a child process
       // to restore it shortly after. The child runs outside our event loop so it
-      // fires even during busy-wait retries. Give the test extra retry budget so
-      // it stays stable under full-suite CPU contention.
+      // fires even during synchronous retry sleeps. Give the test extra retry
+      // budget so it stays stable under full-suite CPU contention.
       renameSync(lockFile, tmpFile);
       spawn('bash', ['-c', `sleep 0.05 && mv "${tmpFile}" "${lockFile}"`], { stdio: 'ignore', detached: true }).unref();
 

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

@@ -299,6 +299,74 @@ test("session_start installs the welcome screen as the TUI header", async (t) =>
   assert.deepEqual(header.render(123), ["welcome 9.9.9-test none 123"]);
 });
 
+test("session_start suppresses the welcome header while auto-mode is active", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-welcome-header-auto-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(
+    join(dir, "dist", "welcome-screen.js"),
+    "export function buildWelcomeScreenLines() { return ['welcome header']; }\n",
+    "utf-8",
+  );
+
+  const originalCwd = process.cwd();
+  const originalGsdPkgRoot = process.env.GSD_PKG_ROOT;
+  process.chdir(dir);
+  process.env.GSD_PKG_ROOT = dir;
+  autoSession.reset();
+  autoSession.active = true;
+  t.after(() => {
+    autoSession.reset();
+    process.chdir(originalCwd);
+    if (originalGsdPkgRoot === undefined) delete process.env.GSD_PKG_ROOT;
+    else process.env.GSD_PKG_ROOT = originalGsdPkgRoot;
+    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,
+    setCompactionThresholdOverride: () => {},
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => false,
+    },
+  } as any);
+
+  assert.equal(typeof headerFactory, "function", "session_start should install a header factory during auto-mode");
+  const header = headerFactory!({}, {});
+  assert.deepEqual(header.render(120), [], "auto-mode session_start must keep the welcome banner suppressed");
+});
+
 test("session hooks preserve closeout-boundary UI during completion reroot", async (t) => {
   const dir = join(
     tmpdir(),

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

@@ -45,6 +45,9 @@ test("formatConfigText provides a text fallback", () => {
 test("core handler routes show-config to overlay with text fallback", async () => {
   const notifications: Array<{ message: string; level: string }> = [];
   const ctx = {
+    modelRegistry: {
+      getAvailable: () => [],
+    },
     ui: {
       custom: async () => undefined,
       notify: (message: string, level: string) => {

package/src/resources/extensions/gsd/tests/single-writer-invariant.test.ts

@@ -365,6 +365,7 @@ test("DB Workspace Interface owns database open-state and maintenance calls", as
     "openWorkflowDatabase",
     "openWorkflowDatabaseByScope",
     "openWorkflowDatabaseByWorkspace",
+    "openWorkflowDatabaseIsolated",
     "openWorkflowDatabasePath",
     "refreshWorkflowDatabaseFromDisk",
     "resolveProjectRootDbPath",

package/src/resources/extensions/gsd/tests/stale-dirlistcache-4648.test.ts

@@ -13,7 +13,13 @@ import { resolveMilestoneFile, clearPathCache } from "../paths.ts";
 
 function mkBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-4648-"));
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(mDir, { recursive: true });
+  // Seed one content file so the dir is recognised as a content-bearing legacy
+  // milestone by dirIsContentBearingLegacyMilestone. The stale-cache tests then
+  // verify that a SECOND file written to the same dir is NOT detected until the
+  // path cache is cleared (the original behaviour under test is preserved).
+  writeFileSync(join(mDir, "M001-RESEARCH.md"), "# M001 research\n");
   return base;
 }