@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

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

@@ -25,16 +25,16 @@ import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
 import { writeLock, clearLock, clearStaleWorkerLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, emitOpenUnitEndForUnit, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
-import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
+import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, resolveEffectiveUnitIsolationMode, } from "./preferences.js";
 import { playNotificationBell, sendDesktopNotification } from "./notifications.js";
 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,12 +48,13 @@ 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";
 import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
+import { createMilestoneMergeTransaction } from "./milestone-merge-transaction.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, verifyExpectedArtifact, } from "./auto-recovery.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
@@ -66,7 +67,8 @@ 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 { closeWorkflowDatabase } from "./db-workspace.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { countPendingCaptures } from "./captures.js";
@@ -94,13 +96,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";
@@ -115,12 +111,13 @@ void initTokenCounter().catch((err) => {
     logWarning("engine", `token counter warm-up failed: ${err instanceof Error ? err.message : String(err)}`);
 });
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
-import { autoSession as s } from "./auto-runtime-state.js";
+import { autoSession as s, getAutoRuntimeSnapshot } from "./auto-runtime-state.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { registerAutoWorker, markWorkerStopping, } from "./db/auto-workers.js";
 import { releaseMilestoneLease } from "./db/milestone-leases.js";
 import { normalizeRealPath } from "./paths.js";
+import { formatStopNoticePrefix, isBlockedStopReason, stopNoticeDisplayReason, } from "./stop-notice.js";
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
 // ALL mutable auto-mode state lives in the AutoSession class (auto/session.ts).
 // This file must NOT declare module-level `let` or `var` variables for state.
@@ -141,17 +138,7 @@ export function formatAutoStopNotification(prefix, totals, unitCount) {
         `Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${unitCount} units`,
     ].join("\n");
 }
-function isBlockedStopReason(reason) {
-    return /^Blocked:\s*/i.test(reason ?? "");
-}
-function formatAutoStopDisplayReason(reason) {
-    return (reason ?? "").replace(/^Blocked:\s*/i, "").trim();
-}
-export function formatAutoStopNotificationPrefix(reason) {
-    const displayReason = formatAutoStopDisplayReason(reason);
-    const prefix = isBlockedStopReason(reason) ? "Auto-mode blocked" : "Auto-mode stopped";
-    return displayReason ? `${prefix} — ${displayReason}` : prefix;
-}
+export { formatStopNoticePrefix as formatAutoStopNotificationPrefix } from "./stop-notice.js";
 function clearSessionModelOverrideForCommandSession(ctx) {
     const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ??
         ctx?.sessionManager?.getSessionId?.();
@@ -350,6 +337,12 @@ export function startAutoDetached(ctx, pi, base, verboseMode, options) {
 export function shouldUseWorktreeIsolation(basePath) {
     return getIsolationMode(basePath) === "worktree";
 }
+export function _resolveEffectiveUnitIsolationModeForTest(configuredMode, isolationDegraded, strandedRecoveryIsolationMode = null) {
+    return resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded, strandedRecoveryIsolationMode);
+}
+function getEffectiveUnitIsolationMode(basePath) {
+    return resolveEffectiveUnitIsolationMode(getIsolationMode(basePath), s.isolationDegraded, s.strandedRecoveryIsolationMode);
+}
 /** 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 */
@@ -460,6 +453,7 @@ function stopAutoCommandPolling() {
 }
 export function getAutoDashboardData() {
     const ledger = getLedger();
+    const runtimeSnapshot = getAutoRuntimeSnapshot();
     const totals = ledger ? getProjectTotals(ledger.units) : null;
     const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ?? null;
     const rtkSavings = sessionId && s.basePath
@@ -492,6 +486,7 @@ export function getAutoDashboardData() {
         pendingCaptureCount,
         rtkSavings,
         rtkEnabled,
+        toolSurface: runtimeSnapshot.toolSurface,
     };
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
@@ -562,6 +557,13 @@ export function getAutoModeStartModel() {
 export function setCurrentDispatchedModelId(model) {
     s.currentDispatchedModelId = model ? `${model.provider}/${model.id}` : null;
 }
+/**
+ * Update the active unit model after runtime recovery switches models mid-unit.
+ * The next session restore path reads this field before dispatching again.
+ */
+export function setCurrentUnitModelForRecovery(model) {
+    s.currentUnitModel = model;
+}
 // Tool tracking — delegates to auto-tool-tracking.ts
 export function markToolStart(toolCallId, toolName) {
     _markToolStart(toolCallId, s.active, toolName);
@@ -628,6 +630,35 @@ export function stopAutoRemote(projectRoot) {
         return { found: false, error: err.message };
     }
 }
+/**
+ * Force-stop a remote auto-mode session before stealing its lock.
+ * The normal stop path stays SIGTERM-only so cooperative sessions can clean up;
+ * this path is only for the explicit "Force start" action.
+ */
+export function forceStopAutoRemote(projectRoot) {
+    const lock = readCrashLock(projectRoot);
+    if (!lock)
+        return { found: false };
+    if (lock.pid === process.pid) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
+    if (!isLockProcessAlive(lock)) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
+    try {
+        process.kill(lock.pid, "SIGTERM");
+        if (isLockProcessAlive(lock)) {
+            process.kill(lock.pid, "SIGKILL");
+        }
+        clearLock(projectRoot);
+        return { found: true, pid: lock.pid };
+    }
+    catch (err) {
+        return { found: false, error: err.message };
+    }
+}
 /**
  * Check if a remote auto-mode session is running (from a different process).
  * Reads the crash lock, checks PID liveness, and returns session details.
@@ -730,6 +761,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 +912,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;
             }
@@ -955,12 +1017,13 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     if (!s.active && !s.paused)
         return;
     const loadedPreferences = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
-    const stopNotificationPrefix = formatAutoStopNotificationPrefix(reason);
-    const displayReason = formatAutoStopDisplayReason(reason);
+    const stopNotificationPrefix = formatStopNoticePrefix(reason);
+    const displayReason = stopNoticeDisplayReason(reason);
     const isHeadlessStop = process.env.GSD_HEADLESS === "1";
     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);
@@ -968,12 +1031,13 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     // worktree was active, and whether the current milestone was merged before
     // stopAuto. The unmerged-work warning is only meaningful for real worktrees.
     try {
-        const { emitAutoExit, normalizeAutoExitReason } = await import("./worktree-telemetry.js");
+        const { autoExitReasonForTerminalOutcome, emitAutoExit, normalizeAutoExitReason, } = await import("./worktree-telemetry.js");
         // Normalize the free-form reason to a closed set so the telemetry
         // aggregator buckets stably. Raw detail is preserved in the phases.ts
         // notification and the notify'd error string.
         const rawReason = reason ?? "stop";
-        const normalizedReason = normalizeAutoExitReason(rawReason);
+        const normalizedReason = autoExitReasonForTerminalOutcome(options.terminalOutcome)
+            ?? normalizeAutoExitReason(rawReason);
         const telemetryBase = s.originalBasePath || s.basePath;
         emitAutoExit(telemetryBase, {
             reason: normalizedReason,
@@ -1149,8 +1213,7 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
         // ── Step 6: DB cleanup ──
         if (isDbAvailable()) {
             try {
-                const { closeDatabase } = await import("./gsd-db.js");
-                closeDatabase();
+                closeWorkflowDatabase();
             }
             catch (e) {
                 debugLog("db-close-failed", {
@@ -1270,6 +1333,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 });
@@ -1579,7 +1650,7 @@ export function buildWorktreeLifecycleDeps() {
     //   C4 (#5627) — GitServiceImpl constructor → gitServiceFactory
     //
     // Final WorktreeLifecycleDeps shape: 3 fields (gitServiceFactory,
-    // worktreeProjection, mergeMilestoneToMain). Down from 18 at slice-7
+    // worktreeProjection, mergeMilestoneToMain transaction runner). Down from 18 at slice-7
     // closure.
     return {
         gitServiceFactory: (basePath) => {
@@ -1587,463 +1658,12 @@ export function buildWorktreeLifecycleDeps() {
             return new GitServiceImpl(basePath, gitConfig);
         },
         worktreeProjection: new WorktreeStateProjection(),
-        mergeMilestoneToMain,
+        mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
     };
 }
 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 +1676,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.
@@ -2234,7 +1860,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     if (freshStartAssessment.classification === "running") {
         const pid = freshStartAssessment.lock?.pid;
         ctx.ui.notify(pid
-            ? `Another auto-mode session (PID ${pid}) appears to be running.\nStop it with \`kill ${pid}\` before starting a new session.`
+            ? `Another auto-mode session (PID ${pid}) appears to be running.\nRun \`/gsd stop\` for graceful shutdown, or choose "Force start" from \`/gsd auto\` to terminate it.`
             : "Another auto-mode session appears to be running.", "error");
         return;
     }