@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/tests/auto-phases-lifecycle.test.ts

@@ -207,6 +207,7 @@ test("runFinalize merges a verified complete-milestone immediately and only once
   const startedAt = Date.now();
   let lifecycleMergeCalls = 0;
   let resolverMergeCalls = 0;
+  const stopAutoCalls: Array<{ reason?: string; options?: unknown }> = [];
   s.basePath = base;
   s.originalBasePath = base;
   s.currentMilestoneId = "M001";
@@ -219,6 +220,9 @@ test("runFinalize merges a verified complete-milestone immediately and only once
   const result = await runFinalizeWithDeps(s, {
     preflightCleanRoot: () => ({ stashPushed: false }),
     postflightPopStash: () => ({ needsManualRecovery: false }),
+    stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string, options?: unknown) => {
+      stopAutoCalls.push({ reason, options });
+    },
     resolver: {
       mergeAndExit() {
         resolverMergeCalls++;
@@ -232,10 +236,19 @@ test("runFinalize merges a verified complete-milestone immediately and only once
     },
   });
 
-  assert.equal(result.action, "next");
+  assert.equal(result.action, "break");
+  assert.equal(result.reason, "milestone-complete");
   assert.equal(lifecycleMergeCalls, 1);
   assert.equal(resolverMergeCalls, 0);
   assert.equal(s.milestoneMergedInPhases, true);
+  assert.equal(stopAutoCalls.length, 1);
+  assert.equal(stopAutoCalls[0]?.reason, "Milestone M001 complete");
+  assert.deepEqual(stopAutoCalls[0]?.options, {
+    completionWidget: {
+      milestoneId: "M001",
+      milestoneTitle: "Milestone",
+    },
+  });
 
   s.currentUnit = {
     type: "complete-milestone",
@@ -245,6 +258,9 @@ test("runFinalize merges a verified complete-milestone immediately and only once
   const second = await runFinalizeWithDeps(s, {
     preflightCleanRoot: () => ({ stashPushed: false }),
     postflightPopStash: () => ({ needsManualRecovery: false }),
+    stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string, options?: unknown) => {
+      stopAutoCalls.push({ reason, options });
+    },
     resolver: {
       mergeAndExit() {
         resolverMergeCalls++;
@@ -258,9 +274,11 @@ test("runFinalize merges a verified complete-milestone immediately and only once
     },
   });
 
-  assert.equal(second.action, "next");
+  assert.equal(second.action, "break");
+  assert.equal(second.reason, "milestone-complete");
   assert.equal(lifecycleMergeCalls, 1);
   assert.equal(resolverMergeCalls, 0);
+  assert.equal(stopAutoCalls.length, 2);
 });
 
 test("runFinalize does not render next-phase handoff for complete-milestone", async (t) => {
@@ -302,7 +320,7 @@ test("runFinalize does not render next-phase handoff for complete-milestone", as
     },
   );
 
-  assert.equal(result.action, "next");
+  assert.equal(result.action, "break");
   assert.equal(
     widgetCalls.some(([key]) => key === "gsd-outcome"),
     false,
@@ -310,6 +328,60 @@ test("runFinalize does not render next-phase handoff for complete-milestone", as
   );
 });
 
+test("runFinalize clears gsd-step and gsd-progress before stopAuto on complete-milestone", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-stale-widget-"));
+  t.after(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const s = new AutoSession();
+  s.basePath = base;
+  s.originalBasePath = base;
+  s.currentMilestoneId = "M001";
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt: Date.now(),
+  };
+
+  const statusCalls: Array<[string, unknown]> = [];
+  const widgetCalls: Array<[string, unknown]> = [];
+
+  await runFinalizeWithDeps(
+    s,
+    {
+      preflightCleanRoot: () => ({ stashPushed: false }),
+      postflightPopStash: () => ({ needsManualRecovery: false }),
+      lifecycle: {
+        exitMilestone() {
+          return { ok: true, merged: true, codeFilesChanged: false };
+        },
+      },
+    },
+    {
+      hasUI: true,
+      ui: {
+        notify() {},
+        setStatus(key: string, value: unknown) {
+          statusCalls.push([key, value]);
+        },
+        setWidget(key: string, value: unknown) {
+          widgetCalls.push([key, value]);
+        },
+      },
+    },
+  );
+
+  assert.ok(
+    statusCalls.some(([key, val]) => key === "gsd-step" && val === undefined),
+    "gsd-step status should be cleared before stopAuto",
+  );
+  assert.ok(
+    widgetCalls.some(([key, val]) => key === "gsd-progress" && val === undefined),
+    "gsd-progress widget should be cleared before stopAuto",
+  );
+});
+
 test("runFinalize stops before merge when an isolated unit leaks app files into project root", async (t) => {
   const root = mkdtempSync(join(tmpdir(), "gsd-root-leak-root-"));
   const worktree = join(root, ".gsd", "worktrees", "M001");

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

@@ -9,7 +9,7 @@ import { randomUUID } from "node:crypto";
 
 import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, buildLoopRemediationSteps, writeBlockerPlaceholder, refreshRecoveryDbForArtifact, writeReactiveExecuteBlocker } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, insertAssessment, getMilestone, getMilestoneCommitAttributionShas, getTask } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, insertAssessment, getMilestone, getMilestoneCommitAttributionShas, getTask, saveGateResult } from "../gsd-db.ts";
 import { readEvents } from "../workflow-events.ts";
 import { clearParseCache } from "../files.ts";
 import { parseRoadmap } from "../parsers-legacy.ts";
@@ -1613,6 +1613,27 @@ test("verifyExpectedArtifact checks pending gate-evaluate artifacts without ESM
   assert.equal(verified, false, "pending gates should keep gate-evaluate unverified");
 });
 
+test("verifyExpectedArtifact fails closed for gate-evaluate when the DB is unavailable", () => {
+  const base = makeTmpProject();
+  closeDatabase();
+
+  const verified = verifyExpectedArtifact("gate-evaluate", "M001/S01/gates+Q3", base);
+
+  assert.equal(verified, false, "gate-evaluate must verify against the DB-backed gate rows");
+});
+
+test("verifyExpectedArtifact ignores complete-slice gates in stale gate-evaluate unit ids", () => {
+  const base = makeTmpProject();
+  insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+  insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q8", scope: "slice" });
+  saveGateResult({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", verdict: "pass", rationale: "OK", findings: "" });
+  saveGateResult({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", verdict: "pass", rationale: "OK", findings: "" });
+
+  const verified = verifyExpectedArtifact("gate-evaluate", "M001/S01/gates+Q3,Q4,Q8", base);
+
+  assert.equal(verified, true, "pending Q8 belongs to complete-slice and must not keep gate-evaluate unverified");
+});
+
 // ─── #4414 regressions ────────────────────────────────────────────────────────
 
 test("#4414: writeBlockerPlaceholder invalidates path cache so dispatch guard sees file", () => {

package/src/resources/extensions/gsd/tests/before-provider-context-management.test.ts

@@ -0,0 +1,145 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { _setAutoActiveForTest } from "../auto.ts";
+import { autoSession } from "../auto-runtime-state.js";
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+
+type HookHandler = (event: any, ctx?: any) => Promise<any> | any;
+
+function createHookHandlers(): Map<string, HookHandler[]> {
+  const handlers = new Map<string, HookHandler[]>();
+  const pi = {
+    on(event: string, handler: HookHandler) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  };
+
+  registerHooks(pi as any, []);
+  return handlers;
+}
+
+function requireHook(handlers: Map<string, HookHandler[]>, event: string): HookHandler {
+  const handler = handlers.get(event)?.[0];
+  assert.ok(handler, `${event} hook should be registered`);
+  return handler;
+}
+
+test("before_provider_request truncates tool results outside auto-mode", async (t) => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-before-provider-context-"));
+  const gsdHome = join(dir, "home");
+  const project = join(dir, "project");
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+
+  mkdirSync(join(project, ".gsd"), { recursive: true });
+  mkdirSync(gsdHome, { recursive: true });
+  writeFileSync(
+    join(project, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "version: 1",
+      "context_management:",
+      "  tool_result_max_chars: 200",
+      "  observation_mask_turns: 1",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = gsdHome;
+  process.chdir(project);
+  _setAutoActiveForTest(false);
+
+  t.after(() => {
+    _setAutoActiveForTest(false);
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const beforeProviderRequest = requireHook(createHookHandlers(), "before_provider_request");
+  const messageText = "m".repeat(250);
+  const responsesOutput = "r".repeat(250);
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "keep me" }] },
+      {
+        role: "toolResult",
+        toolCallId: "toolu_test",
+        toolName: "Read",
+        isError: false,
+        content: [{ type: "text", text: messageText }],
+      },
+    ],
+    input: [
+      { role: "user", content: [{ type: "input_text", text: "keep me" }] },
+      { type: "function_call_output", call_id: "call_test", output: responsesOutput },
+    ],
+  };
+
+  await beforeProviderRequest({ payload });
+
+  const truncatedMessage = (payload.messages[1]?.content as Array<{ text?: string }>)[0]?.text ?? "";
+  const truncatedResponsesOutput = String(payload.input[1]?.output ?? "");
+
+  assert.match(truncatedMessage, /\[truncated\]/);
+  assert.match(truncatedResponsesOutput, /\[truncated\]/);
+  assert.ok(truncatedMessage.length < messageText.length);
+  assert.ok(truncatedResponsesOutput.length < responsesOutput.length);
+  assert.doesNotMatch(truncatedMessage, /result masked/);
+  assert.doesNotMatch(truncatedResponsesOutput, /result masked/);
+});
+
+test("successful shell result clears source context before provider injection", async (t) => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-before-provider-source-"));
+  const project = join(dir, "project");
+  mkdirSync(project, { recursive: true });
+  writeFileSync(join(project, "app.ts"), "export const value = 'before';\n");
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = project;
+  autoSession.setCurrentUnit({
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: 123,
+    workspaceRoot: project,
+  });
+  autoSession.sourceObservations.observeRead({ path: "app.ts" });
+
+  t.after(() => {
+    autoSession.reset();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  assert.match(autoSession.sourceObservations.renderActiveBlock() ?? "", /before/);
+
+  const handlers = createHookHandlers();
+  const toolResult = requireHook(handlers, "tool_result");
+  const beforeProviderRequest = requireHook(handlers, "before_provider_request");
+
+  await toolResult({
+    toolCallId: "toolu_bash",
+    toolName: "bash",
+    input: { command: "printf after > app.ts" },
+    isError: false,
+    result: "ok",
+  }, { cwd: project });
+
+  const payload = {
+    messages: [{ role: "user", content: [{ type: "text", text: "continue" }] }],
+  };
+  await beforeProviderRequest({ payload });
+
+  assert.equal(autoSession.sourceObservations.renderActiveBlock(), null);
+  assert.equal(payload.messages.length, 1);
+  assert.doesNotMatch(payload.messages[0].content[0].text, /Source Context Block/);
+});

package/src/resources/extensions/gsd/tests/closeout-wizard.test.ts

@@ -8,6 +8,7 @@ import {
   buildCloseoutMenuActions,
   buildIdleMenuSummary,
   getPrimaryCloseoutRecommendation,
+  showMilestoneMergeCloseout,
 } from "../closeout-wizard.ts";
 import { buildGsdHomeModel } from "../gsd-command-home.ts";
 import type { GSDState } from "../types.ts";
@@ -119,3 +120,46 @@ test("/gsd home recommends merge milestone when closeout is pending", () => {
   assert.equal(merge?.recommended, true);
   assert.equal(merge?.enabled, true);
 });
+
+test("milestone merge closeout clears stale timer controls and installs the closeout outcome", () => {
+  const statuses: Array<[string, string | undefined]> = [];
+  const widgets: Array<[string, unknown]> = [];
+
+  showMilestoneMergeCloseout({
+    hasUI: true,
+    ui: {
+      setStatus: (key: string, value: string | undefined) => {
+        statuses.push([key, value]);
+      },
+      setWidget: (key: string, value: unknown) => {
+        widgets.push([key, value]);
+      },
+    },
+  } as any, {
+    milestoneId: "M004",
+    branch: "milestone/M004",
+    integrationBranch: "main",
+    files: ["src/app.ts"],
+    dirtyOverlap: [],
+  });
+
+  assert.deepEqual(statuses, [
+    ["gsd-auto", undefined],
+    ["gsd-step", undefined],
+  ]);
+  assert.ok(
+    widgets.some(([key, value]) => key === "gsd-progress" && value === undefined),
+    "stale progress/timer widget should be cleared",
+  );
+  const outcome = widgets.find(([key]) => key === "gsd-outcome")?.[1];
+  assert.equal(typeof outcome, "function");
+
+  const component = (outcome as any)(
+    { requestRender() {} },
+    { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+  );
+  const rendered = component.render(100).join("\n");
+  assert.match(rendered, /Milestone M004 merged/);
+  assert.match(rendered, /Review the closeout/);
+  assert.doesNotMatch(rendered, /\/gsd auto/);
+});

package/src/resources/extensions/gsd/tests/commands-dispatcher-unmerged-milestone.test.ts

@@ -40,6 +40,7 @@ function makeMockCtx(base: string): {
   return {
     ctx: {
       cwd: base,
+      hasUI: true,
       ui: {
         notify: (message: string, kind: string) => {
           calls.push({ message, kind });
@@ -217,7 +218,7 @@ test("dispatcher recovers a completed unmerged milestone through complete-milest
   const base = makeTempRepo("gsd-dispatch-unmerged-");
   try {
     seedRegisteredCompletedWorktree(base);
-    const { ctx, calls } = makeMockCtx(base);
+    const { ctx, calls, widgets, statuses } = makeMockCtx(base);
     const { pi, messages } = makeMockPi();
 
     await handleGSDCommand("dispatch complete-milestone M008", ctx, pi);
@@ -231,6 +232,30 @@ test("dispatcher recovers a completed unmerged milestone through complete-milest
       calls.some((call) => call.message.includes("Milestone M008 merged to main")),
       "user sees merge recovery success",
     );
+    assert.ok(
+      calls.some((call) => call.message.includes("Closeout is complete")),
+      "merge recovery ends at a closeout-complete message",
+    );
+    assert.ok(
+      calls.every((call) => !call.message.includes("Run /gsd again when ready")),
+      "merge recovery must not send the user past the closeout endpoint",
+    );
+    assert.ok(
+      statuses.some(([key, value]) => key === "gsd-auto" && value === undefined),
+      "merge recovery clears stale auto status so the run timer stops",
+    );
+    assert.ok(
+      statuses.some(([key, value]) => key === "gsd-step" && value === undefined),
+      "merge recovery clears stale step status",
+    );
+    assert.ok(
+      widgets.some(([key, value]) => key === "gsd-progress" && value === undefined),
+      "merge recovery clears stale progress/timer controls",
+    );
+    assert.ok(
+      widgets.some(([key, value]) => key === "gsd-outcome" && typeof value === "function"),
+      "merge recovery installs a durable closeout outcome",
+    );
     assert.equal(readFileSync(join(base, "index.html"), "utf-8"), "<h1>M008</h1>\n");
     assert.equal(git(base, "branch", "--list", "milestone/M008"), "");
   } finally {

package/src/resources/extensions/gsd/tests/content-validator.test.ts

@@ -0,0 +1,74 @@
+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 { validateContent } from "../safety/content-validator.ts";
+
+function makeTempFile(content: string): { base: string; path: string } {
+  const base = mkdtempSync(join(tmpdir(), "gsd-content-validator-"));
+  mkdirSync(base, { recursive: true });
+  const path = join(base, "artifact.md");
+  writeFileSync(path, content, "utf-8");
+  return { base, path };
+}
+
+test("validateContent marks empty milestone roadmaps as blocking", () => {
+  const { base, path } = makeTempFile([
+    "# M004: Empty roadmap",
+    "",
+    "## Slices",
+    "",
+    "_TBD_",
+    "",
+  ].join("\n"));
+
+  try {
+    const violations = validateContent("plan-milestone", path);
+    assert.deepEqual(violations, [{
+      severity: "error",
+      reason: "Milestone roadmap has 0 slice(s) — expected at least 1",
+    }]);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("validateContent accepts checkbox milestone roadmap slices", () => {
+  const { base, path } = makeTempFile([
+    "# M004: Roadmap",
+    "",
+    "## Slices",
+    "",
+    "- [ ] **S01: Browser due dates** `risk:low` `depends:[]`",
+    "  > After this: due dates are visible.",
+    "",
+  ].join("\n"));
+
+  try {
+    const violations = validateContent("plan-milestone", path);
+    assert.deepEqual(violations, []);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("validateContent marks empty slice plans as blocking", () => {
+  const { base, path } = makeTempFile([
+    "# S01: Empty slice",
+    "",
+    "## Tasks",
+    "",
+    "_TBD_",
+    "",
+  ].join("\n"));
+
+  try {
+    const violations = validateContent("plan-slice", path);
+    assert.equal(violations[0]?.severity, "error");
+    assert.equal(violations[0]?.reason, "Slice plan has 0 task(s) — expected at least 1");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -8,7 +8,7 @@
 
 import { describe, it, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -18,7 +18,7 @@ import type { LoopDeps } from "../auto/loop-deps.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import type { SessionLockStatus } from "../session-lock.js";
 import { writeGraph, readGraph, type WorkflowGraph, type GraphStep } from "../graph.ts";
-import { writeFileSync } from "node:fs";
+import { SourceObservationStore } from "../source-observations.js";
 import { stringify } from "yaml";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────
@@ -115,6 +115,7 @@ function makeLoopSession(overrides?: Record<string, unknown>) {
     currentMilestoneId: null,
     currentUnit: null,
     currentUnitRouting: null,
+    sourceObservations: new SourceObservationStore(),
     completedUnits: [],
     resourceVersionOnStart: null,
     lastPromptCharCount: undefined,
@@ -139,6 +140,19 @@ function makeLoopSession(overrides?: Record<string, unknown>) {
       newSession: () => Promise.resolve({ cancelled: false }),
       getContextUsage: () => ({ percent: 10, tokens: 1000, limit: 10000 }),
     },
+    setCurrentUnit(this: any, unit: any) {
+      this.currentUnit = unit;
+      this.sourceObservations.beginUnit({
+        unitType: unit.type,
+        unitId: unit.id,
+        startedAt: unit.startedAt,
+        basePath: unit.workspaceRoot ?? this.basePath,
+      });
+    },
+    clearCurrentUnit(this: any) {
+      this.currentUnit = null;
+      this.sourceObservations.clear();
+    },
     clearTimers: () => {},
     lockBasePath: "/tmp/project",
     ...overrides,

package/src/resources/extensions/gsd/tests/doctor-scope-db-unavailable.test.ts

@@ -109,22 +109,12 @@ test("checkEngineHealth treats explicit reopen as authoritative when dispatch ti
       worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
   ).run("worker-1", "localhost", 1, "2026-01-01T00:00:00.000Z", "test", "2026-01-01T00:00:00.000Z", "stopped", base);
-  db.exec("PRAGMA writable_schema = ON");
   db.prepare(
-    `UPDATE sqlite_schema
-     SET sql = replace(sql, 'started_at TEXT NOT NULL', 'started_at TEXT')
-     WHERE type = 'table' AND name = 'unit_dispatches'`,
-  ).run();
-  db.exec("PRAGMA writable_schema = OFF");
-  closeDatabase();
-  openDatabase(join(gsdDir, "gsd.db"));
-  const reopenedDb = _getAdapter()!;
-  reopenedDb.prepare(
     `INSERT INTO unit_dispatches (
       trace_id, worker_id, milestone_lease_token, milestone_id,
       unit_type, unit_id, status, attempt_n, started_at, ended_at
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-  ).run("trace-1", "worker-1", 1, "M001", "complete-milestone", "M001", "completed", 1, null, null);
+  ).run("trace-1", "worker-1", 1, "M001", "complete-milestone", "M001", "completed", 1, "", "");
   appendEvent(base, {
     cmd: "reopen-milestone",
     params: { milestoneId: "M001" },

package/src/resources/extensions/gsd/tests/gate-dispatch.test.ts

@@ -19,10 +19,12 @@ import {
   saveGateResult,
   markAllGatesOmitted,
   getPendingSliceGateCount,
+  getGateResults,
 } from "../gsd-db.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
 import { renderPlanFromDb } from "../markdown-renderer.ts";
 import { invalidateAllCaches } from "../cache.ts";
+import { DISPATCH_RULES } from "../auto-dispatch.ts";
 
 function setupTestProject(): { tmpDir: string; dbPath: string } {
   const tmpDir = mkdtempSync(join(tmpdir(), "gate-dispatch-"));
@@ -213,4 +215,66 @@ describe("evaluating-gates phase", () => {
       `pending Q8 must not stall evaluating-gates — got phase=${state.phase}`,
     );
   });
+
+  test("gate-evaluate dispatch id includes only gate-evaluate-owned gates", async () => {
+    planSlice(tmpDir);
+    await renderPlanFromDb(tmpDir, "M001", "S01");
+
+    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" });
+
+    invalidateStateCache();
+    const state = await deriveState(tmpDir);
+    assert.equal(state.phase, "evaluating-gates");
+
+    const rule = DISPATCH_RULES.find((candidate) => candidate.name === "evaluating-gates → gate-evaluate");
+    assert.ok(rule, "gate-evaluate dispatch rule must exist");
+
+    const result = await rule.match({
+      basePath: tmpDir,
+      mid: "M001",
+      midTitle: "Test Milestone",
+      state,
+      prefs: { gate_evaluation: { enabled: true } },
+    });
+
+    assert.ok(result);
+    assert.equal(result.action, "dispatch");
+    if (result.action !== "dispatch") throw new Error("expected gate-evaluate dispatch");
+    assert.equal(result.unitId, "M001/S01/gates+Q3,Q4");
+    assert.doesNotMatch(result.prompt, /\*\*Q8\*\*/);
+  });
+
+  test("disabled gate evaluation only omits gate-evaluate-owned gates", async () => {
+    planSlice(tmpDir);
+    await renderPlanFromDb(tmpDir, "M001", "S01");
+
+    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" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+
+    invalidateStateCache();
+    const state = await deriveState(tmpDir);
+    assert.equal(state.phase, "evaluating-gates");
+
+    const rule = DISPATCH_RULES.find((candidate) => candidate.name === "evaluating-gates → gate-evaluate");
+    assert.ok(rule, "gate-evaluate dispatch rule must exist");
+
+    const result = await rule.match({
+      basePath: tmpDir,
+      mid: "M001",
+      midTitle: "Test Milestone",
+      state,
+      prefs: { gate_evaluation: { enabled: false } },
+    });
+
+    assert.equal(result?.action, "skip");
+    const byId = new Map(getGateResults("M001", "S01").map((gate) => [gate.gate_id, gate]));
+    assert.equal(byId.get("Q3")?.verdict, "omitted");
+    assert.equal(byId.get("Q4")?.verdict, "omitted");
+    assert.equal(byId.get("Q8")?.status, "pending");
+    assert.equal(byId.get("Q5")?.status, "pending");
+  });
 });

package/src/resources/extensions/gsd/tests/gate-storage.test.ts

@@ -83,6 +83,21 @@ describe("quality_gates CRUD", () => {
     assert.ok(results[0].evaluated_at);
   });
 
+  test("saveGateResult throws when the gate row does not exist", () => {
+    assert.throws(
+      () => saveGateResult({
+        milestoneId: "M001",
+        sliceId: "S01",
+        gateId: "Q3",
+        verdict: "pass",
+        rationale: "No row exists.",
+        findings: "",
+      }),
+      /quality gate row not found/,
+    );
+    assert.equal(getGateResults("M001", "S01").length, 0);
+  });
+
   test("getPendingGates filters by scope", () => {
     insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
     insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });