@useorgx/openclaw-plugin 0.4.8 → 0.4.9

package/dist/http/helpers/auto-continue-engine.js

@@ -0,0 +1,1218 @@
+import { randomUUID as randomUuidFn } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { upsertAgentContext } from "../../agent-context-store.js";
+import { readOpenClawGatewayPort, readOpenClawSettingsSnapshot, } from "../../openclaw-settings.js";
+import { resolveRuntimeHookToken, } from "../../runtime-instance-store.js";
+import { detectMcpHandshakeFailure, shouldKillWorker } from "../../worker-supervisor.js";
+import { getOrgxPluginConfigDir } from "../../paths.js";
+import { buildMissionControlGraph, DEFAULT_TOKEN_BUDGET_ASSUMPTIONS, dedupeStrings, deriveExecutionPolicy, isDispatchableWorkstreamStatus, isDoneStatus, isTodoStatus, readBudgetEnvNumber, summarizeSpawnGuardBlockReason, } from "./mission-control.js";
+import { createAutopilotRuntime } from "./autopilot-runtime.js";
+import { buildWorkstreamSlicePrompt, createCodexBinResolver, ensureAutopilotSliceSchemaPath, fileUpdatedAtEpochMs, parseSliceResult, readFileTailSafe, readSliceOutputFile, } from "./autopilot-slice-utils.js";
+import { pickString } from "./value-utils.js";
+export function createAutoContinueEngine(deps) {
+    const { client, safeErrorMessage, pidAlive, stopProcess, resolveOrgxAgentForDomain, checkSpawnGuardSafe, syncParentRollupsForTask, emitActivitySafe, requestDecisionSafe, registerArtifactSafe, applyAgentStatusUpdatesSafe, upsertRuntimeInstanceFromHook, broadcastRuntimeSse, clearSnapshotResponseCache, resolveByokEnvOverrides, } = deps;
+    const randomUUID = deps.randomUUID ?? randomUuidFn;
+    const __filename = deps.filename;
+    const autoContinueRuns = new Map();
+    const localInitiativeStatusOverrides = new Map();
+    let autoContinueTickInFlight = null;
+    const AUTO_CONTINUE_TICK_MS = readBudgetEnvNumber("ORGX_AUTO_CONTINUE_TICK_MS", 2_500, {
+        min: 250,
+        max: 60_000,
+    });
+    const autoContinueSliceRuns = new Map();
+    // Keep child handles alive so stdout/stderr capture remains reliable even when the process is detached.
+    const autoContinueSliceChildren = new Map();
+    const autoContinueSliceLastHeartbeatMs = new Map();
+    const clearAutoContinueSliceTransientState = (sliceRunId) => {
+        const id = (sliceRunId ?? "").trim();
+        if (!id)
+            return;
+        autoContinueSliceChildren.delete(id);
+        autoContinueSliceLastHeartbeatMs.delete(id);
+    };
+    const AUTO_CONTINUE_SLICE_MAX_TASKS = 6;
+    const AUTO_CONTINUE_SLICE_TIMEOUT_MS = readBudgetEnvNumber("ORGX_AUTOPILOT_SLICE_TIMEOUT_MS", 55 * 60_000, 
+    // Keep test runs fast; real-world defaults are still ~1h unless overridden.
+    { min: 250, max: 6 * 60 * 60_000 });
+    const AUTO_CONTINUE_SLICE_LOG_STALL_MS = readBudgetEnvNumber("ORGX_AUTOPILOT_SLICE_LOG_STALL_MS", 6 * 60_000, 
+    // Stall detection is only enforced when explicitly overridden; keep lower bound permissive for tests.
+    { min: 20, max: 60 * 60_000 });
+    const AUTO_CONTINUE_SLICE_HEARTBEAT_MS = 12_000;
+    const AUTO_CONTINUE_SLICE_SCHEMA_FILENAME = "autopilot-slice-schema.json";
+    const AUTO_CONTINUE_SLICE_LOG_DIRNAME = "autopilot-logs";
+    const setLocalInitiativeStatusOverride = (initiativeId, status) => {
+        const normalizedId = initiativeId.trim();
+        if (!normalizedId)
+            return;
+        localInitiativeStatusOverrides.set(normalizedId, {
+            status,
+            updatedAt: new Date().toISOString(),
+        });
+    };
+    const clearLocalInitiativeStatusOverride = (initiativeId) => {
+        const normalizedId = initiativeId.trim();
+        if (!normalizedId)
+            return;
+        localInitiativeStatusOverrides.delete(normalizedId);
+    };
+    const applyLocalInitiativeOverrides = (rows) => {
+        const seenIds = new Set();
+        const next = rows.map((row) => {
+            const id = pickString(row, ["id"]);
+            if (!id)
+                return row;
+            seenIds.add(id);
+            const override = localInitiativeStatusOverrides.get(id);
+            if (!override)
+                return row;
+            return {
+                ...row,
+                status: override.status,
+                updated_at: pickString(row, ["updated_at", "updatedAt"]) ?? override.updatedAt,
+            };
+        });
+        for (const [id, override] of localInitiativeStatusOverrides.entries()) {
+            if (seenIds.has(id))
+                continue;
+            next.push({
+                id,
+                title: `Initiative ${id.slice(0, 8)}`,
+                name: `Initiative ${id.slice(0, 8)}`,
+                summary: null,
+                status: override.status,
+                progress_pct: null,
+                created_at: override.updatedAt,
+                updated_at: override.updatedAt,
+            });
+        }
+        return next;
+    };
+    const applyLocalInitiativeOverrideToGraph = (graph) => {
+        const override = localInitiativeStatusOverrides.get(graph.initiative.id) ?? null;
+        if (!override)
+            return graph;
+        return {
+            ...graph,
+            initiative: {
+                ...graph.initiative,
+                status: override.status,
+            },
+            nodes: graph.nodes.map((node) => node.type === "initiative" && node.id === graph.initiative.id
+                ? { ...node, status: override.status }
+                : node),
+        };
+    };
+    function normalizeTokenBudget(value, fallback) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return Math.max(1_000, Math.round(value));
+        }
+        if (typeof value === "string" && value.trim().length > 0) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return Math.max(1_000, Math.round(parsed));
+            }
+        }
+        return Math.max(1_000, Math.round(fallback));
+    }
+    function defaultAutoContinueTokenBudget() {
+        const hours = readBudgetEnvNumber("ORGX_AUTO_CONTINUE_BUDGET_HOURS", 4, {
+            min: 0.05,
+            max: 24,
+        });
+        const fallback = DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.tokensPerHour *
+            hours *
+            DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.contingencyMultiplier;
+        return normalizeTokenBudget(process.env.ORGX_AUTO_CONTINUE_TOKEN_BUDGET, fallback);
+    }
+    function estimateTokensForDurationHours(durationHours) {
+        if (!Number.isFinite(durationHours) || durationHours <= 0)
+            return 0;
+        const raw = durationHours *
+            DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.tokensPerHour *
+            DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.contingencyMultiplier;
+        return Math.max(0, Math.round(raw));
+    }
+    // Helpers used by previous task-level auto-continue implementation were removed in v2.
+    // readOpenClawSessionSummary was used by the previous task-level auto-continue implementation.
+    // Autopilot v2 dispatches workstream slices via codex and does not rely on OpenClaw session JSONL.
+    async function fetchInitiativeEntity(initiativeId) {
+        try {
+            const list = await client.listEntities("initiative", { limit: 200 });
+            const match = list.data.find((candidate) => String(candidate?.id ?? "") === initiativeId);
+            return match ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async function updateInitiativeMetadata(initiativeId, patch) {
+        const existing = await fetchInitiativeEntity(initiativeId);
+        const existingMetaRaw = existing && typeof existing === "object"
+            ? existing.metadata
+            : null;
+        const existingMeta = existingMetaRaw && typeof existingMetaRaw === "object" && !Array.isArray(existingMetaRaw)
+            ? existingMetaRaw
+            : {};
+        const nextMeta = { ...existingMeta, ...patch };
+        await client.updateEntity("initiative", initiativeId, { metadata: nextMeta });
+    }
+    async function updateInitiativeAutoContinueState(input) {
+        const now = new Date().toISOString();
+        const patch = {
+            auto_continue_enabled: input.run.status === "running" || input.run.status === "stopping",
+            auto_continue_status: input.run.status,
+            auto_continue_stop_reason: input.run.stopReason,
+            auto_continue_started_at: input.run.startedAt,
+            auto_continue_stopped_at: input.run.stoppedAt,
+            auto_continue_updated_at: now,
+            auto_continue_token_budget: input.run.tokenBudget,
+            auto_continue_tokens_used: input.run.tokensUsed,
+            auto_continue_active_task_id: input.run.activeTaskId,
+            auto_continue_active_run_id: input.run.activeRunId,
+            auto_continue_active_task_token_estimate: input.run.activeTaskTokenEstimate,
+            auto_continue_last_task_id: input.run.lastTaskId,
+            auto_continue_last_run_id: input.run.lastRunId,
+            auto_continue_include_verification: input.run.includeVerification,
+            auto_continue_workstream_filter: input.run.allowedWorkstreamIds,
+            ...(input.run.lastError ? { auto_continue_last_error: input.run.lastError } : {}),
+        };
+        await updateInitiativeMetadata(input.initiativeId, patch);
+    }
+    async function stopAutoContinueRun(input) {
+        const now = new Date().toISOString();
+        const activeRunId = input.run.activeRunId;
+        input.run.status = "stopped";
+        input.run.stopReason = input.reason;
+        input.run.stoppedAt = now;
+        input.run.updatedAt = now;
+        input.run.stopRequested = false;
+        input.run.activeRunId = null;
+        input.run.activeTaskId = null;
+        input.run.activeTaskTokenEstimate = null;
+        if (input.error)
+            input.run.lastError = input.error;
+        clearAutoContinueSliceTransientState(activeRunId);
+        // Only pause the initiative on non-terminal stops (error, blocked, user-requested).
+        // Completed / budget-exhausted runs should not override the initiative status.
+        if (input.reason !== "completed" && input.reason !== "budget_exhausted") {
+            try {
+                await client.updateEntity("initiative", input.run.initiativeId, {
+                    status: "paused",
+                });
+            }
+            catch {
+                // best effort
+            }
+        }
+        try {
+            await updateInitiativeAutoContinueState({
+                initiativeId: input.run.initiativeId,
+                run: input.run,
+            });
+        }
+        catch {
+            // best effort
+        }
+        const scopeSuffix = Array.isArray(input.run.allowedWorkstreamIds) && input.run.allowedWorkstreamIds.length === 1
+            ? ` (${input.run.allowedWorkstreamIds[0]})`
+            : "";
+        const message = input.reason === "completed"
+            ? `Autopilot stopped: current dispatch scope completed${scopeSuffix}.`
+            : input.reason === "budget_exhausted"
+                ? `Autopilot stopped: token budget exhausted (${input.run.tokensUsed}/${input.run.tokenBudget}).`
+                : input.reason === "stopped"
+                    ? `Autopilot stopped by user request${scopeSuffix}.`
+                    : input.reason === "blocked"
+                        ? `Autopilot stopped: blocked pending decision${scopeSuffix}.`
+                        : `Autopilot stopped due to error${scopeSuffix}.`;
+        const phase = input.reason === "completed"
+            ? "completed"
+            : input.reason === "blocked" || input.reason === "error"
+                ? "blocked"
+                : "review";
+        const level = input.reason === "completed"
+            ? "info"
+            : input.reason === "budget_exhausted" || input.reason === "stopped"
+                ? "warn"
+                : "error";
+        await emitActivitySafe({
+            initiativeId: input.run.initiativeId,
+            runId: activeRunId ?? input.run.lastRunId ?? undefined,
+            correlationId: activeRunId ?? input.run.lastRunId ?? undefined,
+            phase,
+            level,
+            message,
+            metadata: {
+                event: "auto_continue_stopped",
+                stop_reason: input.reason,
+                requested_by_agent_id: input.run.agentId,
+                requested_by_agent_name: input.run.agentName,
+                active_run_id: activeRunId,
+                last_run_id: input.run.lastRunId,
+                token_budget: input.run.tokenBudget,
+                tokens_used: input.run.tokensUsed,
+                allowed_workstream_ids: input.run.allowedWorkstreamIds,
+                last_error: input.run.lastError,
+            },
+        });
+    }
+    const codexBinResolver = createCodexBinResolver();
+    const resolveCodexBinInfo = () => codexBinResolver.resolveCodexBinInfo();
+    const { spawnCodexSliceWorker, writeRuntimeEvent } = createAutopilotRuntime({
+        filename: __filename,
+        autoContinueSliceChildren,
+        resolveByokEnvOverrides,
+        safeErrorMessage,
+        resolveCodexBinInfo,
+        upsertRuntimeInstanceFromHook,
+        broadcastRuntimeSse,
+        clearSnapshotResponseCache,
+    });
+    async function tickAutoContinueRun(run) {
+        if (run.status !== "running" && run.status !== "stopping")
+            return;
+        const now = new Date().toISOString();
+        // 1) If we have an active slice, wait for it to finish and then register outcomes.
+        if (run.activeRunId) {
+            const slice = autoContinueSliceRuns.get(run.activeRunId) ?? null;
+            if (!slice) {
+                // Legacy/unknown pointer; clear so we can continue.
+                run.activeRunId = null;
+                run.activeTaskId = null;
+                run.updatedAt = now;
+            }
+            else {
+                const pid = slice.pid;
+                if (pid && pidAlive(pid)) {
+                    const nowMs = Date.now();
+                    const outputTail = readFileTailSafe(slice.outputPath, 240_000);
+                    const outputParsed = outputTail
+                        ? parseSliceResult(outputTail)
+                        : null;
+                    const outputComplete = Boolean(outputParsed &&
+                        typeof outputParsed.status === "string" &&
+                        typeof outputParsed.summary === "string");
+                    if (outputComplete) {
+                        // Some platforms can report a just-finished detached process as still "alive" (zombie).
+                        // Best-effort stop, then clear pid so we can proceed to parse the output contract below.
+                        try {
+                            await stopProcess(pid);
+                        }
+                        catch {
+                            // best effort
+                        }
+                        slice.pid = null;
+                        autoContinueSliceRuns.set(slice.runId, slice);
+                    }
+                    else {
+                        const lastHeartbeat = autoContinueSliceLastHeartbeatMs.get(slice.runId) ?? 0;
+                        if (nowMs - lastHeartbeat >= AUTO_CONTINUE_SLICE_HEARTBEAT_MS) {
+                            try {
+                                writeRuntimeEvent({
+                                    sourceClient: slice.sourceClient,
+                                    event: "heartbeat",
+                                    runId: slice.runId,
+                                    initiativeId: slice.initiativeId,
+                                    workstreamId: slice.workstreamId,
+                                    taskId: slice.taskIds[0] ?? null,
+                                    agentId: slice.agentId,
+                                    agentName: slice.agentName,
+                                    phase: "execution",
+                                    message: `Autopilot slice running: ${slice.workstreamTitle ?? slice.workstreamId}`,
+                                    metadata: {
+                                        event: "autopilot_slice_heartbeat",
+                                        requested_by_agent_id: run.agentId,
+                                        requested_by_agent_name: run.agentName,
+                                        domain: slice.domain,
+                                        required_skills: slice.requiredSkills,
+                                        workstream_id: slice.workstreamId,
+                                        workstream_title: slice.workstreamTitle ?? null,
+                                        task_ids: slice.taskIds,
+                                        milestone_ids: slice.milestoneIds,
+                                        log_path: slice.logPath,
+                                        output_path: slice.outputPath,
+                                    },
+                                });
+                            }
+                            catch {
+                                // best effort
+                            }
+                            autoContinueSliceLastHeartbeatMs.set(slice.runId, nowMs);
+                        }
+                        const startedAtEpochMs = Date.parse(slice.startedAt);
+                        const fallbackEpochMs = Number.isFinite(startedAtEpochMs) ? startedAtEpochMs : nowMs;
+                        const outputUpdatedAtEpochMs = fileUpdatedAtEpochMs(slice.outputPath, fallbackEpochMs);
+                        // Treat stdout/output freshness as progress; stderr noise should not prevent stall detection.
+                        const stallUpdatedAtEpochMs = outputUpdatedAtEpochMs;
+                        const logTail = readFileTailSafe(slice.logPath, 64_000);
+                        const mcpHandshake = detectMcpHandshakeFailure(logTail);
+                        if (mcpHandshake) {
+                            try {
+                                await stopProcess(pid);
+                            }
+                            catch {
+                                // best effort
+                            }
+                            slice.status = "error";
+                            slice.finishedAt = now;
+                            slice.updatedAt = now;
+                            slice.lastError = `Autopilot slice failed to initialize MCP server${mcpHandshake.server ? ` (${mcpHandshake.server})` : ""}.`;
+                            autoContinueSliceRuns.set(slice.runId, slice);
+                            run.lastError = slice.lastError;
+                            run.updatedAt = now;
+                            clearAutoContinueSliceTransientState(slice.runId);
+                            await emitActivitySafe({
+                                initiativeId: run.initiativeId,
+                                runId: slice.runId,
+                                correlationId: slice.runId,
+                                phase: "blocked",
+                                level: "error",
+                                message: `Autopilot slice MCP failed: ${slice.workstreamTitle ?? slice.workstreamId}.`,
+                                metadata: {
+                                    event: "autopilot_slice_mcp_handshake_failed",
+                                    requested_by_agent_id: run.agentId,
+                                    requested_by_agent_name: run.agentName,
+                                    mcp_server: mcpHandshake.server,
+                                    mcp_line: mcpHandshake.line,
+                                    workstream_id: slice.workstreamId,
+                                    task_ids: slice.taskIds,
+                                    milestone_ids: slice.milestoneIds,
+                                    log_path: slice.logPath,
+                                    output_path: slice.outputPath,
+                                },
+                            });
+                            await requestDecisionSafe({
+                                initiativeId: run.initiativeId,
+                                correlationId: slice.runId,
+                                title: `Autopilot slice MCP failed: ${slice.workstreamTitle ?? slice.workstreamId}`,
+                                summary: `MCP handshake failed${mcpHandshake.server ? ` for ${mcpHandshake.server}` : ""}. Review logs/output and decide whether to retry or pause autopilot.`,
+                                urgency: "high",
+                                options: [
+                                    "Retry this workstream slice",
+                                    "Pause autopilot and investigate",
+                                    "Skip this workstream for now",
+                                ],
+                                blocking: true,
+                            });
+                            await stopAutoContinueRun({
+                                run,
+                                reason: "blocked",
+                                error: slice.lastError,
+                            });
+                            return;
+                        }
+                        const killDecision = shouldKillWorker({
+                            nowEpochMs: nowMs,
+                            startedAtEpochMs: fallbackEpochMs,
+                            logUpdatedAtEpochMs: stallUpdatedAtEpochMs,
+                        }, { timeoutMs: AUTO_CONTINUE_SLICE_TIMEOUT_MS, stallMs: AUTO_CONTINUE_SLICE_LOG_STALL_MS });
+                        if (killDecision.kill) {
+                            try {
+                                await stopProcess(pid);
+                            }
+                            catch {
+                                // best effort
+                            }
+                            slice.status = "error";
+                            slice.finishedAt = now;
+                            slice.updatedAt = now;
+                            slice.lastError =
+                                killDecision.kind === "timeout"
+                                    ? `Autopilot slice timed out after ${Math.round(AUTO_CONTINUE_SLICE_TIMEOUT_MS / 60_000)} minutes.`
+                                    : `Autopilot slice stalled (no output) for ${Math.round(AUTO_CONTINUE_SLICE_LOG_STALL_MS / 60_000)} minutes.`;
+                            autoContinueSliceRuns.set(slice.runId, slice);
+                            run.lastError = slice.lastError;
+                            run.updatedAt = now;
+                            clearAutoContinueSliceTransientState(slice.runId);
+                            const event = killDecision.kind === "timeout" ? "autopilot_slice_timeout" : "autopilot_slice_log_stall";
+                            const humanLabel = killDecision.kind === "timeout" ? "timed out" : "stalled";
+                            await emitActivitySafe({
+                                initiativeId: run.initiativeId,
+                                runId: slice.runId,
+                                correlationId: slice.runId,
+                                phase: "blocked",
+                                level: "error",
+                                message: `Autopilot slice ${humanLabel}: ${slice.workstreamTitle ?? slice.workstreamId}.`,
+                                metadata: {
+                                    event,
+                                    requested_by_agent_id: run.agentId,
+                                    requested_by_agent_name: run.agentName,
+                                    workstream_id: slice.workstreamId,
+                                    task_ids: slice.taskIds,
+                                    milestone_ids: slice.milestoneIds,
+                                    log_path: slice.logPath,
+                                    output_path: slice.outputPath,
+                                    reason: killDecision.reason,
+                                    elapsed_ms: killDecision.elapsedMs,
+                                    idle_ms: killDecision.idleMs,
+                                },
+                            });
+                            await requestDecisionSafe({
+                                initiativeId: run.initiativeId,
+                                correlationId: slice.runId,
+                                title: `Autopilot slice ${humanLabel}: ${slice.workstreamTitle ?? slice.workstreamId}`,
+                                summary: "The slice was terminated because it stopped making progress. Review logs/output and decide whether to retry or pause autopilot.",
+                                urgency: "high",
+                                options: [
+                                    "Retry this workstream slice",
+                                    "Pause autopilot and investigate",
+                                    "Skip this workstream for now",
+                                ],
+                                blocking: true,
+                            });
+                            await stopAutoContinueRun({
+                                run,
+                                reason: "blocked",
+                                error: slice.lastError,
+                            });
+                            return;
+                        }
+                        if (run.stopRequested) {
+                            try {
+                                await stopProcess(pid);
+                            }
+                            catch {
+                                // best effort
+                            }
+                        }
+                        if (!outputComplete)
+                            return;
+                    }
+                }
+                // Slice finished.
+                const raw = readSliceOutputFile(slice.outputPath);
+                const parsed = raw ? parseSliceResult(raw) : null;
+                const parsedStatus = parsed?.status ?? "error";
+                const defaultDecisionBlocking = parsedStatus === "completed" ? false : true;
+                const decisions = Array.isArray(parsed?.decisions_needed)
+                    ? (parsed?.decisions_needed ?? [])
+                        .filter((item) => Boolean(item && typeof item.question === "string" && item.question.trim()))
+                    : [];
+                const blockingDecisionCount = decisions.filter((item) => typeof item.blocking === "boolean" ? item.blocking : defaultDecisionBlocking).length;
+                const nonBlockingDecisionCount = Math.max(0, decisions.length - blockingDecisionCount);
+                const effectiveParsedStatus = parsedStatus === "completed" && blockingDecisionCount > 0
+                    ? "needs_decision"
+                    : parsedStatus;
+                slice.status =
+                    effectiveParsedStatus === "completed"
+                        ? "completed"
+                        : effectiveParsedStatus === "blocked" || effectiveParsedStatus === "needs_decision"
+                            ? "blocked"
+                            : "error";
+                slice.finishedAt = now;
+                slice.updatedAt = now;
+                slice.lastError =
+                    slice.status === "error"
+                        ? slice.lastError ?? "Autopilot slice failed or returned invalid output."
+                        : null;
+                autoContinueSliceRuns.set(slice.runId, slice);
+                clearAutoContinueSliceTransientState(slice.runId);
+                // Token accounting: codex CLI doesn't provide tokens here; use the modeled estimate.
+                const modeledTokens = slice.tokenEstimate ?? run.activeTaskTokenEstimate ?? 0;
+                run.tokensUsed += Math.max(0, modeledTokens);
+                run.activeTaskTokenEstimate = null;
+                const artifacts = Array.isArray(parsed?.artifacts)
+                    ? (parsed?.artifacts ?? [])
+                        .filter((item) => Boolean(item && typeof item.name === "string" && item.name.trim()))
+                    : [];
+                const taskUpdates = Array.isArray(parsed?.task_updates)
+                    ? parsed.task_updates
+                    : [];
+                const milestoneUpdates = Array.isArray(parsed?.milestone_updates)
+                    ? parsed.milestone_updates
+                    : [];
+                for (const decision of decisions) {
+                    await requestDecisionSafe({
+                        initiativeId: run.initiativeId,
+                        correlationId: slice.runId,
+                        title: decision.question.trim(),
+                        summary: decision.summary ?? parsed?.summary ?? null,
+                        urgency: decision.urgency ?? "high",
+                        options: Array.isArray(decision.options)
+                            ? decision.options.filter((opt) => typeof opt === "string" && opt.trim())
+                            : [],
+                        blocking: typeof decision.blocking === "boolean" ? decision.blocking : defaultDecisionBlocking,
+                    });
+                }
+                for (const artifact of artifacts) {
+                    await registerArtifactSafe({
+                        initiativeId: run.initiativeId,
+                        runId: slice.runId,
+                        agentId: slice.agentId,
+                        agentName: slice.agentName,
+                        workstreamId: slice.workstreamId,
+                        artifact,
+                    });
+                }
+                const statusUpdateResult = await applyAgentStatusUpdatesSafe({
+                    initiativeId: run.initiativeId,
+                    runId: slice.runId,
+                    correlationId: slice.runId,
+                    taskUpdates,
+                    milestoneUpdates,
+                });
+                try {
+                    writeRuntimeEvent({
+                        sourceClient: slice.sourceClient,
+                        event: slice.status === "error" ? "error" : "session_stop",
+                        runId: slice.runId,
+                        initiativeId: slice.initiativeId,
+                        workstreamId: slice.workstreamId,
+                        taskId: slice.taskIds[0] ?? null,
+                        agentId: slice.agentId,
+                        agentName: slice.agentName ?? null,
+                        phase: slice.status === "completed" ? "completed" : "blocked",
+                        message: parsed?.summary ?? slice.lastError ?? "Autopilot slice finished.",
+                        metadata: {
+                            event: "autopilot_slice_finished",
+                            requested_by_agent_id: run.agentId,
+                            requested_by_agent_name: run.agentName,
+                            status: effectiveParsedStatus,
+                            artifacts: artifacts.length,
+                            decisions: decisions.length,
+                            blocking_decisions: blockingDecisionCount,
+                            non_blocking_decisions: nonBlockingDecisionCount,
+                            status_updates: statusUpdateResult.applied,
+                            status_updates_buffered: statusUpdateResult.buffered,
+                        },
+                    });
+                }
+                catch {
+                    // best effort
+                }
+                await emitActivitySafe({
+                    initiativeId: run.initiativeId,
+                    runId: slice.runId,
+                    correlationId: slice.runId,
+                    phase: slice.status === "completed" ? "completed" : "blocked",
+                    level: slice.status === "completed" ? "info" : "warn",
+                    message: slice.status === "completed"
+                        ? `Autopilot slice completed for ${slice.workstreamTitle ?? slice.workstreamId} (${slice.taskIds.length} task${slice.taskIds.length === 1 ? "" : "s"}).`
+                        : `Autopilot slice blocked: ${slice.workstreamTitle ?? slice.workstreamId}.`,
+                    metadata: {
+                        event: "autopilot_slice_result",
+                        requested_by_agent_id: run.agentId,
+                        requested_by_agent_name: run.agentName,
+                        agent_id: slice.agentId,
+                        agent_name: slice.agentName,
+                        domain: slice.domain,
+                        required_skills: slice.requiredSkills,
+                        workstream_id: slice.workstreamId,
+                        task_ids: slice.taskIds,
+                        milestone_ids: slice.milestoneIds,
+                        parsed_status: effectiveParsedStatus,
+                        has_output: Boolean(parsed),
+                        artifacts: artifacts.length,
+                        decisions: decisions.length,
+                        blocking_decisions: blockingDecisionCount,
+                        non_blocking_decisions: nonBlockingDecisionCount,
+                        decision_required: blockingDecisionCount > 0,
+                        status_updates_applied: statusUpdateResult.applied,
+                        status_updates_buffered: statusUpdateResult.buffered,
+                        output_path: slice.outputPath,
+                        log_path: slice.logPath,
+                        error: slice.lastError,
+                    },
+                });
+                if (slice.status !== "completed") {
+                    if (slice.status === "error" && decisions.length === 0) {
+                        await requestDecisionSafe({
+                            initiativeId: run.initiativeId,
+                            correlationId: slice.runId,
+                            title: `Autopilot slice failed: ${slice.workstreamTitle ?? slice.workstreamId}`,
+                            summary: parsed?.summary ??
+                                slice.lastError ??
+                                "The slice failed without producing a valid output contract. Review logs/output and decide whether to retry or pause autopilot.",
+                            urgency: "high",
+                            options: [
+                                "Retry this workstream slice",
+                                "Pause autopilot and investigate",
+                                "Skip this workstream for now",
+                            ],
+                            blocking: true,
+                        });
+                    }
+                    await stopAutoContinueRun({
+                        run,
+                        reason: slice.status === "error" ? "error" : "blocked",
+                        error: parsed?.summary ??
+                            slice.lastError ??
+                            `Slice returned status: ${effectiveParsedStatus}`,
+                    });
+                    return;
+                }
+                const completionHadNoOutcome = parsedStatus === "completed" &&
+                    artifacts.length === 0 &&
+                    decisions.length === 0 &&
+                    statusUpdateResult.applied === 0;
+                if (!parsed || parsedStatus === "error" || completionHadNoOutcome) {
+                    const attentionTitle = completionHadNoOutcome
+                        ? `Autopilot slice needs verification: ${slice.workstreamTitle ?? slice.workstreamId}`
+                        : `Autopilot slice failed: ${slice.workstreamTitle ?? slice.workstreamId}`;
+                    const attentionSummary = completionHadNoOutcome
+                        ? "The slice reported completion but did not produce artifacts or status updates. Decide whether to retry, request stronger output, or mark tasks manually."
+                        : "The slice exited without a valid output contract. Review logs/output and decide whether to retry or pause autopilot.";
+                    await requestDecisionSafe({
+                        initiativeId: run.initiativeId,
+                        correlationId: slice.runId,
+                        title: attentionTitle,
+                        summary: attentionSummary,
+                        urgency: "high",
+                        options: [
+                            "Retry this workstream slice",
+                            "Pause autopilot and investigate",
+                            "Skip this workstream for now",
+                        ],
+                        blocking: true,
+                    });
+                    await stopAutoContinueRun({
+                        run,
+                        reason: completionHadNoOutcome ? "blocked" : "error",
+                        error: slice.lastError ??
+                            (completionHadNoOutcome
+                                ? "Slice completed without verifiable outcomes."
+                                : "Slice failed or returned invalid output."),
+                    });
+                    return;
+                }
+                run.lastRunId = slice.runId;
+                run.lastTaskId = run.activeTaskId ?? run.lastTaskId;
+                run.activeRunId = null;
+                run.activeTaskId = null;
+                run.updatedAt = now;
+                try {
+                    await updateInitiativeAutoContinueState({
+                        initiativeId: run.initiativeId,
+                        run,
+                    });
+                }
+                catch {
+                    // best effort
+                }
+                if (run.stopAfterSlice) {
+                    run.stopAfterSlice = false;
+                    await stopAutoContinueRun({ run, reason: "completed" });
+                    return;
+                }
+                if (run.stopRequested) {
+                    await stopAutoContinueRun({ run, reason: "stopped" });
+                    return;
+                }
+            }
+        }
+        if (run.stopRequested) {
+            run.status = "stopping";
+            run.updatedAt = now;
+            await stopAutoContinueRun({ run, reason: "stopped" });
+            return;
+        }
+        // 2) Enforce token guardrail before starting a new slice.
+        if (run.tokensUsed >= run.tokenBudget) {
+            await stopAutoContinueRun({ run, reason: "budget_exhausted" });
+            return;
+        }
+        // 3) Pick next workstream slice and dispatch.
+        let graph;
+        try {
+            graph = applyLocalInitiativeOverrideToGraph(await buildMissionControlGraph(client, run.initiativeId));
+        }
+        catch (err) {
+            await stopAutoContinueRun({
+                run,
+                reason: "error",
+                error: safeErrorMessage(err),
+            });
+            return;
+        }
+        const nodes = graph.nodes;
+        const nodeById = new Map(nodes.map((node) => [node.id, node]));
+        const taskNodes = nodes.filter((node) => node.type === "task");
+        const todoTasks = taskNodes.filter((node) => isTodoStatus(node.status));
+        if (todoTasks.length === 0) {
+            await stopAutoContinueRun({ run, reason: "completed" });
+            return;
+        }
+        const taskIsReady = (task) => task.dependencyIds.every((depId) => {
+            const dependency = nodeById.get(depId);
+            return dependency ? isDoneStatus(dependency.status) : true;
+        });
+        const taskHasBlockedParent = (task) => {
+            const milestone = task.milestoneId ? nodeById.get(task.milestoneId) ?? null : null;
+            const workstream = task.workstreamId ? nodeById.get(task.workstreamId) ?? null : null;
+            return (milestone?.status?.toLowerCase() === "blocked" ||
+                workstream?.status?.toLowerCase() === "blocked");
+        };
+        // Select the next eligible workstream by scanning ordered todos.
+        let selectedWorkstreamId = null;
+        for (const taskId of graph.recentTodos) {
+            const node = nodeById.get(taskId);
+            if (!node || node.type !== "task")
+                continue;
+            if (!isTodoStatus(node.status))
+                continue;
+            if (!run.includeVerification &&
+                typeof node.title === "string" &&
+                /^verification[ \t]+scenario/i.test(node.title)) {
+                continue;
+            }
+            if (run.allowedWorkstreamIds && node.workstreamId) {
+                if (!run.allowedWorkstreamIds.includes(node.workstreamId))
+                    continue;
+            }
+            if (!node.workstreamId)
+                continue;
+            const ws = nodeById.get(node.workstreamId);
+            if (ws && !isDispatchableWorkstreamStatus(ws.status))
+                continue;
+            if (!taskIsReady(node))
+                continue;
+            if (taskHasBlockedParent(node))
+                continue;
+            selectedWorkstreamId = node.workstreamId;
+            break;
+        }
+        if (!selectedWorkstreamId) {
+            await stopAutoContinueRun({ run, reason: "blocked" });
+            return;
+        }
+        const workstreamNode = nodeById.get(selectedWorkstreamId) ?? null;
+        const workstreamTitle = workstreamNode?.title ?? null;
+        const initiativeNode = nodes.find((node) => node.type === "initiative") ?? null;
+        const initiativeTitle = initiativeNode?.title ?? `Initiative ${run.initiativeId.slice(0, 8)}`;
+        const sliceTaskNodes = graph.recentTodos
+            .map((taskId) => nodeById.get(taskId))
+            .filter((node) => Boolean(node &&
+            node.type === "task" &&
+            node.workstreamId === selectedWorkstreamId &&
+            isTodoStatus(node.status) &&
+            taskIsReady(node) &&
+            !taskHasBlockedParent(node) &&
+            (run.includeVerification ||
+                !/^verification[ \t]+scenario/i.test(String(node.title ?? "")))))
+            .slice(0, AUTO_CONTINUE_SLICE_MAX_TASKS);
+        const primaryTask = sliceTaskNodes[0] ?? null;
+        if (!primaryTask) {
+            await stopAutoContinueRun({ run, reason: "blocked" });
+            return;
+        }
+        let cappedSliceTaskNodes = sliceTaskNodes;
+        let expectedDurationHours = cappedSliceTaskNodes.reduce((acc, t) => acc +
+            (typeof t.expectedDurationHours === "number" && Number.isFinite(t.expectedDurationHours)
+                ? Math.max(0, t.expectedDurationHours)
+                : 0), 0);
+        let tokenEstimate = estimateTokensForDurationHours(expectedDurationHours);
+        const remainingTokens = run.tokenBudget - run.tokensUsed;
+        if (remainingTokens <= 0) {
+            await stopAutoContinueRun({ run, reason: "budget_exhausted" });
+            return;
+        }
+        // If the modeled slice exceeds the remaining budget, shrink the slice to fit rather than
+        // stopping immediately (Play should still dispatch at least the primary task when possible).
+        if (tokenEstimate > 0 && tokenEstimate > remainingTokens) {
+            const nextSlice = [];
+            let hours = 0;
+            for (const task of sliceTaskNodes) {
+                const taskHours = typeof task.expectedDurationHours === "number" && Number.isFinite(task.expectedDurationHours)
+                    ? Math.max(0, task.expectedDurationHours)
+                    : 0;
+                if (nextSlice.length === 0) {
+                    nextSlice.push(task);
+                    hours += taskHours;
+                    continue;
+                }
+                const nextEstimate = estimateTokensForDurationHours(hours + taskHours);
+                if (nextEstimate > remainingTokens)
+                    continue;
+                nextSlice.push(task);
+                hours += taskHours;
+            }
+            cappedSliceTaskNodes = nextSlice;
+            expectedDurationHours = hours;
+            tokenEstimate = estimateTokensForDurationHours(expectedDurationHours);
+        }
+        if (tokenEstimate > 0 && tokenEstimate > remainingTokens) {
+            await stopAutoContinueRun({ run, reason: "budget_exhausted" });
+            return;
+        }
+        const executionPolicy = deriveExecutionPolicy(primaryTask, workstreamNode);
+        const sliceRunId = randomUUID();
+        const spawnGuardResult = await checkSpawnGuardSafe({
+            domain: executionPolicy.domain,
+            taskId: primaryTask.id,
+            initiativeId: run.initiativeId,
+            correlationId: sliceRunId,
+            runId: sliceRunId,
+            targetLabel: "autopilot slice",
+        });
+        if (spawnGuardResult && typeof spawnGuardResult === "object") {
+            const allowed = spawnGuardResult.allowed;
+            if (allowed === false) {
+                const blockedReason = summarizeSpawnGuardBlockReason(spawnGuardResult);
+                // Maintain existing behavior: mark the primary task blocked when a quality gate denies dispatch.
+                try {
+                    await client.updateEntity("task", primaryTask.id, { status: "blocked" });
+                }
+                catch {
+                    // best effort
+                }
+                try {
+                    await syncParentRollupsForTask({
+                        initiativeId: run.initiativeId,
+                        taskId: primaryTask.id,
+                        workstreamId: selectedWorkstreamId,
+                        milestoneId: primaryTask.milestoneId,
+                        correlationId: sliceRunId,
+                    });
+                }
+                catch {
+                    // best effort
+                }
+                await emitActivitySafe({
+                    initiativeId: run.initiativeId,
+                    runId: sliceRunId,
+                    correlationId: sliceRunId,
+                    phase: "blocked",
+                    level: "error",
+                    message: `Autopilot blocked by spawn guard for ${workstreamTitle ?? selectedWorkstreamId}.`,
+                    metadata: {
+                        event: "auto_continue_spawn_guard_blocked",
+                        task_id: primaryTask.id,
+                        workstream_id: selectedWorkstreamId,
+                        blocked_reason: blockedReason,
+                        spawn_guard: spawnGuardResult,
+                    },
+                });
+                await requestDecisionSafe({
+                    initiativeId: run.initiativeId,
+                    correlationId: sliceRunId,
+                    title: `Unblock autopilot for ${workstreamTitle ?? selectedWorkstreamId}`,
+                    summary: [
+                        `Spawn guard denied dispatch for primary task ${primaryTask.id}.`,
+                        `Reason: ${blockedReason}`,
+                        `Domain: ${executionPolicy.domain}`,
+                        `Required skills: ${executionPolicy.requiredSkills.join(", ")}`,
+                    ].join(" "),
+                    urgency: "high",
+                    options: [
+                        "Approve exception and continue",
+                        "Reassign slice/domain",
+                        "Pause and investigate quality gate",
+                    ],
+                    blocking: true,
+                });
+                await stopAutoContinueRun({ run, reason: "blocked", error: blockedReason });
+                return;
+            }
+        }
+        const milestoneIds = dedupeStrings(cappedSliceTaskNodes.map((t) => (t.milestoneId ?? "").trim()).filter(Boolean));
+        const milestoneSummaries = milestoneIds
+            .map((id) => nodeById.get(id))
+            .filter((node) => Boolean(node && node.type === "milestone"))
+            .map((m) => ({ id: m.id, title: m.title, status: m.status }));
+        const taskSummaries = cappedSliceTaskNodes.map((t) => ({
+            id: t.id,
+            title: t.title,
+            status: t.status,
+            milestoneId: t.milestoneId ?? null,
+        }));
+        const schemaPath = ensureAutopilotSliceSchemaPath(AUTO_CONTINUE_SLICE_SCHEMA_FILENAME);
+        const prompt = buildWorkstreamSlicePrompt({
+            initiativeTitle,
+            initiativeId: run.initiativeId,
+            workstreamId: selectedWorkstreamId,
+            workstreamTitle: workstreamTitle ?? `Workstream ${selectedWorkstreamId.slice(0, 8)}`,
+            milestoneSummaries,
+            taskSummaries,
+            executionPolicy,
+            runId: sliceRunId,
+            schemaPath,
+        });
+        const logsDir = join(getOrgxPluginConfigDir(), AUTO_CONTINUE_SLICE_LOG_DIRNAME);
+        const logPath = join(logsDir, `${sliceRunId}.log`);
+        const outputPath = join(logsDir, `${sliceRunId}.output.json`);
+        let workerCwd = (process.env.ORGX_AUTOPILOT_CWD ?? "").trim() || process.cwd();
+        // LaunchAgents often start with cwd="/". Prefer a stable, user-owned directory
+        // so relative paths and codex sandboxing behave consistently.
+        if (!workerCwd || workerCwd === "/") {
+            workerCwd = homedir();
+        }
+        const sliceAgent = resolveOrgxAgentForDomain(executionPolicy.domain);
+        const workerKind = (process.env.ORGX_AUTOPILOT_WORKER_KIND ?? "").trim().toLowerCase();
+        const inferredExecutor = workerKind === "claude-code" || workerKind === "claude_code" ? "claude-code" : "codex";
+        const executorRaw = (process.env.ORGX_AUTOPILOT_EXECUTOR ?? "").trim().toLowerCase() || inferredExecutor;
+        const executorSourceClient = executorRaw === "claude-code" || executorRaw === "claude_code" ? "claude-code" : "codex";
+        let runtimeHookUrl = null;
+        let runtimeHookToken = null;
+        try {
+            const snapshot = readOpenClawSettingsSnapshot();
+            const port = readOpenClawGatewayPort(snapshot.raw);
+            runtimeHookUrl = `http://127.0.0.1:${port}/orgx/api/hooks/runtime`;
+            runtimeHookToken = resolveRuntimeHookToken();
+        }
+        catch {
+            // best effort
+        }
+        const spawned = spawnCodexSliceWorker({
+            runId: sliceRunId,
+            prompt,
+            cwd: workerCwd,
+            logPath,
+            outputPath,
+            env: {
+                ORGX_SOURCE_CLIENT: executorSourceClient,
+                ORGX_RUN_ID: sliceRunId,
+                ORGX_CORRELATION_ID: sliceRunId,
+                ORGX_INITIATIVE_ID: run.initiativeId,
+                ORGX_WORKSTREAM_ID: selectedWorkstreamId,
+                ORGX_WORKSTREAM_TITLE: workstreamTitle ?? undefined,
+                ORGX_TASK_ID: primaryTask.id,
+                ORGX_AGENT_ID: sliceAgent.id,
+                ORGX_AGENT_NAME: sliceAgent.name,
+                ORGX_OUTPUT_PATH: outputPath,
+                ORGX_RUNTIME_HOOK_URL: runtimeHookUrl ?? undefined,
+                ORGX_HOOK_TOKEN: runtimeHookToken ?? undefined,
+            },
+        });
+        const slice = {
+            runId: sliceRunId,
+            initiativeId: run.initiativeId,
+            initiativeTitle: initiativeTitle ?? null,
+            workstreamId: selectedWorkstreamId,
+            workstreamTitle,
+            agentId: sliceAgent.id,
+            agentName: sliceAgent.name,
+            domain: executionPolicy.domain,
+            requiredSkills: executionPolicy.requiredSkills,
+            sourceClient: executorSourceClient,
+            pid: spawned.pid,
+            status: "running",
+            startedAt: now,
+            finishedAt: null,
+            updatedAt: now,
+            tokenEstimate: tokenEstimate > 0 ? tokenEstimate : null,
+            outputPath,
+            logPath,
+            taskIds: cappedSliceTaskNodes.map((t) => t.id),
+            milestoneIds,
+            lastError: null,
+        };
+        autoContinueSliceRuns.set(sliceRunId, slice);
+        try {
+            writeRuntimeEvent({
+                sourceClient: executorSourceClient,
+                event: "session_start",
+                runId: sliceRunId,
+                initiativeId: run.initiativeId,
+                workstreamId: selectedWorkstreamId,
+                taskId: primaryTask.id,
+                agentId: slice.agentId,
+                agentName: sliceAgent.name,
+                phase: "execution",
+                message: `Autopilot slice started: ${workstreamTitle ?? selectedWorkstreamId}`,
+                metadata: {
+                    event: "autopilot_slice_started",
+                    requested_by_agent_id: run.agentId,
+                    requested_by_agent_name: run.agentName,
+                    domain: executionPolicy.domain,
+                    required_skills: executionPolicy.requiredSkills,
+                    task_ids: slice.taskIds,
+                    initiative_title: initiativeTitle ?? null,
+                    workstream_title: workstreamTitle ?? null,
+                    log_path: logPath,
+                    output_path: outputPath,
+                },
+            });
+        }
+        catch {
+            // best effort
+        }
+        autoContinueSliceLastHeartbeatMs.set(sliceRunId, Date.now());
+        await emitActivitySafe({
+            initiativeId: run.initiativeId,
+            runId: sliceRunId,
+            correlationId: sliceRunId,
+            phase: "execution",
+            level: "info",
+            message: `Autopilot dispatched slice for ${workstreamTitle ?? selectedWorkstreamId}.`,
+            metadata: {
+                event: "autopilot_slice_dispatched",
+                requested_by_agent_id: run.agentId,
+                requested_by_agent_name: run.agentName,
+                agent_id: slice.agentId,
+                agent_name: sliceAgent.name,
+                domain: executionPolicy.domain,
+                required_skills: executionPolicy.requiredSkills,
+                initiative_title: initiativeTitle ?? null,
+                workstream_id: selectedWorkstreamId,
+                workstream_title: workstreamTitle ?? null,
+                task_ids: slice.taskIds,
+                milestone_ids: milestoneIds,
+                log_path: logPath,
+                output_path: outputPath,
+            },
+        });
+        upsertAgentContext({
+            agentId: slice.agentId,
+            initiativeId: run.initiativeId,
+            initiativeTitle: initiativeTitle ?? null,
+            workstreamId: selectedWorkstreamId,
+            taskId: primaryTask.id,
+        });
+        run.lastTaskId = primaryTask.id;
+        run.lastRunId = sliceRunId;
+        run.activeTaskId = primaryTask.id;
+        run.activeRunId = sliceRunId;
+        run.activeTaskTokenEstimate = tokenEstimate > 0 ? tokenEstimate : null;
+        run.updatedAt = now;
+        try {
+            await client.updateEntity("initiative", run.initiativeId, { status: "active" });
+        }
+        catch {
+            // best effort
+        }
+        try {
+            await updateInitiativeAutoContinueState({
+                initiativeId: run.initiativeId,
+                run,
+            });
+        }
+        catch {
+            // best effort
+        }
+    }
+    async function tickAllAutoContinue() {
+        if (autoContinueTickInFlight) {
+            // Wait for the in-flight tick to finish instead of silently dropping.
+            await autoContinueTickInFlight.catch(() => { });
+            return;
+        }
+        const work = (async () => {
+            for (const run of autoContinueRuns.values()) {
+                try {
+                    await tickAutoContinueRun(run);
+                }
+                catch (err) {
+                    // Never let one loop crash the whole handler.
+                    run.lastError = safeErrorMessage(err);
+                    run.updatedAt = new Date().toISOString();
+                    await stopAutoContinueRun({ run, reason: "error", error: run.lastError });
+                }
+            }
+        })();
+        autoContinueTickInFlight = work;
+        try {
+            await work;
+        }
+        finally {
+            autoContinueTickInFlight = null;
+        }
+    }
+    function isInitiativeActiveStatus(status) {
+        const normalized = (status ?? "").trim().toLowerCase();
+        if (!normalized)
+            return false;
+        return !(normalized === "completed" ||
+            normalized === "done" ||
+            normalized === "archived" ||
+            normalized === "deleted" ||
+            normalized === "cancelled");
+    }
+    function runningAutoContinueForWorkstream(initiativeId, workstreamId) {
+        const run = autoContinueRuns.get(initiativeId) ?? null;
+        if (!run)
+            return null;
+        if (run.status !== "running" && run.status !== "stopping")
+            return null;
+        if (!Array.isArray(run.allowedWorkstreamIds) || run.allowedWorkstreamIds.length === 0) {
+            return run;
+        }
+        return run.allowedWorkstreamIds.includes(workstreamId) ? run : null;
+    }
+    async function startAutoContinueRun(input) {
+        const now = new Date().toISOString();
+        const existing = autoContinueRuns.get(input.initiativeId) ?? null;
+        const existingIsLive = existing?.status === "running" || existing?.status === "stopping";
+        const run = existing ??
+            {
+                initiativeId: input.initiativeId,
+                agentId: input.agentId,
+                agentName: input.agentName ?? null,
+                includeVerification: false,
+                allowedWorkstreamIds: null,
+                stopAfterSlice: false,
+                tokenBudget: defaultAutoContinueTokenBudget(),
+                tokensUsed: 0,
+                status: "running",
+                stopReason: null,
+                stopRequested: false,
+                startedAt: now,
+                stoppedAt: null,
+                updatedAt: now,
+                lastError: null,
+                lastTaskId: null,
+                lastRunId: null,
+                activeTaskId: null,
+                activeRunId: null,
+                activeTaskTokenEstimate: null,
+            };
+        run.agentId = input.agentId;
+        run.agentName =
+            typeof input.agentName === "string" && input.agentName.trim().length > 0
+                ? input.agentName.trim()
+                : null;
+        run.includeVerification = input.includeVerification;
+        run.allowedWorkstreamIds = input.allowedWorkstreamIds;
+        run.stopAfterSlice = Boolean(input.stopAfterSlice);
+        run.tokenBudget = normalizeTokenBudget(input.tokenBudget, run.tokenBudget || defaultAutoContinueTokenBudget());
+        run.status = "running";
+        run.stopReason = null;
+        run.stopRequested = false;
+        run.stoppedAt = null;
+        run.updatedAt = now;
+        run.lastError = null;
+        const forceFreshRun = Boolean(input.stopAfterSlice);
+        if (!existingIsLive || forceFreshRun) {
+            run.tokensUsed = 0;
+            run.startedAt = now;
+            run.lastTaskId = null;
+            run.lastRunId = null;
+            run.activeTaskId = null;
+            run.activeRunId = null;
+            run.activeTaskTokenEstimate = null;
+        }
+        autoContinueRuns.set(input.initiativeId, run);
+        void client
+            .updateEntity("initiative", input.initiativeId, { status: "active" })
+            .catch(() => {
+            // best effort
+        });
+        void updateInitiativeAutoContinueState({
+            initiativeId: input.initiativeId,
+            run,
+        }).catch(() => {
+            // best effort
+        });
+        return run;
+    }
+    return {
+        autoContinueRuns,
+        autoContinueSliceRuns,
+        localInitiativeStatusOverrides,
+        writeRuntimeEvent,
+        autoContinueTickMs: AUTO_CONTINUE_TICK_MS,
+        defaultAutoContinueTokenBudget,
+        setLocalInitiativeStatusOverride,
+        clearLocalInitiativeStatusOverride,
+        applyLocalInitiativeOverrides,
+        applyLocalInitiativeOverrideToGraph,
+        updateInitiativeAutoContinueState,
+        stopAutoContinueRun,
+        tickAutoContinueRun,
+        tickAllAutoContinue,
+        isInitiativeActiveStatus,
+        runningAutoContinueForWorkstream,
+        startAutoContinueRun,
+    };
+}