@useorgx/openclaw-plugin 0.7.23 → 0.7.25

package/dist/http/helpers/triage-mapper.js

@@ -53,6 +53,126 @@ function countArray(record, keys) {
     }
     return 0;
 }
+function pickBoolean(record, keys) {
+    if (!record)
+        return null;
+    for (const key of keys) {
+        const candidate = record[key];
+        if (typeof candidate === "boolean")
+            return candidate;
+        if (typeof candidate === "string") {
+            const normalized = candidate.trim().toLowerCase();
+            if (normalized === "true" || normalized === "yes" || normalized === "1")
+                return true;
+            if (normalized === "false" || normalized === "no" || normalized === "0")
+                return false;
+        }
+    }
+    return null;
+}
+function normalizeDecisionOptionsFromUnknown(...values) {
+    const options = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (!Array.isArray(value))
+            continue;
+        for (const entry of value) {
+            if (typeof entry === "string") {
+                const label = entry.trim();
+                if (!label)
+                    continue;
+                const key = label.toLowerCase();
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                options.push({ label });
+                continue;
+            }
+            const record = asRecord(entry);
+            if (!record)
+                continue;
+            const label = pickString(record, ["label", "title", "name", "question"]) ??
+                pickString(record, ["action", "action_type", "actionType"]);
+            if (!label)
+                continue;
+            const id = pickString(record, ["id", "option_id", "optionId"]);
+            const description = pickString(record, ["description", "summary"]);
+            const consequences = pickString(record, ["consequences", "impact"]);
+            const actionType = pickString(record, ["action_type", "actionType", "action"]);
+            const impliedStatus = pickString(record, ["implied_status", "impliedStatus", "status"]);
+            const requiresNote = pickBoolean(record, ["requires_note", "requiresNote", "note_required"]);
+            const recommended = pickBoolean(record, ["recommended", "is_recommended", "isRecommended"]);
+            const key = `${(id ?? "").toLowerCase()}|${label.toLowerCase()}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            options.push({
+                ...(id ? { id } : {}),
+                label,
+                ...(description ? { description } : {}),
+                ...(consequences ? { consequences } : {}),
+                ...(actionType ? { actionType } : {}),
+                ...(impliedStatus ? { impliedStatus } : {}),
+                ...(typeof requiresNote === "boolean" ? { requiresNote } : {}),
+                ...(typeof recommended === "boolean" ? { recommended } : {}),
+            });
+        }
+    }
+    return options.slice(0, 8);
+}
+function normalizeEvidenceFromUnknown(...values) {
+    const evidence = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (!Array.isArray(value))
+            continue;
+        for (const entry of value) {
+            const record = asRecord(entry);
+            if (!record)
+                continue;
+            const title = pickString(record, ["title", "label", "name"]) ??
+                pickString(record, ["source_pointer", "sourcePointer", "source_url", "sourceUrl"]) ??
+                "Evidence";
+            const summary = pickString(record, ["summary", "description"]);
+            const url = pickString(record, ["source_url", "sourceUrl", "url"]);
+            const pointer = pickString(record, ["source_pointer", "sourcePointer", "path"]);
+            const evidenceType = pickString(record, ["evidence_type", "evidenceType", "type"]);
+            const confidenceRaw = record.confidence ?? record.confidence_score;
+            const confidence = typeof confidenceRaw === "number" && Number.isFinite(confidenceRaw)
+                ? Math.max(0, Math.min(1, confidenceRaw))
+                : null;
+            const key = `${title.toLowerCase()}|${url ?? ""}|${pointer ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            evidence.push({
+                title,
+                ...(summary ? { summary } : {}),
+                ...(url ? { url } : {}),
+                ...(pointer ? { pointer } : {}),
+                ...(evidenceType ? { evidenceType } : {}),
+                ...(confidence !== null ? { confidence } : {}),
+            });
+        }
+    }
+    return evidence.slice(0, 8);
+}
+function pickHierarchy(record, keys) {
+    if (!record)
+        return [];
+    for (const key of keys) {
+        const candidate = record[key];
+        if (!Array.isArray(candidate))
+            continue;
+        const normalized = candidate
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        if (normalized.length > 0)
+            return normalized;
+    }
+    return [];
+}
 function deriveInterventionContext(input) {
     const metadata = asRecord(input.metadata);
     const result = asRecord(metadata?.result);
@@ -101,6 +221,28 @@ function deriveInterventionContext(input) {
         countArray(metadata, ["task_updates", "taskUpdates"]);
     const milestoneUpdateCount = countArray(result, ["milestone_updates", "milestoneUpdates"]) ||
         countArray(metadata, ["milestone_updates", "milestoneUpdates"]);
+    const decisionPrompt = pickString(metadata, ["decision_prompt", "decisionPrompt", "question", "decision_title", "decisionTitle"]) ??
+        pickString(result, ["decision_prompt", "decisionPrompt", "question"]);
+    const decisionSummary = pickString(metadata, ["decision_summary", "decisionSummary", "summary", "context"]) ??
+        pickString(result, ["decision_summary", "decisionSummary", "summary"]);
+    const decisionOptions = normalizeDecisionOptionsFromUnknown(metadata?.decision_options, metadata?.decisionOptions, metadata?.options, result?.decision_options, result?.decisionOptions, result?.options);
+    const recommendedAction = pickString(metadata, ["recommended_action", "recommendedAction"]) ??
+        pickString(result, ["recommended_action", "recommendedAction"]) ??
+        requiredAction;
+    const scopeHierarchy = [
+        ...pickHierarchy(metadata, ["scope_hierarchy", "scopeHierarchy"]),
+        ...pickHierarchy(result, ["scope_hierarchy", "scopeHierarchy"]),
+    ].filter((entry, index, source) => source.indexOf(entry) === index);
+    const currentRunState = pickString(metadata, ["current_run_state", "currentRunState", "runtime_state", "runtimeState", "status"]) ??
+        pickString(result, ["current_run_state", "currentRunState", "runtime_state", "runtimeState", "status"]);
+    const impactIfDelayed = pickString(metadata, ["impact_if_delayed", "impactIfDelayed"]) ??
+        pickString(result, ["impact_if_delayed", "impactIfDelayed"]);
+    const evidence = normalizeEvidenceFromUnknown(metadata?.evidence_refs, metadata?.evidenceRefs, result?.evidence_refs, result?.evidenceRefs);
+    const artifacts = pickStringArray(metadata, ["artifacts_created", "artifact_titles", "artifactTitles"]);
+    const updatesApplied = [
+        ...pickStringArray(metadata, ["updates_applied", "updatesApplied"]),
+        ...pickStringArray(result, ["updates_applied", "updatesApplied"]),
+    ];
     const context = {
         blockerReason,
         waitingOn,
@@ -114,6 +256,16 @@ function deriveInterventionContext(input) {
         decisionIds: decisionIds.length > 0 ? Array.from(new Set(decisionIds)) : [],
         taskUpdateCount: taskUpdateCount > 0 ? taskUpdateCount : undefined,
         milestoneUpdateCount: milestoneUpdateCount > 0 ? milestoneUpdateCount : undefined,
+        decisionPrompt,
+        decisionSummary,
+        decisionOptions: decisionOptions.length > 0 ? decisionOptions : undefined,
+        recommendedAction,
+        scopeHierarchy: scopeHierarchy.length > 0 ? scopeHierarchy : undefined,
+        currentRunState,
+        impactIfDelayed,
+        artifacts: artifacts.length > 0 ? Array.from(new Set(artifacts)) : undefined,
+        evidence: evidence.length > 0 ? evidence : undefined,
+        updatesApplied: updatesApplied.length > 0 ? Array.from(new Set(updatesApplied)) : undefined,
     };
     const hasValue = [
         context.blockerReason,
@@ -125,9 +277,19 @@ function deriveInterventionContext(input) {
         context.retryable,
         context.taskUpdateCount,
         context.milestoneUpdateCount,
+        context.decisionPrompt,
+        context.decisionSummary,
+        context.recommendedAction,
+        context.currentRunState,
+        context.impactIfDelayed,
         context.suggestedActions?.length,
         context.nextActions?.length,
         context.decisionIds?.length,
+        context.decisionOptions?.length,
+        context.scopeHierarchy?.length,
+        context.artifacts?.length,
+        context.evidence?.length,
+        context.updatesApplied?.length,
     ].some((entry) => {
         if (typeof entry === "number")
             return entry > 0;
@@ -310,6 +472,72 @@ const FAILURE_MAPPINGS = {
             },
         ],
     },
+    decision_required: {
+        kind: "decision_required",
+        severity: "high",
+        recommendedAction: "Review the options and choose the next move",
+        defaultTitle: (ctx) => `Decision required${ctx.workstreamTitle ? `: ${ctx.workstreamTitle}` : ""}`,
+        defaultSummary: (ctx) => `${ctx.workstreamTitle ?? "This workstream"} cannot continue until a decision is made. ${ctx.reason ?? "Review the recommendation and choose a direction."}`,
+        actions: () => [
+            {
+                action: "approve",
+                label: "Approve path",
+                description: "Accept the recommended option and continue",
+                consequences: "Autopilot will continue with the approved direction.",
+                requiresNote: false,
+                available: true,
+            },
+            {
+                action: "reject",
+                label: "Reject path",
+                description: "Decline this path and provide direction",
+                consequences: "The run stays paused until new direction is provided.",
+                requiresNote: true,
+                available: true,
+            },
+            {
+                action: "snooze",
+                label: "Snooze",
+                description: "Defer this intervention",
+                consequences: "This decision returns to the queue later.",
+                requiresNote: false,
+                available: true,
+            },
+        ],
+    },
+    review_required: {
+        kind: "review_required",
+        severity: "medium",
+        recommendedAction: "Review the update and confirm the next step",
+        defaultTitle: (ctx) => `Review required${ctx.workstreamTitle ? `: ${ctx.workstreamTitle}` : ""}`,
+        defaultSummary: (ctx) => `${ctx.workstreamTitle ?? "This workstream"} surfaced something that needs judgment before it proceeds. ${ctx.reason ?? "Review the evidence and confirm what should happen next."}`,
+        actions: () => [
+            {
+                action: "approve",
+                label: "Approve",
+                description: "Confirm the proposed next step",
+                consequences: "The run continues with the reviewed direction.",
+                requiresNote: false,
+                available: true,
+            },
+            {
+                action: "reject",
+                label: "Send back",
+                description: "Request a different approach",
+                consequences: "The run pauses until new direction is provided.",
+                requiresNote: true,
+                available: true,
+            },
+            {
+                action: "snooze",
+                label: "Snooze",
+                description: "Return to this later",
+                consequences: "The review request will surface again later.",
+                requiresNote: false,
+                available: true,
+            },
+        ],
+    },
     budget_exhausted: {
         kind: "blocked_intervention",
         severity: "critical",
@@ -432,6 +660,19 @@ export async function mapFailureToTriageItem(input) {
     if (input.outputPath) {
         proofBundle.artifactRefs.push(input.outputPath);
     }
+    for (const artifact of intervention?.artifacts ?? []) {
+        if (!proofBundle.artifactRefs.includes(artifact)) {
+            proofBundle.artifactRefs.push(artifact);
+        }
+    }
+    for (const evidence of intervention?.evidence ?? []) {
+        if (evidence.url && !proofBundle.artifactRefs.includes(evidence.url)) {
+            proofBundle.artifactRefs.push(evidence.url);
+        }
+        if (evidence.pointer && !proofBundle.logRefs.includes(evidence.pointer)) {
+            proofBundle.logRefs.push(evidence.pointer);
+        }
+    }
     const impact = {
         initiativeCount: input.initiativeId ? 1 : 0,
         workstreamCount: input.workstreamId ? 1 : 0,
@@ -589,6 +830,41 @@ export function mapDecisionToTriageItem(decision) {
     });
     const blocking = metadata?.blocking !== false;
     const options = Array.isArray(decision.options) ? decision.options : [];
+    const enrichedIntervention = intervention || options.length > 0 || decision.context || decision.recommendedAction || decision.evidenceRefs?.length
+        ? {
+            ...(intervention ?? {}),
+            decisionPrompt: intervention?.decisionPrompt ??
+                decision.title,
+            decisionSummary: intervention?.decisionSummary ??
+                decision.context ??
+                null,
+            decisionOptions: intervention?.decisionOptions && intervention.decisionOptions.length > 0
+                ? intervention.decisionOptions
+                : options.map((option) => ({
+                    id: option.id,
+                    label: option.label,
+                    description: option.description ?? null,
+                    consequences: option.consequences ?? null,
+                    actionType: option.actionType ?? null,
+                    impliedStatus: option.impliedStatus ?? null,
+                    requiresNote: option.requiresNote,
+                    recommended: decision.selectedOptionId != null ? decision.selectedOptionId === option.id : false,
+                })),
+            recommendedAction: intervention?.recommendedAction ??
+                decision.recommendedAction ??
+                null,
+            evidence: intervention?.evidence && intervention.evidence.length > 0
+                ? intervention.evidence
+                : (decision.evidenceRefs ?? []).map((ref) => ({
+                    title: ref.title ?? ref.sourcePointer ?? ref.sourceUrl ?? "Evidence",
+                    summary: ref.summary ?? null,
+                    url: ref.sourceUrl ?? null,
+                    pointer: ref.sourcePointer ?? null,
+                    evidenceType: ref.evidenceType ?? null,
+                    confidence: ref.confidence ?? null,
+                })),
+        }
+        : null;
     const optionActions = options
         .map((option) => {
         const implied = (option.impliedStatus ?? "").toLowerCase();
@@ -657,7 +933,7 @@ export function mapDecisionToTriageItem(decision) {
         fileChanges: [],
         prRefs: [],
         logRefs: [],
-        decisionRefs: Array.from(new Set([decision.id, ...(intervention?.decisionIds ?? [])].filter(Boolean))),
+        decisionRefs: Array.from(new Set([decision.id, ...(enrichedIntervention?.decisionIds ?? [])].filter(Boolean))),
     };
     if (decision.evidenceRefs) {
         for (const ref of decision.evidenceRefs) {
@@ -668,16 +944,19 @@ export function mapDecisionToTriageItem(decision) {
         }
     }
     const summaryBase = (typeof decision.context === "string" && decision.context.trim()) ||
-        intervention?.blockerReason ||
+        enrichedIntervention?.blockerReason ||
         decision.title;
     const summarySuffix = [
-        intervention?.waitingOn ? `Waiting on ${intervention.waitingOn}.` : null,
-        intervention?.requiredAction ? `Required action: ${intervention.requiredAction}.` : null,
+        enrichedIntervention?.waitingOn ? `Waiting on ${enrichedIntervention.waitingOn}.` : null,
+        enrichedIntervention?.requiredAction ? `Required action: ${enrichedIntervention.requiredAction}.` : null,
     ]
         .filter((entry) => Boolean(entry))
         .join(" ");
     const summary = summarySuffix.length > 0 ? `${summaryBase} ${summarySuffix}` : summaryBase;
-    const recommendedAction = decision.recommendedAction ?? intervention?.requiredAction ?? null;
+    const recommendedAction = decision.recommendedAction ??
+        enrichedIntervention?.recommendedAction ??
+        enrichedIntervention?.requiredAction ??
+        null;
     return {
         id: `triage-decision-${decision.id}`,
         kind: mapping?.kind ?? "decision_required",
@@ -698,7 +977,7 @@ export function mapDecisionToTriageItem(decision) {
         blocking,
         recommendedAction,
         agentId: decision.agentId ?? null,
-        intervention,
+        intervention: enrichedIntervention,
         impact: {
             initiativeCount: decision.initiativeId ? 1 : 0,
             workstreamCount: decision.workstreamId ? 1 : 0,

package/dist/http/helpers/value-utils.d.ts

@@ -1,5 +1,6 @@
 export declare function pickString(record: Record<string, unknown>, keys: string[]): string | null;
 export declare function pickNumber(record: Record<string, unknown>, keys: string[]): number | null;
+export declare function pickBoolean(record: Record<string, unknown> | null, keys: string[]): boolean | null;
 export declare function pickHeaderString(headers: Record<string, string | string[] | undefined>, keys: string[]): string | null;
 export declare function toIsoString(value: string | null): string | null;
 export declare function parsePositiveInt(raw: string | null, fallback: number, max?: number): number;

package/dist/http/helpers/value-utils.js

@@ -23,6 +23,23 @@ export function pickNumber(record, keys) {
     }
     return null;
 }
+export function pickBoolean(record, keys) {
+    if (!record)
+        return null;
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "string") {
+            const normalized = value.trim().toLowerCase();
+            if (normalized === "true" || normalized === "yes" || normalized === "1")
+                return true;
+            if (normalized === "false" || normalized === "no" || normalized === "0")
+                return false;
+        }
+    }
+    return null;
+}
 export function pickHeaderString(headers, keys) {
     for (const key of keys) {
         const candidates = [key, key.toLowerCase(), key.toUpperCase()];

package/dist/http/index.js

@@ -56,7 +56,7 @@ import { configureOpenClawProviderRouting, fetchBillingStatusSafe, isPidAlive, l
 import { fetchKickoffContextSafe, renderKickoffMessage } from "./helpers/kickoff-context.js";
 import { createDispatchLifecycle } from "./helpers/dispatch-lifecycle.js";
 import { createRuntimeSseHub } from "./helpers/runtime-sse.js";
-import { parseBooleanQuery, parsePositiveInt, pickHeaderString, pickNumber, pickString, } from "./helpers/value-utils.js";
+import { parseBooleanQuery, pickBoolean, parsePositiveInt, pickHeaderString, pickNumber, pickString, } from "./helpers/value-utils.js";
 import { registerAgentControlRoutes } from "./routes/agent-control.js";
 import { registerAgentSuiteRoutes } from "./routes/agent-suite.js";
 import { registerAgentsCatalogRoutes } from "./routes/agents-catalog.js";
@@ -2411,6 +2411,30 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         ? entry.blockers[0] ??
                             (statusValues.includes("failed") ? "Latest run failed" : "Workstream blocked")
                         : null,
+                    canStartNow: queueState === QueueState.QUEUED || queueState === QueueState.IDLE,
+                    startReasonCode: queueState === QueueState.RUNNING
+                        ? "already_running"
+                        : hasBlocked
+                            ? "blocked"
+                            : queueState === QueueState.QUEUED || queueState === QueueState.IDLE
+                                ? "dispatchable"
+                                : "not_startable",
+                    startReasonLabel: hasBlocked
+                        ? entry.blockers[0] ??
+                            (statusValues.includes("failed") ? "Latest run failed." : "Workstream blocked.")
+                        : queueState === QueueState.RUNNING
+                            ? "Already running."
+                            : "Ready to start this workstream.",
+                    dispatchableTask: queueState === QueueState.QUEUED || queueState === QueueState.IDLE
+                        ? {
+                            id: entry.latest.id ?? `${entry.initiativeId}:${entry.workstreamId}`,
+                            title: (entry.latest.lastEventSummary ?? "").trim() ||
+                                (entry.latest.title ?? "").trim() ||
+                                entry.workstreamTitle,
+                            scope: "workstream",
+                            milestoneId: null,
+                        }
+                        : null,
                     isPinned: pinnedRankByKey.has(pinKey),
                     pinnedRank: pinnedRankByKey.get(pinKey) ?? null,
                     autoContinue: null,
@@ -2503,6 +2527,14 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
             const workstreamNodes = graph.nodes.filter((node) => node.type === "workstream");
             const runningWorkstreams = new Set();
+            const initiativeRun = autoContinueRuns.get(initiativeId) ?? null;
+            const initiativeActiveRunIds = Array.isArray(initiativeRun?.activeSliceRunIds)
+                ? initiativeRun.activeSliceRunIds
+                    .filter((id) => typeof id === "string" && id.trim().length > 0)
+                    .map((id) => id.trim())
+                : typeof initiativeRun?.activeRunId === "string" && initiativeRun.activeRunId.trim().length > 0
+                    ? [initiativeRun.activeRunId.trim()]
+                    : [];
             const taskIsReady = (task) => task.dependencyIds.every((depId) => {
                 const dependency = nodeById.get(depId);
                 return dependency ? isDoneStatus(dependency.status) : true;
@@ -2703,6 +2735,36 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 if (isSuppressed(initiativeId, workstream.id) && queueState !== QueueState.RUNNING) {
                     continue;
                 }
+                const dispatchableTask = preferredReadyTask ?? readyTask ?? null;
+                const initiativeHasConcurrentRun = initiativeActiveRunIds.length > 0 &&
+                    laneState !== LaneState.RUNNING &&
+                    !(autoContinueRun && autoContinueRun.status === RunStatus.RUNNING);
+                const canStartNow = Boolean(dispatchableTask) &&
+                    queueState !== QueueState.RUNNING &&
+                    queueState !== QueueState.BLOCKED &&
+                    !initiativeHasConcurrentRun;
+                const startReasonCode = canStartNow
+                    ? "dispatchable"
+                    : queueState === QueueState.RUNNING
+                        ? "already_running"
+                        : initiativeHasConcurrentRun
+                            ? "initiative_run_active"
+                            : queueState === QueueState.BLOCKED
+                                ? "blocked"
+                                : !dispatchableTask
+                                    ? "no_dispatchable_task"
+                                    : "not_startable";
+                const startReasonLabel = canStartNow
+                    ? `Ready to start ${dispatchableTask?.title ?? "this workstream"}.`
+                    : initiativeHasConcurrentRun
+                        ? "Autopilot is already running for this initiative."
+                        : queueState === QueueState.RUNNING
+                            ? "Already running."
+                            : blockReason
+                                ? blockReason
+                                : dispatchableTask
+                                    ? "This workstream is not ready to start."
+                                    : "No dispatchable task is available right now.";
                 runningWorkstreams.add(workstream.id);
                 const assignedRunnerAgents = [];
                 const assignedRunnerSeen = new Set();
@@ -2763,6 +2825,17 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     runnerSource,
                     queueState,
                     blockReason,
+                    canStartNow,
+                    startReasonCode,
+                    startReasonLabel,
+                    dispatchableTask: dispatchableTask
+                        ? {
+                            id: dispatchableTask.id,
+                            title: dispatchableTask.title,
+                            scope: defaultScope,
+                            milestoneId: dispatchableTask.milestoneId ?? null,
+                        }
+                        : null,
                     isPinned: Boolean(pin),
                     pinnedRank: pin ? (pinnedRankByKey.get(pinKey) ?? null) : null,
                     sliceScope: defaultScope,
@@ -2870,6 +2943,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         blockReason: queueState === QueueState.BLOCKED
                             ? lane?.blockedReason ?? "Blocked"
                             : null,
+                        canStartNow: false,
+                        startReasonCode: queueState === QueueState.RUNNING ? "already_running" : "initiative_run_active",
+                        startReasonLabel: queueState === QueueState.RUNNING
+                            ? "Already running."
+                            : "Autopilot is already running for this initiative.",
+                        dispatchableTask: null,
                         isPinned: Boolean(pinnedByKey.get(`${initiativeId}:${workstream.id}`)),
                         pinnedRank: pinnedRankByKey.get(`${initiativeId}:${workstream.id}`) ?? null,
                         sliceScope,
@@ -3696,13 +3775,18 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             const keys = [...scopedKeys, ...fallbackKeys];
             const seen = new Set();
             const mapped = [];
-            const deriveFailureType = (eventNameRaw, actionTypeRaw, reasonRaw) => {
+            const deriveFailureType = (eventNameRaw, actionTypeRaw, reasonRaw, blockingRaw) => {
                 const eventName = (eventNameRaw ?? "").trim().toLowerCase();
                 const actionType = (actionTypeRaw ?? "").trim().toLowerCase();
                 const reason = (reasonRaw ?? "").trim().toLowerCase();
                 const signature = `${eventName} ${actionType} ${reason}`;
                 if (!signature.trim())
                     return null;
+                if (signature.includes("question_asked") ||
+                    signature.includes("review_item_created") ||
+                    signature.includes("decision_requested")) {
+                    return blockingRaw === false ? "review_required" : "decision_required";
+                }
                 if (signature.includes("status_updates_buffered"))
                     return "status_updates_buffered";
                 if (signature.includes("question_answer_failed"))
@@ -3766,8 +3850,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             pickString(resultRecord ?? {}, ["error", "reason", "blocked_reason", "blockedReason", "summary"]) ??
                             pickString(metadataRecord, ["error", "reason", "message", "blocked_reason", "blockedReason"]) ??
                             pickString(activityRecord, ["description", "summary", "title"]);
+                        const blockingSignal = pickBoolean(metadataRecord, ["blocking"]) ??
+                            pickBoolean(resultRecord, ["blocking"]);
                         const failureType = deriveFailureType(pickString(metadataRecord, ["event", "event_name"]), pickString(metadataRecord, ["action_type", "actionType"]) ??
-                            pickString(activityRecord, ["type"]), reasonText);
+                            pickString(activityRecord, ["type"]), reasonText, blockingSignal);
                         if (!failureType)
                             continue;
                         const runId = pickString(metadataRecord, ["run_id", "source_run_id"]) ?? pickString(activityRecord, ["runId"]);

package/dist/http/routes/live-triage.js

@@ -9,7 +9,12 @@ export function registerLiveTriageRoutes(router, deps) {
     // ─── GET /live/triage ─────────────────────────────────────────────
     router.add("GET", "live/triage", async ({ res, query }) => {
         const workspaceId = query.get("workspace_id") || null;
-        const statusFilter = query.get("status") || "open";
+        const requestedStatus = query.get("status") || "open";
+        const statusFilter = requestedStatus === "pending"
+            ? "open"
+            : requestedStatus === "closed"
+                ? "resolved"
+                : requestedStatus;
         const limitStr = query.get("limit");
         const limit = limitStr ? Math.min(Math.max(1, parseInt(limitStr, 10) || 50), 200) : 50;
         const degraded = [];

package/dist/http/routes/mission-control-actions.d.ts

@@ -23,6 +23,15 @@ type NextUpQueue = {
         sliceTaskIds?: string[];
         sliceTaskCount?: number | null;
         sliceMilestoneId?: string | null;
+        canStartNow?: boolean;
+        startReasonCode?: string | null;
+        startReasonLabel?: string | null;
+        dispatchableTask?: {
+            id: string;
+            title: string;
+            scope: "task" | "milestone" | "workstream";
+            milestoneId?: string | null;
+        } | null;
         executionPolicy?: {
             domain?: string;
             requiredSkills?: string[];