gsd-pi 2.78.0 → 2.78.1-dev.2d3fd6e71

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

@@ -1,6 +1,6 @@
 /**
  * Post-unit processing for auto-loop — auto-commit, doctor run,
- * state rebuild, worktree sync, DB dual-write, hooks, triage, and
+ * state rebuild, projection checks, DB tool closeout, hooks, triage, and
  * quick-task dispatch.
  *
  * Split into two functions called sequentially by auto-loop with
@@ -14,6 +14,7 @@ import { deriveState } from "./state.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { isAwaitingUserInput } from "./user-input-boundary.js";
 import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
@@ -23,7 +24,8 @@ import { runTurnGitAction, } from "./git-service.js";
 import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { syncStateToProjectRoot } from "./auto-worktree.js";
-import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, updateSliceStatus, _getAdapter } from "./gsd-db.js";
+import { normalizeWorktreePathForCompare } from "./worktree-root.js";
+import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
@@ -37,7 +39,7 @@ import { validateFileChanges } from "./safety/file-change-validator.js";
 import { validateContent } from "./safety/content-validator.js";
 import { resolveSafetyHarnessConfig } from "./safety/safety-harness.js";
 import { resolveExpectedArtifactPath as resolveArtifactForContent } from "./auto-artifact-paths.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { getIsolationMode, loadEffectiveGSDPreferences } from "./preferences.js";
 import { getSliceTasks } from "./gsd-db.js";
 import { runPreExecutionChecks } from "./pre-execution-checks.js";
 import { writePreExecutionEvidence } from "./verification-evidence.js";
@@ -48,6 +50,13 @@ import { writeTurnGitTransaction } from "./uok/gitops.js";
 import { isClosedStatus } from "./status-guards.js";
 import { detectAbandonMilestone } from "./abandon-detect.js";
 import { isDeterministicPolicyError } from "./auto-tool-tracking.js";
+import { clearProjectResearchInflightMarker, finalizeProjectResearchTimeout, } from "./project-research-policy.js";
+import { validateArtifact } from "./schemas/validate.js";
+// ─── Path Comparison Helper ───────────────────────────────────────────────
+/** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
+function isSamePathLocal(a, b) {
+    return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
+}
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
 /** Keep failure toasts short while still showing concrete examples. */
@@ -106,9 +115,8 @@ import { autoCommitCurrentBranch } from "./worktree.js";
  * the completion tool. A "rogue" file is one that exists on disk but has
  * no corresponding DB row with status "complete".
  *
- * This is a safety-net diagnostic (D003). The existing migrateFromMarkdown()
- * in postUnitPostVerification() eventually ingests rogue files, but explicit
- * detection provides immediate diagnostics so operators know the prompt failed.
+ * This is a safety-net diagnostic (D003). Runtime detection never imports
+ * markdown into the DB; explicit migration/import/recovery commands own that.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function hasNonEmptyFields(row, fields) {
@@ -142,15 +150,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
             return [];
         const dbRow = getSlice(mid, sid);
         if (!dbRow || dbRow.status !== "complete") {
-            // Auto-remediate: SUMMARY exists on disk but DB is stale — sync DB to
-            // match filesystem instead of reporting as rogue (#3633).
-            try {
-                updateSliceStatus(mid, sid, "complete", new Date().toISOString());
-            }
-            catch {
-                // If DB update fails, fall back to rogue detection so the issue is visible
-                rogues.push({ path: summaryPath, unitType, unitId });
-            }
+            rogues.push({ path: summaryPath, unitType, unitId });
         }
     }
     else if (unitType === "plan-milestone") {
@@ -226,6 +226,43 @@ export function buildStepCompleteMessage(nextState) {
     return `Step complete. Next: ${next.label}\n`
         + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
 }
+export const USER_DRIVEN_DEEP_UNITS = new Set([
+    "discuss-project",
+    "discuss-requirements",
+    "discuss-milestone",
+    "research-decision",
+]);
+export { isAwaitingUserInput } from "./user-input-boundary.js";
+function artifactValidationKind(unitType) {
+    if (unitType === "discuss-project")
+        return "project";
+    if (unitType === "discuss-requirements")
+        return "requirements";
+    return null;
+}
+function describeArtifactVerificationFailure(unitType, unitId, basePath) {
+    const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
+    if (!artifactPath) {
+        return `Artifact verification failed: ${unitType} "${unitId}" has no resolvable artifact path.`;
+    }
+    const relPath = relative(basePath, artifactPath);
+    if (!existsSync(artifactPath)) {
+        return `Artifact verification failed: ${relPath} was not found on disk after unit execution.`;
+    }
+    const validationKind = artifactValidationKind(unitType);
+    if (validationKind) {
+        const result = validateArtifact(artifactPath, validationKind);
+        if (!result.ok) {
+            const errors = result.errors
+                .slice(0, MAX_NOTIFICATION_DETAILS)
+                .map((error) => `${error.code}: ${error.message}`)
+                .join("; ");
+            return `Artifact verification failed: ${relPath} exists but is invalid${errors ? ` (${errors})` : ""}.`;
+        }
+    }
+    const expected = diagnoseExpectedArtifact(unitType, unitId, basePath);
+    return `Artifact verification failed: ${relPath} exists but did not satisfy the ${unitType} completion contract${expected ? ` (${expected})` : ""}.`;
+}
 export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
     try {
         let taskContext;
@@ -425,17 +462,14 @@ export async function postUnitPreVerification(pctx, opts) {
                         });
                     }
                     const failureMsg = `Git ${turnAction} failed: ${(gitResult.error ?? "unknown error").split("\n")[0]}`;
-                    if (uokFlags.gitops) {
-                        ctx.ui.notify(failureMsg, "error");
-                        await pauseAuto(ctx, pi);
-                        return "dispatched";
-                    }
-                    ctx.ui.notify(failureMsg, "warning");
+                    ctx.ui.notify(failureMsg, "error");
                     debugLog("postUnit", {
-                        phase: "git-action-failed-nonblocking",
+                        phase: "git-action-failed-blocking",
                         action: turnAction,
                         error: gitResult.error ?? "unknown error",
                     });
+                    await pauseAuto(ctx, pi);
+                    return "dispatched";
                 }
                 s.lastGitActionStatus = "ok";
                 if (turnAction === "commit" && gitResult.commitMessage) {
@@ -482,7 +516,7 @@ export async function postUnitPreVerification(pctx, opts) {
             await rebuildState(s.basePath);
         });
         // Sync worktree state back to project root (skipped for lightweight sidecars)
-        if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
+        if (!opts?.skipWorktreeSync && s.originalBasePath && !isSamePathLocal(s.originalBasePath, s.basePath)) {
             await runSafely("postUnit", "worktree-sync", () => {
                 syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
             });
@@ -550,7 +584,7 @@ export async function postUnitPreVerification(pctx, opts) {
                 const { getCollapseCadence, mergeSliceToMain } = await import("./slice-cadence.js");
                 if (getCollapseCadence(prefs) !== "slice")
                     return;
-                if (prefs?.git?.isolation !== "worktree")
+                if (getIsolationMode(s.originalBasePath || s.basePath) !== "worktree")
                     return;
                 if (s.isolationDegraded)
                     return;
@@ -591,7 +625,7 @@ export async function postUnitPreVerification(pctx, opts) {
                         ctx.ui.notify(`slice-cadence merge conflict in ${sid}: ${err.conflictedFiles.join(", ")}. ` +
                             `Resolve manually on main and run \`/gsd auto\` to resume.`, "error");
                         // Stop auto AND signal the outer postUnit flow to exit early.
-                        // Without the flag, subsequent hooks (triage, rogue detection,
+                        // Without the flag, subsequent hooks (triage,
                         // DB writes) would keep running against a conflicted main
                         // checkout after the loop was already told to stop.
                         const { stopAuto } = await import("./auto.js");
@@ -611,7 +645,7 @@ export async function postUnitPreVerification(pctx, opts) {
                 }
             });
             // Exit early after stopAuto so the rest of post-unit processing
-            // (triage, rogue detection, hook dispatch, DB writes) doesn't run
+            // (triage, hook dispatch, DB writes) doesn't run
             // against a conflicted main checkout. Return "dispatched" to match
             // the convention used by other stop/pauseAuto paths in this function
             // (see signal handling earlier: stop/pause also return "dispatched").
@@ -652,17 +686,6 @@ export async function postUnitPreVerification(pctx, opts) {
                 logError("engine", "triage resolution failed", { error: err.message });
             }
         }
-        // Rogue file detection — safety net for LLM bypassing completion tools (D003)
-        try {
-            const rogueFiles = detectRogueFileWrites(s.currentUnit.type, s.currentUnit.id, s.basePath);
-            for (const rogue of rogueFiles) {
-                logWarning("engine", "rogue file write detected", { path: rogue.path, unitId: rogue.unitId });
-                ctx.ui.notify(`Rogue file write detected: ${rogue.path}`, "warning");
-            }
-        }
-        catch (e) {
-            debugLog("postUnit", { phase: "rogue-detection", error: String(e) });
-        }
         // ── Safety harness: post-unit validation ──
         try {
             const { loadEffectiveGSDPreferences } = await import("./preferences.js");
@@ -796,13 +819,40 @@ export async function postUnitPreVerification(pctx, opts) {
                     debugLog("postUnit", { phase: "regenerate-projection", error: String(e) });
                 }
             }
+            if (s.currentUnit.type === "research-project") {
+                try {
+                    clearProjectResearchInflightMarker(s.basePath);
+                }
+                catch (e) {
+                    debugLog("postUnit", { phase: "research-project-inflight-cleanup", error: String(e) });
+                }
+            }
+            if (!triggerArtifactVerified && s.currentUnit.type === "research-project") {
+                const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
+                const outcome = finalizeProjectResearchTimeout(s.basePath, "Project research unit ended before all required dimensions produced durable files.");
+                s.pendingVerificationRetry = null;
+                s.verificationRetryCount.delete(retryKey);
+                triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                if (triggerArtifactVerified) {
+                    invalidateAllCaches();
+                    ctx.ui.notify(outcome.kind === "partial-blockers"
+                        ? "Project research finished partially; wrote blockers for missing dimensions and advancing without rerunning all scouts."
+                        : "Project research artifacts are now terminal.", "warning");
+                }
+                else {
+                    ctx.ui.notify("Project research produced no usable research files; wrote PROJECT-RESEARCH-BLOCKER.md and continuing fail-closed.", "error");
+                    return "continue";
+                }
+            }
             // When artifact verification fails for a unit type that has a known expected
-            // artifact, return "retry" so the caller re-dispatches with failure context
+            // artifact, ask the caller to retry so it re-dispatches with failure context
             // instead of blindly re-dispatching the same unit (#1571).
             // Retries are capped at MAX_ARTIFACT_VERIFICATION_RETRIES to prevent
             // unbounded loops (#2007).
             //
             // Pre-checks short-circuit retry for known-unrecoverable failures:
+            // - User-input waits in deep setup: pause instead of retrying or writing
+            //   placeholders while the agent is waiting for approval.
             // - Deterministic policy rejection (#4973): structural write-gate failure
             //   that will recur on every retry, so write a blocker placeholder.
             // - DB infra failure (#2517): completion tool returned db_unavailable, so
@@ -810,11 +860,22 @@ export async function postUnitPreVerification(pctx, opts) {
             // - Tool invocation error (#2883/#3595): malformed JSON args or queued
             //   user message — retry will produce the same failure.
             //
-            // #4973: Deterministic policy rejections (e.g. context_write_blocked from the
-            // write-gate) are checked FIRST — before the DB-availability check — because
-            // they are structural gates that will fire on every retry regardless of DB or
-            // model tier. Short-circuit immediately by writing a blocker placeholder.
-            if (!triggerArtifactVerified && s.lastToolInvocationError && isDeterministicPolicyError(s.lastToolInvocationError)) {
+            // User-driven deep setup prompts may ask for approval before the final
+            // root artifact write. If a premature write hits the write gate in the
+            // same turn, the user wait is the meaningful state; pause instead of
+            // writing a placeholder over PROJECT/REQUIREMENTS.
+            if (!triggerArtifactVerified && USER_DRIVEN_DEEP_UNITS.has(s.currentUnit.type) && isAwaitingUserInput(opts?.agentEndMessages)) {
+                debugLog("postUnit", {
+                    phase: "artifact-verify-awaiting-user",
+                    unitType: s.currentUnit.type,
+                    unitId: s.currentUnit.id,
+                });
+                ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} is waiting for your input — pausing auto-mode instead of retrying the missing artifact.`, "info");
+                s.lastToolInvocationError = null;
+                await pauseAuto(ctx, pi);
+                return "dispatched";
+            }
+            else if (!triggerArtifactVerified && s.lastToolInvocationError && isDeterministicPolicyError(s.lastToolInvocationError)) {
                 const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
                 debugLog("postUnit", { phase: "deterministic-policy-error-placeholder", unitType: s.currentUnit.type, unitId: s.currentUnit.id, error: s.lastToolInvocationError });
                 const reason = `Deterministic policy rejection for ${s.currentUnit.type} "${s.currentUnit.id}": ${s.lastToolInvocationError}. Retrying cannot resolve this gate — writing blocker placeholder to advance pipeline.`;
@@ -846,21 +907,22 @@ export async function postUnitPreVerification(pctx, opts) {
                 if (hasExpectedArtifact) {
                     const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
+                    const failureDetails = describeArtifactVerificationFailure(s.currentUnit.type, s.currentUnit.id, s.basePath);
                     if (attempt > MAX_ARTIFACT_VERIFICATION_RETRIES) {
                         s.verificationRetryCount.delete(retryKey);
                         debugLog("postUnit", { phase: "artifact-verify-exhausted", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
-                        ctx.ui.notify(`Artifact still missing for ${s.currentUnit.type} ${s.currentUnit.id} after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries — pausing auto-mode`, "error");
+                        ctx.ui.notify(`${failureDetails} Pausing auto-mode after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries.`, "error");
                         await pauseAuto(ctx, pi);
                         return "dispatched";
                     }
                     s.verificationRetryCount.set(retryKey, attempt);
                     s.pendingVerificationRetry = {
                         unitId: s.currentUnit.id,
-                        failureContext: `Artifact verification failed: expected artifact for ${s.currentUnit.type} "${s.currentUnit.id}" was not found on disk after unit execution (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+                        failureContext: `${failureDetails} (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
                         attempt,
                     };
                     debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
-                    ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — retrying (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES})`, "warning");
+                    ctx.ui.notify(`${failureDetails} Retrying (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`, "warning");
                     return "retry";
                 }
             }

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
@@ -77,17 +77,17 @@ function capPreamble(preamble) {
  * Uses the budget engine to compute task count ranges and inline context budgets
  * based on the configured executor model's context window.
  */
-function formatExecutorConstraints(sessionContextWindow, modelRegistry) {
+function formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionProvider) {
     let windowTokens;
     try {
         const prefs = loadEffectiveGSDPreferences();
-        windowTokens = resolveExecutorContextWindow(modelRegistry, prefs?.preferences, sessionContextWindow);
+        windowTokens = resolveExecutorContextWindow(modelRegistry, prefs?.preferences, sessionContextWindow, sessionProvider);
     }
     catch (e) {
         logWarning("prompt", `resolveExecutorContextWindow failed: ${e.message}`);
         // Delegate to the budget engine without prefs (the path that just threw)
         // so DEFAULT_CONTEXT_WINDOW stays the single source of truth.
-        windowTokens = resolveExecutorContextWindow(undefined, undefined, sessionContextWindow);
+        windowTokens = resolveExecutorContextWindow(undefined, undefined, sessionContextWindow, sessionProvider);
     }
     const budgets = computeBudgets(windowTokens);
     const { min, max } = budgets.taskCountRange;
@@ -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,
@@ -1074,6 +1136,73 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
     }
     return basePrompt;
 }
+/**
+ * Build a prompt for the workflow-preferences unit type (deep mode).
+ * Default-writing stage: records high-impact workflow defaults in
+ * .gsd/PREFERENCES.md. Runs ONCE per project, early
+ * in deep-mode bootstrap before discuss-project.
+ */
+export async function buildWorkflowPreferencesPrompt(base, structuredQuestionsAvailable = "false") {
+    return loadPrompt("guided-workflow-preferences", {
+        workingDirectory: base,
+        structuredQuestionsAvailable,
+    });
+}
+/**
+ * Build a prompt for the research-project (parallel) unit type (deep mode).
+ * Orchestrator that spawns 4 parallel Task() calls covering stack, features,
+ * architecture, and pitfalls. Each subagent writes its findings to .gsd/research/.
+ * Fires after research-decision marker says "research" and project research files
+ * are missing. Skipped entirely if user picked "skip".
+ */
+export async function buildResearchProjectPrompt(base, structuredQuestionsAvailable = "false") {
+    return loadPrompt("guided-research-project", {
+        workingDirectory: base,
+        structuredQuestionsAvailable,
+    });
+}
+/**
+ * Build a prompt for the research-decision unit type (deep mode).
+ * Fixed-question stage: asks "research first or skip?" via ask_user_questions
+ * and writes .gsd/runtime/research-decision.json. Fires after discuss-requirements
+ * and before research-project-parallel.
+ */
+export async function buildResearchDecisionPrompt(base, structuredQuestionsAvailable = "false") {
+    return loadPrompt("guided-research-decision", {
+        workingDirectory: base,
+        structuredQuestionsAvailable,
+    });
+}
+/**
+ * Build a prompt for the discuss-project unit type (deep mode).
+ * Project-level interview: produces .gsd/PROJECT.md.
+ * Fires before any milestone-level work when planning_depth === "deep" and
+ * PROJECT.md is missing.
+ */
+export async function buildDiscussProjectPrompt(base, structuredQuestionsAvailable = "false") {
+    const inlinedTemplates = inlineTemplate("project", "Project");
+    return loadPrompt("guided-discuss-project", {
+        workingDirectory: base,
+        inlinedTemplates,
+        structuredQuestionsAvailable,
+        commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
+    });
+}
+/**
+ * Build a prompt for the discuss-requirements unit type (deep mode).
+ * Requirements-level interview: produces .gsd/REQUIREMENTS.md using the
+ * structured R### format. Reads PROJECT.md as authoritative context.
+ * Fires when planning_depth === "deep", PROJECT.md exists, and REQUIREMENTS.md is missing.
+ */
+export async function buildDiscussRequirementsPrompt(base, structuredQuestionsAvailable = "false") {
+    const inlinedTemplates = inlineTemplate("requirements", "Requirements");
+    return loadPrompt("guided-discuss-requirements", {
+        workingDirectory: base,
+        inlinedTemplates,
+        structuredQuestionsAvailable,
+        commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
+    });
+}
 export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     // #4782 phase 3: research-milestone migrated through the composer.
     // Declared inline order: milestone-context, project, requirements,
@@ -1305,7 +1434,7 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
  * sketch-scope constraint).
  */
 async function renderSlicePrompt(options) {
-    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {}, sessionContextWindow, modelRegistry, } = options;
+    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {}, sessionContextWindow, modelRegistry, sessionProvider, } = options;
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
@@ -1355,7 +1484,7 @@ async function renderSlicePrompt(options) {
     if (overridesInline)
         inlined.unshift(overridesInline);
     const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
-    const executorContextConstraints = formatExecutorConstraints(sessionContextWindow, modelRegistry);
+    const executorContextConstraints = formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionProvider);
     const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
     const commitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
     return loadPrompt(promptTemplate, {
@@ -1412,6 +1541,7 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
         prependBlocks,
         sessionContextWindow: options?.sessionContextWindow,
         modelRegistry: options?.modelRegistry,
+        sessionProvider: options?.sessionProvider,
     });
 }
 /**
@@ -1446,6 +1576,7 @@ export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base,
         extraVars: { sketchScope },
         sessionContextWindow: options?.sessionContextWindow,
         modelRegistry: options?.modelRegistry,
+        sessionProvider: options?.sessionProvider,
     });
 }
 export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, level) {
@@ -1511,7 +1642,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const overridesSection = formatOverridesSection(activeOverrides);
     // Compute verification budget for the executor's context window (issue #707)
     const prefs = loadEffectiveGSDPreferences();
-    const contextWindow = resolveExecutorContextWindow(opts.modelRegistry, prefs?.preferences, opts.sessionContextWindow);
+    const contextWindow = resolveExecutorContextWindow(opts.modelRegistry, prefs?.preferences, opts.sessionContextWindow, opts.sessionProvider);
     const budgets = computeBudgets(contextWindow);
     const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
     // Truncate carry-forward section when it exceeds 40% of inline context budget.
@@ -2181,6 +2312,7 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
             carryForwardPaths: depPaths,
             sessionContextWindow: opts?.sessionContextWindow,
             modelRegistry: opts?.modelRegistry,
+            sessionProvider: opts?.sessionProvider,
         });
         const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
@@ -2262,6 +2394,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 +2422,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 +2537,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",