gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.0150ae9

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

@@ -4,12 +4,14 @@
  * for the agent to fix gaps before proceeding with the unit.
  */
 import { validatePlanBoundary, validateExecuteBoundary, validateCompleteBoundary, formatValidationIssues, } from "./observability-validator.js";
-import { parseUnitId } from "./unit-id.js";
 export async function collectObservabilityWarnings(ctx, basePath, unitType, unitId) {
     // Hook units have custom artifacts — skip standard observability checks
     if (unitType.startsWith("hook/"))
         return [];
-    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)
         return [];
     let issues = [];

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

@@ -17,38 +17,19 @@ import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, } from "./path
 import { invalidateAllCaches } from "./cache.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
-import { verifyExpectedArtifact, persistCompletedKey, removePersistedKey, } from "./auto-recovery.js";
+import { verifyExpectedArtifact, } from "./auto-recovery.js";
 import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.js";
-import { resolveAutoSupervisorConfig } from "./preferences.js";
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
-import { COMPLETION_TRANSITION_CODES } from "./doctor-types.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
+import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
 import { resetRewriteCircuitBreaker } from "./auto-dispatch.js";
 import { isDbAvailable } from "./gsd-db.js";
 import { consumeSignal } from "./session-status-io.js";
-import { checkPostUnitHooks, getActiveHook, resetHookState, isRetryPending, consumeRetryTrigger, persistHookState, } from "./post-unit-hooks.js";
+import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
-import { writeLock } from "./crash-recovery.js";
-import { STATE_REBUILD_MIN_INTERVAL_MS } from "./auto-constants.js";
-import { parseUnitId } from "./unit-id.js";
-/**
- * Initialize a unit dispatch: stamp the current time, set `s.currentUnit`,
- * and persist the initial runtime record. Returns `startedAt` for callers
- * that need the timestamp.
- */
-function dispatchUnit(s, basePath, unitType, unitId) {
-    const startedAt = Date.now();
-    s.currentUnit = { type: unitType, id: unitId, startedAt };
-    writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, {
-        phase: "dispatched",
-        wrapupWarningSent: false,
-        timeoutAt: null,
-        lastProgressAt: startedAt,
-        progressCount: 0,
-        lastProgressKind: "dispatch",
-    });
-    return startedAt;
-}
+import { debugLog } from "./debug-logger.js";
+/** Throttle STATE.md rebuilds — at most once per 30 seconds */
+const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -81,7 +62,8 @@ export async function postUnitPreVerification(pctx) {
         try {
             let taskContext;
             if (s.currentUnit.type === "execute-task") {
-                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
+                const parts = s.currentUnit.id.split("/");
+                const [mid, sid, tid] = parts;
                 if (mid && sid && tid) {
                     const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
                     if (summaryPath) {
@@ -113,24 +95,20 @@ export async function postUnitPreVerification(pctx) {
         }
         // Doctor: fix mechanical bookkeeping
         try {
-            const { milestone, slice } = parseUnitId(s.currentUnit.id);
-            const doctorScope = slice ? `${milestone}/${slice}` : milestone;
+            const scopeParts = s.currentUnit.id.split("/").slice(0, 2);
+            const doctorScope = scopeParts.join("/");
             const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
             const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" : "task";
             const report = await runGSDDoctor(s.basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
             if (report.fixesApplied.length > 0) {
                 ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
             }
-            // Proactive health tracking — exclude completion-transition codes at task level
-            // since they are expected after the last task and resolved by complete-slice
-            const issuesForHealth = effectiveFixLevel === "task"
-                ? report.issues.filter(i => !COMPLETION_TRANSITION_CODES.has(i.code))
-                : report.issues;
-            const summary = summarizeDoctorIssues(issuesForHealth);
+            // Proactive health tracking
+            const summary = summarizeDoctorIssues(report.issues);
             recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
             // Check if we should escalate to LLM-assisted heal
             if (summary.errors > 0) {
-                const unresolvedErrors = issuesForHealth
+                const unresolvedErrors = report.issues
                     .filter(i => i.severity === "error" && !i.fixable)
                     .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
                 const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
@@ -165,17 +143,23 @@ export async function postUnitPreVerification(pctx) {
                 // Non-fatal
             }
         }
-        // Prune dead bg-shell processes and kill non-persistent live ones.
-        // Without killing live processes between units, dev servers spawned during
-        // one task keep ports bound, causing conflicts in subsequent tasks (#1209).
+        // Prune dead bg-shell processes
         try {
-            const { pruneDeadProcesses, killSessionProcesses } = await import("../bg-shell/process-manager.js");
+            const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
             pruneDeadProcesses();
-            killSessionProcesses();
         }
         catch {
             // Non-fatal
         }
+        // Sync worktree state back to project root
+        if (s.originalBasePath && s.originalBasePath !== s.basePath) {
+            try {
+                syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
+            }
+            catch {
+                // Non-fatal
+            }
+        }
         // Rewrite-docs completion
         if (s.currentUnit.type === "rewrite-docs") {
             try {
@@ -217,17 +201,12 @@ export async function postUnitPreVerification(pctx) {
                 process.stderr.write(`gsd-triage: resolution execution failed: ${err.message}\n`);
             }
         }
-        // Artifact verification and completion persistence
+        // Artifact verification
         let triggerArtifactVerified = false;
         if (!s.currentUnit.type.startsWith("hook/")) {
             try {
                 triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
                 if (triggerArtifactVerified) {
-                    const completionKey = `${s.currentUnit.type}/${s.currentUnit.id}`;
-                    if (!s.completedKeySet.has(completionKey)) {
-                        persistCompletedKey(s.basePath, completionKey);
-                        s.completedKeySet.add(completionKey);
-                    }
                     invalidateAllCaches();
                 }
             }
@@ -256,9 +235,11 @@ export async function postUnitPreVerification(pctx) {
  * Post-verification processing: DB dual-write, post-unit hooks, triage
  * capture dispatch, quick-task dispatch.
  *
+ * Sidecar work (hooks, triage, quick-tasks) is enqueued on `s.sidecarQueue`
+ * for the main loop to drain via `runUnit()`.
+ *
  * Returns:
- * - "dispatched" — a hook/triage/quick-task was dispatched (sendMessage sent)
- * - "continue" — proceed to normal dispatchNextUnit
+ * - "continue" — proceed to sidecar drain / normal dispatch
  * - "step-wizard" — step mode, show wizard instead
  * - "stopped" — stopAuto was called
  */
@@ -274,44 +255,6 @@ export async function postUnitPostVerification(pctx) {
             process.stderr.write(`gsd-db: re-import failed: ${err.message}\n`);
         }
     }
-    // ── Mechanical completion (ADR-003) ──
-    // After task execution, attempt mechanical slice and milestone completion
-    // instead of dispatching LLM sessions for complete-slice / validate-milestone.
-    if (s.currentUnit?.type === "execute-task" && !s.stepMode) {
-        try {
-            const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
-            if (mid && sid) {
-                const state = await deriveState(s.basePath);
-                if (state.phase === "summarizing" && state.activeSlice?.id === sid) {
-                    const { mechanicalSliceCompletion } = await import("./mechanical-completion.js");
-                    const ok = await mechanicalSliceCompletion(s.basePath, mid, sid);
-                    if (ok) {
-                        invalidateAllCaches();
-                        autoCommitCurrentBranch(s.basePath, "mechanical-completion", `${mid}/${sid}`);
-                        ctx.ui.notify(`Mechanical completion: ${sid} summary + roadmap updated.`, "info");
-                        // Re-derive state — check if milestone is now ready for validation
-                        invalidateAllCaches();
-                        const postSliceState = await deriveState(s.basePath);
-                        if (postSliceState.phase === "validating-milestone" || postSliceState.phase === "completing-milestone") {
-                            const { aggregateMilestoneVerification, generateMilestoneSummary } = await import("./mechanical-completion.js");
-                            const validation = await aggregateMilestoneVerification(s.basePath, mid);
-                            if (validation.verdict !== "failed") {
-                                await generateMilestoneSummary(s.basePath, mid);
-                                invalidateAllCaches();
-                                autoCommitCurrentBranch(s.basePath, "mechanical-milestone-completion", mid);
-                                ctx.ui.notify(`Mechanical completion: ${mid} validation + summary written.`, "info");
-                            }
-                        }
-                    }
-                    // If !ok, summarizing phase persists → dispatch rule fires as LLM fallback
-                }
-            }
-        }
-        catch (err) {
-            process.stderr.write(`gsd-mechanical: completion failed: ${err.message}\n`);
-            // Non-fatal — fall through to normal dispatch
-        }
-    }
     // ── Post-unit hooks ──
     if (s.currentUnit && !s.stepMode) {
         const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
@@ -319,62 +262,29 @@ export async function postUnitPostVerification(pctx) {
             if (s.currentUnit) {
                 await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
             }
-            dispatchUnit(s, s.basePath, hookUnit.unitType, hookUnit.unitId);
-            const state = await deriveState(s.basePath);
-            updateProgressWidget(ctx, hookUnit.unitType, hookUnit.unitId, state);
-            const hookState = getActiveHook();
-            ctx.ui.notify(`Running post-unit hook: ${hookUnit.hookName} (cycle ${hookState?.cycle ?? 1})`, "info");
-            // Switch model if the hook specifies one
-            if (hookUnit.model) {
-                const availableModels = ctx.modelRegistry.getAvailable();
-                const match = availableModels.find(m => m.id === hookUnit.model || `${m.provider}/${m.id}` === hookUnit.model);
-                if (match) {
-                    try {
-                        await pi.setModel(match);
-                    }
-                    catch { /* non-fatal */ }
-                }
-            }
-            const result = await s.cmdCtx.newSession();
-            if (result.cancelled) {
-                resetHookState();
-                await stopAuto(ctx, pi, "Hook session cancelled");
-                return "stopped";
-            }
-            const sessionFile = ctx.sessionManager.getSessionFile();
-            writeLock(lockBase(), hookUnit.unitType, hookUnit.unitId, s.completedUnits.length, sessionFile);
             persistHookState(s.basePath);
-            // Start supervision timers for hook units
-            const supervisor = resolveAutoSupervisorConfig();
-            const hookHardTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
-            s.unitTimeoutHandle = setTimeout(async () => {
-                s.unitTimeoutHandle = null;
-                if (!s.active)
-                    return;
-                if (s.currentUnit) {
-                    writeUnitRuntimeRecord(s.basePath, hookUnit.unitType, hookUnit.unitId, s.currentUnit.startedAt, {
-                        phase: "timeout",
-                        timeoutAt: Date.now(),
-                    });
-                }
-                ctx.ui.notify(`Hook ${hookUnit.hookName} exceeded ${supervisor.hard_timeout_minutes ?? 30}min timeout. Pausing auto-mode.`, "warning");
-                resetHookState();
-                await pauseAuto(ctx, pi);
-            }, hookHardTimeoutMs);
-            if (!s.active)
-                return "stopped";
-            pi.sendMessage({ customType: "gsd-auto", content: hookUnit.prompt, display: s.verbose }, { triggerTurn: true });
-            return "dispatched";
+            s.sidecarQueue.push({
+                kind: "hook",
+                unitType: hookUnit.unitType,
+                unitId: hookUnit.unitId,
+                prompt: hookUnit.prompt,
+                model: hookUnit.model,
+            });
+            debugLog("postUnitPostVerification", {
+                phase: "sidecar-enqueue",
+                kind: "hook",
+                unitType: hookUnit.unitType,
+                unitId: hookUnit.unitId,
+                hookName: hookUnit.hookName,
+            });
+            return "continue";
         }
         // Check if a hook requested a retry of the trigger unit
         if (isRetryPending()) {
             const trigger = consumeRetryTrigger();
             if (trigger) {
-                const triggerKey = `${trigger.unitType}/${trigger.unitId}`;
-                s.completedKeySet.delete(triggerKey);
-                removePersistedKey(s.basePath, triggerKey);
                 ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId}.`, "info");
-                // Fall through to normal dispatch
+                // Fall through to normal dispatch — deriveState will re-derive the unit
             }
         }
     }
@@ -406,34 +316,24 @@ export async function postUnitPostVerification(pctx) {
                             currentPlan: currentPlan || "(no active slice plan)",
                             roadmapContext: roadmapContext || "(no active roadmap)",
                         });
-                        ctx.ui.notify(`Triaging ${pending.length} pending capture${pending.length === 1 ? "" : "s"}...`, "info");
                         if (s.currentUnit) {
                             await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
                         }
-                        const triageUnitType = "triage-captures";
                         const triageUnitId = `${mid}/${sid}/triage`;
-                        dispatchUnit(s, s.basePath, triageUnitType, triageUnitId);
-                        updateProgressWidget(ctx, triageUnitType, triageUnitId, state);
-                        const result = await s.cmdCtx.newSession();
-                        if (result.cancelled) {
-                            await stopAuto(ctx, pi);
-                            return "stopped";
-                        }
-                        const sessionFile = ctx.sessionManager.getSessionFile();
-                        writeLock(lockBase(), triageUnitType, triageUnitId, s.completedUnits.length, sessionFile);
-                        const supervisor = resolveAutoSupervisorConfig();
-                        const triageTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
-                        s.unitTimeoutHandle = setTimeout(async () => {
-                            s.unitTimeoutHandle = null;
-                            if (!s.active)
-                                return;
-                            ctx.ui.notify(`Triage unit exceeded timeout. Pausing auto-mode.`, "warning");
-                            await pauseAuto(ctx, pi);
-                        }, triageTimeoutMs);
-                        if (!s.active)
-                            return "stopped";
-                        pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
-                        return "dispatched";
+                        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";
                     }
                 }
             }
@@ -452,36 +352,26 @@ export async function postUnitPostVerification(pctx) {
             const { buildQuickTaskPrompt } = await import("./triage-resolution.js");
             const { markCaptureExecuted } = await import("./captures.js");
             const prompt = buildQuickTaskPrompt(capture);
-            ctx.ui.notify(`Executing quick-task: ${capture.id} — "${capture.text}"`, "info");
             if (s.currentUnit) {
                 await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
             }
-            const qtUnitType = "quick-task";
-            const qtUnitId = `${s.currentMilestoneId}/${capture.id}`;
-            dispatchUnit(s, s.basePath, qtUnitType, qtUnitId);
-            const state = await deriveState(s.basePath);
-            updateProgressWidget(ctx, qtUnitType, qtUnitId, state);
-            const result = await s.cmdCtx.newSession();
-            if (result.cancelled) {
-                await stopAuto(ctx, pi);
-                return "stopped";
-            }
-            const sessionFile = ctx.sessionManager.getSessionFile();
-            writeLock(lockBase(), qtUnitType, qtUnitId, s.completedUnits.length, sessionFile);
             markCaptureExecuted(s.basePath, capture.id);
-            const supervisor = resolveAutoSupervisorConfig();
-            const qtTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
-            s.unitTimeoutHandle = setTimeout(async () => {
-                s.unitTimeoutHandle = null;
-                if (!s.active)
-                    return;
-                ctx.ui.notify(`Quick-task ${capture.id} exceeded timeout. Pausing auto-mode.`, "warning");
-                await pauseAuto(ctx, pi);
-            }, qtTimeoutMs);
-            if (!s.active)
-                return "stopped";
-            pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
-            return "dispatched";
+            const qtUnitId = `${s.currentMilestoneId}/${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 {
             // Non-fatal — proceed to normal dispatch