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

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

@@ -20,7 +20,7 @@ import {
   unlinkSync,
   lstatSync as lstatSyncFn,
 } from "node:fs";
-import { isAbsolute, join, relative, resolve, sep as pathSep } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep as pathSep } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import {
   reconcileWorktreeDb,
@@ -59,6 +59,8 @@ import { debugLog } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
+import { classifyProject } from "./detection.js";
 import {
   nativeGetCurrentBranch,
   nativeDetectMainBranch,
@@ -258,6 +260,47 @@ export function _resolveAutoWorktreeStartPoint(
     : undefined;
 }
 
+function importUntrackedProjectRootContentIntoEmptyWorktree(
+  projectRoot: string,
+  worktreeRoot: string,
+  milestoneId: string,
+): number {
+  const worktreeClassification = classifyProject(worktreeRoot);
+  if (worktreeClassification.kind !== "greenfield") return 0;
+
+  const projectRootClassification = classifyProject(projectRoot);
+  if (
+    projectRootClassification.kind === "greenfield" ||
+    projectRootClassification.kind === "invalid-repo" ||
+    projectRootClassification.untrackedFiles.length === 0
+  ) {
+    return 0;
+  }
+
+  let copied = 0;
+  for (const relPath of projectRootClassification.untrackedFiles) {
+    const src = join(projectRoot, relPath);
+    if (!existsSync(src)) continue;
+
+    const dst = join(worktreeRoot, relPath);
+    if (existsSync(dst)) continue;
+
+    mkdirSync(dirname(dst), { recursive: true });
+    cpSync(src, dst, { recursive: true, force: false });
+    copied++;
+  }
+
+  if (copied > 0) {
+    debugLog("createAutoWorktree", {
+      phase: "import-untracked-project-content",
+      milestoneId,
+      copied,
+    });
+  }
+
+  return copied;
+}
+
 export function _shouldReconcileWorktreeDb(
   worktreeDbPath: string,
   mainDbPath: string,
@@ -912,62 +955,7 @@ export function syncWorktreeStateBack(
 ): { synced: string[] } {
   return _finalizeProjectionForMergeImpl(mainBasePath, worktreePath, milestoneId);
 }
-// ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
-
-/**
- * Run the user-configured post-create hook script after worktree creation.
- * The script receives SOURCE_DIR and WORKTREE_DIR as environment variables.
- * Failure is non-fatal — returns the error message or null on success.
- *
- * Reads the hook path from git.worktree_post_create in preferences.
- * Pass hookPath directly to bypass preference loading (useful for testing).
- */
-export function runWorktreePostCreateHook(
-  sourceDir: string,
-  worktreeDir: string,
-  hookPath?: string,
-): string | null {
-  if (hookPath === undefined) {
-    const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
-    hookPath = prefs?.worktree_post_create;
-  }
-  if (!hookPath) return null;
-
-  // Resolve relative paths against the source project root.
-  // On Windows, convert 8.3 short paths (e.g. RUNNER~1) to long paths
-  // so execFileSync can locate the file correctly.
-  let resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
-  if (!existsSync(resolved)) {
-    return `Worktree post-create hook not found: ${resolved}`;
-  }
-  if (process.platform === "win32") {
-    try { resolved = realpathSync.native(resolved); } catch (err) { /* keep original */
-      logWarning("worktree", `realpath failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  try {
-    // .bat/.cmd files on Windows require shell mode — execFileSync cannot
-    // spawn them directly (EINVAL).
-    const needsShell = process.platform === "win32" && /\.(bat|cmd)$/i.test(resolved);
-    execFileSync(resolved, [], {
-      cwd: worktreeDir,
-      env: {
-        ...process.env,
-        SOURCE_DIR: sourceDir,
-        WORKTREE_DIR: worktreeDir,
-      },
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf-8",
-      timeout: 30_000, // 30 second timeout
-      shell: needsShell,
-    });
-    return null;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return `Worktree post-create hook failed: ${msg}`;
-  }
-}
+export { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 
 // ─── Auto-Worktree Branch Naming ───────────────────────────────────────────
 
@@ -1387,6 +1375,8 @@ export function createAutoWorktree(
   // The original concerns (#759, #778) no longer apply because there is
   // no second copy to drift.
 
+  importUntrackedProjectRootContentIntoEmptyWorktree(basePath, info.path, milestoneId);
+
   // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
   const hookError = runWorktreePostCreateHook(basePath, info.path);
   if (hookError) {

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;
   });
 }