@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.844675c9

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

@@ -30,11 +30,11 @@ import { playNotificationBell, sendDesktopNotification } from "./notifications.j
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, } from "./auto-budget.js";
 import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, isDeterministicPolicyError, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
-import { selectAndApplyModel, resolveModelId, clearToolBaseline, getToolBaselineSnapshot } from "./auto-model-selection.js";
+import { selectAndApplyModel, resolveModelId, clearToolBaseline } from "./auto-model-selection.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
 import { resetHookState, runPreDispatchHooks, restoreHookState, clearPersistedHookState, } from "./post-unit-hooks.js";
 import { runGSDDoctor, rebuildState } from "./doctor.js";
-import { preDispatchHealthGate, recordHealthSnapshot, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
+import { preDispatchHealthGate, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
 import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getInstalledSkillNames } from "./skills.js";
@@ -48,7 +48,7 @@ import { isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
-import { captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, resolveProjectRoot, } from "./worktree.js";
+import { captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
@@ -66,7 +66,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, setAutoActiveStatus, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
-import { isDbAvailable, getMilestone, getMilestoneSlices, getSlice, getTask, refreshOpenDatabaseFromDisk, } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getMilestoneSlices, } from "./gsd-db.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { countPendingCaptures } from "./captures.js";
@@ -94,13 +94,7 @@ import { runAutoLoopWithUok } from "./uok/kernel.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { validateDirectory } from "./validate-directory.js";
 import { createAutoOrchestrator } from "./auto/orchestrator.js";
-import { reconcileBeforeDispatch } from "./state-reconciliation.js";
-import { compileUnitToolContract } from "./tool-contract.js";
-import { createWorktreeSafetyModule } from "./worktree-safety.js";
-import { repairAutoWorktreeSafetyFailure, resolvePausedAutoWorktreePath, } from "./auto-worktree-repair.js";
-import { resolveManifest } from "./unit-context-manifest.js";
-import { classifyFailure } from "./recovery-classification.js";
-import { supportsStructuredQuestions } from "./workflow-mcp.js";
+import { resolvePausedAutoWorktreePath, } from "./auto-worktree-repair.js";
 import { WorktreeLifecycle, } from "./worktree-lifecycle.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { reorderForCaching } from "./prompt-ordering.js";
@@ -350,6 +344,15 @@ export function startAutoDetached(ctx, pi, base, verboseMode, options) {
 export function shouldUseWorktreeIsolation(basePath) {
     return getIsolationMode(basePath) === "worktree";
 }
+function resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded) {
+    return configuredMode === "worktree" && isolationDegraded ? "branch" : configuredMode;
+}
+export function _resolveEffectiveUnitIsolationModeForTest(configuredMode, isolationDegraded) {
+    return resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded);
+}
+function getEffectiveUnitIsolationMode(basePath) {
+    return resolveEffectiveUnitIsolationMode(getIsolationMode(basePath), s.isolationDegraded);
+}
 /** Crash recovery prompt — set by startAuto, consumed by the main loop */
 /** Pending verification retry — set when gate fails with retries remaining, consumed by autoLoop */
 /** Verification retry count per unitId — separate from s.unitDispatchCount which tracks artifact-missing retries */
@@ -730,6 +733,38 @@ function setLifecycleOutcome(ctx, input) {
         startedAt: s.autoStartTime,
     });
 }
+const TERMINAL_CLOSEOUT_COMMANDS = [
+    "/gsd status for overview",
+    "/gsd visualize to inspect",
+    "/gsd notifications for history",
+    "/gsd start for new work",
+];
+function setTerminalCloseoutOutcome(ctx, input) {
+    if (!ctx?.hasUI)
+        return;
+    const milestoneLabel = input.milestoneId ? `Milestone ${input.milestoneId}` : "Milestone";
+    const title = input.allMilestonesComplete ? "All milestones complete" : `${milestoneLabel} complete`;
+    const titleLine = input.milestoneTitle && input.milestoneId
+        ? `${input.milestoneTitle}. `
+        : "";
+    const nextAction = input.allMilestonesComplete
+        ? "Review the closeout, then start new work when ready."
+        : "Review the closeout, then start the next milestone when ready.";
+    ctx.ui.setHeader?.(() => ({
+        render() { return []; },
+        invalidate() { },
+    }));
+    ctx.ui.setStatus?.("gsd-step", undefined);
+    ctx.ui.setWidget?.("gsd-progress", undefined);
+    setLifecycleOutcome(ctx, {
+        status: "complete",
+        title,
+        detail: `${titleLine}${input.reason ?? "Milestone closeout finished."}`,
+        nextAction,
+        commands: TERMINAL_CLOSEOUT_COMMANDS,
+        unitLabel: input.milestoneId ? `complete-milestone ${input.milestoneId}` : null,
+    });
+}
 function handleLostSessionLock(ctx, lockStatus) {
     debugLog("session-lock-lost", {
         lockBase: lockBase(),
@@ -849,7 +884,6 @@ export async function cleanupAfterLoopExit(ctx) {
     if (!s.paused) {
         if (preserveCompletionSurface) {
             ctx.ui.setStatus("gsd-auto", undefined);
-            s.completionStopInProgress = false;
             if (preserveStepSurface) {
                 s.preserveStepSurfaceAfterLoopExit = false;
             }
@@ -961,6 +995,7 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     const completionStopRequested = Boolean(options.completionWidget);
     const preserveCloseoutTranscript = !isHeadlessStop && (options.preserveCloseoutTranscript ?? completionStopRequested);
     const installCompletionWidget = completionStopRequested && !preserveCloseoutTranscript;
+    const installTerminalCloseoutOutcome = completionStopRequested && preserveCloseoutTranscript;
     const preserveCompletionSurface = completionStopRequested || preserveCloseoutTranscript;
     s.completionStopInProgress = preserveCompletionSurface;
     playNotificationBell("stop", loadedPreferences?.notifications);
@@ -1270,6 +1305,14 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
                 ctx.ui.notify(`${stopNotificationPrefix}.`, "info");
             }
         }
+        if (installTerminalCloseoutOutcome && ctx && options.completionWidget) {
+            setTerminalCloseoutOutcome(ctx, {
+                milestoneId: completionMilestoneId,
+                milestoneTitle: options.completionWidget.milestoneTitle ?? null,
+                allMilestonesComplete: options.completionWidget.allMilestonesComplete,
+                reason: reason ?? "Milestone closeout finished.",
+            });
+        }
         // ── Step 9: Cmux sidebar / event log ──
         try {
             pi?.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "clear", preferences: loadedPreferences });
@@ -1593,457 +1636,6 @@ export function buildWorktreeLifecycleDeps() {
 function buildLifecycle() {
     return new WorktreeLifecycle(s, buildWorktreeLifecycleDeps());
 }
-/**
- * Build the production `DispatchAdapter` used by `createWiredAutoOrchestrationModule`.
- *
- * Exported so tests can verify parity with `runDispatch`'s `resolveDispatch` call —
- * the wired adapter must derive `structuredQuestionsAvailable`, `sessionContextWindow`,
- * `sessionProvider`, and `modelRegistry` the same way phases.ts:runDispatch does.
- */
-export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
-    function getAlreadyClosedDispatchReason(unitType, unitId) {
-        if (!isDbAvailable())
-            return null;
-        refreshOpenDatabaseFromDisk();
-        const { milestone, slice, task } = parseUnitId(unitId);
-        if (unitType === "execute-task" && milestone && slice && task) {
-            const row = getTask(milestone, slice, task);
-            return row && isClosedStatus(row.status)
-                ? `execute-task ${unitId} is already ${row.status}`
-                : null;
-        }
-        if (unitType === "complete-slice" && milestone && slice) {
-            const row = getSlice(milestone, slice);
-            return row && isClosedStatus(row.status)
-                ? `complete-slice ${unitId} is already ${row.status}`
-                : null;
-        }
-        return null;
-    }
-    function shouldAdoptActiveMilestone(state, activeSession, activeDispatchBasePath) {
-        const activeMilestoneId = state.activeMilestone?.id;
-        const currentMilestoneId = activeSession?.currentMilestoneId;
-        if (!activeSession || !activeMilestoneId || !currentMilestoneId || activeMilestoneId === currentMilestoneId) {
-            return false;
-        }
-        const scopedWorktreeMilestone = (activeSession.basePath ? detectWorktreeName(activeSession.basePath) : null) ??
-            detectWorktreeName(activeDispatchBasePath);
-        if (scopedWorktreeMilestone && scopedWorktreeMilestone !== activeMilestoneId) {
-            return false;
-        }
-        const currentMilestone = state.registry.find((milestone) => milestone.id === currentMilestoneId);
-        return !!currentMilestone && isClosedStatus(currentMilestone.status);
-    }
-    return {
-        async decideNextUnit(input) {
-            const state = input.stateSnapshot;
-            const active = state.activeMilestone;
-            if (!active)
-                return null;
-            const activeSession = input.session ?? session;
-            const activeDispatchBasePath = activeSession?.basePath || dispatchBasePath;
-            if (activeSession && shouldAdoptActiveMilestone(state, activeSession, activeDispatchBasePath)) {
-                activeSession.currentMilestoneId = active.id;
-            }
-            const prefs = loadEffectiveGSDPreferences(activeDispatchBasePath)?.preferences;
-            // Derive session-derived dispatch inputs the same way phases.ts:runDispatch does
-            // (#5789). Prefer caller-supplied values when present so test harnesses and
-            // alternative wirings can inject deterministic snapshots; otherwise pull from
-            // the captured pi/ctx references.
-            const sessionProvider = input.sessionProvider ?? ctx.model?.provider;
-            const sessionContextWindow = input.sessionContextWindow ?? ctx.model?.contextWindow;
-            const modelRegistry = input.modelRegistry ?? ctx.modelRegistry;
-            const authMode = sessionProvider && typeof ctx.modelRegistry?.getProviderAuthMode === "function"
-                ? ctx.modelRegistry.getProviderAuthMode(sessionProvider)
-                : undefined;
-            // Use baseline snapshot — same reason as phases.ts:runDispatch: the live
-            // active set may be narrowed by the prior unit before selectAndApplyModel
-            // restores it, causing false transport-preflight failures (#477 follow-up).
-            const activeTools = getToolBaselineSnapshot(pi);
-            // Mirrors runDispatch: deep-planning keeps approval gates in plain chat
-            // because structured questions can be cancelled outside the chat turn on
-            // some transports.
-            const structuredQuestionsAvailable = input.structuredQuestionsAvailable ??
-                (prefs?.planning_depth === "deep"
-                    ? "false"
-                    : supportsStructuredQuestions(activeTools, {
-                        authMode,
-                        baseUrl: ctx.model?.baseUrl,
-                    })
-                        ? "true"
-                        : "false");
-            const pendingRetry = session?.pendingVerificationRetryDispatch;
-            if (session && pendingRetry) {
-                session.pendingVerificationRetryDispatch = null;
-                const alreadyClosedReason = getAlreadyClosedDispatchReason(pendingRetry.unitType, pendingRetry.unitId);
-                if (alreadyClosedReason) {
-                    session.pendingOrchestrationDispatch = null;
-                    session.pendingVerificationRetry = null;
-                    return { kind: "skipped", reason: alreadyClosedReason };
-                }
-                session.pendingOrchestrationDispatch = pendingRetry;
-                return {
-                    unitType: pendingRetry.unitType,
-                    unitId: pendingRetry.unitId,
-                    reason: "verification-retry",
-                    preconditions: [],
-                };
-            }
-            const action = await resolveDispatch({
-                basePath: activeDispatchBasePath,
-                mid: active.id,
-                midTitle: active.title,
-                state,
-                prefs,
-                session: activeSession,
-                structuredQuestionsAvailable,
-                sessionContextWindow,
-                sessionProvider,
-                modelRegistry,
-                activeTools,
-                sessionAuthMode: authMode,
-                sessionBaseUrl: ctx.model?.baseUrl,
-            });
-            if (action.action === "stop") {
-                if (session)
-                    session.pendingOrchestrationDispatch = null;
-                return {
-                    kind: "blocked",
-                    reason: action.reason,
-                    action: action.level === "warning" ? "pause" : "stop",
-                };
-            }
-            if (action.action !== "dispatch") {
-                if (session)
-                    session.pendingOrchestrationDispatch = null;
-                return {
-                    kind: "skipped",
-                    reason: action.matchedRule ?? "dispatch-skip",
-                };
-            }
-            const alreadyClosedReason = getAlreadyClosedDispatchReason(action.unitType, action.unitId);
-            if (alreadyClosedReason) {
-                if (session) {
-                    session.pendingOrchestrationDispatch = null;
-                    session.pendingVerificationRetry = null;
-                }
-                return { kind: "skipped", reason: alreadyClosedReason };
-            }
-            if (session) {
-                const pending = {
-                    unitType: action.unitType,
-                    unitId: action.unitId,
-                    prompt: action.prompt,
-                    pauseAfterUatDispatch: action.pauseAfterDispatch ?? false,
-                    state,
-                    mid: active.id,
-                    midTitle: active.title,
-                };
-                session.pendingOrchestrationDispatch = pending;
-            }
-            return {
-                unitType: action.unitType,
-                unitId: action.unitId,
-                reason: action.matchedRule ?? "dispatch",
-                preconditions: [],
-            };
-        },
-    };
-}
-function isUsableLiveOrchestratorBasePath(basePath) {
-    if (!basePath || !existsSync(basePath))
-        return false;
-    if (!detectWorktreeName(basePath))
-        return true;
-    try {
-        return readFileSync(join(basePath, ".git"), "utf8").trim().startsWith("gitdir: ");
-    }
-    catch {
-        return false;
-    }
-}
-export function resolveLiveOrchestratorBasePath(input) {
-    const primary = input.sessionBasePath || input.capturedBasePath;
-    if (isUsableLiveOrchestratorBasePath(primary))
-        return primary;
-    const fallbacks = [
-        input.originalBasePath,
-        input.runtimeBasePath,
-        resolveProjectRoot(input.capturedBasePath),
-    ];
-    for (const candidate of fallbacks) {
-        if (candidate && isUsableLiveOrchestratorBasePath(candidate)) {
-            return candidate;
-        }
-    }
-    return input.runtimeBasePath || input.capturedBasePath;
-}
-/**
- * Thin entry glue for the new Auto Orchestration module.
- *
- * This intentionally wires only dispatch + error notification today, with
- * no behavior changes to the existing auto loop. It provides a concrete seam
- * the next refactor steps can adopt incrementally.
- */
-export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, runtimeBasePath = resolveProjectRoot(dispatchBasePath)) {
-    const flowId = `auto-orchestrator-${Date.now()}`;
-    let seq = 0;
-    const getLiveDispatchBasePath = () => resolveLiveOrchestratorBasePath({
-        capturedBasePath: dispatchBasePath,
-        runtimeBasePath,
-        sessionBasePath: s.basePath,
-        originalBasePath: s.originalBasePath,
-    });
-    const deps = {
-        stateReconciliation: {
-            async reconcileBeforeDispatch() {
-                const activeBasePath = getLiveDispatchBasePath();
-                const result = await reconcileBeforeDispatch(activeBasePath);
-                // Failure-path summaries written by gsd_summary_save create
-                // artifact-db-status-divergence blockers for tasks that are still
-                // pending (gsd_task_complete never ran). These tasks can still be
-                // dispatched and the drift self-heals once they complete successfully.
-                const hardBlockers = result.blockers.filter((b) => !b.includes("has SUMMARY artifact while DB status is") &&
-                    !b.includes("has SUMMARY on disk while DB status is") &&
-                    !b.includes("has task SUMMARY artifacts but no DB tasks"));
-                if (hardBlockers.length > 0) {
-                    return {
-                        ok: false,
-                        reason: hardBlockers[0],
-                        stateSnapshot: result.stateSnapshot,
-                    };
-                }
-                const repairedKinds = result.repaired.map((d) => d.kind);
-                return {
-                    ok: true,
-                    reason: repairedKinds.length > 0
-                        ? `repaired: ${repairedKinds.join(", ")}`
-                        : "clean",
-                    stateSnapshot: result.stateSnapshot,
-                };
-            },
-        },
-        dispatch: createWiredDispatchAdapter(ctx, pi, dispatchBasePath, s),
-        recovery: {
-            async classifyAndRecover(input) {
-                const recovery = classifyFailure(input);
-                return { action: recovery.action, reason: recovery.reason };
-            },
-        },
-        toolContract: {
-            async compileUnitToolContract(unitType) {
-                const result = compileUnitToolContract(unitType);
-                if (!result.ok)
-                    return { ok: false, reason: result.detail };
-                return { ok: true, reason: result.contract.validationRules.join(", ") };
-            },
-        },
-        worktree: {
-            async prepareForUnit(unitType, unitId) {
-                const manifest = resolveManifest(unitType);
-                if (!manifest) {
-                    return {
-                        ok: false,
-                        reason: `No Unit manifest is registered for ${unitType}`,
-                    };
-                }
-                if (getIsolationMode(runtimeBasePath) !== "worktree") {
-                    return { ok: true, reason: "not-required" };
-                }
-                const writeScope = manifest.tools.mode === "all" || manifest.tools.mode === "docs"
-                    ? "source-writing"
-                    : "planning-only";
-                if (getIsolationMode(runtimeBasePath) !== "worktree") {
-                    return { ok: true, reason: "isolation-not-worktree" };
-                }
-                const safety = createWorktreeSafetyModule();
-                const activeBasePath = getLiveDispatchBasePath();
-                const snapshot = await deriveState(activeBasePath);
-                const milestoneId = snapshot.activeMilestone?.id ?? null;
-                const expectedBranch = milestoneId ? autoWorktreeBranch(milestoneId) : null;
-                let result = safety.validateUnitRoot({
-                    unitType,
-                    unitId,
-                    writeScope,
-                    projectRoot: runtimeBasePath,
-                    unitRoot: activeBasePath,
-                    milestoneId,
-                    isolationMode: getIsolationMode(runtimeBasePath),
-                    expectedBranch,
-                });
-                if (!result.ok) {
-                    const repaired = await repairAutoWorktreeSafetyFailure({
-                        safetyResult: result,
-                        projectRoot: runtimeBasePath,
-                        activeRoot: activeBasePath,
-                        milestoneId,
-                        enterMilestone: async (id) => {
-                            buildLifecycle().adoptSessionRoot(runtimeBasePath, s.originalBasePath || runtimeBasePath);
-                            const enterResult = buildLifecycle().enterMilestone(id, {
-                                notify: ctx.ui.notify.bind(ctx.ui),
-                            });
-                            if (!enterResult.ok)
-                                return { ok: false, reason: enterResult.reason };
-                            rebuildScope(s.basePath, s.currentMilestoneId);
-                            return { ok: true };
-                        },
-                        revalidate: () => safety.validateUnitRoot({
-                            unitType,
-                            unitId,
-                            writeScope,
-                            projectRoot: runtimeBasePath,
-                            unitRoot: getLiveDispatchBasePath(),
-                            milestoneId,
-                            isolationMode: getIsolationMode(runtimeBasePath),
-                            expectedBranch,
-                        }),
-                    });
-                    result = repaired.result;
-                    if (result.ok) {
-                        return { ok: true, reason: repaired.repaired ? `repaired-${result.kind}` : result.kind };
-                    }
-                    const repairDetail = repaired.repairReason
-                        ? ` (repair skipped: ${repaired.repairReason})`
-                        : "";
-                    return { ok: false, reason: `${result.kind}: ${result.reason}${repairDetail}` };
-                }
-                return { ok: true, reason: result.kind };
-            },
-            async syncAfterUnit() { },
-            async cleanupOnStop() { },
-        },
-        health: {
-            checkResourcesStale() {
-                return checkResourcesStale(s.resourceVersionOnStart);
-            },
-            async preAdvanceGate() {
-                try {
-                    const gate = await preDispatchHealthGate(getLiveDispatchBasePath());
-                    if (gate.proceed) {
-                        return {
-                            kind: "pass",
-                            fixesApplied: gate.fixesApplied,
-                        };
-                    }
-                    return {
-                        kind: "fail",
-                        reason: gate.reason ?? "Pre-dispatch health check failed — run /gsd doctor for details.",
-                        action: gate.severity ?? "pause",
-                    };
-                }
-                catch (error) {
-                    return { kind: "threw", error };
-                }
-            },
-            async postAdvanceRecord(result) {
-                if (result.kind === "error") {
-                    recordHealthSnapshot(1, 0, 0, [{
-                            code: "orchestration-error",
-                            message: result.reason ?? "orchestration error",
-                            severity: "error",
-                            unitId: "orchestration",
-                        }], [], "orchestration");
-                }
-                else if (result.kind === "blocked") {
-                    recordHealthSnapshot(0, 1, 0, [{
-                            code: "orchestration-blocked",
-                            message: result.reason ?? "orchestration blocked",
-                            severity: "warning",
-                            unitId: "orchestration",
-                        }], [], "orchestration");
-                }
-            },
-        },
-        runtime: {
-            async ensureLockOwnership() {
-                const status = getSessionLockStatus(runtimeBasePath);
-                if (!status.valid || status.failureReason === "pid-mismatch") {
-                    throw new Error("session lock held by another process");
-                }
-            },
-            async journalTransition(event) {
-                const eventType = event.name === "start"
-                    ? "orchestrator-iteration-start"
-                    : event.name === "resume"
-                        ? "orchestrator-iteration-start"
-                        : event.name === "advance"
-                            ? "orchestrator-dispatch-match"
-                            : event.name === "advance-blocked"
-                                ? "orchestrator-guard-block"
-                                : event.name === "advance-stopped"
-                                    ? "orchestrator-dispatch-stop"
-                                    : event.name === "advance-error"
-                                        ? "orchestrator-iteration-end"
-                                        : event.name === "advance-paused" || event.name === "advance-retry"
-                                            ? "orchestrator-guard-block"
-                                            : event.name === "stop"
-                                                ? "orchestrator-terminal"
-                                                : "orchestrator-iteration-end";
-                _emitJournalEvent(runtimeBasePath, {
-                    ts: new Date().toISOString(),
-                    flowId,
-                    seq: ++seq,
-                    eventType,
-                    data: {
-                        source: "auto-orchestrator",
-                        name: event.name,
-                        reason: event.reason,
-                        unitType: event.unitType,
-                        unitId: event.unitId,
-                    },
-                });
-            },
-        },
-        notifications: {
-            async notifyLifecycle(event) {
-                if (event.name === "error") {
-                    ctx.ui.notify(event.detail ?? "auto orchestration error", "error");
-                }
-            },
-        },
-        uokGate: {
-            async emit(input) {
-                const activeBasePath = getLiveDispatchBasePath();
-                const prefs = loadEffectiveGSDPreferences(activeBasePath)?.preferences;
-                const uokFlags = resolveUokFlags(prefs);
-                if (!uokFlags.gates)
-                    return;
-                const milestoneId = input.milestoneId ?? s.currentMilestoneId ?? undefined;
-                try {
-                    const { UokGateRunner } = await import("./uok/gate-runner.js");
-                    const runner = new UokGateRunner();
-                    runner.register({
-                        id: input.gateId,
-                        type: input.gateType,
-                        execute: async () => ({
-                            outcome: input.outcome,
-                            failureClass: input.failureClass,
-                            rationale: input.rationale,
-                            findings: input.findings ?? "",
-                        }),
-                    });
-                    await runner.run(input.gateId, {
-                        basePath: activeBasePath,
-                        traceId: `pre-dispatch:${flowId}`,
-                        turnId: `orch-${seq}`,
-                        milestoneId,
-                        unitType: "pre-dispatch",
-                        unitId: `orch-${seq}`,
-                    });
-                }
-                catch (err) {
-                    logWarning("engine", `uok gate emit failed: ${getErrorMessage(err)}`, {
-                        file: "auto.ts",
-                        gateId: input.gateId,
-                        gateType: input.gateType,
-                        ...(milestoneId ? { milestoneId } : {}),
-                    });
-                }
-            },
-        },
-    };
-    return createAutoOrchestrator(deps);
-}
 function notifyResumeBlocked(ctx, result) {
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
     ctx.ui.notify(`Auto-mode blocked: ${result.reason}. Fix and run ${resumeCmd} to resume.`, "warning");
@@ -2056,7 +1648,13 @@ function notifyResumeBlocked(ctx, result) {
     });
 }
 function ensureOrchestrationModule(ctx, pi, basePath) {
-    s.orchestration = createWiredAutoOrchestrationModule(ctx, pi, basePath, lockBase());
+    s.orchestration = createAutoOrchestrator({
+        ctx,
+        pi,
+        dispatchBasePath: basePath,
+        runtimeBasePath: lockBase(),
+        session: s,
+    });
 }
 /**
  * Build the LoopDeps object from auto.ts private scope.

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -11,7 +11,7 @@ import { canonicalToolName, clearDiscussionFlowState, isDepthConfirmationAnswer,
 import { resolveManifest } from "../unit-context-manifest.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
-import { clearToolInvocationError, getAutoRuntimeSnapshot, getSourceObservationStore, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError, } from "../auto-runtime-state.js";
+import { clearAutoCompletionStopInProgress, clearToolInvocationError, getAutoRuntimeSnapshot, getSourceObservationStore, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError, } from "../auto-runtime-state.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { maybePauseAutoForApprovalGate, resetPendingGatePauseGuard } from "./pending-gate-pause.js";
 import { saveActivityLog } from "../activity-log.js";
@@ -109,7 +109,9 @@ export const MINIMAL_GSD_TOOL_NAMES = [
     "gsd_checkpoint_db",
     "gsd_plan_milestone",
     "memory_query",
+    "gsd_memory_query",
     "capture_thought",
+    "gsd_capture_thought",
 ];
 export const MINIMAL_AUTO_BASE_TOOL_NAMES = [
     "ask_user_questions",
@@ -624,6 +626,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
     });
     pi.on("before_agent_start", async (event, ctx) => {
+        clearAutoCompletionStopInProgress();
         resetPendingGatePauseGuard();
         applyMinimalGsdToolSurface(pi);
         // Wait for ecosystem loader to finish (no-op after first turn).

package/dist/resources/extensions/gsd/debug-logger.js

@@ -21,6 +21,7 @@ const _counters = {
     parsePlanTotalMs: 0,
     dispatches: 0,
     renders: 0,
+    gitInvocations: 0,
 };
 /** Max debug log files to keep. Older ones are pruned on enable. */
 const MAX_DEBUG_LOGS = 5;
@@ -118,6 +119,14 @@ export function debugCount(counter, value = 1) {
         return;
     _counters[counter] += value;
 }
+/**
+ * Snapshot the current debug counters. Used by the per-dispatch benchmark
+ * harness (#442) to read counts without disabling debug (which is what
+ * writeDebugSummary does). Returns a copy so callers can't mutate internal state.
+ */
+export function getDebugCounters() {
+    return { ..._counters };
+}
 /** Record a peak value (only updates if new value is higher). */
 export function debugPeak(counter, value) {
     if (!_enabled)
@@ -154,6 +163,7 @@ export function writeDebugSummary() {
         avgTtsrCheck_ms,
         ttsrPeakBuffer: _counters.ttsrPeakBuffer,
         renders: _counters.renders,
+        gitInvocations: _counters.gitInvocations,
     });
     return disableDebug();
 }