@useorgx/openclaw-plugin 0.7.20 → 0.7.24

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;
@@ -319,10 +330,7 @@ export function createAutoContinueEngine(deps) {
                             event: "question_timeout_started",
                             action_type: normalizeActivityActionType("question_timeout_started"),
                             action_phase: normalizeActivityActionPhase("review"),
-                            initiative_id: pending.initiativeId,
-                            workstream_id: pending.workstreamId,
-                            source_run_id: pending.sourceRunId,
-                            source_client: pending.sourceClient,
+                            ...(pending.eventMetadata ?? {}),
                             decision_ids: pending.decisionIds,
                             decision_count: pending.decisionIds.length,
                             decision_action: pending.action,
@@ -367,6 +375,166 @@ export function createAutoContinueEngine(deps) {
         }, delaySeconds * 1_000);
         pending.timer.unref?.();
     };
+    const pickMetadataString = (record, keys) => {
+        if (!record)
+            return null;
+        for (const key of keys) {
+            const value = record[key];
+            if (typeof value !== "string")
+                continue;
+            const trimmed = value.trim();
+            if (trimmed.length > 0)
+                return trimmed;
+        }
+        return null;
+    };
+    const pickMetadataStringArray = (record, keys) => {
+        if (!record)
+            return [];
+        for (const key of keys) {
+            const raw = record[key];
+            if (!Array.isArray(raw))
+                continue;
+            const values = raw
+                .filter((entry) => typeof entry === "string")
+                .map((entry) => entry.trim())
+                .filter(Boolean);
+            if (values.length > 0)
+                return values;
+        }
+        return [];
+    };
+    const normalizeQueuedDecisionOptions = (value, recommendedAction) => {
+        if (!Array.isArray(value))
+            return [];
+        const normalized = [];
+        const seen = new Set();
+        const recommendedLower = recommendedAction?.trim().toLowerCase() ?? null;
+        for (const rawOption of value) {
+            if (typeof rawOption === "string") {
+                const label = rawOption.trim();
+                if (!label)
+                    continue;
+                const key = label.toLowerCase();
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                normalized.push({
+                    label,
+                    recommended: recommendedLower !== null && label.toLowerCase() === recommendedLower,
+                });
+                continue;
+            }
+            if (!rawOption || typeof rawOption !== "object" || Array.isArray(rawOption))
+                continue;
+            const optionRecord = rawOption;
+            const label = pickMetadataString(optionRecord, ["label", "title", "name"]) ??
+                pickMetadataString(optionRecord, ["action", "action_type", "actionType"]);
+            if (!label)
+                continue;
+            const id = pickMetadataString(optionRecord, ["id", "option_id", "optionId"]);
+            const description = pickMetadataString(optionRecord, ["description", "summary"]);
+            const consequences = pickMetadataString(optionRecord, ["consequences", "impact"]);
+            const actionType = pickMetadataString(optionRecord, ["action_type", "actionType", "action"]);
+            const impliedStatus = pickMetadataString(optionRecord, ["implied_status", "impliedStatus", "status"]);
+            const requiresNote = optionRecord.requires_note === true ||
+                optionRecord.requiresNote === true ||
+                optionRecord.note_required === true;
+            const recommended = optionRecord.recommended === true ||
+                optionRecord.is_recommended === true ||
+                optionRecord.isRecommended === true ||
+                (recommendedLower !== null && label.toLowerCase() === recommendedLower);
+            const key = `${(id ?? "").toLowerCase()}|${label.toLowerCase()}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            normalized.push({
+                ...(id ? { id } : {}),
+                label,
+                ...(description ? { description } : {}),
+                ...(consequences ? { consequences } : {}),
+                ...(actionType ? { action_type: actionType } : {}),
+                ...(impliedStatus ? { implied_status: impliedStatus } : {}),
+                ...(requiresNote ? { requires_note: true } : {}),
+                ...(recommended ? { recommended: true } : {}),
+            });
+        }
+        return normalized.slice(0, 8);
+    };
+    const normalizeQueuedDecisionEvidence = (value) => {
+        if (!Array.isArray(value))
+            return [];
+        const normalized = [];
+        const seen = new Set();
+        for (const rawEvidence of value) {
+            if (!rawEvidence || typeof rawEvidence !== "object" || Array.isArray(rawEvidence))
+                continue;
+            const record = rawEvidence;
+            const title = pickMetadataString(record, ["title", "label", "name"]) ??
+                pickMetadataString(record, ["source_pointer", "sourcePointer", "source_url", "sourceUrl"]) ??
+                "Evidence";
+            const summary = pickMetadataString(record, ["summary", "description"]);
+            const sourceUrl = pickMetadataString(record, ["source_url", "sourceUrl", "url"]);
+            const sourcePointer = pickMetadataString(record, ["source_pointer", "sourcePointer", "path"]);
+            const evidenceType = pickMetadataString(record, ["evidence_type", "evidenceType", "type"]);
+            const confidenceRaw = record.confidence ?? record.confidence_score;
+            const confidence = typeof confidenceRaw === "number" && Number.isFinite(confidenceRaw)
+                ? Math.max(0, Math.min(1, confidenceRaw))
+                : null;
+            const key = `${title.toLowerCase()}|${sourceUrl ?? ""}|${sourcePointer ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            normalized.push({
+                title,
+                ...(summary ? { summary } : {}),
+                ...(sourceUrl ? { source_url: sourceUrl } : {}),
+                ...(sourcePointer ? { source_pointer: sourcePointer } : {}),
+                ...(evidenceType ? { evidence_type: evidenceType } : {}),
+                ...(confidence !== null ? { confidence } : {}),
+            });
+        }
+        return normalized.slice(0, 8);
+    };
+    const buildQuestionEventMetadata = (input) => {
+        const metadata = {
+            initiative_id: input.initiativeId,
+            workstream_id: input.workstreamId,
+            source_run_id: input.sourceRunId,
+            source_client: input.sourceClient,
+            decision_ids: input.decisionIds,
+            decision_count: input.decisionIds.length,
+            blocking: input.blocking,
+            decision_title: input.title,
+            decision_prompt: input.title,
+            question: input.title,
+            required_action: input.recommendedAction,
+            recommended_action: input.recommendedAction,
+            current_run_state: input.currentRunState,
+            impact_if_delayed: input.impactIfDelayed,
+            reason: input.reason,
+            decision_type: input.decisionType,
+        };
+        if (input.summary)
+            metadata.decision_summary = input.summary;
+        if (input.options.length > 0) {
+            metadata.decision_options = input.options;
+            metadata.decision_option_labels = input.options.map((option) => option.label);
+        }
+        if (input.evidenceRefs.length > 0)
+            metadata.evidence_refs = input.evidenceRefs;
+        if (input.scopeHierarchy.length > 0)
+            metadata.scope_hierarchy = input.scopeHierarchy;
+        if (input.initiativeTitle)
+            metadata.initiative_title = input.initiativeTitle;
+        if (input.workstreamTitle)
+            metadata.workstream_title = input.workstreamTitle;
+        if (input.taskTitle)
+            metadata.task_title = input.taskTitle;
+        if (input.nextActions.length > 0)
+            metadata.next_actions = input.nextActions;
+        return metadata;
+    };
     const scheduleQuestionAutoAnswer = async (input) => {
         const decisionIds = dedupeStrings(input.decisionIds
             .map((entry) => (entry ?? "").trim())
@@ -374,6 +542,28 @@ export function createAutoContinueEngine(deps) {
         if (decisionIds.length === 0)
             return;
         const policy = resolveQuestionPolicy(input.initiativeId, input.workstreamId);
+        const questionMetadata = buildQuestionEventMetadata({
+            initiativeId: input.initiativeId,
+            workstreamId: input.workstreamId,
+            sourceRunId: input.sourceRunId,
+            sourceClient: input.sourceClient,
+            decisionIds,
+            blocking: input.blocking,
+            title: input.title,
+            summary: input.summary,
+            decisionType: input.decisionType,
+            options: input.options,
+            recommendedAction: input.recommendedAction,
+            evidenceRefs: input.evidenceRefs,
+            scopeHierarchy: input.scopeHierarchy,
+            initiativeTitle: input.initiativeTitle,
+            workstreamTitle: input.workstreamTitle,
+            taskTitle: input.taskTitle,
+            nextActions: input.nextActions,
+            currentRunState: input.currentRunState,
+            impactIfDelayed: input.impactIfDelayed,
+            reason: input.reason,
+        });
         await emitActivitySafe({
             initiativeId: input.initiativeId,
             runId: input.sourceRunId,
@@ -391,13 +581,7 @@ export function createAutoContinueEngine(deps) {
                 event: "question_asked",
                 action_type: normalizeActivityActionType("question_asked"),
                 action_phase: normalizeActivityActionPhase("review"),
-                initiative_id: input.initiativeId,
-                workstream_id: input.workstreamId,
-                source_run_id: input.sourceRunId,
-                source_client: input.sourceClient,
-                decision_ids: decisionIds,
-                decision_count: decisionIds.length,
-                blocking: input.blocking,
+                ...questionMetadata,
                 question_policy_mode: policy.mode,
                 question_policy_version: policy.policyVersion,
                 timeout_seconds_applied: policy.timeoutSeconds,
@@ -423,12 +607,7 @@ export function createAutoContinueEngine(deps) {
                     event: "review_item_created",
                     action_type: normalizeActivityActionType("review_item_created"),
                     action_phase: normalizeActivityActionPhase("blocked"),
-                    initiative_id: input.initiativeId,
-                    workstream_id: input.workstreamId,
-                    source_run_id: input.sourceRunId,
-                    source_client: input.sourceClient,
-                    decision_ids: decisionIds,
-                    decision_count: decisionIds.length,
+                    ...questionMetadata,
                     blocking: true,
                     reason: "blocking_question_requires_human",
                     question_policy_mode: policy.mode,
@@ -452,11 +631,7 @@ export function createAutoContinueEngine(deps) {
                     event: "review_item_created",
                     action_type: normalizeActivityActionType("review_item_created"),
                     action_phase: normalizeActivityActionPhase("review"),
-                    initiative_id: input.initiativeId,
-                    workstream_id: input.workstreamId,
-                    source_run_id: input.sourceRunId,
-                    source_client: input.sourceClient,
-                    decision_ids: decisionIds,
+                    ...questionMetadata,
                     reason: "policy_disabled",
                     question_policy_mode: policy.mode,
                     question_policy_version: policy.policyVersion,
@@ -476,6 +651,7 @@ export function createAutoContinueEngine(deps) {
             existing.policyVersion = policy.policyVersion;
             existing.timeoutSeconds = policy.timeoutSeconds;
             existing.dueAt = new Date(dueAtEpoch).toISOString();
+            existing.eventMetadata = questionMetadata;
             armQuestionAutoAnswerTimer(key, existing, policy.timeoutSeconds);
             await emitActivitySafe({
                 initiativeId: input.initiativeId,
@@ -490,10 +666,7 @@ export function createAutoContinueEngine(deps) {
                     event: "question_timeout_started",
                     action_type: normalizeActivityActionType("question_timeout_started"),
                     action_phase: normalizeActivityActionPhase("review"),
-                    initiative_id: input.initiativeId,
-                    workstream_id: input.workstreamId,
-                    source_run_id: input.sourceRunId,
-                    source_client: input.sourceClient,
+                    ...questionMetadata,
                     decision_ids: existing.decisionIds,
                     decision_count: existing.decisionIds.length,
                     decision_action: existing.action,
@@ -519,6 +692,7 @@ export function createAutoContinueEngine(deps) {
             dueAt: new Date(dueAtEpoch).toISOString(),
             timer: null,
             decisionIds,
+            eventMetadata: questionMetadata,
         };
         armQuestionAutoAnswerTimer(key, pending, policy.timeoutSeconds);
         pendingQuestionAutoAnswerByScope.set(key, pending);
@@ -535,12 +709,7 @@ export function createAutoContinueEngine(deps) {
                 event: "question_timeout_started",
                 action_type: normalizeActivityActionType("question_timeout_started"),
                 action_phase: normalizeActivityActionPhase("review"),
-                initiative_id: input.initiativeId,
-                workstream_id: input.workstreamId,
-                source_run_id: input.sourceRunId,
-                source_client: input.sourceClient,
-                decision_ids: decisionIds,
-                decision_count: decisionIds.length,
+                ...questionMetadata,
                 decision_action: policy.action,
                 timeout_seconds_applied: policy.timeoutSeconds,
                 question_policy_mode: policy.mode,
@@ -692,6 +861,34 @@ export function createAutoContinueEngine(deps) {
             inferredStreamId ??
             linkedSlice?.workstreamId ??
             null);
+        const initiativeTitle = pickMetadataString(metadataBase, ["initiative_title", "initiativeTitle"]) ??
+            pickMetadataString(sourceRefBase, ["initiative_title", "initiativeTitle"]) ??
+            null;
+        const workstreamTitle = pickMetadataString(metadataBase, ["workstream_title", "workstreamTitle"]) ??
+            pickMetadataString(sourceRefBase, ["workstream_title", "workstreamTitle"]) ??
+            linkedSlice?.workstreamTitle ??
+            null;
+        const taskTitle = pickMetadataString(metadataBase, ["task_title", "taskTitle", "dispatch_task_title"]) ??
+            null;
+        const recommendedAction = typeof normalizedInput.recommendedAction === "string" && normalizedInput.recommendedAction.trim().length > 0
+            ? normalizedInput.recommendedAction.trim()
+            : pickMetadataString(metadataBase, ["recommended_action", "recommendedAction"]);
+        const decisionOptions = normalizeQueuedDecisionOptions(normalizedInput.options ?? [], recommendedAction);
+        const decisionEvidenceRefs = normalizeQueuedDecisionEvidence(normalizedInput.evidenceRefs ?? []);
+        const scopeHierarchy = [
+            ...pickMetadataStringArray(metadataBase, ["scope_hierarchy", "scopeHierarchy"]),
+            ...pickMetadataStringArray(sourceRefBase, ["scope_hierarchy", "scopeHierarchy"]),
+            ...[initiativeTitle, workstreamTitle, taskTitle].filter((entry) => typeof entry === "string" && entry.trim().length > 0),
+        ].filter((entry, index, source) => source.indexOf(entry) === index);
+        const nextActions = [
+            ...pickMetadataStringArray(metadataBase, ["next_actions", "nextActions"]),
+            ...(recommendedAction ? [recommendedAction] : []),
+        ].filter((entry, index, source) => source.indexOf(entry) === index);
+        const currentRunState = pickMetadataString(metadataBase, ["current_run_state", "currentRunState", "runtime_state", "runtimeState", "parsed_status", "parsedStatus"]) ??
+            linkedSlice?.status ??
+            null;
+        const impactIfDelayed = pickMetadataString(metadataBase, ["impact_if_delayed", "impactIfDelayed"]) ??
+            null;
         const result = await requestDecisionSafe(normalizedInput);
         if (typeof result === "boolean") {
             return { queued: result, decisionIds: [] };
@@ -719,6 +916,23 @@ export function createAutoContinueEngine(deps) {
                     sourceClient,
                     decisionIds,
                     blocking: Boolean(normalizedInput.blocking),
+                    title: normalizedInput.title,
+                    summary: typeof normalizedInput.summary === "string" && normalizedInput.summary.trim().length > 0
+                        ? normalizedInput.summary.trim()
+                        : null,
+                    decisionType: typeof normalizedInput.decisionType === "string" && normalizedInput.decisionType.trim().length > 0
+                        ? normalizedInput.decisionType.trim()
+                        : null,
+                    options: decisionOptions,
+                    recommendedAction,
+                    evidenceRefs: decisionEvidenceRefs,
+                    scopeHierarchy,
+                    initiativeTitle,
+                    workstreamTitle,
+                    taskTitle,
+                    nextActions,
+                    currentRunState,
+                    impactIfDelayed,
                     reason: typeof normalizedInput.conflictSource === "string"
                         ? normalizedInput.conflictSource
                         : null,
@@ -731,6 +945,35 @@ 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();
     /**
@@ -780,6 +1023,9 @@ export function createAutoContinueEngine(deps) {
             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),
@@ -817,6 +1063,10 @@ export function createAutoContinueEngine(deps) {
                 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);
@@ -1024,6 +1274,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 });
@@ -1211,6 +1493,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();
@@ -1485,6 +1818,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,
@@ -1510,6 +1844,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;
@@ -1524,6 +1859,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;
@@ -1553,18 +1889,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,
@@ -1685,7 +2009,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,
                 },
             });
         }
@@ -1843,11 +2167,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,
@@ -1965,11 +2285,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,
@@ -2067,6 +2383,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()))
@@ -2210,9 +2588,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"
@@ -2606,11 +2982,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"
@@ -2692,11 +3064,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"
@@ -3704,16 +4072,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;
@@ -3738,6 +4117,7 @@ export function createAutoContinueEngine(deps) {
             outputSchemaPath: schemaPath,
             resumeSessionId: resumedFromSessionId,
             env: {
+                ...(workerEnvOverrides ?? {}),
                 ORGX_SOURCE_CLIENT: executorSourceClient,
                 ORGX_RUN_ID: sliceRunId,
                 ORGX_CORRELATION_ID: sliceRunId,
@@ -3915,12 +4295,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,
@@ -4013,6 +4387,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;
@@ -4188,6 +4563,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
@@ -4199,6 +4575,7 @@ export function createAutoContinueEngine(deps) {
                 parallelMode: latestRun?.parallelMode ?? "iwmt",
                 stopAfterSlice: true,
                 ignoreSpawnGuardRateLimit: latestRun?.ignoreSpawnGuardRateLimit ?? false,
+                workerEnvOverrides: autoFixWorkerEnv,
             });
             await tickAutoContinueRun(dispatchRun);
             await emitActivitySafe({
@@ -4293,11 +4670,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,
@@ -4325,8 +4706,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
@@ -4339,6 +4726,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);
@@ -4375,11 +4763,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,
@@ -4438,7 +4821,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,
                     },
                 });
             }