gsd-pi 2.48.0-dev.ced2eca → 2.49.0-dev.9e177e9

package/dist/headless-ui.js

@@ -13,9 +13,19 @@ export function handleExtensionUIRequest(event, writeToStdin) {
     const { id, method } = event;
     let response;
     switch (method) {
-        case 'select':
-            response = { type: 'extension_ui_response', id, value: event.options?.[0] ?? '' };
+        case 'select': {
+            // Lock-guard prompts list "View status" first, but headless needs "Force start"
+            // to proceed. Detect by title and pick the force option.
+            const title = String(event.title ?? '');
+            let selected = event.options?.[0] ?? '';
+            if (title.includes('Auto-mode is running') && event.options) {
+                const forceOption = event.options.find(o => o.toLowerCase().includes('force start'));
+                if (forceOption)
+                    selected = forceOption;
+            }
+            response = { type: 'extension_ui_response', id, value: selected };
             break;
+        }
         case 'confirm':
             response = { type: 'extension_ui_response', id, confirmed: true };
             break;

package/dist/headless.js

@@ -37,8 +37,8 @@ export function parseHeadlessArgs(argv) {
         if (!positionalStarted && arg.startsWith('--')) {
             if (arg === '--timeout' && i + 1 < args.length) {
                 options.timeout = parseInt(args[++i], 10);
-                if (Number.isNaN(options.timeout) || options.timeout <= 0) {
-                    process.stderr.write('[headless] Error: --timeout must be a positive integer (milliseconds)\n');
+                if (Number.isNaN(options.timeout) || options.timeout < 0) {
+                    process.stderr.write('[headless] Error: --timeout must be a non-negative integer (milliseconds, 0 to disable)\n');
                     process.exit(1);
                 }
             }
@@ -132,6 +132,13 @@ async function runHeadlessOnce(options, restartCount) {
     if (isNewMilestone && options.timeout === 300_000) {
         options.timeout = 600_000; // 10 minutes
     }
+    // auto-mode sessions are long-running (minutes to hours) with their own internal
+    // per-unit timeout via auto-supervisor. Disable the overall timeout unless the
+    // user explicitly set --timeout.
+    const isAutoMode = options.command === 'auto';
+    if (isAutoMode && options.timeout === 300_000) {
+        options.timeout = 0;
+    }
     // Supervised mode cannot share stdin with --context -
     if (options.supervised && options.context === '-') {
         process.stderr.write('[headless] Error: --supervised cannot be used with --context - (both require stdin)\n');
@@ -267,12 +274,14 @@ async function runHeadlessOnce(options, restartCount) {
     }
     // Precompute supervised response timeout
     const responseTimeout = options.responseTimeout ?? 30_000;
-    // Overall timeout
-    const timeoutTimer = setTimeout(() => {
-        process.stderr.write(`[headless] Timeout after ${options.timeout / 1000}s\n`);
-        exitCode = 1;
-        resolveCompletion();
-    }, options.timeout);
+    // Overall timeout (disabled when options.timeout === 0, e.g. auto-mode)
+    const timeoutTimer = options.timeout > 0
+        ? setTimeout(() => {
+            process.stderr.write(`[headless] Timeout after ${options.timeout / 1000}s\n`);
+            exitCode = 1;
+            resolveCompletion();
+        }, options.timeout)
+        : null;
     // Event handler
     client.onEvent((event) => {
         const eventObj = event;
@@ -354,7 +363,8 @@ async function runHeadlessOnce(options, restartCount) {
         interrupted = true;
         exitCode = 1;
         client.stop().finally(() => {
-            clearTimeout(timeoutTimer);
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
             if (idleTimer)
                 clearTimeout(idleTimer);
             process.exit(exitCode);
@@ -368,7 +378,8 @@ async function runHeadlessOnce(options, restartCount) {
     }
     catch (err) {
         process.stderr.write(`[headless] Error: Failed to start RPC session: ${err instanceof Error ? err.message : String(err)}\n`);
-        clearTimeout(timeoutTimer);
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
         process.exit(1);
     }
     // Access stdin writer from the internal process
@@ -376,7 +387,8 @@ async function runHeadlessOnce(options, restartCount) {
     if (!internalProcess?.stdin) {
         process.stderr.write('[headless] Error: Cannot access child process stdin\n');
         await client.stop();
-        clearTimeout(timeoutTimer);
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
         process.exit(1);
     }
     stdinWriter = (data) => {
@@ -424,7 +436,10 @@ async function runHeadlessOnce(options, restartCount) {
         if (!options.json) {
             process.stderr.write('[headless] Milestone ready — chaining into auto-mode...\n');
         }
-        // Reset completion state for the auto-mode phase
+        // Reset completion state for the auto-mode phase.
+        // Disable the overall timeout — auto-mode has its own internal supervisor.
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
         completed = false;
         milestoneReady = false;
         blocked = false;
@@ -443,7 +458,8 @@ async function runHeadlessOnce(options, restartCount) {
         }
     }
     // Cleanup
-    clearTimeout(timeoutTimer);
+    if (timeoutTimer)
+        clearTimeout(timeoutTimer);
     if (idleTimer)
         clearTimeout(idleTimer);
     pendingResponseTimers.forEach((timer) => clearTimeout(timer));

package/dist/resources/extensions/gsd/auto/infra-errors.js

@@ -17,6 +17,7 @@ export const INFRA_ERROR_CODES = new Set([
     "EDQUOT", // disk quota exceeded
     "EMFILE", // too many open files (process)
     "ENFILE", // too many open files (system)
+    "EAGAIN", // resource temporarily unavailable (resource exhaustion)
     "ECONNREFUSED", // connection refused (offline / local server down)
     "ENOTFOUND", // DNS lookup failed (offline / no network)
     "ENETUNREACH", // network unreachable (offline / no route)

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

@@ -721,18 +721,18 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     deps.updateSessionLock(deps.lockBase(), unitType, unitId, sessionFile);
     deps.writeLock(deps.lockBase(), unitType, unitId, sessionFile);
     // Tag the most recent window entry with error info for stuck detection
-    if (unitResult.status === "error" || unitResult.status === "cancelled") {
-        const lastEntry = loopState.recentUnits[loopState.recentUnits.length - 1];
-        if (lastEntry) {
+    const lastEntry = loopState.recentUnits[loopState.recentUnits.length - 1];
+    if (lastEntry) {
+        if (unitResult.errorContext) {
+            lastEntry.error = `${unitResult.errorContext.category}:${unitResult.errorContext.message}`.slice(0, 200);
+        }
+        else if (unitResult.status === "error" || unitResult.status === "cancelled") {
             lastEntry.error = `${unitResult.status}:${unitType}/${unitId}`;
         }
-    }
-    else if (unitResult.event?.messages?.length) {
-        const lastMsg = unitResult.event.messages[unitResult.event.messages.length - 1];
-        const msgStr = typeof lastMsg === "string" ? lastMsg : JSON.stringify(lastMsg);
-        if (/error|fail|exception/i.test(msgStr)) {
-            const lastEntry = loopState.recentUnits[loopState.recentUnits.length - 1];
-            if (lastEntry) {
+        else if (unitResult.event?.messages?.length) {
+            const lastMsg = unitResult.event.messages[unitResult.event.messages.length - 1];
+            const msgStr = typeof lastMsg === "string" ? lastMsg : JSON.stringify(lastMsg);
+            if (/error|fail|exception/i.test(msgStr)) {
                 lastEntry.error = msgStr.slice(0, 200);
             }
         }
@@ -779,7 +779,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.unitDispatchCount.delete(`${unitType}/${unitId}`);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
-    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified, ...(unitResult.errorContext ? { errorContext: unitResult.errorContext } : {}) }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
     return { action: "next", data: { unitStartedAt: s.currentUnit.startedAt } };
 }
 // ─── runFinalize ──────────────────────────────────────────────────────────────

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

@@ -64,12 +64,12 @@ export function isSessionSwitchInFlight() {
  * blocks to ensure the autoLoop is never stuck awaiting a promise that
  * will never resolve. Safe to call when no resolver is pending (no-op).
  */
-export function resolveAgentEndCancelled() {
+export function resolveAgentEndCancelled(errorContext) {
     if (_currentResolve) {
         debugLog("resolveAgentEndCancelled", { status: "resolving-cancelled" });
         const r = _currentResolve;
         _currentResolve = null;
-        r({ status: "cancelled" });
+        r({ status: "cancelled", ...(errorContext ? { errorContext } : {}) });
     }
 }
 // ─── resetPendingResolve (test helper) ───────────────────────────────────────

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

@@ -41,13 +41,13 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
             unitId,
             error: msg,
         });
-        return { status: "cancelled" };
+        return { status: "cancelled", errorContext: { message: `Session creation failed: ${msg}`, category: "session-failed", isTransient: true } };
     }
     if (sessionTimeoutHandle)
         clearTimeout(sessionTimeoutHandle);
     if (sessionResult.cancelled) {
         debugLog("runUnit-session-timeout", { unitType, unitId });
-        return { status: "cancelled" };
+        return { status: "cancelled", errorContext: { message: "Session creation timed out", category: "timeout", isTransient: true } };
     }
     if (!s.active) {
         return { status: "cancelled" };

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

@@ -61,6 +61,9 @@ export class AutoSession {
     lastStateRebuildAt = 0;
     // ── Sidecar queue ─────────────────────────────────────────────────────
     sidecarQueue = [];
+    // ── Isolation degradation ────────────────────────────────────────────
+    /** Set to true when worktree creation fails; prevents merge of nonexistent branch. */
+    isolationDegraded = false;
     // ── Dispatch circuit breakers ──────────────────────────────────────
     rewriteAttemptCount = 0;
     // ── Metrics ──────────────────────────────────────────────────────────────
@@ -140,6 +143,7 @@ export class AutoSession {
         this.pendingQuickTasks = [];
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
+        this.isolationDegraded = false;
         // Signal handler
         this.sigtermHandler = null;
         // Loop promise state lives in auto-loop.ts module scope

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

@@ -4,14 +4,13 @@
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
 import { resolveMilestonePath, resolveSlicePath, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
+import { parseUnitId } from "./unit-id.js";
 import { join } from "node:path";
 /**
  * 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];
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
         case "discuss-milestone": {
             const dir = resolveMilestonePath(base, mid);
@@ -39,10 +38,9 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
         }
         case "run-uat": {
             const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "UAT-RESULT")) : null;
+            return dir ? join(dir, buildSliceFileName(sid, "UAT")) : null;
         }
         case "execute-task": {
-            const tid = parts[2];
             const dir = resolveSlicePath(base, mid, sid);
             return dir && tid
                 ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY"))
@@ -66,6 +64,9 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
         }
         case "rewrite-docs":
             return null;
+        case "gate-evaluate":
+            // Gate evaluate writes to DB quality_gates table — verified via state derivation
+            return null;
         case "reactive-execute":
             // Reactive execute produces multiple task summaries — verified separately
             return null;
@@ -74,9 +75,7 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
     }
 }
 export function diagnoseExpectedArtifact(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
         case "discuss-milestone":
             return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
@@ -89,7 +88,6 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
         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`;
         }
         case "complete-slice":
@@ -101,7 +99,7 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
         case "reassess-roadmap":
             return `${relSliceFile(base, mid, sid, "ASSESSMENT")} (roadmap reassessment)`;
         case "run-uat":
-            return `${relSliceFile(base, mid, sid, "UAT-RESULT")} (UAT result)`;
+            return `${relSliceFile(base, mid, sid, "UAT")} (UAT result)`;
         case "validate-milestone":
             return `${relMilestoneFile(base, mid, "VALIDATION")} (milestone validation report)`;
         case "complete-milestone":

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

@@ -18,15 +18,16 @@ import { computeProgressScore } from "./progress-score.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
+import { parseUnitId } from "./unit-id.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
  * Returns null if the format doesn't match.
  */
 export function extractUatSliceId(unitId) {
-    const parts = unitId.split("/");
-    if (parts.length >= 2 && parts[1].startsWith("S"))
-        return parts[1];
+    const { slice } = parseUnitId(unitId);
+    if (slice?.startsWith("S"))
+        return slice;
     return null;
 }
 // ─── Unit Description Helpers ─────────────────────────────────────────────────
@@ -115,6 +116,8 @@ export function describeNextUnit(state) {
             return { label: `Replan ${sid}: ${sTitle}`, description: "Blocker found — replan the slice." };
         case "completing-milestone":
             return { label: "Complete milestone", description: "Write milestone summary." };
+        case "evaluating-gates":
+            return { label: `Evaluate gates for ${sid}: ${sTitle}`, description: "Parallel quality gate assessment before execution." };
         default:
             return { label: "Continue", description: "Execute the next step." };
     }

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

@@ -9,12 +9,13 @@
  * without modifying orchestration code.
  */
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted } from "./gsd-db.js";
+import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 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, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -104,30 +105,15 @@ export const DISPATCH_RULES = [
                 return null;
             }
             for (const sliceId of completedSliceIds) {
-                const resultFile = resolveSliceFile(basePath, mid, sliceId, "UAT-RESULT");
+                const resultFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
                 if (!resultFile)
                     continue;
                 const content = await loadFile(resultFile);
                 if (!content)
                     continue;
-                const verdictMatch = content.match(/verdict:\s*([\w-]+)/i);
-                const verdict = verdictMatch?.[1]?.toLowerCase();
-                // Determine acceptable verdicts based on UAT type.
-                // mixed / human-experience / live-runtime modes may legitimately
-                // produce PARTIAL when all automatable checks pass but human-only
-                // checks remain — this should not block progression.
-                const acceptableVerdicts = ["pass", "passed"];
-                const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
-                if (uatFile) {
-                    const uatContent = await loadFile(uatFile);
-                    if (uatContent) {
-                        const uatType = extractUatType(uatContent);
-                        if (uatType === "mixed" || uatType === "human-experience" || uatType === "live-runtime") {
-                            acceptableVerdicts.push("partial");
-                        }
-                    }
-                }
-                if (verdict && !acceptableVerdicts.includes(verdict)) {
+                const verdict = extractVerdict(content);
+                const uatType = extractUatType(content);
+                if (verdict && !isAcceptableUatVerdict(verdict, uatType)) {
                     return {
                         action: "stop",
                         reason: `UAT verdict for ${sliceId} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
@@ -261,6 +247,32 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        name: "evaluating-gates → gate-evaluate",
+        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+            if (state.phase !== "evaluating-gates")
+                return null;
+            if (!state.activeSlice)
+                return missingSliceStop(mid, state.phase);
+            const sid = state.activeSlice.id;
+            const sTitle = state.activeSlice.title;
+            // Gate evaluation is opt-in via preferences
+            const gateConfig = prefs?.gate_evaluation;
+            if (!gateConfig?.enabled) {
+                markAllGatesOmitted(mid, sid);
+                return { action: "skip" };
+            }
+            const pending = getPendingGates(mid, sid, "slice");
+            if (pending.length === 0)
+                return { action: "skip" };
+            return {
+                action: "dispatch",
+                unitType: "gate-evaluate",
+                unitId: `${mid}/${sid}/gates+${pending.map(g => g.gate_id).join(",")}`,
+                prompt: await buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, basePath),
+            };
+        },
+    },
     {
         name: "replanning-slice → replan-slice",
         match: async ({ state, mid, midTitle, basePath }) => {

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

@@ -15,11 +15,12 @@ import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
+import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
 import { verifyExpectedArtifact, resolveExpectedArtifactPath, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
-import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
+import { syncStateToProjectRoot } from "./auto-worktree.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
@@ -47,13 +48,20 @@ import { _resetHasChangesCache } from "./native-git-bridge.js";
  * in postUnitPostVerification() eventually ingests rogue files, but explicit
  * detection provides immediate diagnostics so operators know the prompt failed.
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function hasNonEmptyFields(row, fields) {
+    if (!row)
+        return false;
+    return fields.some(f => String(row[f] || "").trim().length > 0);
+}
+const MILESTONE_PLANNING_FIELDS = ["title", "vision", "requirement_coverage", "boundary_map_markdown"];
+const SLICE_PLANNING_FIELDS = ["title", "demo", "risk", "depends"];
 export function detectRogueFileWrites(unitType, unitId, basePath) {
     if (!isDbAvailable())
         return [];
-    const parts = unitId.split("/");
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     const rogues = [];
     if (unitType === "execute-task") {
-        const [mid, sid, tid] = parts;
         if (!mid || !sid || !tid)
             return [];
         const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
@@ -65,7 +73,6 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         }
     }
     else if (unitType === "complete-slice") {
-        const [mid, sid] = parts;
         if (!mid || !sid)
             return [];
         const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
@@ -77,33 +84,25 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         }
     }
     else if (unitType === "plan-milestone") {
-        const [mid] = parts;
         if (!mid)
             return [];
         const roadmapPath = resolveMilestoneFile(basePath, mid, "ROADMAP");
         if (!roadmapPath || !existsSync(roadmapPath))
             return [];
         const dbRow = getMilestone(mid);
-        const hasPlanningState = !!dbRow && (String(dbRow.title || "").trim().length > 0 ||
-            String(dbRow.vision || "").trim().length > 0 ||
-            String(dbRow.requirement_coverage || "").trim().length > 0 ||
-            String(dbRow.boundary_map_markdown || "").trim().length > 0);
+        const hasPlanningState = hasNonEmptyFields(dbRow, MILESTONE_PLANNING_FIELDS);
         if (!hasPlanningState) {
             rogues.push({ path: roadmapPath, unitType, unitId });
         }
     }
     else if (unitType === "plan-slice" || unitType === "replan-slice") {
-        const [mid, sid] = parts;
         if (!mid || !sid)
             return [];
         const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
         if (!planPath || !existsSync(planPath))
             return [];
         const dbRow = getSlice(mid, sid);
-        const hasPlanningState = !!dbRow && (String(dbRow.title || "").trim().length > 0 ||
-            String(dbRow.demo || "").trim().length > 0 ||
-            String(dbRow.risk || "").trim().length > 0 ||
-            String(dbRow.depends || "").trim().length > 0);
+        const hasPlanningState = hasNonEmptyFields(dbRow, SLICE_PLANNING_FIELDS);
         if (!hasPlanningState) {
             rogues.push({ path: planPath, unitType, unitId });
         }
@@ -114,7 +113,6 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         }
     }
     else if (unitType === "reassess-roadmap") {
-        const [mid, sid] = parts;
         if (!mid || !sid)
             return [];
         const assessPath = resolveSliceFile(basePath, mid, sid, "ASSESSMENT");
@@ -130,7 +128,6 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         }
     }
     else if (unitType === "plan-task") {
-        const [mid, sid, tid] = parts;
         if (!mid || !sid || !tid)
             return [];
         const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
@@ -180,8 +177,7 @@ export async function postUnitPreVerification(pctx, opts) {
         try {
             let taskContext;
             if (s.currentUnit.type === "execute-task") {
-                const parts = s.currentUnit.id.split("/");
-                const [mid, sid, tid] = parts;
+                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
                 if (mid && sid && tid) {
                     const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
                     if (summaryPath) {
@@ -284,8 +280,7 @@ export async function postUnitPreVerification(pctx, opts) {
         // Reactive state cleanup on slice completion
         if (s.currentUnit.type === "complete-slice") {
             try {
-                const parts = s.currentUnit.id.split("/");
-                const [mid, sid] = parts;
+                const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
                 if (mid && sid) {
                     const { clearReactiveState } = await import("./reactive-graph.js");
                     clearReactiveState(s.basePath, mid, sid);
@@ -356,8 +351,7 @@ export async function postUnitPreVerification(pctx, opts) {
             // from DB data before giving up (e.g. research-slice produces PLAN from engine).
             if (!triggerArtifactVerified) {
                 try {
-                    const parts = s.currentUnit.id.split("/");
-                    const [mid, sid] = parts;
+                    const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
                     if (mid && sid) {
                         const regenerated = regenerateIfMissing(s.basePath, mid, sid, "PLAN");
                         if (regenerated) {
@@ -444,8 +438,7 @@ export async function postUnitPostVerification(pctx) {
                 ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting task state.`, "info");
                 // ── State reset: undo the completion so deriveState re-derives the unit ──
                 try {
-                    const parts = trigger.unitId.split("/");
-                    const [mid, sid, tid] = parts;
+                    const { milestone: mid, slice: sid, task: tid } = parseUnitId(trigger.unitId);
                     // 1. Reset task status in DB and re-render plan checkboxes
                     if (mid && sid && tid) {
                         try {