@opengsd/gsd-pi 1.2.0-dev.84c56d87 → 1.2.0-dev.8e6112e9

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

@@ -7,6 +7,9 @@
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import {
   openDatabase,
   closeDatabase,
@@ -22,6 +25,17 @@ import {
   formatDecisionsForPrompt,
   formatRequirementsForPrompt,
 } from '../context-store.ts';
+import { inlineRequirementsFromDb } from '../auto-prompts.ts';
+import { migrateFromMarkdown } from '../md-importer.ts';
+
+function createDbProjectWithRequirements(content: string): { tmpDir: string; gsdDir: string } {
+  const tmpDir = mkdtempSync(join(tmpdir(), 'prompt-db-requirements-'));
+  const gsdDir = join(tmpDir, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, 'REQUIREMENTS.md'), content);
+  openDatabase(join(gsdDir, 'gsd.db'));
+  return { tmpDir, gsdDir };
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // prompt-db: DB-aware decisions helper returns scoped content
@@ -182,6 +196,116 @@ console.log('\n=== prompt-db: fallback when DB unavailable ===');
   assert.deepStrictEqual(formattedReqs, '', 'formatRequirementsForPrompt returns empty for empty input');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: DB-aware requirements helper does not fall back on empty DB rows
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('prompt-db: inlineRequirementsFromDb returns null instead of full file when DB query is empty', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    `# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n\n${'large requirement body\n'.repeat(500)}`,
+  );
+  try {
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', undefined, 'full');
+
+    assert.equal(inlined, null);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('prompt-db: inlineRequirementsFromDb cascades from empty milestone query to active requirements', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    '# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n',
+  );
+  try {
+    insertRequirement({
+      id: 'R001',
+      class: 'functional',
+      status: 'active',
+      description: 'active requirement for another milestone',
+      why: 'needed',
+      source: 'M001',
+      primary_owner: 'M001/S01',
+      supporting_slices: '',
+      validation: 'test',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+    insertRequirement({
+      id: 'R002',
+      class: 'functional',
+      status: 'validated',
+      description: 'validated requirement should not be active fallback',
+      why: 'already done',
+      source: 'M001',
+      primary_owner: 'M001/S02',
+      supporting_slices: '',
+      validation: 'done',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', undefined, 'full');
+
+    assert.ok(inlined);
+    assert.match(inlined, /### Requirements/);
+    assert.match(inlined, /# Requirements \(compact\)/);
+    assert.match(inlined, /R001/);
+    assert.match(inlined, /active requirement for another milestone/);
+    assert.doesNotMatch(inlined, /R002/);
+    assert.doesNotMatch(inlined, /FULL FILE SHOULD NOT BE INLINED/);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('prompt-db: inlineRequirementsFromDb keeps active fallback compact for slice-scoped full calls', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    '# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n',
+  );
+  try {
+    insertRequirement({
+      id: 'R001',
+      class: 'functional',
+      status: 'active',
+      description: 'active requirement for another milestone',
+      why: 'needed',
+      source: 'M001',
+      primary_owner: 'M001/S01',
+      supporting_slices: '',
+      validation: 'test',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+
+    // Slice-scoped call at inlineLevel "full" with no matching rows for the
+    // milestone+slice or milestone-only queries. The cascade should land on
+    // status: "active" rows from another milestone, and those project-wide
+    // active rows must be formatted compactly even though sliceId is set —
+    // otherwise the full per-requirement markdown would be inlined for every
+    // active row across the project.
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', 'S99', 'full');
+
+    assert.ok(inlined);
+    assert.match(inlined, /### Requirements/);
+    assert.match(inlined, /# Requirements \(compact\)/);
+    assert.match(inlined, /R001/);
+    // Full per-requirement markdown is forbidden here — its hallmark fields
+    // (Class:/Status:/Why: as bolded list items) are emitted only by
+    // formatRequirementsForPrompt, never by formatRequirementsCompact.
+    assert.doesNotMatch(inlined, /\*\*Class:\*\*/);
+    assert.doesNotMatch(inlined, /FULL FILE SHOULD NOT BE INLINED/);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
 // ═══════════════════════════════════════════════════════════════════════════
 // prompt-db: scoped filtering reduces content vs unscoped
 // ═══════════════════════════════════════════════════════════════════════════
@@ -316,12 +440,6 @@ console.log('\n=== prompt-db: DB helpers wrapper format matches expected pattern
 // prompt-db: re-import updates DB when source markdown changes
 // ═══════════════════════════════════════════════════════════════════════════
 
-import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { migrateFromMarkdown } from '../md-importer.ts';
-
-
 describe('prompt-db', () => {
 test('prompt-db: re-import updates DB when source markdown changes', () => {
   // Create a temp dir simulating a project with .gsd/DECISIONS.md

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -17,10 +17,8 @@ import {
   shouldDeferTransientErrorToCoreRetry,
   suppressTerminalDeletedWorktreeMessageEnd,
 } from "../bootstrap/agent-end-recovery.ts";
-import {
-  _buildCancelledUnitStopReason,
-  _classifyZeroToolProviderMessageForTest,
-} from "../auto/phases.ts";
+import { _buildCancelledUnitStopReason } from "../auto/phase-helpers.ts";
+import { _classifyZeroToolProviderMessageForTest } from "../auto/unit-phase.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package

package/src/resources/extensions/gsd/tests/remote-notification-from-desktop.test.ts

@@ -5,103 +5,53 @@
  * as a fire-and-forget side-effect so that Telegram/Slack/Discord channels
  * receive the same events as native desktop notifications.
  *
- * Testing strategy (structural analysis):
- *   node:test does not support mock.module without --experimental-test-module-mocks,
- *   so we use the same source-code structural approach established in this codebase
- *   (see session-start-footer.test.ts). We read notifications.ts and assert that:
- *     1. It imports sendRemoteNotification from the remote-questions/notify module.
- *     2. The sendDesktopNotification function body calls sendRemoteNotification
- *        with title and message as arguments.
- *     3. The call uses the void fire-and-forget pattern with a .catch(() => {})
- *        suppressor so that async failures never break the synchronous caller.
+ * Testing strategy (behavioral):
+ *   Import sendDesktopNotification and the swappable remoteNotificationDispatcher.
+ *   Mock the dispatcher's send method, call sendDesktopNotification, and assert
+ *   that the dispatcher received the same title/message and that the call is
+ *   fire-and-forget (the function returns without awaiting).
  *
  * Relates to #4341.
  */
 
 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 SOURCE = readFileSync(join(__dirname, "..", "notifications.ts"), "utf-8");
+import {
+  sendDesktopNotification,
+  remoteNotificationDispatcher,
+} from "../notifications.js";
 
-test("notifications.ts imports sendRemoteNotification from remote-questions/notify", () => {
-  const hasImport =
-    SOURCE.includes('from "../remote-questions/notify.js"') ||
-    SOURCE.includes("from '../remote-questions/notify.js'");
-  assert.ok(
-    hasImport,
-    "notifications.ts must import from '../remote-questions/notify.js'",
-  );
-
-  const importLine = SOURCE.split("\n").find(
-    (line) =>
-      line.includes("sendRemoteNotification") &&
-      (line.includes("remote-questions/notify") || line.includes("remote-questions/notify.js")),
-  );
-  assert.ok(
-    importLine,
-    "The import statement must include sendRemoteNotification from the remote-questions/notify module",
-  );
-});
-
-test("sendDesktopNotification calls sendRemoteNotification(title, message)", () => {
-  // Extract the body of sendDesktopNotification — from its opening brace to the
-  // closing brace at the same indentation level.
-  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
-  assert.ok(fnStart > -1, "sendDesktopNotification must be present in notifications.ts");
+test("sendDesktopNotification calls sendRemoteNotification with title and message", async (t) => {
+  const sendMock = t.mock.method(remoteNotificationDispatcher, "send", async () => {});
 
-  // Find the next exported function/const after sendDesktopNotification to bound the search.
-  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
-  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
-
-  assert.ok(
-    fnBody.includes("sendRemoteNotification"),
-    "sendDesktopNotification must call sendRemoteNotification",
-  );
+  sendDesktopNotification("Test Title", "Test Message");
 
-  assert.ok(
-    fnBody.includes("sendRemoteNotification(title") || fnBody.includes("sendRemoteNotification(title,"),
-    "sendRemoteNotification must be called with title as first argument",
-  );
+  assert.equal(sendMock.mock.callCount(), 1);
+  assert.deepEqual(sendMock.mock.calls[0].arguments, ["Test Title", "Test Message"]);
 });
 
-test("sendRemoteNotification is invoked as void fire-and-forget with .catch(() => {})", () => {
-  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
-  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
-  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
+test("sendDesktopNotification does not await the remote notification", async (t) => {
+  const sendMock = t.mock.method(remoteNotificationDispatcher, "send", async () => {});
 
-  assert.ok(
-    fnBody.includes("void sendRemoteNotification("),
-    "sendRemoteNotification must be called with void (fire-and-forget)",
-  );
+  const result = sendDesktopNotification("Async Title", "Async Message");
 
-  assert.ok(
-    fnBody.includes(".catch("),
-    "sendRemoteNotification call must be followed by .catch() to suppress unhandled-rejection warnings",
-  );
+  assert.equal(result, undefined, "sendDesktopNotification must return void");
+  assert.equal(sendMock.mock.callCount(), 1);
 });
 
-test("sendRemoteNotification call appears before shouldSendDesktopNotification guard", () => {
-  // Regression guard for the HIGH-severity bug where remote notifications were
-  // gated behind the desktop-notification preference check. Users who disable
-  // desktop notifications must still receive Telegram/Slack/Discord messages.
-  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
-  assert.ok(fnStart > -1, "sendDesktopNotification must be present in notifications.ts");
-
-  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
-  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
+test("sendDesktopNotification fires remote notification even when desktop notifications are disabled", async (t) => {
+  const sendMock = t.mock.method(remoteNotificationDispatcher, "send", async () => {});
 
-  const remoteCallIdx = fnBody.indexOf("sendRemoteNotification(");
-  const guardIdx = fnBody.indexOf("shouldSendDesktopNotification(");
-
-  assert.ok(remoteCallIdx > -1, "sendRemoteNotification must be called inside sendDesktopNotification");
-  assert.ok(guardIdx > -1, "shouldSendDesktopNotification guard must be present inside sendDesktopNotification");
-
-  assert.ok(
-    remoteCallIdx < guardIdx,
-    `sendRemoteNotification (pos ${remoteCallIdx}) must appear BEFORE the shouldSendDesktopNotification guard (pos ${guardIdx}) so that remote channels fire even when desktop notifications are disabled`,
+  sendDesktopNotification(
+    "Remote Title",
+    "Remote Message",
+    "info",
+    "complete",
+    undefined,
+    { notifications: { enabled: false } },
   );
+
+  assert.equal(sendMock.mock.callCount(), 1);
+  assert.deepEqual(sendMock.mock.calls[0].arguments, ["Remote Title", "Remote Message"]);
 });

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -200,6 +200,74 @@ test("parseRoadmapSlices: checkbox slices with pipe characters do not switch to
   assert.deepEqual(slices[2]?.depends, ["S01", "S02"]);
 });
 
+test("parseRoadmapSlices: demo markdown table does not switch checkbox roadmap to table mode (#721)", () => {
+  const checkboxWithDemoTable = [
+    "# M004: Demo Table Repro",
+    "",
+    "## Slices",
+    "",
+    "- [x] **S01: First** `risk:low` `depends:[]`",
+    "  > After this: cli can render examples:",
+    "| Example | Meaning |",
+    "| --- | --- |",
+    "| S01 | Not a roadmap row |",
+    "- [ ] **S02: Second** `risk:medium` `depends:[S01]`",
+    "  > After this: cat file | sort returns stable output.",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(checkboxWithDemoTable);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.title, "First");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.deepEqual(slices[1]?.depends, ["S01"]);
+});
+
+test("parseRoadmapSlices: table preceded by intro prose still parsed as table (#722)", () => {
+  const tableWithIntro = [
+    "# M005: Intro Before Table",
+    "",
+    "## Slices",
+    "",
+    "This milestone is broken into the following slices:",
+    "",
+    "| Slice | Title | Risk | Status |",
+    "| --- | --- | --- | --- |",
+    "| S01 | Foundation | Low | [x] Done |",
+    "| S02 | Core | High | [ ] Pending |",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(tableWithIntro);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, false);
+});
+
+test("parseRoadmapSlices: table without markdown separator row still parsed as table (#722)", () => {
+  const tableWithoutSeparator = [
+    "# M006: No Separator",
+    "",
+    "## Slices",
+    "",
+    "| Slice | Title | Risk | Status |",
+    "| S01 | Foundation | Low | [x] Done |",
+    "| S02 | Core | High | [ ] Pending |",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(tableWithoutSeparator);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, false);
+});
+
 // --- Prose slice header completion marker tests (#1803) ---
 
 test("parseRoadmapSlices: prose headers with ✓ marker detected as done", () => {

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -6,7 +6,11 @@ import assert from "node:assert/strict";
 
 import { classifyFailure } from "../recovery-classification.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
-import { compileUnitContextContract, compileUnitToolContract } from "../tool-contract.js";
+import {
+  compileUnitContextContract,
+  compileUnitToolContract,
+  getUnitWorkflowDispatchReadinessError,
+} from "../tool-contract.js";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
 
@@ -63,7 +67,13 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
 
   assert.equal(result.ok, true);
   assert.equal(result.ok && result.contract.unitType, "execute-task");
-  assert.deepEqual(result.ok && result.contract.requiredWorkflowTools, ["gsd_task_complete"]);
+  assert.deepEqual(result.ok && result.contract.requiredWorkflowTools, [
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_capture_thought",
+  ]);
   assert.deepEqual(result.ok && result.contract.forbiddenWorkflowTools, []);
   assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
   assert.ok(result.ok && result.contract.validationRules.includes("closeout-tool-present"));
@@ -87,6 +97,20 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   });
 });
 
+test("Tool Contract derives dispatch readiness from Unit workflow tools", () => {
+  const error = getUnitWorkflowDispatchReadinessError({
+    provider: "claude-code",
+    unitType: "plan-slice",
+    projectRoot: "/tmp/project",
+    env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+    surface: "auto-mode",
+    authMode: "externalCli",
+    baseUrl: "local://claude-code",
+  });
+
+  assert.equal(error, null);
+});
+
 test("Unit Context Contract exposes prompt context without workflow tool surface", () => {
   const result = compileUnitContextContract("execute-task");