gsd-pi 2.82.0 → 3.0.0-dev.8b8d129d7

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

@@ -728,12 +728,20 @@ export async function inlineDecisionsFromDb(base, milestoneId, scope, level) {
     try {
         const { isDbAvailable } = await import("./gsd-db.js");
         if (isDbAvailable()) {
-            const { queryDecisions, formatDecisionsForPrompt } = await import("./context-store.js");
+            // ADR-013 Phase 6 cutover (Stage 1): read decisions from the `memories`
+            // table. Both `queryDecisions` (legacy) and `queryDecisionsFromMemories`
+            // return identical Decision[] for active rows once Phase 5 dual-write is
+            // caught up. Switching the read here lets the destructive Phase 6 step
+            // (#5755) retire the legacy `decisions` table without changing prompt
+            // contents. Projection regen (`DECISIONS.md`) still sources from the
+            // legacy table — that switch lands separately to handle superseded
+            // history cleanly.
+            const { queryDecisionsFromMemories, formatDecisionsForPrompt } = await import("./context-store.js");
             // First query: try with both milestoneId and scope (if scope provided)
-            let decisions = queryDecisions({ milestoneId, scope });
+            let decisions = queryDecisionsFromMemories({ milestoneId, scope });
             // Cascade: if empty AND scope was provided, retry without scope
             if (decisions.length === 0 && scope) {
-                decisions = queryDecisions({ milestoneId });
+                decisions = queryDecisionsFromMemories({ milestoneId });
             }
             if (decisions.length > 0) {
                 // Use compact format for non-full levels to save ~35% tokens
@@ -2689,14 +2697,40 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         readyTaskListLines.push(`- **${tid}: ${tTitle}**`);
         // Build dependency-scoped carry-forward paths for this task
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
-        // Build a full execute-task prompt with dependency-based carry-forward
-        const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
-            carryForwardPaths: depPaths,
-            sessionContextWindow: opts?.sessionContextWindow,
-            modelRegistry: opts?.modelRegistry,
-            sessionProvider: opts?.sessionProvider,
-            contextModeRenderMode: "nested",
-        });
+        const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
+        const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
+        const taskPlanRelPath = `${relSlicePath(base, mid, sid)}/tasks/${tid}-PLAN.md`;
+        const taskPlanInline = taskPlanContent
+            ? [
+                "## Inlined Task Plan (authoritative local execution contract)",
+                `Source: \`${taskPlanRelPath}\``,
+                "",
+                taskPlanContent.trim(),
+            ].join("\n")
+            : [
+                "## Inlined Task Plan (authoritative local execution contract)",
+                `Task plan not found at dispatch time. Read \`${taskPlanRelPath}\` before executing.`,
+            ].join("\n");
+        const carryForwardSection = await buildCarryForwardSection(depPaths, base);
+        const taskSummaryPath = `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`;
+        const taskPrompt = [
+            `## UNIT: Execute Task ${tid} ("${tTitle}")`,
+            "",
+            "Work only in the repository root.",
+            "Implement from the inlined task plan below. Verify changes, then call `gsd_task_complete`.",
+            "Do not run git commands.",
+            "",
+            carryForwardSection,
+            "",
+            taskPlanInline,
+            "",
+            "## Completion Contract",
+            `- Call \`gsd_task_complete\` with camelCase fields: \`milestoneId\`, \`sliceId\`, \`taskId\`, \`oneLiner\`, \`narrative\`, \`verification\`, and \`verificationEvidence\`.`,
+            `- Do not manually write \`${taskSummaryPath}\` or edit PLAN checkboxes; the completion tool is canonical.`,
+            `- Use \`blocker_discovered: true\` only if the task cannot be completed due to a real blocker.`,
+            "",
+            `When done, say: "Task ${tid} complete."`,
+        ].join("\n");
         const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${tid}: ${tTitle}`,
@@ -2769,7 +2803,7 @@ export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, b
         subagentSections.push([
             `### ${slice.id}: ${slice.title}`,
             "",
-            `Use this as the prompt for a \`subagent\` call${modelSuffix} (agent: \`gsd-executor\` or the default agent):`,
+            `Use this as the prompt for a \`subagent\` call${modelSuffix} (agent: \`scout\`):`,
             "",
             "```",
             slicePrompt,
@@ -2838,7 +2872,7 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base,
         subagentSections.push([
             `### ${def.id}: ${def.question}`,
             "",
-            `Use this as the prompt for a \`subagent\` call${modelSuffix}:`,
+            `Use this as the prompt for a \`subagent\` call${modelSuffix} (agent: \`tester\`):`,
             "",
             "```",
             subPrompt,

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

@@ -14,7 +14,8 @@ import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
 import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
-import { logWarning } from "./workflow-logger.js";
+import { getErrorMessage } from "./error-utils.js";
+import { logWarning, logError } from "./workflow-logger.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { isClosedStatus } from "./status-guards.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
@@ -23,11 +24,36 @@ import { execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
+import { hasVerdict } from "./verdict-parser.js";
 import { validateArtifact } from "./schemas/validate.js";
 import { getProjectResearchStatus } from "./project-research-policy.js";
+import { isGsdWorktreePath } from "./worktree-root.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
+// ─── Artifact Resolution & Verification ───────────────────────────────────────
+export function diagnoseWorktreeIntegrityFailure(basePath) {
+    if (!isGsdWorktreePath(basePath))
+        return null;
+    if (!existsSync(basePath)) {
+        return `Worktree integrity failure: ${basePath} does not exist. Repair or recreate the worktree before retrying.`;
+    }
+    const gitPath = join(basePath, ".git");
+    if (!existsSync(gitPath)) {
+        return `Worktree integrity failure: ${basePath} is not a valid git worktree (.git missing). Repair or recreate the worktree before retrying.`;
+    }
+    try {
+        execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return null;
+    }
+    catch (err) {
+        return `Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${getErrorMessage(err).split("\n")[0]}). Repair or recreate the worktree before retrying.`;
+    }
+}
 export function refreshRecoveryDbForArtifact(unitType, unitId) {
     if (unitType !== "plan-slice" && unitType !== "execute-task")
         return { ok: true };
@@ -137,9 +163,16 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // Strategy: check `git diff --name-only` against the merge-base with the
         // main branch. This captures ALL files changed during the milestone's
         // lifetime while running on a milestone branch.
-        const integrationBranch = milestoneId
-            ? readIntegrationBranch(basePath, milestoneId) ?? detectMainBranch(basePath)
-            : detectMainBranch(basePath);
+        const recordedIntegrationBranch = milestoneId
+            ? readIntegrationBranch(basePath, milestoneId)
+            : null;
+        let integrationBranch;
+        if (recordedIntegrationBranch?.startsWith("milestone/")) {
+            integrationBranch = detectMainBranch(basePath);
+        }
+        else {
+            integrationBranch = recordedIntegrationBranch ?? detectMainBranch(basePath);
+        }
         const currentBranch = getCurrentBranch(basePath);
         const branchDiff = getChangedFilesSinceBranch(basePath, integrationBranch);
         if (!branchDiff.ok)
@@ -471,29 +504,49 @@ function commitMatchesMilestone(basePath, message, milestoneId, files) {
     // 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 or local GSD state proves the task belongs here.
+    // names the milestone, local GSD state proves the task belongs here, or the
+    // commit is implementation-bearing evidence itself (#5100).
     if (/^GSD-Task:\s*S[^/\s]+\/T\S+/m.test(message)) {
         if (files.some((file) => isMilestoneArtifactPath(file, milestoneId)))
             return true;
         if (commitMessageMentionsMilestone(message, milestoneId))
             return true;
-        if (commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId))
+        const taskTrailerOwnership = getTaskOwnershipStatus(basePath, message, milestoneId);
+        if (taskTrailerOwnership === true)
+            return true;
+        if (taskTrailerOwnership === false)
+            return false;
+        // taskTrailerOwnership === null: unknown ownership. Apply fallback only
+        // in this case to avoid cross-milestone attribution.
+        if (MILESTONE_ID_RE.test(milestoneId) && classifyImplementationFiles(files) === "present")
             return true;
     }
     return false;
 }
-function commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId) {
+/**
+ * Tri-state task ownership probe.
+ * true => DB or local files confirm this milestone owns the task.
+ * false => DB is available and this milestone is registered, but task is absent.
+ * null => ownership unknown (milestone not in DB yet, or no DB + no local files).
+ */
+function getTaskOwnershipStatus(basePath, message, milestoneId) {
     const match = message.match(/^GSD-Task:\s*(S[^/\s]+)\/(T[^\s]+)/m);
     if (!match)
-        return false;
+        return null;
     const [, sliceId, taskId] = match;
-    if (getTask(milestoneId, sliceId, taskId))
-        return true;
+    if (isDbAvailable()) {
+        if (!getMilestone(milestoneId))
+            return null;
+        return getTask(milestoneId, sliceId, taskId) ? true : false;
+    }
+    // DB unavailable: fallback to local task-file presence.
     const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
-    if (!tasksDir)
-        return false;
-    return existsSync(join(tasksDir, `${taskId}-PLAN.md`))
-        || existsSync(join(tasksDir, `${taskId}-SUMMARY.md`));
+    if (tasksDir
+        && (existsSync(join(tasksDir, `${taskId}-PLAN.md`))
+            || existsSync(join(tasksDir, `${taskId}-SUMMARY.md`)))) {
+        return true;
+    }
+    return null;
 }
 function commitMessageMentionsMilestone(message, milestoneId) {
     if (!MILESTONE_ID_RE.test(milestoneId))
@@ -673,6 +726,11 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         return false;
     }
     if (!existsSync(absPath)) {
+        const worktreeFailure = diagnoseWorktreeIntegrityFailure(base);
+        if (worktreeFailure) {
+            logError("recovery", `${worktreeFailure} Unit: ${unitType} ${unitId}.`);
+            return false;
+        }
         logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
         return false;
     }
@@ -683,6 +741,13 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             return false;
         }
     }
+    if (unitType === "run-uat") {
+        const assessmentContent = readFileSync(absPath, "utf-8");
+        if (!hasVerdict(assessmentContent)) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: assessment missing verdict at ${absPath}`);
+            return false;
+        }
+    }
     if (unitType === "plan-milestone") {
         try {
             const roadmap = parseLegacyRoadmap(readFileSync(absPath, "utf-8"));

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

@@ -21,10 +21,10 @@ import { invalidateAllCaches } from "./cache.js";
 import { writeLock, clearLock } from "./crash-recovery.js";
 import { acquireSessionLock, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
-import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, nativeBranchList, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchList, nativeBranchExists, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath, checkoutBranchWithStashGuard } from "./auto-worktree.js";
 import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
 import { worktreePath as getWorktreeDir, isInsideWorktreesDir } from "./worktree-manager.js";
 import { emitWorktreeOrphaned } from "./worktree-telemetry.js";
@@ -33,7 +33,7 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, openDatabase, getDbStatus } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getAllMilestones, openDatabase, getDbStatus } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
@@ -88,9 +88,11 @@ export function decideSurvivorAction(hasSurvivorBranch, phase) {
         return "finalize";
     return "none";
 }
-export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
+export function auditOrphanedMilestoneBranches(basePath, isolationMode, gitDeps = {}) {
     const recovered = [];
     const warnings = [];
+    const branchList = gitDeps.branchList ?? nativeBranchList;
+    const branchExists = gitDeps.branchExists ?? nativeBranchExists;
     // Skip in none mode — no milestone branches are created
     if (isolationMode === "none")
         return { recovered, warnings };
@@ -98,15 +100,16 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
     if (!isDbAvailable())
         return { recovered, warnings };
     let milestoneBranches;
+    let milestoneBranchListAvailable = true;
     try {
-        milestoneBranches = nativeBranchList(basePath, "milestone/*");
+        milestoneBranches = branchList(basePath, "milestone/*");
     }
     catch {
-        // git branch list failed — skip audit
-        return { recovered, warnings };
+        milestoneBranchListAvailable = false;
+        // git branch list failed — fall through with an empty branch set so the
+        // branch-less orphan pass can still run after per-milestone verification.
+        milestoneBranches = [];
     }
-    if (milestoneBranches.length === 0)
-        return { recovered, warnings };
     // Detect main branch for merge-check
     let mainBranch;
     try {
@@ -236,6 +239,71 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
             }
         }
     }
+    // Second pass (#5879): catch worktree directories stranded by a previous
+    // audit that deleted the milestone/* branch but failed to remove the
+    // directory (or the dir was orphaned by a separate path entirely, e.g.
+    // postflight-stash-restore-failed during closeout). The branch-keyed loop
+    // above is invisible to these cases — `nativeBranchList` returns nothing
+    // for the milestone, so the dir-cleanup block at line ~310 is never
+    // reached.
+    //
+    // Keyed on milestones whose DB status is `complete`. We do not iterate
+    // over arbitrary directories under .gsd/worktrees/ to avoid touching
+    // dirs that belong to an in-progress milestone whose branch was deleted
+    // separately — those are handled by the in-progress orphan path above
+    // when the branch is present, and by `/gsd doctor` when it is not.
+    const seenMilestoneIds = new Set(milestoneBranches.map((branch) => branch.replace(/^milestone\//, "")));
+    let completedMilestones = [];
+    try {
+        completedMilestones = getAllMilestones();
+    }
+    catch {
+        // DB read failure — skip the second pass; the first pass is still useful.
+        completedMilestones = [];
+    }
+    for (const m of completedMilestones) {
+        if (m.status !== "complete")
+            continue;
+        if (seenMilestoneIds.has(m.id))
+            continue; // already processed in the branch loop
+        if (!milestoneBranchListAvailable) {
+            try {
+                if (branchExists(basePath, `milestone/${m.id}`))
+                    continue;
+            }
+            catch (err) {
+                warnings.push(`Could not verify whether milestone/${m.id} still exists; skipping branch-less worktree cleanup for safety: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+        }
+        const wtDir = getWorktreeDir(basePath, m.id);
+        if (!existsSync(wtDir))
+            continue;
+        if (!isInsideWorktreesDir(basePath, wtDir)) {
+            warnings.push(`Orphaned worktree directory for ${m.id} is outside .gsd/worktrees/ — skipping removal for safety.`);
+            continue;
+        }
+        // Try `git worktree remove` first in case the dir is still registered
+        // (defensive — usually it is not when we reach this branch-less pass).
+        try {
+            nativeWorktreeRemove(basePath, wtDir, true);
+        }
+        catch (e) {
+            logWarning("engine", `worktree remove failed (expected for branch-less orphans): ${e instanceof Error ? e.message : String(e)}`);
+        }
+        if (existsSync(wtDir)) {
+            try {
+                rmSync(wtDir, { recursive: true, force: true });
+                recovered.push(`Removed orphaned worktree directory for ${m.id} (branch already deleted).`);
+            }
+            catch (err) {
+                warnings.push(`Failed to remove orphaned worktree directory for ${m.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else {
+            recovered.push(`Removed orphaned worktree directory for ${m.id} (branch already deleted).`);
+        }
+    }
     return { recovered, warnings };
 }
 /**
@@ -368,7 +436,7 @@ export function _mergeOrphanCompletedMilestone(lifecycle, orphanId, ui) {
     return { merged: false, error: err };
 }
 export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps, interrupted) {
-    const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase, buildLifecycle, } = deps;
+    const { shouldUseWorktreeIsolation, registerSigtermHandler, registerAutoWorkerForSession, lockBase, buildLifecycle, } = deps;
     const dirCheck = validateDirectory(base);
     if (dirCheck.severity === "blocked") {
         ctx.ui.notify(dirCheck.reason, "error");
@@ -523,6 +591,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // consult DB status and avoid clearing runtime units for milestones that
         // only have a failure-path SUMMARY on disk (#4663).
         await openProjectDbIfPresent(base);
+        registerAutoWorkerForSession(base);
         // Clean stale runtime unit files for completed milestones (#887).
         // DB-authoritative: when DB is available, require DB status to be closed
         // before clearing runtime units. A SUMMARY file alone is no longer
@@ -606,12 +675,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // worktree cleanup) was never run — the survivor branch must be merged.
         // Applies to both worktree and branch isolation modes.
         let hasSurvivorBranch = false;
-        if (state.activeMilestone &&
+        let survivorMilestoneId = state.activeMilestone?.id ?? null;
+        if (!survivorMilestoneId && state.phase === "complete") {
+            survivorMilestoneId = findUnmergedCompletedMilestone(base, getIsolationMode(base));
+        }
+        if (survivorMilestoneId &&
             (state.phase === "pre-planning" || state.phase === "complete") &&
             getIsolationMode(base) !== "none" &&
             !detectWorktreeName(base) &&
             !base.includes(`${pathSep}.gsd${pathSep}worktrees${pathSep}`)) {
-            const milestoneBranch = `milestone/${state.activeMilestone.id}`;
+            const milestoneBranch = `milestone/${survivorMilestoneId}`;
             const { nativeBranchExists } = await import("./native-git-bridge.js");
             hasSurvivorBranch = nativeBranchExists(base, milestoneBranch);
             if (hasSurvivorBranch) {
@@ -645,7 +718,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Re-evaluate via the helper — the discuss branch above may have cleared
         // hasSurvivorBranch after a successful promotion.
         if (decideSurvivorAction(hasSurvivorBranch, state.phase) === "finalize") {
-            const mid = state.activeMilestone.id;
+            const mid = survivorMilestoneId;
             // Commit 68ef58a3c made `_mergeBranchMode` throw on wrong-branch
             // instead of returning false silently. Wrap the call so the throw is
             // converted into an error notify + clean bootstrap abort, not an
@@ -828,7 +901,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 const integrationBranch = nativeDetectMainBranch(base);
                 const branchToCheckout = resolveIsolationNoneBranchCheckout(currentBranch, integrationBranch, isolationMode, isRepo);
                 if (branchToCheckout) {
-                    nativeCheckoutBranch(base, branchToCheckout);
+                    checkoutBranchWithStashGuard(base, branchToCheckout, "isolation-none-recovery");
                     logWarning("bootstrap", `Returned to "${branchToCheckout}" — HEAD was on stale milestone branch "${currentBranch}" (isolation: none does not use milestone branches).`);
                 }
             }

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

@@ -262,13 +262,21 @@ export function startUnitSupervision(sctx) {
         if (runtime?.continueHereFired)
             return;
         const contextUsage = s.cmdCtx.getContextUsage();
-        if (!contextUsage || contextUsage.percent == null || contextUsage.percent < continueHereThreshold)
+        if (!contextUsage || contextUsage.percent == null)
+            return;
+        const rawPercent = contextUsage.percent;
+        if (rawPercent > 150) {
+            logWarning("timer", `[continue-here] ignoring implausible context percent: ${rawPercent}`);
+            return;
+        }
+        const contextPercent = Math.max(0, Math.min(100, rawPercent));
+        if (contextPercent < continueHereThreshold)
             return;
         writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
             continueHereFired: true,
         });
         if (s.verbose) {
-            ctx.ui.notify(`Context at ${contextUsage.percent}% (threshold: ${continueHereThreshold}%) — sending wrap-up signal.`, "info");
+            ctx.ui.notify(`Context at ${contextPercent}% (threshold: ${continueHereThreshold}%) — sending wrap-up signal.`, "info");
         }
         // Only trigger a new turn if no tools are currently in flight (#3512).
         const contextTrigger = getInFlightToolCount() === 0;
@@ -277,7 +285,7 @@ export function startUnitSupervision(sctx) {
             display: s.verbose,
             content: [
                 "**CONTEXT BUDGET WARNING — wrap up this unit now.**",
-                `Context window is at ${contextUsage.percent}% (threshold: ${continueHereThreshold}%).`,
+                `Context window is at ${contextPercent}% (threshold: ${continueHereThreshold}%).`,
                 "The next unit needs a fresh context to work effectively. Wrap up now:",
                 "1. Finish any in-progress file writes",
                 "2. Write or update the required durable artifacts (summary, checkboxes)",