gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

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

@@ -1,14 +1,14 @@
 /**
- * Post-unit processing for handleAgentEnd — auto-commit, doctor run,
+ * Post-unit processing for auto-loop — auto-commit, doctor run,
  * state rebuild, worktree sync, DB dual-write, hooks, triage, and
  * quick-task dispatch.
  *
- * Split into two functions called sequentially by handleAgentEnd with
+ * Split into two functions called sequentially by auto-loop with
  * the verification gate between them:
  *   1. postUnitPreVerification() — commit, doctor, state rebuild, worktree sync, artifact verification
  *   2. postUnitPostVerification() — DB dual-write, hooks, triage, quick-tasks
  *
- * Extracted from handleAgentEnd() in auto.ts.
+ * Extracted from the pre-loop agent_end handler in auto.ts.
  */
 import { deriveState } from "./state.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -19,7 +19,7 @@ import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
-import { autoCommitCurrentBranch, } from "./worktree.js";
+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";
@@ -42,6 +42,9 @@ import { getSliceTasks } from "./gsd-db.js";
 import { runPreExecutionChecks } from "./pre-execution-checks.js";
 import { writePreExecutionEvidence } from "./verification-evidence.js";
 import { ensureCodebaseMapFresh } from "./codebase-generator.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { UokGateRunner } from "./uok/gate-runner.js";
+import { writeTurnGitTransaction } from "./uok/gitops.js";
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
 /** Enqueue a sidecar item (hook, triage, or quick-task) for the main loop to
@@ -63,7 +66,7 @@ function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
  *  next actual task commit via `smartStage()`. */
 const LIFECYCLE_ONLY_UNITS = new Set([
     "research-milestone", "discuss-milestone", "discuss-slice", "plan-milestone",
-    "validate-milestone", "research-slice", "plan-slice",
+    "validate-milestone", "research-slice", "plan-slice", "refine-slice",
     "replan-slice", "complete-slice", "run-uat",
     "reassess-roadmap", "rewrite-docs",
 ]);
@@ -71,6 +74,7 @@ import { describeNextUnit, } from "./auto-dashboard.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
+import { autoCommitCurrentBranch } from "./worktree.js";
 /**
  * Detect summary files written directly to disk without the LLM calling
  * the completion tool. A "rogue" file is one that exists on disk but has
@@ -135,7 +139,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
             rogues.push({ path: roadmapPath, unitType, unitId });
         }
     }
-    else if (unitType === "plan-slice" || unitType === "replan-slice") {
+    else if (unitType === "plan-slice" || unitType === "refine-slice" || unitType === "replan-slice") {
         if (!mid || !sid)
             return [];
         const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
@@ -189,6 +193,57 @@ export function buildStepCompleteMessage(nextState) {
     return `Step complete. Next: ${next.label}\n`
         + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
 }
+export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
+    try {
+        let taskContext;
+        if (unitType === "execute-task") {
+            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+            if (mid && sid && tid) {
+                const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+                if (summaryPath) {
+                    try {
+                        const summaryContent = await loadFile(summaryPath);
+                        if (summaryContent) {
+                            const summary = parseSummary(summaryContent);
+                            let ghIssueNumber;
+                            try {
+                                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+                            }
+                            catch (err) {
+                                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+                            }
+                            taskContext = {
+                                taskId: `${sid}/${tid}`,
+                                taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                                oneLiner: summary.oneLiner || undefined,
+                                keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                                issueNumber: ghIssueNumber,
+                            };
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+                    }
+                }
+            }
+        }
+        _resetHasChangesCache();
+        if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
+            return null;
+        }
+        const commitMsg = autoCommitCurrentBranch(basePath, unitType, unitId, taskContext);
+        if (commitMsg) {
+            ctx?.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+        }
+        return commitMsg;
+    }
+    catch (e) {
+        debugLog("postUnit", { phase: "auto-commit", error: String(e) });
+        ctx?.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
+        return null;
+    }
+}
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -221,12 +276,19 @@ export async function postUnitPreVerification(pctx, opts) {
     if (!opts?.skipSettleDelay) {
         await new Promise(r => setTimeout(r, 100));
     }
-    // Auto-commit
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const uokFlags = resolveUokFlags(prefs);
+    // Turn-level git action (commit | snapshot | status-only)
     if (s.currentUnit) {
         const unit = s.currentUnit;
+        const turnAction = uokFlags.gitops ? uokFlags.gitopsTurnAction : "commit";
+        const traceId = s.currentTraceId ?? `turn:${unit.startedAt}`;
+        const turnId = s.currentTurnId ?? `${unit.type}/${unit.id}/${unit.startedAt}`;
+        s.lastGitActionFailure = null;
+        s.lastGitActionStatus = null;
         try {
             let taskContext;
-            if (s.currentUnit.type === "execute-task") {
+            if (turnAction === "commit" && s.currentUnit.type === "execute-task") {
                 const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
                 if (mid && sid && tid) {
                     const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
@@ -266,19 +328,101 @@ export async function postUnitPreVerification(pctx, opts) {
             // code files only in the working tree where they are destroyed by
             // `git worktree remove --force` during teardown.
             _resetHasChangesCache();
-            // Skip auto-commit for lifecycle-only units (#2553) — they only touch
-            // `.gsd/` internal state files. Those files are picked up by the next
-            // actual task commit via smartStage().
-            if (!LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type)) {
-                const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
-                if (commitMsg) {
-                    ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+            const skipLifecycleCommit = turnAction === "commit" && LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type);
+            if (skipLifecycleCommit) {
+                debugLog("postUnit", {
+                    phase: "git-action-skipped",
+                    reason: "lifecycle-only-unit",
+                    unitType: s.currentUnit.type,
+                    unitId: s.currentUnit.id,
+                });
+            }
+            else {
+                const gitResult = runTurnGitAction({
+                    basePath: s.basePath,
+                    action: turnAction,
+                    unitType: s.currentUnit.type,
+                    unitId: s.currentUnit.id,
+                    taskContext,
+                });
+                if (uokFlags.gitops) {
+                    writeTurnGitTransaction({
+                        basePath: s.basePath,
+                        traceId,
+                        turnId,
+                        unitType: unit.type,
+                        unitId: unit.id,
+                        stage: "publish",
+                        action: turnAction,
+                        push: uokFlags.gitopsTurnPush,
+                        status: gitResult.status,
+                        error: gitResult.error,
+                        metadata: {
+                            dirty: gitResult.dirty,
+                            commitMessage: gitResult.commitMessage,
+                            snapshotLabel: gitResult.snapshotLabel,
+                        },
+                    });
+                }
+                if (gitResult.status === "failed") {
+                    s.lastGitActionFailure = gitResult.error ?? `git ${turnAction} failed`;
+                    s.lastGitActionStatus = "failed";
+                    if (uokFlags.gitops && uokFlags.gates) {
+                        const parsed = parseUnitId(unit.id);
+                        const gateRunner = new UokGateRunner();
+                        gateRunner.register({
+                            id: "closeout-git-action",
+                            type: "closeout",
+                            execute: async () => ({
+                                outcome: "fail",
+                                failureClass: "git",
+                                rationale: `turn git action "${turnAction}" failed`,
+                                findings: gitResult.error ?? "unknown git failure",
+                            }),
+                        });
+                        await gateRunner.run("closeout-git-action", {
+                            basePath: s.basePath,
+                            traceId,
+                            turnId,
+                            milestoneId: parsed.milestone ?? undefined,
+                            sliceId: parsed.slice ?? undefined,
+                            taskId: parsed.task ?? undefined,
+                            unitType: unit.type,
+                            unitId: unit.id,
+                        });
+                    }
+                    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");
+                    debugLog("postUnit", {
+                        phase: "git-action-failed-nonblocking",
+                        action: turnAction,
+                        error: gitResult.error ?? "unknown error",
+                    });
+                }
+                s.lastGitActionStatus = "ok";
+                if (turnAction === "commit" && gitResult.commitMessage) {
+                    ctx.ui.notify(`Committed: ${gitResult.commitMessage.split("\n")[0]}`, "info");
+                }
+                else if (turnAction === "snapshot" && gitResult.snapshotLabel) {
+                    ctx.ui.notify(`Snapshot recorded: ${gitResult.snapshotLabel}`, "info");
                 }
             }
         }
         catch (e) {
-            debugLog("postUnit", { phase: "auto-commit", error: String(e) });
-            ctx.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
+            const message = e instanceof Error ? e.message : String(e);
+            s.lastGitActionFailure = message;
+            s.lastGitActionStatus = "failed";
+            debugLog("postUnit", { phase: "git-action", error: message, action: turnAction });
+            ctx.ui.notify(`Git ${turnAction} failed: ${message.split("\n")[0]}`, uokFlags.gitops ? "error" : "warning");
+            if (uokFlags.gitops) {
+                await pauseAuto(ctx, pi);
+                return "dispatched";
+            }
         }
         // GitHub sync (non-blocking, opt-in)
         await runSafely("postUnit", "github-sync", async () => {
@@ -711,14 +855,18 @@ export async function postUnitPostVerification(pctx) {
             debugLog("postUnit", { phase: "capture-protection-error", error: String(e) });
         }
     }
-    // ── Pre-execution checks (after plan-slice completes) ──
+    // ── Pre-execution checks (after plan-slice or ADR-011 refine-slice completes) ──
+    // Both emit the same PLAN.md + task artifacts via gsd_plan_slice, so the
+    // same structural validation applies to both.
     if (s.currentUnit &&
-        s.currentUnit.type === "plan-slice") {
+        (s.currentUnit.type === "plan-slice" || s.currentUnit.type === "refine-slice")) {
+        const currentUnit = s.currentUnit;
         let preExecPauseNeeded = false;
         await runSafely("postUnitPostVerification", "pre-execution-checks", async () => {
+            const prefs = loadEffectiveGSDPreferences()?.preferences;
+            const uokFlags = resolveUokFlags(prefs);
             try {
                 // Check preferences — respect enhanced_verification and enhanced_verification_pre
-                const prefs = loadEffectiveGSDPreferences()?.preferences;
                 const enhancedEnabled = prefs?.enhanced_verification !== false; // default true
                 const preEnabled = prefs?.enhanced_verification_pre !== false; // default true
                 if (!enhancedEnabled || !preEnabled) {
@@ -730,7 +878,7 @@ export async function postUnitPostVerification(pctx) {
                     return;
                 }
                 // Parse the unit ID to get milestone/slice IDs
-                const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
+                const { milestone: mid, slice: sid } = parseUnitId(currentUnit.id);
                 if (!mid || !sid) {
                     debugLog("postUnitPostVerification", {
                         phase: "pre-execution-checks",
@@ -749,6 +897,7 @@ export async function postUnitPostVerification(pctx) {
                     });
                     return;
                 }
+                const strictMode = prefs?.enhanced_verification_strict === true;
                 // Run pre-execution checks
                 const result = await runPreExecutionChecks(tasks, s.basePath);
                 // Log summary to stderr in existing verification output format
@@ -764,10 +913,43 @@ export async function postUnitPostVerification(pctx) {
                 if (slicePath) {
                     writePreExecutionEvidence(result, slicePath, mid, sid);
                 }
-                // Notify UI
+                if (uokFlags.gates) {
+                    const failedChecks = result.checks
+                        .filter((check) => !check.passed)
+                        .map((check) => `[${check.category}] ${check.target}: ${check.message}`);
+                    const warnEscalated = result.status === "warn" && strictMode;
+                    const blockingFailure = result.status === "fail" || warnEscalated;
+                    const gateRunner = new UokGateRunner();
+                    gateRunner.register({
+                        id: "pre-execution-checks",
+                        type: "input",
+                        execute: async () => ({
+                            outcome: blockingFailure ? "fail" : "pass",
+                            failureClass: result.status === "fail" ? "input" : warnEscalated ? "policy" : "none",
+                            rationale: blockingFailure
+                                ? `pre-execution checks ${result.status}${warnEscalated ? " (strict)" : ""}`
+                                : "pre-execution checks passed",
+                            findings: failedChecks.join("\n"),
+                        }),
+                    });
+                    await gateRunner.run("pre-execution-checks", {
+                        basePath: s.basePath,
+                        traceId: `pre-execution:${currentUnit.id}`,
+                        turnId: currentUnit.id,
+                        milestoneId: mid,
+                        sliceId: sid,
+                        unitType: currentUnit.type,
+                        unitId: currentUnit.id,
+                    });
+                }
+                // Notify UI — surface actionable details (#4259)
                 if (result.status === "fail") {
-                    const blockingCount = result.checks.filter(c => !c.passed && c.blocking).length;
-                    ctx.ui.notify(`Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found`, "error");
+                    const blockingChecks = result.checks.filter(c => !c.passed && c.blocking);
+                    const blockingCount = blockingChecks.length;
+                    const details = blockingChecks.slice(0, 3).map(c => `  \u2022 ${c.message}`).join("\n");
+                    const suffix = blockingChecks.length > 3 ? `\n  \u2022 ...and ${blockingChecks.length - 3} more` : "";
+                    const evidenceNote = `\nSee ${sid}-PRE-EXEC-VERIFY.json for full details.`;
+                    ctx.ui.notify(`Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found\n${details}${suffix}${evidenceNote}`, "error");
                     preExecPauseNeeded = true;
                 }
                 else if (result.status === "warn") {
@@ -794,6 +976,29 @@ export async function postUnitPostVerification(pctx) {
                 });
                 logError("engine", `gsd-pre-exec: Pre-execution checks threw an error: ${errorMessage}`);
                 ctx.ui.notify(`Pre-execution checks error: ${errorMessage} — pausing for human review`, "error");
+                if (uokFlags.gates && s.currentUnit) {
+                    const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
+                    const gateRunner = new UokGateRunner();
+                    gateRunner.register({
+                        id: "pre-execution-checks",
+                        type: "input",
+                        execute: async () => ({
+                            outcome: "manual-attention",
+                            failureClass: "manual-attention",
+                            rationale: "pre-execution checks threw before completion",
+                            findings: errorMessage,
+                        }),
+                    });
+                    await gateRunner.run("pre-execution-checks", {
+                        basePath: s.basePath,
+                        traceId: `pre-execution:${s.currentUnit.id}`,
+                        turnId: s.currentUnit.id,
+                        milestoneId: mid ?? undefined,
+                        sliceId: sid ?? undefined,
+                        unitType: s.currentUnit.type,
+                        unitId: s.currentUnit.id,
+                    });
+                }
                 preExecPauseNeeded = true;
             }
         });

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

@@ -20,12 +20,53 @@ import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { logWarning } from "./workflow-logger.js";
+import { inlineGraphSubgraph } from "./graph-context.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
+/**
+ * Historical static ceiling for the preamble cap. Kept as an upper bound even
+ * after context-window-aware sizing so large-window users don't suddenly see
+ * 10× looser caps than before. Small-window users get a tighter cap derived
+ * from their configured executor window.
+ */
 const MAX_PREAMBLE_CHARS = 30_000;
+/**
+ * Resolve prompt budgets from the configured executor context window.
+ *
+ * The prompt builders here don't have access to the runtime model registry
+ * (they're called from many non-ctx sites), so `resolveExecutorContextWindow`
+ * is fed the user-configurable `context_window_override` preference as the
+ * `sessionContextWindow` fallback. That preference exists specifically to
+ * cover small-window local models (e.g. 32K lemonade/llama.cpp servers) whose
+ * n_ctx is not discoverable through the model registry. Issue #4435.
+ */
+function resolvePromptBudgets() {
+    try {
+        const prefs = loadEffectiveGSDPreferences();
+        const sessionWindow = prefs?.preferences.context_window_override;
+        const windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences, sessionWindow);
+        return computeBudgets(windowTokens);
+    }
+    catch (e) {
+        logWarning("prompt", `resolvePromptBudgets failed: ${e.message}`);
+        return computeBudgets(200_000);
+    }
+}
+/**
+ * Character budget for dependency/prior slice summaries injected into dispatch
+ * prompts. Scales with the executor's configured context window (issue #4435).
+ */
+function resolveSummaryBudgetChars() {
+    return resolvePromptBudgets().summaryBudgetChars;
+}
 function capPreamble(preamble) {
-    if (preamble.length <= MAX_PREAMBLE_CHARS)
+    // Cap inlined context at min(historical 30K ceiling, scaled inline budget).
+    // The ceiling preserves pre-fix behavior for large-window users; the scaled
+    // budget tightens the cap for small-window users whose true safe limit is
+    // below 30K. `computeBudgets` allocates 40% of total chars to inline context.
+    const budget = Math.min(MAX_PREAMBLE_CHARS, resolvePromptBudgets().inlineContextBudgetChars);
+    if (preamble.length <= budget)
         return preamble;
-    return truncateAtSectionBoundary(preamble, MAX_PREAMBLE_CHARS).content;
+    return truncateAtSectionBoundary(preamble, budget).content;
 }
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 /**
@@ -871,13 +912,13 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
  * as a seed when present. The discussion agent interviews the user, writes
  * a full CONTEXT.md, and the phase transitions to pre-planning automatically.
  */
-export async function buildDiscussMilestonePrompt(mid, midTitle, base) {
+export async function buildDiscussMilestonePrompt(mid, midTitle, base, structuredQuestionsAvailable = "false") {
     const discussTemplates = inlineTemplate("context", "Context");
     const basePrompt = loadPrompt("guided-discuss-milestone", {
         milestoneId: mid,
         milestoneTitle: midTitle,
         inlinedTemplates: discussTemplates,
-        structuredQuestionsAvailable: "false",
+        structuredQuestionsAvailable,
         commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
         fastPathInstruction: "",
     });
@@ -1040,8 +1081,12 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const knowledgeInlineRS = await inlineKnowledgeScoped(base, keywords);
     if (knowledgeInlineRS)
         inlined.push(knowledgeInlineRS);
+    // Knowledge graph: subgraph for this slice (graceful — skipped if no graph.json)
+    const graphBlockRS = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
+    if (graphBlockRS)
+        inlined.push(graphBlockRS);
     inlined.push(inlineTemplate("research", "Research"));
-    const depContent = await inlineDependencySummaries(mid, sid, base);
+    const depContent = await inlineDependencySummaries(mid, sid, base, resolveSummaryBudgetChars());
     const activeOverrides = await loadActiveOverrides(base);
     const overridesInline = formatOverridesSection(activeOverrides);
     if (overridesInline)
@@ -1068,26 +1113,35 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
         ...buildSkillDiscoveryVars(),
     });
 }
-export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, level) {
-    const inlineLevel = level ?? resolveInlineLevel();
+/**
+ * Shared assembly for plan-slice and refine-slice prompts. Both builders need
+ * the same inlined context (roadmap excerpt, slice context, research, decisions,
+ * requirements, knowledge, graph subgraph, templates, dependency summaries,
+ * overrides). Extracted to prevent drift between the two sites.
+ *
+ * `prependBlocks` are pushed onto the start of the inlined array BEFORE any
+ * shared content, so callers can add unit-specific headers (e.g., the refine
+ * sketch-scope constraint).
+ */
+async function renderSlicePrompt(options) {
+    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {} } = options;
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
     const researchRel = relSliceFile(base, mid, sid, "RESEARCH");
     const sliceContextPath = resolveSliceFile(base, mid, sid, "CONTEXT");
     const sliceContextRel = relSliceFile(base, mid, sid, "CONTEXT");
-    const inlined = [];
-    // Inject phase handoff anchor from research phase (if available)
+    const inlined = [...prependBlocks];
+    // Phase handoff anchor from research phase (if available)
     const researchSliceAnchor = readPhaseAnchor(base, mid, "research-slice");
     if (researchSliceAnchor)
         inlined.push(formatAnchorForPrompt(researchSliceAnchor));
-    // Use roadmap excerpt instead of full roadmap for context reduction
-    const roadmapExcerptPS = await inlineRoadmapExcerpt(base, mid, sid);
-    if (roadmapExcerptPS) {
-        inlined.push(roadmapExcerptPS);
+    // Roadmap excerpt with full-roadmap fallback
+    const roadmapExcerpt = await inlineRoadmapExcerpt(base, mid, sid);
+    if (roadmapExcerpt) {
+        inlined.push(roadmapExcerpt);
     }
     else {
-        // Fall back to full roadmap if excerpt fails
         inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     }
     const sliceCtxInline = await inlineFileOptional(sliceContextPath, sliceContextRel, "Slice Context (from discussion)");
@@ -1096,36 +1150,34 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const researchInline = await inlineFileOptional(researchPath, researchRel, "Slice Research");
     if (researchInline)
         inlined.push(researchInline);
-    if (inlineLevel !== "minimal") {
-        // Derive scope from slice title for decision filtering (R005)
-        const derivedScopePS = deriveSliceScope(sTitle);
-        const decisionsInline = await inlineDecisionsFromDb(base, mid, derivedScopePS, inlineLevel);
+    if (level !== "minimal") {
+        const derivedScope = deriveSliceScope(sTitle);
+        const decisionsInline = await inlineDecisionsFromDb(base, mid, derivedScope, level);
         if (decisionsInline)
             inlined.push(decisionsInline);
-        const requirementsInline = await inlineRequirementsFromDb(base, mid, sid, inlineLevel);
+        const requirementsInline = await inlineRequirementsFromDb(base, mid, sid, level);
         if (requirementsInline)
             inlined.push(requirementsInline);
     }
-    // Use scoped knowledge based on slice title keywords
-    const keywordsPS = extractKeywords(sTitle);
-    const knowledgeInlinePS = await inlineKnowledgeScoped(base, keywordsPS);
-    if (knowledgeInlinePS)
-        inlined.push(knowledgeInlinePS);
+    const knowledgeInline = await inlineKnowledgeScoped(base, extractKeywords(sTitle));
+    if (knowledgeInline)
+        inlined.push(knowledgeInline);
+    const graphBlock = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
+    if (graphBlock)
+        inlined.push(graphBlock);
     inlined.push(inlineTemplate("plan", "Slice Plan"));
-    if (inlineLevel === "full") {
+    if (level === "full") {
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
     }
-    const depContent = await inlineDependencySummaries(mid, sid, base);
-    const planActiveOverrides = await loadActiveOverrides(base);
-    const planOverridesInline = formatOverridesSection(planActiveOverrides);
-    if (planOverridesInline)
-        inlined.unshift(planOverridesInline);
+    const depContent = await inlineDependencySummaries(mid, sid, base, resolveSummaryBudgetChars());
+    const overridesInline = formatOverridesSection(await loadActiveOverrides(base));
+    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")}`);
-    // Build executor context constraints from the budget engine
     const executorContextConstraints = formatExecutorConstraints();
     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("plan-slice", {
+    return loadPrompt(promptTemplate, {
         workingDirectory: base,
         milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
         slicePath: relSlicePath(base, mid, sid),
@@ -1144,6 +1196,56 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
             sliceTitle: sTitle,
             extraContext: [inlinedContext, depContent],
         }),
+        ...extraVars,
+    });
+}
+export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, level, options) {
+    const prependBlocks = [];
+    // ADR-011: when the refining-phase dispatch rule gracefully downgrades to
+    // plan-slice (progressive_planning was toggled off mid-milestone), it
+    // forwards the stored sketch_scope as a SOFT hint — context, not a hard
+    // constraint. The planner is free to expand beyond it.
+    if (options?.softScopeHint && options.softScopeHint.trim().length > 0) {
+        prependBlocks.push(`## Prior Sketch Scope (soft hint — non-binding)\n\n${options.softScopeHint.trim()}\n\n` +
+            `This scope was captured during an earlier progressive-planning pass that was later disabled. Treat it as context only — you may plan beyond it if the work genuinely requires more scope. Do NOT treat this as a hard boundary.`);
+    }
+    return renderSlicePrompt({
+        mid, sid, sTitle, base,
+        level: level ?? resolveInlineLevel(),
+        promptTemplate: "plan-slice",
+        prependBlocks,
+    });
+}
+/**
+ * ADR-011 refine-slice: expand a sketch into a full plan using the current
+ * codebase state and prior slice summary. Mechanically similar to plan-slice
+ * but framed as a *transformation* (sketch → full plan) rather than a
+ * blank-sheet planning pass. Reuses inlineDependencySummaries for prior
+ * slice SUMMARY and inlines the stored sketch_scope as a hard constraint.
+ */
+export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base, level) {
+    // Pull the stored sketch scope from the DB — the hard constraint we plan within.
+    let sketchScope = "";
+    try {
+        const { isDbAvailable, getSlice } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            sketchScope = getSlice(mid, sid)?.sketch_scope ?? "";
+        }
+    }
+    catch {
+        sketchScope = "";
+    }
+    const prependBlocks = [];
+    if (sketchScope.trim().length > 0) {
+        prependBlocks.push(`## Sketch Scope (hard constraint)\n\n${sketchScope.trim()}\n\n` +
+            `Treat this as the authoritative boundary for the slice. Do not plan work outside this scope; if the scope is too narrow, surface it as a deviation rather than expanding silently.`);
+    }
+    return renderSlicePrompt({
+        mid, sid, sTitle, base,
+        level: level ?? resolveInlineLevel(),
+        promptTemplate: "refine-slice",
+        prependBlocks,
+        extraVars: { sketchScope },
     });
 }
 export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, level) {
@@ -1194,12 +1296,15 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         : null;
     // Only include if it has content (not a "not found" result)
     const knowledgeContent = knowledgeInlineET && !knowledgeInlineET.includes("not found") ? knowledgeInlineET : null;
+    // Knowledge graph: tight subgraph for this task (graceful — skipped if no graph.json)
+    const graphBlockET = await inlineGraphSubgraph(base, `${tid} ${tTitle}`, { budget: 2000 });
     const inlinedTemplates = inlineLevel === "minimal"
         ? inlineTemplate("task-summary", "Task Summary")
         : [
             inlineTemplate("task-summary", "Task Summary"),
             inlineTemplate("decisions", "Decisions"),
             ...(knowledgeContent ? [knowledgeContent] : []),
+            ...(graphBlockET ? [graphBlockET] : []),
         ].join("\n\n---\n\n");
     const taskSummaryPath = join(base, `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`);
     const activeOverrides = await loadActiveOverrides(base);
@@ -1221,7 +1326,28 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const runtimeContext = runtimeContent
         ? `### Runtime Context\nSource: \`.gsd/RUNTIME.md\`\n\n${runtimeContent.trim()}`
         : "";
-    const phaseAnchorSection = planAnchor ? formatAnchorForPrompt(planAnchor) : "";
+    let phaseAnchorSection = planAnchor ? formatAnchorForPrompt(planAnchor) : "";
+    // ADR-011 Phase 2: inject any resolved-but-unapplied escalation override
+    // into this task's prompt. Claim is atomic via DB UPDATE WHERE IS NULL, so
+    // if a parallel build already injected it, we skip. Feature-gated by
+    // phases.mid_execution_escalation. Prepended to phaseAnchorSection so it
+    // appears near the top of the prompt above planning anchors.
+    if (prefs?.preferences?.phases?.mid_execution_escalation === true) {
+        try {
+            const { claimOverrideForInjection } = await import("./escalation.js");
+            const claimed = claimOverrideForInjection(base, mid, sid);
+            if (claimed) {
+                const block = claimed.injectionBlock + "\n\n---\n\n";
+                phaseAnchorSection = phaseAnchorSection
+                    ? `${block}${phaseAnchorSection}`
+                    : block;
+            }
+        }
+        catch (escalationErr) {
+            // Escalation module unavailable or threw — log and proceed.
+            logWarning("prompt", `escalation override injection failed: ${escalationErr.message}`);
+        }
+    }
     // Task-scoped gates owned by execute-task (Q5/Q6/Q7). Pull only the
     // gates that plan-slice actually seeded for this task — tasks with no
     // external dependencies legitimately skip Q5, tasks with no runtime