gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/src/resources/extensions/gsd/tests/test-helpers.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Tests for test-helpers.ts — the timing helpers (waitForCondition,
+ * findLine) used to replace magic-number sleeps and positional line
+ * indexing in the test suite.
+ *
+ * The `extractSourceRegion` helper (introduced in #4773/#4774) is
+ * deliberately NOT tested here. It is the source-grep antipattern that
+ * #4784 names as the root problem; tests against toy fixtures only
+ * legitimize the pattern without validating behaviour. Its test cases
+ * were removed as part of #4834 — callers are being migrated to
+ * behaviour tests one file at a time, after which the helper is slated
+ * for deletion.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { waitForCondition, findLine } from "./test-helpers.ts";
+
+// ─── waitForCondition ─────────────────────────────────────────────────────
+
+test("waitForCondition returns immediately when condition is true", async () => {
+  const result = await waitForCondition(() => true);
+  assert.equal(result, true);
+});
+
+test("waitForCondition waits and returns when condition becomes true", async () => {
+  let flipped = false;
+  setTimeout(() => { flipped = true; }, 30);
+  const result = await waitForCondition(() => flipped, { intervalMs: 5 });
+  assert.equal(result, true);
+});
+
+test("waitForCondition throws after timeout with description", async () => {
+  await assert.rejects(
+    waitForCondition(() => false, { timeoutMs: 50, intervalMs: 5, description: "the flag to flip" }),
+    /waiting for the flag to flip/i,
+  );
+});
+
+test("waitForCondition surfaces last error on timeout", async () => {
+  await assert.rejects(
+    waitForCondition(
+      () => { throw new Error("probe failed"); },
+      { timeoutMs: 30, intervalMs: 5, description: "probe" },
+    ),
+    /probe failed/,
+  );
+});
+
+test("waitForCondition returns the truthy value (not just true)", async () => {
+  let n = 0;
+  const result = await waitForCondition(() => {
+    n++;
+    return n >= 3 ? { ready: true, iteration: n } : null;
+  }, { intervalMs: 5 });
+  // The helper only resolves when the condition returns a truthy value, so
+  // result cannot be null here. Assert it and narrow for the follow-ups.
+  assert.ok(result, "waitForCondition must resolve with a truthy value, not null");
+  assert.equal(result.ready, true);
+  assert.equal(result.iteration, 3);
+});
+
+// ─── findLine ─────────────────────────────────────────────────────────────
+
+test("findLine locates a line by regex", () => {
+  const output = "header\nstatus: ok\nfooter";
+  const match = findLine(output, /^status:/);
+  assert.equal(match.index, 1);
+  assert.equal(match.text, "status: ok");
+});
+
+test("findLine locates a line by predicate", () => {
+  const output = "a\nb\nc";
+  const match = findLine(output, (l) => l === "b");
+  assert.equal(match.index, 1);
+  assert.equal(match.text, "b");
+});
+
+test("findLine throws with preview when no line matches", () => {
+  assert.throws(
+    () => findLine("a\nb\nc", /NOTFOUND/),
+    /First 10 lines/,
+  );
+});
+
+test("findLine resets lastIndex between lines for /g regex patterns", () => {
+  // Without the reset, RegExp.test with /g flag stateful-advances lastIndex
+  // and can skip matches on subsequent calls. Verify the reset keeps
+  // per-line testing deterministic.
+  const output = "foo\nfoo\nfoo";
+  const globalRe = /foo/g;
+  const match = findLine(output, globalRe);
+  assert.equal(match.index, 0);
+  // Second call on the same pattern must also match — would fail without reset
+  const match2 = findLine(output, globalRe);
+  assert.equal(match2.index, 0);
+});

package/src/resources/extensions/gsd/tests/test-helpers.ts

@@ -59,3 +59,156 @@ export function createTestContext() {
 
   return { assertEq, assertTrue, assertMatch, assertNoMatch, report };
 }
+
+// ─── Source-inspection helpers (DEPRECATED — do not add new callers) ──────────
+//
+// `extractSourceRegion` was introduced in #4773 / #4774 as a more-durable
+// replacement for hand-rolled `src.slice(idx, idx + N)` patterns. Issue
+// #4784 surfaced that the helper is the wrong target: its use case —
+// testing that an identifier or phrase exists in production source text
+// — is the source-grep antipattern that causes false coverage in the
+// first place. Tests should exercise behaviour (call the function,
+// assert on its return value or observable effects) rather than check
+// whether specific identifier strings remain in source.
+//
+// CONTRIBUTING.md forbids new callers of this helper. Existing callers
+// are being migrated one file at a time; the helper is slated for
+// removal once the last caller is converted.
+//
+// Do not add new callers. If you are tempted to, file an issue
+// describing the behavioural invariant you want to test and we will
+// find a runtime assertion instead.
+
+/**
+ * @deprecated Use a real behaviour test against the function under
+ *   inspection instead. See #4784 and CONTRIBUTING.md > "Test behaviour,
+ *   not source shape". No new callers.
+ *
+ * Extract a region of source between a start anchor and either an explicit
+ * end anchor or, if none is given, a set of reasonable structural
+ * terminators (next `private `/`export `/`function `/`class `/`interface `/
+ * `//` section separator). Falls back to end-of-source if none match.
+ *
+ * @param src        The source text.
+ * @param startAnchor Literal substring that marks the start of the region.
+ *                   Typically a function name, a section header comment, or
+ *                   a distinctive statement.
+ * @param endAnchor  Optional. Either a literal substring that marks the end,
+ *                   or `{ fromIdx: number }` to find the *next* occurrence
+ *                   of `startAnchor` at or after `fromIdx` (useful when the
+ *                   anchor appears multiple times and a positional search
+ *                   is required). When omitted, structural terminators are
+ *                   used.
+ *
+ * Returns the extracted region (including the start anchor), or an empty
+ * string if `startAnchor` is not found.
+ */
+export function extractSourceRegion(
+  src: string,
+  startAnchor: string,
+  endAnchor?: string | { fromIdx: number },
+): string {
+  const fromIdx = typeof endAnchor === "object" && endAnchor !== null
+    ? endAnchor.fromIdx
+    : 0;
+  const endLiteral = typeof endAnchor === "string" ? endAnchor : undefined;
+
+  const startIdx = src.indexOf(startAnchor, fromIdx);
+  if (startIdx < 0) return "";
+
+  if (endLiteral) {
+    const endIdx = src.indexOf(endLiteral, startIdx + startAnchor.length);
+    return endIdx > 0 ? src.slice(startIdx, endIdx) : src.slice(startIdx);
+  }
+
+  // Heuristic terminators — the next sibling declaration/section.
+  const terminators = [
+    "\n  private ",
+    "\n  public ",
+    "\n  protected ",
+    "\n  static ",
+    "\nexport function ",
+    "\nexport async function ",
+    "\nfunction ",
+    "\nasync function ",
+    "\nexport class ",
+    "\nclass ",
+    "\nexport interface ",
+    "\ninterface ",
+    "\n// ─", // section separator comments
+    "\n/** ", // next docblock
+  ];
+
+  let earliestEnd = -1;
+  for (const t of terminators) {
+    const idx = src.indexOf(t, startIdx + startAnchor.length);
+    if (idx > 0 && (earliestEnd < 0 || idx < earliestEnd)) earliestEnd = idx;
+  }
+
+  return earliestEnd > 0 ? src.slice(startIdx, earliestEnd) : src.slice(startIdx);
+}
+
+/**
+ * Poll `condition()` until it returns truthy or `timeoutMs` elapses.
+ * Returns the truthy value from `condition()`, or throws on timeout.
+ *
+ * Use this instead of `await new Promise(r => setTimeout(r, <magic-ms>))`
+ * when waiting for a state change that tests produce. The fixed-sleep
+ * pattern is flaky: too short → race; too long → slow tests.
+ *
+ * @param condition  Predicate. Returns truthy when done. May be async.
+ * @param opts.timeoutMs  Max total wait. Defaults to 2000ms.
+ * @param opts.intervalMs Poll interval. Defaults to 10ms.
+ * @param opts.description Included in the timeout error for debuggability.
+ */
+export async function waitForCondition<T>(
+  condition: () => T | Promise<T>,
+  opts: { timeoutMs?: number; intervalMs?: number; description?: string } = {},
+): Promise<T> {
+  const timeoutMs = opts.timeoutMs ?? 2000;
+  const intervalMs = opts.intervalMs ?? 10;
+  const deadline = Date.now() + timeoutMs;
+  let lastErr: unknown;
+  while (Date.now() < deadline) {
+    try {
+      const result = await condition();
+      if (result) return result;
+    } catch (e) {
+      lastErr = e;
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  const desc = opts.description ?? "condition";
+  const errSuffix = lastErr instanceof Error ? ` (last error: ${lastErr.message})` : "";
+  throw new Error(`waitForCondition timed out after ${timeoutMs}ms waiting for ${desc}${errSuffix}`);
+}
+
+/**
+ * Find the first line in rendered output that matches a predicate. Returns
+ * the line's index and text, or throws if no line matches.
+ *
+ * Use this instead of `lines[N]` indexing when the N is positional and
+ * could shift under formatting changes.
+ */
+export function findLine(
+  output: string,
+  predicate: RegExp | ((line: string) => boolean),
+): { index: number; text: string } {
+  const lines = output.split("\n");
+  const fn = predicate instanceof RegExp
+    ? (l: string) => {
+        // RegExp.test is stateful when the pattern has /g or /y flags
+        // (maintains lastIndex across calls). Reset before each test so
+        // matches on different lines don't silently skip.
+        if (predicate.global || predicate.sticky) predicate.lastIndex = 0;
+        return predicate.test(l);
+      }
+    : predicate;
+  for (let i = 0; i < lines.length; i++) {
+    if (fn(lines[i]!)) return { index: i, text: lines[i]! };
+  }
+  const preview = lines.slice(0, 10).join("\n");
+  throw new Error(
+    `findLine: no line matched. First 10 lines were:\n${preview}`,
+  );
+}

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

@@ -102,7 +102,8 @@ describe("token-counter: estimateTokensForProvider", () => {
 
 describe("token-counter: backward compatibility", () => {
   it("countTokensSync returns heuristic estimate when tiktoken is not loaded", () => {
-    // Without tiktoken loaded, countTokensSync falls back to ceil(len/4)
+    // Without tiktoken loaded, countTokensSync falls back to estimateTokensForProvider.
+    // With no provider (defaults to "unknown", ratio 4.0): ceil(100/4) = 25.
     const text = "A".repeat(100);
     const result = countTokensSync(text);
     // Either tiktoken is loaded (exact count) or heuristic (ceil(100/4) = 25)
@@ -127,3 +128,106 @@ describe("token-counter: backward compatibility", () => {
     assert.equal(result, 0);
   });
 });
+
+// ─── provider-aware fallback (issue #4529) ───────────────────────────────────
+// Regression tests: countTokens/countTokensSync must use provider-specific
+// ratios for their heuristic fallback, not a hardcoded GPT-4o / 4 divisor.
+
+describe("token-counter: provider-aware heuristic fallback", () => {
+  // These tests exercise the heuristic path (no tiktoken or before init).
+  // We call estimateTokensForProvider directly to validate expected values,
+  // then verify countTokens/countTokensSync return the same values when
+  // tiktoken is unavailable.
+
+  it("countTokensSync uses anthropic ratio (3.5) when provider is 'anthropic'", () => {
+    const text = "A".repeat(350);
+    // anthropic: ceil(350 / 3.5) = 100
+    // openai/unknown: ceil(350 / 4.0) = 88
+    // These are different — the provider must matter.
+    const anthropicEstimate = estimateTokensForProvider(text, "anthropic");
+    const unknownEstimate = estimateTokensForProvider(text, "unknown");
+    assert.equal(anthropicEstimate, 100, "anthropic ratio should give 100 tokens for 350 chars");
+    assert.equal(unknownEstimate, 88, "unknown ratio should give 88 tokens for 350 chars");
+    assert.notEqual(
+      anthropicEstimate,
+      unknownEstimate,
+      "anthropic and unknown estimates must differ — if they are equal the provider is being ignored",
+    );
+
+    // Actually call countTokensSync with the anthropic provider.
+    // When tiktoken is not loaded, this must return the provider-aware estimate (100).
+    // When tiktoken is loaded, it returns the tiktoken count (which is also > 0 and
+    // will be in the range [88, 120] for 350 "A" characters with cl100k_base).
+    const syncResult = countTokensSync(text, "anthropic");
+    assert.ok(typeof syncResult === "number", "countTokensSync must return a number");
+    assert.ok(syncResult > 0, "countTokensSync must return a positive count");
+    // If tiktoken is unavailable the result must exactly match the anthropic heuristic.
+    // If tiktoken is available we cannot assert the exact value, but we know it will
+    // not equal the unknown-provider heuristic (88) for 350 identical characters.
+    const tiktokenAvailable = syncResult !== anthropicEstimate;
+    if (!tiktokenAvailable) {
+      assert.equal(
+        syncResult,
+        anthropicEstimate,
+        `countTokensSync with 'anthropic' provider must return ${anthropicEstimate} (not the unknown-provider value ${unknownEstimate}) when tiktoken is unavailable`,
+      );
+    }
+  });
+
+  it("countTokens uses anthropic ratio when provider='anthropic' and tiktoken unavailable", async () => {
+    const text = "A".repeat(350);
+    // anthropic heuristic: ceil(350 / 3.5) = 100
+    // unknown/hardcoded-4 heuristic: ceil(350 / 4.0) = 88
+    const anthropicEstimate = estimateTokensForProvider(text, "anthropic"); // 100
+    const unknownEstimate = estimateTokensForProvider(text, "unknown");     // 88
+    const hardcodedFallback = Math.ceil(text.length / 4);                   // 88
+
+    // The anthropic heuristic must produce more tokens than the old /4 fallback.
+    assert.equal(anthropicEstimate, 100, "anthropic heuristic should give 100 tokens for 350 chars");
+    assert.ok(
+      anthropicEstimate > hardcodedFallback,
+      `anthropic estimate (${anthropicEstimate}) must exceed the hardcoded /4 fallback (${hardcodedFallback})`,
+    );
+    assert.notEqual(
+      anthropicEstimate,
+      unknownEstimate,
+      "anthropic and unknown estimates must differ — provider is being ignored if equal",
+    );
+
+    // Call countTokens with the anthropic provider and verify the result.
+    const result = await countTokens(text, "anthropic");
+    assert.ok(typeof result === "number", "should return a number");
+    assert.ok(result > 0, "should return a positive token count");
+
+    // When tiktoken is unavailable: result must equal the anthropic heuristic (100),
+    // NOT the unknown-provider heuristic (88). This is the core regression guard for #4529.
+    // When tiktoken IS available: result is the tiktoken count, which will differ from
+    // the heuristic — but it must never equal the wrong (unknown) heuristic for this text.
+    if (result === anthropicEstimate || result === unknownEstimate) {
+      // We are on the heuristic path — assert the correct provider ratio was used.
+      assert.equal(
+        result,
+        anthropicEstimate,
+        `countTokens with 'anthropic' provider returned ${result} but expected ${anthropicEstimate} (anthropic heuristic) not ${unknownEstimate} (unknown/hardcoded heuristic)`,
+      );
+    } else {
+      // tiktoken is active — result is an exact BPE count.
+      // For 350 identical "A" characters cl100k_base produces a count in [80, 130].
+      assert.ok(
+        result >= 80 && result <= 130,
+        `tiktoken count ${result} for 350 "A" chars is outside expected range [80, 130]`,
+      );
+    }
+  });
+
+  it("countTokens with provider='anthropic' yields more tokens than provider='openai' (heuristic)", () => {
+    const text = "A".repeat(400);
+    // anthropic: ceil(400/3.5) = 115, openai: ceil(400/4.0) = 100
+    const anthropic = estimateTokensForProvider(text, "anthropic");
+    const openai = estimateTokensForProvider(text, "openai");
+    assert.ok(
+      anthropic > openai,
+      `anthropic estimate (${anthropic}) must exceed openai estimate (${openai}) for same text`,
+    );
+  });
+});

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

@@ -14,6 +14,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -127,7 +128,13 @@ test("profile: balanced profile skips research, reassess, and slice research (AD
 
 test("profile: quality profile skips research, slice research, and reassess (ADR-003)", () => {
   const qualityIdx = preferencesSrc.indexOf('case "quality":');
-  const qualityBlock = preferencesSrc.slice(qualityIdx, qualityIdx + 300);
+  // preferencesSrc is concatenated from multiple modules — bound the region
+  // with the next case marker so the assertion stays tightly scoped.
+  const qualityBlock = extractSourceRegion(
+    preferencesSrc,
+    'case "quality":',
+    'case "burn-max":',
+  );
   assert.ok(qualityBlock.includes("skip_research: true"), "quality should skip research");
   assert.ok(qualityBlock.includes("skip_slice_research: true"), "quality should skip slice research");
   assert.ok(qualityBlock.includes("skip_reassess: true"), "quality should skip reassess");

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

@@ -14,6 +14,7 @@ import {
   isToolCompatibleWithProvider,
   filterToolsForProvider,
   adjustToolSet,
+  GROQ_MAX_TOOLS,
 } from "../model-router.js";
 
 import {
@@ -197,3 +198,109 @@ describe("adjustToolSet", () => {
     assert.deepEqual(removedTools, ["mcp_complex"]);
   });
 });
+
+// ─── GROQ_MAX_TOOLS constant ─────────────────────────────────────────────────
+
+describe("GROQ_MAX_TOOLS", () => {
+  test("equals 128", () => {
+    assert.equal(GROQ_MAX_TOOLS, 128);
+  });
+});
+
+// ─── Groq tool-count cap (#4376) ────────────────────────────────────────────
+
+describe("filterToolsForProvider — Groq 128-tool cap", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("does not cap when provider is not groq", () => {
+    const toolNames = Array.from({ length: 200 }, (_, i) => `tool_${i}`);
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-completions");
+    assert.equal(compatible.length, 200);
+    assert.equal(filtered.length, 0);
+  });
+
+  test("does not cap when <= 128 tools with groq provider", () => {
+    const toolNames = Array.from({ length: 128 }, (_, i) => `tool_${i}`);
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-completions", "groq");
+    assert.equal(compatible.length, 128);
+    assert.equal(filtered.length, 0);
+  });
+
+  test("caps to 128 when >128 tools with groq provider", () => {
+    const toolNames = Array.from({ length: 200 }, (_, i) => `tool_${i}`);
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-completions", "groq");
+    assert.equal(compatible.length, 128);
+    assert.equal(filtered.length, 72);
+  });
+
+  test("keeps the first 128 tools when capping", () => {
+    const toolNames = Array.from({ length: 200 }, (_, i) => `tool_${i}`);
+    const { compatible } = filterToolsForProvider(toolNames, "openai-completions", "groq");
+    assert.equal(compatible[0], "tool_0");
+    assert.equal(compatible[127], "tool_127");
+  });
+
+  test("trimmed tools appear in filtered list", () => {
+    const toolNames = Array.from({ length: 130 }, (_, i) => `tool_${i}`);
+    const { filtered } = filterToolsForProvider(toolNames, "openai-completions", "groq");
+    assert.equal(filtered.length, 2);
+    assert.equal(filtered[0], "tool_128");
+    assert.equal(filtered[1], "tool_129");
+  });
+
+  test("emits a warning when tools are trimmed", () => {
+    const warnings: string[] = [];
+    const original = console.warn;
+    console.warn = (...args: unknown[]) => { warnings.push(String(args[0])); };
+    try {
+      const toolNames = Array.from({ length: 129 }, (_, i) => `tool_${i}`);
+      filterToolsForProvider(toolNames, "openai-completions", "groq");
+      assert.equal(warnings.length, 1);
+      assert.ok(warnings[0].includes("128"), "warning mentions Groq limit");
+    } finally {
+      console.warn = original;
+    }
+  });
+
+  test("does not warn when tools are at the limit", () => {
+    const warnings: string[] = [];
+    const original = console.warn;
+    console.warn = (...args: unknown[]) => { warnings.push(String(args[0])); };
+    try {
+      const toolNames = Array.from({ length: 128 }, (_, i) => `tool_${i}`);
+      filterToolsForProvider(toolNames, "openai-completions", "groq");
+      assert.equal(warnings.length, 0);
+    } finally {
+      console.warn = original;
+    }
+  });
+});
+
+describe("adjustToolSet — Groq 128-tool cap", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("caps to 128 tools when provider is groq and >128 tools active", () => {
+    const toolNames = Array.from({ length: 150 }, (_, i) => `tool_${i}`);
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "openai-completions", "groq");
+    assert.equal(result.length, 128);
+    assert.equal(removedTools.length, 22);
+  });
+
+  test("does not cap for non-groq providers even with >128 tools", () => {
+    const toolNames = Array.from({ length: 150 }, (_, i) => `tool_${i}`);
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "openai-completions", "openai");
+    assert.equal(result.length, 150);
+    assert.equal(removedTools.length, 0);
+  });
+
+  test("does not cap when provider is omitted", () => {
+    const toolNames = Array.from({ length: 150 }, (_, i) => `tool_${i}`);
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "openai-completions");
+    assert.equal(result.length, 150);
+    assert.equal(removedTools.length, 0);
+  });
+});

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

@@ -44,7 +44,19 @@ describe("#2883: tool invocation error tracking on AutoSession", () => {
 
 // ─── isToolInvocationError classifier ────────────────────────────────────
 
-import { isToolInvocationError, isQueuedUserMessageSkip } from "../auto-tool-tracking.ts";
+import {
+  isDeterministicPolicyError,
+  isToolInvocationError,
+  isQueuedUserMessageSkip,
+} from "../auto-tool-tracking.ts";
+import {
+  shouldBlockContextWrite,
+  shouldBlockPendingGateInSnapshot,
+  shouldBlockQueueExecutionInSnapshot,
+  resetWriteGateState,
+  type WriteGateSnapshot,
+} from "../bootstrap/write-gate.ts";
+import { BLOCKED_WRITE_ERROR } from "../write-intercept.ts";
 
 describe("#2883: isToolInvocationError classification", () => {
   test("detects JSON validation failure pattern", () => {
@@ -89,11 +101,59 @@ describe("#2883: isToolInvocationError classification", () => {
     );
   });
 
+  test("detects raw write-gate CONTEXT failures for non-GSD write tools", () => {
+    resetWriteGateState();
+    const result = shouldBlockContextWrite(
+      "write",
+      "/tmp/project/.gsd/milestones/M001/M001-CONTEXT.md",
+      "M001",
+      false,
+    );
+
+    assert.equal(result.block, true);
+    assert.equal(isDeterministicPolicyError(result.reason ?? ""), true);
+    assert.equal(isToolInvocationError(result.reason ?? ""), true);
+  });
+
+  test("detects raw pending-gate failures for non-GSD write tools", () => {
+    const snapshot: WriteGateSnapshot = {
+      verifiedDepthMilestones: [],
+      activeQueuePhase: false,
+      pendingGateId: "depth_verification_M001",
+    };
+    const result = shouldBlockPendingGateInSnapshot(snapshot, "write", "M001", false);
+
+    assert.equal(result.block, true);
+    assert.equal(isDeterministicPolicyError(result.reason ?? ""), true);
+    assert.equal(isToolInvocationError(result.reason ?? ""), true);
+  });
+
+  test("detects queue-mode policy blocks for raw write/edit/bash tools", () => {
+    const snapshot: WriteGateSnapshot = {
+      verifiedDepthMilestones: [],
+      activeQueuePhase: true,
+      pendingGateId: null,
+    };
+    const writeResult = shouldBlockQueueExecutionInSnapshot(snapshot, "write", "src/app.ts", true);
+    const bashResult = shouldBlockQueueExecutionInSnapshot(snapshot, "bash", "npm run build", true);
+
+    assert.equal(writeResult.block, true);
+    assert.equal(bashResult.block, true);
+    assert.equal(isDeterministicPolicyError(writeResult.reason ?? ""), true);
+    assert.equal(isToolInvocationError(bashResult.reason ?? ""), true);
+  });
+
+  test("detects direct STATE.md/gsd.db write-intercept policy blocks", () => {
+    assert.equal(isDeterministicPolicyError(BLOCKED_WRITE_ERROR), true);
+    assert.equal(isToolInvocationError(BLOCKED_WRITE_ERROR), true);
+  });
+
   test("returns false for normal tool errors (business logic)", () => {
     assert.equal(
       isToolInvocationError("Slice S01 is already complete"),
       false,
     );
+    assert.equal(isDeterministicPolicyError("Slice S01 is already complete"), false);
   });
 
   test("returns false for empty string", () => {

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

@@ -36,6 +36,9 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_reassess_roadmap", alias: "gsd_roadmap_reassess" },
   { canonical: "gsd_complete_milestone", alias: "gsd_milestone_complete" },
   { canonical: "gsd_validate_milestone", alias: "gsd_milestone_validate" },
+  { canonical: "gsd_task_reopen", alias: "gsd_reopen_task" },
+  { canonical: "gsd_slice_reopen", alias: "gsd_reopen_slice" },
+  { canonical: "gsd_milestone_reopen", alias: "gsd_reopen_milestone" },
 ];
 
 // ─── Registration count ──────────────────────────────────────────────────────
@@ -45,7 +48,11 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assert.deepStrictEqual(pi.tools.length, 30, 'Should register exactly 30 tools (14 canonical + 14 aliases + 1 gate tool + 1 gsd_skip_slice)');
+assert.deepStrictEqual(
+  pi.tools.length,
+  RENAME_MAP.length * 2 + 2,
+  'Should register canonical/alias tool pairs plus 1 gate tool and 1 gsd_skip_slice',
+);
 
 // ─── Both names exist for each pair ──────────────────────────────────────────