gsd-pi 2.50.0-dev.d210a87 → 2.50.0

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -13,11 +13,10 @@ import type { GSDState } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
 import type { UatType } from "./files.js";
 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,
@@ -27,7 +26,7 @@ import {
   buildMilestoneFileName,
   buildSliceFileName,
 } from "./paths.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
 import {
@@ -89,46 +88,10 @@ function missingSliceStop(mid: string, phase: string): DispatchAction {
   };
 }
 
-/**
- * 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: string, mid: string): string[] {
-  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: string): string {
-  return join(gsdRoot(basePath), "runtime", "rewrite-count.json");
-}
-
-export function getRewriteCount(basePath: string): number {
-  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: string, count: number): void {
-  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: DispatchRule[] = [
@@ -137,14 +100,14 @@ export const DISPATCH_RULES: DispatchRule[] = [
     match: async ({ mid, midTitle, state, basePath, session }) => {
       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",
@@ -580,14 +543,30 @@ export const DISPATCH_RULES: DispatchRule[] = [
       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: string[];
+      if (isDbAvailable()) {
+        sliceIds = getMilestoneSlices(mid).map(s => s.id);
+      } else {
+        sliceIds = [];
+      }
+
+      if (sliceIds.length > 0) {
+        const missingSlices: string[] = [];
+        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
@@ -627,13 +606,28 @@ export const DISPATCH_RULES: DispatchRule[] = [
       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: string[];
+      if (isDbAvailable()) {
+        sliceIds = getMilestoneSlices(mid).map(s => s.id);
+      } else {
+        sliceIds = [];
+      }
+
+      if (sliceIds.length > 0) {
+        const missingSlices: string[] = [];
+        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
@@ -647,33 +641,6 @@ export const DISPATCH_RULES: DispatchRule[] = [
         };
       }
 
-      // 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" as const,
-                    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" as const,
-                  };
-                }
-              }
-            }
-          }
-        }
-      } catch { /* fall through — don't block on DB errors */ }
-
       return {
         action: "dispatch",
         unitType: "complete-milestone",

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -47,29 +47,8 @@ import {
 } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
-import { runSafely } from "./auto-utils.js";
-import type { AutoSession, SidecarItem } from "./auto/session.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: AutoSession,
-  ctx: ExtensionContext,
-  entry: SidecarItem,
-  debugExtra: Record<string, unknown>,
-  notification?: string,
-): "continue" {
-  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";
-}
+import type { AutoSession } from "./auto/session.js";
+
 /** 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()`. */
@@ -260,7 +239,6 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
 
   // Auto-commit
   if (s.currentUnit) {
-    const unit = s.currentUnit;
     try {
       let taskContext: TaskCommitContext | undefined;
 
@@ -319,56 +297,64 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
     }
 
     // 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", () => {
-        syncStateToProjectRoot(s.basePath, s.originalBasePath!, s.currentMilestoneId);
-      });
+      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
@@ -516,11 +502,23 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
       }
       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
@@ -619,12 +617,26 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
             }
 
             const triageUnitId = `${mid}/${sid}/triage`;
-            return enqueueSidecar(
-              s, ctx,
-              { kind: "triage", unitType: "triage-captures", unitId: triageUnitId, prompt },
-              { pendingCount: pending.length },
+            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";
           }
         }
       }
@@ -653,12 +665,27 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
       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 },
+      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/src/resources/extensions/gsd/auto-prompts.ts

@@ -784,14 +784,6 @@ export async function checkNeedsRunUat(
         if (!uatContent) return null;
         // 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 };
       }
@@ -816,13 +808,6 @@ export async function checkNeedsRunUat(
   if (!uatContentFb) return null;
   // 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 };
 }
@@ -1345,24 +1330,6 @@ export async function buildValidateMilestonePrompt(
   const inlined: string[] = [];
   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: string[] = [];
-        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: string[] = [];
   try {
@@ -1392,21 +1359,6 @@ export async function buildValidateMilestonePrompt(
     if (uatInline) inlined.push(uatInline);
   }
 
-  // Aggregate unresolved follow-ups and known limitations across slices
-  const outstandingItems: string[] = [];
-  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/src/resources/extensions/gsd/auto-recovery.ts

@@ -12,7 +12,7 @@ import { parseUnitId } from "./unit-id.js";
 import { atomicWriteSync } from "./atomic-write.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,
@@ -195,8 +195,13 @@ export function verifyExpectedArtifact(
   // 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) return false;
+    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"
@@ -228,7 +233,10 @@ export function verifyExpectedArtifact(
   // 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("+");
@@ -278,7 +286,10 @@ export function verifyExpectedArtifact(
   // 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) {
@@ -308,7 +319,9 @@ export function verifyExpectedArtifact(
   // 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
@@ -343,7 +356,9 @@ export function verifyExpectedArtifact(
   // 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) {
@@ -410,17 +425,6 @@ export function writeBlockerPlaceholder(
     `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);
 }
 
@@ -540,7 +544,10 @@ export function buildLoopRemediationSteps(
   unitId: string,
   base: string,
 ): string | null {
-  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) break;

package/src/resources/extensions/gsd/auto.ts

@@ -17,7 +17,6 @@ import type {
 } from "@gsd/pi-coding-agent";
 
 import { deriveState } from "./state.js";
-import { parseUnitId } from "./unit-id.js";
 import type { GSDState } from "./types.js";
 import { getManifestStatus } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
@@ -105,7 +104,6 @@ import {
   captureAvailableSkills,
   resetSkillTelemetry,
 } from "./skill-telemetry.js";
-import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import {
   initMetrics,
   resetMetrics,
@@ -303,11 +301,6 @@ export { type AutoDashboardData } from "./auto-dashboard.js";
 export function getAutoDashboardData(): AutoDashboardData {
   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 {
@@ -330,8 +323,6 @@ export function getAutoDashboardData(): AutoDashboardData {
     totalCost: totals?.cost ?? 0,
     totalTokens: totals?.tokens.total ?? 0,
     pendingCaptureCount,
-    rtkSavings,
-    rtkEnabled,
   };
 }
 
@@ -599,11 +590,8 @@ export async function stopAuto(
     // 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: () => {} };
@@ -1289,7 +1277,8 @@ function ensurePreconditions(
   base: string,
   state: GSDState,
 ): void {
-  const { milestone: mid, slice: sid } = parseUnitId(unitId);
+  const parts = unitId.split("/");
+  const mid = parts[0]!;
 
   const mDir = resolveMilestonePath(base, mid);
   if (!mDir) {
@@ -1297,7 +1286,8 @@ function ensurePreconditions(
     mkdirSync(join(newDir, "slices"), { recursive: true });
   }
 
-  if (sid !== undefined) {
+  if (parts.length >= 2) {
+    const sid = parts[1]!;
 
     const mDirResolved = resolveMilestonePath(base, mid);
     if (mDirResolved) {