gsd-pi 2.78.0-dev.aeeb2ca00 → 2.78.1-dev.0fdacd524

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

@@ -26,6 +26,7 @@ import {
 import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { PROJECT_FILES, hasProjectFileInAncestor } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
@@ -81,11 +82,7 @@ export function resetSessionTimeoutState(): void {
  * Exported for testing as _resolveReportBasePath.
  */
 export function _resolveReportBasePath(s: Pick<AutoSession, "originalBasePath" | "basePath">): string {
-  // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
-  // originalBasePath is falsy — prevents reports landing in the worktree (#3729).
-  const resolved = s.originalBasePath || s.basePath;
-  const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-  return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+  return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
 }
 
 /**
@@ -96,12 +93,7 @@ export function _resolveReportBasePath(s: Pick<AutoSession, "originalBasePath" |
 export function _resolveDispatchGuardBasePath(
   s: Pick<AutoSession, "originalBasePath" | "basePath">,
 ): string {
-  // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
-  // originalBasePath is falsy — prevents guard checks running against the
-  // worktree instead of the project root (#3729).
-  const resolved = s.originalBasePath || s.basePath;
-  const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-  return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+  return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
 }
 
 const PLAN_V2_GATE_PHASES: ReadonlySet<Phase> = new Set([
@@ -1342,7 +1334,7 @@ export async function runUnitPhase(
   iterData: IterationData,
   loopState: LoopState,
   sidecarItem?: SidecarItem,
-): Promise<PhaseResult<{ unitStartedAt: number }>> {
+): Promise<PhaseResult<{ unitStartedAt?: number; requestDispatchedAt?: number }>> {
   const { ctx, pi, s, deps, prefs } = ic;
   const { unitType, unitId, prompt, state, mid } = iterData;
 
@@ -1860,7 +1852,7 @@ export async function runUnitPhase(
         );
         // Fall through to next iteration where dispatch will re-derive
         // and re-dispatch this unit.
-        return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
+        return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
       }
     }
   }
@@ -1924,7 +1916,7 @@ export async function runUnitPhase(
     s.checkpointSha = null;
   }
 
-  return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
+  return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
 }
 
 // ─── runFinalize ──────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/auto/run-unit.ts

@@ -40,6 +40,29 @@ export async function runUnit(
 ): Promise<UnitResult> {
   debugLog("runUnit", { phase: "start", unitType, unitId });
 
+  // Ensure cwd matches basePath BEFORE newSession() captures it. The new
+  // session reads process.cwd() during construction to anchor its tool
+  // runtime and system prompt; if cwd has drifted (async_bash, background
+  // jobs, prior unit cleanup), the session would otherwise be rooted to
+  // the wrong directory. Must be synchronous — no awaits between chdir
+  // and newSession (#1389, #4762 follow-up).
+  try {
+    if (process.cwd() !== s.basePath) {
+      process.chdir(s.basePath);
+    }
+  } catch (e) {
+    const msg = `Failed to chdir to basePath before newSession (basePath: ${s.basePath}): ${String(e)}`;
+    logWarning("engine", msg, { basePath: s.basePath, error: String(e) });
+    return {
+      status: "cancelled",
+      errorContext: {
+        message: msg,
+        category: "session-failed",
+        isTransient: true,
+      },
+    };
+  }
+
   // ── Session creation with timeout ──
   debugLog("runUnit", { phase: "session-create", unitType, unitId });
 
@@ -120,17 +143,6 @@ export async function runUnit(
     _setCurrentResolve(resolve);
   });
 
-  // Ensure cwd matches basePath before dispatch (#1389).
-  // async_bash and background jobs can drift cwd away from the worktree.
-  // Realigning here prevents commits from landing on the wrong branch.
-  try {
-    if (process.cwd() !== s.basePath) {
-      process.chdir(s.basePath);
-    }
-  } catch (e) {
-    logWarning("engine", "Failed to chdir to basePath before dispatch", { basePath: s.basePath, error: String(e) });
-  }
-
   // ── Provider request-readiness pre-check (#4555) ──
   // Verify the provider can accept requests before dispatching. If the token
   // has expired since bootstrap, return cancelled immediately so the unit is
@@ -171,6 +183,7 @@ export async function runUnit(
   // ── Send the prompt ──
   debugLog("runUnit", { phase: "send-message", unitType, unitId });
 
+  const requestDispatchedAt = Date.now();
   pi.sendMessage(
     { customType: "gsd-auto", content: prompt, display: s.verbose },
     { triggerTurn: true },
@@ -201,6 +214,7 @@ export async function runUnit(
     unitId,
     status: result.status,
   });
+  const finalResult: UnitResult = { ...result, requestDispatchedAt };
 
   // Discard trailing follow-up messages (e.g. async_job_result notifications)
   // from the completed unit. Without this, queued follow-ups trigger wasteful
@@ -216,5 +230,5 @@ export async function runUnit(
     logWarning("engine", "clearQueue failed after unit completion", { error: String(e) });
   }
 
-  return result;
+  return finalResult;
 }

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

@@ -21,6 +21,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent
 import type { GitServiceImpl } from "../git-service.js";
 import type { CaptureEntry } from "../captures.js";
 import type { BudgetAlertLevel } from "../auto-budget.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 
 // ─── Exported Types ──────────────────────────────────────────────────────────
 
@@ -193,6 +194,8 @@ export class AutoSession {
   lastPromptCharCount: number | undefined;
   lastBaselineCharCount: number | undefined;
   pendingQuickTasks: CaptureEntry[] = [];
+  /** Timestamp of the last LLM request dispatch (ms since epoch). Used for proactive rate limiting. */
+  lastRequestTimestamp = 0;
 
   // ── Safety harness ───────────────────────────────────────────────────────
   /** SHA of the pre-unit git checkpoint ref. Cleared on success or rollback. */
@@ -224,12 +227,7 @@ export class AutoSession {
   }
 
   get lockBasePath(): string {
-    // Prefer originalBasePath (project root); fall back to basePath.
-    // Strip /.gsd/worktrees/ suffix if basePath is itself a worktree path
-    // to avoid reading/writing the lock inside the worktree (#3729).
-    const resolved = this.originalBasePath || this.basePath;
-    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+    return resolveWorktreeProjectRoot(this.basePath, this.originalBasePath);
   }
 
   reset(): void {
@@ -294,6 +292,7 @@ export class AutoSession {
     this.lastPromptCharCount = undefined;
     this.lastBaselineCharCount = undefined;
     this.pendingQuickTasks = [];
+    this.lastRequestTimestamp = 0;
     this.sidecarQueue = [];
     this.rewriteAttemptCount = 0;
     this.consecutiveCompleteBootstraps = 0;

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

@@ -66,6 +66,7 @@ export interface UnitResult {
   status: "completed" | "cancelled" | "error";
   event?: AgentEndEvent;
   errorContext?: ErrorContext;
+  requestDispatchedAt?: number;
 }
 
 // ─── Phase pipeline types ────────────────────────────────────────────────────

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

@@ -19,6 +19,7 @@ import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
 import { nativeIsRepo } from "./native-git-bridge.js";
+import { getHomeDir } from "./home-dir.js";
 import {
   resolveMilestoneFile,
   resolveSliceFile,
@@ -582,8 +583,8 @@ export function updateProgressWidget(
   let widgetPwd: string;
   {
     let fullPwd = process.cwd();
-    const widgetHome = process.env.HOME || process.env.USERPROFILE;
-    if (widgetHome && fullPwd.startsWith(widgetHome)) {
+    const widgetHome = getHomeDir();
+    if (widgetHome && (fullPwd === widgetHome || fullPwd.startsWith(widgetHome + "/") || fullPwd.startsWith(widgetHome + "\\"))) {
       fullPwd = `~${fullPwd.slice(widgetHome.length)}`;
     }
     const parts = fullPwd.split("/");

package/src/resources/extensions/gsd/auto-direct-dispatch.ts

@@ -30,6 +30,8 @@ import {
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import type { MinimalModelRegistry } from "./context-budget.js";
 import { pauseAuto } from "./auto.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { logWarning } from "./workflow-logger.js";
 import {
   getWorkflowTransportSupportError,
   getRequiredWorkflowToolsForAutoUnit,
@@ -50,6 +52,14 @@ export async function dispatchDirectPhase(
     return;
   }
 
+  const projectRoot = base;
+
+  // Switch the dispatch base to the canonical milestone worktree if one
+  // exists. Without this, /gsd dispatch invoked from the project root would
+  // build prompts and create a session anchored to the project root even
+  // though the milestone's actual code lives in the worktree.
+  const dispatchBase = resolveCanonicalMilestoneRoot(base, mid);
+
   const normalized = phase.toLowerCase();
   let unitType: string;
   let unitId: string;
@@ -70,7 +80,7 @@ export async function dispatchDirectPhase(
 
         // When require_slice_discussion is enabled, pause auto-mode before
         // each new slice so the user can discuss requirements first (#789).
-        const sliceContextFile = resolveSliceFile(base, mid, sid, "CONTEXT");
+        const sliceContextFile = resolveSliceFile(dispatchBase, mid, sid, "CONTEXT");
         const requireDiscussion = loadEffectiveGSDPreferences()?.preferences?.phases?.require_slice_discussion;
         if (requireDiscussion && !sliceContextFile) {
           ctx.ui.notify(
@@ -83,11 +93,11 @@ export async function dispatchDirectPhase(
 
         unitType = "research-slice";
         unitId = `${mid}/${sid}`;
-        prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, base);
+        prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase);
       } else {
         unitType = "research-milestone";
         unitId = mid;
-        prompt = await buildResearchMilestonePrompt(mid, midTitle, base);
+        prompt = await buildResearchMilestonePrompt(mid, midTitle, dispatchBase);
       }
       break;
     }
@@ -106,7 +116,7 @@ export async function dispatchDirectPhase(
         unitType = "plan-slice";
         unitId = `${mid}/${sid}`;
         prompt = await buildPlanSlicePrompt(
-          mid, midTitle, sid, sTitle, base, undefined,
+          mid, midTitle, sid, sTitle, dispatchBase, undefined,
           {
             sessionContextWindow: ctx.model?.contextWindow,
             modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
@@ -115,7 +125,7 @@ export async function dispatchDirectPhase(
       } else {
         unitType = "plan-milestone";
         unitId = mid;
-        prompt = await buildPlanMilestonePrompt(mid, midTitle, base);
+        prompt = await buildPlanMilestonePrompt(mid, midTitle, dispatchBase);
       }
       break;
     }
@@ -137,7 +147,7 @@ export async function dispatchDirectPhase(
       unitType = "execute-task";
       unitId = `${mid}/${sid}/${tid}`;
       prompt = await buildExecuteTaskPrompt(
-        mid, sid, sTitle, tid, tTitle, base,
+        mid, sid, sTitle, tid, tTitle, dispatchBase,
         {
           sessionContextWindow: ctx.model?.contextWindow,
           modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
@@ -159,11 +169,11 @@ export async function dispatchDirectPhase(
         }
         unitType = "complete-slice";
         unitId = `${mid}/${sid}`;
-        prompt = await buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base);
+        prompt = await buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase);
       } else {
         unitType = "complete-milestone";
         unitId = mid;
-        prompt = await buildCompleteMilestonePrompt(mid, midTitle, base);
+        prompt = await buildCompleteMilestonePrompt(mid, midTitle, dispatchBase);
       }
       break;
     }
@@ -177,7 +187,7 @@ export async function dispatchDirectPhase(
       }
       if (completedSliceIds.length === 0) {
         // File-based fallback: parse roadmap checkboxes
-        const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+        const roadmapPath = resolveMilestoneFile(dispatchBase, mid, "ROADMAP");
         if (roadmapPath) {
           const roadmapContent = await loadFile(roadmapPath);
           if (roadmapContent) {
@@ -192,7 +202,7 @@ export async function dispatchDirectPhase(
       const completedSliceId = completedSliceIds[completedSliceIds.length - 1];
       unitType = "reassess-roadmap";
       unitId = `${mid}/${completedSliceId}`;
-      prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base);
+      prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, dispatchBase);
       break;
     }
 
@@ -208,7 +218,7 @@ export async function dispatchDirectPhase(
       }
       if (uatCompletedSliceIds.length === 0) {
         // File-based fallback: parse roadmap checkboxes
-        const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+        const roadmapPath = resolveMilestoneFile(dispatchBase, mid, "ROADMAP");
         if (roadmapPath) {
           const roadmapContent = await loadFile(roadmapPath);
           if (roadmapContent) {
@@ -221,7 +231,7 @@ export async function dispatchDirectPhase(
         return;
       }
       const sid = uatCompletedSliceIds[uatCompletedSliceIds.length - 1];
-      const uatFile = resolveSliceFile(base, mid, sid, "UAT");
+      const uatFile = resolveSliceFile(dispatchBase, mid, sid, "UAT");
       if (!uatFile) {
         ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");
         return;
@@ -231,10 +241,10 @@ export async function dispatchDirectPhase(
         ctx.ui.notify("Cannot dispatch run-uat: UAT file is empty.", "warning");
         return;
       }
-      const uatPath = relSliceFile(base, mid, sid, "UAT");
+      const uatPath = relSliceFile(dispatchBase, mid, sid, "UAT");
       unitType = "run-uat";
       unitId = `${mid}/${sid}`;
-      prompt = await buildRunUatPrompt(mid, sid, uatPath, uatContent, base);
+      prompt = await buildRunUatPrompt(mid, sid, uatPath, uatContent, dispatchBase);
       break;
     }
 
@@ -248,7 +258,7 @@ export async function dispatchDirectPhase(
       }
       unitType = "replan-slice";
       unitId = `${mid}/${sid}`;
-      prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base);
+      prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase);
       break;
     }
 
@@ -264,7 +274,7 @@ export async function dispatchDirectPhase(
     ctx.model?.provider,
     getRequiredWorkflowToolsForAutoUnit(unitType),
     {
-      projectRoot: base,
+      projectRoot,
       surface: "direct phase dispatch",
       unitType,
       authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
@@ -277,13 +287,39 @@ export async function dispatchDirectPhase(
   }
 
   ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
-  const result = await ctx.newSession();
-  if (result.cancelled) {
-    ctx.ui.notify("Session creation cancelled.", "warning");
-    return;
+
+  const originalCwd = process.cwd();
+
+  try {
+    // Ensure cwd matches dispatchBase BEFORE newSession() captures it. Synchronous —
+    // no awaits between chdir and newSession.
+    try {
+      if (process.cwd() !== dispatchBase) {
+        process.chdir(dispatchBase);
+      }
+    } catch (err) {
+      const msg = `Failed to chdir before direct-dispatch newSession (basePath: ${dispatchBase}): ${err instanceof Error ? err.message : String(err)}`;
+      logWarning("engine", msg, { file: "auto-direct-dispatch.ts", basePath: dispatchBase, error: err instanceof Error ? err.message : String(err) });
+      ctx.ui.notify(`${msg}. Cancelling dispatch to avoid running in the wrong directory.`, "error");
+      return;
+    }
+
+    const result = await ctx.newSession();
+    if (result.cancelled) {
+      ctx.ui.notify("Session creation cancelled.", "warning");
+      return;
+    }
+    pi.sendMessage(
+      { customType: "gsd-dispatch", content: prompt, display: false },
+      { triggerTurn: true },
+    );
+  } finally {
+    try {
+      if (process.cwd() !== originalCwd) {
+        process.chdir(originalCwd);
+      }
+    } catch (err) {
+      logWarning("engine", `Failed to restore cwd after direct dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto-direct-dispatch.ts", basePath: originalCwd });
+    }
   }
-  pi.sendMessage(
-    { customType: "gsd-dispatch", content: prompt, display: false },
-    { triggerTurn: true },
-  );
 }

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

@@ -797,14 +797,25 @@ export const DISPATCH_RULES: DispatchRule[] = [
       if (state.phase !== "executing" || !state.activeTask) return null;
       if (!state.activeSlice) return null; // fall through
 
-      // Only activate when reactive_execution is explicitly enabled
+      // Reactive dispatch is on by default when there are enough ready tasks to
+      // benefit from parallelism. Users opt out explicitly via
+      // `reactive_execution.enabled: false`. The downstream safety checks
+      // (graph ambiguity, ready-task count, conflict-free selection) still gate
+      // every actual dispatch, so the worst-case "default-on" outcome is the
+      // same fall-through to sequential execution as before.
       const reactiveConfig = prefs?.reactive_execution;
-      if (!reactiveConfig?.enabled) return null;
+      if (reactiveConfig?.enabled === false) return null;
 
       const sid = state.activeSlice.id;
       const sTitle = state.activeSlice.title;
-      const maxParallel = reactiveConfig.max_parallel ?? 2;
-      const subagentModel = reactiveConfig.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
+      const maxParallel = reactiveConfig?.max_parallel ?? 2;
+      const subagentModel = reactiveConfig?.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
+      // Default-on safety threshold: only activate reactive dispatch when at
+      // least N tasks are ready. Users who explicitly enabled reactive_execution
+      // keep the legacy threshold of 2 (matches the prior "any parallelism is
+      // better than none" intent). Default-on installs require >=3 to avoid
+      // surprising users with parallelism on small slices.
+      const minReadyTasksForReactive = reactiveConfig?.enabled === true ? 2 : 3;
 
       // Dry-run mode: max_parallel=1 means graph is derived and logged but
       // execution remains sequential
@@ -831,8 +842,9 @@ export const DISPATCH_RULES: DispatchRule[] = [
         const completed = new Set(graph.filter((n) => n.done).map((n) => n.id));
         const readyIds = getReadyTasks(graph, completed, new Set());
 
-        // Only activate reactive dispatch when >1 task is ready
-        if (readyIds.length <= 1) return null;
+        // Only activate reactive dispatch when enough tasks are ready.
+        // Threshold is 2 when explicitly opted in, 3 when default-on.
+        if (readyIds.length < minReadyTasksForReactive) return null;
 
         const uokFlags = resolveUokFlags(prefs);
         const selected = uokFlags.executionGraph

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

@@ -37,7 +37,7 @@ import { composeInlinedContext, type ArtifactResolver } from "./unit-context-com
 import { logWarning } from "./workflow-logger.js";
 import { inlineGraphSubgraph } from "./graph-context.js";
 import { buildExtractionStepsBlock } from "./commands-extract-learnings.js";
-import { warnIfManifestHasMissingSkills } from "./skill-manifest.js";
+import { resolveSkillManifest, warnIfManifestHasMissingSkills } from "./skill-manifest.js";
 
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 
@@ -776,6 +776,25 @@ function formatSkillActivationBlock(skillNames: string[]): string {
   return `<skill_activation>${calls}.</skill_activation>`;
 }
 
+/**
+ * Manifest-driven recommendations block — informational only, does NOT
+ * auto-invoke. Lists per-unit-type skills that are installed but not already
+ * activated by explicit user intent (always_use_skills / prefer_skills /
+ * skill_rules / task-plan skills_used). Surfaces relevant skills to the
+ * model so they can be invoked when the model judges them useful.
+ *
+ * This is the additive complement to the existing activation directive:
+ * activation force-invokes (explicit intent), recommendations remind
+ * (manifest defaults). User intent is preserved as the stronger signal
+ * (RFC #4779 design principle); this block only adds visibility.
+ */
+function formatSkillRecommendationsBlock(unitType: string | undefined, skillNames: string[]): string {
+  if (!unitType) return "";
+  const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
+  if (safe.length === 0) return "";
+  return `<skill_recommendations unit="${unitType}">For this unit type, also consider invoking: ${safe.join(", ")}. Use Skill({ skill: 'name' }) when relevant — these are recommendations, not requirements.</skill_recommendations>`;
+}
+
 export function buildSkillActivationBlock(params: {
   base: string;
   milestoneId: string;
@@ -846,10 +865,49 @@ export function buildSkillActivationBlock(params: {
     }
   }
 
+  // Heuristic auto-match (gated on skill_discovery: "auto").
+  // For each installed skill, check if its name or description appears in the
+  // unit's context tokens (milestone/slice/task titles). Only consider skills
+  // already on the unit-type manifest allowlist — this keeps the heuristic
+  // narrow and avoids wildly off-topic activations.
+  // Users who set `skill_discovery: "off"` or "suggest" do not get
+  // auto-matched skills (the recommendations block still surfaces manifest
+  // skills passively); only "auto" actually adds them to the activation
+  // directive set. Default `skill_discovery` is "suggest", so this is opt-in.
+  if ((prefs?.skill_discovery ?? "suggest") === "auto") {
+    const manifestAllow = resolveSkillManifest(params.unitType);
+    const allowSet = manifestAllow ? new Set(manifestAllow) : null;
+    for (const skill of visibleSkills) {
+      const normalized = normalizeSkillReference(skill.name);
+      if (matched.has(normalized) || avoided.has(normalized)) continue;
+      // Respect the manifest allowlist when present; wildcard (null) lets all
+      // installed skills compete for keyword match.
+      if (allowSet && !allowSet.has(normalized)) continue;
+      if (skillMatchesContext(skill, contextTokens)) {
+        matched.add(normalized);
+      }
+    }
+  }
+
   const ordered = [...matched]
     .filter(name => installedNames.has(name) && !avoided.has(name))
     .sort();
-  return formatSkillActivationBlock(ordered);
+  const activationBlock = formatSkillActivationBlock(ordered);
+
+  // Manifest-driven recommendations (additive, does not override explicit intent).
+  // Only surface skills the manifest declares for this unit type that are
+  // installed and not already in matched/avoided.
+  const matchedSet = new Set(ordered);
+  const manifestList = resolveSkillManifest(params.unitType);
+  const recommendations = (manifestList ?? [])
+    .filter(name => installedNames.has(name) && !avoided.has(name) && !matchedSet.has(name))
+    .sort();
+  const recommendationsBlock = formatSkillRecommendationsBlock(params.unitType, recommendations);
+
+  if (!activationBlock && !recommendationsBlock) return "";
+  if (!activationBlock) return recommendationsBlock;
+  if (!recommendationsBlock) return activationBlock;
+  return `${activationBlock}\n${recommendationsBlock}`;
 }
 
 /**
@@ -1209,6 +1267,7 @@ export async function buildDiscussMilestonePrompt(
   const discussTemplates = inlineTemplate("context", "Context");
 
   const basePrompt = loadPrompt("guided-discuss-milestone", {
+    workingDirectory: base,
     milestoneId: mid,
     milestoneTitle: midTitle,
     inlinedTemplates: discussTemplates,
@@ -2587,6 +2646,7 @@ export async function buildParallelResearchSlicesPrompt(
   }
 
   return loadPrompt("parallel-research-slices", {
+    workingDirectory: basePath,
     mid,
     midTitle,
     sliceCount: String(slices.length),
@@ -2623,6 +2683,7 @@ export async function buildGateEvaluatePrompt(
 
   const subagentSections: string[] = [];
   const gateListLines: string[] = [];
+  const normalizedBase = base.replaceAll("\\", "/");
 
   for (const def of gateDefs) {
     gateListLines.push(`- **${def.id}**: ${def.question}`);
@@ -2630,6 +2691,8 @@ export async function buildGateEvaluatePrompt(
     const subPrompt = [
       `You are evaluating quality gate **${def.id}** for slice ${sid} (${sTitle}).`,
       "",
+      `**Working directory:** \`${normalizedBase}\`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT \`cd\` to any other directory.`,
+      "",
       `## Question: ${def.question}`,
       "",
       def.guidance,
@@ -2746,6 +2809,7 @@ export async function buildRewriteDocsPrompt(
   const documentList = docList.length > 0 ? docList.join("\n") : "- No active plan documents found.";
 
   return loadPrompt("rewrite-docs", {
+    workingDirectory: base,
     milestoneId: mid,
     milestoneTitle: midTitle,
     sliceId: sid ?? "none",

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

@@ -9,6 +9,7 @@
 
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { parseUnitId } from "./unit-id.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
@@ -213,13 +214,40 @@ function getChangedFilesSinceBranch(basePath: string, targetBranch: string): { o
 function getChangedFilesFromMilestoneTaggedCommits(
   basePath: string,
   milestoneId: string,
+): { ok: boolean; matched: boolean; files: string[] } {
+  // Primary: path-scoped log against .gsd/milestones/<id>. Fast and unbounded
+  // by depth when .gsd/ is tracked in git.
+  const scoped = scanGsdTaggedCommits(basePath, milestoneId, [
+    "log", "--format=%H%x1f%B%x1e", "HEAD", "--", `.gsd/milestones/${milestoneId}`,
+  ]);
+  if (!scoped.ok) return scoped;
+  if (scoped.matched) return scoped;
+
+  // Fallback (#5033): when .gsd/ is gitignored / external / untracked, the
+  // path-scoped scan matches no commits even though GSD-tagged commits
+  // referencing the milestone exist on the integration branch. Re-scan all
+  // of HEAD's history and rely on commitMatchesMilestone to bind by
+  // explicit milestone mention in the message body.
+  //
+  // Intentionally unbounded — symmetric with the primary scan, and avoids
+  // reintroducing the rolling-depth failure class removed in #4699 where
+  // milestone evidence aged out behind unrelated activity.
+  return scanGsdTaggedCommits(basePath, milestoneId, [
+    "log", "--format=%H%x1f%B%x1e", "HEAD",
+  ]);
+}
+
+function scanGsdTaggedCommits(
+  basePath: string,
+  milestoneId: string,
+  gitArgs: readonly string[],
 ): { ok: boolean; matched: boolean; files: string[] } {
   try {
-    const logOutput = execFileSync(
-      "git",
-      ["log", "--format=%H%x1f%B%x1e", "HEAD", "--", `.gsd/milestones/${milestoneId}`],
-      { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
-    );
+    const logOutput = execFileSync("git", [...gitArgs], {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    });
     const records = logOutput
       .split("\x1e")
       .map((record) => record.trim())
@@ -270,15 +298,25 @@ function commitMatchesMilestone(message: string, milestoneId: string, files: rea
   if (commitTrailerStartsWithMilestone(message, milestoneId)) return true;
 
   // Meaningful execute-task commits currently store task scope as Sxx/Tyy
-  // rather than Mxx/Sxx/Tyy. Bind those commits back to the milestone only
-  // when the commit also touched this milestone's artifacts.
+  // rather than Mxx/Sxx/Tyy. Bind those commits back to the milestone when
+  // either the commit touched this milestone's artifacts, or — for projects
+  // where .gsd/ is gitignored/external (#5033) — the message explicitly
+  // names the milestone.
   if (/^GSD-Task:\s*S[^/\s]+\/T\S+/m.test(message)) {
-    return files.some((file) => isMilestoneArtifactPath(file, milestoneId));
+    if (files.some((file) => isMilestoneArtifactPath(file, milestoneId))) return true;
+    if (commitMessageMentionsMilestone(message, milestoneId)) return true;
   }
 
   return false;
 }
 
+function commitMessageMentionsMilestone(message: string, milestoneId: string): boolean {
+  if (!MILESTONE_ID_RE.test(milestoneId)) return false;
+
+  const escapedMilestone = milestoneId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${escapedMilestone}\\b`).test(message);
+}
+
 function commitTrailerStartsWithMilestone(message: string, milestoneId: string): boolean {
   const escapedMilestone = milestoneId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const trailerPattern = new RegExp(