@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/state-reconciliation/drift/stale-render.ts

@@ -61,6 +61,18 @@ function isRepairableStaleRenderReason(reason: string): boolean {
   );
 }
 
+function canonicalizeMilestoneId(dirSegment: string): string {
+  if (getMilestone(dirSegment)) return dirSegment;
+  const suffixId = dirSegment.match(/^(M\d+-[a-z0-9]{6})(?:$|-)/)?.[1];
+  if (suffixId && getMilestone(suffixId)) return suffixId;
+
+  // Descriptor layout: e.g. M001-DESCRIPTOR → M001
+  const baseId = dirSegment.match(/^(M\d+)(?:$|-)/i)?.[1];
+  if (baseId && getMilestone(baseId)) return baseId;
+
+  return suffixId ?? baseId ?? dirSegment;
+}
+
 function resolveRoadmapMilestoneIdFromPath(normPath: string): string {
   const milestoneMatch = normPath.match(/milestones\/([^/]+)\//);
   if (!milestoneMatch) {
@@ -106,7 +118,19 @@ async function repairStaleRenderFromBasePath(
         `stale-render drift: plan path missing milestone/slice segments: ${record.renderPath}`,
       );
     }
-    await renderPlanCheckboxes(basePath, pathMatch[1], pathMatch[2]);
+    const milestoneId = canonicalizeMilestoneId(pathMatch[1]);
+    const wrote = await renderPlanCheckboxes(
+      basePath,
+      milestoneId,
+      pathMatch[2],
+      record.renderPath,
+    );
+    if (!wrote) {
+      throw new Error(
+        `stale-render drift: plan re-render wrote nothing for ${milestoneId}/${pathMatch[2]} ` +
+          `(${record.renderPath}); slice has no tasks or its path is unresolvable`,
+      );
+    }
     return;
   }
 
@@ -120,7 +144,15 @@ async function repairStaleRenderFromBasePath(
         `stale-render drift: task summary path/reason malformed: ${record.renderPath} reason=${reason}`,
       );
     }
-    await renderTaskSummary(basePath, pathMatch[1], pathMatch[2], taskMatch[1]);
+    const milestoneId = canonicalizeMilestoneId(pathMatch[1]);
+    const wrote = await renderTaskSummary(basePath, milestoneId, pathMatch[2], taskMatch[1]);
+    if (!wrote) {
+      throw new Error(
+        `stale-render drift: task summary re-render wrote nothing for ` +
+          `${milestoneId}/${pathMatch[2]}/${taskMatch[1]} (${record.renderPath}); ` +
+          `task has no summary in DB or its slice path is unresolvable`,
+      );
+    }
     return;
   }
 
@@ -131,7 +163,7 @@ async function repairStaleRenderFromBasePath(
         `stale-render drift: slice summary path missing milestone/slice segments: ${record.renderPath}`,
       );
     }
-    const milestoneId = pathMatch[1];
+    const milestoneId = canonicalizeMilestoneId(pathMatch[1]);
     const sliceId = pathMatch[2];
     const slice = getSlice(milestoneId, sliceId);
     const uatPath = join(dirname(record.renderPath), buildSliceFileName(sliceId, "UAT"));
@@ -139,7 +171,14 @@ async function repairStaleRenderFromBasePath(
     if (slice?.full_uat_md && !existsSync(uatPath)) {
       setSliceSummaryMd(milestoneId, sliceId, slice.full_summary_md ?? "", "");
     }
-    await renderSliceSummary(basePath, milestoneId, sliceId);
+    const wrote = await renderSliceSummary(basePath, milestoneId, sliceId);
+    if (!wrote) {
+      throw new Error(
+        `stale-render drift: slice summary re-render wrote nothing for ` +
+          `${milestoneId}/${sliceId} (${record.renderPath}); slice has no summary/UAT ` +
+          `in DB or its path is unresolvable`,
+      );
+    }
     return;
   }
 
@@ -152,7 +191,7 @@ async function repairStaleRenderFromBasePath(
     }
     // When UAT.md is removed from disk, mirror that intent by clearing stale
     // persisted UAT content instead of rehydrating it back onto disk.
-    const milestoneId = pathMatch[1];
+    const milestoneId = canonicalizeMilestoneId(pathMatch[1]);
     const sliceId = pathMatch[2];
     const slice = getSlice(milestoneId, sliceId);
     if (!slice) {

package/src/resources/extensions/gsd/state-reconciliation/drift/stale-worker.ts

@@ -10,6 +10,11 @@ import {
   readSessionLockData,
   removeStaleSessionLock,
 } from "../../session-lock.js";
+import { clearStaleWorkerLock } from "../../crash-recovery.js";
+import { findStaleWorkerForProject } from "../../db/auto-workers.js";
+import { isDbAvailable } from "../../gsd-db.js";
+import { normalizeRealPath } from "../../paths.js";
+import { logWarning } from "../../workflow-logger.js";
 import type { GSDState } from "../../types.js";
 import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
 
@@ -20,23 +25,46 @@ export function detectStaleWorkerDrift(
   ctx: DriftContext,
 ): StaleWorkerDrift[] {
   const data = readSessionLockData(ctx.basePath);
-  if (!data) return [];
-  if (typeof data.pid !== "number") return [];
-  if (isSessionLockProcessAlive(data)) return [];
-
-  return [
-    {
-      kind: "stale-worker",
-      lockPath: effectiveLockFile(),
-      pid: data.pid,
-    },
-  ];
+  if (data && typeof data.pid === "number") {
+    return isSessionLockProcessAlive(data)
+      ? []
+      : [{ kind: "stale-worker", lockPath: effectiveLockFile(), pid: data.pid }];
+  }
+
+  // The lock file is missing or unparseable. It is not the only source of
+  // truth: a crashed worker can leave a workers row 'active' with held leases
+  // and in-flight dispatches even when its lock file is gone. Fall back to the
+  // DB worker registry so that state is still detected and repaired.
+  if (isDbAvailable()) {
+    try {
+      const stale = findStaleWorkerForProject(normalizeRealPath(ctx.basePath));
+      if (stale && typeof stale.pid === "number") {
+        return [{ kind: "stale-worker", lockPath: effectiveLockFile(), pid: stale.pid }];
+      }
+    } catch (err) {
+      // Best-effort: detection must never throw and abort the reconcile cycle.
+      logWarning(
+        "reconcile",
+        `stale-worker DB fallback detection failed: ${(err as Error).message}`,
+      );
+    }
+  }
+
+  return [];
 }
 
 export function repairStaleWorker(_record: StaleWorkerDrift, ctx: DriftContext): void {
   // removeStaleSessionLock is idempotent: it re-reads lock state and is a
   // no-op when the lock is held by an alive process. Safe under cap=2 retry.
   removeStaleSessionLock(ctx.basePath);
+
+  // Removing the lock file alone leaves the DB-side worker state dangling: the
+  // dead worker's milestone_leases stay 'held' and its unit_dispatches stay
+  // 'running'/'claimed', blocking new claims until the lease TTL expires.
+  // clearStaleWorkerLock cancels those dispatches, releases the leases, and
+  // marks the worker stopping — the same cleanup the startup crash-recovery
+  // path performs. It is DB-gated, idempotent, and best-effort.
+  clearStaleWorkerLock(ctx.basePath);
 }
 
 export const staleWorkerHandler: DriftHandler<StaleWorkerDrift> = {

package/src/resources/extensions/gsd/state-reconciliation/index.ts

@@ -7,6 +7,8 @@ import {
   invalidateStateCache as defaultInvalidate,
 } from "../state.js";
 import { clearParseCache as defaultClearParseCache } from "../files.js";
+import { clearPathCache } from "../paths.js";
+import { logWarning } from "../workflow-logger.js";
 import type { GSDState } from "../types.js";
 
 import {
@@ -68,18 +70,24 @@ export async function reconcileBeforeDispatch(
     const stateSnapshot = await deps.deriveState(basePath, deps.deriveStateOptions);
     const ctx: DriftContext = { basePath, state: stateSnapshot };
 
-    const drift = await detectAllDrift(stateSnapshot, ctx, registry, pass);
+    const detection = await detectAllDrift(stateSnapshot, ctx, registry);
+    const drift = detection.records;
     if (drift.length === 0) {
       return {
         ok: true,
         stateSnapshot,
         repaired,
-        blockers: stateSnapshot.blockers ?? [],
+        blockers: [
+          ...new Set([
+            ...(stateSnapshot.blockers ?? []),
+            ...detection.detectBlockers,
+          ]),
+        ],
       };
     }
 
     const failures: ReconciliationFailureDetail[] = [];
-    const blockers: string[] = [];
+    const blockers: string[] = [...detection.detectBlockers];
     let repairedThisPass = false;
     for (const record of drift) {
       const handler = registry.find((h) => h.kind === record.kind);
@@ -107,7 +115,11 @@ export async function reconcileBeforeDispatch(
     }
 
     if (repairedThisPass) {
+      // A repair may have mutated on-disk structure (e.g. quarantined a slice
+      // dir). Clear both the parse cache and the path/dir cache centrally so
+      // later passes and any subsequent repair see fresh filesystem state.
       clearParseCache();
+      clearPathCache();
     }
     if (blockers.length > 0) {
       let blockerState = stateSnapshot;
@@ -132,10 +144,11 @@ export async function reconcileBeforeDispatch(
   deps.invalidateStateCache();
   const finalState = await deps.deriveState(basePath, deps.deriveStateOptions);
   const finalCtx: DriftContext = { basePath, state: finalState };
-  const persistent = await detectAllDrift(finalState, finalCtx, registry);
+  const finalDetection = await detectAllDrift(finalState, finalCtx, registry);
+  const persistent = finalDetection.records;
 
   if (persistent.length > 0) {
-    const blockers: string[] = [];
+    const blockers: string[] = [...finalDetection.detectBlockers];
     const unblockedPersistent: DriftRecord[] = [];
     for (const record of persistent) {
       const handler = registry.find((h) => h.kind === record.kind);
@@ -161,28 +174,45 @@ export async function reconcileBeforeDispatch(
     ok: true,
     stateSnapshot: finalState,
     repaired,
-    blockers: finalState.blockers ?? [],
+    blockers: [
+      ...new Set([
+        ...(finalState.blockers ?? []),
+        ...finalDetection.detectBlockers,
+      ]),
+    ],
   };
 }
 
+interface DetectionOutcome {
+  records: DriftRecord[];
+  /** One blocker string per handler whose detect() threw. */
+  detectBlockers: string[];
+}
+
+/**
+ * Run every detector. A single detector throwing (e.g. a transient file read
+ * error) must NOT abort the whole cycle and hide every later handler's drift —
+ * it is collected as a blocker so dispatch is still gated, while the remaining
+ * detectors run and their drift gets repaired (graceful degradation, ADR-017).
+ */
 async function detectAllDrift(
   state: GSDState,
   ctx: DriftContext,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   registry: ReadonlyArray<DriftHandler<any>>,
-  pass?: number,
-): Promise<DriftRecord[]> {
-  const collected: DriftRecord[] = [];
+): Promise<DetectionOutcome> {
+  const records: DriftRecord[] = [];
+  const detectBlockers: string[] = [];
   for (const handler of registry) {
     try {
       const detected = await handler.detect(state, ctx);
-      collected.push(...detected);
+      records.push(...detected);
     } catch (cause) {
-      throw new ReconciliationFailedError({
-        failures: [{ drift: { kind: handler.kind } as DriftRecord, cause }],
-        pass,
-      });
+      const message = cause instanceof Error ? cause.message : String(cause);
+      const blocker = `Drift detection failed for "${handler.kind}": ${message}`;
+      logWarning("reconcile", blocker);
+      detectBlockers.push(blocker);
     }
   }
-  return collected;
+  return { records, detectBlockers };
 }

package/src/resources/extensions/gsd/state-reconciliation/spawn-gate.ts

@@ -21,10 +21,10 @@ export interface SpawnGateDeps extends Partial<ReconciliationDeps> {
 }
 
 /**
- * Run reconciliation before spawning workers. Returns ok=true when the run
- * completed without throwing (blockers ride along but don't fail the gate —
- * spawn callers can choose how to handle them). On
- * ReconciliationFailedError, returns ok=false with the error message so the
+ * Run reconciliation before spawning workers. Returns ok=true only when the run
+ * completed without throwing AND surfaced no blockers; any blocker fails the
+ * gate (ok=false, reason carries the first blocker) so callers must not spawn.
+ * On ReconciliationFailedError, returns ok=false with the error message so the
  * caller can surface it to the user without re-throwing.
  *
  * Other unexpected errors propagate; they are not part of the drift

package/src/resources/extensions/gsd/state.ts

@@ -483,7 +483,7 @@ async function buildRegistryAndFindActive(
   let activeMilestoneSlices: SliceRow[] = [];
   let activeMilestoneFound = false;
   let activeMilestoneHasDraft = false;
-  let firstDeferredQueuedShell: { id: string; title: string; deps: string[] } | null = null;
+  let firstDeferredQueuedShell: { id: string; title: string; deps: string[]; hasDraftContext: boolean } | null = null;
 
   for (const m of milestones) {
     if (parkedMilestoneIds.has(m.id)) {
@@ -505,6 +505,8 @@ async function buildRegistryAndFindActive(
     const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
 
     const title = stripMilestonePrefix(m.title) || m.id;
+    const hasContext = !!resolveMilestoneFile(basePath, m.id, "CONTEXT");
+    const hasDraftContext = !hasContext && !!resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
 
     if (!activeMilestoneFound) {
       const deps = m.depends_on;
@@ -515,9 +517,9 @@ async function buildRegistryAndFindActive(
         continue;
       }
 
-      if (m.status === 'queued' && slices.length === 0) {
+      if (m.status === 'queued' && slices.length === 0 && !hasContext) {
         if (!firstDeferredQueuedShell) {
-          firstDeferredQueuedShell = { id: m.id, title, deps };
+          firstDeferredQueuedShell = { id: m.id, title, deps, hasDraftContext };
         }
         registry.push({ id: m.id, title, status: 'pending', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
         continue;
@@ -531,7 +533,7 @@ async function buildRegistryAndFindActive(
         continue;
       }
 
-      if (m.status === 'needs-discussion') activeMilestoneHasDraft = true;
+      if ((m.status === 'needs-discussion' && !hasContext) || hasDraftContext) activeMilestoneHasDraft = true;
 
       activeMilestone = { id: m.id, title };
       activeMilestoneSlices = slices;
@@ -548,6 +550,7 @@ async function buildRegistryAndFindActive(
     activeMilestone = { id: shell.id, title: shell.title };
     activeMilestoneSlices = [];
     activeMilestoneFound = true;
+    if (shell.hasDraftContext) activeMilestoneHasDraft = true;
     const entry = registry.find(e => e.id === shell.id);
     if (entry) entry.status = 'active';
   }

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

@@ -36,6 +36,7 @@ import { registerAutoWorker } from "../db/auto-workers.js";
 import { claimMilestoneLease } from "../db/milestone-leases.js";
 import { recordDispatchClaim, markCanceled } from "../db/unit-dispatches.js";
 import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.js";
+import { SourceObservationStore } from "../source-observations.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -1102,6 +1103,7 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
     currentMilestoneId: "M001",
     currentUnit: null,
     currentUnitRouting: null,
+    sourceObservations: new SourceObservationStore(),
     completedUnits: [],
     resourceVersionOnStart: null,
     lastPromptCharCount: undefined,
@@ -1118,6 +1120,7 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
     unitLifetimeDispatches: new Map<string, number>(),
     unitRecoveryCount: new Map<string, number>(),
     verificationRetryCount: new Map<string, number>(),
+    zeroToolRetryCount: new Map<string, number>(),
     gitService: null,
     lastRequestTimestamp: 0,
     autoStartTime: Date.now(),
@@ -1125,6 +1128,19 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
       newSession: () => Promise.resolve({ cancelled: false }),
       getContextUsage: () => ({ percent: 10, tokens: 1000, limit: 10000 }),
     },
+    setCurrentUnit(this: any, unit: any) {
+      this.currentUnit = unit;
+      this.sourceObservations.beginUnit({
+        unitType: unit.type,
+        unitId: unit.id,
+        startedAt: unit.startedAt,
+        basePath: unit.workspaceRoot ?? this.basePath,
+      });
+    },
+    clearCurrentUnit(this: any) {
+      this.currentUnit = null;
+      this.sourceObservations.clear();
+    },
     clearTimers: () => {},
     ...overrides,
   } as any;
@@ -4693,6 +4709,104 @@ test("runUnitPhase retries 0-tool units with ordinary network-related assistant
   assert.equal(deps.callLog.includes("pauseAuto"), false);
 });
 
+test("runUnitPhase pauses auto-mode when zero-tool-call retry is exhausted", async (t) => {
+  _resetPendingResolve();
+
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-exhausted-"));
+  t.after(() => {
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const ctx = {
+    ...makeMockCtx(),
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+    },
+    sessionManager: {
+      getEntries: () => [],
+    },
+    modelRegistry: {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    },
+  } as any;
+  const pi = {
+    ...makeMockPi(),
+    sendMessage: () => {
+      queueMicrotask(() => resolveAgentEnd(makeEvent([
+        {
+          role: "assistant",
+          content: [
+            { type: "text", text: "Error: I'll investigate the network error handling next." },
+          ],
+        },
+      ])));
+    },
+  } as any;
+  const s = makeLoopSession({
+    basePath,
+    canonicalProjectRoot: basePath,
+    originalBasePath: basePath,
+  });
+  // Pre-seed counter at MAX_ZERO_TOOL_RETRIES so the next zero-tool turn exhausts the cap
+  s.zeroToolRetryCount.set("execute-task/M001/S01/T01", 1);
+
+  const mockLedger = {
+    version: 1,
+    projectStartedAt: Date.now(),
+    units: [] as any[],
+  };
+  const deps = makeMockDeps({
+    closeoutUnit: async () => {
+      mockLedger.units.push({
+        type: "execute-task",
+        id: "M001/S01/T01",
+        startedAt: s.currentUnit?.startedAt ?? Date.now(),
+        toolCalls: 0,
+        assistantMessages: 1,
+        tokens: { input: 100, output: 20, total: 120, cacheRead: 0, cacheWrite: 0 },
+        cost: 0.01,
+      });
+    },
+    getLedger: () => mockLedger,
+  });
+  let seq = 0;
+
+  const result = await runUnitPhase(
+    { ctx, pi, s, deps, prefs: undefined, iteration: 1, flowId: "flow-zero-tool-exhausted", nextSeq: () => ++seq },
+    {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "do work",
+      finalPrompt: "do work",
+      pauseAfterUatDispatch: false,
+      state: {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Milestone" },
+        activeSlice: { id: "S01", title: "Slice" },
+        activeTask: { id: "T01", title: "Task" },
+        registry: [{ id: "M001", title: "Milestone", status: "active" }],
+        recentDecisions: [],
+        blockers: [],
+        nextAction: "",
+        progress: { milestones: { done: 0, total: 1 } },
+        requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+      } as any,
+      mid: "M001",
+      midTitle: "Milestone",
+      isRetry: false,
+      previousTier: undefined,
+    },
+    { recentUnits: [{ key: "execute-task/M001/S01/T01" }], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 },
+  );
+
+  assert.equal(result.action, "break");
+  assert.equal((result as any).reason, "zero-tool-calls-exhausted");
+  assert.equal(deps.callLog.includes("pauseAuto"), true);
+});
+
 test("autoLoop pauses user-driven deep question instead of flagging 0 tool calls", async () => {
   _resetPendingResolve();
 

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

@@ -33,6 +33,7 @@ import {
   selectAndApplyModel,
   ModelPolicyDispatchBlockedError,
   clearToolBaseline,
+  getToolBaselineSnapshot,
 } from "../auto-model-selection.js";
 import { applyModelPolicyFilter } from "../uok/model-policy.js";
 import {
@@ -139,7 +140,7 @@ function makeCtx(
 test("vacuous-truth (a): unit type with empty workflow-required tools → dispatch succeeds", async () => {
   const env = makeTempProject();
   try {
-    // `refine-slice` is not in the getRequiredWorkflowToolsForAutoUnit switch
+    // `rewrite-docs` has no required workflow tools
     // → returns []. Exercises the empty-requiredTools branch in
     // applyModelPolicyFilter (existing test used
     // gate-evaluate which has non-empty required tools and never hit this path).
@@ -161,7 +162,7 @@ test("vacuous-truth (a): unit type with empty workflow-required tools → dispat
     const result = await selectAndApplyModel(
       makeCtx(availableModels),
       pi as any,
-      "refine-slice",
+      "rewrite-docs",
       "x1",
       env.dir,
       undefined,
@@ -308,8 +309,8 @@ test("genuinely-impossible (a): pi-native required tool incompatible with candid
 test("genuinely-impossible (b): cross-provider routing disabled + provider mismatch → typed error", async () => {
   const env = makeTempProject();
   try {
-    // Use plan-slice (workflow-required: ["gsd_plan_slice"]) but pretend no
-    // candidate model can carry it.  The simplest way: provide a model whose
+    // Use plan-slice but pretend no candidate model can carry its required
+    // workflow tools. The simplest way: provide a model whose
     // api is a fictitious "no-tools" string — `filterToolsForProvider` returns
     // every tool as filtered for an unknown api with toolCalling=false, OR we
     // can pick a real api that also denies the tool.  We use an api that
@@ -711,3 +712,64 @@ test("cross-mode (#4965): auto → guided → auto preserves the original auto-e
     env.cleanup();
   }
 });
+
+// ─── 8. Baseline union: MCP tools connected after baseline capture (#477) ─────
+//
+// `getToolBaselineSnapshot` must return the UNION of the frozen WeakMap baseline
+// and the current live tool set.  This ensures:
+//   (a) Provider-narrowed tools (in baseline, dropped from live) are still seen
+//       by transport preflight — the bug-5 fix from #477.
+//   (b) Tools connected after the baseline was captured (e.g. MCP server attached
+//       mid-session) are also visible — so a paused run that resumes after MCP
+//       reconnects clears the transport warning on the first iteration instead of
+//       repeating it indefinitely.
+
+test("baseline union (#477): getToolBaselineSnapshot includes live tools not present in frozen baseline", async () => {
+  const env = makeTempProject();
+  try {
+    const availableModels = [
+      { id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" },
+    ];
+
+    const initialTools = ["bash", "read", "write"];
+    const pi = makeRecordingPi(initialTools);
+    clearToolBaseline(pi as unknown as object);
+
+    // Capture baseline with only native tools (no MCP connected yet).
+    await selectAndApplyModel(
+      makeCtx(availableModels),
+      pi as any,
+      "execute-task",
+      "u1",
+      env.dir,
+      undefined,
+      false,
+      { provider: "anthropic", id: "claude-sonnet-4-6" },
+      undefined,
+      /* isAutoMode */ true,
+    );
+
+    // Simulate: provider narrows tools (Groq cap, hook override, etc.).
+    // The baseline in the WeakMap still has the full initial set.
+    pi.setActiveTools(["bash"]);
+
+    // Simulate: user connects MCP mid-session (after the baseline was captured).
+    const liveTools = pi.getActiveTools().concat(["mcp__gsd-workflow__gsd_uat_exec"]);
+    pi.setActiveTools(liveTools);
+
+    const snapshot = getToolBaselineSnapshot(pi as any);
+
+    // All baseline tools must be present (even the provider-narrowed ones).
+    for (const t of initialTools) {
+      assert.ok(snapshot.includes(t), `snapshot must include baseline tool: ${t}`);
+    }
+    // Newly connected MCP tool must also be present.
+    assert.ok(
+      snapshot.includes("mcp__gsd-workflow__gsd_uat_exec"),
+      "snapshot must include MCP tool connected after baseline capture",
+    );
+  } finally {
+    env.restoreEnv();
+    env.cleanup();
+  }
+});