@useorgx/openclaw-plugin 0.7.8 → 0.7.15

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

@@ -9,11 +9,13 @@ import { appendTeamCompletion } from "../../team-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 { 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 { createAutopilotRuntime } from "./autopilot-runtime.js";
-import { buildScopeDirective, buildSliceOutputInstructions, buildWorkstreamSlicePrompt, createCodexBinResolver, ensureAutopilotSliceSchemaPath, fileUpdatedAtEpochMs, parseSliceResult, readFileTailSafe, readSliceOutputFile, } from "./autopilot-slice-utils.js";
+import { buildScopeDirective, buildSliceOutputInstructions, buildWorkstreamSlicePrompt, createCodexBinResolver, ensureAutopilotSliceSchemaPath, extractSessionIdFromLog, extractSessionIdFromOutput, fileUpdatedAtEpochMs, parseSliceResult, readFileTailSafe, readSliceOutputFile, } from "./autopilot-slice-utils.js";
 import { pickString } from "./value-utils.js";
+import { LaneState, RunStatus, } from "./queue-constants.js";
 function resolveAutopilotDefaultCwd(filename) {
     let cursor = dirname(filename);
     for (let i = 0; i < 12; i += 1) {
@@ -63,6 +65,35 @@ export function createAutoContinueEngine(deps) {
         ? "reject"
         : "approve";
     const autoContinueSliceRuns = new Map();
+    const workstreamSessionStore = new Map();
+    function sessionResumeEnabled() {
+        const raw = (process.env.ORGX_AUTOPILOT_SESSION_RESUME ?? "").trim().toLowerCase();
+        if (!raw)
+            return false;
+        return !(raw === "0" || raw === "false" || raw === "no" || raw === "off");
+    }
+    function setWorkstreamSession(workstreamId, entry) {
+        workstreamSessionStore.set(workstreamId, entry);
+    }
+    function getWorkstreamSession(workstreamId) {
+        return workstreamSessionStore.get(workstreamId) ?? null;
+    }
+    function clearWorkstreamSession(initiativeId) {
+        for (const [key, entry] of workstreamSessionStore.entries()) {
+            if (entry.initiativeId === initiativeId) {
+                workstreamSessionStore.delete(key);
+            }
+        }
+    }
+    function listWorkstreamSessions(initiativeId) {
+        const results = [];
+        for (const entry of workstreamSessionStore.values()) {
+            if (!initiativeId || entry.initiativeId === initiativeId) {
+                results.push(entry);
+            }
+        }
+        return results;
+    }
     /** Spread into any metadata object to flag mock-worker activity. */
     function mockMeta(slice) {
         return slice.isMockWorker ? { mock: true } : {};
@@ -999,7 +1030,7 @@ export function createAutoContinueEngine(deps) {
         }
         const existing = run.laneByWorkstreamId[normalizedWorkstreamId] ?? {
             workstreamId: normalizedWorkstreamId,
-            state: "idle",
+            state: LaneState.IDLE,
             activeRunId: null,
             activeTaskIds: [],
             blockedReason: null,
@@ -1051,12 +1082,12 @@ export function createAutoContinueEngine(deps) {
             if (lane && lane.activeRunId === sliceRunId) {
                 setLaneState(run, {
                     workstreamId: normalizedWorkstreamId,
-                    state: lane.state === "blocked" ? "blocked" : "idle",
+                    state: lane.state === LaneState.BLOCKED ? "blocked" : "idle",
                     activeRunId: null,
                     activeTaskIds: [],
                     retryAt: lane.retryAt ?? null,
                     waitingOnWorkstreamIds: lane.waitingOnWorkstreamIds ?? [],
-                    blockedReason: lane.state === "blocked" ? lane.blockedReason : null,
+                    blockedReason: lane.state === LaneState.BLOCKED ? lane.blockedReason : null,
                 });
             }
         }
@@ -1359,7 +1390,7 @@ export function createAutoContinueEngine(deps) {
             updated_at: lane.updatedAt,
         }));
         const patch = {
-            auto_continue_enabled: input.run.status === "running" || input.run.status === "stopping",
+            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,
             auto_continue_started_at: input.run.startedAt,
@@ -1398,7 +1429,7 @@ export function createAutoContinueEngine(deps) {
         const now = new Date().toISOString();
         ensureRunInternals(input.run);
         const activeRunIds = listActiveSliceRunIds(input.run);
-        input.run.status = "stopped";
+        input.run.status = RunStatus.STOPPED;
         input.run.stopReason = input.reason;
         input.run.stoppedAt = now;
         input.run.updatedAt = now;
@@ -1412,7 +1443,7 @@ export function createAutoContinueEngine(deps) {
             if (lane.activeRunId || lane.activeTaskIds.length > 0) {
                 setLaneState(input.run, {
                     workstreamId: lane.workstreamId,
-                    state: lane.state === "blocked" ? "blocked" : "idle",
+                    state: lane.state === LaneState.BLOCKED ? "blocked" : "idle",
                     activeRunId: null,
                     activeTaskIds: [],
                 });
@@ -1542,7 +1573,7 @@ export function createAutoContinueEngine(deps) {
                         event: "autopilot_transition",
                         actionType: "run_state_transition",
                     }),
-                    old_state: "running",
+                    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,
@@ -1700,8 +1731,8 @@ export function createAutoContinueEngine(deps) {
                             const decisionResult = await requestDecisionQueued({
                                 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.`,
+                                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",
@@ -1744,7 +1775,7 @@ export function createAutoContinueEngine(deps) {
                             });
                             setLaneState(run, {
                                 workstreamId: slice.workstreamId,
-                                state: "blocked",
+                                state: LaneState.BLOCKED,
                                 activeRunId: null,
                                 activeTaskIds: [],
                                 blockedReason: slice.lastError,
@@ -1786,6 +1817,9 @@ export function createAutoContinueEngine(deps) {
                             clearAutoContinueSliceTransientState(slice.runId);
                             const event = killDecision.kind === "timeout" ? "autopilot_slice_timeout" : "autopilot_slice_log_stall";
                             const humanLabel = killDecision.kind === "timeout" ? "timed out" : "stalled";
+                            const stallDecisionTitle = killDecision.kind === "timeout"
+                                ? `Autopilot slice timed out: ${slice.workstreamTitle ?? slice.workstreamId}`
+                                : `Autopilot slice stalled: ${slice.workstreamTitle ?? slice.workstreamId}`;
                             await emitActivitySafe({
                                 initiativeId: run.initiativeId,
                                 runId: slice.runId,
@@ -1819,8 +1853,8 @@ export function createAutoContinueEngine(deps) {
                             const decisionResult = await requestDecisionQueued({
                                 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.",
+                                title: stallDecisionTitle,
+                                summary: humanizeSliceFailureSummary(slice.lastError ?? `Autopilot slice ${humanLabel}`),
                                 urgency: "high",
                                 options: [
                                     "Retry this workstream slice",
@@ -1872,7 +1906,7 @@ export function createAutoContinueEngine(deps) {
                             });
                             setLaneState(run, {
                                 workstreamId: slice.workstreamId,
-                                state: "blocked",
+                                state: LaneState.BLOCKED,
                                 activeRunId: null,
                                 activeTaskIds: [],
                                 blockedReason: slice.lastError,
@@ -1904,6 +1938,25 @@ export function createAutoContinueEngine(deps) {
                 const raw = readSliceOutputFile(slice.outputPath);
                 const parsed = raw ? parseSliceResult(raw) : null;
                 const parsedStatus = parsed?.status ?? "error";
+                // Session capture: extract CLI session ID from output or log for future resume.
+                if (sessionResumeEnabled()) {
+                    const outputSessionId = raw ? extractSessionIdFromOutput(raw, slice.sourceClient) : null;
+                    const logSessionId = outputSessionId
+                        ? null
+                        : extractSessionIdFromLog(readFileTailSafe(slice.logPath, 32_000), slice.sourceClient);
+                    const capturedSessionId = outputSessionId ?? logSessionId ?? null;
+                    if (capturedSessionId) {
+                        slice.cliSessionId = capturedSessionId;
+                        setWorkstreamSession(slice.workstreamId, {
+                            sessionId: capturedSessionId,
+                            workstreamId: slice.workstreamId,
+                            initiativeId: slice.initiativeId,
+                            sourceClient: slice.sourceClient,
+                            capturedAt: new Date().toISOString(),
+                            fromRunId: slice.runId,
+                        });
+                    }
+                }
                 const defaultDecisionBlocking = parsedStatus === "completed" ? false : true;
                 const allDecisions = Array.isArray(parsed?.decisions_needed)
                     ? (parsed?.decisions_needed ?? [])
@@ -1919,13 +1972,25 @@ export function createAutoContinueEngine(deps) {
                 const decisions = allDecisions.filter((item) => !isParserSyntheticFallbackDecision(item));
                 const normalizedBlockingDecisionCount = allDecisions.filter((item) => typeof item.blocking === "boolean" ? item.blocking : defaultDecisionBlocking).length;
                 const normalizedNonBlockingDecisionCount = Math.max(0, allDecisions.length - normalizedBlockingDecisionCount);
-                const effectiveParsedStatus = parsedStatus === "completed" && normalizedBlockingDecisionCount > 0
+                const operationalParsedStatus = parsedStatus === "completed" && normalizedBlockingDecisionCount > 0
                     ? "needs_decision"
                     : parsedStatus;
+                const parsedSummarySignal = String(parsed?.summary ?? "").toLowerCase();
+                const parsedLooksLikeNoOutcomeCompletion = operationalParsedStatus === "error" &&
+                    (parsedSummarySignal.includes("without verifiable outcomes") ||
+                        parsedSummarySignal.includes("without output") ||
+                        parsedSummarySignal.includes("without artifacts") ||
+                        parsedSummarySignal.includes("did not report artifacts") ||
+                        (parsedSummarySignal.includes("did not report") &&
+                            parsedSummarySignal.includes("status updates")) ||
+                        parsedSummarySignal.includes("produced nothing"));
+                const reportedParsedStatus = parsedLooksLikeNoOutcomeCompletion
+                    ? "completed"
+                    : operationalParsedStatus;
                 slice.status =
-                    effectiveParsedStatus === "completed"
+                    operationalParsedStatus === "completed"
                         ? "completed"
-                        : effectiveParsedStatus === "blocked" || effectiveParsedStatus === "needs_decision"
+                        : operationalParsedStatus === "blocked" || operationalParsedStatus === "needs_decision"
                             ? "blocked"
                             : "error";
                 slice.finishedAt = now;
@@ -2005,7 +2070,7 @@ export function createAutoContinueEngine(deps) {
                     : [];
                 const resultEnvelope = {
                     summary: userSummary,
-                    parsed_status: effectiveParsedStatus,
+                    parsed_status: reportedParsedStatus,
                     task_updates: taskUpdates,
                     milestone_updates: milestoneUpdates,
                     next_actions: nextActions,
@@ -2196,7 +2261,7 @@ export function createAutoContinueEngine(deps) {
                             correlation_id: slice.runId,
                             requested_by_agent_id: run.agentId,
                             requested_by_agent_name: run.agentName,
-                            status: effectiveParsedStatus,
+                            status: reportedParsedStatus,
                             artifacts: artifacts.length,
                             decisions: allDecisions.length,
                             blocking_decisions: normalizedBlockingDecisionCount,
@@ -2240,7 +2305,7 @@ export function createAutoContinueEngine(deps) {
                             userSummary,
                             event: "autopilot_slice_handoff",
                             extra: {
-                                parsed_status: effectiveParsedStatus,
+                                parsed_status: reportedParsedStatus,
                                 artifacts: artifacts.length,
                                 decisions: decisions.length,
                                 decision_ids: decisionIds,
@@ -2286,7 +2351,7 @@ export function createAutoContinueEngine(deps) {
                         behavior_config_hash: slice.behaviorConfigHash,
                         policy_source: slice.behaviorPolicySource,
                         behavior_automation_level: slice.behaviorAutomationLevel,
-                        parsed_status: effectiveParsedStatus,
+                        parsed_status: reportedParsedStatus,
                         has_output: Boolean(parsed),
                         artifacts: artifacts.length,
                         decisions: allDecisions.length,
@@ -2295,7 +2360,7 @@ export function createAutoContinueEngine(deps) {
                         decision_ids: decisionIds,
                         blocking_decision_ids: Array.from(new Set(blockingDecisionIds)),
                         non_blocking_decision_ids: Array.from(new Set(nonBlockingDecisionIds)),
-                        decision_required: blockingDecisionQueued || effectiveParsedStatus === "needs_decision",
+                        decision_required: blockingDecisionQueued || operationalParsedStatus === "needs_decision",
                         status_updates_applied: statusUpdateResult.applied,
                         status_updates_buffered: statusUpdateResult.buffered,
                         reported_skill_evidence_count: skillEvidence.length,
@@ -2333,19 +2398,63 @@ export function createAutoContinueEngine(deps) {
                         queued: false,
                         decisionIds: [],
                     };
+                    const fallbackRawError = parsed?.summary ??
+                        slice.lastError ??
+                        (slice.status === "blocked"
+                            ? "Execution is blocked and needs intervention."
+                            : "Agent process exited without a valid output contract.");
+                    const fallbackHumanized = humanizeSliceFailure(fallbackRawError);
+                    const fallbackErrorSignal = [
+                        parsed?.summary ?? null,
+                        slice.lastError ?? null,
+                        fallbackRawError,
+                    ]
+                        .filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+                        .join(" ")
+                        .toLowerCase();
+                    const looksLikeNoOutcome = fallbackErrorSignal.includes("without verifiable outcomes") ||
+                        fallbackErrorSignal.includes("without output") ||
+                        fallbackErrorSignal.includes("without artifacts") ||
+                        fallbackErrorSignal.includes("did not report artifacts") ||
+                        (fallbackErrorSignal.includes("did not report") &&
+                            fallbackErrorSignal.includes("status updates")) ||
+                        fallbackErrorSignal.includes("produced nothing");
+                    const looksLikeStall = fallbackErrorSignal.includes("stall") ||
+                        fallbackErrorSignal.includes("stopped making progress");
+                    const looksLikeTimeout = fallbackErrorSignal.includes("timeout") ||
+                        fallbackErrorSignal.includes("timed out") ||
+                        fallbackErrorSignal.includes("ran out of time");
+                    const blockedLike = slice.status === "blocked" ||
+                        looksLikeNoOutcome ||
+                        looksLikeStall ||
+                        looksLikeTimeout;
+                    const decisionConflictSource = looksLikeNoOutcome
+                        ? "slice_completed_without_outcome"
+                        : looksLikeTimeout
+                            ? "slice_timeout"
+                            : looksLikeStall
+                                ? "slice_stall_no_output"
+                                : blockedLike
+                                    ? "slice_missing_blocking_decision"
+                                    : "slice_invalid_output";
+                    const fallbackDecisionTitle = looksLikeNoOutcome
+                        ? `Autopilot slice needs verification: ${slice.workstreamTitle ?? slice.workstreamId}`
+                        : looksLikeStall
+                            ? `Autopilot slice stalled: ${slice.workstreamTitle ?? slice.workstreamId}`
+                            : looksLikeTimeout
+                                ? `Autopilot slice timed out: ${slice.workstreamTitle ?? slice.workstreamId}`
+                                : blockedLike
+                                    ? `Autopilot slice blocked: ${slice.workstreamTitle ?? slice.workstreamId}`
+                                    : `Autopilot slice failed: ${slice.workstreamTitle ?? slice.workstreamId}`;
+                    const fallbackDecisionSummary = looksLikeNoOutcome
+                        ? "The slice reported completion but did not produce artifacts or status updates. Decide whether to retry, request stronger output, or mark tasks manually."
+                        : fallbackHumanized.explanation;
                     if (!blockingDecisionQueued) {
-                        const blockedLike = slice.status === "blocked";
                         fallbackDecisionResult = await requestDecisionQueued({
                             initiativeId: run.initiativeId,
                             correlationId: slice.runId,
-                            title: blockedLike
-                                ? `Autopilot slice blocked: ${slice.workstreamTitle ?? slice.workstreamId}`
-                                : `Autopilot slice failed: ${slice.workstreamTitle ?? slice.workstreamId}`,
-                            summary: parsed?.summary ??
-                                slice.lastError ??
-                                (blockedLike
-                                    ? "The slice reported a blocked/decision-required state without a blocking decision payload. Review logs/output and decide whether to retry, unblock, or skip."
-                                    : "The slice failed without producing a valid output contract. Review logs/output and decide whether to retry or pause autopilot."),
+                            title: fallbackDecisionTitle,
+                            summary: fallbackDecisionSummary,
                             urgency: "high",
                             options: [
                                 "Retry this workstream slice",
@@ -2353,18 +2462,20 @@ export function createAutoContinueEngine(deps) {
                                 "Skip this workstream for now",
                             ],
                             blocking: true,
-                            decisionType: blockedLike ? "autopilot_blocked_without_decision" : "autopilot_failure",
+                            decisionType: looksLikeNoOutcome
+                                ? "autopilot_completed_without_outcome"
+                                : blockedLike
+                                    ? "autopilot_blocked_without_decision"
+                                    : "autopilot_failure",
                             workstreamId: slice.workstreamId,
                             agentId: slice.agentId,
                             sourceSystem: "orgx-autopilot",
-                            conflictSource: blockedLike
-                                ? "slice_missing_blocking_decision"
-                                : "slice_invalid_output",
+                            conflictSource: decisionConflictSource,
                             dedupeKey: [
                                 "autopilot",
                                 run.initiativeId,
                                 slice.workstreamId,
-                                blockedLike ? "slice_missing_blocking_decision" : "slice_invalid_output",
+                                decisionConflictSource,
                             ].join(":"),
                             recommendedAction: nextActions[0] ??
                                 "Review the output contract and logs, then retry or pause autopilot until the blocker is resolved.",
@@ -2372,19 +2483,17 @@ export function createAutoContinueEngine(deps) {
                             sourceRef: {
                                 run_id: slice.runId,
                                 workstream_id: slice.workstreamId,
-                                parsed_status: effectiveParsedStatus,
+                                parsed_status: reportedParsedStatus,
                             },
                             evidenceRefs: [
                                 {
                                     evidence_type: "slice_output_validation",
                                     title: "Slice output requires fallback decision",
-                                    summary: parsed?.summary ??
-                                        slice.lastError ??
-                                        "Slice did not provide a blocking decision payload.",
+                                    summary: fallbackDecisionSummary,
                                     source_pointer: slice.outputPath,
                                     payload: {
                                         log_path: slice.logPath,
-                                        parsed_status: effectiveParsedStatus,
+                                        parsed_status: reportedParsedStatus,
                                     },
                                 },
                                 ...artifactEvidenceRefs,
@@ -2393,12 +2502,12 @@ export function createAutoContinueEngine(deps) {
                     }
                     setLaneState(run, {
                         workstreamId: slice.workstreamId,
-                        state: "blocked",
+                        state: LaneState.BLOCKED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason: parsed?.summary ??
                             slice.lastError ??
-                            `Slice returned status: ${effectiveParsedStatus}`,
+                            `Slice returned status: ${reportedParsedStatus}`,
                         waitingOnWorkstreamIds: [],
                         retryAt: null,
                     });
@@ -2407,10 +2516,8 @@ export function createAutoContinueEngine(deps) {
                     }
                     await stopAutoContinueRun({
                         run,
-                        reason: slice.status === "error" ? "error" : "blocked",
-                        error: parsed?.summary ??
-                            slice.lastError ??
-                            `Slice returned status: ${effectiveParsedStatus}`,
+                        reason: blockedLike ? "blocked" : "error",
+                        error: fallbackRawError,
                         decisionRequired: blockingDecisionQueued || fallbackDecisionResult.queued,
                         decisionIds: Array.from(new Set([...decisionIds, ...fallbackDecisionResult.decisionIds])),
                     });
@@ -2421,12 +2528,14 @@ export function createAutoContinueEngine(deps) {
                     decisions.length === 0 &&
                     statusUpdateResult.applied === 0;
                 if (!parsed || parsedStatus === "error" || completionHadNoOutcome) {
+                    const rawError = slice.lastError ?? (completionHadNoOutcome
+                        ? "Completed without verifiable outcomes or artifacts."
+                        : "Agent process exited without a valid output contract.");
+                    const humanized = humanizeSliceFailure(rawError);
                     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.";
+                        ? `Agent finished but produced nothing: ${slice.workstreamTitle ?? slice.workstreamId}`
+                        : `${humanized.headline}: ${slice.workstreamTitle ?? slice.workstreamId}`;
+                    const attentionSummary = humanized.explanation;
                     const decisionResult = await requestDecisionQueued({
                         initiativeId: run.initiativeId,
                         correlationId: slice.runId,
@@ -2481,7 +2590,7 @@ export function createAutoContinueEngine(deps) {
                     });
                     setLaneState(run, {
                         workstreamId: slice.workstreamId,
-                        state: "blocked",
+                        state: LaneState.BLOCKED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason: slice.lastError ??
@@ -2515,7 +2624,7 @@ export function createAutoContinueEngine(deps) {
                 });
                 setLaneState(run, {
                     workstreamId: slice.workstreamId,
-                    state: "completed",
+                    state: LaneState.COMPLETED,
                     activeRunId: null,
                     activeTaskIds: [],
                     blockedReason: null,
@@ -2593,7 +2702,7 @@ export function createAutoContinueEngine(deps) {
         }
         syncLegacyRunPointers(run);
         if (run.stopRequested) {
-            run.status = "stopping";
+            run.status = RunStatus.STOPPING;
             run.updatedAt = now;
             await stopAutoContinueRun({ run, reason: "stopped" });
             return;
@@ -2725,7 +2834,7 @@ export function createAutoContinueEngine(deps) {
             for (const [workstreamId, waitingOnWorkstreamIds] of waitingByWorkstream.entries()) {
                 setLaneState(run, {
                     workstreamId,
-                    state: "waiting_dependency",
+                    state: LaneState.WAITING_DEPENDENCY,
                     activeRunId: null,
                     activeTaskIds: [],
                     blockedReason: null,
@@ -2976,7 +3085,7 @@ export function createAutoContinueEngine(deps) {
             }
             setLaneState(run, {
                 workstreamId: selectedWorkstreamId,
-                state: "blocked",
+                state: LaneState.BLOCKED,
                 activeRunId: null,
                 activeTaskIds: [],
                 blockedReason,
@@ -3071,7 +3180,7 @@ export function createAutoContinueEngine(deps) {
             }
             setLaneState(run, {
                 workstreamId: selectedWorkstreamId,
-                state: "blocked",
+                state: LaneState.BLOCKED,
                 activeRunId: null,
                 activeTaskIds: [],
                 blockedReason,
@@ -3136,7 +3245,7 @@ export function createAutoContinueEngine(deps) {
                     });
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "rate_limited",
+                        state: LaneState.RATE_LIMITED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason,
@@ -3219,7 +3328,7 @@ export function createAutoContinueEngine(deps) {
                     run.updatedAt = now;
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "idle",
+                        state: LaneState.IDLE,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason: null,
@@ -3327,7 +3436,7 @@ export function createAutoContinueEngine(deps) {
                     }
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "blocked",
+                        state: LaneState.BLOCKED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason,
@@ -3463,6 +3572,9 @@ export function createAutoContinueEngine(deps) {
         catch {
             // best effort
         }
+        // Session resume: check if a previous session exists for this workstream.
+        const priorSession = sessionResumeEnabled() ? getWorkstreamSession(selectedWorkstreamId) : null;
+        const resumedFromSessionId = priorSession?.sessionId ?? null;
         const spawned = spawnCodexSliceWorker({
             runId: sliceRunId,
             prompt,
@@ -3470,6 +3582,7 @@ export function createAutoContinueEngine(deps) {
             logPath,
             outputPath,
             outputSchemaPath: schemaPath,
+            resumeSessionId: resumedFromSessionId,
             env: {
                 ORGX_SOURCE_CLIENT: executorSourceClient,
                 ORGX_RUN_ID: sliceRunId,
@@ -3510,7 +3623,7 @@ export function createAutoContinueEngine(deps) {
             behaviorAutomationLevel,
             sourceClient: executorSourceClient,
             pid: spawned.pid,
-            status: "running",
+            status: RunStatus.RUNNING,
             startedAt: now,
             finishedAt: null,
             updatedAt: now,
@@ -3523,6 +3636,8 @@ export function createAutoContinueEngine(deps) {
             scopeMilestoneIds: scopeMilestoneIds,
             lastError: null,
             isMockWorker: workerKind === "mock",
+            cliSessionId: null,
+            resumedFromSessionId,
         };
         autoContinueSliceRuns.set(sliceRunId, slice);
         try {
@@ -3626,7 +3741,7 @@ export function createAutoContinueEngine(deps) {
         run.activeTaskIds = dedupeStrings([...run.activeTaskIds, ...slice.taskIds]);
         setLaneState(run, {
             workstreamId: selectedWorkstreamId,
-            state: "running",
+            state: LaneState.RUNNING,
             activeRunId: sliceRunId,
             activeTaskIds: slice.taskIds,
             blockedReason: null,
@@ -3705,16 +3820,16 @@ export function createAutoContinueEngine(deps) {
         }
         const lane = run.laneByWorkstreamId[workstreamId] ?? null;
         if (lane &&
-            (lane.state === "running" ||
-                lane.state === "blocked" ||
-                lane.state === "waiting_dependency" ||
-                lane.state === "rate_limited")) {
+            (lane.state === LaneState.RUNNING ||
+                lane.state === LaneState.BLOCKED ||
+                lane.state === LaneState.WAITING_DEPENDENCY ||
+                lane.state === LaneState.RATE_LIMITED)) {
             return run;
         }
         if (Array.isArray(run.allowedWorkstreamIds) &&
             run.allowedWorkstreamIds.length > 0 &&
             run.allowedWorkstreamIds.includes(workstreamId) &&
-            (run.status === "running" || run.status === "stopping")) {
+            (run.status === RunStatus.RUNNING || run.status === RunStatus.STOPPING)) {
             return run;
         }
         return null;
@@ -3798,13 +3913,13 @@ export function createAutoContinueEngine(deps) {
             const existingRun = autoContinueRuns.get(initiativeId) ?? null;
             if (existingRun &&
                 (existingRun.stopRequested ||
-                    existingRun.status === "stopping" ||
+                    existingRun.status === RunStatus.STOPPING ||
                     existingRun.stopReason === "stopped")) {
                 await emitSkip("paused_by_user");
                 return;
             }
             if (existingRun &&
-                (existingRun.status === "running" || existingRun.status === "stopping") &&
+                (existingRun.status === RunStatus.RUNNING || existingRun.status === RunStatus.STOPPING) &&
                 listActiveSliceRunIds(existingRun).length > 0) {
                 const activeRunIds = listActiveSliceRunIds(existingRun);
                 await emitSkip("already_running", {
@@ -4017,7 +4132,7 @@ export function createAutoContinueEngine(deps) {
     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 existingIsLive = existing?.status === RunStatus.RUNNING || existing?.status === RunStatus.STOPPING;
         const run = existing ??
             {
                 initiativeId: input.initiativeId,
@@ -4032,7 +4147,7 @@ export function createAutoContinueEngine(deps) {
                 scope: "task",
                 tokenBudget: defaultAutoContinueTokenBudget(),
                 tokensUsed: 0,
-                status: "running",
+                status: RunStatus.RUNNING,
                 stopReason: null,
                 stopRequested: false,
                 startedAt: now,
@@ -4075,7 +4190,7 @@ export function createAutoContinueEngine(deps) {
                 ? normalizeTokenBudget(run.tokenBudget, defaultAutoContinueTokenBudget())
                 : defaultAutoContinueTokenBudget();
         }
-        run.status = "running";
+        run.status = RunStatus.RUNNING;
         run.stopReason = null;
         run.stopRequested = false;
         run.stoppedAt = null;
@@ -4094,6 +4209,7 @@ export function createAutoContinueEngine(deps) {
             run.activeTaskId = null;
             run.activeRunId = null;
             run.activeTaskTokenEstimate = null;
+            clearWorkstreamSession(input.initiativeId);
         }
         syncLegacyRunPointers(run);
         autoContinueRuns.set(input.initiativeId, run);
@@ -4157,8 +4273,8 @@ export function createAutoContinueEngine(deps) {
                             event: "autopilot_transition",
                             actionType: "run_state_transition",
                         }),
-                        old_state: "idle",
-                        new_state: "running",
+                        old_state: LaneState.IDLE,
+                        new_state: LaneState.RUNNING,
                         reason: "started",
                         workspace_id: run.allowedWorkstreamIds?.[0] ?? null,
                     },
@@ -4191,5 +4307,12 @@ export function createAutoContinueEngine(deps) {
         getAutoContinueLaneForWorkstream,
         scheduleAutoFixForWorkstream,
         startAutoContinueRun,
+        // Session store (for resume support)
+        workstreamSessionStore,
+        getWorkstreamSession,
+        setWorkstreamSession,
+        clearWorkstreamSession,
+        listWorkstreamSessions,
+        sessionResumeEnabled,
     };
 }

package/dist/http/helpers/autopilot-runtime.d.ts

@@ -21,6 +21,7 @@ export declare function createAutopilotRuntime(deps: CreateAutopilotRuntimeDeps)
         outputPath: string;
         outputSchemaPath?: string;
         env: Record<string, string | undefined>;
+        resumeSessionId?: string | null;
     }) => {
         pid: number | null;
     };