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

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -22,6 +22,29 @@ let sessionSwitchGeneration = 0;
  */
 export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     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 });
     let sessionResult;
@@ -91,17 +114,6 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const unitPromise = new Promise((resolve) => {
         _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
@@ -138,6 +150,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const capturedTurnGen = getCurrentTurnGeneration();
     // ── 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 });
     // ── Await agent_end with absolute timeout (H4 fix) ──
     // If supervision fails to resolve unitPromise within 30s, treat as cancelled.
@@ -160,6 +173,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
         unitId,
         status: result.status,
     });
+    const finalResult = { ...result, requestDispatchedAt };
     // Discard trailing follow-up messages (e.g. async_job_result notifications)
     // from the completed unit. Without this, queued follow-ups trigger wasteful
     // LLM turns before the next session can start (#1642).
@@ -174,5 +188,5 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (e) {
         logWarning("engine", "clearQueue failed after unit completion", { error: String(e) });
     }
-    return result;
+    return finalResult;
 }

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

@@ -15,6 +15,7 @@
  * auto-session-encapsulation.test.ts enforce that auto.ts has no module-level
  * `let` or `var` declarations.
  */
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 // ─── Constants ───────────────────────────────────────────────────────────────
 export const STUB_RECOVERY_THRESHOLD = 2;
 export const NEW_SESSION_TIMEOUT_MS = 120_000;
@@ -118,6 +119,8 @@ export class AutoSession {
     lastPromptCharCount;
     lastBaselineCharCount;
     pendingQuickTasks = [];
+    /** 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. */
     checkpointSha = null;
@@ -153,12 +156,7 @@ export class AutoSession {
         this.unitLifetimeDispatches.clear();
     }
     get lockBasePath() {
-        // 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() {
         this.clearTimers();
@@ -215,6 +213,7 @@ export class AutoSession {
         this.lastPromptCharCount = undefined;
         this.lastBaselineCharCount = undefined;
         this.pendingQuickTasks = [];
+        this.lastRequestTimestamp = 0;
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;

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

@@ -10,6 +10,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 { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -461,8 +462,8 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     let widgetPwd;
     {
         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/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -10,6 +10,8 @@ import { resolveMilestoneFile, resolveSliceFile, relSliceFile, } from "./paths.j
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { logWarning } from "./workflow-logger.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "./workflow-mcp.js";
 export async function dispatchDirectPhase(ctx, pi, phase, base) {
     const state = await deriveState(base);
@@ -19,6 +21,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         ctx.ui.notify("Cannot dispatch: no active milestone.", "warning");
         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;
     let unitId;
@@ -37,7 +45,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 // 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(`Slice ${sid} requires discussion before planning. Run /gsd discuss to discuss this slice, then /gsd auto to resume.`, "info");
@@ -46,12 +54,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 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;
         }
@@ -68,7 +76,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 unitType = "plan-slice";
                 unitId = `${mid}/${sid}`;
-                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base, undefined, {
+                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase, undefined, {
                     sessionContextWindow: ctx.model?.contextWindow,
                     modelRegistry: ctx.modelRegistry,
                 });
@@ -76,7 +84,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             else {
                 unitType = "plan-milestone";
                 unitId = mid;
-                prompt = await buildPlanMilestonePrompt(mid, midTitle, base);
+                prompt = await buildPlanMilestonePrompt(mid, midTitle, dispatchBase);
             }
             break;
         }
@@ -96,7 +104,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             unitType = "execute-task";
             unitId = `${mid}/${sid}/${tid}`;
-            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
+            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, dispatchBase, {
                 sessionContextWindow: ctx.model?.contextWindow,
                 modelRegistry: ctx.modelRegistry,
             });
@@ -115,12 +123,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 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;
         }
@@ -133,7 +141,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             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) {
@@ -148,7 +156,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             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;
         }
         case "uat":
@@ -163,7 +171,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             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) {
@@ -176,7 +184,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 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;
@@ -186,10 +194,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 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;
         }
         case "replan":
@@ -202,7 +210,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             unitType = "replan-slice";
             unitId = `${mid}/${sid}`;
-            prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base);
+            prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase);
             break;
         }
         default:
@@ -210,7 +218,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             return;
     }
     const compatibilityError = getWorkflowTransportSupportError(ctx.model?.provider, getRequiredWorkflowToolsForAutoUnit(unitType), {
-        projectRoot: base,
+        projectRoot,
         surface: "direct phase dispatch",
         unitType,
         authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
@@ -221,10 +229,36 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         return;
     }
     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/dist/resources/extensions/gsd/auto-dispatch.js

@@ -655,14 +655,25 @@ export const DISPATCH_RULES = [
                 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)
+            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
             if (maxParallel <= 1)
@@ -678,8 +689,9 @@ export const DISPATCH_RULES = [
                     return null;
                 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)
+                // 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/dist/resources/extensions/gsd/auto-prompts.js

@@ -23,7 +23,7 @@ import { composeInlinedContext } from "./unit-context-composer.js";
 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 ─────────────────────────────────────────────────────────────
 /**
  * Historical static ceiling for the preamble cap. Kept as an upper bound even
@@ -675,6 +675,26 @@ function formatSkillActivationBlock(skillNames) {
     const calls = safe.map(name => `Call Skill({ skill: '${name}' })`).join('. ');
     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, skillNames) {
+    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) {
     const prefs = params.preferences ?? loadEffectiveGSDPreferences(params.base)?.preferences;
     const contextTokens = tokenizeSkillContext(params.milestoneId, params.milestoneTitle, params.sliceId, params.sliceTitle, params.taskId, params.taskTitle);
@@ -717,10 +737,51 @@ export function buildSkillActivationBlock(params) {
             logWarning("prompt", `parseTaskPlanFile failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    // 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}`;
 }
 /**
  * Build the skill discovery template variables for research prompts.
@@ -1059,6 +1120,7 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
 export async function buildDiscussMilestonePrompt(mid, midTitle, base, structuredQuestionsAvailable = "false") {
     const discussTemplates = inlineTemplate("context", "Context");
     const basePrompt = loadPrompt("guided-discuss-milestone", {
+        workingDirectory: base,
         milestoneId: mid,
         milestoneTitle: midTitle,
         inlinedTemplates: discussTemplates,
@@ -2262,6 +2324,7 @@ export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, b
         ].join("\n"));
     }
     return loadPrompt("parallel-research-slices", {
+        workingDirectory: basePath,
         mid,
         midTitle,
         sliceCount: String(slices.length),
@@ -2289,11 +2352,14 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base,
     const gateDefs = getGatesForTurn("gate-evaluate").filter((def) => pendingIds.has(def.id));
     const subagentSections = [];
     const gateListLines = [];
+    const normalizedBase = base.replaceAll("\\", "/");
     for (const def of gateDefs) {
         gateListLines.push(`- **${def.id}**: ${def.question}`);
         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,
@@ -2401,6 +2467,7 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
     ].join("\n")).join("\n\n");
     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/dist/resources/extensions/gsd/auto-recovery.js

@@ -7,6 +7,7 @@
  * globals or AutoContext dependency.
  */
 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";
@@ -168,8 +169,35 @@ function getChangedFilesSinceBranch(basePath, targetBranch) {
     }
 }
 function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
+    // 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, milestoneId, gitArgs) {
     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())
@@ -213,13 +241,24 @@ function commitMatchesMilestone(message, milestoneId, files) {
     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, milestoneId) {
+    if (!MILESTONE_ID_RE.test(milestoneId))
+        return false;
+    const escapedMilestone = milestoneId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`\\b${escapedMilestone}\\b`).test(message);
+}
 function commitTrailerStartsWithMilestone(message, milestoneId) {
     const escapedMilestone = milestoneId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const trailerPattern = new RegExp(`^GSD-(?:Task|Unit):\\s*${escapedMilestone}(?:$|[\\s/])`, "m");

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -0,0 +1,31 @@
+// GSD auto-mode runtime state
+import { AutoSession } from "./auto/session.js";
+import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, markToolEnd as markTrackedToolEnd, markToolStart as markTrackedToolStart, } from "./auto-tool-tracking.js";
+export const autoSession = new AutoSession();
+export function getAutoRuntimeSnapshot() {
+    return {
+        active: autoSession.active,
+        paused: autoSession.paused,
+        currentUnit: autoSession.currentUnit ? { ...autoSession.currentUnit } : null,
+        basePath: autoSession.basePath,
+    };
+}
+export function isAutoActive() {
+    return autoSession.active;
+}
+export function isAutoPaused() {
+    return autoSession.paused;
+}
+export function markToolStart(toolCallId, toolName) {
+    markTrackedToolStart(toolCallId, autoSession.active, toolName);
+}
+export function markToolEnd(toolCallId) {
+    markTrackedToolEnd(toolCallId);
+}
+export function recordToolInvocationError(toolName, errorMsg) {
+    if (!autoSession.active)
+        return;
+    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg) || isDeterministicPolicyError(errorMsg)) {
+        autoSession.lastToolInvocationError = `${toolName}: ${errorMsg}`;
+    }
+}

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

@@ -208,7 +208,7 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
         else {
             // Branch is NOT merged — preserve for safety, warn the user
             warnings.push(`Branch ${branch} exists for completed milestone ${milestoneId} but is NOT merged into ${mainBranch}. ` +
-                `This may contain unmerged work. Merge manually or run \`/gsd health --fix\` to resolve.`);
+                `This may contain unmerged work. Merge manually or run \`/gsd doctor fix\` to resolve.`);
             // #4764 telemetry
             try {
                 emitWorktreeOrphaned(basePath, milestoneId, {

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -139,6 +139,6 @@ export const DETERMINISTIC_POLICY_ERROR_STRINGS = [
 export function isDeterministicPolicyError(errorMsg) {
     if (!errorMsg)
         return false;
-    return (DETERMINISTIC_POLICY_ERROR_RE.test(errorMsg) ||
-        DETERMINISTIC_POLICY_ERROR_STRINGS.some(s => errorMsg.includes(s)));
+    return DETERMINISTIC_POLICY_ERROR_RE.test(errorMsg)
+        || DETERMINISTIC_POLICY_ERROR_STRINGS.some(s => errorMsg.includes(s));
 }