gsd-pi 2.48.0 → 2.49.0-dev.9e177e9

package/packages/pi-coding-agent/src/modes/rpc/jsonl.ts

@@ -48,11 +48,17 @@ export function attachJsonlLineReader(stream: Readable, onLine: (line: string) =
 		}
 	};
 
+	const onError = (_err: Error) => {
+		// Stream errors are non-fatal for JSONL reading
+	};
+
 	stream.on("data", onData);
 	stream.on("end", onEnd);
+	stream.on("error", onError);
 
 	return () => {
 		stream.off("data", onData);
 		stream.off("end", onEnd);
+		stream.off("error", onError);
 	};
 }

package/packages/pi-coding-agent/src/modes/rpc/rpc-client.ts

@@ -488,8 +488,6 @@ export class RpcClient {
 		const fullCommand = { ...command, id } as RpcCommand;
 
 		return new Promise((resolve, reject) => {
-			this.pendingRequests.set(id, { resolve, reject });
-
 			const timeout = setTimeout(() => {
 				this.pendingRequests.delete(id);
 				reject(new Error(`Timeout waiting for response to ${command.type}. Stderr: ${this.stderr}`));

package/packages/pi-coding-agent/src/modes/rpc/rpc-mode.ts

@@ -710,8 +710,8 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			}
 
 			default: {
-				const unknownCommand = command as { type: string };
-				return error(undefined, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
+				const unknownCommand = command as { type: string; id?: string };
+				return error(unknownCommand.id, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
 			}
 		}
 	};

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.48.0",
+  "version": "2.49.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/github-sync/tests/commit-linking.test.ts

@@ -10,7 +10,8 @@ describe("commit linking", () => {
       issueNumber: 43,
     });
     assert.ok(msg.includes("Resolves #43"), "should include Resolves trailer");
-    assert.ok(msg.startsWith("feat(S01/T02):"), "subject line unchanged");
+    assert.ok(msg.startsWith("feat:"), "subject line has no scope");
+    assert.ok(msg.includes("GSD-Task: S01/T02"), "GSD-Task trailer present");
   });
 
   it("includes both key files and Resolves #N", () => {
@@ -22,10 +23,13 @@ describe("commit linking", () => {
     });
     assert.ok(msg.includes("- src/auth.ts"), "key files present");
     assert.ok(msg.includes("Resolves #43"), "Resolves trailer present");
-    // Resolves should come after key files
+    assert.ok(msg.includes("GSD-Task: S01/T02"), "GSD-Task trailer present");
+    // GSD-Task should come after key files but before Resolves
     const keyFilesIdx = msg.indexOf("- src/auth.ts");
+    const taskIdx = msg.indexOf("GSD-Task: S01/T02");
     const resolvesIdx = msg.indexOf("Resolves #43");
-    assert.ok(resolvesIdx > keyFilesIdx, "Resolves after key files");
+    assert.ok(taskIdx > keyFilesIdx, "GSD-Task after key files");
+    assert.ok(resolvesIdx > taskIdx, "Resolves after GSD-Task");
   });
 
   it("no Resolves trailer when issueNumber is not set", () => {
@@ -34,6 +38,6 @@ describe("commit linking", () => {
       taskTitle: "implement auth",
     });
     assert.ok(!msg.includes("Resolves"), "no Resolves when no issueNumber");
-    assert.ok(!msg.includes("\n"), "no body when no issueNumber or keyFiles");
+    assert.ok(msg.includes("GSD-Task: S01/T02"), "GSD-Task trailer still present");
   });
 });

package/src/resources/extensions/gsd/auto/infra-errors.ts

@@ -18,6 +18,7 @@ export const INFRA_ERROR_CODES: ReadonlySet<string> = 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/src/resources/extensions/gsd/auto/phases.ts

@@ -1039,17 +1039,16 @@ export async function runUnitPhase(
   );
 
   // 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);
       }
     }
@@ -1122,7 +1121,7 @@ export async function runUnitPhase(
     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 } };
 }

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

@@ -8,7 +8,7 @@
  * Imports from: auto/types
  */
 
-import type { UnitResult, AgentEndEvent } from "./types.js";
+import type { UnitResult, AgentEndEvent, ErrorContext } from "./types.js";
 import type { AutoSession } from "./session.js";
 import { debugLog } from "../debug-logger.js";
 
@@ -77,12 +77,12 @@ export function isSessionSwitchInFlight(): boolean {
  * 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(): void {
+export function resolveAgentEndCancelled(errorContext?: ErrorContext): void {
   if (_currentResolve) {
     debugLog("resolveAgentEndCancelled", { status: "resolving-cancelled" });
     const r = _currentResolve;
     _currentResolve = null;
-    r({ status: "cancelled" });
+    r({ status: "cancelled", ...(errorContext ? { errorContext } : {}) });
   }
 }
 

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

@@ -58,13 +58,13 @@ export async function runUnit(
       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) {

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

@@ -118,6 +118,10 @@ export class AutoSession {
   // ── Sidecar queue ─────────────────────────────────────────────────────
   sidecarQueue: SidecarItem[] = [];
 
+  // ── Isolation degradation ────────────────────────────────────────────
+  /** Set to true when worktree creation fails; prevents merge of nonexistent branch. */
+  isolationDegraded = false;
+
   // ── Dispatch circuit breakers ──────────────────────────────────────
   rewriteAttemptCount = 0;
 
@@ -200,6 +204,7 @@ export class AutoSession {
     this.pendingQuickTasks = [];
     this.sidecarQueue = [];
     this.rewriteAttemptCount = 0;
+    this.isolationDegraded = false;
 
     // Signal handler
     this.sigtermHandler = null;

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

@@ -47,12 +47,25 @@ export interface AgentEndEvent {
   messages: unknown[];
 }
 
+/**
+ * Structured error context attached to a UnitResult when the unit ends
+ * due to an infrastructure or timeout error (not user-driven cancellation).
+ */
+export interface ErrorContext {
+  message: string;
+  category: "provider" | "timeout" | "idle" | "network" | "aborted" | "session-failed" | "unknown";
+  stopReason?: string;
+  isTransient?: boolean;
+  retryAfterMs?: number;
+}
+
 /**
  * Result of a single unit execution (one iteration of the loop).
  */
 export interface UnitResult {
   status: "completed" | "cancelled" | "error";
   event?: AgentEndEvent;
+  errorContext?: ErrorContext;
 }
 
 // ─── Phase pipeline types ────────────────────────────────────────────────────

package/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -13,6 +13,7 @@ import {
   buildSliceFileName,
   buildTaskFileName,
 } from "./paths.js";
+import { parseUnitId } from "./unit-id.js";
 import { join } from "node:path";
 
 /**
@@ -23,9 +24,7 @@ export function resolveExpectedArtifactPath(
   unitId: string,
   base: string,
 ): string | null {
-  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);
@@ -53,10 +52,9 @@ export function resolveExpectedArtifactPath(
     }
     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"))
@@ -80,6 +78,9 @@ export function resolveExpectedArtifactPath(
     }
     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;
@@ -93,38 +94,35 @@ export function diagnoseExpectedArtifact(
   unitId: string,
   base: string,
 ): string | null {
-  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)`;
+      return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
     case "research-milestone":
-      return `${relMilestoneFile(base, mid!, "RESEARCH")} (milestone research)`;
+      return `${relMilestoneFile(base, mid, "RESEARCH")} (milestone research)`;
     case "plan-milestone":
-      return `${relMilestoneFile(base, mid!, "ROADMAP")} (milestone roadmap)`;
+      return `${relMilestoneFile(base, mid, "ROADMAP")} (milestone roadmap)`;
     case "research-slice":
-      return `${relSliceFile(base, mid!, sid!, "RESEARCH")} (slice research)`;
+      return `${relSliceFile(base, mid, sid!, "RESEARCH")} (slice research)`;
     case "plan-slice":
-      return `${relSliceFile(base, mid!, sid!, "PLAN")} (slice plan)`;
+      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`;
+      return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid!, "PLAN")} + summary written`;
     }
     case "complete-slice":
-      return `Slice ${sid} marked [x] in ${relMilestoneFile(base, mid!, "ROADMAP")} + summary + UAT written`;
+      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")}`;
+      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)`;
+      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)`;
+      return `${relMilestoneFile(base, mid, "VALIDATION")} (milestone validation report)`;
     case "complete-milestone":
-      return `${relMilestoneFile(base, mid!, "SUMMARY")} (milestone summary)`;
+      return `${relMilestoneFile(base, mid, "SUMMARY")} (milestone summary)`;
     default:
       return null;
   }

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

@@ -25,6 +25,7 @@ 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 ─────────────────────────────────────────────────────
 
@@ -33,8 +34,8 @@ import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.
  * Returns null if the format doesn't match.
  */
 export function extractUatSliceId(unitId: string): string | null {
-  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;
 }
 
@@ -151,6 +152,8 @@ export function describeNextUnit(state: GSDState): { label: string; description:
       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/src/resources/extensions/gsd/auto-dispatch.ts

@@ -13,7 +13,8 @@ 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 } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted } from "./gsd-db.js";
+import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 
 import {
   resolveMilestoneFile,
@@ -43,6 +44,7 @@ import {
   buildReassessRoadmapPrompt,
   buildRewriteDocsPrompt,
   buildReactiveExecutePrompt,
+  buildGateEvaluatePrompt,
   checkNeedsReassessment,
   checkNeedsRunUat,
 } from "./auto-prompts.js";
@@ -184,13 +186,14 @@ export const DISPATCH_RULES: DispatchRule[] = [
       }
 
       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();
-        if (verdict && verdict !== "pass" && verdict !== "passed") {
+        const verdict = extractVerdict(content);
+        const uatType = extractUatType(content);
+
+        if (verdict && !isAcceptableUatVerdict(verdict, uatType)) {
           return {
             action: "stop" as const,
             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.`,
@@ -331,6 +334,38 @@ export const DISPATCH_RULES: DispatchRule[] = [
       };
     },
   },
+  {
+    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/src/resources/extensions/gsd/auto-loop.ts

@@ -13,4 +13,4 @@ export { resolveAgentEnd, resolveAgentEndCancelled, isSessionSwitchInFlight, _re
 export { detectStuck } from "./auto/detect-stuck.js";
 export { runUnit } from "./auto/run-unit.js";
 export type { LoopDeps } from "./auto/loop-deps.js";
-export type { AgentEndEvent, UnitResult } from "./auto/types.js";
+export type { AgentEndEvent, ErrorContext, UnitResult } from "./auto/types.js";

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

@@ -23,6 +23,7 @@ import {
   buildTaskFileName,
 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
+import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit, type CloseoutOptions } from "./auto-unit-closeout.js";
 import {
   autoCommitCurrentBranch,
@@ -33,7 +34,7 @@ import {
   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,6 +48,16 @@ import {
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 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()`. */
+const LIFECYCLE_ONLY_UNITS = new Set([
+  "research-milestone", "discuss-milestone", "plan-milestone",
+  "validate-milestone", "research-slice", "plan-slice",
+  "replan-slice", "complete-slice", "run-uat",
+  "reassess-roadmap", "rewrite-docs",
+]);
 import {
   updateProgressWidget as _updateProgressWidget,
   updateSliceProgressCache,
@@ -74,6 +85,15 @@ export interface RogueFileWrite {
  * 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: Record<string, any> | null, fields: string[]): boolean {
+  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: string,
   unitId: string,
@@ -81,11 +101,10 @@ export function detectRogueFileWrites(
 ): RogueFileWrite[] {
   if (!isDbAvailable()) return [];
 
-  const parts = unitId.split("/");
+  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
   const rogues: RogueFileWrite[] = [];
 
   if (unitType === "execute-task") {
-    const [mid, sid, tid] = parts;
     if (!mid || !sid || !tid) return [];
 
     const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
@@ -96,7 +115,6 @@ export function detectRogueFileWrites(
       rogues.push({ path: summaryPath, unitType, unitId });
     }
   } else if (unitType === "complete-slice") {
-    const [mid, sid] = parts;
     if (!mid || !sid) return [];
 
     const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
@@ -107,37 +125,25 @@ export function detectRogueFileWrites(
       rogues.push({ path: summaryPath, unitType, unitId });
     }
   } 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 });
@@ -149,7 +155,6 @@ export function detectRogueFileWrites(
       rogues.push({ path: replanPath, unitType, unitId });
     }
   } else if (unitType === "reassess-roadmap") {
-    const [mid, sid] = parts;
     if (!mid || !sid) return [];
 
     const assessPath = resolveSliceFile(basePath, mid, sid, "ASSESSMENT");
@@ -166,7 +171,6 @@ export function detectRogueFileWrites(
       }
     }
   } else if (unitType === "plan-task") {
-    const [mid, sid, tid] = parts;
     if (!mid || !sid || !tid) return [];
 
     const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
@@ -239,8 +243,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       let taskContext: TaskCommitContext | undefined;
 
       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) {
@@ -279,9 +282,14 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       // `git worktree remove --force` during teardown.
       _resetHasChangesCache();
 
-      const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
-      if (commitMsg) {
-        ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+      // Skip auto-commit for lifecycle-only units (#2553) — they only touch
+      // `.gsd/` internal state files. Those files are picked up by the next
+      // actual task commit via smartStage().
+      if (!LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type)) {
+        const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
+        if (commitMsg) {
+          ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+        }
       }
     } catch (e) {
       debugLog("postUnit", { phase: "auto-commit", error: String(e) });
@@ -339,8 +347,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
     // 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);
@@ -425,8 +432,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       // 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) {
@@ -526,8 +532,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
 
         // ── 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) {