@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

package/src/resources/extensions/gsd/tests/auto-dispatch-baseline-harness.test.ts

@@ -0,0 +1,53 @@
+// Project/App: gsd-pi
+// File Purpose: Cover the getDebugCounters() snapshot getter added for the
+// per-dispatch benchmark harness (issue #442, Phase 0.3). The harness itself
+// (scripts/auto-dispatch-baseline.mjs) reads counters via this getter without
+// disabling debug (which is what writeDebugSummary does).
+
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { mkdtempSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  enableDebug,
+  disableDebug,
+  debugCount,
+  getDebugCounters,
+} from '../debug-logger.ts';
+
+function tmpGsd(): string {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-baseline-harness-'));
+  mkdirSync(join(tmp, '.gsd'), { recursive: true });
+  return tmp;
+}
+
+test('getDebugCounters returns a live snapshot of the hot-path counters', () => {
+  enableDebug(tmpGsd());
+
+  debugCount('deriveStateCalls', 3);
+  debugCount('parseRoadmapCalls');
+  debugCount('parsePlanCalls', 2);
+  debugCount('gitInvocations', 7);
+
+  const snap = getDebugCounters();
+  assert.strictEqual(snap.deriveStateCalls, 3);
+  assert.strictEqual(snap.parseRoadmapCalls, 1);
+  assert.strictEqual(snap.parsePlanCalls, 2);
+  assert.strictEqual(snap.gitInvocations, 7);
+
+  disableDebug();
+});
+
+test('getDebugCounters returns a copy — callers cannot mutate internal state', () => {
+  enableDebug(tmpGsd());
+  debugCount('gitInvocations', 5);
+
+  const snap = getDebugCounters() as Record<string, number>;
+  snap.gitInvocations = 999;
+
+  assert.strictEqual(getDebugCounters().gitInvocations, 5, 'internal counter must be unaffected by mutating the snapshot');
+
+  disableDebug();
+});

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

@@ -23,11 +23,12 @@ import {
 import { runUnit, shouldDeferUnitFailsafeTimeout } from "../auto/run-unit.js";
 import { scheduleAutoWakeup, _resetAutoWakeupsForTest } from "../auto/schedule-wakeup.js";
 import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from "../unit-runtime.js";
-import { autoLoop } from "../auto/loop.js";
-import { runDispatch, runUnitPhase } from "../auto/phases.js";
+import { autoLoop as rawAutoLoop } from "../auto/loop.js";
+import { runPreDispatch, runDispatch, runUnitPhase } from "../auto/phases.js";
 import { detectStuck } from "../auto/detect-stuck.js";
-import type { UnitResult, AgentEndEvent } from "../auto/types.js";
+import type { UnitResult, AgentEndEvent, LoopState } from "../auto/types.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
+import type { AutoAdvanceResult, AutoOrchestrationModule, AutoStatus, UnitRef } from "../auto/contracts.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import type { SessionLockStatus } from "../session-lock.js";
@@ -40,6 +41,17 @@ import { SourceObservationStore } from "../source-observations.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
+const ORCHESTRATION_MISSING_REASON =
+  "Auto Orchestration Module is not wired; cannot dispatch built-in GSD Unit.";
+
+type CapturedAutoSideEffects<T> = {
+  result: T;
+  stopped: boolean;
+  stoppedReason?: string;
+  paused: boolean;
+  pausedReason?: string;
+};
+
 function makeEvent(
   messages: unknown[] = [{ role: "assistant" }],
 ): AgentEndEvent {
@@ -67,12 +79,203 @@ async function waitForMicrotasks(
   assert.fail(`Timed out waiting for ${label}`);
 }
 
+function makeLoopState(): LoopState {
+  return {
+    recentUnits: [],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null,
+    lastDispatchPhase: null,
+  };
+}
+
+function createLoopTestOrchestration(
+  ctx: any,
+  pi: any,
+  s: any,
+  deps: LoopDeps,
+): AutoOrchestrationModule {
+  // Production auto.ts wires the real Auto Orchestration Module before entering
+  // autoLoop. These loop-mechanics tests keep their LoopDeps fixtures by
+  // adapting the old phase helpers to the public orchestration Interface.
+  const loopState = makeLoopState();
+  const status: AutoStatus = { phase: "running", transitionCount: 0 };
+  let iteration = 0;
+  let seq = 0;
+
+  function nextSeq(): number {
+    return ++seq;
+  }
+
+  function clearActiveUnit(): void {
+    status.activeUnit = undefined;
+  }
+
+  async function captureAutoSideEffects<T>(
+    run: () => Promise<T>,
+  ): Promise<CapturedAutoSideEffects<T>> {
+    const originalStopAuto = deps.stopAuto;
+    const originalPauseAuto = deps.pauseAuto;
+    let stoppedReason: string | undefined;
+    let pausedReason: string | undefined;
+    let stopped = false;
+    let paused = false;
+
+    (deps as any).stopAuto = async (...args: Parameters<LoopDeps["stopAuto"]>) => {
+      stopped = true;
+      stoppedReason = args[2];
+      return originalStopAuto(...args);
+    };
+    (deps as any).pauseAuto = async (...args: Parameters<LoopDeps["pauseAuto"]>) => {
+      paused = true;
+      const context = args[2] as { message?: string } | undefined;
+      pausedReason = context?.message;
+      return originalPauseAuto(...args);
+    };
+
+    try {
+      const result = await run();
+      return { result, stopped, stoppedReason, paused, pausedReason };
+    } finally {
+      (deps as any).stopAuto = originalStopAuto;
+      (deps as any).pauseAuto = originalPauseAuto;
+    }
+  }
+
+  function resultForBreak(
+    reason: string,
+    sideEffects: CapturedAutoSideEffects<unknown>,
+  ): AutoAdvanceResult {
+    clearActiveUnit();
+    status.phase = sideEffects.paused && !sideEffects.stopped ? "paused" : "stopped";
+    status.transitionCount += 1;
+    if (sideEffects.paused && !sideEffects.stopped) {
+      return {
+        kind: "blocked",
+        reason: sideEffects.pausedReason ?? reason,
+        action: "pause",
+      };
+    }
+    return {
+      kind: "stopped",
+      reason: sideEffects.stoppedReason ?? reason,
+    };
+  }
+
+  return {
+    async start() {
+      status.phase = "running";
+      status.transitionCount += 1;
+      return { kind: "started" };
+    },
+    async advance() {
+      iteration += 1;
+      seq = 0;
+      const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
+      const ic = {
+        ctx,
+        pi,
+        s,
+        deps,
+        prefs,
+        iteration,
+        flowId: `loop-test-orchestration-${iteration}`,
+        nextSeq,
+      };
+
+      const preDispatch = await captureAutoSideEffects(() => runPreDispatch(ic, loopState));
+      const preDispatchResult = preDispatch.result;
+      if (preDispatchResult.action === "break") {
+        return resultForBreak(preDispatchResult.reason, preDispatch);
+      }
+      if (preDispatchResult.action === "continue") {
+        return { kind: "skipped", reason: "pre-dispatch-skip" };
+      }
+      if (preDispatchResult.action === "retry") {
+        return { kind: "paused", reason: preDispatchResult.reason };
+      }
+
+      const dispatch = await captureAutoSideEffects(() =>
+        runDispatch(ic, preDispatchResult.data, loopState),
+      );
+      if (dispatch.result.action === "break") {
+        return resultForBreak(dispatch.result.reason, dispatch);
+      }
+      if (dispatch.result.action === "continue") {
+        return {
+          kind: "skipped",
+          reason: "dispatch-skip",
+          stateSnapshot: preDispatchResult.data.state,
+        };
+      }
+      if (dispatch.result.action === "retry") {
+        return { kind: "paused", reason: dispatch.result.reason };
+      }
+
+      const data = dispatch.result.data;
+      const unit: UnitRef = { unitType: data.unitType, unitId: data.unitId };
+      s.pendingOrchestrationDispatch = {
+        unitType: data.unitType,
+        unitId: data.unitId,
+        prompt: data.prompt,
+        pauseAfterUatDispatch: data.pauseAfterUatDispatch,
+        state: data.state,
+        mid: data.mid,
+        midTitle: data.midTitle,
+      };
+      status.phase = "running";
+      status.activeUnit = unit;
+      status.transitionCount += 1;
+      return { kind: "advanced", unit, stateSnapshot: data.state };
+    },
+    async completeActiveUnit() {
+      clearActiveUnit();
+    },
+    async retryActiveUnit() {
+      clearActiveUnit();
+    },
+    async resume() {
+      status.phase = "running";
+      status.transitionCount += 1;
+      return { kind: "resumed" };
+    },
+    async stop(reason: string) {
+      status.phase = "stopped";
+      clearActiveUnit();
+      status.transitionCount += 1;
+      return { kind: "stopped", reason };
+    },
+    getStatus() {
+      return {
+        ...status,
+        activeUnit: status.activeUnit ? { ...status.activeUnit } : undefined,
+      };
+    },
+  };
+}
+
+async function autoLoop(
+  ctx: any,
+  pi: any,
+  s: any,
+  deps: LoopDeps,
+  options?: Parameters<typeof rawAutoLoop>[4],
+): Promise<void> {
+  if (!s.orchestration) {
+    s.orchestration = createLoopTestOrchestration(ctx, pi, s, deps);
+  }
+  await rawAutoLoop(ctx, pi, s, deps, options);
+}
+
 /**
  * Build a minimal mock AutoSession with controllable newSession behavior.
  */
 function makeMockSession(opts?: {
   newSessionResult?: { cancelled: boolean };
   newSessionThrows?: string;
+  /** Reject newSession() with a specific Error instance (e.g. TypeError). */
+  newSessionThrowsError?: Error;
   newSessionDelayMs?: number;
   onNewSessionStart?: (session: any) => void;
   onNewSessionSettle?: (session: any) => void;
@@ -87,6 +290,9 @@ function makeMockSession(opts?: {
     cmdCtx: {
       newSession: (options?: { abortSignal?: AbortSignal; workspaceRoot?: string }) => {
         opts?.onNewSessionStart?.(session);
+        if (opts?.newSessionThrowsError) {
+          return Promise.reject(opts.newSessionThrowsError);
+        }
         if (opts?.newSessionThrows) {
           return Promise.reject(new Error(opts.newSessionThrows));
         }
@@ -497,6 +703,73 @@ test("runUnit returns cancelled when session creation fails", async () => {
   assert.equal(pi.calls.length, 0);
 });
 
+test("runUnit: TypeError from newSession is classified as structural (isTransient: false)", async () => {
+  // Regression for #572: a TypeError thrown from newSession (e.g. "something is
+  // not a function") indicates a programming error, not a transient provider
+  // blip. Before the fix it was always classified isTransient: true, causing
+  // auto-mode to retry indefinitely instead of surfacing the real problem.
+  _resetPendingResolve();
+
+  const baseCtx = {
+    ...makeMockCtx(),
+    ui: { notify: () => {}, setStatus: () => {}, setWorkingMessage: () => {} },
+    sessionManager: { getEntries: () => [] },
+    modelRegistry: { getProviderAuthMode: () => undefined, isProviderRequestReady: () => true },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession({
+    newSessionThrowsError: new TypeError("pi.sendMessage is not a function"),
+  });
+
+  const result = await runUnit(baseCtx, pi, s, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "session-failed");
+  assert.equal(result.errorContext?.isTransient, false, "TypeError must be non-transient");
+});
+
+test("runUnit: 'is not a function' message from newSession is classified as structural", async () => {
+  // Regression for #572: the pattern also catches errors where the thrown
+  // object is not a TypeError instance but the message contains "is not a function".
+  _resetPendingResolve();
+
+  const baseCtx = {
+    ...makeMockCtx(),
+    ui: { notify: () => {}, setStatus: () => {}, setWorkingMessage: () => {} },
+    sessionManager: { getEntries: () => [] },
+    modelRegistry: { getProviderAuthMode: () => undefined, isProviderRequestReady: () => true },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession({ newSessionThrows: "pi.sendMessage is not a function" });
+
+  const result = await runUnit(baseCtx, pi, s, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "session-failed");
+  assert.equal(result.errorContext?.isTransient, false, "'is not a function' errors must be non-transient");
+});
+
+test("runUnit: generic network error from newSession remains transient", async () => {
+  // Confirm that non-structural session errors (e.g. 429, ECONNREFUSED) are
+  // still classified as transient so auto-mode can retry them.
+  _resetPendingResolve();
+
+  const baseCtx = {
+    ...makeMockCtx(),
+    ui: { notify: () => {}, setStatus: () => {}, setWorkingMessage: () => {} },
+    sessionManager: { getEntries: () => [] },
+    modelRegistry: { getProviderAuthMode: () => undefined, isProviderRequestReady: () => true },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession({ newSessionThrows: "connection refused" });
+
+  const result = await runUnit(baseCtx, pi, s, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "session-failed");
+  assert.equal(result.errorContext?.isTransient, true, "network errors must remain transient");
+});
+
 test("runUnit clears queued switch cancellation when session creation fails", async () => {
   _resetPendingResolve();
 
@@ -1164,6 +1437,34 @@ test("autoLoop exits when s.active is set to false", async (t) => {
   );
 });
 
+test("autoLoop pauses visibly when Auto Orchestration Module is not wired", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+  let pauseContext: unknown;
+
+  const deps = makeMockDeps({
+    pauseAuto: async (_ctx, _pi, errorContext) => {
+      pauseContext = errorContext;
+      deps.callLog.push("pauseAuto");
+    },
+  });
+
+  await rawAutoLoop(ctx, pi, s, deps);
+
+  assert.ok(deps.callLog.includes("pauseAuto"), "missing orchestration should pause auto-mode");
+  assert.equal(
+    (pauseContext as { message?: string } | undefined)?.message,
+    ORCHESTRATION_MISSING_REASON,
+  );
+  assert.equal(deps.callLog.includes("deriveState"), false);
+  assert.equal(deps.callLog.includes("resolveDispatch"), false);
+  assert.equal(s.pendingOrchestrationDispatch, null);
+});
+
 test("autoLoop exits on terminal complete state", async (t) => {
   _resetPendingResolve();
 
@@ -1990,11 +2291,15 @@ test("autoLoop retries next iteration when orchestration reports paused", async
     },
   });
 
+  const journalEvents: Array<{ eventType: string; data?: any }> = [];
   const deps = makeMockDeps({
     resolveDispatch: async () => {
       deps.callLog.push("resolveDispatch");
       throw new Error("legacy resolveDispatch must not run after orchestration paused");
     },
+    emitJournalEvent: (entry: any) => {
+      journalEvents.push(entry);
+    },
   });
 
   await autoLoop(ctx, pi, s, deps);
@@ -2007,6 +2312,11 @@ test("autoLoop retries next iteration when orchestration reports paused", async
     "orchestration paused must not fall back to legacy dispatch",
   );
   assert.equal(s.pendingOrchestrationDispatch, null, "no orchestration dispatch should remain pending");
+
+  const pausedIterationEnd = journalEvents.find(
+    (e) => e.eventType === "iteration-end" && e.data?.status === "paused",
+  );
+  assert.ok(pausedIterationEnd, "orchestration paused must emit iteration-end to close the iteration journal");
 });
 
 test("autoLoop consumes pending orchestration dispatch without advancing twice", async () => {
@@ -2094,8 +2404,13 @@ test("autoLoop stops orchestrator complete state through completion surface", as
       start: async () => ({ kind: "stopped" as const, reason: "unused" }),
       advance: async () => ({
         kind: "stopped" as const,
-        reason: "all milestones complete",
+        reason: "legacy text not used",
         stateSnapshot,
+        terminalOutcome: {
+          code: "all-complete" as const,
+          displayReason: "All milestones complete",
+          allMilestonesComplete: true as const,
+        },
       }),
       completeActiveUnit: async () => {},
       retryActiveUnit: async () => {},
@@ -2121,6 +2436,7 @@ test("autoLoop stops orchestrator complete state through completion surface", as
     milestoneTitle: "Priority Levels",
     allMilestonesComplete: true,
   });
+  assert.equal((stopCalls[0]?.options as any)?.terminalOutcome?.code, "all-complete");
   assert.equal(
     deps.callLog.includes("resolveDispatch"),
     false,
@@ -2960,7 +3276,7 @@ test("autoLoop closes journal iteration on pre-dispatch health-gate break", asyn
   assert.equal(deps.callLog.includes("pauseAuto"), true);
   assert.deepEqual(pauseOptions, { expectedCurrentUnit: null });
   assert.ok(
-    journalEvents.some((event) => event.eventType === "iteration-end" && event.data?.reason === "pre-dispatch-break"),
+    journalEvents.some((event) => event.eventType === "iteration-end" && event.data?.reason === "health-gate-failed"),
     "pre-dispatch break must close the started iteration",
   );
 });
@@ -5201,6 +5517,129 @@ test("dispatch Worktree Safety wins before stuck detection for execute-task with
   );
 });
 
+test("dispatch Worktree Safety honors degraded branch fallback instead of demanding the canonical worktree root", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const notifications: string[] = [];
+  ctx.ui.notify = (msg: string) => { notifications.push(msg); };
+
+  // Worktree creation failed and the lifecycle fell back to the milestone
+  // branch in the project root. The safety gate must validate against that
+  // effective branch mode, not the configured worktree mode.
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-safety-degraded-"));
+  t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
+
+  const s = makeLoopSession({
+    basePath: projectRoot,
+    originalBasePath: projectRoot,
+    canonicalProjectRoot: projectRoot,
+    isolationDegraded: true,
+  });
+  const deps = makeMockDeps({
+    getIsolationMode: () => "worktree",
+  });
+  const result = await runDispatch(
+    {
+      ctx,
+      pi,
+      s,
+      deps,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "test-flow",
+      nextSeq: () => 1,
+    },
+    {
+      state: {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Test", status: "active" },
+        activeSlice: { id: "S01", title: "Slice 1" },
+        activeTask: { id: "T01" },
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+      } as any,
+      mid: "M001",
+      midTitle: "Test",
+    },
+    {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    },
+  );
+
+  assert.equal(result.action, "next", "dispatch must proceed under degraded branch isolation");
+  assert.ok(
+    !notifications.some((n) => n.includes("Worktree Safety failed")),
+    "degraded branch fallback must not trip a false invalid-root",
+  );
+  assert.ok(!deps.callLog.includes("stopAuto"), "auto-mode must not stop on the degraded fallback");
+});
+
+test("dispatch Worktree Safety honors stranded branch recovery instead of demanding the canonical worktree root", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const notifications: string[] = [];
+  ctx.ui.notify = (msg: string) => { notifications.push(msg); };
+
+  // Bootstrap adopted stranded work by checking out the milestone branch in
+  // the project root (strandedRecoveryIsolationMode = "branch"). Isolation is
+  // NOT degraded — the adoption is intentional. The safety gate must validate
+  // against the effective branch mode, not the configured worktree mode.
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-safety-stranded-"));
+  t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
+
+  const s = makeLoopSession({
+    basePath: projectRoot,
+    originalBasePath: projectRoot,
+    canonicalProjectRoot: projectRoot,
+    strandedRecoveryIsolationMode: "branch",
+  });
+  const deps = makeMockDeps({
+    getIsolationMode: () => "worktree",
+  });
+  const result = await runDispatch(
+    {
+      ctx,
+      pi,
+      s,
+      deps,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "test-flow",
+      nextSeq: () => 1,
+    },
+    {
+      state: {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Test", status: "active" },
+        activeSlice: { id: "S01", title: "Slice 1" },
+        activeTask: { id: "T01" },
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+      } as any,
+      mid: "M001",
+      midTitle: "Test",
+    },
+    {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    },
+  );
+
+  assert.equal(result.action, "next", "dispatch must proceed under stranded branch recovery");
+  assert.ok(
+    !notifications.some((n) => n.includes("Worktree Safety failed")),
+    "stranded branch recovery must not trip a false invalid-root",
+  );
+  assert.ok(!deps.callLog.includes("stopAuto"), "auto-mode must not stop on stranded branch recovery");
+});
+
 test("runDispatch runs stuck detection while artifact verification retry is pending (#5719)", async (t) => {
   _resetPendingResolve();
 

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

@@ -1,8 +1,13 @@
 import { describe, it } 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";
 
 import { parseMilestoneTarget, parseModelFlag } from "../commands/handlers/auto.js";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 describe("parseMilestoneTarget", () => {
   it("extracts a simple milestone ID", () => {
     const result = parseMilestoneTarget("auto M016");
@@ -60,6 +65,24 @@ describe("parseMilestoneTarget", () => {
   });
 });
 
+describe("auto preference diagnostics", () => {
+  it("notifies preference diagnostics before launching auto-mode", () => {
+    const source = readFileSync(join(__dirname, "..", "commands", "handlers", "auto.ts"), "utf-8");
+    const autoBlockIndex = source.indexOf('if (trimmed === "auto" || trimmed.startsWith("auto "))');
+    assert.ok(autoBlockIndex >= 0, "auto command block should exist");
+    const nextBlockIndex = source.indexOf('if (trimmed === "stop")', autoBlockIndex);
+    const autoBlock = source.slice(autoBlockIndex, nextBlockIndex);
+    const notifyIndex = autoBlock.indexOf("notifyPreferenceDiagnostics");
+    assert.ok(notifyIndex >= 0, "auto command should notify preference diagnostics");
+    for (const match of autoBlock.matchAll(/startAutoDetached/g)) {
+      assert.ok(
+        notifyIndex < match.index!,
+        "preference diagnostics should be notified before each auto-mode launch",
+      );
+    }
+  });
+});
+
 describe("parseModelFlag", () => {
   it("extracts provider/model from --model", () => {
     const result = parseModelFlag("auto --model openrouter/openai/gpt-5.4");

package/src/resources/extensions/gsd/tests/auto-model-selection-tool-poisoning.test.ts

@@ -33,6 +33,7 @@ import {
   selectAndApplyModel,
   ModelPolicyDispatchBlockedError,
   clearToolBaseline,
+  getRegisteredToolSnapshot,
   getToolBaselineSnapshot,
 } from "../auto-model-selection.js";
 import { applyModelPolicyFilter } from "../uok/model-policy.js";
@@ -773,3 +774,20 @@ test("baseline union (#477): getToolBaselineSnapshot includes live tools not pre
     env.cleanup();
   }
 });
+
+test("registered tool snapshot includes tools hidden from the active surface", () => {
+  const pi = {
+    getActiveTools: () => ["read"],
+    getAllTools: () => [
+      { name: "read" },
+      { name: "browser_navigate" },
+      { name: "mcp__gsd-browser__*" },
+    ],
+  };
+
+  assert.deepEqual(getRegisteredToolSnapshot(pi as any), [
+    "read",
+    "browser_navigate",
+    "mcp__gsd-browser__*",
+  ]);
+});