@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.a5a2de8

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -298,6 +298,106 @@ test("session_start installs the welcome screen as the TUI header", async (t) =>
   assert.deepEqual(header.render(123), ["welcome 9.9.9-test none 123"]);
 });
 
+test("session hooks preserve closeout-boundary UI during completion reroot", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-closeout-session-hooks-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  const tempGsdHome = join(dir, "home");
+  mkdirSync(tempGsdHome, { recursive: true });
+  writeFileSync(
+    join(dir, "dist", "welcome-screen.js"),
+    "export function buildWelcomeScreenLines() { return ['welcome header']; }\n",
+    "utf-8",
+  );
+
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const originalGsdPkgRoot = process.env.GSD_PKG_ROOT;
+  process.chdir(dir);
+  process.env.GSD_HOME = tempGsdHome;
+  process.env.GSD_PKG_ROOT = dir;
+  autoSession.reset();
+  autoSession.completionStopInProgress = true;
+  t.after(() => {
+    autoSession.reset();
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    if (originalGsdPkgRoot === undefined) delete process.env.GSD_PKG_ROOT;
+    else process.env.GSD_PKG_ROOT = originalGsdPkgRoot;
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const sessionStart = handlers.get("session_start");
+  const sessionSwitch = handlers.get("session_switch");
+  assert.ok(sessionStart, "session_start handler must be registered");
+  assert.ok(sessionSwitch, "session_switch handler must be registered");
+
+  const widgetCalls: Array<{ key: string; value: unknown }> = [];
+  let headerInstallCount = 0;
+  const ctx = {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setFooter: () => {},
+      setHeader: () => {
+        headerInstallCount++;
+      },
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: (key: string, value: unknown) => {
+        widgetCalls.push({ key, value });
+      },
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+    setCompactionThresholdOverride: () => {},
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => false,
+    },
+  };
+
+  await sessionStart!({}, ctx);
+  assert.equal(
+    headerInstallCount,
+    0,
+    "completion reroot session_start must not reinstall the welcome/project-console header",
+  );
+  assert.ok(
+    widgetCalls.some((call) => call.key === "gsd-health" && call.value === undefined),
+    "completion reroot session_start should hide the ambient health widget",
+  );
+
+  widgetCalls.length = 0;
+  await sessionSwitch!({ reason: "reroot" }, ctx);
+  assert.deepEqual(
+    widgetCalls
+      .filter((call) => call.key === "gsd-progress" || call.key === "gsd-outcome")
+      .map((call) => [call.key, call.value]),
+    [],
+    "completion reroot session_switch must not clear the preserved closeout surface",
+  );
+  assert.ok(
+    widgetCalls.some((call) => call.key === "gsd-health" && call.value === undefined),
+    "completion reroot session_switch should keep the ambient health widget hidden",
+  );
+});
+
 test("session_start and session_switch apply disabled model provider policy from current preferences", async (t) => {
   const dir = join(
     tmpdir(),

package/src/resources/extensions/gsd/tests/state-reconciliation-drift.test.ts

@@ -1352,6 +1352,145 @@ test("ADR-017: orphan task completion artifact fails closed", async (t) => {
   assert.match(result.blockers.join("\n"), /Artifact\/DB status drift/);
 });
 
+test("ADR-017 (#414): failure-path summary artifact blocker matches auto.ts filter phrase", async (t) => {
+  // When gsd_summary_save writes a SUMMARY artifact row for a task that never
+  // called gsd_task_complete, the task stays pending and the artifact DB row
+  // produces an artifact-db-status-divergence blocker. The auto.ts dispatch
+  // wrapper must be able to filter this class of blocker to allow re-dispatch.
+  // If this test fails, update the filter strings in auto.ts to match.
+  const base = mkdtempSync(join(tmpdir(), "gsd-failure-path-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S04"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S04", milestoneId: "M001", title: "Task", status: "pending" });
+  insertArtifact({
+    path: join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks", "T01", "T01-SUMMARY.md"),
+    artifact_type: "SUMMARY",
+    milestone_id: "M001",
+    slice_id: "S04",
+    task_id: "T01",
+    full_content: "# T01 Failure Summary\n",
+  });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for pending-task SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY artifact while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): no-db-tasks summary artifact blocker matches auto.ts filter phrase", async (t) => {
+  // When a slice has SUMMARY artifacts in the DB but no DB tasks, the auto.ts
+  // filter must be able to recognise this as a failure-path case and skip it.
+  const base = mkdtempSync(join(tmpdir(), "gsd-no-db-tasks-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S04"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  // No tasks inserted — slice has SUMMARY artifacts for a task that no longer exists.
+  insertArtifact({
+    path: join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks", "T01", "T01-SUMMARY.md"),
+    artifact_type: "SUMMARY",
+    milestone_id: "M001",
+    slice_id: "S04",
+    task_id: "T01",
+    full_content: "# T01 Failure Summary\n",
+  });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for no-db-tasks SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has task SUMMARY artifacts but no DB tasks/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): task-level on-disk summary blocker matches auto.ts filter phrase", async (t) => {
+  // When gsd_summary_save writes a SUMMARY file to disk for a task that never
+  // called gsd_task_complete, but the artifact DB row was not yet written (or
+  // the process crashed before insertion), reconciliation emits
+  // "has SUMMARY on disk while DB status is". The auto.ts filter must match
+  // this phrase so re-dispatch is not blocked.
+  const base = mkdtempSync(join(tmpdir(), "gsd-task-disk-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Failure Summary\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S04", milestoneId: "M001", title: "Task", status: "pending" });
+  // No artifact row inserted — SUMMARY exists only on disk.
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for on-disk task SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY on disk while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): slice-level on-disk summary blocker matches auto.ts filter phrase", async (t) => {
+  // When a SUMMARY file exists on disk for a slice that is still pending
+  // (no gsd_task_complete for the slice), reconciliation emits
+  // "has SUMMARY on disk while DB status is". The auto.ts filter must match
+  // this phrase so re-dispatch is not blocked.
+  const base = mkdtempSync(join(tmpdir(), "gsd-slice-disk-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S04");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S04-SUMMARY.md"), "# S04 Failure Summary\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  // No artifact row inserted — SUMMARY exists only on disk.
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for on-disk slice SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY on disk while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
 test("ADR-017: completed milestone dispatch history blocks accidental re-planning", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-completed-reopened-drift-"));
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -101,7 +101,7 @@ test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without al
   assert.ok(!result.includes("gsd_complete_slice"));
 });
 
-test("buildMinimalAutoGsdToolSet scopes run-uat to UAT-specific tools", () => {
+test("buildMinimalAutoGsdToolSet scopes run-uat to UAT-specific and read-only tools", () => {
   const active = ["ask_user_questions", "bash", "read", "edit", "write", "gsd_summary_save"];
   const registered = [
     ...active,
@@ -123,11 +123,11 @@ test("buildMinimalAutoGsdToolSet scopes run-uat to UAT-specific tools", () => {
   assert.ok(result.includes("gsd_resume"));
   assert.ok(result.includes("gsd_milestone_status"));
   assert.ok(result.includes("gsd_journal_query"));
+  assert.ok(result.includes("read"));
   assert.ok(result.includes("browser_navigate"), "run-uat needs browser_navigate");
   assert.ok(result.includes("browser_click"), "run-uat needs browser_click");
   assert.ok(!result.includes("ToolSearch"));
   assert.ok(!result.includes("bash"));
-  assert.ok(!result.includes("read"));
   assert.ok(!result.includes("edit"));
   assert.ok(!result.includes("write"));
   assert.ok(!result.includes("gsd_exec"));
@@ -230,9 +230,9 @@ test("buildMinimalAutoGsdToolSet preserves compatible browser add-ons for run-ua
   assert.ok(result.includes("gsd_uat_exec"));
   assert.ok(result.includes("gsd_uat_result_save"));
   assert.ok(result.includes("subagent"));
+  assert.ok(result.includes("read"));
   assert.ok(!result.includes("ToolSearch"));
   assert.ok(!result.includes("bash"));
-  assert.ok(!result.includes("read"));
   assert.ok(!result.includes("edit"));
   assert.ok(!result.includes("write"));
   assert.ok(!result.includes("gsd_exec"));
@@ -281,12 +281,12 @@ test("buildMinimalAutoGsdToolSet honors provider-compatible registered tools for
 
   assert.ok(result.includes("gsd_uat_exec"));
   assert.ok(result.includes("gsd_uat_result_save"));
+  assert.ok(result.includes("read"));
   assert.ok(result.includes("browser_navigate"));
   assert.ok(result.includes("browser_click"));
   assert.ok(!result.includes("browser_screenshot"), "provider-filtered screenshot tool must stay filtered");
   assert.ok(!result.includes("ToolSearch"));
   assert.ok(!result.includes("bash"));
-  assert.ok(!result.includes("read"));
   assert.ok(!result.includes("gsd_exec"));
   assert.ok(!result.includes("gsd_summary_save"));
   assert.ok(!result.includes("gsd_save_gate_result"));

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

@@ -102,6 +102,25 @@ describe("#2883: isToolInvocationError classification", () => {
     );
   });
 
+  test("detects MCP -32602 Input validation error (wire format)", () => {
+    assert.equal(
+      isToolInvocationError("MCP error -32602: Input validation error: Invalid arguments for tool gsd_slice_complete [path: verification, expected string, invalid_type]"),
+      true,
+    );
+  });
+
+  test("detects standalone 'Input validation error' prefix", () => {
+    assert.equal(isToolInvocationError("Input validation error: expected string"), true);
+  });
+
+  test("detects 'Invalid arguments for tool' prefix", () => {
+    assert.equal(isToolInvocationError("Invalid arguments for tool gsd_slice_complete"), true);
+  });
+
+  test("detects 'No such tool available' error", () => {
+    assert.equal(isToolInvocationError("No such tool available: mcp__gsd-workflow__memory_query"), true);
+  });
+
   test("detects ESM export-link errors", () => {
     assert.equal(
       isToolInvocationError("The requested module '../paths.js' does not provide an export named 'gsdProjectionRoot'"),

package/src/resources/extensions/gsd/tests/tool-param-optionality.test.ts

@@ -101,13 +101,19 @@ test("gsd_slice_complete — enrichment arrays are optional", () => {
     "sliceTitle",
     "oneLiner",
     "narrative",
-    "verification",
     "uatContent",
   ];
   for (const field of coreRequired) {
     assert.ok(required.has(field), `core field "${field}" must be required`);
   }
 
+  // verification is intentionally optional — models that omit it avoid -32602;
+  // the summary records verification as passed without detail in that case.
+  assert.ok(
+    !required.has("verification"),
+    "verification must be optional — omitting it avoids -32602; summary records verification as passed without detail",
+  );
+
   // Enrichment/metadata arrays MUST be optional
   const enrichmentFields = [
     "keyFiles",

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

@@ -11,11 +11,14 @@ 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, /must be exactly `Contract`, `Integration`, `Operational`, or `UAT`/i);
+  assert.match(prompt, /Preserve every planned non-empty class row/i);
+  assert.match(prompt, /first cell of each row must be exactly `Contract`, `Integration`, `Operational`, or `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`/);
+  assert.match(prompt, /pass a complete canonical table in `verificationClasses`/i);
+  assert.match(prompt, /If Reviewer C omitted a planned class, reconstruct the missing row/i);
+  assert.match(prompt, /Do not call `gsd_validate_milestone` with a partial `verificationClasses` table/i);
 });

package/src/resources/extensions/gsd/tests/validate-milestone-write-order.test.ts

@@ -180,6 +180,35 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     assert.equal(row, undefined, "assessment row should not be written when verification classes are invalid");
   });
 
+  it("reports all missing planned verification class rows at once", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({
+      id: "M001",
+      planning: {
+        verificationContract: "Contract command exits 0",
+        verificationOperational: "Process lifecycle proof",
+        verificationUat: "Browser-observable UAT proof",
+      },
+    });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+
+    const result = await handleValidateMilestone(
+      { ...VALID_PARAMS, verificationClasses: "| Check | Result |\n| --- | --- |\n| Generic verification | PASS |" },
+      base,
+    );
+    assert.ok("error" in result, "expected validation to fail");
+    assert.match(result.error, /canonical rows "Contract", "Operational", "UAT"/);
+    assert.match(result.error, /planned contract, operational, uat verification/);
+
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT status FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as { status: string } | undefined;
+    assert.equal(row, undefined, "assessment row should not be written when verification classes are invalid");
+  });
+
   it("accepts verificationClasses when planned Operational class is present", async () => {
     base = makeTmpBase();
     const dbPath = join(base, ".gsd", "gsd.db");
@@ -406,6 +435,110 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     assert.equal(result.verdict, "pass");
   });
 
+  it("keeps pass when browser-like criteria are verified by runtime-executable UAT", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({
+      id: "M001",
+      planning: {
+        successCriteria: [
+          "Clicking Mark All Complete sets all todos completed",
+          "Reload keeps completed state",
+        ],
+        verificationUat: "Run the Node.js DOM-state script against the static app source.",
+      },
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      // Uses localhost so hasBrowserRequiredText returns true and the gate is
+      // actually triggered before the runtime evidence bypasses it.
+      demo: "Visit localhost:3000 to verify DOM state after clicking Mark All Complete.",
+    });
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(
+      join(sliceDir, "S01-ASSESSMENT.md"),
+      [
+        "---",
+        "sliceId: S01",
+        "uatType: runtime-executable",
+        "verdict: PASS",
+        "attempt: 1",
+        "---",
+        "# UAT Result - S01",
+        "",
+        "## Checks",
+        "",
+        "| Check | Mode | Result | Evidence | Notes |",
+        "|-------|------|--------|----------|-------|",
+        "| DOM-state script | runtime | PASS | gsd_uat_exec:.gsd/evidence/uat/M001/S01/dom-state.json | Runtime assertion verified completed state and reload persistence. |",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const result = await handleValidateMilestone(
+      {
+        ...VALID_PARAMS,
+        verificationClasses:
+          `${VALID_PARAMS.verificationClasses}\n| UAT | Runtime executable UAT verified static-app behavior. |`,
+      },
+      base,
+    );
+
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+    assert.equal(result.verdict, "pass");
+  });
+
+  it("downgrades to needs-attention when only one of two browser-requiring slices has runtime evidence", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      demo: "Visit localhost:3000 to verify DOM state.",
+    });
+    insertSlice({
+      id: "S02",
+      milestoneId: "M001",
+      demo: "Visit localhost:3000 to confirm persistence after reload.",
+    });
+    // S01 has runtime-executable evidence; S02 has none.
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md"),
+      [
+        "---",
+        "sliceId: S01",
+        "uatType: runtime-executable",
+        "verdict: PASS",
+        "---",
+        "| DOM check | runtime | PASS | gsd_uat_exec:.gsd/evidence/uat/M001/S01/dom.json | Verified. |",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const result = await handleValidateMilestone(
+      {
+        ...VALID_PARAMS,
+        verificationClasses: `${VALID_PARAMS.verificationClasses}\n| UAT | S01 runtime verified; S02 still needs evidence. |`,
+      },
+      base,
+    );
+
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+    assert.equal(
+      result.verdict,
+      "needs-attention",
+      "S01 runtime evidence must not bypass the gate for S02 which has browser requirements but no evidence",
+    );
+  });
+
   it("ignores slice full_uat_md planning text for browser requirement detection", async () => {
     base = makeTmpBase();
     const dbPath = join(base, ".gsd", "gsd.db");

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

@@ -35,6 +35,20 @@ function makeTempDir(prefix: string): string {
   return dir;
 }
 
+function withRtkDisabled<T>(callback: () => T): T {
+  const previous = process.env.GSD_RTK_DISABLED;
+  process.env.GSD_RTK_DISABLED = "1";
+  try {
+    return callback();
+  } finally {
+    if (previous === undefined) {
+      delete process.env.GSD_RTK_DISABLED;
+    } else {
+      process.env.GSD_RTK_DISABLED = previous;
+    }
+  }
+}
+
 // ─── Discovery Tests ─────────────────────────────────────────────────────────
 
 describe("verification-gate: discovery", () => {
@@ -430,6 +444,38 @@ describe("verification-gate: execution", () => {
     assert.ok(result.checks[1].stderr.includes("err"));
   });
 
+  test("grep -c zero-match failure includes absence-check warning", () => {
+    writeFileSync(join(tmp, "sample.txt"), "present\n");
+
+    const result = withRtkDisabled(() => runVerificationGate({
+      cwd: tmp,
+      preferenceCommands: ["grep -c missing sample.txt"],
+    }));
+
+    assert.equal(result.passed, false);
+    assert.equal(result.checks.length, 1);
+    assert.equal(result.checks[0].exitCode, 1);
+    assert.equal(result.checks[0].stdout.trim(), "0");
+    assert.match(result.checks[0].stderr, /grep -c/);
+    assert.match(result.checks[0].stderr, /count=0/);
+    assert.match(result.checks[0].stderr, /! grep -q/);
+  });
+
+  test("grep -c matching count does not warn", () => {
+    writeFileSync(join(tmp, "sample.txt"), "present\n");
+
+    const result = withRtkDisabled(() => runVerificationGate({
+      cwd: tmp,
+      preferenceCommands: ["grep -c present sample.txt"],
+    }));
+
+    assert.equal(result.passed, true);
+    assert.equal(result.checks.length, 1);
+    assert.equal(result.checks[0].exitCode, 0);
+    assert.equal(result.checks[0].stdout.trim(), "1");
+    assert.equal(result.checks[0].stderr, "");
+  });
+
   test("no commands discovered → gate passes with 0 checks", () => {
     const result = runVerificationGate({
       cwd: tmp,
@@ -686,6 +732,11 @@ test("isLikelyCommand: bash negation with known command is accepted", () => {
   assert.equal(isLikelyCommand("! grep needle file.txt"), true);
 });
 
+test("validateVerificationCommand accepts negated quiet absence checks", () => {
+  assert.equal(validateVerificationCommand("! grep -q needle file.txt").ok, true);
+  assert.equal(validateVerificationCommand("! rg -q needle file.txt").ok, true);
+});
+
 test("validateVerificationCommand allows shell pipelines", () => {
   assert.deepEqual(validateVerificationCommand("python3 -m pytest tests/ -q --tb=short").ok, true);
   const result = validateVerificationCommand("python3 -m pytest tests/ -q --tb=short | tail -5");