gsd-pi 2.50.0-dev.d210a87 → 2.50.0

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

@@ -9,10 +9,10 @@
  * without modifying orchestration code.
  */
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted } from "./gsd-db.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
-import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
 import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
@@ -23,42 +23,8 @@ function missingSliceStop(mid, phase) {
         level: "error",
     };
 }
-/**
- * Check for milestone slices missing SUMMARY files.
- * Returns array of missing slice IDs, or empty array if all present or DB unavailable.
- */
-function findMissingSummaries(basePath, mid) {
-    if (!isDbAvailable())
-        return [];
-    const sliceIds = getMilestoneSlices(mid).map(s => s.id);
-    return sliceIds.filter(sid => {
-        const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
-        return !summaryPath || !existsSync(summaryPath);
-    });
-}
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
 const MAX_REWRITE_ATTEMPTS = 3;
-// ─── Disk-persisted rewrite attempt counter ──────────────────────────────────
-// The counter must survive session restarts (crash recovery, pause/resume,
-// step-mode). Storing it on the in-memory session object caused the circuit
-// breaker to never trip — see https://github.com/gsd-build/gsd-2/issues/2203
-function rewriteCountPath(basePath) {
-    return join(gsdRoot(basePath), "runtime", "rewrite-count.json");
-}
-export function getRewriteCount(basePath) {
-    try {
-        const data = JSON.parse(readFileSync(rewriteCountPath(basePath), "utf-8"));
-        return typeof data.count === "number" ? data.count : 0;
-    }
-    catch {
-        return 0;
-    }
-}
-export function setRewriteCount(basePath, count) {
-    const filePath = rewriteCountPath(basePath);
-    mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
-    writeFileSync(filePath, JSON.stringify({ count, updatedAt: new Date().toISOString() }) + "\n");
-}
 // ─── Rules ────────────────────────────────────────────────────────────────
 export const DISPATCH_RULES = [
     {
@@ -67,14 +33,16 @@ export const DISPATCH_RULES = [
             const pendingOverrides = await loadActiveOverrides(basePath);
             if (pendingOverrides.length === 0)
                 return null;
-            const count = getRewriteCount(basePath);
+            const count = session?.rewriteAttemptCount ?? 0;
             if (count >= MAX_REWRITE_ATTEMPTS) {
                 const { resolveAllOverrides } = await import("./files.js");
                 await resolveAllOverrides(basePath);
-                setRewriteCount(basePath, 0);
+                if (session)
+                    session.rewriteAttemptCount = 0;
                 return null;
             }
-            setRewriteCount(basePath, count + 1);
+            if (session)
+                session.rewriteAttemptCount++;
             const unitId = state.activeSlice ? `${mid}/${state.activeSlice.id}` : mid;
             return {
                 action: "dispatch",
@@ -440,14 +408,30 @@ export const DISPATCH_RULES = [
             if (state.phase !== "validating-milestone")
                 return null;
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files before
-            // allowing milestone validation.
-            const missingSlices = findMissingSummaries(basePath, mid);
-            if (missingSlices.length > 0) {
-                return {
-                    action: "stop",
-                    reason: `Cannot validate milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. These slices may have been skipped.`,
-                    level: "error",
-                };
+            // allowing milestone validation. If any slice lacks a summary, the milestone
+            // is not genuinely complete — something skipped earlier slices.
+            let sliceIds;
+            if (isDbAvailable()) {
+                sliceIds = getMilestoneSlices(mid).map(s => s.id);
+            }
+            else {
+                sliceIds = [];
+            }
+            if (sliceIds.length > 0) {
+                const missingSlices = [];
+                for (const sid of sliceIds) {
+                    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
+                    if (!summaryPath || !existsSync(summaryPath)) {
+                        missingSlices.push(sid);
+                    }
+                }
+                if (missingSlices.length > 0) {
+                    return {
+                        action: "stop",
+                        reason: `Cannot validate milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. These slices may have been skipped.`,
+                        level: "error",
+                    };
+                }
             }
             // Skip preference: write a minimal pass-through VALIDATION file
             if (prefs?.phases?.skip_milestone_validation) {
@@ -484,13 +468,28 @@ export const DISPATCH_RULES = [
             if (state.phase !== "completing-milestone")
                 return null;
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files.
-            const missingSlices = findMissingSummaries(basePath, mid);
-            if (missingSlices.length > 0) {
-                return {
-                    action: "stop",
-                    reason: `Cannot complete milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. Run /gsd doctor to diagnose.`,
-                    level: "error",
-                };
+            let sliceIds;
+            if (isDbAvailable()) {
+                sliceIds = getMilestoneSlices(mid).map(s => s.id);
+            }
+            else {
+                sliceIds = [];
+            }
+            if (sliceIds.length > 0) {
+                const missingSlices = [];
+                for (const sid of sliceIds) {
+                    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
+                    if (!summaryPath || !existsSync(summaryPath)) {
+                        missingSlices.push(sid);
+                    }
+                }
+                if (missingSlices.length > 0) {
+                    return {
+                        action: "stop",
+                        reason: `Cannot complete milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. Run /gsd doctor to diagnose.`,
+                        level: "error",
+                    };
+                }
             }
             // Safety guard (#1703): verify the milestone produced implementation
             // artifacts (non-.gsd/ files). A milestone with only plan files and
@@ -502,32 +501,6 @@ export const DISPATCH_RULES = [
                     level: "error",
                 };
             }
-            // Verification class compliance: if operational verification was planned,
-            // ensure the validation output documents it before allowing completion.
-            try {
-                if (isDbAvailable()) {
-                    const milestone = getMilestone(mid);
-                    if (milestone?.verification_operational &&
-                        milestone.verification_operational.toLowerCase() !== "none") {
-                        const validationPath = resolveMilestoneFile(basePath, mid, "VALIDATION");
-                        if (validationPath) {
-                            const validationContent = await loadFile(validationPath);
-                            if (validationContent) {
-                                const hasOperationalCheck = validationContent.includes("Operational") &&
-                                    (validationContent.includes("MET") || validationContent.includes("N/A"));
-                                if (!hasOperationalCheck) {
-                                    return {
-                                        action: "stop",
-                                        reason: `Milestone ${mid} has planned operational verification ("${milestone.verification_operational.substring(0, 100)}") but the validation output does not address it. Re-run validation with verification class awareness, or update the validation to document operational compliance.`,
-                                        level: "warning",
-                                    };
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            catch { /* fall through — don't block on DB errors */ }
             return {
                 action: "dispatch",
                 unitType: "complete-milestone",

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

@@ -27,21 +27,6 @@ import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
-import { runSafely } from "./auto-utils.js";
-/** Enqueue a sidecar item (hook, triage, or quick-task) for the main loop to
- *  drain via runUnit. Logs the enqueue event and notifies the UI. */
-function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
-    s.sidecarQueue.push(entry);
-    debugLog("postUnitPostVerification", {
-        phase: "sidecar-enqueue",
-        kind: entry.kind,
-        unitId: entry.unitId,
-        ...debugExtra,
-    });
-    if (notification)
-        ctx.ui.notify(notification, "info");
-    return "continue";
-}
 /** Unit types that only touch `.gsd/` internal state files (no code changes).
  *  Auto-commit is skipped for these — their state files are picked up by the
  *  next actual task commit via `smartStage()`. */
@@ -189,7 +174,6 @@ export async function postUnitPreVerification(pctx, opts) {
     }
     // Auto-commit
     if (s.currentUnit) {
-        const unit = s.currentUnit;
         try {
             let taskContext;
             if (s.currentUnit.type === "execute-task") {
@@ -246,51 +230,65 @@ export async function postUnitPreVerification(pctx, opts) {
             ctx.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
         }
         // GitHub sync (non-blocking, opt-in)
-        await runSafely("postUnit", "github-sync", async () => {
+        try {
             const { runGitHubSync } = await import("../github-sync/sync.js");
-            await runGitHubSync(s.basePath, unit.type, unit.id);
-        });
+            await runGitHubSync(s.basePath, s.currentUnit.type, s.currentUnit.id);
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "github-sync", error: String(e) });
+        }
         // Prune dead bg-shell processes
-        await runSafely("postUnit", "prune-bg-shell", async () => {
+        try {
             const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
             pruneDeadProcesses();
-        });
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "prune-bg-shell", error: String(e) });
+        }
         // Tear down browser between units to prevent Chrome process accumulation (#1733)
-        await runSafely("postUnit", "browser-teardown", async () => {
+        try {
             const { getBrowser } = await import("../browser-tools/state.js");
             if (getBrowser()) {
                 const { closeBrowser } = await import("../browser-tools/lifecycle.js");
                 await closeBrowser();
                 debugLog("postUnit", { phase: "browser-teardown", status: "closed" });
             }
-        });
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "browser-teardown", error: String(e) });
+        }
         // Sync worktree state back to project root (skipped for lightweight sidecars)
         if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
-            await runSafely("postUnit", "worktree-sync", () => {
+            try {
                 syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
-            });
+            }
+            catch (e) {
+                debugLog("postUnit", { phase: "worktree-sync", error: String(e) });
+            }
         }
         // Rewrite-docs completion
         if (s.currentUnit.type === "rewrite-docs") {
-            await runSafely("postUnit", "rewrite-docs-resolve", async () => {
+            try {
                 await resolveAllOverrides(s.basePath);
-                // Reset both disk and in-memory counters. Disk counter is authoritative
-                // (survives restarts); in-memory is kept in sync for the current session.
-                const { setRewriteCount } = await import("./auto-dispatch.js");
-                setRewriteCount(s.basePath, 0);
                 s.rewriteAttemptCount = 0;
                 ctx.ui.notify("Override(s) resolved — rewrite-docs completed.", "info");
-            });
+            }
+            catch (e) {
+                debugLog("postUnit", { phase: "rewrite-docs-resolve", error: String(e) });
+            }
         }
         // Reactive state cleanup on slice completion
         if (s.currentUnit.type === "complete-slice") {
-            await runSafely("postUnit", "reactive-state-cleanup", async () => {
-                const { milestone: mid, slice: sid } = parseUnitId(unit.id);
+            try {
+                const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
                 if (mid && sid) {
                     const { clearReactiveState } = await import("./reactive-graph.js");
                     clearReactiveState(s.basePath, mid, sid);
                 }
-            });
+            }
+            catch (e) {
+                debugLog("postUnit", { phase: "reactive-state-cleanup", error: String(e) });
+            }
         }
         // Post-triage: execute actionable resolutions
         if (s.currentUnit.type === "triage-captures") {
@@ -417,7 +415,21 @@ export async function postUnitPostVerification(pctx) {
                 await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
             }
             persistHookState(s.basePath);
-            return enqueueSidecar(s, ctx, { kind: "hook", unitType: hookUnit.unitType, unitId: hookUnit.unitId, prompt: hookUnit.prompt, model: hookUnit.model }, { hookName: hookUnit.hookName });
+            s.sidecarQueue.push({
+                kind: "hook",
+                unitType: hookUnit.unitType,
+                unitId: hookUnit.unitId,
+                prompt: hookUnit.prompt,
+                model: hookUnit.model,
+            });
+            debugLog("postUnitPostVerification", {
+                phase: "sidecar-enqueue",
+                kind: "hook",
+                unitType: hookUnit.unitType,
+                unitId: hookUnit.unitId,
+                hookName: hookUnit.hookName,
+            });
+            return "continue";
         }
         // Check if a hook requested a retry of the trigger unit
         if (isRetryPending()) {
@@ -498,7 +510,20 @@ export async function postUnitPostVerification(pctx) {
                             await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
                         }
                         const triageUnitId = `${mid}/${sid}/triage`;
-                        return enqueueSidecar(s, ctx, { kind: "triage", unitType: "triage-captures", unitId: triageUnitId, prompt }, { pendingCount: pending.length }, `Triaging ${pending.length} pending capture${pending.length === 1 ? "" : "s"}...`);
+                        s.sidecarQueue.push({
+                            kind: "triage",
+                            unitType: "triage-captures",
+                            unitId: triageUnitId,
+                            prompt,
+                        });
+                        debugLog("postUnitPostVerification", {
+                            phase: "sidecar-enqueue",
+                            kind: "triage",
+                            unitId: triageUnitId,
+                            pendingCount: pending.length,
+                        });
+                        ctx.ui.notify(`Triaging ${pending.length} pending capture${pending.length === 1 ? "" : "s"}...`, "info");
+                        return "continue";
                     }
                 }
             }
@@ -522,7 +547,21 @@ export async function postUnitPostVerification(pctx) {
             }
             markCaptureExecuted(s.basePath, capture.id);
             const qtUnitId = `${s.currentMilestoneId}/${capture.id}`;
-            return enqueueSidecar(s, ctx, { kind: "quick-task", unitType: "quick-task", unitId: qtUnitId, prompt, captureId: capture.id }, { captureId: capture.id }, `Executing quick-task: ${capture.id} — "${capture.text}"`);
+            s.sidecarQueue.push({
+                kind: "quick-task",
+                unitType: "quick-task",
+                unitId: qtUnitId,
+                prompt,
+                captureId: capture.id,
+            });
+            debugLog("postUnitPostVerification", {
+                phase: "sidecar-enqueue",
+                kind: "quick-task",
+                unitId: qtUnitId,
+                captureId: capture.id,
+            });
+            ctx.ui.notify(`Executing quick-task: ${capture.id} — "${capture.text}"`, "info");
+            return "continue";
         }
         catch (e) {
             debugLog("postUnit", { phase: "quick-task-dispatch", error: String(e) });

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

@@ -675,15 +675,6 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
                 // If the UAT file already contains a verdict, UAT has been run — skip
                 if (hasVerdict(uatContent))
                     return null;
-                // Also check the ASSESSMENT file — the run-uat prompt writes the verdict
-                // there (via gsd_summary_save artifact_type:"ASSESSMENT"), not into the
-                // UAT spec file. Without this check the unit re-dispatches indefinitely.
-                const assessmentFile = resolveSliceFile(base, mid, sid, "ASSESSMENT");
-                if (assessmentFile) {
-                    const assessmentContent = await loadFile(assessmentFile);
-                    if (assessmentContent && hasVerdict(assessmentContent))
-                        return null;
-                }
                 const uatType = getUatType(uatContent);
                 return { sliceId: sid, uatType };
             }
@@ -715,14 +706,6 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
     // If the UAT file already contains a verdict, UAT has been run — skip
     if (hasVerdict(uatContentFb))
         return null;
-    // Also check the ASSESSMENT file for the file-based fallback path (same
-    // reason as the DB path above — verdict lives in ASSESSMENT, not UAT).
-    const assessmentFileFb = resolveSliceFile(base, mid, uatSid, "ASSESSMENT");
-    if (assessmentFileFb) {
-        const assessmentContentFb = await loadFile(assessmentFileFb);
-        if (assessmentContentFb && hasVerdict(assessmentContentFb))
-            return null;
-    }
     const uatTypeFb = getUatType(uatContentFb);
     return { sliceId: uatSid, uatType: uatTypeFb };
 }
@@ -1190,28 +1173,6 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
-    // Inline verification classes from planning (if available in DB)
-    try {
-        const { isDbAvailable, getMilestone } = await import("./gsd-db.js");
-        if (isDbAvailable()) {
-            const milestone = getMilestone(mid);
-            if (milestone) {
-                const classes = [];
-                if (milestone.verification_contract)
-                    classes.push(`- **Contract:** ${milestone.verification_contract}`);
-                if (milestone.verification_integration)
-                    classes.push(`- **Integration:** ${milestone.verification_integration}`);
-                if (milestone.verification_operational)
-                    classes.push(`- **Operational:** ${milestone.verification_operational}`);
-                if (milestone.verification_uat)
-                    classes.push(`- **UAT:** ${milestone.verification_uat}`);
-                if (classes.length > 0) {
-                    inlined.push(`### Verification Classes (from planning)\n\nThese verification tiers were defined during milestone planning. Each non-empty class must be checked for evidence during validation.\n\n${classes.join("\n")}`);
-                }
-            }
-        }
-    }
-    catch { /* fall through */ }
     // Inline all slice summaries and UAT results
     let valSliceIds = [];
     try {
@@ -1242,24 +1203,6 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         if (uatInline)
             inlined.push(uatInline);
     }
-    // Aggregate unresolved follow-ups and known limitations across slices
-    const outstandingItems = [];
-    for (const sid of valSliceIds) {
-        const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
-        if (!summaryPath)
-            continue;
-        const content = await loadFile(summaryPath);
-        if (!content)
-            continue;
-        const summary = parseSummary(content);
-        if (summary.followUps)
-            outstandingItems.push(`- **${sid} Follow-ups:** ${summary.followUps.trim()}`);
-        if (summary.knownLimitations)
-            outstandingItems.push(`- **${sid} Known Limitations:** ${summary.knownLimitations.trim()}`);
-    }
-    if (outstandingItems.length > 0) {
-        inlined.push(`### Outstanding Items (aggregated from slice summaries)\n\nThese follow-ups and known limitations were documented during slice completion but have not been resolved.\n\n${outstandingItems.join('\n')}`);
-    }
     // Inline existing VALIDATION file if this is a re-validation round
     const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
     const validationRel = relMilestoneFile(base, mid, "VALIDATION");

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

@@ -6,10 +6,9 @@
  * Pure functions that receive all needed state as parameters — no module-level
  * globals or AutoContext dependency.
  */
-import { parseUnitId } from "./unit-id.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
@@ -149,9 +148,13 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // Reactive-execute: verify that each dispatched task's summary exists.
     // The unitId encodes the batch: "{mid}/{sid}/reactive+T02,T03"
     if (unitType === "reactive-execute") {
-        const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
-        if (!mid || !sid || !batchPart)
+        const parts = unitId.split("/");
+        const mid = parts[0];
+        const sidAndBatch = parts[1];
+        const batchPart = parts[2]; // "reactive+T02,T03"
+        if (!mid || !sidAndBatch || !batchPart)
             return false;
+        const sid = sidAndBatch;
         const plusIdx = batchPart.indexOf("+");
         if (plusIdx === -1) {
             // Legacy format "reactive" without batch IDs — fall back to "any summary"
@@ -178,7 +181,10 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // Gate-evaluate: verify that each dispatched gate has been resolved in the DB.
     // The unitId encodes the batch: "{mid}/{sid}/gates+Q3,Q4"
     if (unitType === "gate-evaluate") {
-        const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+        const parts = unitId.split("/");
+        const mid = parts[0];
+        const sid = parts[1];
+        const batchPart = parts[2]; // "gates+Q3,Q4"
         if (!mid || !sid || !batchPart)
             return false;
         const plusIdx = batchPart.indexOf("+");
@@ -230,7 +236,10 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // execute-task: DB status is authoritative. Fall back to heading-style plan
     // detection when the DB is unavailable (unmigrated projects).
     if (unitType === "execute-task") {
-        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+        const parts = unitId.split("/");
+        const mid = parts[0];
+        const sid = parts[1];
+        const tid = parts[2];
         if (mid && sid && tid) {
             const dbTask = getTask(mid, sid, tid);
             if (dbTask) {
@@ -262,7 +271,9 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // but omitted T{tid}-PLAN.md files would be marked complete, causing execute-task
     // to dispatch with a missing task plan (see issue #739).
     if (unitType === "plan-slice") {
-        const { milestone: mid, slice: sid } = parseUnitId(unitId);
+        const parts = unitId.split("/");
+        const mid = parts[0];
+        const sid = parts[1];
         if (mid && sid) {
             try {
                 // DB primary path — get task IDs to verify task plan files exist
@@ -298,7 +309,9 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // complete-slice: DB status is authoritative for whether the slice is done.
     // Fall back to file-based check (roadmap [x]) when DB is unavailable.
     if (unitType === "complete-slice") {
-        const { milestone: mid, slice: sid } = parseUnitId(unitId);
+        const parts = unitId.split("/");
+        const mid = parts[0];
+        const sid = parts[1];
         if (mid && sid) {
             const dir = resolveSlicePath(base, mid, sid);
             if (dir) {
@@ -364,18 +377,6 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
         `Review and replace this file before relying on downstream artifacts.`,
     ].join("\n");
     writeFileSync(absPath, content, "utf-8");
-    // Mark the task as complete in the DB so verifyExpectedArtifact passes.
-    // Without this, the DB status stays "pending" and the dispatch loop
-    // re-derives the same task indefinitely (#2531).
-    if (unitType === "execute-task" && isDbAvailable()) {
-        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-        if (mid && sid && tid) {
-            try {
-                updateTaskStatus(mid, sid, tid, "complete", new Date().toISOString());
-            }
-            catch { /* non-fatal */ }
-        }
-    }
     return diagnoseExpectedArtifact(unitType, unitId, base);
 }
 // ─── Merge State Reconciliation ───────────────────────────────────────────────
@@ -475,7 +476,10 @@ export function reconcileMergeState(basePath, ctx) {
  * These are shown when automatic reconciliation is not possible.
  */
 export function buildLoopRemediationSteps(unitType, unitId, base) {
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    const parts = unitId.split("/");
+    const mid = parts[0];
+    const sid = parts[1];
+    const tid = parts[2];
     switch (unitType) {
         case "execute-task": {
             if (!mid || !sid || !tid)

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

@@ -10,7 +10,6 @@
  * telling the LLM which files to read and what to do.
  */
 import { deriveState } from "./state.js";
-import { parseUnitId } from "./unit-id.js";
 import { getManifestStatus } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -32,7 +31,6 @@ import { runGSDDoctor, rebuildState } from "./doctor.js";
 import { preDispatchHealthGate, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
 import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
-import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
@@ -124,11 +122,6 @@ function deregisterSigtermHandler() {
 export function getAutoDashboardData() {
     const ledger = getLedger();
     const totals = ledger ? getProjectTotals(ledger.units) : null;
-    const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ?? null;
-    const rtkSavings = sessionId && s.basePath
-        ? getRtkSessionSavings(s.basePath, sessionId)
-        : null;
-    const rtkEnabled = loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true;
     // Pending capture count — lazy check, non-fatal
     let pendingCaptureCount = 0;
     try {
@@ -152,8 +145,6 @@ export function getAutoDashboardData() {
         totalCost: totals?.cost ?? 0,
         totalTokens: totals?.tokens.total ?? 0,
         pendingCaptureCount,
-        rtkSavings,
-        rtkEnabled,
     };
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
@@ -370,11 +361,8 @@ export async function stopAuto(ctx, pi, reason) {
         // When the milestone is complete (has a SUMMARY), merge the worktree branch
         // back to main so code isn't stranded on the worktree branch (#2317).
         // For incomplete milestones, preserve the branch for later resumption.
-        //
-        // Skip if phases.ts already merged this milestone — avoids the double
-        // mergeAndExit that fails because the branch was already deleted (#2645).
         try {
-            if (s.currentMilestoneId && !s.milestoneMergedInPhases) {
+            if (s.currentMilestoneId) {
                 const notifyCtx = ctx
                     ? { notify: ctx.ui.notify.bind(ctx.ui) }
                     : { notify: () => { } };
@@ -939,13 +927,15 @@ const widgetStateAccessors = {
  * dispatching a unit. The LLM should never need to mkdir or git checkout.
  */
 function ensurePreconditions(unitType, unitId, base, state) {
-    const { milestone: mid, slice: sid } = parseUnitId(unitId);
+    const parts = unitId.split("/");
+    const mid = parts[0];
     const mDir = resolveMilestonePath(base, mid);
     if (!mDir) {
         const newDir = join(milestonesDir(base), mid);
         mkdirSync(join(newDir, "slices"), { recursive: true });
     }
-    if (sid !== undefined) {
+    if (parts.length >= 2) {
+        const sid = parts[1];
         const mDirResolved = resolveMilestonePath(base, mid);
         if (mDirResolved) {
             const slicesDir = join(mDirResolved, "slices");