@useorgx/openclaw-plugin 0.7.11 → 0.7.15

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: [],
                 });
@@ -1572,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,
@@ -1774,7 +1775,7 @@ export function createAutoContinueEngine(deps) {
                             });
                             setLaneState(run, {
                                 workstreamId: slice.workstreamId,
-                                state: "blocked",
+                                state: LaneState.BLOCKED,
                                 activeRunId: null,
                                 activeTaskIds: [],
                                 blockedReason: slice.lastError,
@@ -1816,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,
@@ -1849,7 +1853,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 +1906,7 @@ export function createAutoContinueEngine(deps) {
                             });
                             setLaneState(run, {
                                 workstreamId: slice.workstreamId,
-                                state: "blocked",
+                                state: LaneState.BLOCKED,
                                 activeRunId: null,
                                 activeTaskIds: [],
                                 blockedReason: slice.lastError,
@@ -1968,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;
@@ -2054,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,
@@ -2245,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,
@@ -2289,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,
@@ -2335,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,
@@ -2344,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,
@@ -2382,20 +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";
-                        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 +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.",
@@ -2422,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,
@@ -2443,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,
                     });
@@ -2457,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])),
                     });
@@ -2533,7 +2590,7 @@ export function createAutoContinueEngine(deps) {
                     });
                     setLaneState(run, {
                         workstreamId: slice.workstreamId,
-                        state: "blocked",
+                        state: LaneState.BLOCKED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason: slice.lastError ??
@@ -2567,7 +2624,7 @@ export function createAutoContinueEngine(deps) {
                 });
                 setLaneState(run, {
                     workstreamId: slice.workstreamId,
-                    state: "completed",
+                    state: LaneState.COMPLETED,
                     activeRunId: null,
                     activeTaskIds: [],
                     blockedReason: null,
@@ -2645,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;
@@ -2777,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,
@@ -3028,7 +3085,7 @@ export function createAutoContinueEngine(deps) {
             }
             setLaneState(run, {
                 workstreamId: selectedWorkstreamId,
-                state: "blocked",
+                state: LaneState.BLOCKED,
                 activeRunId: null,
                 activeTaskIds: [],
                 blockedReason,
@@ -3123,7 +3180,7 @@ export function createAutoContinueEngine(deps) {
             }
             setLaneState(run, {
                 workstreamId: selectedWorkstreamId,
-                state: "blocked",
+                state: LaneState.BLOCKED,
                 activeRunId: null,
                 activeTaskIds: [],
                 blockedReason,
@@ -3188,7 +3245,7 @@ export function createAutoContinueEngine(deps) {
                     });
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "rate_limited",
+                        state: LaneState.RATE_LIMITED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason,
@@ -3271,7 +3328,7 @@ export function createAutoContinueEngine(deps) {
                     run.updatedAt = now;
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "idle",
+                        state: LaneState.IDLE,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason: null,
@@ -3379,7 +3436,7 @@ export function createAutoContinueEngine(deps) {
                     }
                     setLaneState(run, {
                         workstreamId: selectedWorkstreamId,
-                        state: "blocked",
+                        state: LaneState.BLOCKED,
                         activeRunId: null,
                         activeTaskIds: [],
                         blockedReason,
@@ -3566,7 +3623,7 @@ export function createAutoContinueEngine(deps) {
             behaviorAutomationLevel,
             sourceClient: executorSourceClient,
             pid: spawned.pid,
-            status: "running",
+            status: RunStatus.RUNNING,
             startedAt: now,
             finishedAt: null,
             updatedAt: now,
@@ -3684,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,
@@ -3763,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;
@@ -3856,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", {
@@ -4075,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,
@@ -4090,7 +4147,7 @@ export function createAutoContinueEngine(deps) {
                 scope: "task",
                 tokenBudget: defaultAutoContinueTokenBudget(),
                 tokensUsed: 0,
-                status: "running",
+                status: RunStatus.RUNNING,
                 stopReason: null,
                 stopRequested: false,
                 startedAt: now,
@@ -4133,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;
@@ -4216,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,
                     },