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

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

@@ -0,0 +1,119 @@
+// gsd-pi — Recovery GitHub-finalize detached-promise log coverage.
+//
+// refreshRecoveryDbForArtifact fires a detached GitHub milestone finalize after
+// a complete-milestone DB closeout (auto-recovery.ts finalize block). Its catch
+// logs `GitHub milestone finalize failed after DB closeout` (:232, formerly
+// :203). The catch is otherwise reachable only with a real GitHub remote +
+// network failure, so we drive the real complete-milestone recovery path
+// (seeded closed milestone + proven closeout) and inject a throwing finalize
+// via the sanctioned _setGithubFinalizeFnForTests seam.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { refreshRecoveryDbForArtifact, _setGithubFinalizeFnForTests } from "../auto-recovery.ts";
+import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  drainLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+
+function git(cwd: string, args: string[]): void {
+  execFileSync("git", args, { cwd, stdio: "ignore" });
+}
+
+test("refreshRecoveryDbForArtifact logs a recovery warning when the detached GitHub finalize throws (auto-recovery.ts:232)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-recovery-finalize-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try {
+    // Real git repo with an implementation change on a milestone branch so
+    // hasImplementationArtifacts(base, "M001") returns "present" — required for
+    // proveMilestoneCloseout to pass and the recovery to reach the finalize block.
+    git(base, ["init", "-b", "main"]);
+    git(base, ["config", "user.email", "test@test.com"]);
+    git(base, ["config", "user.name", "Test"]);
+    writeFileSync(join(base, "README.md"), "# init\n");
+    git(base, ["add", "."]);
+    git(base, ["commit", "-m", "init"]);
+    git(base, ["checkout", "-b", "milestone/M001"]);
+    writeFileSync(join(base, "src.ts"), "export const x = 1;\n");
+    git(base, ["add", "."]);
+    git(base, ["commit", "-m", "impl"]);
+
+    invalidateAllCaches();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice One", status: "complete" });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      verificationResult: "passed",
+    });
+    insertAssessment({
+      path: ".gsd/milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass\n",
+    });
+
+    // Proven closeout SUMMARY artifact so proveMilestoneCloseout passes and the
+    // recovery reaches the finalize block.
+    const summaryPath = resolveExpectedArtifactPath("complete-milestone", "M001", base);
+    assert.ok(summaryPath, "complete-milestone summary path must resolve");
+    mkdirSync(dirname(summaryPath), { recursive: true });
+    writeFileSync(summaryPath, "# Milestone One\n\nComplete.\n", "utf-8");
+
+    // Inject a throwing finalize so the detached-promise catch fires. The
+    // detached promise resolves on a microtask, so we await one before draining.
+    const restoreFinalize = _setGithubFinalizeFnForTests(() => {
+      throw new Error("forced github finalize failure");
+    });
+
+    const previous = setStderrLoggingEnabled(false);
+    _resetLogs();
+    let logs: LogEntry[] = [];
+    try {
+      const result = refreshRecoveryDbForArtifact("complete-milestone", "M001", base);
+      assert.equal(result.ok, true, "DB closeout must succeed before the detached finalize");
+      // Drain detached-promise queue so the catch's logWarning lands.
+      await new Promise((resolve) => setImmediate(resolve));
+      logs = drainLogs();
+    } finally {
+      _resetLogs();
+      setStderrLoggingEnabled(previous);
+      restoreFinalize();
+    }
+
+    const warn = logs.find(
+      (e) => e.component === "recovery" && /GitHub milestone finalize failed after DB closeout/u.test(e.message),
+    );
+    assert.ok(
+      warn,
+      "a recovery warning must be logged when the detached GitHub finalize throws (got: " +
+        logs.filter((e) => e.component === "recovery").map((e) => e.message).join(" | ") + ")",
+    );
+    assert.match(warn!.message, /forced github finalize failure/u);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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/register-hooks-depth-verification.test.ts

@@ -19,6 +19,7 @@ import {
   resetWriteGateState,
   setPendingGate,
   shouldBlockContextArtifactSave,
+  shouldBlockContextWrite,
 } from "../bootstrap/write-gate.ts";
 import { classifyCommand } from "../safety/destructive-guard.ts";
 import { toRoundResultResponse } from "../../remote-questions/manager.ts";
@@ -201,9 +202,82 @@ test("register-hooks unlocks milestone depth verification from question id witho
   );
 });
 
+test("register-hooks canonicalizes lower-case milestone ids in depth-verification question ids", async (t) => {
+  const dir = makeTempDir("lowercase-mid");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState(dir);
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<void> | void) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_m001_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Do you agree?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  await armDepthGate(handlers, "ask_user_questions", questions);
+  assert.equal(getPendingGate(), questionId);
+
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: {
+        response: {
+          answers: {
+            [questionId]: { selected: "Yes, you got it (Recommended)" },
+          },
+        },
+      },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "confirming lower-case m001 gate should clear pending state");
+  assert.deepEqual(
+    loadWriteGateSnapshot(dir).verifiedDepthMilestones,
+    ["M001"],
+    "verified milestone id should be stored canonically",
+  );
+  assert.equal(
+    shouldBlockContextWrite(
+      "write",
+      ".gsd/milestones/M001/M001-CONTEXT.md",
+      null,
+      false,
+      dir,
+    ).block,
+    false,
+    "lower-case question id should unlock the matching upper-case CONTEXT.md path",
+  );
+});
+
 test("register-hooks persists first structured question round for new milestone re-entry", async (t) => {
   const dir = makeTempDir("question-draft");
-  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
   const originalCwd = process.cwd();
   process.chdir(dir);
   resetWriteGateState(dir);
@@ -274,9 +348,10 @@ test("register-hooks persists first structured question round for new milestone
     }, ctx);
   }
 
-  const milestoneDir = join(dir, ".gsd", "milestones", "M004");
-  const draftPath = join(milestoneDir, "M004-CONTEXT-DRAFT.md");
-  const discussionPath = join(milestoneDir, "M004-DISCUSSION.md");
+  // Flat-phase: ensureMilestoneShell creates phases/04-new-milestone-m004/ for M004
+  const milestoneDir = join(dir, ".gsd", "phases", "04-new-milestone-m004");
+  const draftPath = join(milestoneDir, "04-CONTEXT-DRAFT.md");
+  const discussionPath = join(milestoneDir, "04-DISCUSSION.md");
 
   assert.equal(existsSync(draftPath), true, "first answer round should create a resumable context draft");
   assert.equal(existsSync(discussionPath), true, "first answer round should create a discussion log");