gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

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

@@ -1,3 +1,5 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 // ensureDbOpen — Tests that the lazy DB opener creates + migrates the database
 // when .gsd/ exists with Markdown content but no gsd.db file.
 //
@@ -5,14 +7,11 @@
 // "GSD database is not available" because ensureDbOpen only opened
 // existing DB files but never created them.
 
-import { createTestContext } from './test-helpers.ts';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs';
 import { closeDatabase, isDbAvailable, getDecisionById } from '../gsd-db.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
-
 function makeTmpDir(): string {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-ensure-db-'));
   return dir;
@@ -28,141 +27,134 @@ function cleanupDir(dir: string): void {
 // ensureDbOpen creates DB + migrates when .gsd/ has Markdown
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n── ensureDbOpen: creates DB from Markdown ──');
-
-{
-  const tmpDir = makeTmpDir();
-  const gsdDir = path.join(tmpDir, '.gsd');
-  fs.mkdirSync(gsdDir, { recursive: true });
-
-  // Write a minimal DECISIONS.md so migration has content
-  const decisionsContent = `# Decisions
-
-| # | When | Scope | Decision | Choice | Rationale | Revisable |
-|---|------|-------|----------|--------|-----------|-----------|
-| D001 | M001 | architecture | Use SQLite | SQLite | Sync API | Yes |
-`;
-  fs.writeFileSync(path.join(gsdDir, 'DECISIONS.md'), decisionsContent);
-
-  // Verify no DB file exists yet
-  const dbPath = path.join(gsdDir, 'gsd.db');
-  assertTrue(!fs.existsSync(dbPath), 'DB file should not exist before ensureDbOpen');
-
-  // Close any previously open DB
-  try { closeDatabase(); } catch { /* ok */ }
-
-  // Override process.cwd to point at tmpDir for ensureDbOpen
-  const origCwd = process.cwd;
-  process.cwd = () => tmpDir;
-
-  try {
-    // Dynamic import to get the freshest version
-    const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-
-    const result = await ensureDbOpen();
-
-    assertTrue(result === true, 'ensureDbOpen should return true when .gsd/ has Markdown');
-    assertTrue(fs.existsSync(dbPath), 'DB file should be created after ensureDbOpen');
-    assertTrue(isDbAvailable(), 'DB should be available after ensureDbOpen');
-
-    // Verify that Markdown migration actually ran
-    const decision = getDecisionById('D001');
-    assertTrue(decision !== null, 'D001 should be migrated from DECISIONS.md');
-    if (decision) {
-      assertEq(decision.scope, 'architecture', 'Migrated decision scope should match');
-      assertEq(decision.choice, 'SQLite', 'Migrated decision choice should match');
+describe('ensure-db-open', () => {
+  test('ensureDbOpen: creates DB from Markdown', async () => {
+    const tmpDir = makeTmpDir();
+    const gsdDir = path.join(tmpDir, '.gsd');
+    fs.mkdirSync(gsdDir, { recursive: true });
+
+    // Write a minimal DECISIONS.md so migration has content
+    const decisionsContent = `# Decisions
+
+  | # | When | Scope | Decision | Choice | Rationale | Revisable |
+  |---|------|-------|----------|--------|-----------|-----------|
+  | D001 | M001 | architecture | Use SQLite | SQLite | Sync API | Yes |
+  `;
+    fs.writeFileSync(path.join(gsdDir, 'DECISIONS.md'), decisionsContent);
+
+    // Verify no DB file exists yet
+    const dbPath = path.join(gsdDir, 'gsd.db');
+    assert.ok(!fs.existsSync(dbPath), 'DB file should not exist before ensureDbOpen');
+
+    // Close any previously open DB
+    try { closeDatabase(); } catch { /* ok */ }
+
+    // Override process.cwd to point at tmpDir for ensureDbOpen
+    const origCwd = process.cwd;
+    process.cwd = () => tmpDir;
+
+    try {
+      // Dynamic import to get the freshest version
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+
+      const result = await ensureDbOpen();
+
+      assert.ok(result === true, 'ensureDbOpen should return true when .gsd/ has Markdown');
+      assert.ok(fs.existsSync(dbPath), 'DB file should be created after ensureDbOpen');
+      assert.ok(isDbAvailable(), 'DB should be available after ensureDbOpen');
+
+      // Verify that Markdown migration actually ran
+      const decision = getDecisionById('D001');
+      assert.ok(decision !== null, 'D001 should be migrated from DECISIONS.md');
+      if (decision) {
+        assert.deepStrictEqual(decision.scope, 'architecture', 'Migrated decision scope should match');
+        assert.deepStrictEqual(decision.choice, 'SQLite', 'Migrated decision choice should match');
+      }
+    } finally {
+      process.cwd = origCwd;
+      closeDatabase();
+      cleanupDir(tmpDir);
     }
-  } finally {
-    process.cwd = origCwd;
-    closeDatabase();
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ensureDbOpen returns false when no .gsd/ exists
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── ensureDbOpen: no .gsd/ returns false ──');
-
-{
-  const tmpDir = makeTmpDir();
-  // No .gsd/ directory at all
-
-  try { closeDatabase(); } catch { /* ok */ }
-  const origCwd = process.cwd;
-  process.cwd = () => tmpDir;
-
-  try {
-    const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-    const result = await ensureDbOpen();
-    assertTrue(result === false, 'ensureDbOpen should return false when no .gsd/ exists');
-    assertTrue(!isDbAvailable(), 'DB should not be available');
-  } finally {
-    process.cwd = origCwd;
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ensureDbOpen opens existing DB without re-migration
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── ensureDbOpen: opens existing DB ──');
-
-{
-  const tmpDir = makeTmpDir();
-  const gsdDir = path.join(tmpDir, '.gsd');
-  fs.mkdirSync(gsdDir, { recursive: true });
-
-  // Create a DB file first
-  const dbPath = path.join(gsdDir, 'gsd.db');
-  const { openDatabase } = await import('../gsd-db.ts');
-  openDatabase(dbPath);
-  closeDatabase();
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ensureDbOpen returns false when no .gsd/ exists
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  test('ensureDbOpen: no .gsd/ returns false', async () => {
+    const tmpDir = makeTmpDir();
+    // No .gsd/ directory at all
+
+    try { closeDatabase(); } catch { /* ok */ }
+    const origCwd = process.cwd;
+    process.cwd = () => tmpDir;
+
+    try {
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+      const result = await ensureDbOpen();
+      assert.ok(result === false, 'ensureDbOpen should return false when no .gsd/ exists');
+      assert.ok(!isDbAvailable(), 'DB should not be available');
+    } finally {
+      process.cwd = origCwd;
+      cleanupDir(tmpDir);
+    }
+  });
 
-  assertTrue(fs.existsSync(dbPath), 'DB file should exist from manual create');
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ensureDbOpen opens existing DB without re-migration
+  // ═══════════════════════════════════════════════════════════════════════════
 
-  const origCwd = process.cwd;
-  process.cwd = () => tmpDir;
+  test('ensureDbOpen: opens existing DB', async () => {
+    const tmpDir = makeTmpDir();
+    const gsdDir = path.join(tmpDir, '.gsd');
+    fs.mkdirSync(gsdDir, { recursive: true });
 
-  try {
-    const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-    const result = await ensureDbOpen();
-    assertTrue(result === true, 'ensureDbOpen should open existing DB');
-    assertTrue(isDbAvailable(), 'DB should be available');
-  } finally {
-    process.cwd = origCwd;
+    // Create a DB file first
+    const dbPath = path.join(gsdDir, 'gsd.db');
+    const { openDatabase } = await import('../gsd-db.ts');
+    openDatabase(dbPath);
     closeDatabase();
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ensureDbOpen returns false for empty .gsd/ (no Markdown, no DB)
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── ensureDbOpen: empty .gsd/ returns false ──');
 
-{
-  const tmpDir = makeTmpDir();
-  fs.mkdirSync(path.join(tmpDir, '.gsd'), { recursive: true });
-  // .gsd/ exists but no DECISIONS.md, REQUIREMENTS.md, or milestones/
+    assert.ok(fs.existsSync(dbPath), 'DB file should exist from manual create');
 
-  try { closeDatabase(); } catch { /* ok */ }
-  const origCwd = process.cwd;
-  process.cwd = () => tmpDir;
+    const origCwd = process.cwd;
+    process.cwd = () => tmpDir;
 
-  try {
-    const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-    const result = await ensureDbOpen();
-    assertTrue(result === false, 'ensureDbOpen should return false for empty .gsd/');
-  } finally {
-    process.cwd = origCwd;
-    cleanupDir(tmpDir);
-  }
-}
+    try {
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+      const result = await ensureDbOpen();
+      assert.ok(result === true, 'ensureDbOpen should open existing DB');
+      assert.ok(isDbAvailable(), 'DB should be available');
+    } finally {
+      process.cwd = origCwd;
+      closeDatabase();
+      cleanupDir(tmpDir);
+    }
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ensureDbOpen returns false for empty .gsd/ (no Markdown, no DB)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  test('ensureDbOpen: empty .gsd/ returns false', async () => {
+    const tmpDir = makeTmpDir();
+    fs.mkdirSync(path.join(tmpDir, '.gsd'), { recursive: true });
+    // .gsd/ exists but no DECISIONS.md, REQUIREMENTS.md, or milestones/
+
+    try { closeDatabase(); } catch { /* ok */ }
+    const origCwd = process.cwd;
+    process.cwd = () => tmpDir;
+
+    try {
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+      const result = await ensureDbOpen();
+      assert.ok(result === false, 'ensureDbOpen should return false for empty .gsd/');
+    } finally {
+      process.cwd = origCwd;
+      cleanupDir(tmpDir);
+    }
+  });
 
-// ═══════════════════════════════════════════════════════════════════════════
+  // ═══════════════════════════════════════════════════════════════════════════
 
-report();
+});

package/src/resources/extensions/gsd/tests/est-annotation-timeout.test.ts

@@ -0,0 +1,120 @@
+/**
+ * est-annotation-timeout.test.ts — Regression tests for #2243.
+ *
+ * Tasks with `est: 30m` or `est: 2h` annotations should get extended
+ * supervision timeouts. The parseEstimateMinutes helper should parse
+ * estimate strings, and startUnitSupervision should use them.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const timersSrcPath = join(import.meta.dirname, "..", "auto-timers.ts");
+const timersSrc = readFileSync(timersSrcPath, "utf-8");
+
+// ─── Source analysis: parseEstimateMinutes exists and is exported ────────────
+
+test("#2243: auto-timers.ts should export parseEstimateMinutes", () => {
+  assert.ok(
+    timersSrc.includes("export function parseEstimateMinutes"),
+    "parseEstimateMinutes should be exported from auto-timers.ts",
+  );
+});
+
+// ─── Inline unit test of parseEstimateMinutes logic ─────────────────────────
+// Since importing the module pulls in heavy deps, test the parsing logic inline.
+
+function parseEstimateMinutes(estimate: string): number | null {
+  if (!estimate || typeof estimate !== "string") return null;
+  const trimmed = estimate.trim();
+  if (!trimmed) return null;
+
+  let totalMinutes = 0;
+  let matched = false;
+
+  const hoursMatch = trimmed.match(/(\d+)\s*h/i);
+  if (hoursMatch) {
+    totalMinutes += Number(hoursMatch[1]) * 60;
+    matched = true;
+  }
+
+  const minutesMatch = trimmed.match(/(\d+)\s*m/i);
+  if (minutesMatch) {
+    totalMinutes += Number(minutesMatch[1]);
+    matched = true;
+  }
+
+  return matched ? totalMinutes : null;
+}
+
+test("#2243: parseEstimateMinutes parses '30m' correctly", () => {
+  assert.equal(parseEstimateMinutes("30m"), 30);
+});
+
+test("#2243: parseEstimateMinutes parses '2h' correctly", () => {
+  assert.equal(parseEstimateMinutes("2h"), 120);
+});
+
+test("#2243: parseEstimateMinutes parses '1h30m' correctly", () => {
+  assert.equal(parseEstimateMinutes("1h30m"), 90);
+});
+
+test("#2243: parseEstimateMinutes parses '15m' correctly", () => {
+  assert.equal(parseEstimateMinutes("15m"), 15);
+});
+
+test("#2243: parseEstimateMinutes returns null for empty string", () => {
+  assert.equal(parseEstimateMinutes(""), null);
+});
+
+test("#2243: parseEstimateMinutes returns null for invalid string", () => {
+  assert.equal(parseEstimateMinutes("not a time"), null);
+});
+
+// ─── Source analysis: startUnitSupervision uses task estimates ───────────────
+
+test("#2243: startUnitSupervision should reference task estimates for timeout scaling", () => {
+  const usesEstimate =
+    timersSrc.includes("parseEstimateMinutes") &&
+    timersSrc.includes("estimateMinutes") &&
+    timersSrc.includes("taskEstimate");
+
+  assert.ok(
+    usesEstimate,
+    "startUnitSupervision should use task estimate annotations for timeout scaling",
+  );
+});
+
+test("#2243: SupervisionContext should accept an optional taskEstimate field", () => {
+  const ctxIdx = timersSrc.indexOf("SupervisionContext");
+  assert.ok(ctxIdx !== -1, "SupervisionContext interface exists");
+
+  const ctxEnd = timersSrc.indexOf("}", ctxIdx);
+  const ctxBlock = timersSrc.slice(ctxIdx, ctxEnd);
+
+  assert.ok(
+    ctxBlock.includes("taskEstimate"),
+    "SupervisionContext should include a taskEstimate field",
+  );
+});
+
+test("#2243: timeouts should be scaled by estimate (timeoutScale in source)", () => {
+  assert.ok(
+    timersSrc.includes("timeoutScale"),
+    "auto-timers.ts should use a timeoutScale factor derived from est: annotations",
+  );
+});
+
+test("#2243: idle timeout should NOT be scaled (idle is idle regardless of estimate)", () => {
+  // Find the idleTimeoutMs line
+  const idleIdx = timersSrc.indexOf("const idleTimeoutMs");
+  assert.ok(idleIdx !== -1, "idleTimeoutMs variable exists");
+  
+  const idleLine = timersSrc.slice(idleIdx, timersSrc.indexOf("\n", idleIdx));
+  assert.ok(
+    !idleLine.includes("timeoutScale"),
+    "idleTimeoutMs should NOT be scaled — idle is idle",
+  );
+});

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

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 
 import { registerExitCommand } from "../exit-command.ts";
 
-test("/exit requests graceful shutdown instead of process.exit", async () => {
+test("/exit requests graceful shutdown instead of process.exit", async (t) => {
   const commands = new Map<
     string,
     {
@@ -35,15 +35,13 @@ test("/exit requests graceful shutdown instead of process.exit", async () => {
     throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
   }) as typeof process.exit;
 
-  try {
-    await exit.handler("", {
-      async shutdown() {
-        shutdownCalls += 1;
-      },
-    });
-  } finally {
-    process.exit = originalExit;
-  }
+  t.after(() => { process.exit = originalExit; });
+
+  await exit.handler("", {
+    async shutdown() {
+      shutdownCalls += 1;
+    },
+  });
 
   assert.equal(stopAutoCalls, 1, "handler should stop auto-mode exactly once before shutdown");
   assert.equal(shutdownCalls, 1, "handler should request graceful shutdown exactly once");
@@ -51,7 +49,7 @@ test("/exit requests graceful shutdown instead of process.exit", async () => {
 
 // ─── #1839 regression: ESM cache mismatch must not crash exit ────────────────
 
-test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async () => {
+test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async (t) => {
   const commands = new Map<string, { description?: string; handler: (args: string, ctx: any) => Promise<void> }>();
 
   const pi = {
@@ -80,20 +78,18 @@ test("/exit still shuts down gracefully when stopAuto throws (ESM module cache m
     throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
   }) as typeof process.exit;
 
-  try {
-    await exit.handler("", {
-      async shutdown() {
-        shutdownCalls += 1;
-      },
-      ui: {
-        notify(msg: string, level: string) {
-          notifications.push({ msg, level });
-        },
+  t.after(() => { process.exit = originalExit; });
+
+  await exit.handler("", {
+    async shutdown() {
+      shutdownCalls += 1;
+    },
+    ui: {
+      notify(msg: string, level: string) {
+        notifications.push({ msg, level });
       },
-    });
-  } finally {
-    process.exit = originalExit;
-  }
+    },
+  });
 
   assert.equal(shutdownCalls, 1, "shutdown must still be called even when stopAuto throws");
   assert.equal(notifications.length, 1, "should emit exactly one warning notification");