@useorgx/openclaw-plugin 0.7.11 → 0.7.16

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

@@ -15,6 +15,7 @@ import { buildMissionControlGraph, DEFAULT_TOKEN_BUDGET_ASSUMPTIONS, dedupeStrin
 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";
+import { LaneState, RunStatus, } from "./queue-constants.js";
 function resolveAutopilotDefaultCwd(filename) {
     let cursor = dirname(filename);
     for (let i = 0; i < 12; i += 1) {
@@ -1029,7 +1030,7 @@ export function createAutoContinueEngine(deps) {
         }
         const existing = run.laneByWorkstreamId[normalizedWorkstreamId] ?? {
             workstreamId: normalizedWorkstreamId,
-            state: "idle",
+            state: LaneState.IDLE,
             activeRunId: null,
             activeTaskIds: [],
             blockedReason: null,
@@ -1081,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,
                 });
             }
         }
@@ -1389,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,
@@ -1428,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;
@@ -1442,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: [],
                 });
@@ -1553,6 +1554,20 @@ export function createAutoContinueEngine(deps) {
                 decision_count: decisionIds.length,
                 last_error: input.run.lastError,
                 error_location: errorLocation,
+                ...(input.reason === "blocked" || input.reason === "error"
+                    ? {
+                        blocker: {
+                            kind: decisionRequired ? "decision_required" : "error",
+                            summary: input.error ?? input.run.lastError ?? "Execution blocked",
+                            required_actor: decisionRequired ? "user" : "system",
+                            required_action: decisionRequired
+                                ? "Resolve the pending decision in Decisions panel"
+                                : "Review the error and retry",
+                            can_skip: true,
+                            skip_route: "/orgx/api/autopilot/skip",
+                        },
+                    }
+                    : {}),
             },
         });
         // Emit autopilot_transition event for state observers.
@@ -1572,7 +1587,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,
@@ -1774,7 +1789,7 @@ export function createAutoContinueEngine(deps) {
                             });
                             setLaneState(run, {
                                 workstreamId: slice.workstreamId,
-                                state: "blocked",
+                                state: LaneState.BLOCKED,
                                 activeRunId: null,
                                 activeTaskIds: [],
                                 blockedReason: slice.lastError,
@@ -1816,6 +1831,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,
@@ -1849,7 +1867,7 @@ export function createAutoContinueEngine(deps) {
                             const decisionResult = await requestDecisionQueued({
                                 initiativeId: run.initiativeId,
                                 correlationId: slice.runId,
-                                title: `Agent ${humanLabel === "timed out" ? "ran out of time" : "stopped making progress"}: ${slice.workstreamTitle ?? slice.workstreamId}`,
+                                title: stallDecisionTitle,
                                 summary: humanizeSliceFailureSummary(slice.lastError ?? `Autopilot slice ${humanLabel}`),
                                 urgency: "high",
                                 options: [
@@ -1902,7 +1920,7 @@ export function createAutoContinueEngine(deps) {
                             });
                             setLaneState(run, {
                                 workstreamId: slice.workstreamId,
-                                state: "blocked",
+                                state: LaneState.BLOCKED,
                                 activeRunId: null,
                                 activeTaskIds: [],
                                 blockedReason: slice.lastError,
@@ -1968,13 +1986,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;
@@ -2054,7 +2084,7 @@ export function createAutoContinueEngine(deps) {
                     : [];
                 const resultEnvelope = {
                     summary: userSummary,
-                    parsed_status: effectiveParsedStatus,
+                    parsed_status: reportedParsedStatus,
                     task_updates: taskUpdates,
                     milestone_updates: milestoneUpdates,
                     next_actions: nextActions,
@@ -2245,7 +2275,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,
@@ -2262,12 +2292,53 @@ export function createAutoContinueEngine(deps) {
                             ...mockMeta(slice),
                             user_summary: userSummary,
                             next_actions: nextActions,
+                            outcomes: {
+                                pr_url: typeof parsed?.pr_url === "string" ? parsed.pr_url : null,
+                                pr_number: typeof parsed?.pr_number === "number" ? parsed.pr_number : null,
+                                commit_sha: typeof parsed?.commit_sha === "string" ? parsed.commit_sha : null,
+                                commit_url: typeof parsed?.commit_url === "string" ? parsed.commit_url : null,
+                                tests: null,
+                                artifact_ids: artifacts.map((a) => a.name).filter(Boolean),
+                                task_updates: taskUpdates?.length ?? 0,
+                            },
                         },
                     });
                 }
                 catch {
                     // best effort
                 }
+                // Emit explicit session completion event for canonical agent panel state
+                if (slice.status === "completed" || reportedParsedStatus === "completed") {
+                    await emitActivitySafe({
+                        initiativeId: run.initiativeId,
+                        runId: slice.runId,
+                        correlationId: slice.runId,
+                        phase: "completed",
+                        level: "info",
+                        message: userSummary ?? `Completed work on ${slice.workstreamTitle ?? "task"}`,
+                        metadata: {
+                            ...buildSliceEnrichment({
+                                run,
+                                slice,
+                                workstreamId: slice.workstreamId,
+                                workstreamTitle: slice.workstreamTitle ?? null,
+                                domain: slice.domain,
+                                requiredSkills: slice.requiredSkills,
+                                userSummary,
+                                event: "session_completed",
+                            }),
+                            session_id: slice.cliSessionId ?? null,
+                            source_client: slice.sourceClient,
+                            workstream_title: slice.workstreamTitle ?? null,
+                            task_title: slice.workstreamTitle ?? slice.workstreamId,
+                            duration_ms: slice.finishedAt
+                                ? new Date(slice.finishedAt).getTime() - new Date(slice.startedAt).getTime()
+                                : null,
+                            outcome: reportedParsedStatus ?? slice.status,
+                            artifacts_produced: artifacts.length,
+                        },
+                    });
+                }
                 if (slice.status === "completed") {
                     await emitActivitySafe({
                         initiativeId: run.initiativeId,
@@ -2289,7 +2360,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,
@@ -2335,7 +2406,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,
@@ -2344,7 +2415,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,
@@ -2382,20 +2453,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";
-                        const fallbackRawError = parsed?.summary ?? slice.lastError ??
-                            (blockedLike
-                                ? "Execution is blocked and needs intervention."
-                                : "Agent process exited without a valid output contract.");
-                        const fallbackHumanized = humanizeSliceFailure(fallbackRawError);
                         fallbackDecisionResult = await requestDecisionQueued({
                             initiativeId: run.initiativeId,
                             correlationId: slice.runId,
-                            title: blockedLike
-                                ? `Agent needs your help: ${slice.workstreamTitle ?? slice.workstreamId}`
-                                : `${fallbackHumanized.headline}: ${slice.workstreamTitle ?? slice.workstreamId}`,
-                            summary: fallbackHumanized.explanation,
+                            title: fallbackDecisionTitle,
+                            summary: fallbackDecisionSummary,
                             urgency: "high",
                             options: [
                                 "Retry this workstream slice",
@@ -2403,18 +2517,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.",
@@ -2422,19 +2538,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,
@@ -2443,12 +2557,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,
                     });
@@ -2457,10 +2571,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])),
                     });
@@ -2533,7 +2645,7 @@ export function createAutoContinueEngine(deps) {
                     });
                     setLaneState(run, {
                         workstreamId: slice.workstreamId,
-                        state: "blocked",
+                        state: LaneState.BLOCKED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason: slice.lastError ??
@@ -2567,7 +2679,7 @@ export function createAutoContinueEngine(deps) {
                 });
                 setLaneState(run, {
                     workstreamId: slice.workstreamId,
-                    state: "completed",
+                    state: LaneState.COMPLETED,
                     activeRunId: null,
                     activeTaskIds: [],
                     blockedReason: null,
@@ -2645,7 +2757,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;
@@ -2697,8 +2809,11 @@ export function createAutoContinueEngine(deps) {
         };
         // Select the next eligible workstream by scanning ordered todos.
         let selectedWorkstreamId = null;
+        let selectedQueueRank = 0;
         let deferredBySpawnGuardRateLimit = 0;
+        let queueScanIndex = 0;
         for (const taskId of graph.recentTodos) {
+            queueScanIndex++;
             const node = nodeById.get(taskId);
             if (!node || node.type !== "task")
                 continue;
@@ -2740,6 +2855,7 @@ export function createAutoContinueEngine(deps) {
                 continue;
             }
             selectedWorkstreamId = node.workstreamId;
+            selectedQueueRank = queueScanIndex + 1;
             break;
         }
         if (!selectedWorkstreamId) {
@@ -2777,7 +2893,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,
@@ -3028,7 +3144,7 @@ export function createAutoContinueEngine(deps) {
             }
             setLaneState(run, {
                 workstreamId: selectedWorkstreamId,
-                state: "blocked",
+                state: LaneState.BLOCKED,
                 activeRunId: null,
                 activeTaskIds: [],
                 blockedReason,
@@ -3123,7 +3239,7 @@ export function createAutoContinueEngine(deps) {
             }
             setLaneState(run, {
                 workstreamId: selectedWorkstreamId,
-                state: "blocked",
+                state: LaneState.BLOCKED,
                 activeRunId: null,
                 activeTaskIds: [],
                 blockedReason,
@@ -3188,7 +3304,7 @@ export function createAutoContinueEngine(deps) {
                     });
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "rate_limited",
+                        state: LaneState.RATE_LIMITED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason,
@@ -3271,7 +3387,7 @@ export function createAutoContinueEngine(deps) {
                     run.updatedAt = now;
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "idle",
+                        state: LaneState.IDLE,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason: null,
@@ -3379,7 +3495,7 @@ export function createAutoContinueEngine(deps) {
                     }
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "blocked",
+                        state: LaneState.BLOCKED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason,
@@ -3566,7 +3682,7 @@ export function createAutoContinueEngine(deps) {
             behaviorAutomationLevel,
             sourceClient: executorSourceClient,
             pid: spawned.pid,
-            status: "running",
+            status: RunStatus.RUNNING,
             startedAt: now,
             finishedAt: null,
             updatedAt: now,
@@ -3618,6 +3734,10 @@ export function createAutoContinueEngine(deps) {
                     scope_milestone_ids: slice.scopeMilestoneIds,
                     log_path: logPath,
                     output_path: outputPath,
+                    dispatch_queue_rank: selectedQueueRank > 0 ? selectedQueueRank : null,
+                    dispatch_workstream_title: workstreamTitle ?? null,
+                    dispatch_task_title: primaryTask.title ?? null,
+                    dispatch_selection_reason: "top_of_queue",
                     ...mockMeta(slice),
                 },
             });
@@ -3657,6 +3777,10 @@ export function createAutoContinueEngine(deps) {
                 scope_milestone_ids: slice.scopeMilestoneIds,
                 log_path: logPath,
                 output_path: outputPath,
+                dispatch_queue_rank: selectedQueueRank > 0 ? selectedQueueRank : null,
+                dispatch_workstream_title: workstreamTitle ?? null,
+                dispatch_task_title: primaryTask.title ?? null,
+                dispatch_selection_reason: "top_of_queue",
                 ...mockMeta(slice),
             },
         });
@@ -3684,7 +3808,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,
@@ -3763,16 +3887,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;
@@ -3856,13 +3980,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", {
@@ -4075,7 +4199,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,
@@ -4090,7 +4214,7 @@ export function createAutoContinueEngine(deps) {
                 scope: "task",
                 tokenBudget: defaultAutoContinueTokenBudget(),
                 tokensUsed: 0,
-                status: "running",
+                status: RunStatus.RUNNING,
                 stopReason: null,
                 stopRequested: false,
                 startedAt: now,
@@ -4133,7 +4257,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;
@@ -4216,8 +4340,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,
                     },
@@ -4229,6 +4353,102 @@ export function createAutoContinueEngine(deps) {
         }
         return run;
     }
+    async function skipCurrentWorkstream(initiativeId, workstreamId, reason) {
+        const run = autoContinueRuns.get(initiativeId) ?? null;
+        if (!run) {
+            return { ok: false, skippedWorkstreamId: workstreamId };
+        }
+        ensureRunInternals(run);
+        if (!run.blockedWorkstreamIds.includes(workstreamId)) {
+            run.blockedWorkstreamIds.push(workstreamId);
+        }
+        setLaneState(run, {
+            workstreamId,
+            state: LaneState.BLOCKED,
+            activeRunId: null,
+            activeTaskIds: [],
+            blockedReason: reason ?? "Skipped by user",
+            waitingOnWorkstreamIds: [],
+            retryAt: null,
+        });
+        run.updatedAt = new Date().toISOString();
+        try {
+            await emitActivitySafe({
+                initiativeId,
+                runId: run.lastRunId ?? undefined,
+                correlationId: run.lastRunId ?? undefined,
+                phase: "review",
+                level: "info",
+                message: `Workstream ${workstreamId} skipped${reason ? `: ${reason}` : ""}.`,
+                metadata: {
+                    ...buildSliceEnrichment({
+                        run,
+                        workstreamId,
+                        event: "autopilot_item_skipped",
+                    }),
+                    skipped_workstream_id: workstreamId,
+                    skip_reason: reason ?? null,
+                },
+            });
+        }
+        catch {
+            // best effort
+        }
+        // Re-enable the run if it was stopped due to the blocked workstream.
+        if (run.status === RunStatus.STOPPED && run.stopReason === "blocked") {
+            run.status = RunStatus.RUNNING;
+            run.stopReason = null;
+            run.stoppedAt = null;
+            run.stopRequested = false;
+            run.lastError = null;
+        }
+        // Trigger the next tick to pick up a different workstream.
+        try {
+            await tickAutoContinueRun(run);
+        }
+        catch {
+            // best effort
+        }
+        // Determine what the next workstream is, if any.
+        const nextLane = Object.values(run.laneByWorkstreamId ?? {}).find((lane) => lane.state === LaneState.RUNNING && lane.workstreamId !== workstreamId) ?? null;
+        return {
+            ok: true,
+            skippedWorkstreamId: workstreamId,
+            nextWorkstreamId: nextLane?.workstreamId ?? undefined,
+            nextWorkstreamTitle: undefined,
+        };
+    }
+    function getCanonicalAutopilotState(initiativeId) {
+        const run = autoContinueRuns.get(initiativeId) ?? null;
+        if (!run)
+            return null;
+        const canonicalState = run.status === RunStatus.RUNNING
+            ? "running"
+            : run.status === RunStatus.STOPPING
+                ? "stopping"
+                : run.stopReason === "blocked" || run.stopReason === "error"
+                    ? "blocked"
+                    : "idle";
+        const reason = canonicalState === "blocked"
+            ? run.lastError ?? run.stopReason ?? null
+            : canonicalState === "stopping"
+                ? "stop_requested"
+                : null;
+        // Find the first active slice to identify the current workstream.
+        const activeSliceRunId = (run.activeSliceRunIds ?? [])[0] ?? run.activeRunId ?? null;
+        const activeSlice = activeSliceRunId
+            ? autoContinueSliceRuns.get(activeSliceRunId) ?? null
+            : null;
+        return {
+            state: canonicalState,
+            reason,
+            activeRunId: activeSliceRunId,
+            activeWorkstreamId: activeSlice?.workstreamId ?? null,
+            activeWorkstreamTitle: activeSlice?.workstreamTitle ?? null,
+            queueHeadTitle: activeSlice?.workstreamTitle ?? null,
+            lastTransitionAt: run.updatedAt ?? run.startedAt,
+        };
+    }
     return {
         autoContinueRuns,
         autoContinueSliceRuns,
@@ -4250,6 +4470,8 @@ export function createAutoContinueEngine(deps) {
         getAutoContinueLaneForWorkstream,
         scheduleAutoFixForWorkstream,
         startAutoContinueRun,
+        skipCurrentWorkstream,
+        getCanonicalAutopilotState,
         // Session store (for resume support)
         workstreamSessionStore,
         getWorkstreamSession,