@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/src/resources/extensions/gsd/tests/recovery-verify-logs.test.ts

@@ -0,0 +1,428 @@
+// gsd-pi — Recovery artifact-verification log coverage.
+//
+// `verifyExpectedArtifact` is the gate that prevents an LLM from advancing the
+// pipeline with a stub or incomplete artifact. Each verify-fail branch emits a
+// `recovery` warning (or error) describing the exact reason — these logs are
+// the operator's signal during stuck-loop diagnosis, so regressions that change
+// or drop them must surface. The existing artifact-verification tests assert
+// only the boolean return value; this file pins the log output for each
+// important gate:
+//   - plan-milestone roadmap has zero slices      (auto-recovery.ts:511)
+//   - run-uat assessment missing a verdict        (auto-recovery.ts:502)
+//   - validate-milestone validation not terminal  (auto-recovery.ts:494)
+//   - generic verify-fail: artifact file missing  (auto-recovery.ts:487)
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { verifyExpectedArtifact, _setRoadmapParserFnForTests } from "../auto-recovery.ts";
+import { closeDatabase, openDatabase, _getAdapter } from "../gsd-db.ts";
+import {
+  drainLogs,
+  peekLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+
+function createFixtureBase(prefix = "gsd-recovery-logs-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function milestoneDir(base: string, mid: string): string {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function sliceDir(base: string, mid: string, sid: string): string {
+  const dir = join(base, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Run `verifyExpectedArtifact` with stderr suppressed and capture both the
+ * return value and the log entries emitted by the call. The log buffer is
+ * reset before the call (so no bleed from prior tests) and drained inside the
+ * capture scope (before the finally clears it) so callers can assert on logs
+ * after the helper returns.
+ *
+ * NOTE: the workflow-logger `_buffer` is a process-wide singleton shared with
+ * the code under test, so we must drain inside this scope — reading it after
+ * the finally would see an already-cleared buffer.
+ */
+function verifyAndCaptureLogs(
+  unitType: string,
+  unitId: string,
+  base: string,
+): { result: boolean; logs: LogEntry[] } {
+  const previous = setStderrLoggingEnabled(false);
+  _resetLogs();
+  try {
+    const result = verifyExpectedArtifact(unitType, unitId, base);
+    return { result, logs: drainLogs() };
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
+  }
+}
+
+function findRecovery(logs: readonly LogEntry[]): LogEntry | undefined {
+  return logs.find((e) => e.component === "recovery");
+}
+
+test("plan-milestone verify-fail logs a recovery warning naming the zero-slice roadmap", () => {
+  const base = createFixtureBase();
+  try {
+    const dir = milestoneDir(base, "M001");
+    writeFileSync(join(dir, "M001-ROADMAP.md"), "# M001: Stub\n\n## Slices\n\n_TBD_\n", "utf-8");
+
+    const { result, logs } = verifyAndCaptureLogs("plan-milestone", "M001", base);
+
+    assert.equal(result, false, "zero-slice roadmap must fail verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.equal(recovery!.severity, "warn");
+    assert.match(recovery!.message, /verify-fail plan-milestone M001: roadmap has zero slices/u);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("run-uat verify-fail logs a recovery warning when the assessment has no verdict", () => {
+  const base = createFixtureBase();
+  try {
+    const dir = sliceDir(base, "M001", "S01");
+    // No `verdict:` frontmatter → hasVerdict() returns false → warning fires.
+    writeFileSync(join(dir, "S01-ASSESSMENT.md"), "# UAT\n\nNo verdict yet.\n", "utf-8");
+
+    const { result, logs } = verifyAndCaptureLogs("run-uat", "M001/S01", base);
+
+    assert.equal(result, false, "verdict-less assessment must fail verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery entry must be logged");
+    assert.equal(recovery!.severity, "warn");
+    assert.match(recovery!.message, /verify-fail run-uat M001\/S01: assessment missing verdict/u);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("validate-milestone verify-fail logs a recovery warning when the validation is not terminal", () => {
+  const base = createFixtureBase();
+  try {
+    const dir = milestoneDir(base, "M001");
+    // No `verdict:` → isValidationTerminal() returns false → warning fires.
+    writeFileSync(join(dir, "M001-VALIDATION.md"), "# Validation\n\nStill in progress.\n", "utf-8");
+
+    const { result, logs } = verifyAndCaptureLogs("validate-milestone", "M001", base);
+
+    assert.equal(result, false, "non-terminal validation must fail verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.equal(recovery!.severity, "warn");
+    assert.match(recovery!.message, /verify-fail validate-milestone M001: validation not terminal/u);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("verify-fail logs a recovery warning when an expected artifact file is absent", () => {
+  const base = createFixtureBase();
+  try {
+    // complete-slice resolves a SUMMARY path under the milestone dir, but we
+    // never write the file → existsSync is false → the generic verify-fail path
+    // logs and returns false.
+    sliceDir(base, "M001", "S01");
+
+    const { result, logs } = verifyAndCaptureLogs("complete-slice", "M001/S01", base);
+
+    assert.equal(result, false, "missing artifact must fail verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.equal(recovery!.severity, "warn");
+    assert.match(recovery!.message, /verify-fail complete-slice M001\/S01: existsSync false/u);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("a passing verification produces no recovery warnings", () => {
+  const base = createFixtureBase();
+  try {
+    const dir = milestoneDir(base, "M001");
+    writeFileSync(
+      join(dir, "M001-ROADMAP.md"),
+      ["# M001: Real roadmap", "", "## Slices", "", "- [ ] **S01: First slice** `risk:low` `depends:[]`", ""].join("\n"),
+      "utf-8",
+    );
+
+    const { result, logs } = verifyAndCaptureLogs("plan-milestone", "M001", base);
+
+    assert.equal(result, true, "a real roadmap must pass verification");
+    assert.equal(
+      findRecovery(logs),
+      undefined,
+      "no recovery warning should be logged on success",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── plan-slice verification gates (legacy path, no DB) ────────────────────
+// These run the filesystem fallback when isDbAvailable() is false. Each verify-
+// fail branch logs a recovery warning naming the exact missing artifact, so a
+// regression that drops the reason would hide why a slice refused to advance.
+
+test("plan-slice verify-fail logs a recovery warning when the plan has no task entries", () => {
+  const base = createFixtureBase("gsd-recovery-logs-plan-");
+  try {
+    const dir = sliceDir(base, "M001", "S01");
+    // A PLAN with neither a `- [ ] **T0x:**` checkbox nor a `## T0x --` heading.
+    writeFileSync(join(dir, "S01-PLAN.md"), "# S01: Stub\n\n## Tasks\n\n_TBD_\n", "utf-8");
+
+    const { result, logs } = verifyAndCaptureLogs("plan-slice", "M001/S01", base);
+
+    assert.equal(result, false, "a task-less plan must fail verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.match(
+      recovery!.message,
+      /verify-fail plan-slice M001\/S01: plan has no task checkbox\/heading/u,
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("plan-slice verify-fail logs a recovery warning when the tasks dir is missing", () => {
+  const base = createFixtureBase("gsd-recovery-logs-tasksdir-");
+  try {
+    const dir = sliceDir(base, "M001", "S01");
+    // Valid checkbox task, but we deliberately do NOT create the tasks/ dir.
+    writeFileSync(
+      join(dir, "S01-PLAN.md"),
+      "# S01: Has task\n\n## Tasks\n\n- [ ] **T01: A** `est:15m`\n",
+      "utf-8",
+    );
+
+    const { result, logs } = verifyAndCaptureLogs("plan-slice", "M001/S01", base);
+
+    assert.equal(result, false, "a plan without its tasks dir must fail verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.match(
+      recovery!.message,
+      /verify-fail plan-slice M001\/S01: tasks dir missing/u,
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("plan-slice verify-fail logs a recovery warning when an individual task plan file is missing", () => {
+  const base = createFixtureBase("gsd-recovery-logs-taskplan-");
+  try {
+    const dir = sliceDir(base, "M001", "S01");
+    writeFileSync(
+      join(dir, "S01-PLAN.md"),
+      "# S01: Has task\n\n## Tasks\n\n- [ ] **T01: A** `est:15m`\n",
+      "utf-8",
+    );
+    // Create the tasks dir but NOT the T01-PLAN.md file inside it.
+    mkdirSync(join(dir, "tasks"), { recursive: true });
+
+    const { result, logs } = verifyAndCaptureLogs("plan-slice", "M001/S01", base);
+
+    assert.equal(result, false, "a missing task plan file must fail verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.match(
+      recovery!.message,
+      /verify-fail plan-slice M001\/S01: task plan missing .*T01-PLAN\.md/u,
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── parallel-research sentinel verification gates ─────────────────────────
+// The "{mid}/parallel-research" sentinel fans research across multiple slices.
+// verifyExpectedArtifact checks every research-ready slice has a RESEARCH file;
+// each failure logs a recovery warning naming the exact gap.
+
+test("parallel-research verify-fail logs a recovery warning when the roadmap is missing", () => {
+  const base = createFixtureBase("gsd-recovery-logs-prr-");
+  try {
+    // No roadmap file present → resolveExpectedArtifactPath("plan-milestone")
+    // returns null/missing → :445 warning.
+    const { result, logs } = verifyAndCaptureLogs("research-slice", "M001/parallel-research", base);
+
+    assert.equal(result, false, "missing roadmap must fail parallel-research verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.match(
+      recovery!.message,
+      /verify-fail research-slice M001\/parallel-research: roadmap missing/u,
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("parallel-research verify-fail logs a recovery warning when a research-ready slice lacks RESEARCH", () => {
+  const base = createFixtureBase("gsd-recovery-logs-prrs-");
+  try {
+    const dir = milestoneDir(base, "M001");
+    // A roadmap with one not-done slice (S01) and no milestone-level RESEARCH.
+    // S01 is research-ready (no deps, not done) and has no RESEARCH file → :462.
+    writeFileSync(
+      join(dir, "M001-ROADMAP.md"),
+      ["# M001: Roadmap", "", "## Slices", "", "- [ ] **S01: First** `risk:low` `depends:[]`", ""].join("\n"),
+      "utf-8",
+    );
+
+    const { result, logs } = verifyAndCaptureLogs("research-slice", "M001/parallel-research", base);
+
+    assert.equal(result, false, "a research-ready slice without RESEARCH must fail verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.match(
+      recovery!.message,
+      /verify-fail research-slice M001\/parallel-research: slice S01 missing RESEARCH/u,
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── gate-evaluate DB-degradation gate ─────────────────────────────────────
+// gate-evaluate verifies dispatched gates are no longer pending via a DB query.
+// When the DB is available but the query throws (e.g. quality_gates table
+// missing), the catch (auto-recovery.ts:411) logs a recovery warning and treats
+// the unit as verified to avoid blocking. This pins that degradation log.
+
+test("gate-evaluate verify logs a recovery warning when the pending-gates DB query throws", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-recovery-logs-gate-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  try {
+    // Open a DB then drop quality_gates so getPendingGatesForTurn throws inside
+    // the gate-evaluate DB branch → :411 warning. (getGateIdsForTurn returns
+    // default gate-evaluate ids, so the query path is reached.)
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    _getAdapter()!.exec("DROP TABLE quality_gates");
+
+    const previous = setStderrLoggingEnabled(false);
+    _resetLogs();
+    let result: boolean;
+    try {
+      // Batch unitId "M001/S01/gates+Q3" encodes one dispatched gate.
+      result = verifyExpectedArtifact("gate-evaluate", "M001/S01/gates+Q3", base);
+      const logs = drainLogs();
+      const recovery = logs.find((e) => e.component === "recovery" && /gate-evaluate DB check failed/u.test(e.message));
+      assert.ok(recovery, "a recovery warning must be logged when the gate DB check throws");
+      assert.match(recovery!.message, /gate-evaluate DB check failed/u);
+    } finally {
+      _resetLogs();
+      setStderrLoggingEnabled(previous);
+    }
+    // Per :411 comment, a DB failure is treated as verified (return true) to
+    // avoid blocking the loop — pin that resilience contract too.
+    assert.equal(result, true, "a gate-evaluate DB failure must not block verification");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── roadmap-parse-threw catches (:515 plan-milestone, :622 complete-slice) ─
+// parseLegacyRoadmap is internally defensive against every malformed input, so
+// these catches are unreachable without the _setRoadmapParserFnForTests seam.
+// We inject a throwing parser to pin both best-effort failure logs.
+
+test("plan-milestone verify logs a recovery warning when the roadmap parser throws (auto-recovery.ts:515)", () => {
+  const base = createFixtureBase("gsd-recovery-logs-parse-");
+  const restore = _setRoadmapParserFnForTests(() => {
+    throw new Error("forced roadmap parse failure");
+  });
+  try {
+    const dir = milestoneDir(base, "M001");
+    // A real ROADMAP file must exist so verification reaches the parser.
+    writeFileSync(join(dir, "M001-ROADMAP.md"), "# M001: x\n\n## Slices\n\n- [ ] **S01: A**\n", "utf-8");
+
+    const { result, logs } = verifyAndCaptureLogs("plan-milestone", "M001", base);
+
+    assert.equal(result, false, "a parser failure must fail plan-milestone verification");
+    const recovery = findRecovery(logs);
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.match(recovery!.message, /plan-milestone roadmap verification failed/u);
+    assert.match(recovery!.message, /forced roadmap parse failure/u);
+  } finally {
+    restore();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-slice verify logs a recovery warning when the legacy roadmap parse fails (auto-recovery.ts:622)", () => {
+  const base = createFixtureBase("gsd-recovery-logs-cs-parse-");
+  const restore = _setRoadmapParserFnForTests(() => {
+    throw new Error("forced legacy roadmap parse failure");
+  });
+  try {
+    const dir = sliceDir(base, "M001", "S01");
+    // complete-slice verification: SUMMARY + UAT present, DB unavailable →
+    // legacy roadmap checkbox fallback → parser throws → :622 warning.
+    writeFileSync(join(dir, "S01-SUMMARY.md"), "# S01 done\n", "utf-8");
+    // UAT file required so the complete-slice guard (auto-recovery.ts:655) does
+    // not return false before reaching the legacy roadmap fallback.
+    writeFileSync(join(dir, "S01-UAT.md"), "# UAT\n", "utf-8");
+    // Legacy ROADMAP.md (unprefixed) under the milestone dir.
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "ROADMAP.md"), "# M001\n\n## Slices\n\n- [ ] **S01: A**\n", "utf-8");
+
+    const { result, logs } = verifyAndCaptureLogs("complete-slice", "M001/S01", base);
+
+    assert.equal(result, false, "a parser failure must fail complete-slice verification");
+    const recovery = logs.find((e) => e.component === "recovery" && /roadmap parse failed/u.test(e.message));
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.match(recovery!.message, /roadmap parse failed/u);
+    assert.match(recovery!.message, /forced legacy roadmap parse failure/u);
+  } finally {
+    restore();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("parallel-research verify logs a recovery warning when the roadmap parse throws (auto-recovery.ts:522)", () => {
+  const base = createFixtureBase("gsd-recovery-logs-prr-throw-");
+  const restore = _setRoadmapParserFnForTests(() => {
+    throw new Error("forced parallel-research parse failure");
+  });
+  try {
+    const dir = milestoneDir(base, "M001");
+    // A real ROADMAP with a research-ready slice so verification reaches the
+    // parser loop; the seam makes parseRoadmapForRecovery throw → :522 catch.
+    writeFileSync(
+      join(dir, "M001-ROADMAP.md"),
+      ["# M001: Roadmap", "", "## Slices", "", "- [ ] **S01: First** `risk:low` `depends:[]`", ""].join("\n"),
+      "utf-8",
+    );
+
+    const { result, logs } = verifyAndCaptureLogs("research-slice", "M001/parallel-research", base);
+
+    assert.equal(result, false, "a parser failure must fail parallel-research verification");
+    const recovery = logs.find((e) => e.component === "recovery" && /parallel-research verification failed/u.test(e.message));
+    assert.ok(recovery, "a recovery warning must be logged");
+    assert.match(recovery!.message, /parallel-research verification failed/u);
+    assert.match(recovery!.message, /forced parallel-research parse failure/u);
+  } finally {
+    restore();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/register-extension-guard.test.ts

@@ -52,6 +52,31 @@ test("handleRecoverableExtensionProcessError swallows uv_cwd ENOENT", () => {
   }
 });
 
+test("handleRecoverableExtensionProcessError suppresses uv_cwd stderr in TUI mode", async () => {
+  const { setStderrLoggingEnabled } = await import("../workflow-logger.ts");
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+  const previous = setStderrLoggingEnabled(false);
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(
+      Object.assign(new Error("process.cwd failed"), {
+        code: "ENOENT",
+        syscall: "uv_cwd",
+      }),
+    );
+    assert.equal(handled, true);
+    assert.equal(stderr, "");
+  } finally {
+    setStderrLoggingEnabled(previous);
+    process.stderr.write = originalWrite;
+  }
+});
+
 test("handleRecoverableExtensionProcessError swallows read EIO", () => {
 	let stderr = "";
 	const originalWrite = process.stderr.write.bind(process.stderr);

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/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/runtime-invariant-modules.test.ts

@@ -67,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"));