gsd-pi 2.75.0 → 2.76.0-dev.4100bd590

package/src/resources/extensions/gsd/tests/prompt-budget-enforcement.test.ts

@@ -1,13 +1,8 @@
 /**
  * Prompt budget enforcement tests — verifies that budget-aware prompt builders
- * truncate content at section boundaries and that plan-slice includes executor
- * context constraints.
- *
- * Tests:
- *   1. inlineDependencySummaries() truncates when budget is small, passes through when large
- *   2. plan-slice.md template includes {{executorContextConstraints}} placeholder
- *   3. Executor constraints formatting varies with context window size
- *   4. Different context windows produce different budget-constrained outputs
+ * truncate content at section boundaries, that plan-slice includes executor
+ * context constraints, and that prompt builders thread the real executor
+ * context window through to the budget engine (issue #4142).
  */
 
 import { describe, it, beforeEach, afterEach } from "node:test";
@@ -164,6 +159,33 @@ describe("prompt-budget: inlineDependencySummaries truncation", () => {
     const result = await inlineDependencySummaries("M001", "S01", base, 1000);
     assert.equal(result, "- (no dependencies)");
   });
+
+  // Regression for issue #4435: a slice with 12 declared dependencies on a
+  // small-window (32K) model should not inject the full concatenated 55-70K
+  // chars of dep summaries. Exercises the budget the builders now pass in
+  // (computeBudgets(32000).summaryBudgetChars ≈ 19_200 chars).
+  it("caps 12 cumulative dep summaries at the 32K summaryBudgetChars (#4435)", async () => {
+    const depIds = Array.from({ length: 12 }, (_, i) => `S${String(i + 1).padStart(2, "0")}`);
+    const section = (label: string) => `### ${label}\n\n${"Lorem ipsum dolor sit amet. ".repeat(200)}`;
+    const perSummary = [section("Results"), section("Key Decisions"), section("Forward Intelligence")].join("\n\n");
+    const summaries: Record<string, string> = {};
+    for (const id of depIds) summaries[id] = perSummary;
+
+    setupDependencyFixture(base, "M001", "S13", depIds, summaries);
+
+    const budget32K = computeBudgets(32_000).summaryBudgetChars;
+    const result = await inlineDependencySummaries("M001", "S13", base, budget32K);
+
+    // The total raw content would be 12 × ~17K chars ≈ 200K chars. Budget at
+    // 32K is ~19.2K chars. The result must be bounded and the overflow marker
+    // must be present.
+    assert.ok(result.length <= budget32K + 200, `result must fit within 32K summary budget, got ${result.length}`);
+    assert.ok(result.includes("[...truncated"), "must emit the truncation marker when over budget");
+
+    // Unbounded call returns the full ~200K — confirms this is the regression surface.
+    const unbounded = await inlineDependencySummaries("M001", "S13", base);
+    assert.ok(unbounded.length > budget32K * 5, "unbounded call should blow past the 32K budget (regression baseline)");
+  });
 });
 
 // ─── plan-slice template includes executor constraints placeholder ────────────
@@ -461,4 +483,133 @@ describe("prompt-budget: execute-task builder truncation pattern", () => {
       assert.ok(result.droppedSections > 0, "should report dropped sections");
     }
   });
+});
+
+// ─── Regression: prompt builders must thread modelRegistry + sessionContextWindow (issue #4142) ───
+//
+// `resolveExecutorContextWindow()` resolves the executor context window in 3
+// steps: (1) look up the configured executor model in `modelRegistry`, (2) fall
+// back to `sessionContextWindow`, (3) fall back to `DEFAULT_CONTEXT_WINDOW`
+// (200K). Before this fix, prompt-builder call sites passed `undefined` for
+// both knobs and always landed on Step 3 — even on 1M-token models. These
+// source-level assertions pin the wiring so future refactors cannot regress it.
+
+describe("prompt-budget: modelRegistry + sessionContextWindow wiring", () => {
+  const autoPromptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
+  const autoDispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+  const autoDirectDispatchSrc = readFileSync(join(__dirname, "..", "auto-direct-dispatch.ts"), "utf-8");
+  const phasesSrc = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
+
+  it("formatExecutorConstraints accepts and forwards both knobs", () => {
+    assert.match(
+      autoPromptsSrc,
+      /function formatExecutorConstraints\([^)]*sessionContextWindow[^)]*modelRegistry[^)]*\)/s,
+      "formatExecutorConstraints must accept sessionContextWindow and modelRegistry",
+    );
+    assert.match(
+      autoPromptsSrc,
+      /resolveExecutorContextWindow\(\s*modelRegistry\s*,\s*prefs\?\.preferences\s*,\s*sessionContextWindow/,
+      "formatExecutorConstraints must forward both to resolveExecutorContextWindow",
+    );
+  });
+
+  it("renderSlicePrompt options declare both knobs and forward to formatExecutorConstraints", () => {
+    assert.match(
+      autoPromptsSrc,
+      /async function renderSlicePrompt\(options:\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/s,
+      "renderSlicePrompt options must declare both fields",
+    );
+    assert.match(
+      autoPromptsSrc,
+      /formatExecutorConstraints\(sessionContextWindow,\s*modelRegistry\)/,
+      "renderSlicePrompt must forward both to formatExecutorConstraints",
+    );
+  });
+
+  it("buildPlanSlicePrompt options declare both knobs and thread them into renderSlicePrompt", () => {
+    assert.match(
+      autoPromptsSrc,
+      /export async function buildPlanSlicePrompt\([\s\S]*?options\?:\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/,
+      "buildPlanSlicePrompt options must declare both fields",
+    );
+    assert.match(
+      autoPromptsSrc,
+      /sessionContextWindow:\s*options\?\.sessionContextWindow,\s*modelRegistry:\s*options\?\.modelRegistry/,
+      "buildPlanSlicePrompt must forward both into renderSlicePrompt",
+    );
+  });
+
+  it("ExecuteTaskPromptOptions declares both knobs", () => {
+    assert.match(
+      autoPromptsSrc,
+      /interface ExecuteTaskPromptOptions\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/s,
+      "ExecuteTaskPromptOptions must declare both fields",
+    );
+  });
+
+  it("buildExecuteTaskPrompt forwards opts.modelRegistry + opts.sessionContextWindow to resolveExecutorContextWindow", () => {
+    assert.match(
+      autoPromptsSrc,
+      /resolveExecutorContextWindow\(\s*opts\.modelRegistry\s*,\s*prefs\?\.preferences\s*,\s*opts\.sessionContextWindow/,
+      "buildExecuteTaskPrompt must forward both into resolveExecutorContextWindow",
+    );
+  });
+
+  it("buildReactiveExecutePrompt accepts opts and forwards to embedded buildExecuteTaskPrompt", () => {
+    assert.match(
+      autoPromptsSrc,
+      /export async function buildReactiveExecutePrompt\([\s\S]*?opts\?:\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/,
+      "buildReactiveExecutePrompt must accept sessionContextWindow + modelRegistry",
+    );
+    assert.match(
+      autoPromptsSrc,
+      /sessionContextWindow:\s*opts\?\.sessionContextWindow,\s*modelRegistry:\s*opts\?\.modelRegistry/,
+      "buildReactiveExecutePrompt must forward both into the embedded buildExecuteTaskPrompt call",
+    );
+  });
+
+  it("DispatchContext declares both knobs", () => {
+    assert.match(
+      autoDispatchSrc,
+      /interface DispatchContext\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/s,
+      "DispatchContext must declare both fields so dispatch rules can thread them",
+    );
+  });
+
+  it("DISPATCH_RULES destructure and forward both knobs at every prompt-builder call site", () => {
+    // Every plan-slice / execute-task / reactive-execute rule must destructure
+    // both names from its match context so new call sites can't silently drop them.
+    const matchLines = autoDispatchSrc.match(/match:\s*async\s*\(\{[^}]*sessionContextWindow[^}]*modelRegistry[^}]*\}/g) ?? [];
+    assert.ok(
+      matchLines.length >= 5,
+      `expected ≥5 dispatch rules destructuring both knobs, got ${matchLines.length}`,
+    );
+
+    const forwardCount = (autoDispatchSrc.match(/sessionContextWindow,\s*modelRegistry/g) ?? []).length;
+    assert.ok(
+      forwardCount >= 5,
+      `expected ≥5 forward sites of { sessionContextWindow, modelRegistry }, got ${forwardCount}`,
+    );
+  });
+
+  it("runDispatch populates both knobs from ctx.model / ctx.modelRegistry", () => {
+    assert.match(
+      phasesSrc,
+      /sessionContextWindow:\s*ctx\.model\?\.contextWindow/,
+      "runDispatch must populate sessionContextWindow from ctx.model?.contextWindow",
+    );
+    assert.match(
+      phasesSrc,
+      /modelRegistry:\s*ctx\.modelRegistry/,
+      "runDispatch must populate modelRegistry from ctx.modelRegistry",
+    );
+  });
+
+  it("dispatchDirectPhase forwards both knobs to buildPlanSlicePrompt and buildExecuteTaskPrompt", () => {
+    const passes = (autoDirectDispatchSrc.match(/sessionContextWindow:\s*ctx\.model\?\.contextWindow[\s\S]*?modelRegistry:\s*ctx\.modelRegistry/g) ?? []).length;
+    assert.ok(
+      passes >= 2,
+      `dispatchDirectPhase must forward the pair at both prompt-builder call sites (≥2), got ${passes}`,
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -223,6 +223,30 @@ test("replan-slice prompt uses gsd_replan_slice as canonical DB-backed tool", ()
   assert.doesNotMatch(prompt, /Degraded fallback/i);
 });
 
+// ─── ADR-011 refine-slice prompt contracts ────────────────────────────
+
+test("refine-slice prompt names gsd_plan_slice as the DB-backed write path", () => {
+  const prompt = readPrompt("refine-slice");
+  assert.match(prompt, /gsd_plan_slice/, "refine-slice must call gsd_plan_slice to persist");
+});
+
+test("refine-slice prompt does not instruct direct PLAN.md writes", () => {
+  const prompt = readPrompt("refine-slice");
+  assert.match(
+    prompt,
+    /do NOT rely on direct `PLAN\.md` writes/i,
+    "refine-slice must not frame direct file writes as authoritative",
+  );
+});
+
+test("refine-slice prompt frames the unit as a transformation, not blank-sheet planning", () => {
+  const prompt = readPrompt("refine-slice");
+  // The framing language is load-bearing — the model should treat this as
+  // expanding an approved sketch, not planning from scratch.
+  assert.match(prompt, /expands an approved sketch/i);
+  assert.match(prompt, /Sketch Scope/);
+});
+
 test("reassess-roadmap prompt references gsd_reassess_roadmap tool", () => {
   const prompt = readPrompt("reassess-roadmap");
   assert.match(prompt, /gsd_reassess_roadmap/);

package/src/resources/extensions/gsd/tests/prompt-db.test.ts

@@ -360,7 +360,7 @@ test('prompt-db: re-import updates DB when source markdown changes', () => {
 `;
   writeFileSync(join(gsdDir, 'DECISIONS.md'), updatedDecisions);
 
-  // Re-import (simulating what handleAgentEnd does)
+  // Re-import (simulating what the agent_end path does)
   migrateFromMarkdown(tmpDir);
 
   // Verify DB now has 3 decisions

package/src/resources/extensions/gsd/tests/prompts-no-gitignored-test-refs.test.ts

@@ -0,0 +1,56 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const promptsDir = join(__dirname, "..", "prompts");
+
+function readPrompt(name: string): string {
+  return readFileSync(join(promptsDir, name), "utf-8");
+}
+
+test("add-tests prompt forbids referencing gitignored paths", () => {
+  const prompt = readPrompt("add-tests.md");
+
+  assert.match(
+    prompt,
+    /gitignore/i,
+    "add-tests prompt should mention .gitignore to rule out referencing local-only files",
+  );
+  assert.match(prompt, /\.gsd\//, "add-tests prompt should name .gsd/ as off-limits for tests");
+  assert.match(prompt, /\.planning\//, "add-tests prompt should name .planning/ as off-limits for tests");
+  assert.match(prompt, /\.audits\//, "add-tests prompt should name .audits/ as off-limits for tests");
+  assert.match(
+    prompt,
+    /tracked/i,
+    "add-tests prompt should frame the rule in terms of tracked files",
+  );
+});
+
+test("plan-slice prompt warns against planning tests that depend on gitignored files", () => {
+  const prompt = readPrompt("plan-slice.md");
+
+  assert.match(
+    prompt,
+    /gitignore/i,
+    "plan-slice prompt should warn against planning tests that depend on .gitignore paths",
+  );
+  assert.match(prompt, /\.gsd\//, "plan-slice prompt should name .gsd/ as off-limits for planned tests");
+  assert.match(prompt, /\.planning\//, "plan-slice prompt should name .planning/ as off-limits for planned tests");
+  assert.match(prompt, /\.audits\//, "plan-slice prompt should name .audits/ as off-limits for planned tests");
+});
+
+test("execute-task prompt forbids tests that reference gitignored paths", () => {
+  const prompt = readPrompt("execute-task.md");
+
+  assert.match(
+    prompt,
+    /gitignore/i,
+    "execute-task prompt should forbid referencing gitignored paths from tests",
+  );
+  assert.match(prompt, /\.gsd\//, "execute-task prompt should name .gsd/ as off-limits for tests");
+  assert.match(prompt, /\.planning\//, "execute-task prompt should name .planning/ as off-limits for tests");
+  assert.match(prompt, /\.audits\//, "execute-task prompt should name .audits/ as off-limits for tests");
+});

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

@@ -32,6 +32,19 @@ test("classifyError detects rate limit from message", () => {
   assert.equal(result.kind, "rate-limit");
 });
 
+test("classifyError treats Anthropic quota-window phrasing as transient rate-limit (#4373)", () => {
+  const result = classifyError("You've hit your limit · resets soon");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 60_000);
+});
+
+test("classifyError treats usage-limit phrasing as transient rate-limit (#4373)", () => {
+  const result = classifyError("usage limit reached for this workspace");
+  assert.ok(isTransient(result));
+  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.",
@@ -134,6 +147,49 @@ test("classifyError: rate limit takes precedence over auth keywords", () => {
   assert.ok(isTransient(result));
 });
 
+// ── unsupported-model: account/plan entitlement rejection (#4513) ──────────
+
+test("classifyError: Codex ChatGPT-account entitlement rejection is unsupported-model", () => {
+  const result = classifyError(
+    "The 'gpt-5.1-codex-max' model is not supported when using Codex with a ChatGPT account.",
+  );
+  assert.equal(result.kind, "unsupported-model");
+  assert.ok(!isTransient(result));
+});
+
+test("classifyError: 'model not available for this plan' is unsupported-model", () => {
+  const result = classifyError("This model is not available for your current plan.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'account does not have access to model' is unsupported-model", () => {
+  const result = classifyError("Your account does not have access to the gpt-5 model.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'tier does not support deployment' is unsupported-model", () => {
+  const result = classifyError("The free tier does not support this deployment.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'account suspended' stays permanent (not unsupported-model)", () => {
+  const result = classifyError("Your account has been suspended. Contact support.");
+  assert.equal(result.kind, "permanent");
+});
+
+test("classifyError: 'invalid account' stays permanent", () => {
+  const result = classifyError("invalid account credentials");
+  assert.equal(result.kind, "permanent");
+});
+
+test("classifyError: rate limit on unsupported-model phrasing stays rate-limit", () => {
+  // A throttled account is not an entitlement failure.
+  const result = classifyError(
+    "429 rate limit — model not supported when using your account right now",
+  );
+  assert.equal(result.kind, "rate-limit");
+});
+
 // ── STREAM_RE: V8 JSON parse error variants (#2916) ────────────────────────
 
 test("classifyError: 'Expected comma/brace after property value in JSON' is transient stream", () => {
@@ -202,6 +258,10 @@ test("isTransientNetworkError detects DNS errors", () => {
   assert.ok(isTransientNetworkError("dns resolution failed"));
 });
 
+test("isTransientNetworkError detects unexpected EOF", () => {
+  assert.ok(isTransientNetworkError("unexpected EOF"));
+});
+
 test("isTransientNetworkError rejects auth errors", () => {
   assert.ok(!isTransientNetworkError("unauthorized: invalid API key"));
 });
@@ -455,6 +515,22 @@ test("agent-end-recovery.ts resumes transient provider pauses through startAuto
   );
 });
 
+test("agent-end-recovery.ts does not defer rate-limit errors to core retry handler before fallback (#4373)", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+  assert.ok(
+    src.includes('if (isTransient(cls) && cls.kind !== "rate-limit")'),
+    "rate-limit errors must bypass transient core-retry deferral so fallback can execute (#4373)",
+  );
+});
+
+test("agent-end-recovery.ts updates dashboard dispatched model after fallback switch", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+  assert.ok(
+    src.includes("setCurrentDispatchedModelId"),
+    "agent-end-recovery.ts should update currentDispatchedModelId when recovery switches model",
+  );
+});
+
 // ── Codex error extraction (#1166) ──────────────────────────────────────────
 
 test("openai-codex-responses.ts extracts nested error fields", () => {
@@ -514,16 +590,24 @@ test("provider-error-resume.ts calls resetTransientRetryState before startAuto",
 test("phases.ts handles timeout session-creation failures with pause instead of stopAuto", () => {
   const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
 
-  // The cancelled + isTransient + category=timeout path must pause, not hard-stop
+  // The cancelled + isTransient session-start path must pause, not hard-stop
+  assert.ok(
+    src.includes('errorCategory === "timeout"'),
+    "phases.ts must check errorCategory === 'timeout' on transient cancelled unitResults",
+  );
   assert.ok(
-    src.includes('category === "timeout"'),
-    "phases.ts must check category === 'timeout' on transient cancelled unitResults",
+    src.includes('errorCategory === "session-failed"'),
+    "phases.ts must also check errorCategory === 'session-failed' on transient cancelled unitResults",
   );
   // Must call pauseAuto or pauseAutoForProviderError (not stopAuto) for timeout cancellations
   assert.ok(
-    /category === "timeout"[\s\S]{0,1200}pauseAuto/.test(src),
+    /errorCategory === "timeout"[\s\S]{0,1800}pauseAuto/.test(src),
     "phases.ts must call pauseAuto for session-timeout failures (not stopAuto or continue)",
   );
+  assert.ok(
+    /errorCategory === "session-failed"[\s\S]{0,700}pauseAuto/.test(src),
+    "phases.ts must call pauseAuto for transient session-start failures (not stopAuto or continue)",
+  );
   // Must NOT use action: "continue" for transient cancellations (causes infinite loops)
   assert.ok(
     !/isTransient[\s\S]{0,500}action:\s*"continue"/.test(src),

package/src/resources/extensions/gsd/tests/python-resolver.test.ts

@@ -0,0 +1,131 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+// Regression tests for #4416: python invocation normalization for Windows.
+// These tests import from python-resolver.ts which is created as part of the fix.
+import { normalizePythonCommand, detectPythonExecutable } from "../python-resolver.ts";
+
+describe("normalizePythonCommand", () => {
+  test("passes through command that does not start with python", () => {
+    assert.equal(normalizePythonCommand("npm run test"), "npm run test");
+  });
+
+  test("passes through empty string", () => {
+    assert.equal(normalizePythonCommand(""), "");
+  });
+
+  test("passes through non-python shell commands unchanged", () => {
+    assert.equal(normalizePythonCommand("node index.js"), "node index.js");
+    assert.equal(normalizePythonCommand("npx tsc --noEmit"), "npx tsc --noEmit");
+  });
+
+  test("passes through command unchanged when no python is detected", () => {
+    // We cannot fully mock detectPythonExecutable here without a mock framework,
+    // but we can verify that a command without python tokens is always preserved.
+    const cmd = "cargo test";
+    assert.equal(normalizePythonCommand(cmd), cmd);
+  });
+
+  test("rewrites leading python3 token when interpreter is detected", () => {
+    const input = "python3 -m pytest";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.ok(
+      result.startsWith(`${detected} `),
+      `Expected rewritten prefix '${detected} ' in: ${result}`,
+    );
+    assert.ok(result.includes("-m pytest"), `Expected arguments preserved in: ${result}`);
+  });
+
+  test("rewrites leading python token when interpreter is detected", () => {
+    const input = "python manage.py migrate";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.ok(
+      result.startsWith(`${detected} `),
+      `Expected rewritten prefix '${detected} ' in: ${result}`,
+    );
+    assert.ok(result.includes("manage.py migrate"), `Expected arguments preserved in: ${result}`);
+  });
+
+  test("rewrites python token after && compound separator", () => {
+    const input = "echo ok && python3 -m pytest --tb=short";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.ok(
+      result.includes(`&& ${detected} `),
+      `Expected '&& ${detected} ' segment in: ${result}`,
+    );
+    assert.ok(
+      result.includes("-m pytest --tb=short"),
+      `Expected arguments preserved in: ${result}`,
+    );
+  });
+
+  test("rewrites leading python token when command has leading whitespace", () => {
+    const input = "  python3 -m pytest";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.equal(
+      result,
+      `  ${detected} -m pytest`,
+      `Expected leading whitespace preserved and python3 rewritten in: ${result}`,
+    );
+  });
+
+  test("does not duplicate '-3' when rewriting existing 'py -3' token", () => {
+    const input = "py -3 -m pytest";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.equal(
+      result,
+      `${detected} -m pytest`,
+      `Expected clean rewrite without duplicated '-3' in: ${result}`,
+    );
+  });
+});
+
+describe("detectPythonExecutable", () => {
+  test("returns a string or null — never throws", () => {
+    let result: string | null | undefined;
+    assert.doesNotThrow(() => {
+      result = detectPythonExecutable();
+    });
+    assert.ok(result === null || typeof result === "string");
+  });
+
+  test("return value is a known python invocation form or null", () => {
+    const result = detectPythonExecutable();
+    const valid = [null, "python3", "python", "py -3"];
+    assert.ok(
+      valid.includes(result as string | null),
+      `Expected one of ${valid.join(", ")}, got: ${String(result)}`,
+    );
+  });
+
+  test("returns the same value on repeated calls (cached)", () => {
+    const first = detectPythonExecutable();
+    const second = detectPythonExecutable();
+    assert.equal(first, second, "detectPythonExecutable must return consistent cached result");
+  });
+});

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -10,6 +10,7 @@ import {
   resetWriteGateState,
   shouldBlockContextArtifactSave,
 } from "../bootstrap/write-gate.ts";
+import { toRoundResultResponse } from "../../remote-questions/manager.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -95,3 +96,69 @@ test("register-hooks unlocks milestone depth verification from question id witho
     "question-id milestone inference should unlock the matching milestone context write",
   );
 });
+
+test("register-hooks clears depth gate when remote (Telegram/Slack/Discord) answer is normalized (#4406)", async (t) => {
+  const dir = makeTempDir("remote");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<void> | void) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_M002_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Do you agree?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({ toolName: "ask_user_questions", input: { questions } });
+  }
+  assert.equal(getPendingGate(), questionId);
+
+  // Simulate the normalized response the remote manager now emits:
+  // a Telegram button press returns a RemoteAnswer that is fed through
+  // toRoundResultResponse before reaching details.response.
+  const remoteAnswer = {
+    answers: {
+      [questionId]: { answers: ["Yes, you got it (Recommended)"] },
+    },
+  };
+  const normalized = toRoundResultResponse(remoteAnswer);
+
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: { response: normalized },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "normalized remote answer must clear the gate");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M002").block,
+    false,
+    "remote confirmation must unlock the matching milestone context write",
+  );
+});