gsd-pi 2.71.0 → 2.72.0

package/src/resources/extensions/gsd/tests/prompt-system-gate-coverage.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Prompt-system gate coverage tests.
+ *
+ * These tests pin the invariants the plan file documents:
+ *   1. Every pending slice-scoped gate is routed to exactly one owner turn.
+ *      Q8 (owned by complete-slice) MUST NOT leak into gate-evaluate and
+ *      get silently dropped the way it used to before the registry landed.
+ *   2. getPendingGatesForTurn filters by the registry's owner turn, not
+ *      just the DB scope column.
+ *   3. Output validators recognize artifacts that contain the required
+ *      gate section headings, and flag ones that don't.
+ *   4. Prompt output produced by the validators reflects MV01-MV04.
+ *
+ * They also assert the VALIDATION.md renderer still produces headings
+ * matching the registry's promptSection strings, so future renderer
+ * edits that drift from the registry fail the suite loudly.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  insertGateRow,
+  getPendingGates,
+  getPendingGatesForTurn,
+} from "../gsd-db.ts";
+import {
+  GATE_REGISTRY,
+  getGatesForTurn,
+  type OwnerTurn,
+} from "../gate-registry.ts";
+import {
+  validateSliceSummaryOutput,
+  validateTaskSummaryOutput,
+  validateMilestoneValidationOutput,
+  validateGateSections,
+} from "../prompt-validation.ts";
+
+function setupTestDb(): string {
+  const tmpDir = mkdtempSync(join(tmpdir(), "prompt-gate-coverage-"));
+  const dbPath = join(tmpDir, "gsd.db");
+  openDatabase(dbPath);
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({
+    milestoneId: "M001",
+    id: "S01",
+    title: "Test Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Test Task",
+    status: "pending",
+  });
+  return tmpDir;
+}
+
+describe("getPendingGatesForTurn routes by owner turn, not scope column", () => {
+  let tmpDir: string;
+  beforeEach(() => {
+    tmpDir = setupTestDb();
+  });
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("Q8 stored as scope:'slice' is owned by complete-slice, not gate-evaluate", () => {
+    // Seed the three slice-scoped gates plan-slice writes today.
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q8", scope: "slice" });
+
+    // getPendingGates(..., "slice") returns all three (unchanged).
+    const allSlicePending = getPendingGates("M001", "S01", "slice");
+    assert.equal(allSlicePending.length, 3);
+
+    // But the turn-aware helper routes them correctly.
+    const gateEval = getPendingGatesForTurn("M001", "S01", "gate-evaluate");
+    assert.deepEqual(gateEval.map((g) => g.gate_id).sort(), ["Q3", "Q4"]);
+
+    const completeSlice = getPendingGatesForTurn("M001", "S01", "complete-slice");
+    assert.deepEqual(completeSlice.map((g) => g.gate_id), ["Q8"]);
+  });
+
+  test("task-scoped gates are scoped to the requested task id", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q6", scope: "task", taskId: "T01" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T02" });
+
+    const t1 = getPendingGatesForTurn("M001", "S01", "execute-task", "T01");
+    assert.equal(t1.length, 2);
+    assert.ok(t1.every((g) => g.gate_id === "Q5" || g.gate_id === "Q6"));
+
+    const t2 = getPendingGatesForTurn("M001", "S01", "execute-task", "T02");
+    assert.equal(t2.length, 1);
+    assert.equal(t2[0].gate_id, "Q5");
+  });
+});
+
+describe("per-turn output validators", () => {
+  test("validateSliceSummaryOutput flags missing Operational Readiness", () => {
+    const md = `# S01: Test Slice\n\n## What Happened\nstuff\n\n## Verification\nstuff\n`;
+    const result = validateSliceSummaryOutput(md);
+    assert.equal(result.valid, false);
+    assert.ok(result.missing.some((m) => m.includes("Q8")));
+    assert.ok(result.missing.some((m) => m.includes("Operational Readiness")));
+  });
+
+  test("validateSliceSummaryOutput passes when Operational Readiness heading is present", () => {
+    const md = `# S01\n\n## Operational Readiness\n- Health: /health\n- Failure: alert\n`;
+    const result = validateSliceSummaryOutput(md);
+    assert.equal(result.valid, true);
+    assert.equal(result.missing.length, 0);
+  });
+
+  test("validateMilestoneValidationOutput requires all four MV headings", () => {
+    // Missing Requirement Coverage.
+    const md = [
+      "# Milestone Validation: M001",
+      "## Success Criteria Checklist",
+      "ok",
+      "## Slice Delivery Audit",
+      "ok",
+      "## Cross-Slice Integration",
+      "ok",
+    ].join("\n\n");
+    const result = validateMilestoneValidationOutput(md);
+    assert.equal(result.valid, false);
+    assert.ok(result.missing.some((m) => m.includes("MV04")));
+  });
+
+  test("validateMilestoneValidationOutput passes for a complete VALIDATION.md", () => {
+    const md = [
+      "# Milestone Validation: M001",
+      "## Success Criteria Checklist",
+      "ok",
+      "## Slice Delivery Audit",
+      "ok",
+      "## Cross-Slice Integration",
+      "ok",
+      "## Requirement Coverage",
+      "ok",
+    ].join("\n\n");
+    const result = validateMilestoneValidationOutput(md);
+    assert.equal(result.valid, true, `unexpected missing: ${result.missing.join(", ")}`);
+  });
+
+  test("validateTaskSummaryOutput flags missing task-gate sections", () => {
+    const md = `# T01\n\n## What Happened\nstuff\n\n## Verification\nstuff\n`;
+    const result = validateTaskSummaryOutput(md);
+    assert.equal(result.valid, false);
+    const idsInMissing = result.missing.join(" ");
+    assert.ok(idsInMissing.includes("Q5"));
+    assert.ok(idsInMissing.includes("Q6"));
+    assert.ok(idsInMissing.includes("Q7"));
+  });
+
+  test("validateGateSections returns empty missing when gate bucket is empty", () => {
+    // Build a phoney owner turn that owns nothing (simulate by validating
+    // against a real turn against an artifact containing every section).
+    const fullMd = getGatesForTurn("validate-milestone")
+      .map((g) => `## ${g.promptSection}\n\nstuff`)
+      .join("\n\n");
+    const result = validateGateSections(fullMd, "validate-milestone");
+    assert.equal(result.valid, true);
+  });
+});
+
+describe("registry / renderer parity", () => {
+  test("MV promptSections match the validate-milestone renderer H2 headings", () => {
+    // Mirror the string literals from tools/validate-milestone.ts
+    // renderValidationMarkdown() so a rename there flips this test red.
+    const expectedHeadings = [
+      "Success Criteria Checklist",
+      "Slice Delivery Audit",
+      "Cross-Slice Integration",
+      "Requirement Coverage",
+    ];
+    const registryHeadings = getGatesForTurn("validate-milestone").map((g) => g.promptSection);
+    assert.deepEqual(registryHeadings.sort(), [...expectedHeadings].sort());
+  });
+
+  test("Q8 promptSection matches the complete-slice renderer H2 heading", () => {
+    // Mirror the slice-summary H2 introduced in tools/complete-slice.ts.
+    assert.equal(GATE_REGISTRY.Q8.promptSection, "Operational Readiness");
+  });
+
+  test("registry owner turns cover every turn gate-registry.ts declares", () => {
+    const ownerTurns = new Set<OwnerTurn>(Object.values(GATE_REGISTRY).map((g) => g.ownerTurn));
+    assert.ok(ownerTurns.has("gate-evaluate"));
+    assert.ok(ownerTurns.has("execute-task"));
+    assert.ok(ownerTurns.has("complete-slice"));
+    assert.ok(ownerTurns.has("validate-milestone"));
+  });
+});

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

@@ -32,6 +32,15 @@ test("classifyError detects rate limit from message", () => {
   assert.equal(result.kind, "rate-limit");
 });
 
+test("classifyError treats OpenRouter affordability errors as transient rate-limit class", () => {
+  const result = classifyError(
+    "402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
+  );
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0);
+});
+
 test("classifyError extracts reset delay from message", () => {
   const result = classifyError("rate limit exceeded, reset in 45s");
   assert.equal(result.kind, "rate-limit");
@@ -101,6 +110,13 @@ test("classifyError detects quota exceeded as permanent", () => {
   assert.ok(!isTransient(result));
 });
 
+test("classifyError treats plain 'Connection error.' as transient connection failure (#3594)", () => {
+  const result = classifyError("Connection error.");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "connection");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 15_000);
+});
+
 test("classifyError treats unknown error as not transient", () => {
   const result = classifyError("something went wrong");
   assert.ok(!isTransient(result));

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -37,10 +37,10 @@ test("dashboard shortcut resolves the project root instead of the current worktr
   });
 
   let capturedHandler: ((ctx: any) => Promise<void>) | null = null;
-  const shortcuts: Array<{ description: string; handler: (ctx: any) => Promise<void> }> = [];
+  const shortcuts: Array<{ key: string; description: string; handler: (ctx: any) => Promise<void> }> = [];
   const pi = {
-    registerShortcut: (_key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
-      shortcuts.push(shortcut);
+    registerShortcut: (key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
+      shortcuts.push({ key: String(key), ...shortcut });
       if (!capturedHandler) {
         capturedHandler = shortcut.handler;
       }
@@ -69,5 +69,63 @@ test("dashboard shortcut resolves the project root instead of the current worktr
 
   assert.ok(customCalls > 0, "shortcut opens the dashboard overlay when project root is resolved");
   assert.equal(notices.length, 0, "shortcut does not fall back to the missing-.gsd warning");
-  assert.equal(shortcuts.length, 3, "all GSD shortcuts are still registered");
+  assert.equal(shortcuts.length, 5, "all GSD shortcuts are still registered");
+  const keys = shortcuts.map((shortcut) => shortcut.key);
+  assert.ok(keys.includes("ctrl+alt+g"), "primary dashboard shortcut is registered");
+  assert.ok(keys.includes("ctrl+shift+g"), "fallback dashboard shortcut is registered");
+  assert.ok(keys.includes("ctrl+alt+n"), "primary notifications shortcut is registered");
+  assert.ok(keys.includes("ctrl+shift+n"), "fallback notifications shortcut is registered");
+  assert.ok(keys.includes("ctrl+alt+p"), "primary parallel shortcut is registered");
+  // No Ctrl+Shift+P fallback — conflicts with cycleModelBackward (shift+ctrl+p)
+  assert.ok(!keys.includes("ctrl+shift+p"), "parallel fallback must not be registered (conflicts with cycleModelBackward)");
+});
+
+test("parallel shortcut passes resolved project root into overlay", async (t) => {
+  const base = makeTempDir("parallel-root");
+  const worktreeRoot = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(join(base, ".gsd", "parallel"), { recursive: true });
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(worktreeRoot);
+  t.after(() => {
+    process.chdir(originalCwd);
+    cleanup(base);
+  });
+
+  const shortcuts: Array<{ key: string; description: string; handler: (ctx: any) => Promise<void> }> = [];
+  registerShortcuts({
+    registerShortcut: (key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
+      shortcuts.push({ key: String(key), ...shortcut });
+    },
+  } as any);
+
+  const parallelShortcut = shortcuts.find((shortcut) => shortcut.key === "ctrl+alt+p");
+  assert.ok(parallelShortcut, "parallel shortcut is registered");
+
+  let capturedBasePath: string | undefined;
+  await parallelShortcut!.handler({
+    hasUI: true,
+    ui: {
+      custom: async (factory: any) => {
+        const overlay = factory(
+          { requestRender() {} },
+          { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+          null,
+          () => {},
+        );
+        capturedBasePath = (overlay as any).basePath;
+        overlay.dispose?.();
+        return true;
+      },
+      notify: () => {},
+    },
+  });
+
+  assert.ok(capturedBasePath, "parallel shortcut should construct overlay with a basePath");
+  assert.equal(
+    realpathSync(capturedBasePath),
+    realpathSync(base),
+    "parallel overlay should use the resolved project root, not the worktree cwd",
+  );
 });

package/src/resources/extensions/gsd/tests/session-model-override.test.ts

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  clearSessionModelOverride,
+  getSessionModelOverride,
+  setSessionModelOverride,
+} from "../session-model-override.js";
+
+const phasesSource = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
+
+test("setSessionModelOverride stores provider/model for the session", () => {
+  const sessionId = `session-override-${Date.now()}`;
+  setSessionModelOverride(sessionId, { provider: "openai-codex", id: "gpt-5.4" });
+
+  const override = getSessionModelOverride(sessionId);
+  assert.equal(override?.provider, "openai-codex");
+  assert.equal(override?.id, "gpt-5.4");
+});
+
+test("clearSessionModelOverride removes the session override", () => {
+  const sessionId = `session-clear-${Date.now()}`;
+  setSessionModelOverride(sessionId, { provider: "anthropic", id: "claude-sonnet-4-6" });
+  clearSessionModelOverride(sessionId);
+  assert.equal(getSessionModelOverride(sessionId), undefined);
+});
+
+test("auto dispatch threads manual session model override into selectAndApplyModel", () => {
+  assert.ok(
+    phasesSource.includes("s.manualSessionModelOverride"),
+    "auto/phases.ts should pass s.manualSessionModelOverride into selectAndApplyModel",
+  );
+});

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -0,0 +1,90 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const gsdDir = resolve(import.meta.dirname, "..");
+
+function readGsdFile(relativePath: string): string {
+  return readFileSync(resolve(gsdDir, relativePath), "utf-8");
+}
+
+test("command entrypoints use startAutoDetached instead of awaiting startAuto (#3733)", () => {
+  const autoHandlerSrc = readGsdFile("commands/handlers/auto.ts");
+  const workflowHandlerSrc = readGsdFile("commands/handlers/workflow.ts");
+  const guidedFlowSrc = readGsdFile("guided-flow.ts");
+
+  assert.ok(
+    !autoHandlerSrc.includes("await startAuto("),
+    "auto command handler should not await startAuto from the active agent turn",
+  );
+  assert.ok(
+    !workflowHandlerSrc.includes("await startAuto("),
+    "workflow command handler should not await startAuto from the active agent turn",
+  );
+  assert.ok(
+    !guidedFlowSrc.includes("await startAuto("),
+    "guided flow should not await startAuto from the active agent turn",
+  );
+
+  assert.ok(
+    autoHandlerSrc.includes("startAutoDetached("),
+    "auto command handler should launch auto-mode through startAutoDetached",
+  );
+  assert.ok(
+    workflowHandlerSrc.includes("startAutoDetached("),
+    "workflow handler should launch auto-mode through startAutoDetached",
+  );
+  assert.ok(
+    guidedFlowSrc.includes("startAutoDetached("),
+    "guided flow should launch auto-mode through startAutoDetached",
+  );
+});
+
+test("startAutoDetached reports failures asynchronously (#3733)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+
+  assert.ok(
+    autoSrc.includes("export function startAutoDetached"),
+    "auto.ts should export startAutoDetached",
+  );
+  assert.ok(
+    autoSrc.includes("void startAuto(ctx, pi, base, verboseMode, options).catch"),
+    "startAutoDetached should launch startAuto without awaiting it",
+  );
+  assert.ok(
+    autoSrc.includes("ctx.ui.notify(`Auto-start failed: ${message}`, \"error\")"),
+    "startAutoDetached should surface async startup failures to the user",
+  );
+});
+
+test("detached auto-start preserves milestone lock across pause/stop cleanup (#3733)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const sessionSrc = readGsdFile("auto/session.ts");
+
+  assert.ok(
+    autoSrc.includes("milestoneLock?: string | null"),
+    "startAuto/startAutoDetached options should carry an explicit milestone lock",
+  );
+  assert.ok(
+    autoSrc.includes("s.sessionMilestoneLock = options.milestoneLock ?? null;"),
+    "startAuto should capture the requested milestone lock before async work begins",
+  );
+  assert.ok(
+    autoSrc.includes("milestoneLock: s.sessionMilestoneLock ?? undefined"),
+    "pause metadata should persist the detached milestone lock for resume",
+  );
+  assert.ok(
+    autoSrc.includes("s.sessionMilestoneLock = meta.milestoneLock ?? null;"),
+    "resume should restore the persisted milestone lock",
+  );
+  assert.ok(
+    autoSrc.includes("restoreMilestoneLockEnv();"),
+    "auto cleanup should restore the previous process milestone-lock env",
+  );
+
+  assert.ok(
+    sessionSrc.includes("sessionMilestoneLock: string | null = null;"),
+    "AutoSession should track the detached milestone lock explicitly",
+  );
+});

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -61,6 +61,13 @@ describe("#2883: isToolInvocationError classification", () => {
     );
   });
 
+  test("detects Node v18+ JSON parse variant with property-value text", () => {
+    assert.equal(
+      isToolInvocationError("Expected ',' or '}' after property value in JSON at position 4096"),
+      true,
+    );
+  });
+
   test("detects Unexpected end of JSON input", () => {
     assert.equal(
       isToolInvocationError("Unexpected end of JSON input"),

package/src/resources/extensions/gsd/tests/validate-milestone-prompt-verification-classes.test.ts

@@ -0,0 +1,18 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const promptPath = join(process.cwd(), "src/resources/extensions/gsd/prompts/validate-milestone.md");
+const prompt = readFileSync(promptPath, "utf-8");
+
+test("validate-milestone reviewer C requires canonical verification class names", () => {
+  assert.match(prompt, /\*\*Reviewer C[\s\S]*Verification Classes/i);
+  assert.match(prompt, /exact class names [`']?Contract[`']?, [`']?Integration[`']?, [`']?Operational[`']?, and [`']?UAT[`']?/i);
+  assert.match(prompt, /If no verification classes were planned, say that explicitly/i);
+});
+
+test("validate-milestone prompt routes verification class analysis into verificationClasses", () => {
+  assert.match(prompt, /pass it in `verificationClasses`/i);
+  assert.match(prompt, /Extract the `Verification Classes` subsection from Reviewer C and pass it verbatim in `verificationClasses`/);
+});

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -21,7 +21,10 @@ import {
   getMilestone,
   updateSliceStatus,
   setSliceSummaryMd,
+  saveGateResult,
+  getPendingGatesForTurn,
 } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSliceFile, resolveSlicePath, clearPathCache } from "../paths.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -39,6 +42,23 @@ export interface CompleteSliceResult {
   uatPath: string;
 }
 
+/**
+ * Map a complete-slice-owned gate id to the CompleteSliceParams field
+ * whose presence drives `pass` vs. `omitted`. Keep this in lockstep with
+ * the gates declared in gate-registry.ts under ownerTurn "complete-slice".
+ */
+function sliceGateFieldForId(
+  id: string,
+  params: CompleteSliceParams,
+): string | undefined {
+  switch (id) {
+    case "Q8":
+      return params.operationalReadiness;
+    default:
+      return undefined;
+  }
+}
+
 /**
  * Render slice summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -169,6 +189,10 @@ ${reqSurfaced}
 
 ${reqInvalidated}
 
+## Operational Readiness
+
+${params.operationalReadiness?.trim() || "None."}
+
 ## Deviations
 
 ${params.deviations || "None."}
@@ -330,6 +354,45 @@ export async function handleCompleteSlice(
   // Store rendered markdown in DB for D004 recovery
   setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
 
+  // ── Close gates owned by complete-slice (Q8) ───────────────────────────
+  // Each owned gate maps to a specific summary section via the registry.
+  // If the caller populated the corresponding field, record `pass`; if the
+  // field is empty, record `omitted`. Without this loop, Q8 would stay
+  // pending forever and block future state derivation (see gate-registry).
+  try {
+    const pendingGates = getPendingGatesForTurn(
+      params.milestoneId,
+      params.sliceId,
+      "complete-slice",
+    );
+    if (pendingGates.length > 0) {
+      const ownedDefs = new Map(getGatesForTurn("complete-slice").map((g) => [g.id, g] as const));
+      for (const row of pendingGates) {
+        const def = ownedDefs.get(row.gate_id);
+        if (!def) continue;
+        // Map gate id → param field it maps to. Keep the map local so
+        // adding a new complete-slice gate is a single place change.
+        const field = sliceGateFieldForId(def.id, params);
+        const hasContent = typeof field === "string" && field.trim().length > 0;
+        saveGateResult({
+          milestoneId: params.milestoneId,
+          sliceId: params.sliceId,
+          gateId: def.id,
+          verdict: hasContent ? "pass" : "omitted",
+          rationale: hasContent
+            ? `${def.promptSection} section populated in slice summary`
+            : `${def.promptSection} section left empty — recorded as omitted`,
+          findings: hasContent ? (field as string).trim() : "",
+        });
+      }
+    }
+  } catch (gateErr) {
+    logWarning(
+      "tool",
+      `complete-slice gate close warning for ${params.milestoneId}/${params.sliceId}: ${(gateErr as Error).message}`,
+    );
+  }
+
   // Invalidate all caches
   invalidateStateCache();
   clearPathCache();

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -24,7 +24,10 @@ import {
   updateTaskStatus,
   setTaskSummaryMd,
   deleteVerificationEvidence,
+  saveGateResult,
+  getPendingGatesForTurn,
 } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -44,6 +47,27 @@ export interface CompleteTaskResult {
 
 import type { TaskRow } from "../gsd-db.js";
 
+/**
+ * Map an execute-task-owned gate id to the CompleteTaskParams field whose
+ * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
+ * declared in gate-registry.ts under ownerTurn "execute-task".
+ */
+function taskGateFieldForId(
+  id: string,
+  params: CompleteTaskParams,
+): string | undefined {
+  switch (id) {
+    case "Q5":
+      return params.failureModes;
+    case "Q6":
+      return params.loadProfile;
+    case "Q7":
+      return params.negativeTests;
+    default:
+      return undefined;
+  }
+}
+
 /**
  * Normalize a list parameter that may arrive as a string (newline-delimited
  * bullet list from the LLM) into a string array (#3361).
@@ -236,6 +260,45 @@ export async function handleCompleteTask(
   // Store rendered markdown in DB for D004 recovery
   setTaskSummaryMd(params.milestoneId, params.sliceId, params.taskId, summaryMd);
 
+  // ── Close gates owned by execute-task (Q5/Q6/Q7) for this task ────────
+  // Each gate id maps to a specific params field via taskGateFieldForId.
+  // When the model populates the field, record `pass`; when it's empty,
+  // record `omitted`. Task-scoped rows are filtered by taskId so a single
+  // task's completion doesn't touch sibling tasks' gate rows.
+  try {
+    const pendingGates = getPendingGatesForTurn(
+      params.milestoneId,
+      params.sliceId,
+      "execute-task",
+      params.taskId,
+    );
+    if (pendingGates.length > 0) {
+      const ownedDefs = new Map(getGatesForTurn("execute-task").map((g) => [g.id, g] as const));
+      for (const row of pendingGates) {
+        const def = ownedDefs.get(row.gate_id);
+        if (!def) continue;
+        const field = taskGateFieldForId(def.id, params);
+        const hasContent = typeof field === "string" && field.trim().length > 0;
+        saveGateResult({
+          milestoneId: params.milestoneId,
+          sliceId: params.sliceId,
+          taskId: params.taskId,
+          gateId: def.id,
+          verdict: hasContent ? "pass" : "omitted",
+          rationale: hasContent
+            ? `${def.promptSection} section populated in task summary`
+            : `${def.promptSection} section left empty — recorded as omitted`,
+          findings: hasContent ? (field as string).trim() : "",
+        });
+      }
+    }
+  } catch (gateErr) {
+    logWarning(
+      "tool",
+      `complete-task gate close warning for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${(gateErr as Error).message}`,
+    );
+  }
+
   // Invalidate all caches
   invalidateStateCache();
   clearPathCache();

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -8,6 +8,7 @@ import {
   _getAdapter,
   saveGateResult,
 } from "../gsd-db.js";
+import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
 import type { CompleteMilestoneParams } from "./complete-milestone.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -427,7 +428,9 @@ export async function executeSaveGateResult(
       };
   }
 
-  const validGates = ["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"];
+  // Source of truth: gate-registry.ts. Every declared GateId is accepted,
+  // so adding a new gate in one place automatically flows through here.
+  const validGates = Object.keys(GATE_REGISTRY);
   if (!validGates.includes(params.gateId)) {
     return {
       content: [{ type: "text", text: `Error: Invalid gateId "${params.gateId}". Must be one of: ${validGates.join(", ")}` }],