@opengsd/gsd-pi 1.1.1-dev.75048e7 → 1.1.1-dev.9f86580

package/src/resources/extensions/gsd/context-masker.ts

@@ -5,10 +5,17 @@
  * Reduces context bloat between compactions with zero LLM overhead.
  * Preserves message ordering, roles, and all assistant/user messages.
  *
- * Operates on the pi-ai Message[] format (post-convertToLlm, pre-provider):
+ * Operates on provider payloads after convertToLlm:
+ *
+ * pi-ai Message[] payloads:
  *   - toolResult messages: { role: "toolResult", content: TextContent[] }
  *   - bash results are already converted to: { role: "user", content: [{type:"text",text:"..."}] }
  *     and start with "Ran `" from bashExecutionToText.
+ *
+ * OpenAI/Codex Responses payloads:
+ *   - conversation items live in `input`, not `messages`
+ *   - tool results are { type: "function_call_output", output: string | content[] }
+ *   - bash results are user items with input_text content starting with "Ran `"
  */
 
 interface MaskableMessage {
@@ -20,6 +27,37 @@ interface MaskableMessage {
 
 const MASK_PLACEHOLDER = "[result masked — within summarized history]";
 const MASK_CONTENT_BLOCK = [{ type: "text" as const, text: MASK_PLACEHOLDER }];
+const RESPONSES_MASK_CONTENT_BLOCK = [{ type: "input_text" as const, text: MASK_PLACEHOLDER }];
+const TRUNCATION_MARKER = "\n…[truncated]";
+
+type TextLikeBlock = {
+  type?: string;
+  text?: unknown;
+  [key: string]: unknown;
+};
+
+interface ResponsesInputItem {
+  role?: string;
+  type?: string;
+  content?: unknown;
+  output?: unknown;
+  [key: string]: unknown;
+}
+
+function isTextLikeBlock(block: unknown): block is TextLikeBlock {
+  return Boolean(block && typeof block === "object" && "text" in block);
+}
+
+function firstTextFromContent(content: unknown): string | undefined {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return undefined;
+  const first = content.find(isTextLikeBlock);
+  return typeof first?.text === "string" ? first.text : undefined;
+}
+
+function isBashResultText(text: string | undefined): boolean {
+  return typeof text === "string" && text.startsWith("Ran `");
+}
 
 function findTurnBoundary(messages: MaskableMessage[], keepRecentTurns: number): number {
   let turnsSeen = 0;
@@ -43,10 +81,8 @@ function findTurnBoundary(messages: MaskableMessage[], keepRecentTurns: number):
  * The bashExecutionToText format always starts with "Ran `".
  */
 function isBashResultUserMessage(m: MaskableMessage): boolean {
-  if (m.role !== "user" || !Array.isArray(m.content)) return false;
-  const first = m.content[0];
-  return first && typeof first === "object" && "text" in first &&
-    typeof first.text === "string" && first.text.startsWith("Ran `");
+  if (m.role !== "user") return false;
+  return isBashResultText(firstTextFromContent(m.content));
 }
 
 function isMaskableMessage(m: MaskableMessage): boolean {
@@ -72,3 +108,114 @@ export function createObservationMask(keepRecentTurns: number = 8) {
     });
   };
 }
+
+function isResponsesBashResultUserItem(item: ResponsesInputItem): boolean {
+  if (item.role !== "user") return false;
+  return isBashResultText(firstTextFromContent(item.content));
+}
+
+function findResponsesTurnBoundary(items: ResponsesInputItem[], keepRecentTurns: number): number {
+  let turnsSeen = 0;
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i];
+    if (item.role === "user" && !isResponsesBashResultUserItem(item)) {
+      turnsSeen++;
+      if (turnsSeen >= keepRecentTurns) return i;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Observation masking for OpenAI/Codex Responses API payloads.
+ *
+ * Responses payloads store the conversation under `input` instead of
+ * `messages`, with tool results as `function_call_output` items. Keep this
+ * separate from createObservationMask so each payload shape stays explicit.
+ */
+export function createResponsesInputObservationMask(keepRecentTurns: number = 8) {
+  return (items: ResponsesInputItem[]): ResponsesInputItem[] => {
+    const boundary = findResponsesTurnBoundary(items, keepRecentTurns);
+    if (boundary === 0) return items;
+
+    return items.map((item, i) => {
+      if (i >= boundary) return item;
+      if (item.type === "function_call_output") {
+        return { ...item, output: MASK_PLACEHOLDER };
+      }
+      if (isResponsesBashResultUserItem(item)) {
+        return { ...item, content: RESPONSES_MASK_CONTENT_BLOCK };
+      }
+      return item;
+    });
+  };
+}
+
+function truncateText(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + TRUNCATION_MARKER;
+}
+
+function truncateTextBlocks(content: unknown, maxChars: number): unknown {
+  if (typeof content === "string") {
+    return truncateText(content, maxChars);
+  }
+  if (!Array.isArray(content)) return content;
+
+  let remaining = maxChars;
+  let didTruncate = false;
+  const nextBlocks: unknown[] = [];
+
+  for (const block of content) {
+    if (!isTextLikeBlock(block) || typeof block.text !== "string") {
+      nextBlocks.push(block);
+      continue;
+    }
+
+    if (remaining <= 0) {
+      didTruncate = true;
+      continue;
+    }
+
+    const text = block.text;
+    if (text.length <= remaining) {
+      nextBlocks.push(block);
+      remaining -= text.length;
+      continue;
+    }
+
+    nextBlocks.push({ ...block, text: truncateText(text, remaining) });
+    remaining = 0;
+    didTruncate = true;
+  }
+
+  return didTruncate ? nextBlocks : content;
+}
+
+function normalizedMaxChars(maxChars: number): number {
+  return Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : 800;
+}
+
+export function truncateContextResultMessages(messages: MaskableMessage[], maxChars: number = 800): MaskableMessage[] {
+  const limit = normalizedMaxChars(maxChars);
+  return messages.map((message) => {
+    if (!isMaskableMessage(message)) return message;
+    const content = truncateTextBlocks(message.content, limit);
+    return content === message.content ? message : { ...message, content };
+  });
+}
+
+export function truncateResponsesInputResultItems(items: ResponsesInputItem[], maxChars: number = 800): ResponsesInputItem[] {
+  const limit = normalizedMaxChars(maxChars);
+  return items.map((item) => {
+    if (item.type === "function_call_output") {
+      const output = truncateTextBlocks(item.output, limit);
+      return output === item.output ? item : { ...item, output };
+    }
+    if (isResponsesBashResultUserItem(item)) {
+      const content = truncateTextBlocks(item.content, limit);
+      return content === item.content ? item : { ...item, content };
+    }
+    return item;
+  });
+}

package/src/resources/extensions/gsd/guided-flow.ts

@@ -1158,7 +1158,10 @@ async function dispatchWorkflow(
             ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
             : undefined,
         baseUrl: result.appliedModel?.baseUrl ?? ctx.model?.baseUrl,
-        activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
+        // Guided flow starts the MCP workflow server as part of dispatch, so the
+        // parent session's activeTools doesn't include MCP tools yet. The MCP
+        // launch config check (detectWorkflowMcpLaunchConfig) is the right gate
+        // here — not whether MCP tools are pre-registered in the parent session.
       },
     );
     if (compatibilityError) {

package/src/resources/extensions/gsd/planner-handoff.ts

@@ -0,0 +1,149 @@
+// Project/App: gsd-pi
+// File Purpose: Optional gsd-planner handoff after milestone planning.
+
+import { spawn as spawnChild, type ChildProcess, type SpawnOptions } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { gsdRoot } from "./paths.js";
+
+export const PLANNER_HANDOFF_RULE_NAME = "planning review handoff -> gsd-planner";
+export const GSD_PLANNER_COMMAND = "gsd-planner";
+
+export interface GsdPlannerSpawnPlan {
+  command: string;
+  args: string[];
+  cwd: string;
+}
+
+export interface GsdPlannerLaunchInput {
+  basePath: string;
+  milestoneId?: string | null;
+  extraArgs?: string[];
+}
+
+export type GsdPlannerLaunchResult =
+  | { status: "launched"; plan: GsdPlannerSpawnPlan }
+  | { status: "failed"; plan: GsdPlannerSpawnPlan; error: Error };
+
+type SpawnLike = (
+  command: string,
+  args: readonly string[],
+  options: SpawnOptions,
+) => ChildProcess;
+
+export interface GsdPlannerLaunchDeps {
+  spawn?: SpawnLike;
+}
+
+function handoffDir(basePath: string): string {
+  return join(gsdRoot(basePath), "runtime", "planner-handoffs");
+}
+
+function safeMilestoneFileSegment(milestoneId: string): string {
+  return milestoneId.replace(/[^A-Za-z0-9._-]/g, "_") || "unknown";
+}
+
+function handoffMarkerPath(basePath: string, milestoneId: string): string {
+  return join(handoffDir(basePath), `${safeMilestoneFileSegment(milestoneId)}.json`);
+}
+
+export function hasPlannerHandoffBeenOffered(basePath: string, milestoneId: string): boolean {
+  return existsSync(handoffMarkerPath(basePath, milestoneId));
+}
+
+export function markPlannerHandoffOffered(
+  basePath: string,
+  milestoneId: string,
+  source: "auto" | "command" = "auto",
+): void {
+  mkdirSync(handoffDir(basePath), { recursive: true });
+  writeFileSync(
+    handoffMarkerPath(basePath, milestoneId),
+    JSON.stringify({
+      milestoneId,
+      source,
+      offeredAt: new Date().toISOString(),
+    }, null, 2) + "\n",
+    "utf-8",
+  );
+}
+
+export function buildGsdPlannerSpawnPlan(input: GsdPlannerLaunchInput): GsdPlannerSpawnPlan {
+  const args = ["--project", input.basePath];
+  const milestoneId = input.milestoneId?.trim();
+  if (milestoneId) args.push("--milestone", milestoneId);
+  args.push(...(input.extraArgs ?? []));
+  return {
+    command: GSD_PLANNER_COMMAND,
+    args,
+    cwd: input.basePath,
+  };
+}
+
+function quoteArg(arg: string): string {
+  return /^[A-Za-z0-9_./:=@+-]+$/.test(arg) ? arg : JSON.stringify(arg);
+}
+
+export function formatGsdPlannerCommand(plan: GsdPlannerSpawnPlan): string {
+  return [plan.command, ...plan.args].map(quoteArg).join(" ");
+}
+
+export async function launchGsdPlanner(
+  input: GsdPlannerLaunchInput,
+  deps: GsdPlannerLaunchDeps = {},
+): Promise<GsdPlannerLaunchResult> {
+  const plan = buildGsdPlannerSpawnPlan(input);
+  const spawn = deps.spawn ?? spawnChild;
+
+  let child: ChildProcess;
+  try {
+    child = spawn(plan.command, plan.args, {
+      cwd: plan.cwd,
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+  } catch (err) {
+    return {
+      status: "failed",
+      plan,
+      error: err instanceof Error ? err : new Error(String(err)),
+    };
+  }
+
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (result: GsdPlannerLaunchResult) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    child.once("error", (err) => {
+      settle({
+        status: "failed",
+        plan,
+        error: err instanceof Error ? err : new Error(String(err)),
+      });
+    });
+    child.once("spawn", () => {
+      child.unref();
+      settle({ status: "launched", plan });
+    });
+  });
+}
+
+export function formatPlannerHandoffPauseReason(milestoneId: string): string {
+  return [
+    `Milestone ${milestoneId} is planned. Review or customize the plan before implementation if needed.`,
+    `Run /gsd planner to launch ${GSD_PLANNER_COMMAND}, or run /gsd auto to continue without planner changes.`,
+  ].join(" ");
+}
+
+export function formatPlannerLaunchUnavailable(plan: GsdPlannerSpawnPlan, error: Error): string {
+  return [
+    `Could not launch ${GSD_PLANNER_COMMAND}: ${error.message}`,
+    `Install ${GSD_PLANNER_COMMAND} or run it manually: ${formatGsdPlannerCommand(plan)}`,
+  ].join("\n");
+}

package/src/resources/extensions/gsd/preferences-models.ts

@@ -372,6 +372,7 @@ export function resolveAutoSupervisorConfig(): AutoSupervisorConfig {
     soft_timeout_minutes: configured.soft_timeout_minutes ?? 20,
     idle_timeout_minutes: configured.idle_timeout_minutes ?? 10,
     hard_timeout_minutes: configured.hard_timeout_minutes ?? 30,
+    stalled_tool_timeout_minutes: configured.stalled_tool_timeout_minutes ?? 5,
     ...(configured.model ? { model: configured.model } : {}),
   };
 }

package/src/resources/extensions/gsd/preferences-types.ts

@@ -256,6 +256,14 @@ export interface AutoSupervisorConfig {
   soft_timeout_minutes?: number;
   idle_timeout_minutes?: number;
   hard_timeout_minutes?: number;
+  /**
+   * Dedicated budget for a single in-flight tool call before it is treated as
+   * hung. Distinct from `idle_timeout_minutes`: a genuinely stuck tool should
+   * be recovered in minutes rather than waiting out the full idle window. A
+   * long-but-progressing session is not idle, so it must not share the hung-tool
+   * threshold.
+   */
+  stalled_tool_timeout_minutes?: number;
 }
 
 export interface RemoteQuestionsConfig {

package/src/resources/extensions/gsd/prompts/plan-milestone.md

@@ -14,7 +14,7 @@ All relevant context is preloaded below. Start immediately without re-reading th
 
 ## Already Planned? Soft Brake
 
-If `{{outputPath}}` exists with at least one slice line (e.g. `- [ ] **S01:`) AND `gsd_query` reports slice rows for this milestone, a prior `gsd_plan_milestone` call already persisted the plan. Do **not** re-call it; its UPSERT could overwrite existing planning. Skip to the ready phrase.
+If `{{outputPath}}` exists with at least one slice line (e.g. `- [ ] **S01:`) AND `gsd_milestone_status` reports slice rows for this milestone, a prior `gsd_plan_milestone` call already persisted the plan. Do **not** re-call it; its UPSERT could overwrite existing planning. Skip to the ready phrase.
 
 If only the file or only DB rows exist, the prior write was incomplete; plan normally so the tool reconciles both.
 

package/src/resources/extensions/gsd/prompts/run-uat.md

@@ -27,7 +27,7 @@ You are the UAT runner. Execute every check defined in `{{uatPath}}` as deeply a
 ### Automation rules by mode
 
 - `artifact-driven` — verify with shell commands, scripts, file reads, and artifact structure checks.
-- `browser-executable` — use gsd-browser tools to navigate to the target URL and verify expected behavior. Prefer `mcp__gsd-browser__browser_*` tools when namespaced, or direct `browser_*` tools when surfaced without a namespace. Capture screenshots as evidence. Record pass/fail with specific assertions.
+- `browser-executable` — use browser tools to navigate to the target URL and verify expected behavior. Prefer direct `browser_*` tools when available. Capture screenshots as evidence. Record pass/fail with specific assertions.
 - `runtime-executable` — execute the specified command or script. Capture stdout/stderr as evidence. Record pass/fail based on exit code and output.
 - `live-runtime` — exercise the real runtime path. Start or connect to the app/service if needed, use browser/runtime/network checks, and verify observable behavior.
 - `mixed` — run all automatable artifact-driven and live-runtime checks. Separate any remaining human-only checks explicitly.
@@ -48,7 +48,7 @@ Choose the lightest tool that proves the check honestly:
 - Run `node` / other script invocations
 - Read files and verify their contents
 - Check that expected artifacts exist and have correct structure
-- For live/runtime/UI checks, exercise the real flow with gsd-browser when applicable and inspect runtime/network/console state
+- For live/runtime/UI checks, exercise the real flow with browser tools when applicable and inspect runtime/network/console state
 - When a check cannot be honestly automated, gather the best objective evidence you can and mark it `NEEDS-HUMAN`
 
 For each check, record:

package/src/resources/extensions/gsd/prompts/system.md

@@ -118,7 +118,7 @@ Templates are in `{{templatesDir}}`.
 
 **Secrets:** Use `secure_env_collect`. Never ask the user to edit `.env` files or paste secrets.
 
-**Browser verification:** Verify frontend work against a running app with gsd-browser by default. Use `browser_find`/`browser_snapshot_refs` for discovery, refs/selectors -> `browser_batch` for actions, `browser_assert` for verification, and `browser_diff` -> console/network logs -> full inspection as last resort. If tools are MCP-namespaced, prefer `mcp__gsd-browser__browser_*`. Retry only with a new hypothesis.
+**Browser verification:** Verify frontend work against a running app with browser tools by default. Use `browser_find`/`browser_snapshot_refs` for discovery, refs/selectors -> `browser_batch` for actions, `browser_assert` for verification, and `browser_diff` -> console/network logs -> full inspection as last resort. If browser tools are MCP-namespaced, use that host-provided browser surface. Retry only with a new hypothesis.
 
 **Database:** Never query `.gsd/gsd.db` directly via `sqlite3`, `better-sqlite3`, or `node -e require('better-sqlite3')`; the engine owns a single-writer WAL connection. Use `gsd_milestone_status`, `gsd_journal_query`, or other `gsd_*` tools.
 

package/src/resources/extensions/gsd/skill-manifest.ts

@@ -117,6 +117,18 @@ const UNIT_TYPE_SKILL_MANIFEST: Record<string, string[]> = {
     "review",
     "accessibility",
   ],
+  // Slice closeout — the "closer" role: verify assembled task work, write the
+  // downstream-ready summary + UAT, optionally drive reviewer/security/tester
+  // subagents. Predictable skill set, mirrors `complete-milestone`.
+  "complete-slice": [
+    "verify-before-complete",
+    "test",
+    "review",
+    "security-review",
+    "write-docs",
+    "observability",
+    "handoff",
+  ],
   // `execute-task` intentionally omitted — implementation hot path covers a
   // wide surface of technologies; wildcard fallback preserves today's
   // behavior until per-task skill hints can be derived from task-plan

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

@@ -1118,6 +1118,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(),
@@ -4693,6 +4694,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();
+  }
+});

package/src/resources/extensions/gsd/tests/auto-supervisor.test.mjs

@@ -20,6 +20,10 @@ test('resolveAutoSupervisorConfig provides safe timeout defaults', () => {
     assert.equal(supervisor.soft_timeout_minutes, 20);
     assert.equal(supervisor.idle_timeout_minutes, 10);
     assert.equal(supervisor.hard_timeout_minutes, 30);
+    // A single hung tool gets its own short budget, well below the idle window,
+    // so a genuinely stuck tool is recovered in minutes instead of waiting out
+    // the full idle timeout.
+    assert.equal(supervisor.stalled_tool_timeout_minutes, 5);
   } finally {
     if (previousGsdHome === undefined) {
       delete process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/bundled-skill-triggers.test.ts

@@ -76,3 +76,12 @@ test('BUNDLED_SKILL_TRIGGERS: skill ids are unique', () => {
     seen.add(skill);
   }
 });
+
+test('BUNDLED_SKILL_TRIGGERS: gsd-browser and agent-browser stay distinct', () => {
+  const gsdBrowser = BUNDLED_SKILL_TRIGGERS.find(entry => entry.skill === 'gsd-browser');
+  const agentBrowser = BUNDLED_SKILL_TRIGGERS.find(entry => entry.skill === 'agent-browser');
+
+  assert.ok(gsdBrowser, 'gsd-browser trigger should be registered');
+  assert.ok(agentBrowser, 'agent-browser trigger should be registered');
+  assert.notStrictEqual(gsdBrowser.trigger, agentBrowser.trigger);
+});