gsd-pi 2.38.0-dev.96dc7fb → 2.38.0-dev.98b44dc

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

@@ -22,7 +22,6 @@ import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.j
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.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, isRetryPending, consumeRetryTrigger, persistHookState, } from "./post-unit-hooks.js";
@@ -36,7 +35,7 @@ const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
  *
  * Returns "dispatched" if a signal caused stop/pause, "continue" to proceed.
  */
-export async function postUnitPreVerification(pctx) {
+export async function postUnitPreVerification(pctx, opts) {
     const { s, ctx, pi, buildSnapshotOpts, stopAuto, pauseAuto } = pctx;
     // ── Parallel worker signal check ──
     const milestoneLock = process.env.GSD_MILESTONE_LOCK;
@@ -55,8 +54,10 @@ export async function postUnitPreVerification(pctx) {
     }
     // Invalidate all caches
     invalidateAllCaches();
-    // Small delay to let files settle
-    await new Promise(r => setTimeout(r, 500));
+    // Small delay to let files settle (skipped for sidecars where latency matters more)
+    if (!opts?.skipSettleDelay) {
+        await new Promise(r => setTimeout(r, 100));
+    }
     // Auto-commit
     if (s.currentUnit) {
         try {
@@ -71,16 +72,26 @@ export async function postUnitPreVerification(pctx) {
                             const summaryContent = await loadFile(summaryPath);
                             if (summaryContent) {
                                 const summary = parseSummary(summaryContent);
+                                // Look up GitHub issue number for commit linking
+                                let ghIssueNumber;
+                                try {
+                                    const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                                    ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
+                                }
+                                catch {
+                                    // GitHub sync not available — skip
+                                }
                                 taskContext = {
                                     taskId: `${sid}/${tid}`,
                                     taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
                                     oneLiner: summary.oneLiner || undefined,
                                     keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                                    issueNumber: ghIssueNumber,
                                 };
                             }
                         }
-                        catch {
-                            // Non-fatal
+                        catch (e) {
+                            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
                         }
                     }
                 }
@@ -90,57 +101,75 @@ export async function postUnitPreVerification(pctx) {
                 ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
             }
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "auto-commit", error: String(e) });
         }
-        // Doctor: fix mechanical bookkeeping
+        // GitHub sync (non-blocking, opt-in)
         try {
-            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
-            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 = 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);
-                if (escalation.shouldEscalate) {
-                    ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
-                    try {
-                        const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
-                        const { dispatchDoctorHeal } = await import("./commands-handlers.js");
-                        const actionable = report.issues.filter(i => i.severity === "error");
-                        const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
-                        const structuredIssues = formatDoctorIssuesForPrompt(actionable);
-                        dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
-                    }
-                    catch {
-                        // Non-fatal
-                    }
-                }
-            }
+            const { runGitHubSync } = await import("../github-sync/sync.js");
+            await runGitHubSync(s.basePath, s.currentUnit.type, s.currentUnit.id);
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "github-sync", error: String(e) });
         }
-        // Throttled STATE.md rebuild
-        const now = Date.now();
-        if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
+        // Doctor: fix mechanical bookkeeping (skipped for lightweight sidecars)
+        if (!opts?.skipDoctor)
             try {
-                await rebuildState(s.basePath);
-                s.lastStateRebuildAt = now;
-                autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
+                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 — filter to current milestone to avoid
+                // cross-milestone stale errors inflating the escalation counter
+                const currentMilestoneId = s.currentUnit.id.split("/")[0];
+                const milestoneIssues = currentMilestoneId
+                    ? report.issues.filter(i => i.unitId === currentMilestoneId ||
+                        i.unitId.startsWith(`${currentMilestoneId}/`))
+                    : report.issues;
+                const summary = summarizeDoctorIssues(milestoneIssues);
+                recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
+                // Check if we should escalate to LLM-assisted heal
+                if (summary.errors > 0) {
+                    const unresolvedErrors = milestoneIssues
+                        .filter(i => i.severity === "error" && !i.fixable)
+                        .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
+                    const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
+                    if (escalation.shouldEscalate) {
+                        ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
+                        try {
+                            const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
+                            const { dispatchDoctorHeal } = await import("./commands-handlers.js");
+                            const actionable = report.issues.filter(i => i.severity === "error");
+                            const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
+                            const structuredIssues = formatDoctorIssuesForPrompt(actionable);
+                            dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
+                            return "dispatched";
+                        }
+                        catch (e) {
+                            debugLog("postUnit", { phase: "doctor-heal-dispatch", error: String(e) });
+                        }
+                    }
+                }
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "doctor", error: String(e) });
+            }
+        // Throttled STATE.md rebuild (skipped for lightweight sidecars)
+        if (!opts?.skipStateRebuild) {
+            const now = Date.now();
+            if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
+                try {
+                    await rebuildState(s.basePath);
+                    s.lastStateRebuildAt = now;
+                    autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
+                }
+                catch (e) {
+                    debugLog("postUnit", { phase: "state-rebuild", error: String(e) });
+                }
             }
         }
         // Prune dead bg-shell processes
@@ -148,27 +177,27 @@ export async function postUnitPreVerification(pctx) {
             const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
             pruneDeadProcesses();
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "prune-bg-shell", error: String(e) });
         }
-        // Sync worktree state back to project root
-        if (s.originalBasePath && s.originalBasePath !== s.basePath) {
+        // Sync worktree state back to project root (skipped for lightweight sidecars)
+        if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
             try {
                 syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "worktree-sync", error: String(e) });
             }
         }
         // Rewrite-docs completion
         if (s.currentUnit.type === "rewrite-docs") {
             try {
                 await resolveAllOverrides(s.basePath);
-                resetRewriteCircuitBreaker();
+                s.rewriteAttemptCount = 0;
                 ctx.ui.notify("Override(s) resolved — rewrite-docs completed.", "info");
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "rewrite-docs-resolve", error: String(e) });
             }
         }
         // Reactive state cleanup on slice completion
@@ -181,8 +210,8 @@ export async function postUnitPreVerification(pctx) {
                     clearReactiveState(s.basePath, mid, sid);
                 }
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "reactive-state-cleanup", error: String(e) });
             }
         }
         // Post-triage: execute actionable resolutions
@@ -224,8 +253,8 @@ export async function postUnitPreVerification(pctx) {
                     invalidateAllCaches();
                 }
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "artifact-verify", error: String(e) });
             }
         }
         else {
@@ -238,8 +267,8 @@ export async function postUnitPreVerification(pctx) {
                 });
                 clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "hook-finalize", error: String(e) });
             }
         }
     }
@@ -352,8 +381,8 @@ export async function postUnitPostVerification(pctx) {
                 }
             }
         }
-        catch {
-            // Triage check failure is non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "triage-check", error: String(e) });
         }
     }
     // ── Quick-task dispatch ──
@@ -387,8 +416,8 @@ export async function postUnitPostVerification(pctx) {
             ctx.ui.notify(`Executing quick-task: ${capture.id} — "${capture.text}"`, "info");
             return "continue";
         }
-        catch {
-            // Non-fatal — proceed to normal dispatch
+        catch (e) {
+            debugLog("postUnit", { phase: "quick-task-dispatch", error: String(e) });
         }
     }
     // Step mode → show wizard instead of dispatch