@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

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

@@ -123,6 +123,7 @@ function resolveCompletionStopFromOutcome(outcome, stateSnapshot) {
 // tolerates — same behavior as a fresh session.
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
 const MAX_CONSECUTIVE_ALREADY_ACTIVE_SKIPS = 3;
+const MAX_CONSECUTIVE_ORCHESTRATION_SKIPS = 3;
 const ORCHESTRATION_MISSING_REASON = "Auto Orchestration Module is not wired; cannot dispatch built-in GSD Unit.";
 function stableStuckStateScopeId(s) {
     return normalizeRealPath(s.scope?.workspace.projectRoot ?? (s.originalBasePath || s.basePath));
@@ -132,7 +133,19 @@ function loadStuckState(s) {
     if (!scopeId)
         return { recentUnits: [], stuckRecoveryAttempts: 0 };
     try {
-        const recentUnits = getRecentUnitKeysForProjectRoot(scopeId, STUCK_WINDOW_SIZE);
+        // Scope the stuck window to the CURRENT session (trace_id) so stale
+        // finalize-retry entries from previous sessions don't fire detectStuck
+        // Rule 1 on the first iteration — killing auto-mode before any new
+        // dispatch runs (#852). A prior session's two consecutive finalize-retry
+        // failures would otherwise permanently block every new session.
+        //
+        // s.currentTraceId is only set inside the first loop iteration (line ~443),
+        // so at this call-site it is always null for a fresh session. Return []
+        // directly in that case — no prior dispatch has occurred in this session,
+        // so the stuck window is trivially empty and the DB query is skipped.
+        const recentUnits = s.currentTraceId != null
+            ? getRecentUnitKeysForProjectRoot(scopeId, STUCK_WINDOW_SIZE, s.currentTraceId)
+            : [];
         const stuckRecoveryAttempts = getRuntimeKv("global", scopeId, STUCK_RECOVERY_ATTEMPTS_KEY) ?? 0;
         return { recentUnits, stuckRecoveryAttempts };
     }
@@ -295,6 +308,8 @@ export async function autoLoop(ctx, pi, s, deps, options) {
     let consecutiveErrors = 0;
     let consecutiveCooldowns = 0;
     let consecutiveAlreadyActiveSkips = 0;
+    let consecutiveOrchestrationSkips = 0;
+    let lastOrchestrationSkipKey = null;
     const recentErrorMessages = [];
     while (s.active) {
         iteration++;
@@ -777,11 +792,51 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     }
                     if (orchestrationResult.kind === "skipped") {
                         s.pendingOrchestrationDispatch = null;
+                        // Idempotent re-poll skips are benign (an active unit is still running).
+                        // The orchestrator's own stuck-window detection handles the truly-stuck case.
+                        // Do not count these toward the consecutive-skip streak.
+                        if (orchestrationResult.reason === "idempotent advance: unit already active") {
+                            emitIterationEnd({ skipped: true });
+                            completeIteration();
+                            finishTurn("skipped");
+                            continue;
+                        }
+                        const skipState = orchestrationResult.stateSnapshot;
+                        const skipKey = [
+                            orchestrationResult.reason,
+                            skipState?.phase,
+                            skipState?.activeMilestone?.id,
+                            skipState?.activeSlice?.id,
+                            skipState?.activeTask?.id,
+                        ].join("|");
+                        consecutiveOrchestrationSkips = skipKey === lastOrchestrationSkipKey
+                            ? consecutiveOrchestrationSkips + 1
+                            : 1;
+                        lastOrchestrationSkipKey = skipKey;
+                        if (consecutiveOrchestrationSkips >= MAX_CONSECUTIVE_ORCHESTRATION_SKIPS) {
+                            const msg = `Orchestration skipped ${consecutiveOrchestrationSkips} consecutive attempts without progress. Pausing auto-mode for manual recovery.`;
+                            ctx.ui.notify(msg, "error");
+                            await deps.pauseAuto(ctx, pi, {
+                                message: msg,
+                                category: "unknown",
+                            }, {
+                                expectedCurrentUnit: null,
+                            });
+                            finishTurn("paused", "manual-attention", orchestrationResult.reason ?? "orchestration-skipped");
+                            finishIncompleteIteration({
+                                status: "paused",
+                                reason: orchestrationResult.reason ?? "orchestration-skipped",
+                                failureClass: "manual-attention",
+                            });
+                            break;
+                        }
                         emitIterationEnd({ skipped: true });
                         completeIteration();
                         finishTurn("skipped");
                         continue;
                     }
+                    consecutiveOrchestrationSkips = 0;
+                    lastOrchestrationSkipKey = null;
                     if (orchestrationResult.kind === "paused") {
                         s.pendingOrchestrationDispatch = null;
                         finishIncompleteIteration({
@@ -1148,7 +1203,17 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             const finalizeDecision = decideFinalizeResult(finalizeResult.action === "break"
                 ? { action: "break", reason: finalizeResult.reason }
                 : finalizeResult.action === "continue"
-                    ? { action: "continue" }
+                    ? {
+                        action: "continue",
+                        // Surface the specific verification failure (e.g. "roadmap has
+                        // zero slices") in the ledger/stuck-loop reason instead of the
+                        // opaque bare "finalize-retry" token. The retry paths in
+                        // runFinalize set s.pendingVerificationRetry.failureContext
+                        // from describeArtifactVerificationFailure before returning
+                        // continue; it is cleared on the next dispatch, so reading it
+                        // here captures the reason for THIS finalize (#852 follow-up).
+                        failureDetail: s.pendingVerificationRetry?.failureContext,
+                    }
                     : { action: "next" });
             if (finalizeDecision.action === "stop") {
                 dispatchSettled = settleDispatchFailed(dispatchId, finalizeDecision.ledgerErrorSummary, {

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

@@ -124,7 +124,9 @@ export async function decideOrchestratorDispatch(ctx, pi, dispatchBasePath, sess
     const active = state.activeMilestone;
     const activeSession = input.session ?? session;
     const activeDispatchBasePath = activeSession?.basePath || dispatchBasePath;
-    const prefs = loadEffectiveGSDPreferencesWithRegistry(ctx.modelRegistry, activeDispatchBasePath, resolveProfileAnchorProvider(ctx.model?.provider, session?.autoModeStartModel?.provider))?.preferences;
+    const prefs = loadEffectiveGSDPreferencesWithRegistry(ctx.modelRegistry, activeDispatchBasePath, resolveProfileAnchorProvider(ctx.model?.provider, session?.autoModeStartModel?.provider), activeSession?.autoModeStartModel
+        ? `${activeSession.autoModeStartModel.provider}/${activeSession.autoModeStartModel.id}`
+        : undefined)?.preferences;
     if (!active) {
         if (state.phase !== "pre-planning")
             return null;
@@ -394,12 +396,17 @@ export class AutoOrchestrator {
         }
     }
     // ── UokGateAdapter (folded) ──────────────────────────────────────────────
-    async emitUokGate(input) {
+    resolveUokGateContext() {
         const activeBasePath = this.getLiveDispatchBasePath();
-        const prefs = loadEffectiveGSDPreferencesWithRegistry(this.ctx.modelRegistry, activeBasePath, resolveProfileAnchorProvider(this.ctx.model?.provider, this.s.autoModeStartModel?.provider))?.preferences;
-        const uokFlags = resolveUokFlags(prefs);
-        if (!uokFlags.gates)
+        const prefs = loadEffectiveGSDPreferencesWithRegistry(this.ctx.modelRegistry, activeBasePath, resolveProfileAnchorProvider(this.ctx.model?.provider, this.s.autoModeStartModel?.provider), this.s.autoModeStartModel
+            ? `${this.s.autoModeStartModel.provider}/${this.s.autoModeStartModel.id}`
+            : undefined)?.preferences;
+        return { activeBasePath, uokFlags: resolveUokFlags(prefs) };
+    }
+    async emitUokGate(input) {
+        if (!input.uokFlags.gates)
             return;
+        const activeBasePath = input.activeBasePath;
         const milestoneId = input.milestoneId ?? this.s.currentMilestoneId ?? undefined;
         try {
             const { UokGateRunner } = await import("../uok/gate-runner.js");
@@ -553,7 +560,7 @@ export class AutoOrchestrator {
                 return new GitServiceImpl(basePath, gitConfig);
             },
             worktreeProjection: new WorktreeStateProjection(),
-            mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
+            mergeMilestone: createMilestoneMergeTransaction(mergeMilestoneToMain),
         });
     }
     rebuildScope(rawPath, milestoneId) {
@@ -732,12 +739,17 @@ export class AutoOrchestrator {
     async start(_sessionContext) {
         this.lastAdvanceKey = null;
         this.lastFinalizedUnitKey = null;
-        // #482: the DB dispatch ledger is the source of truth across sessions.
-        // Discard any in-memory window and rebuild it from the ledger so a unit
-        // that was re-dispatched in previous sessions is detected as stuck here
-        // instead of silently re-dispatching forever.
+        // #852: a fresh user-triggered session must start with a clean stuck window.
+        // Cross-session rehydration at start() was removed because it caused false
+        // stuck-loop verdicts when prior sessions left consecutive finalize-retry
+        // entries in unit_dispatches — the new session would be killed before its
+        // first dispatch ran. Within-session stuck detection (accumulated through
+        // recordDispatch() calls during advance()) remains fully active and catches
+        // genuine stuck patterns after STUCK_WINDOW_SIZE dispatches.
+        //
+        // resume() retains cross-session rehydration: an interrupted session resuming
+        // after a crash should see the dispatch history it had been accumulating.
         this.dispatchHistory.clearOnRecovery();
-        this.dispatchHistory.rehydrate();
         this.lastStuckRecoveryKey = null;
         this.lastDerivedPhase = null;
         this.status.phase = "running";
@@ -751,9 +763,11 @@ export class AutoOrchestrator {
         const stopAdvanceTimer = debugTime("orchestrator-advance");
         try {
             this.ensureLockOwnership();
+            const uokGateContext = this.resolveUokGateContext();
             const staleMsg = this.checkResourcesStale();
             if (staleMsg) {
                 await this.emitUokGate({
+                    ...uokGateContext,
                     gateId: "resource-version-guard",
                     gateType: "policy",
                     outcome: "fail",
@@ -767,6 +781,7 @@ export class AutoOrchestrator {
                 return blocked;
             }
             await this.emitUokGate({
+                ...uokGateContext,
                 gateId: "resource-version-guard",
                 gateType: "policy",
                 outcome: "pass",
@@ -776,6 +791,7 @@ export class AutoOrchestrator {
             const gate = await this.preAdvanceGate();
             if (gate.kind === "fail") {
                 await this.emitUokGate({
+                    ...uokGateContext,
                     gateId: "pre-dispatch-health-gate",
                     gateType: "execution",
                     outcome: "manual-attention",
@@ -794,6 +810,7 @@ export class AutoOrchestrator {
             }
             if (gate.kind === "threw") {
                 await this.emitUokGate({
+                    ...uokGateContext,
                     gateId: "pre-dispatch-health-gate",
                     gateType: "execution",
                     outcome: "manual-attention",
@@ -805,6 +822,7 @@ export class AutoOrchestrator {
             }
             else {
                 await this.emitUokGate({
+                    ...uokGateContext,
                     gateId: "pre-dispatch-health-gate",
                     gateType: "execution",
                     outcome: "pass",

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

@@ -6,7 +6,7 @@ import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
-import { consumeAutoWakeup } from "./schedule-wakeup.js";
+import { clearAutoWakeup, consumeAutoWakeup } from "./schedule-wakeup.js";
 import { applyUnitSkillVisibility } from "../skill-scope.js";
 const UNIT_FAILSAFE_BUFFER_MS = 30_000;
 const UNIT_FAILSAFE_RECHECK_MS = 30_000;
@@ -192,7 +192,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const UNIT_HARD_TIMEOUT_MS = Math.max(UNIT_FAILSAFE_BUFFER_MS, ((supervisor.hard_timeout_minutes ?? 30) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS);
     const freshProgressMs = Math.max(UNIT_FAILSAFE_BUFFER_MS, ((supervisor.idle_timeout_minutes ?? 10) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS);
     let unitTimeoutHandle;
-    let result;
+    let result = { status: "cancelled" };
     try {
         const awaitAgentEndWithTimeout = (agentEndPromise) => {
             const timeoutResult = new Promise((resolve) => {
@@ -297,6 +297,9 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     finally {
         if (unitTimeoutHandle)
             clearTimeout(unitTimeoutHandle);
+        if (result.status !== "completed") {
+            clearAutoWakeup(s.basePath, unitType, unitId);
+        }
         ctx.ui.setWorkingMessage?.(undefined);
         setVisibleSkills?.(undefined);
     }

package/dist/resources/extensions/gsd/auto/schedule-wakeup.js

@@ -13,6 +13,9 @@ export function consumeAutoWakeup(basePath, unitType, unitId) {
     pendingWakeups.delete(key);
     return wakeup;
 }
+export function clearAutoWakeup(basePath, unitType, unitId) {
+    pendingWakeups.delete(wakeupKey(basePath, unitType, unitId));
+}
 export function _resetAutoWakeupsForTest() {
     pendingWakeups.clear();
 }

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

@@ -78,6 +78,8 @@ export class AutoSession {
     currentUnitRouting = null;
     currentMilestoneId = null;
     sourceObservations = new SourceObservationStore();
+    /** Live tool-surface snapshot for dashboard / runtime telemetry while auto is active. */
+    toolSurfaceSnapshot = null;
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
     /** Explicit /gsd model pin captured at bootstrap (session-scoped policy override). */
@@ -122,6 +124,13 @@ export class AutoSession {
      * the issues after MAX_PRE_EXEC_RETRIES re-attempts.
      */
     preExecRetryCount = new Map();
+    /**
+     * Tracks how many times each slice unit has been re-dispatched to plan-slice
+     * because task plan files were missing. Keyed by unitId (e.g. "M001/S01").
+     * Separate from preExecRetryCount so pre-exec gate failures do not block or
+     * conflate with missing-task-plan recovery.
+     */
+    missingTaskPlanRetryCount = new Map();
     // ── Tool invocation errors (#2883) ──────────────────────────────────
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
@@ -270,6 +279,7 @@ export class AutoSession {
         this.unitRecoveryCount.clear();
         // Unit
         this.clearCurrentUnit();
+        this.toolSurfaceSnapshot = null;
         this.currentTraceId = null;
         this.currentTurnId = null;
         this.currentUnitRouting = null;
@@ -307,6 +317,7 @@ export class AutoSession {
         this.consecutiveCompleteBootstraps = 0;
         this.lastPreExecFailure = null;
         this.preExecRetryCount.clear();
+        this.missingTaskPlanRetryCount.clear();
         this.lastToolInvocationError = null;
         this.toolUnavailableRetries = 0;
         this.lastUnitAgentEndMessages = null;

package/dist/resources/extensions/gsd/auto/verification-retry-policy.js

@@ -25,7 +25,7 @@ export function decideVerificationRetry(input) {
         return { action: "pause", reason: "missing-retry-context" };
     }
     const key = verificationRetryKey(unitType, retryInfo.unitId);
-    const failureHash = hashVerificationFailureContext(retryInfo.failureContext);
+    const failureHash = hashVerificationFailureContext(retryInfo.signature ?? retryInfo.failureContext);
     if (input.previousFailureHash === failureHash) {
         return {
             action: "pause",

package/dist/resources/extensions/gsd/auto/workflow-kernel.js

@@ -76,6 +76,15 @@ const COMPLETE_AND_BREAK_REASONS = [
 function isCompleteAndBreakReason(reason) {
     return COMPLETE_AND_BREAK_REASONS.includes(reason);
 }
+/** Strip per-attempt counter suffixes so detect-stuck Rule 1 can match repeats. */
+const FAILURE_DETAIL_ATTEMPT_SUFFIX_RE = /\s*\(attempt\s+\d+(?:\/\d+)?\)\.?$/i;
+function failureDetailForLedger(detail) {
+    const trimmed = detail?.trim();
+    if (!trimmed)
+        return undefined;
+    const normalized = trimmed.replace(FAILURE_DETAIL_ATTEMPT_SUFFIX_RE, "").trim();
+    return normalized || undefined;
+}
 export function decideFinalizeResult(input) {
     if (input.action === "break") {
         const reason = input.reason ?? "unknown";
@@ -90,9 +99,14 @@ export function decideFinalizeResult(input) {
         };
     }
     if (input.action === "continue") {
+        // Carry the specific verification failure (e.g. "roadmap has zero slices",
+        // "15-SUMMARY.md was not found on disk") into the ledger summary so the
+        // stuck-loop kill message is actionable. The `finalize-retry` prefix is
+        // preserved so legacy ledger filters and dashboards still match (#852).
+        const detail = failureDetailForLedger(input.failureDetail);
         return {
             action: "retry",
-            ledgerErrorSummary: "finalize-retry",
+            ledgerErrorSummary: detail ? `finalize-retry: ${detail}` : "finalize-retry",
         };
     }
     return { action: "complete" };

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -5,27 +5,93 @@
 // resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
-import { gsdRoot, gsdProjectionRoot, resolveDir, resolveFile, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
+import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } from "./paths.js";
+import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
-import { join } from "node:path";
+import { dirname, join, relative } from "node:path";
+import { existsSync } from "node:fs";
 function resolveMilestoneArtifactPath(base, mid, suffix) {
     const existing = resolveProjectedMilestoneFile(base, mid, suffix) ?? resolveProjectMilestoneFile(base, mid, suffix);
     if (existing)
         return existing;
-    const dir = resolveProjectedMilestonePath(base, mid) ?? resolveProjectMilestonePath(base, mid);
-    return dir ? join(dir, buildMilestoneFileName(mid, suffix)) : null;
+    // Try projected (worktree) path, then project-root path. Both can return
+    // either a legacy (milestones/<MID>/) or flat-phase (phases/NN-slug/) dir.
+    const dir = resolveProjectedMilestonePath(base, mid) ?? resolveProjectMilestonePath(base, mid) ?? resolveMilestonePath(base, mid);
+    if (dir) {
+        // The filename depends on the LAYOUT of the resolved directory, not on
+        // which resolver found it. A flat-phase dir (phases/NN-slug/) uses the
+        // phase-number prefix (15-CONTEXT.md); a legacy dir (milestones/<MID>/)
+        // uses the milestone-id prefix (M015-CONTEXT.md). Building the wrong
+        // filename for the resolved dir produces existsSync-false paths that trap
+        // the unit in a finalize-retry loop (#852).
+        //
+        // Layout is determined structurally from the resolved directory's parent
+        // segment name, NOT by comparing against a root-anchored legacyMilestonesDir
+        // base path. On a canonical worktree (<project>/.gsd-worktrees/M001/),
+        // legacyMilestonesDir uses gsdProjectionRoot (the worktree .gsd) while
+        // resolveProjectMilestonePath uses gsdRoot (the project .gsd) — two
+        // different roots. A dir returned by resolveProjectMilestonePath would
+        // fail the startsWith check against the worktree root and incorrectly
+        // produce a flat-phase filename for a legacy directory (#bugbot c5ee8eba).
+        const parentDir = dirname(dir);
+        const isLegacy = parentDir.endsWith("/milestones") || parentDir.endsWith("\\milestones");
+        const phaseNum = milestoneIdToPhaseNum(mid);
+        const filename = isLegacy
+            ? `${mid}-${suffix}.md`
+            : `${String(phaseNum).padStart(2, "0")}-${suffix}.md`;
+        return join(dir, filename);
+    }
+    return null;
+}
+/**
+ * Build the layout-aware filename for a milestone artifact suffix.
+ * Exported so other callers (e.g. verification diagnostics) use the same
+ * naming policy: flat-phase dirs use the phase-number prefix (15-CONTEXT.md),
+ * legacy dirs use the milestone-id prefix (M015-CONTEXT.md).
+ *
+ * Layout is determined structurally: dirs whose immediate parent is named
+ * "milestones" are legacy; all others are flat-phase. This avoids the
+ * root-path ambiguity between gsdProjectionRoot (worktree .gsd) and gsdRoot
+ * (project .gsd) that caused wrong filenames on canonical worktrees.
+ */
+export function buildMilestoneArtifactFilename(mid, suffix, dir) {
+    const parentDir = dirname(dir);
+    const isLegacy = parentDir.endsWith("/milestones") || parentDir.endsWith("\\milestones");
+    const phaseNum = milestoneIdToPhaseNum(mid);
+    return isLegacy
+        ? `${mid}-${suffix}.md`
+        : `${String(phaseNum).padStart(2, "0")}-${suffix}.md`;
 }
 function resolveSliceArtifactPath(base, mid, sid, suffix) {
     const existing = resolveProjectedSliceFile(base, mid, sid, suffix) ?? resolveProjectSliceFile(base, mid, sid, suffix);
     if (existing)
         return existing;
-    const dir = resolveProjectedSlicePath(base, mid, sid) ?? resolveProjectSlicePath(base, mid, sid);
-    return dir ? join(dir, buildSliceFileName(sid, suffix)) : null;
+    // Flat-phase: plan files live at phases/NN-slug/NN-MM-SUFFIX.md — resolveSliceFile handles both layouts.
+    const flatPhase = resolveSliceFile(base, mid, sid, suffix);
+    if (flatPhase)
+        return flatPhase;
+    // File doesn't exist yet — use relSliceFile for the layout-aware canonical path.
+    // buildSliceFileName(sid) only has sliceId → MM-SUFFIX.md, wrong for both layouts.
+    return join(base, relSliceFile(base, mid, sid, suffix));
 }
 function resolveProjectMilestonePath(base, mid) {
     const milestonesDir = join(gsdRoot(base), "milestones");
     const dir = resolveDir(milestonesDir, mid);
-    return dir ? join(milestonesDir, dir) : null;
+    if (!dir)
+        return null;
+    // git-service.ts creates milestones/<MID>/ for integration-branch metadata
+    // (<MID>-META.json) even in flat-phase projects. A dir that holds ONLY
+    // *-META.json files must not be treated as a real legacy milestone dir —
+    // otherwise this early-return resolves CONTEXT/ROADMAP/SUMMARY to the legacy
+    // path (milestones/<MID>/<MID>-<SUFFIX>.md) before the flat-phase fallback
+    // can run, trapping the unit in a finalize-retry loop (#852 follow-up).
+    //
+    // We use dirIsMetaOnlyLegacyMilestone rather than !dirIsContentBearingLegacyMilestone
+    // so that an EMPTY dir (a new milestone before any content is written) is NOT
+    // blocked — it is a valid legacy target that write-paths should resolve to.
+    if (dirIsMetaOnlyLegacyMilestone(join(milestonesDir, dir)))
+        return null;
+    return join(milestonesDir, dir);
 }
 function resolveProjectMilestoneFile(base, mid, suffix) {
     const dir = resolveProjectMilestonePath(base, mid);
@@ -50,16 +116,10 @@ function resolveProjectSliceFile(base, mid, sid, suffix) {
     return file ? join(dir, file) : null;
 }
 function resolveProjectedMilestonePath(base, mid) {
-    const milestonesDir = join(gsdProjectionRoot(base), "milestones");
-    const dir = resolveDir(milestonesDir, mid);
-    return dir ? join(milestonesDir, dir) : null;
+    return resolveMilestonePath(base, mid);
 }
 function resolveProjectedMilestoneFile(base, mid, suffix) {
-    const dir = resolveProjectedMilestonePath(base, mid);
-    if (!dir)
-        return null;
-    const file = resolveFile(dir, mid, suffix);
-    return file ? join(dir, file) : null;
+    return resolveMilestoneFile(base, mid, suffix);
 }
 function resolveProjectedSlicePath(base, mid, sid) {
     const milestoneDir = resolveProjectedMilestonePath(base, mid);
@@ -128,10 +188,13 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             return resolveSliceArtifactPath(base, mid, sid, "ASSESSMENT");
         }
         case "execute-task": {
-            const dir = resolveProjectedSlicePath(base, mid, sid) ?? resolveProjectSlicePath(base, mid, sid);
-            return dir && tid
-                ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY"))
-                : null;
+            const slicePath = resolveProjectedSlicePath(base, mid, sid)
+                ?? resolveProjectSlicePath(base, mid, sid)
+                ?? resolveSlicePath(base, mid, sid);
+            if (!slicePath || !tid)
+                return null;
+            const tasksDir = resolveTasksDir(base, mid, sid) ?? slicePath;
+            return join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
         }
         case "complete-slice": {
             return resolveSliceArtifactPath(base, mid, sid, "SUMMARY");
@@ -219,3 +282,29 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
             return null;
     }
 }
+/**
+ * Resolve slice RESEARCH with worktree projection first, then canonical
+ * project-root path. Shared by dispatch rules, execute-task prompts, and
+ * artifact verification.
+ */
+export function resolveSliceResearchLocation(basePath, mid, sid) {
+    const projectedFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
+    if (projectedFile) {
+        return {
+            absolutePath: projectedFile,
+            relativePath: relSliceFile(basePath, mid, sid, "RESEARCH"),
+        };
+    }
+    const canonicalPath = resolveExpectedArtifactPath("research-slice", `${mid}/${sid}`, basePath);
+    if (canonicalPath && existsSync(canonicalPath)) {
+        return {
+            absolutePath: canonicalPath,
+            relativePath: relative(basePath, canonicalPath),
+        };
+    }
+    return { absolutePath: null, relativePath: null };
+}
+/** Returns the absolute RESEARCH path when it exists, otherwise null. */
+export function resolveExistingSliceResearchPath(basePath, mid, sid) {
+    return resolveSliceResearchLocation(basePath, mid, sid).absolutePath;
+}

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

@@ -68,6 +68,10 @@ export function resolveCompactionThresholdPercent(raw) {
     const value = typeof raw === "number" && Number.isFinite(raw) && raw >= 0.5 && raw <= 0.95 ? raw : 0.6;
     return value <= 1 ? value * 100 : value;
 }
-export function shouldRerootStepSessionForContext(contextPercent, compactionThresholdPercent) {
+export const HARD_CONTEXT_REROOT_THRESHOLD_PERCENT = 90;
+export function shouldWarnStepSessionForContext(contextPercent, compactionThresholdPercent) {
     return getContextPauseAction(contextPercent, resolveCompactionThresholdPercent(compactionThresholdPercent)) === "pause";
 }
+export function shouldRerootStepSessionForContext(contextPercent) {
+    return getContextPauseAction(contextPercent, HARD_CONTEXT_REROOT_THRESHOLD_PERCENT) === "pause";
+}