@opengsd/gsd-pi 1.0.2-dev.e70300c → 1.0.2-dev.fb7ddf1

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

@@ -135,6 +135,8 @@ import {
   captureAvailableSkills,
   resetSkillTelemetry,
 } from "./skill-telemetry.js";
+import { getInstalledSkillNames } from "./skills.js";
+import { effectiveSkillNamesForUnit } from "./skill-scope.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { deactivateGSD } from "../shared/gsd-phase-state.js";
 import {
@@ -216,7 +218,14 @@ import {
   deregisterSigtermHandler as _deregisterSigtermHandler,
   detectWorkingTreeActivity,
 } from "./auto-supervisor.js";
-import { isDbAvailable, getMilestone, getMilestoneSlices } from "./gsd-db.js";
+import {
+  isDbAvailable,
+  getMilestone,
+  getMilestoneSlices,
+  getSlice,
+  getTask,
+  refreshOpenDatabaseFromDisk,
+} from "./gsd-db.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { countPendingCaptures } from "./captures.js";
@@ -2068,6 +2077,25 @@ export function createWiredDispatchAdapter(
   dispatchBasePath: string,
   session?: AutoSession,
 ): DispatchAdapter {
+  function getAlreadyClosedDispatchReason(unitType: string, unitId: string): string | null {
+    if (!isDbAvailable()) return null;
+    refreshOpenDatabaseFromDisk();
+    const { milestone, slice, task } = parseUnitId(unitId);
+    if (unitType === "execute-task" && milestone && slice && task) {
+      const row = getTask(milestone, slice, task);
+      return row && isClosedStatus(row.status)
+        ? `execute-task ${unitId} is already ${row.status}`
+        : null;
+    }
+    if (unitType === "complete-slice" && milestone && slice) {
+      const row = getSlice(milestone, slice);
+      return row && isClosedStatus(row.status)
+        ? `complete-slice ${unitId} is already ${row.status}`
+        : null;
+    }
+    return null;
+  }
+
   return {
     async decideNextUnit(input) {
       const state = input.stateSnapshot;
@@ -2107,6 +2135,15 @@ export function createWiredDispatchAdapter(
       const pendingRetry = session?.pendingVerificationRetryDispatch;
       if (session && pendingRetry) {
         session.pendingVerificationRetryDispatch = null;
+        const alreadyClosedReason = getAlreadyClosedDispatchReason(
+          pendingRetry.unitType,
+          pendingRetry.unitId,
+        );
+        if (alreadyClosedReason) {
+          session.pendingOrchestrationDispatch = null;
+          session.pendingVerificationRetry = null;
+          return { kind: "skipped", reason: alreadyClosedReason };
+        }
         session.pendingOrchestrationDispatch = pendingRetry;
         return {
           unitType: pendingRetry.unitType,
@@ -2144,6 +2181,14 @@ export function createWiredDispatchAdapter(
           reason: action.matchedRule ?? "dispatch-skip",
         };
       }
+      const alreadyClosedReason = getAlreadyClosedDispatchReason(action.unitType, action.unitId);
+      if (alreadyClosedReason) {
+        if (session) {
+          session.pendingOrchestrationDispatch = null;
+          session.pendingVerificationRetry = null;
+        }
+        return { kind: "skipped", reason: alreadyClosedReason };
+      }
       if (session) {
         const pending: PendingOrchestrationDispatch = {
           unitType: action.unitType,
@@ -2562,7 +2607,10 @@ function buildLoopDeps(pi: ExtensionAPI): LoopDeps {
     autoCommitUnit,
     recordOutcome,
     writeLock,
-    captureAvailableSkills,
+    captureAvailableSkills: () => {
+      const unitType = s.currentUnit?.type;
+      captureAvailableSkills(effectiveSkillNamesForUnit(unitType, getInstalledSkillNames()));
+    },
     ensurePreconditions,
     updateSliceProgressCache,
 

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -715,8 +715,9 @@ export function registerDbTools(pi: ExtensionAPI): void {
     promptSnippet: "Complete a GSD task (DB write + summary render + checkbox toggle)",
     promptGuidelines: [
       "Use gsd_task_complete (or gsd_complete_task) when a task is finished and needs to be recorded.",
-      "All string fields are required. verificationEvidence is an array of objects with command, exitCode, verdict, durationMs.",
-      "The tool validates required fields and returns an error message if any are missing.",
+      "Include verification whenever possible. If verification is omitted, the executor derives it from verificationEvidence when possible.",
+      "verificationEvidence is an array of objects with command, exitCode, verdict, durationMs.",
+      "The tool validates required fields and returns an error message if verification cannot be derived.",
       "On success, returns the summaryPath where the SUMMARY.md was written.",
       "Idempotent — calling with the same params twice will upsert (INSERT OR REPLACE) without error.",
     ],
@@ -727,7 +728,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
       milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
       oneLiner: Type.String({ description: "One-line summary of what was accomplished" }),
       narrative: Type.String({ description: "Detailed narrative of what happened during the task" }),
-      verification: Type.String({ description: "What was verified and how — commands run, tests passed, behavior confirmed" }),
+      verification: Type.Optional(Type.String({ description: "What was verified and how — commands run, tests passed, behavior confirmed. If omitted, derived from verificationEvidence when possible." })),
       // ── Enrichment metadata (optional — defaults to empty) ────────────
       deviations: Type.Optional(Type.String({ description: "Deviations from the task plan, or 'None.'" })),
       knownIssues: Type.Optional(Type.String({ description: "Known issues discovered but not fixed, or 'None.'" })),

package/src/resources/extensions/gsd/bootstrap/exec-tools.ts

@@ -43,11 +43,16 @@ export function registerExecTools(pi: ExtensionAPI): void {
       "Need persisted output? Read the stdout_path returned in details (file on local disk).",
     ],
     parameters: Type.Object({
-      runtime: Type.Union(
-        [Type.Literal("bash"), Type.Literal("node"), Type.Literal("python")],
-        { description: "Interpreter: bash (-c), node (-e), or python3 (-c)." },
+      runtime: Type.Optional(
+        Type.String({
+          description:
+            "Optional interpreter. Defaults to bash. Supported: bash, node, python; sh/shell, js/nodejs, and py/python3 aliases are accepted.",
+        }),
       ),
-      script: Type.String({ description: "Script body. Keep output small (log the finding, not the data)." }),
+      script: Type.Optional(Type.String({ description: "Script body. Keep output small (log the finding, not the data)." })),
+      command: Type.Optional(Type.String({ description: "Alias for script; defaults to bash when runtime is omitted." })),
+      cmd: Type.Optional(Type.String({ description: "Short alias for script." })),
+      code: Type.Optional(Type.String({ description: "Alias for script, useful for node/python snippets." })),
       purpose: Type.Optional(Type.String({ description: "Short label recorded in meta.json for later review." })),
       timeout_ms: Type.Optional(
         Type.Number({

package/src/resources/extensions/gsd/bootstrap/register-extension.ts

@@ -27,6 +27,32 @@ import { initCmuxEventListeners } from "../../cmux/index.js";
 
 export { writeCrashLog } from "./crash-log.js";
 
+// Pipe-closed storm guard. #99/#101 stopped EPIPE from flooding ~/.gsd/crash,
+// but a persistently-broken output pipe whose `destroyed`/`writableEnded` flags
+// never flip is still swallowed on every write — a tight, progress-free CPU
+// spin. If the pipe-closed error fires in a tight loop the pipe is gone for
+// good; exit cleanly instead.
+const EPIPE_STORM_THRESHOLD = 100;
+const EPIPE_STORM_WINDOW_MS = 10_000;
+let epipeCount = 0;
+let epipeWindowStart = 0;
+
+/** Write to stderr without ever re-throwing — stderr can EPIPE too, which would
+ *  re-enter this handler and re-loop. */
+function safeStderr(msg: string): void {
+  try {
+    process.stderr.write(msg);
+  } catch { /* stderr is also broken; nothing we can do */ }
+}
+
+/** A peer closing the read end of a pipe mid-write surfaces differently per
+ *  platform: POSIX throws `EPIPE`; Windows throws `Error: write EOF` (or
+ *  `read EOF`) with no `code` set, from node:internal/stream_base_commons.
+ *  Both are the same logical condition and must be treated as recoverable —
+ *  otherwise the Windows EOF variant escapes to the uncaught-exception path
+ *  and crashes auto-mode workers mid-iteration (#181). ECONNRESET is NOT
+ *  included here: it commonly comes from network sockets (#182 follow-up) and
+ *  is a real error that should surface rather than be silently swallowed. */
 function isPipeClosedError(err: Error): boolean {
   const errno = (err as NodeJS.ErrnoException).code;
   if (errno === "EPIPE") return true;
@@ -36,7 +62,7 @@ function isPipeClosedError(err: Error): boolean {
 
 export function handleRecoverableExtensionProcessError(err: Error): boolean {
   if (err.message.includes("ProcessTransport is not ready for writing")) {
-    process.stderr.write(`[gsd] swallowed dead transport control write: ${err.message}\n`);
+    safeStderr(`[gsd] swallowed dead transport control write: ${err.message}\n`);
     return true;
   }
   if (isPipeClosedError(err)) {
@@ -46,7 +72,18 @@ export function handleRecoverableExtensionProcessError(err: Error): boolean {
     if (stdoutGone) {
       process.exit(0);
     }
-    process.stderr.write(
+    const now = Date.now();
+    if (now - epipeWindowStart > EPIPE_STORM_WINDOW_MS) {
+      epipeWindowStart = now;
+      epipeCount = 0;
+    }
+    if (++epipeCount > EPIPE_STORM_THRESHOLD) {
+      safeStderr(
+        `[gsd] ${tag} storm (${epipeCount} within ${EPIPE_STORM_WINDOW_MS}ms) — output pipe is gone; exiting.\n`,
+      );
+      process.exit(0);
+    }
+    safeStderr(
       `[gsd] swallowed ${tag} (syscall=${(err as NodeJS.ErrnoException).syscall ?? "?"})\n`,
     );
     return true;
@@ -54,18 +91,18 @@ export function handleRecoverableExtensionProcessError(err: Error): boolean {
   if ((err as NodeJS.ErrnoException).code === "EIO") {
     const syscall = (err as NodeJS.ErrnoException).syscall;
     if (syscall === "read") {
-      process.stderr.write(`[gsd] EIO: ${err.message}\n`);
+      safeStderr(`[gsd] EIO: ${err.message}\n`);
       return true;
     }
   }
   if ((err as NodeJS.ErrnoException).code === "ENOENT") {
     const syscall = (err as NodeJS.ErrnoException).syscall;
     if (syscall?.startsWith("spawn")) {
-      process.stderr.write(`[gsd] spawn ENOENT: ${(err as any).path ?? "unknown"} — command not found\n`);
+      safeStderr(`[gsd] spawn ENOENT: ${(err as any).path ?? "unknown"} — command not found\n`);
       return true;
     }
     if (syscall === "uv_cwd") {
-      process.stderr.write(`[gsd] ENOENT (${syscall}): ${err.message}\n`);
+      safeStderr(`[gsd] ENOENT (${syscall}): ${err.message}\n`);
       return true;
     }
   }

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -33,6 +33,7 @@ import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { extractSubagentAgentClasses } from "./subagent-input.js";
 import { approvalGateIdForUnit, isExplicitApprovalResponse, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.js";
 import { resolveSkillManifest } from "../skill-manifest.js";
+import { applyUnitSkillVisibility, unitHasSkillManifest } from "../skill-scope.js";
 import { getGuidedUnitContext } from "../guided-unit-context.js";
 import { registerPlanMilestoneSchemaRecovery } from "./plan-milestone-schema-recovery.js";
 
@@ -146,6 +147,53 @@ function withPreservedShimTools(toolNames: readonly string[]): string[] {
   return [...new Set([...toolNames, ...ALWAYS_PRESERVED_SHIM_TOOL_NAMES])];
 }
 
+/**
+ * Backwards-compatibility workflow tool aliases (each forwards to a canonical
+ * twin). Mirrors WORKFLOW_TOOL_CONTRACTS[].aliases in @opengsd/contracts. These
+ * stay registered/callable but are dropped from the model-advertised tool set
+ * (~5.6K tokens/turn of duplicate schemas) — the canonical name is always
+ * advertised, and prompts/scoped tool sets already use canonical names.
+ */
+const WORKFLOW_ALIAS_TOOL_NAMES = new Set<string>([
+  "gsd_save_decision",
+  "gsd_update_requirement",
+  "gsd_save_requirement",
+  "gsd_generate_milestone_id",
+  "gsd_task_plan",
+  "gsd_slice_replan",
+  "gsd_complete_slice",
+  "gsd_milestone_complete",
+  "gsd_milestone_validate",
+  "gsd_roadmap_reassess",
+  "gsd_complete_task",
+  "gsd_reopen_task",
+  "gsd_reopen_slice",
+  "gsd_reopen_milestone",
+]);
+
+/** True when a (possibly mcp-scoped) tool name is a workflow alias. */
+function isWorkflowAliasTool(toolName: string): boolean {
+  return WORKFLOW_ALIAS_TOOL_NAMES.has(canonicalToolName(toolName));
+}
+
+/** True for the ~58 Playwright browser tools (browser_navigate, browser_click, …). */
+function isBrowserTool(toolName: string): boolean {
+  return canonicalToolName(toolName).startsWith("browser_");
+}
+
+/**
+ * True when any message in the request is driven by a GSD workflow command
+ * (customType starting "gsd-"). Plain interactive chat has none, and is scoped
+ * to the minimal GSD tool surface by default.
+ */
+export function requestHasGsdCustomType(
+  requestCustomMessages: readonly { customType?: string }[] | undefined,
+): boolean {
+  return (requestCustomMessages ?? []).some(
+    (message) => typeof message.customType === "string" && message.customType.startsWith("gsd-"),
+  );
+}
+
 const RUN_UAT_BROWSER_TOOL_NAMES = [
   "browser_navigate",
   "browser_click",
@@ -178,6 +226,7 @@ const AUTO_UNIT_SCOPED_TOOLS: Record<string, readonly string[]> = {
     "gsd_plan_milestone",
     "gsd_milestone_generate_id",
   ],
+  "discuss-slice": ["gsd_summary_save", "gsd_decision_save"],
   "validate-milestone": ["gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],
   "complete-milestone": ["gsd_complete_milestone", "subagent"],
   "research-slice": ["gsd_summary_save", "gsd_decision_save"],
@@ -213,7 +262,7 @@ function isGsdManagedTool(name: string): boolean {
  *
  * MCP-scoped names follow `mcp__<namespace>__<toolname>`.
  * Example: if `requestedToolNames` contains `gsd_exec` and `activeToolNames` contains
- * `mcp__gsd-workflow__gsd_exec`, the MCP-scoped active name is included in the result.
+ * `mcp__custom-workflow__gsd_exec`, the MCP-scoped active name is included in the result.
  *
  * Returns deduplicated active tool names that satisfy the requested base names.
  */
@@ -313,6 +362,16 @@ function isGeneralGsdToolScopingRequested(): boolean {
   return process.env.PI_GSD_MINIMAL_TOOLS === "1";
 }
 
+/**
+ * Whether the ~58-tool Playwright browser surface (~7K tokens) should be
+ * advertised in interactive sessions. Off by default — browser tools stay
+ * registered/callable (so auto run-uat, which scopes them in explicitly, is
+ * unaffected) but are dropped from the model-facing surface until opted in.
+ */
+function isBrowserToolSurfaceRequested(): boolean {
+  return process.env.PI_GSD_BROWSER_TOOLS === "1";
+}
+
 export interface ScopedGsdWorkflowState {
   tools: string[] | null;
   visibleSkills: string[] | undefined;
@@ -357,8 +416,7 @@ export function scopeGsdWorkflowToolsForDispatch(
     ? buildMinimalAutoGsdToolSet(current, unitType, registeredToolNames)
     : buildMinimalGsdWorkflowToolSet(current, registeredToolNames);
   const toolsChanged = !(scoped.length === current.length && scoped.every((name, index) => name === current[index]));
-  const skillManifest = resolveSkillManifest(unitType);
-  const canScopeSkills = skillManifest !== null && pi.getVisibleSkills && pi.setVisibleSkills;
+  const canScopeSkills = unitHasSkillManifest(unitType) && pi.getVisibleSkills && pi.setVisibleSkills;
   if (!toolsChanged && !canScopeSkills) {
     return null;
   }
@@ -366,8 +424,8 @@ export function scopeGsdWorkflowToolsForDispatch(
     pi.setActiveTools(scoped);
   }
   const visibleSkills = canScopeSkills ? pi.getVisibleSkills!() : undefined;
-  if (canScopeSkills) {
-    pi.setVisibleSkills!(skillManifest);
+  if (canScopeSkills && pi.setVisibleSkills) {
+    applyUnitSkillVisibility({ setVisibleSkills: pi.setVisibleSkills }, unitType);
   }
   return {
     tools: toolsChanged ? current : null,
@@ -507,6 +565,21 @@ function initSessionNotifications(ctx: ExtensionContext): void {
   initNotificationWidget(ctx);
 }
 
+async function prepareWorkflowMcpForHookContext(
+  ctx: ExtensionContext,
+  basePath: string,
+): Promise<void> {
+  // Skip MCP auto-prep when running inside an auto-worktree. The worktree
+  // already has .mcp.json from createAutoWorktree, and re-running the writer
+  // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
+  // CLI path resolution), dirtying the tree and breaking the milestone merge.
+  const { isInAutoWorktree } = await import("../auto-worktree.js");
+  if (isInAutoWorktree(basePath)) return;
+
+  const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+  prepareWorkflowMcpForProject(ctx, basePath);
+}
+
 export function registerHooks(
   pi: ExtensionAPI,
   ecosystemHandlers: GSDEcosystemBeforeAgentStartHandler[],
@@ -532,12 +605,7 @@ export function registerHooks(
     await syncServiceTierStatus(ctx);
     await applyDisabledModelProviderPolicy(ctx);
     await applyCompactionThresholdOverride(ctx);
-    // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
-    const { isInAutoWorktree } = await import("../auto-worktree.js");
-    if (!isInAutoWorktree(basePath)) {
-      const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-      prepareWorkflowMcpForProject(ctx, basePath);
-    }
+    await prepareWorkflowMcpForHookContext(ctx, basePath);
 
     // Apply show_token_cost preference (#1515)
     try {
@@ -563,15 +631,7 @@ export function registerHooks(
     await syncServiceTierStatus(ctx);
     await applyDisabledModelProviderPolicy(ctx);
     await applyCompactionThresholdOverride(ctx);
-    // Skip MCP auto-prep when running inside an auto-worktree. The worktree
-    // already has .mcp.json from createAutoWorktree, and re-running the writer
-    // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
-    // CLI path resolution), dirtying the tree and breaking the milestone merge.
-    const { isInAutoWorktree } = await import("../auto-worktree.js");
-    if (!isInAutoWorktree(basePath)) {
-      const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-      prepareWorkflowMcpForProject(ctx, basePath);
-    }
+    await prepareWorkflowMcpForHookContext(ctx, basePath);
     await loadToolApiKeysForSession();
     if (!isAutoActive()) {
       ctx.ui.setWidget("gsd-progress", undefined);
@@ -608,9 +668,26 @@ export function registerHooks(
     }
     clearDeferredApprovalGate(beforeAgentBasePath);
 
+    // session_start can fire before the active provider has settled. By
+    // before_agent_start, Claude Code CLI sessions should get the same
+    // project MCP config that /gsd mcp init would write.
+    await prepareWorkflowMcpForHookContext(ctx, beforeAgentBasePath);
+
+    let systemPrompt = event.systemPrompt;
+    const { appendDiscoveredSkillsFallback, hasSkillSnapshot, refreshCatalogForNewSkills } = await import("../skill-discovery.js");
+    if (hasSkillSnapshot()) {
+      const loadedSkills = await refreshCatalogForNewSkills({
+        reload: () => (ctx as ExtensionContext & { reload: () => Promise<void> }).reload(),
+        notify: (message, level) => ctx.ui.notify(message, level),
+      });
+      if (loadedSkills.length > 0) {
+        systemPrompt = appendDiscoveredSkillsFallback(ctx.getSystemPrompt(), loadedSkills);
+      }
+    }
+
     // GSD's own context injection (existing behavior — unchanged).
     const { buildBeforeAgentStartResult } = await import("./system-context.js");
-    const gsdResult = await buildBeforeAgentStartResult(event, ctx);
+    const gsdResult = await buildBeforeAgentStartResult({ ...event, systemPrompt }, ctx);
 
     // Refresh the snapshot used by ecosystem getPhase()/getActiveUnit().
     // deriveState has its own ~100ms cache so this is cheap on repeat calls.
@@ -623,7 +700,7 @@ export function registerHooks(
 
     // Chain ecosystem handlers using pi's runner.ts chaining protocol:
     // each handler sees the systemPrompt mutated by prior handlers.
-    let currentSystemPrompt = gsdResult?.systemPrompt ?? event.systemPrompt;
+    let currentSystemPrompt = gsdResult?.systemPrompt ?? systemPrompt;
     // `any` because pi's BeforeAgentStartEventResult.message uses an internal
     // CustomMessage type that's not re-exported (see ecosystem/gsd-extension-api.ts).
     let lastMessage: any = gsdResult?.message;
@@ -1307,9 +1384,23 @@ export function registerHooks(
   // Extensions can override tool set after model selection by returning { toolNames: [...] }
   // Return undefined to let the built-in provider compatibility filtering proceed.
   pi.on("adjust_tool_set", async (event) => {
-    if (isFullGsdToolSurfaceRequested()) return undefined;
     const removed = new Set(event.filteredTools);
-    const providerCompatible = event.activeToolNames.filter((name) => !removed.has(name));
+    const compatible = event.activeToolNames.filter((name) => !removed.has(name));
+    // Always drop backwards-compatibility workflow aliases from the advertised
+    // surface; they remain registered/callable but never cost schema tokens.
+    // Drop the heavy browser surface too unless explicitly opted in — it stays
+    // registered, so auto run-uat (which scopes browser tools in from the full
+    // registry) still works. Both filters are skipped under full-tools mode.
+    const fullToolsRequested = isFullGsdToolSurfaceRequested();
+    const dropAliases = !fullToolsRequested;
+    const dropBrowser = !fullToolsRequested && !isBrowserToolSurfaceRequested();
+    const providerCompatible = compatible.filter(
+      (name) => !(dropAliases && isWorkflowAliasTool(name)) && !(dropBrowser && isBrowserTool(name)),
+    );
+    const surfaceReduced = providerCompatible.length !== compatible.length;
+    if (fullToolsRequested) {
+      return surfaceReduced ? { toolNames: providerCompatible } : undefined;
+    }
     const registeredToolNames = resolveRegisteredToolNames(pi, event.activeToolNames);
     const guidedUnit = getGuidedUnitContext();
     const requestScoped = buildRequestScopedGsdToolSet(
@@ -1334,6 +1425,14 @@ export function registerHooks(
     if (isGeneralGsdToolScopingRequested()) {
       return { toolNames: buildMinimalGsdToolSet(providerCompatible) };
     }
-    return undefined;
+    // Plain interactive chat (no GSD workflow command driving this request)
+    // never needs the full ~50-tool workflow surface — scope it to the minimal
+    // GSD set by default (all non-GSD tools are preserved). Requests carrying a
+    // gsd-* customType keep their existing surface, so no command is stranded.
+    // Set PI_GSD_FULL_TOOLS=1 (handled above) to restore the full surface.
+    if (!requestHasGsdCustomType(event.requestCustomMessages)) {
+      return { toolNames: buildMinimalGsdToolSet(providerCompatible) };
+    }
+    return surfaceReduced ? { toolNames: providerCompatible } : undefined;
   });
 }

package/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -11,11 +11,9 @@ import { loadPrompt, getTemplatesDir } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
 import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
 import { resolveModelWithFallbacksForUnit } from "../preferences-models.js";
-import { resolveSkillReference } from "../preferences-skills.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { extractIntroAndRules } from "../knowledge-parser.js";
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
-import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
 import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
 import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-session-state.js";
 import { deriveState } from "../state.js";
@@ -72,20 +70,6 @@ export const BUNDLED_SKILL_TRIGGERS: Array<{ trigger: string; skill: string }> =
   { trigger: "Deep code optimization audit — perf anti-patterns, memory leaks, algorithmic complexity, bundle size, I/O, caching, dead code (parallel pattern-based hunt)", skill: "code-optimizer" },
 ];
 
-function buildBundledSkillsTable(): string {
-  const cwd = process.cwd();
-  const rows: string[] = [];
-  for (const { trigger, skill } of BUNDLED_SKILL_TRIGGERS) {
-    const resolution = resolveSkillReference(skill, cwd);
-    if (resolution.method === "unresolved") continue; // skill not installed — omit from prompt
-    rows.push(`| ${trigger} | \`${resolution.resolvedPath}\` |`);
-  }
-  if (rows.length === 0) {
-    return "*No bundled skills found. Install or sync skills to `~/.gsd/agent/skills/`, `~/.agents/skills/`, or `~/.claude/skills/`.*";
-  }
-  return `| Trigger | Skill to load |\n|---|---|\n${rows.join("\n")}`;
-}
-
 function warnDeprecatedAgentInstructions(): void {
   const paths = [
     join(gsdHome(), "agent-instructions.md"),
@@ -110,7 +94,6 @@ export async function buildBeforeAgentStartResult(
 
   const stopContextTimer = debugTime("context-inject");
   const systemContent = loadPrompt("system", {
-    bundledSkillsTable: buildBundledSkillsTable(),
     templatesDir: getTemplatesDir(),
     shortcutDashboard: formatShortcut("Ctrl+Alt+G"),
     shortcutShell: formatShortcut("Ctrl+Alt+B"),
@@ -141,7 +124,7 @@ export async function buildBeforeAgentStartResult(
   if (loadedPreferences) {
     const cwd = basePath;
     const report = resolveAllSkillReferences(loadedPreferences.preferences, cwd);
-    preferenceBlock = `\n\n${renderPreferencesForSystemPrompt(loadedPreferences.preferences, report.resolutions)}`;
+    preferenceBlock = `\n\n${renderPreferencesForSystemPrompt(loadedPreferences.preferences, report.resolutions, { includeResolvedPaths: false })}`;
     if (report.warnings.length > 0) {
       ctx.ui.notify(
         `GSD skill preferences: ${report.warnings.length} unresolved skill${report.warnings.length === 1 ? "" : "s"}: ${report.warnings.join(", ")}`,
@@ -201,14 +184,6 @@ export async function buildBeforeAgentStartResult(
     );
   }
 
-  let newSkillsBlock = "";
-  if (hasSkillSnapshot()) {
-    const newSkills = detectNewSkills();
-    if (newSkills.length > 0) {
-      newSkillsBlock = formatSkillsXml(newSkills);
-    }
-  }
-
   let codebaseBlock = "";
   try {
     const codebaseOptions = loadedPreferences?.preferences?.codebase
@@ -264,13 +239,13 @@ export async function buildBeforeAgentStartResult(
   // Keeping it out of `fullSystem` preserves provider prompt-cache stability
   // for the static system/tool prefix. The dynamic memory block rides the
   // volatile context message instead. (#5019)
-  const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${newSkillsBlock}${worktreeBlock}${subagentModelBlock}`;
+  const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${worktreeBlock}${subagentModelBlock}`;
 
   stopContextTimer({
     systemPromptSize: fullSystem.length,
     injectionSize: injection?.length ?? forensicsInjection?.length ?? 0,
     hasPreferences: preferenceBlock.length > 0,
-    hasNewSkills: newSkillsBlock.length > 0,
+    hasNewSkills: false,
   });
 
   const contextMessage = buildContextMessage({ memoryBlock, injection, forensicsInjection });

package/src/resources/extensions/gsd/bootstrap/tool-search-shim.ts

@@ -1,5 +1,5 @@
 // GSD does not implement Anthropic deferred-tool ToolSearch. Models trained on
-// that API sometimes try `select:mcp__gsd-workflow__<tool>` and get a hard
+// that API sometimes try `select:mcp__<server>__<tool>` and get a hard
 // "Tool ToolSearch not found" failure. This shim returns explicit call guidance.
 
 import { createToolSearchShimResult, Type } from "@gsd/pi-ai";
@@ -12,14 +12,14 @@ export function registerToolSearchShim(pi: ExtensionAPI): void {
 		name: "ToolSearch",
 		label: "Tool Search (guidance)",
 		description:
-			"Not supported in GSD. Workflow tools are already in your tool list — invoke them by name " +
-			"(e.g. gsd_save_gate_result or mcp__gsd-workflow__gsd_save_gate_result). Do not use ToolSearch.",
+			"Not supported in GSD. If the needed workflow tool is active, invoke the exact listed tool name " +
+			"(e.g. gsd_save_gate_result, or the active MCP-scoped workflow name in Claude Code). Do not use ToolSearch.",
 		parameters: Type.Object({
 			query: Type.String({ description: "Ignored — use a direct tool call instead" }),
 			max_results: Type.Optional(Type.Number()),
 		}),
 		async execute(_toolCallId, params) {
-			return createToolSearchShimResult(params);
+			return createToolSearchShimResult(params, { activeToolNames: pi.getActiveTools() });
 		},
 		renderCall(args: any, theme: any) {
 			const q = args.query ?? "";

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -802,7 +802,7 @@ export function shouldBlockPlanningUnit(
   if (!policy) return { block: false };
   if (policy.mode === "all") return { block: false };
 
-  const tool = toolName;
+  const tool = canonicalToolName(toolName);
 
   // Read-only mode: only Read-class tools are permitted.
   if (policy.mode === "read-only") {

package/src/resources/extensions/gsd/closeout-recovery.ts

@@ -205,7 +205,12 @@ export function getCloseoutManualResolveBlocker(basePath: string): string | null
     return `Unmerged paths remain in ${basePath}: ${conflictProbe.unmerged.slice(0, 5).join(", ")}`;
   }
 
-  const status = runGit(basePath, ["status", "--porcelain"]);
+  let status: string;
+  try {
+    status = runGit(basePath, ["status", "--porcelain"]);
+  } catch {
+    return `Could not inspect git status in ${basePath}.`;
+  }
   if (status) {
     return `Working tree still has uncommitted changes in ${basePath}. Commit, stash, or run /gsd closeout retry first.`;
   }

package/src/resources/extensions/gsd/commands/handlers/auto.ts

@@ -208,7 +208,15 @@ export async function handleAutoCommand(trimmed: string, ctx: ExtensionCommandCo
 
   if (trimmed === "") {
     if (!(await guardRemoteSession(ctx, pi))) return true;
-    if (await hasUnresolvedCloseoutBlocker(ctx, projectRoot())) return true;
+    const basePath = projectRoot();
+    const { hasGsdBootstrapArtifacts } = await import("../../detection.js");
+    const { gsdRoot } = await import("../../paths.js");
+    if (!hasGsdBootstrapArtifacts(gsdRoot(basePath))) {
+      const { showSmartEntry } = await import("../../guided-flow.js");
+      await showSmartEntry(ctx, pi, basePath, { step: true });
+      return true;
+    }
+    if (await hasUnresolvedCloseoutBlocker(ctx, basePath)) return true;
     const { showGsdHome } = await import("../../gsd-command-home.js");
     await showGsdHome(ctx, pi, projectRoot());
     return true;

package/src/resources/extensions/gsd/commands-handlers.ts

@@ -26,6 +26,7 @@ import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { currentDirectoryRoot, projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { isPnpmInstall } from "../../shared/package-manager-detection.js";
 import {
   buildDoctorHealIssuePayload,
   buildDoctorHealSummary,
@@ -57,6 +58,7 @@ function isBunInstall(argv1: string | undefined = process.argv[1]): boolean {
 
 function resolveInstallCommand(pkg: string): string {
   if (isBunInstall()) return `bun add -g ${pkg}`;
+  if (isPnpmInstall()) return `pnpm add -g ${pkg}`;
   return `npm install -g ${pkg}`;
 }