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

package/dist/resources/extensions/gsd/auto.js

@@ -37,6 +37,8 @@ import { runGSDDoctor, rebuildState } from "./doctor.js";
 import { preDispatchHealthGate, recordHealthSnapshot, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
 import { clearSkillSnapshot } from "./skill-discovery.js";
 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 { initMetrics, resetMetrics, getLedger, getProjectTotals, filterUnitsForMilestone, formatCost, formatTokenCount, } from "./metrics.js";
@@ -64,7 +66,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } 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";
@@ -1576,6 +1578,25 @@ function buildLifecycle() {
  * `sessionProvider`, and `modelRegistry` the same way phases.ts:runDispatch does.
  */
 export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
+    function getAlreadyClosedDispatchReason(unitType, unitId) {
+        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;
@@ -1611,6 +1632,12 @@ export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
             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,
@@ -1648,6 +1675,14 @@ export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
                     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 = {
                     unitType: action.unitType,
@@ -2040,7 +2075,10 @@ function buildLoopDeps(pi) {
         autoCommitUnit,
         recordOutcome,
         writeLock,
-        captureAvailableSkills,
+        captureAvailableSkills: () => {
+            const unitType = s.currentUnit?.type;
+            captureAvailableSkills(effectiveSkillNamesForUnit(unitType, getInstalledSkillNames()));
+        },
         ensurePreconditions,
         updateSliceProgressCache,
         // Model selection + supervision

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -678,8 +678,9 @@ export function registerDbTools(pi) {
         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.",
         ],
@@ -690,7 +691,7 @@ export function registerDbTools(pi) {
             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/dist/resources/extensions/gsd/bootstrap/exec-tools.js

@@ -36,8 +36,13 @@ export function registerExecTools(pi) {
             "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)." }),
-            script: Type.String({ description: "Script body. Keep output small (log the finding, not the data)." }),
+            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.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({
                 description: "Per-invocation timeout (ms). Capped at 600000. Default from preferences.",

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -21,6 +21,31 @@ import { logWarning } from "../workflow-logger.js";
 // EventEmitter does not buffer events for late subscribers.
 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) {
+    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) {
     const errno = err.code;
     if (errno === "EPIPE")
@@ -30,7 +55,7 @@ function isPipeClosedError(err) {
 }
 export function handleRecoverableExtensionProcessError(err) {
     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)) {
@@ -40,24 +65,33 @@ export function handleRecoverableExtensionProcessError(err) {
         if (stdoutGone) {
             process.exit(0);
         }
-        process.stderr.write(`[gsd] swallowed ${tag} (syscall=${err.syscall ?? "?"})\n`);
+        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.syscall ?? "?"})\n`);
         return true;
     }
     if (err.code === "EIO") {
         const syscall = err.syscall;
         if (syscall === "read") {
-            process.stderr.write(`[gsd] EIO: ${err.message}\n`);
+            safeStderr(`[gsd] EIO: ${err.message}\n`);
             return true;
         }
     }
     if (err.code === "ENOENT") {
         const syscall = err.syscall;
         if (syscall?.startsWith("spawn")) {
-            process.stderr.write(`[gsd] spawn ENOENT: ${err.path ?? "unknown"} — command not found\n`);
+            safeStderr(`[gsd] spawn ENOENT: ${err.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/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -25,7 +25,7 @@ import { initNotificationWidget } from "../notification-widget.js";
 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";
 let approvalQuestionAbortInFlight = false;
@@ -125,6 +125,45 @@ export const MINIMAL_AUTO_BASE_TOOL_NAMES = [
 function withPreservedShimTools(toolNames) {
     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([
+    "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) {
+    return WORKFLOW_ALIAS_TOOL_NAMES.has(canonicalToolName(toolName));
+}
+/** True for the ~58 Playwright browser tools (browser_navigate, browser_click, …). */
+function isBrowserTool(toolName) {
+    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) {
+    return (requestCustomMessages ?? []).some((message) => typeof message.customType === "string" && message.customType.startsWith("gsd-"));
+}
 const RUN_UAT_BROWSER_TOOL_NAMES = [
     "browser_navigate",
     "browser_click",
@@ -156,6 +195,7 @@ const AUTO_UNIT_SCOPED_TOOLS = {
         "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"],
@@ -188,7 +228,7 @@ function isGsdManagedTool(name) {
  *
  * 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.
  */
@@ -258,6 +298,15 @@ export function isFullGsdToolSurfaceRequested() {
 function isGeneralGsdToolScopingRequested() {
     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() {
+    return process.env.PI_GSD_BROWSER_TOOLS === "1";
+}
 function resolveRegisteredToolNames(pi, fallback) {
     if (typeof pi.getAllTools === "function") {
         return pi.getAllTools().map((tool) => tool.name);
@@ -285,8 +334,7 @@ export function scopeGsdWorkflowToolsForDispatch(pi, unitType) {
         ? 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;
     }
@@ -294,8 +342,8 @@ export function scopeGsdWorkflowToolsForDispatch(pi, unitType) {
         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,
@@ -418,6 +466,17 @@ function initSessionNotifications(ctx) {
     installNotifyInterceptor(ctx);
     initNotificationWidget(ctx);
 }
+async function prepareWorkflowMcpForHookContext(ctx, basePath) {
+    // 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, ecosystemHandlers) {
     // ADR-005 Phase 3b: surface pi-ai ProviderSwitchReport via audit, notification, and counter.
     // Idempotent — only the first registerHooks call installs.
@@ -438,12 +497,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         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 {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -468,15 +522,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         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);
@@ -511,9 +557,24 @@ export function registerHooks(pi, ecosystemHandlers) {
             }
         }
         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.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.
         try {
@@ -525,7 +586,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         // 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 = gsdResult?.message;
@@ -1124,10 +1185,21 @@ export function registerHooks(pi, ecosystemHandlers) {
     // 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(providerCompatible, event.requestCustomMessages, registeredToolNames, guidedUnit?.unitType);
@@ -1143,6 +1215,14 @@ export function registerHooks(pi, ecosystemHandlers) {
         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/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -8,11 +8,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";
@@ -66,20 +64,6 @@ export const BUNDLED_SKILL_TRIGGERS = [
     { trigger: "Author a YAML workflow definition — steps, triggers, and templates", skill: "create-workflow" },
     { 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() {
-    const cwd = process.cwd();
-    const rows = [];
-    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() {
     const paths = [
         join(gsdHome(), "agent-instructions.md"),
@@ -98,7 +82,6 @@ export async function buildBeforeAgentStartResult(event, ctx) {
         return undefined;
     const stopContextTimer = debugTime("context-inject");
     const systemContent = loadPrompt("system", {
-        bundledSkillsTable: buildBundledSkillsTable(),
         templatesDir: getTemplatesDir(),
         shortcutDashboard: formatShortcut("Ctrl+Alt+G"),
         shortcutShell: formatShortcut("Ctrl+Alt+B"),
@@ -125,7 +108,7 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     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(", ")}`, "warning");
         }
@@ -178,13 +161,6 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     if (globalSizeKb > 4) {
         ctx.ui.notify(`GSD: ~/.gsd/agent/KNOWLEDGE.md is ${globalSizeKb.toFixed(1)}KB — consider trimming to keep system prompt lean.`, "warning");
     }
-    let newSkillsBlock = "";
-    if (hasSkillSnapshot()) {
-        const newSkills = detectNewSkills();
-        if (newSkills.length > 0) {
-            newSkillsBlock = formatSkillsXml(newSkills);
-        }
-    }
     let codebaseBlock = "";
     try {
         const codebaseOptions = loadedPreferences?.preferences?.codebase
@@ -235,12 +211,12 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     // 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 });
     return {

package/dist/resources/extensions/gsd/bootstrap/tool-search-shim.js

@@ -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";
 export { parseToolSearchSelectQuery } from "@gsd/pi-ai";
@@ -8,14 +8,14 @@ export function registerToolSearchShim(pi) {
     pi.registerTool({
         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.",
+        description: "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, theme) {
             const q = args.query ?? "";

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -672,7 +672,7 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
         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") {
         if (PLANNING_SAFE_TOOLS.has(tool))

package/dist/resources/extensions/gsd/closeout-recovery.js

@@ -167,7 +167,13 @@ export function getCloseoutManualResolveBlocker(basePath) {
     if (conflictProbe.status === "dirty" && conflictProbe.unmerged.length > 0) {
         return `Unmerged paths remain in ${basePath}: ${conflictProbe.unmerged.slice(0, 5).join(", ")}`;
     }
-    const status = runGit(basePath, ["status", "--porcelain"]);
+    let status;
+    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/dist/resources/extensions/gsd/commands/handlers/auto.js

@@ -197,7 +197,15 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
     if (trimmed === "") {
         if (!(await guardRemoteSession(ctx, pi)))
             return true;
-        if (await hasUnresolvedCloseoutBlocker(ctx, projectRoot()))
+        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());

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -17,6 +17,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, buildWorkflowDispatchContent, } from "./workflow-protocol.js";
 import { restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch, } from "./bootstrap/register-hooks.js";
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-pi/latest";
@@ -42,6 +43,8 @@ function isBunInstall(argv1 = process.argv[1]) {
 function resolveInstallCommand(pkg) {
     if (isBunInstall())
         return `bun add -g ${pkg}`;
+    if (isPnpmInstall())
+        return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
 async function fetchLatestVersionForCommand() {