@useorgx/openclaw-plugin 0.7.18 → 0.7.23

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

@@ -3,7 +3,7 @@ import { existsSync } from "node:fs";
 import { readdir, stat, unlink } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { normalizeActivityActionPhase, normalizeActivityActionType, } from "../../contracts/shared-types.js";
+import { normalizeActivityActionPhase, normalizeActivityActionType, normalizeDecisionActionType, } from "../../contracts/shared-types.js";
 import { upsertAgentContext, upsertRunContext } from "../../agent-context-store.js";
 import { appendTeamCompletion } from "../../team-context-store.js";
 import { readOpenClawGatewayPort, readOpenClawSettingsSnapshot, } from "../../openclaw-settings.js";
@@ -11,7 +11,7 @@ import { resolveRuntimeHookToken, } from "../../runtime-instance-store.js";
 import { detectMcpHandshakeFailure, shouldKillWorker } from "../../worker-supervisor.js";
 import { humanizeSliceFailure, humanizeSliceFailureSummary } from "./humanize-slice-failure.js";
 import { getOrgxPluginConfigDir } from "../../paths.js";
-import { buildMissionControlGraph, DEFAULT_TOKEN_BUDGET_ASSUMPTIONS, dedupeStrings, detectBehaviorConfigDrift, deriveBehaviorAutomationLevel, deriveBehaviorConfigContext, deriveExecutionPolicy, evaluateScopeCompletion, isDispatchableWorkstreamStatus, isDoneStatus, isTodoStatus, readBudgetEnvNumber, selectSliceTasksByScope, SLICE_SCOPE_TIMEOUT_MULTIPLIER, spawnGuardIsRateLimited, summarizeSpawnGuardBlockReason, } from "./mission-control.js";
+import { buildMissionControlGraph, DEFAULT_TOKEN_BUDGET_ASSUMPTIONS, dedupeStrings, detectBehaviorConfigDrift, deriveBehaviorAutomationLevel, deriveBehaviorConfigContext, deriveInitiativeLifecycleStatus, deriveExecutionPolicy, evaluateScopeCompletion, isDispatchableWorkstreamStatus, isDoneStatus, isTodoStatus, readBudgetEnvNumber, selectSliceTasksByScope, SLICE_SCOPE_TIMEOUT_MULTIPLIER, spawnGuardIsRateLimited, summarizeSpawnGuardBlockReason, } from "./mission-control.js";
 import { createAutopilotRuntime } from "./autopilot-runtime.js";
 import { buildScopeDirective, buildSliceOutputInstructions, buildWorkstreamSlicePrompt, createCodexBinResolver, ensureAutopilotSliceSchemaPath, extractSessionIdFromLog, extractSessionIdFromOutput, fileUpdatedAtEpochMs, parseSliceResult, readFileTailSafe, readSliceOutputFile, } from "./autopilot-slice-utils.js";
 import { pickString } from "./value-utils.js";
@@ -28,7 +28,18 @@ function resolveAutopilotDefaultCwd(filename) {
     }
     return homedir();
 }
+function captureAutopilotWorkerEnv() {
+    return {
+        ORGX_AUTOPILOT_CWD: (process.env.ORGX_AUTOPILOT_CWD ?? "").trim() || undefined,
+        ORGX_AUTOPILOT_EXECUTOR: (process.env.ORGX_AUTOPILOT_EXECUTOR ?? "").trim() || undefined,
+        ORGX_AUTOPILOT_WORKER_KIND: (process.env.ORGX_AUTOPILOT_WORKER_KIND ?? "").trim() || undefined,
+        ORGX_AUTOPILOT_MOCK_SCENARIO: (process.env.ORGX_AUTOPILOT_MOCK_SCENARIO ?? "").trim() || undefined,
+        ORGX_AUTOPILOT_MOCK_SLEEP_MS: (process.env.ORGX_AUTOPILOT_MOCK_SLEEP_MS ?? "").trim() || undefined,
+        ORGX_AUTOPILOT_SESSION_RESUME: (process.env.ORGX_AUTOPILOT_SESSION_RESUME ?? "").trim() || undefined,
+    };
+}
 export function createAutoContinueEngine(deps) {
+    const defaultWorkerEnvOverrides = captureAutopilotWorkerEnv();
     const { client, safeErrorMessage, pidAlive, stopProcess, resolveOrgxAgentForDomain, checkSpawnGuardSafe, syncParentRollupsForTask, emitActivitySafe, requestDecisionSafe, registerArtifactSafe, applyAgentStatusUpdatesSafe, upsertRuntimeInstanceFromHook, broadcastRuntimeSse, clearSnapshotResponseCache, resolveByokEnvOverrides, } = deps;
     const randomUUID = deps.randomUUID ?? randomUuidFn;
     const fetchKickoffContextSafeFn = deps.fetchKickoffContextSafe ?? null;
@@ -731,8 +742,139 @@ export function createAutoContinueEngine(deps) {
         }
         return { queued: false, decisionIds: [] };
     };
+    const defaultInterventionDecisionOptions = () => [
+        {
+            id: "retry_slice",
+            label: "Retry this workstream slice",
+            description: "Retry once with the latest context and logs.",
+            consequences: "Autopilot retries this workstream slice immediately.",
+            implied_status: "approved",
+            action_type: "retry",
+            requires_note: false,
+        },
+        {
+            id: "pause_and_investigate",
+            label: "Pause autopilot and investigate",
+            description: "Pause orchestration and capture operator notes for handoff.",
+            consequences: "Autopilot pauses and waits for new operator guidance.",
+            implied_status: "declined",
+            action_type: "pause",
+            requires_note: true,
+        },
+        {
+            id: "skip_for_now",
+            label: "Skip this workstream for now",
+            description: "Defer this lane and keep other workstreams moving.",
+            consequences: "This lane is deferred while the rest of the queue continues.",
+            implied_status: "declined",
+            action_type: "defer",
+            requires_note: true,
+        },
+    ];
     const __filename = deps.filename;
     const autoContinueRuns = new Map();
+    /**
+     * Rehydrate an AutoContinueRun from persisted initiative metadata.
+     * Called when the in-memory Map is empty (e.g. after server restart) to
+     * restore the last-known autopilot state so the dashboard toggle stays
+     * accurate.
+     */
+    async function restoreAutoContinueRun(initiativeId) {
+        // Already in memory — nothing to restore.
+        if (autoContinueRuns.has(initiativeId)) {
+            return autoContinueRuns.get(initiativeId) ?? null;
+        }
+        try {
+            const entity = await fetchInitiativeEntity(initiativeId);
+            if (!entity)
+                return null;
+            const meta = entity && typeof entity === "object"
+                ? entity.metadata ?? {}
+                : {};
+            const enabled = meta.auto_continue_enabled;
+            const status = meta.auto_continue_status;
+            if (!enabled || !status)
+                return null;
+            // Reconstruct lane objects from persisted array.
+            const rawLanes = Array.isArray(meta.auto_continue_lane_states)
+                ? meta.auto_continue_lane_states
+                : [];
+            const laneByWorkstreamId = {};
+            for (const raw of rawLanes) {
+                const wsId = String(raw.workstream_id ?? "").trim();
+                if (!wsId)
+                    continue;
+                laneByWorkstreamId[wsId] = {
+                    workstreamId: wsId,
+                    state: raw.state ?? LaneState.IDLE,
+                    activeRunId: raw.active_run_id ?? null,
+                    activeTaskIds: Array.isArray(raw.active_task_ids) ? raw.active_task_ids : [],
+                    blockedReason: raw.blocked_reason ?? null,
+                    waitingOnWorkstreamIds: Array.isArray(raw.waiting_on_workstream_ids)
+                        ? raw.waiting_on_workstream_ids
+                        : [],
+                    retryAt: raw.retry_at ?? null,
+                    updatedAt: raw.updated_at ?? new Date().toISOString(),
+                };
+            }
+            const now = new Date().toISOString();
+            const run = {
+                initiativeId,
+                workspaceId: typeof meta.workspace_id === "string" && meta.workspace_id.trim().length > 0
+                    ? meta.workspace_id.trim()
+                    : null,
+                agentId: "",
+                agentName: null,
+                includeVerification: Boolean(meta.auto_continue_include_verification),
+                allowedWorkstreamIds: Array.isArray(meta.auto_continue_workstream_filter)
+                    ? meta.auto_continue_workstream_filter
+                    : null,
+                stopAfterSlice: false,
+                ignoreSpawnGuardRateLimit: Boolean(meta.auto_continue_ignore_spawn_guard_rate_limit),
+                maxParallelSlices: normalizeMaxParallelSlices(meta.auto_continue_max_parallel, AUTO_CONTINUE_MAX_PARALLEL_DEFAULT),
+                parallelMode: normalizeParallelMode(meta.auto_continue_parallel_mode),
+                scope: "task",
+                tokenBudget: normalizeTokenBudget(meta.auto_continue_token_budget, defaultAutoContinueTokenBudget()),
+                tokensUsed: typeof meta.auto_continue_tokens_used === "number" ? meta.auto_continue_tokens_used : 0,
+                status: status,
+                stopReason: meta.auto_continue_stop_reason ?? null,
+                stopRequested: false,
+                startedAt: meta.auto_continue_started_at ?? now,
+                stoppedAt: meta.auto_continue_stopped_at ?? null,
+                updatedAt: meta.auto_continue_updated_at ?? now,
+                lastError: meta.auto_continue_last_error ?? null,
+                lastTaskId: meta.auto_continue_last_task_id ?? null,
+                lastRunId: meta.auto_continue_last_run_id ?? null,
+                activeSliceRunIds: Array.isArray(meta.auto_continue_active_run_ids)
+                    ? meta.auto_continue_active_run_ids
+                    : [],
+                activeTaskIds: Array.isArray(meta.auto_continue_active_task_ids)
+                    ? meta.auto_continue_active_task_ids
+                    : [],
+                laneByWorkstreamId,
+                blockedWorkstreamIds: Array.isArray(meta.auto_continue_blocked_workstream_ids)
+                    ? meta.auto_continue_blocked_workstream_ids
+                    : [],
+                activeTaskId: meta.auto_continue_active_task_id ?? null,
+                activeRunId: meta.auto_continue_active_run_id ?? null,
+                activeTaskTokenEstimate: typeof meta.auto_continue_active_task_token_estimate === "number"
+                    ? meta.auto_continue_active_task_token_estimate
+                    : null,
+                workerEnvOverrides: null,
+                lastInitiativeStatus: typeof meta.status === "string" && meta.status.trim().length > 0
+                    ? meta.status.trim()
+                    : null,
+            };
+            ensureRunInternals(run);
+            syncLegacyRunPointers(run);
+            // Insert into in-memory map so subsequent lookups are fast.
+            autoContinueRuns.set(initiativeId, run);
+            return run;
+        }
+        catch {
+            return null;
+        }
+    }
     const localInitiativeStatusOverrides = new Map();
     const localTaskStatusOverrides = new Map();
     const localMilestoneStatusOverrides = new Map();
@@ -929,6 +1071,38 @@ export function createAutoContinueEngine(deps) {
         autoContinueSliceChildren.delete(id);
         autoContinueSliceLastHeartbeatMs.delete(id);
     };
+    const stopActiveSliceProcesses = async (sliceRunIds) => {
+        for (const rawRunId of sliceRunIds) {
+            const sliceRunId = rawRunId.trim();
+            if (!sliceRunId)
+                continue;
+            const child = autoContinueSliceChildren.get(sliceRunId) ?? null;
+            try {
+                if (child && child.exitCode === null && !child.killed) {
+                    child.kill("SIGTERM");
+                }
+            }
+            catch {
+                // best effort
+            }
+            const slice = autoContinueSliceRuns.get(sliceRunId) ?? null;
+            const pid = slice?.pid ?? child?.pid ?? null;
+            if (pid && pidAlive(pid)) {
+                try {
+                    await stopProcess(pid);
+                }
+                catch {
+                    // best effort
+                }
+            }
+            if (slice) {
+                slice.pid = null;
+                slice.updatedAt = new Date().toISOString();
+                autoContinueSliceRuns.set(sliceRunId, slice);
+            }
+            clearAutoContinueSliceTransientState(sliceRunId);
+        }
+    };
     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 });
@@ -1116,6 +1290,57 @@ export function createAutoContinueEngine(deps) {
         run.maxParallelSlices = normalizeMaxParallelSlices(run.maxParallelSlices, AUTO_CONTINUE_MAX_PARALLEL_DEFAULT);
         run.parallelMode = normalizeParallelMode(run.parallelMode);
         run.tokenBudget = normalizeTokenBudget(run.tokenBudget, defaultAutoContinueTokenBudget());
+        if (!run.workerEnvOverrides || typeof run.workerEnvOverrides !== "object") {
+            run.workerEnvOverrides = null;
+        }
+        run.workspaceId =
+            typeof run.workspaceId === "string" && run.workspaceId.trim().length > 0
+                ? run.workspaceId.trim()
+                : null;
+        run.lastInitiativeStatus =
+            typeof run.lastInitiativeStatus === "string" && run.lastInitiativeStatus.trim().length > 0
+                ? run.lastInitiativeStatus.trim()
+                : null;
+    };
+    const laneStateToChildStatus = (laneState) => {
+        if (laneState === LaneState.RUNNING)
+            return "in_progress";
+        if (laneState === LaneState.BLOCKED)
+            return "blocked";
+        if (laneState === LaneState.WAITING_DEPENDENCY || laneState === LaneState.RATE_LIMITED) {
+            return "paused";
+        }
+        if (laneState === LaneState.COMPLETED)
+            return "completed";
+        return "todo";
+    };
+    const deriveInitiativeStatusFromRun = (run) => {
+        ensureRunInternals(run);
+        const childStatuses = Object.values(run.laneByWorkstreamId ?? {}).map((lane) => laneStateToChildStatus(lane.state));
+        if (run.status === RunStatus.RUNNING || run.status === RunStatus.STOPPING) {
+            return deriveInitiativeLifecycleStatus("active", childStatuses.length > 0 ? childStatuses : ["in_progress"]);
+        }
+        if (run.stopReason === "blocked" || run.stopReason === "error") {
+            return "blocked";
+        }
+        if (run.stopReason === "completed") {
+            const scopedRun = run.stopAfterSlice ||
+                (Array.isArray(run.allowedWorkstreamIds) && run.allowedWorkstreamIds.length > 0);
+            return scopedRun ? "paused" : "completed";
+        }
+        if (run.stopReason === "budget_exhausted" || run.stopReason === "stopped") {
+            return "paused";
+        }
+        return childStatuses.length > 0
+            ? deriveInitiativeLifecycleStatus("paused", childStatuses)
+            : "paused";
+    };
+    const syncInitiativeLifecycleStatus = async (run) => {
+        const nextStatus = deriveInitiativeStatusFromRun(run);
+        if (run.lastInitiativeStatus === nextStatus)
+            return;
+        await client.updateEntity("initiative", run.initiativeId, { status: nextStatus });
+        run.lastInitiativeStatus = nextStatus;
     };
     const recordLocalStatusOverrides = (input) => {
         const initiativeId = input.initiativeId.trim();
@@ -1390,6 +1615,7 @@ export function createAutoContinueEngine(deps) {
             updated_at: lane.updatedAt,
         }));
         const patch = {
+            ...(input.run.workspaceId ? { workspace_id: input.run.workspaceId } : {}),
             auto_continue_enabled: input.run.status === RunStatus.RUNNING || input.run.status === RunStatus.STOPPING,
             auto_continue_status: input.run.status,
             auto_continue_stop_reason: input.run.stopReason,
@@ -1415,6 +1641,7 @@ export function createAutoContinueEngine(deps) {
             ...(input.run.lastError ? { auto_continue_last_error: input.run.lastError } : {}),
         };
         await updateInitiativeMetadata(input.initiativeId, patch);
+        await syncInitiativeLifecycleStatus(input.run);
     }
     async function stopAutoContinueRun(input) {
         const decisionRequired = input.reason === "blocked" && input.decisionRequired === true;
@@ -1429,6 +1656,7 @@ export function createAutoContinueEngine(deps) {
         const now = new Date().toISOString();
         ensureRunInternals(input.run);
         const activeRunIds = listActiveSliceRunIds(input.run);
+        await stopActiveSliceProcesses(activeRunIds);
         input.run.status = RunStatus.STOPPED;
         input.run.stopReason = input.reason;
         input.run.stoppedAt = now;
@@ -1458,18 +1686,6 @@ export function createAutoContinueEngine(deps) {
         for (const runId of activeRunIds) {
             clearAutoContinueSliceTransientState(runId);
         }
-        // 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,
@@ -1590,7 +1806,7 @@ export function createAutoContinueEngine(deps) {
                     old_state: LaneState.RUNNING,
                     new_state: input.reason === "completed" || input.reason === "stopped" ? "idle" : input.reason === "blocked" ? "blocked" : input.reason === "error" ? "error" : "idle",
                     reason: input.reason,
-                    workspace_id: input.run.allowedWorkstreamIds?.[0] ?? null,
+                    workspace_id: input.run.workspaceId ?? null,
                 },
             });
         }
@@ -1748,11 +1964,7 @@ export function createAutoContinueEngine(deps) {
                                 title: `Agent couldn't connect to tools: ${slice.workstreamTitle ?? slice.workstreamId}`,
                                 summary: humanizeSliceFailureSummary(`MCP handshake failed${mcpHandshake.server ? ` for ${mcpHandshake.server}` : ""}.`),
                                 urgency: "high",
-                                options: [
-                                    "Retry this workstream slice",
-                                    "Pause autopilot and investigate",
-                                    "Skip this workstream for now",
-                                ],
+                                options: defaultInterventionDecisionOptions(),
                                 blocking: true,
                                 decisionType: "autopilot_failure",
                                 workstreamId: slice.workstreamId,
@@ -1870,11 +2082,7 @@ export function createAutoContinueEngine(deps) {
                                 title: stallDecisionTitle,
                                 summary: humanizeSliceFailureSummary(slice.lastError ?? `Autopilot slice ${humanLabel}`),
                                 urgency: "high",
-                                options: [
-                                    "Retry this workstream slice",
-                                    "Pause autopilot and investigate",
-                                    "Skip this workstream for now",
-                                ],
+                                options: defaultInterventionDecisionOptions(),
                                 blocking: true,
                                 decisionType: "autopilot_failure",
                                 workstreamId: slice.workstreamId,
@@ -1972,6 +2180,68 @@ export function createAutoContinueEngine(deps) {
                     }
                 }
                 const defaultDecisionBlocking = parsedStatus === "completed" ? false : true;
+                const normalizeDecisionOptions = (value) => {
+                    if (!Array.isArray(value))
+                        return [];
+                    const normalized = [];
+                    for (const rawOption of value) {
+                        if (typeof rawOption === "string") {
+                            const label = rawOption.trim();
+                            if (label.length > 0)
+                                normalized.push(label);
+                            continue;
+                        }
+                        if (!rawOption || typeof rawOption !== "object" || Array.isArray(rawOption)) {
+                            continue;
+                        }
+                        const optionRecord = rawOption;
+                        const label = (typeof optionRecord.label === "string" && optionRecord.label.trim()) ||
+                            (typeof optionRecord.title === "string" && optionRecord.title.trim()) ||
+                            (typeof optionRecord.name === "string" && optionRecord.name.trim()) ||
+                            null;
+                        if (!label)
+                            continue;
+                        const normalizedRecord = { label };
+                        const id = (typeof optionRecord.id === "string" && optionRecord.id.trim()) ||
+                            (typeof optionRecord.option_id === "string" && optionRecord.option_id.trim()) ||
+                            null;
+                        if (id)
+                            normalizedRecord.id = id;
+                        const description = (typeof optionRecord.description === "string" && optionRecord.description.trim()) ||
+                            null;
+                        if (description)
+                            normalizedRecord.description = description;
+                        const consequences = (typeof optionRecord.consequences === "string" && optionRecord.consequences.trim()) ||
+                            (typeof optionRecord.impact === "string" && optionRecord.impact.trim()) ||
+                            null;
+                        if (consequences)
+                            normalizedRecord.consequences = consequences;
+                        const impliedStatusRaw = typeof optionRecord.implied_status === "string"
+                            ? optionRecord.implied_status
+                            : typeof optionRecord.status === "string"
+                                ? optionRecord.status
+                                : null;
+                        if (impliedStatusRaw) {
+                            const implied = impliedStatusRaw.trim().toLowerCase();
+                            if (implied === "approved" ||
+                                implied === "declined" ||
+                                implied === "cancelled" ||
+                                implied === "rejected") {
+                                normalizedRecord.implied_status = implied;
+                            }
+                        }
+                        const actionType = normalizeDecisionActionType(optionRecord.action_type ?? optionRecord.type ?? optionRecord.verb ?? optionRecord.action);
+                        if (actionType)
+                            normalizedRecord.action_type = actionType;
+                        if (optionRecord.requires_note === true ||
+                            optionRecord.requiresNote === true ||
+                            optionRecord.note_required === true) {
+                            normalizedRecord.requires_note = true;
+                        }
+                        normalized.push(normalizedRecord);
+                    }
+                    return normalized.slice(0, 8);
+                };
                 const allDecisions = Array.isArray(parsed?.decisions_needed)
                     ? (parsed?.decisions_needed ?? [])
                         .filter((item) => Boolean(item && typeof item.question === "string" && item.question.trim()))
@@ -2115,9 +2385,7 @@ export function createAutoContinueEngine(deps) {
                         title: normalizedQuestion,
                         summary: decision.summary ?? parsed?.summary ?? null,
                         urgency: decision.urgency ?? "high",
-                        options: Array.isArray(decision.options)
-                            ? decision.options.filter((opt) => typeof opt === "string" && opt.trim())
-                            : [],
+                        options: normalizeDecisionOptions(decision.options),
                         blocking: isBlocking,
                         decisionType: isBlocking
                             ? "autopilot_blocking_decision"
@@ -2511,11 +2779,7 @@ export function createAutoContinueEngine(deps) {
                             title: fallbackDecisionTitle,
                             summary: fallbackDecisionSummary,
                             urgency: "high",
-                            options: [
-                                "Retry this workstream slice",
-                                "Pause autopilot and investigate",
-                                "Skip this workstream for now",
-                            ],
+                            options: defaultInterventionDecisionOptions(),
                             blocking: true,
                             decisionType: looksLikeNoOutcome
                                 ? "autopilot_completed_without_outcome"
@@ -2597,11 +2861,7 @@ export function createAutoContinueEngine(deps) {
                         title: attentionTitle,
                         summary: attentionSummary,
                         urgency: "high",
-                        options: [
-                            "Retry this workstream slice",
-                            "Pause autopilot and investigate",
-                            "Skip this workstream for now",
-                        ],
+                        options: defaultInterventionDecisionOptions(),
                         blocking: true,
                         decisionType: completionHadNoOutcome
                             ? "autopilot_completed_without_outcome"
@@ -3609,16 +3869,27 @@ export function createAutoContinueEngine(deps) {
         const logsDir = join(getOrgxPluginConfigDir(), AUTO_CONTINUE_SLICE_LOG_DIRNAME);
         const logPath = join(logsDir, `${sliceRunId}.log`);
         const outputPath = join(logsDir, `${sliceRunId}.output.json`);
-        const configuredWorkerCwd = (process.env.ORGX_AUTOPILOT_CWD ?? "").trim();
+        const workerEnvOverrides = run.workerEnvOverrides ?? defaultWorkerEnvOverrides;
+        const configuredWorkerCwd = (workerEnvOverrides?.ORGX_AUTOPILOT_CWD ??
+            process.env.ORGX_AUTOPILOT_CWD ??
+            "").trim();
         let workerCwd = configuredWorkerCwd || resolveAutopilotDefaultCwd(__filename);
         // LaunchAgents sometimes start with cwd="/". Fall back to plugin root (or home if unresolved).
         if (!workerCwd || workerCwd === "/") {
             workerCwd = resolveAutopilotDefaultCwd(__filename);
         }
         const sliceAgent = resolveOrgxAgentForDomain(executionPolicy.domain);
-        const workerKind = (process.env.ORGX_AUTOPILOT_WORKER_KIND ?? "").trim().toLowerCase();
+        const workerKind = (workerEnvOverrides?.ORGX_AUTOPILOT_WORKER_KIND ??
+            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 executorRaw = (workerEnvOverrides?.ORGX_AUTOPILOT_EXECUTOR ??
+            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;
@@ -3643,6 +3914,7 @@ export function createAutoContinueEngine(deps) {
             outputSchemaPath: schemaPath,
             resumeSessionId: resumedFromSessionId,
             env: {
+                ...(workerEnvOverrides ?? {}),
                 ORGX_SOURCE_CLIENT: executorSourceClient,
                 ORGX_RUN_ID: sliceRunId,
                 ORGX_CORRELATION_ID: sliceRunId,
@@ -3820,12 +4092,6 @@ export function createAutoContinueEngine(deps) {
         // Clear stale errors when a new slice dispatches successfully.
         run.lastError = null;
         run.updatedAt = now;
-        try {
-            await client.updateEntity("initiative", run.initiativeId, { status: "active" });
-        }
-        catch {
-            // best effort
-        }
         try {
             await updateInitiativeAutoContinueState({
                 initiativeId: run.initiativeId,
@@ -3918,6 +4184,7 @@ export function createAutoContinueEngine(deps) {
         const sourceEvent = (input.event ?? "").trim() || null;
         const requestedByAgentId = (input.requestedByAgentId ?? "").trim() || null;
         const requestedByAgentName = (input.requestedByAgentName ?? "").trim() || null;
+        const autoFixWorkerEnv = captureAutopilotWorkerEnv();
         const providedGraceMs = typeof input.graceMs === "number" && Number.isFinite(input.graceMs)
             ? Math.floor(input.graceMs)
             : null;
@@ -4093,6 +4360,7 @@ export function createAutoContinueEngine(deps) {
                 null;
             const dispatchRun = await startAutoContinueRun({
                 initiativeId,
+                workspaceId: latestRun?.workspaceId ?? null,
                 agentId: dispatchAgentId,
                 agentName: dispatchAgentName,
                 // Auto-fix retries should follow current defaults unless an operator explicitly
@@ -4104,6 +4372,7 @@ export function createAutoContinueEngine(deps) {
                 parallelMode: latestRun?.parallelMode ?? "iwmt",
                 stopAfterSlice: true,
                 ignoreSpawnGuardRateLimit: latestRun?.ignoreSpawnGuardRateLimit ?? false,
+                workerEnvOverrides: autoFixWorkerEnv,
             });
             await tickAutoContinueRun(dispatchRun);
             await emitActivitySafe({
@@ -4198,11 +4467,15 @@ export function createAutoContinueEngine(deps) {
     }
     async function startAutoContinueRun(input) {
         const now = new Date().toISOString();
+        const nextWorkerEnvOverrides = input.workerEnvOverrides && typeof input.workerEnvOverrides === "object"
+            ? { ...input.workerEnvOverrides }
+            : { ...defaultWorkerEnvOverrides };
         const existing = autoContinueRuns.get(input.initiativeId) ?? null;
         const existingIsLive = existing?.status === RunStatus.RUNNING || existing?.status === RunStatus.STOPPING;
         const run = existing ??
             {
                 initiativeId: input.initiativeId,
+                workspaceId: null,
                 agentId: input.agentId,
                 agentName: input.agentName ?? null,
                 includeVerification: false,
@@ -4230,8 +4503,14 @@ export function createAutoContinueEngine(deps) {
                 activeTaskId: null,
                 activeRunId: null,
                 activeTaskTokenEstimate: null,
+                workerEnvOverrides: null,
+                lastInitiativeStatus: null,
             };
         ensureRunInternals(run);
+        run.workspaceId =
+            typeof input.workspaceId === "string" && input.workspaceId.trim().length > 0
+                ? input.workspaceId.trim()
+                : run.workspaceId;
         run.agentId = input.agentId;
         run.agentName =
             typeof input.agentName === "string" && input.agentName.trim().length > 0
@@ -4244,6 +4523,7 @@ export function createAutoContinueEngine(deps) {
         run.stopAfterSlice = Boolean(input.stopAfterSlice);
         run.ignoreSpawnGuardRateLimit = Boolean(input.ignoreSpawnGuardRateLimit);
         run.scope = input.scope ?? "task";
+        run.workerEnvOverrides = nextWorkerEnvOverrides;
         const hasExplicitTokenBudgetInput = input.tokenBudget !== null &&
             input.tokenBudget !== undefined &&
             !(typeof input.tokenBudget === "string" && input.tokenBudget.trim().length === 0);
@@ -4280,11 +4560,6 @@ export function createAutoContinueEngine(deps) {
         }
         syncLegacyRunPointers(run);
         autoContinueRuns.set(input.initiativeId, run);
-        void client
-            .updateEntity("initiative", input.initiativeId, { status: "active" })
-            .catch(() => {
-            // best effort
-        });
         void updateInitiativeAutoContinueState({
             initiativeId: input.initiativeId,
             run,
@@ -4343,7 +4618,7 @@ export function createAutoContinueEngine(deps) {
                         old_state: LaneState.IDLE,
                         new_state: LaneState.RUNNING,
                         reason: "started",
-                        workspace_id: run.allowedWorkstreamIds?.[0] ?? null,
+                        workspace_id: run.workspaceId ?? null,
                     },
                 });
             }
@@ -4470,6 +4745,7 @@ export function createAutoContinueEngine(deps) {
         getAutoContinueLaneForWorkstream,
         scheduleAutoFixForWorkstream,
         startAutoContinueRun,
+        restoreAutoContinueRun,
         skipCurrentWorkstream,
         getCanonicalAutopilotState,
         // Session store (for resume support)

package/dist/http/helpers/autopilot-runtime.js

@@ -199,7 +199,11 @@ export function createAutopilotRuntime(deps) {
     function spawnCodexSliceWorker(input) {
         ensurePrivateDirForFile(input.logPath);
         ensurePrivateDirForFile(input.outputPath);
-        const workerKind = (process.env.ORGX_AUTOPILOT_WORKER_KIND ?? "").trim().toLowerCase();
+        const workerKind = (input.env.ORGX_AUTOPILOT_WORKER_KIND ??
+            process.env.ORGX_AUTOPILOT_WORKER_KIND ??
+            "")
+            .trim()
+            .toLowerCase();
         if (workerKind === "mock") {
             const scriptPath = resolve(dirname(deps.filename), "..", "..", "scripts", "mock-autopilot-slice-worker.mjs");
             const logStream = createSafeAppendStream(input.logPath);

package/dist/http/helpers/autopilot-slice-utils.js

@@ -33,7 +33,27 @@ function autopilotSliceSchema() {
     const decisionProperties = {
         question: { type: "string", minLength: 1 },
         summary: { type: ["string", "null"] },
-        options: { type: ["array", "null"], items: { type: "string" } },
+        options: {
+            type: ["array", "null"],
+            items: {
+                type: ["string", "object"],
+                minLength: 1,
+                additionalProperties: false,
+                required: ["label"],
+                properties: {
+                    id: { type: ["string", "null"] },
+                    label: { type: "string", minLength: 1 },
+                    description: { type: ["string", "null"] },
+                    consequences: { type: ["string", "null"] },
+                    implied_status: {
+                        type: ["string", "null"],
+                        enum: ["approved", "declined", "cancelled", "rejected", null],
+                    },
+                    action_type: { type: ["string", "null"] },
+                    requires_note: { type: ["boolean", "null"] },
+                },
+            },
+        },
         urgency: {
             type: ["string", "null"],
             enum: ["low", "medium", "high", "urgent", null],
@@ -859,6 +879,8 @@ export function buildSliceOutputInstructions(input) {
         "- Artifacts must be verifiable: include URLs or local paths, plus verification steps.",
         "- Include `confidence_score` for each artifact (`0` to `1`; use `null` when unknown).",
         "- If you need a human decision, include it in decisions_needed.",
+        "- Prefer structured decision options objects with: id, label, description, consequences, implied_status, action_type, requires_note.",
+        "- String options are still accepted, but structured options are required for precise decision routing.",
         "- For every decisions_needed entry, ALWAYS set blocking explicitly (true or false).",
         "- If status is blocked, needs_decision, or error: include at least one decisions_needed entry with blocking=true.",
         "- Status/decision consistency is strict:",
@@ -959,6 +981,8 @@ export function buildWorkstreamSlicePrompt(input) {
         "- Artifacts must be verifiable: include URLs or local paths, plus verification steps.",
         "- Include `confidence_score` for each artifact (`0` to `1`; use `null` when unknown).",
         "- If you need a human decision, include it in decisions_needed.",
+        "- Prefer structured decision options objects with: id, label, description, consequences, implied_status, action_type, requires_note.",
+        "- String options are still accepted, but structured options are required for precise decision routing.",
         "- For every decisions_needed entry, ALWAYS set blocking explicitly (true or false).",
         "- If status is blocked, needs_decision, or error: include at least one decisions_needed entry with blocking=true.",
         "- Status/decision consistency is strict:",

package/dist/http/helpers/decision-mapper.d.ts

@@ -5,6 +5,7 @@ type LiveDecisionOption = {
     id: string;
     label: string;
     description: string | null;
+    consequences: string | null;
     impliedStatus: LiveDecisionOptionStatus | null;
     actionType: DecisionActionType | null;
     requiresNote: boolean;