gsd-pi 2.49.0 → 2.50.0-dev.9476db8

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

@@ -5,7 +5,8 @@
  * state, no globals — every dependency is passed as a parameter or imported as a
  * utility.
  */
-import { loadFile, parseContinue, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
+import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
+import { hasVerdict, getUatType } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
@@ -14,6 +15,7 @@ import { getLoadedSkills } from "@gsd/pi-coding-agent";
 import { join, basename } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
+import { getPendingGates } from "./gsd-db.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 const MAX_PREAMBLE_CHARS = 30_000;
@@ -354,10 +356,17 @@ function resolvePreferredSkillNames(prefs, visibleSkills, contextTokens, base) {
         .filter(skill => preferred.has(normalizeSkillReference(skill.name)) && skillMatchesContext(skill, contextTokens))
         .map(skill => normalizeSkillReference(skill.name));
 }
+/** Skill names must be lowercase alphanumeric with hyphens — reject anything else
+ *  to prevent prompt injection via crafted directory names. */
+const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9-]*$/;
 function formatSkillActivationBlock(skillNames) {
-    if (skillNames.length === 0)
+    const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
+    if (safe.length === 0)
         return "";
-    const calls = skillNames.map(name => `Call Skill('${name}')`).join('. ');
+    // Use explicit parameter syntax so LLMs pass { skill: "..." } instead of { name: "..." }.
+    // The function-call-like syntax `Skill('name')` led LLMs to infer a positional
+    // parameter name, causing tool validation failures — see #2224.
+    const calls = safe.map(name => `Call Skill({ skill: '${name}' })`).join('. ');
     return `<skill_activation>${calls}.</skill_activation>`;
 }
 export function buildSkillActivationBlock(params) {
@@ -663,13 +672,10 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
                 const uatContent = await loadFile(uatFile);
                 if (!uatContent)
                     return null;
-                const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-                if (uatResultFile) {
-                    const hasResult = !!(await loadFile(uatResultFile));
-                    if (hasResult)
-                        return null;
-                }
-                const uatType = extractUatType(uatContent) ?? "artifact-driven";
+                // If the UAT file already contains a verdict, UAT has been run — skip
+                if (hasVerdict(uatContent))
+                    return null;
+                const uatType = getUatType(uatContent);
                 return { sliceId: sid, uatType };
             }
         }
@@ -697,13 +703,10 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
     const uatContentFb = await loadFile(uatFileFb);
     if (!uatContentFb)
         return null;
-    const uatResultFb = resolveSliceFile(base, mid, uatSid, "UAT-RESULT");
-    if (uatResultFb) {
-        const hasResultFb = !!(await loadFile(uatResultFb));
-        if (hasResultFb)
-            return null;
-    }
-    const uatTypeFb = extractUatType(uatContentFb) ?? "artifact-driven";
+    // If the UAT file already contains a verdict, UAT has been run — skip
+    if (hasVerdict(uatContentFb))
+        return null;
+    const uatTypeFb = getUatType(uatContentFb);
     return { sliceId: uatSid, uatType: uatTypeFb };
 }
 // ─── Prompt Builders ──────────────────────────────────────────────────────
@@ -1194,8 +1197,8 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
         const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
         inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
-        const uatPath = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-        const uatRel = relSliceFile(base, mid, sid, "UAT-RESULT");
+        const uatPath = resolveSliceFile(base, mid, sid, "UAT");
+        const uatRel = relSliceFile(base, mid, sid, "UAT");
         const uatInline = await inlineFileOptional(uatPath, uatRel, `${sid} UAT Result`);
         if (uatInline)
             inlined.push(uatInline);
@@ -1334,8 +1337,8 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
     if (projectInline)
         inlined.push(projectInline);
     const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
-    const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "UAT-RESULT"));
-    const uatType = extractUatType(uatContent) ?? "artifact-driven";
+    const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "UAT"));
+    const uatType = getUatType(uatContent);
     return loadPrompt("run-uat", {
         workingDirectory: base,
         milestoneId: mid,
@@ -1465,6 +1468,84 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         inlinedTemplates,
     });
 }
+// ─── Gate Evaluation ──────────────────────────────────────────────────────
+const GATE_QUESTIONS = {
+    Q3: {
+        question: "How can this be exploited?",
+        guidance: [
+            "Identify abuse scenarios: parameter tampering, replay attacks, privilege escalation.",
+            "Map data exposure risks: PII, tokens, secrets accessible through this slice.",
+            "Define input trust boundaries: untrusted user input reaching DB, API, or filesystem.",
+            "If none apply, return verdict 'omitted' with rationale explaining why.",
+        ].join("\n"),
+    },
+    Q4: {
+        question: "What existing promises does this break?",
+        guidance: [
+            "List which existing requirements (R001, R003, etc.) are touched by this slice.",
+            "Identify what must be re-tested after shipping.",
+            "Flag decisions that should be revisited given the new scope.",
+            "If no existing requirements are affected, return verdict 'omitted'.",
+        ].join("\n"),
+    },
+};
+export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base) {
+    const pending = getPendingGates(mid, sid, "slice");
+    // Load the slice plan for context
+    const planFile = resolveSliceFile(base, mid, sid, "PLAN");
+    const planContent = planFile ? (await loadFile(planFile)) ?? "(plan file empty)" : "(plan file not found)";
+    // Build per-gate subagent prompts
+    const subagentSections = [];
+    const gateListLines = [];
+    for (const gate of pending) {
+        const meta = GATE_QUESTIONS[gate.gate_id];
+        if (!meta)
+            continue;
+        gateListLines.push(`- **${gate.gate_id}**: ${meta.question}`);
+        const subPrompt = [
+            `You are evaluating quality gate **${gate.gate_id}** for slice ${sid} (${sTitle}).`,
+            "",
+            `## Question: ${meta.question}`,
+            "",
+            meta.guidance,
+            "",
+            "## Slice Plan",
+            "",
+            planContent,
+            "",
+            "## Instructions",
+            "",
+            "Analyze the slice plan above and answer the gate question.",
+            `Call the \`gsd_save_gate_result\` tool with:`,
+            `- \`milestoneId\`: "${mid}"`,
+            `- \`sliceId\`: "${sid}"`,
+            `- \`gateId\`: "${gate.gate_id}"`,
+            "- `verdict`: \"pass\" (no concerns), \"flag\" (concerns found), or \"omitted\" (not applicable)",
+            "- `rationale`: one-sentence justification",
+            "- `findings`: detailed markdown findings (or empty if omitted)",
+        ].join("\n");
+        subagentSections.push([
+            `### ${gate.gate_id}: ${meta.question}`,
+            "",
+            "Use this as the prompt for a `subagent` call:",
+            "",
+            "```",
+            subPrompt,
+            "```",
+        ].join("\n"));
+    }
+    return loadPrompt("gate-evaluate", {
+        workingDirectory: base,
+        milestoneId: mid,
+        milestoneTitle: midTitle,
+        sliceId: sid,
+        sliceTitle: sTitle,
+        slicePlanContent: planContent,
+        gateCount: String(pending.length),
+        gateList: gateListLines.join("\n"),
+        subagentPrompts: subagentSections.join("\n\n---\n\n"),
+    });
+}
 export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, overrides) {
     const sid = activeSlice?.id;
     const sTitle = activeSlice?.title ?? "";

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

@@ -6,85 +6,19 @@
  * Pure functions that receive all needed state as parameters — no module-level
  * globals or AutoContext dependency.
  */
-import { clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.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 { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
+import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
+// Re-export so existing consumers of auto-recovery.ts keep working.
+export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 // ─── Artifact Resolution & Verification ───────────────────────────────────────
-/**
- * Resolve the expected artifact for a unit to an absolute path.
- */
-export function resolveExpectedArtifactPath(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
-    switch (unitType) {
-        case "discuss-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "CONTEXT")) : null;
-        }
-        case "research-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "RESEARCH")) : null;
-        }
-        case "plan-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "ROADMAP")) : null;
-        }
-        case "research-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "RESEARCH")) : null;
-        }
-        case "plan-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "PLAN")) : null;
-        }
-        case "reassess-roadmap": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "ASSESSMENT")) : null;
-        }
-        case "run-uat": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "UAT-RESULT")) : null;
-        }
-        case "execute-task": {
-            const tid = parts[2];
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir && tid
-                ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY"))
-                : null;
-        }
-        case "complete-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "SUMMARY")) : null;
-        }
-        case "validate-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "VALIDATION")) : null;
-        }
-        case "complete-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "SUMMARY")) : null;
-        }
-        case "replan-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "REPLAN")) : null;
-        }
-        case "rewrite-docs":
-            return null;
-        case "reactive-execute":
-            // Reactive execute produces multiple task summaries — verified separately
-            return null;
-        default:
-            return null;
-    }
-}
 /**
  * Check whether a milestone produced implementation artifacts (non-`.gsd/` files)
  * in the git history. Uses `git log --name-only` to inspect all commits on the
@@ -244,6 +178,36 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         }
         return true;
     }
+    // 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 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("+");
+        if (plusIdx === -1)
+            return true; // no specific gates encoded — pass
+        const gateIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
+        if (gateIds.length === 0)
+            return true;
+        try {
+            const { getPendingGates: getPending } = require("./gsd-db.js");
+            const pending = getPending(mid, sid, "slice");
+            const pendingIds = new Set(pending.map((g) => g.gate_id));
+            // All dispatched gates must no longer be pending
+            for (const gid of gateIds) {
+                if (pendingIds.has(gid))
+                    return false;
+            }
+        }
+        catch {
+            // DB unavailable — treat as verified to avoid blocking
+        }
+        return true;
+    }
     const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
     // For unit types with no verifiable artifact (null path), the parent directory
     // is missing on disk — treat as stale completion state so the key gets evicted (#313).
@@ -415,44 +379,35 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
     writeFileSync(absPath, content, "utf-8");
     return diagnoseExpectedArtifact(unitType, unitId, base);
 }
-export function diagnoseExpectedArtifact(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
-    switch (unitType) {
-        case "discuss-milestone":
-            return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
-        case "research-milestone":
-            return `${relMilestoneFile(base, mid, "RESEARCH")} (milestone research)`;
-        case "plan-milestone":
-            return `${relMilestoneFile(base, mid, "ROADMAP")} (milestone roadmap)`;
-        case "research-slice":
-            return `${relSliceFile(base, mid, sid, "RESEARCH")} (slice research)`;
-        case "plan-slice":
-            return `${relSliceFile(base, mid, sid, "PLAN")} (slice plan)`;
-        case "execute-task": {
-            const tid = parts[2];
-            return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid, "PLAN")} + summary written`;
+// ─── Merge State Reconciliation ───────────────────────────────────────────────
+/**
+ * Best-effort abort of a pending merge/squash and hard-reset to HEAD.
+ * Handles both real merges (MERGE_HEAD) and squash merges (SQUASH_MSG).
+ */
+function abortAndResetMerge(basePath, hasMergeHead, squashMsgPath) {
+    if (hasMergeHead) {
+        try {
+            nativeMergeAbort(basePath);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    else if (squashMsgPath) {
+        try {
+            unlinkSync(squashMsgPath);
+        }
+        catch {
+            /* best-effort */
         }
-        case "complete-slice":
-            return `Slice ${sid} marked [x] in ${relMilestoneFile(base, mid, "ROADMAP")} + summary + UAT written`;
-        case "replan-slice":
-            return `${relSliceFile(base, mid, sid, "REPLAN")} + updated ${relSliceFile(base, mid, sid, "PLAN")}`;
-        case "rewrite-docs":
-            return "Active overrides resolved in .gsd/OVERRIDES.md + plan documents updated";
-        case "reassess-roadmap":
-            return `${relSliceFile(base, mid, sid, "ASSESSMENT")} (roadmap reassessment)`;
-        case "run-uat":
-            return `${relSliceFile(base, mid, sid, "UAT-RESULT")} (UAT result)`;
-        case "validate-milestone":
-            return `${relMilestoneFile(base, mid, "VALIDATION")} (milestone validation report)`;
-        case "complete-milestone":
-            return `${relMilestoneFile(base, mid, "SUMMARY")} (milestone summary)`;
-        default:
-            return null;
+    }
+    try {
+        nativeResetHard(basePath);
+    }
+    catch {
+        /* best-effort */
     }
 }
-// ─── Merge State Reconciliation ───────────────────────────────────────────────
 /**
  * Detect leftover merge state from a prior session and reconcile it.
  * If MERGE_HEAD or SQUASH_MSG exists, check whether conflicts are resolved.
@@ -503,95 +458,18 @@ export function reconcileMergeState(basePath, ctx) {
                 }
             }
             if (!resolved) {
-                if (hasMergeHead) {
-                    try {
-                        nativeMergeAbort(basePath);
-                    }
-                    catch {
-                        /* best-effort */
-                    }
-                }
-                else if (hasSquashMsg) {
-                    try {
-                        unlinkSync(squashMsgPath);
-                    }
-                    catch {
-                        /* best-effort */
-                    }
-                }
-                try {
-                    nativeResetHard(basePath);
-                }
-                catch {
-                    /* best-effort */
-                }
+                abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
                 ctx.ui.notify("Detected leftover merge state — auto-resolve failed, cleaned up. Re-deriving state.", "warning");
             }
         }
         else {
             // Code conflicts present — abort and reset
-            if (hasMergeHead) {
-                try {
-                    nativeMergeAbort(basePath);
-                }
-                catch {
-                    /* best-effort */
-                }
-            }
-            else if (hasSquashMsg) {
-                try {
-                    unlinkSync(squashMsgPath);
-                }
-                catch {
-                    /* best-effort */
-                }
-            }
-            try {
-                nativeResetHard(basePath);
-            }
-            catch {
-                /* best-effort */
-            }
+            abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
             ctx.ui.notify("Detected leftover merge state with unresolved conflicts — cleaned up. Re-deriving state.", "warning");
         }
     }
     return true;
 }
-// ─── Self-Heal Runtime Records ────────────────────────────────────────────────
-/**
- * Self-heal: scan runtime records in .gsd/ and clear stale ones.
- * Clears dispatched records older than 1 hour (process crashed before
- * completing the unit). deriveState() handles re-derivation — no need
- * for completion key persistence here.
- */
-export async function selfHealRuntimeRecords(base, ctx) {
-    try {
-        const { listUnitRuntimeRecords } = await import("./unit-runtime.js");
-        const records = listUnitRuntimeRecords(base);
-        let healed = 0;
-        const STALE_THRESHOLD_MS = 60 * 60 * 1000; // 1 hour
-        const now = Date.now();
-        for (const record of records) {
-            const { unitType, unitId } = record;
-            // Case 0 removed — roadmap checkbox auto-fix is no longer needed.
-            // With DB-as-truth, stale checkboxes are fixed by repairStaleRenders().
-            // Clear stale dispatched records (dispatched > 1h ago, process crashed)
-            const age = now - (record.startedAt ?? 0);
-            if (record.phase === "dispatched" && age > STALE_THRESHOLD_MS) {
-                clearUnitRuntimeRecord(base, unitType, unitId);
-                healed++;
-                continue;
-            }
-        }
-        if (healed > 0) {
-            ctx.ui.notify(`Self-heal: cleared ${healed} stale runtime record(s).`, "info");
-        }
-    }
-    catch (e) {
-        // Non-fatal — self-heal should never block auto-mode start
-        void e;
-    }
-}
 // ─── Loop Remediation ─────────────────────────────────────────────────────────
 /**
  * Build concrete, manual remediation steps for a loop-detected unit failure.

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

@@ -24,7 +24,7 @@ import { nativeInit, nativeAddAll, nativeCommit, } 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 { readResourceVersion } from "./auto-worktree-sync.js";
+import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
 import { initMetrics } from "./metrics.js";
 import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
@@ -33,6 +33,7 @@ import { snapshotSkills } from "./skill-discovery.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
+import { parseUnitId } from "./unit-id.js";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
@@ -119,7 +120,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 ctx.ui.notify(`Another auto-mode session (PID ${crashLock.pid}) appears to be running.\nStop it with \`kill ${crashLock.pid}\` before starting a new session.`, "error");
                 return releaseLockAndReturn();
             }
-            const recoveredMid = crashLock.unitId.split("/")[0];
+            const recoveredMid = parseUnitId(crashLock.unitId).milestone;
             const milestoneAlreadyComplete = recoveredMid
                 ? !!resolveMilestoneFile(base, recoveredMid, "SUMMARY")
                 : false;
@@ -159,35 +160,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Invalidate caches before initial state derivation
         invalidateAllCaches();
         // Clean stale runtime unit files for completed milestones (#887)
-        try {
-            const runtimeUnitsDir = join(gsdRoot(base), "runtime", "units");
-            if (existsSync(runtimeUnitsDir)) {
-                for (const file of readdirSync(runtimeUnitsDir)) {
-                    if (!file.endsWith(".json"))
-                        continue;
-                    const midMatch = file.match(/(M\d+(?:-[a-z0-9]{6})?)/);
-                    if (!midMatch)
-                        continue;
-                    const mid = midMatch[1];
-                    if (resolveMilestoneFile(base, mid, "SUMMARY")) {
-                        try {
-                            unlinkSync(join(runtimeUnitsDir, file));
-                        }
-                        catch (e) {
-                            debugLog("stale-unit-cleanup-failed", {
-                                file,
-                                error: e instanceof Error ? e.message : String(e),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) {
-            debugLog("stale-unit-dir-cleanup-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
-        }
+        cleanStaleRuntimeUnits(gsdRoot(base), (mid) => !!resolveMilestoneFile(base, mid, "SUMMARY"));
         let state = await deriveState(base);
         // Stale worktree state recovery (#654)
         if (state.activeMilestone &&

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

@@ -155,7 +155,7 @@ export function startUnitSupervision(sctx) {
             const message = err instanceof Error ? err.message : String(err);
             console.error(`[idle-watchdog] Unhandled error: ${message}`);
             // Unblock any pending unit promise so the auto-loop is not orphaned.
-            resolveAgentEndCancelled();
+            resolveAgentEndCancelled({ message: `Idle watchdog error: ${message}`, category: "idle", isTransient: true });
             try {
                 ctx.ui.notify(`Idle watchdog error: ${message}`, "warning");
             }
@@ -188,7 +188,7 @@ export function startUnitSupervision(sctx) {
             const message = err instanceof Error ? err.message : String(err);
             console.error(`[hard-timeout] Unhandled error: ${message}`);
             // Unblock any pending unit promise so the auto-loop is not orphaned.
-            resolveAgentEndCancelled();
+            resolveAgentEndCancelled({ message: `Hard timeout error: ${message}`, category: "timeout", isTransient: true });
             try {
                 ctx.ui.notify(`Hard timeout error: ${message}`, "warning");
             }

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

@@ -10,6 +10,7 @@
  * checks the result and handles control flow.
  */
 import { resolveSlicePath } from "./paths.js";
+import { parseUnitId } from "./unit-id.js";
 import { isDbAvailable, getTask } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
@@ -34,18 +35,15 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         const effectivePrefs = loadEffectiveGSDPreferences();
         const prefs = effectivePrefs?.preferences;
         // Read task plan verify field
-        const parts = s.currentUnit.id.split("/");
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
         let taskPlanVerify;
-        if (parts.length >= 3) {
-            const [mid, sid, tid] = parts;
+        if (mid && sid && tid) {
             if (isDbAvailable()) {
                 taskPlanVerify = getTask(mid, sid, tid)?.verify;
             }
             // When DB unavailable, taskPlanVerify stays undefined — gate runs without task-specific checks
         }
         const result = runVerificationGate({
-            basePath: s.basePath,
-            unitId: s.currentUnit.id,
             cwd: s.basePath,
             preferenceCommands: prefs?.verification_commands,
             taskPlanVerify,
@@ -100,9 +98,8 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         }
         // Write verification evidence JSON
         const attempt = s.verificationRetryCount.get(s.currentUnit.id) ?? 0;
-        if (parts.length >= 3) {
+        if (mid && sid && tid) {
             try {
-                const [mid, sid, tid] = parts;
                 const sDir = resolveSlicePath(s.basePath, mid, sid);
                 if (sDir) {
                     const tasksDir = join(sDir, "tasks");