@useorgx/openclaw-plugin 0.7.20 → 0.7.24

package/dist/http/helpers/autopilot-runtime.js

@@ -199,7 +199,11 @@ export function createAutopilotRuntime(deps) {
     function spawnCodexSliceWorker(input) {
         ensurePrivateDirForFile(input.logPath);
         ensurePrivateDirForFile(input.outputPath);
-        const workerKind = (process.env.ORGX_AUTOPILOT_WORKER_KIND ?? "").trim().toLowerCase();
+        const workerKind = (input.env.ORGX_AUTOPILOT_WORKER_KIND ??
+            process.env.ORGX_AUTOPILOT_WORKER_KIND ??
+            "")
+            .trim()
+            .toLowerCase();
         if (workerKind === "mock") {
             const scriptPath = resolve(dirname(deps.filename), "..", "..", "scripts", "mock-autopilot-slice-worker.mjs");
             const logStream = createSafeAppendStream(input.logPath);

package/dist/http/helpers/autopilot-slice-utils.js

@@ -33,7 +33,27 @@ function autopilotSliceSchema() {
     const decisionProperties = {
         question: { type: "string", minLength: 1 },
         summary: { type: ["string", "null"] },
-        options: { type: ["array", "null"], items: { type: "string" } },
+        options: {
+            type: ["array", "null"],
+            items: {
+                type: ["string", "object"],
+                minLength: 1,
+                additionalProperties: false,
+                required: ["label"],
+                properties: {
+                    id: { type: ["string", "null"] },
+                    label: { type: "string", minLength: 1 },
+                    description: { type: ["string", "null"] },
+                    consequences: { type: ["string", "null"] },
+                    implied_status: {
+                        type: ["string", "null"],
+                        enum: ["approved", "declined", "cancelled", "rejected", null],
+                    },
+                    action_type: { type: ["string", "null"] },
+                    requires_note: { type: ["boolean", "null"] },
+                },
+            },
+        },
         urgency: {
             type: ["string", "null"],
             enum: ["low", "medium", "high", "urgent", null],
@@ -859,6 +879,8 @@ export function buildSliceOutputInstructions(input) {
         "- Artifacts must be verifiable: include URLs or local paths, plus verification steps.",
         "- Include `confidence_score` for each artifact (`0` to `1`; use `null` when unknown).",
         "- If you need a human decision, include it in decisions_needed.",
+        "- Prefer structured decision options objects with: id, label, description, consequences, implied_status, action_type, requires_note.",
+        "- String options are still accepted, but structured options are required for precise decision routing.",
         "- For every decisions_needed entry, ALWAYS set blocking explicitly (true or false).",
         "- If status is blocked, needs_decision, or error: include at least one decisions_needed entry with blocking=true.",
         "- Status/decision consistency is strict:",
@@ -959,6 +981,8 @@ export function buildWorkstreamSlicePrompt(input) {
         "- Artifacts must be verifiable: include URLs or local paths, plus verification steps.",
         "- Include `confidence_score` for each artifact (`0` to `1`; use `null` when unknown).",
         "- If you need a human decision, include it in decisions_needed.",
+        "- Prefer structured decision options objects with: id, label, description, consequences, implied_status, action_type, requires_note.",
+        "- String options are still accepted, but structured options are required for precise decision routing.",
         "- For every decisions_needed entry, ALWAYS set blocking explicitly (true or false).",
         "- If status is blocked, needs_decision, or error: include at least one decisions_needed entry with blocking=true.",
         "- Status/decision consistency is strict:",

package/dist/http/helpers/decision-mapper.d.ts

@@ -5,6 +5,7 @@ type LiveDecisionOption = {
     id: string;
     label: string;
     description: string | null;
+    consequences: string | null;
     impliedStatus: LiveDecisionOptionStatus | null;
     actionType: DecisionActionType | null;
     requiresNote: boolean;

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

@@ -76,6 +76,7 @@ function parseDecisionOptions(record) {
                 id,
                 label,
                 description: null,
+                consequences: null,
                 impliedStatus: null,
                 actionType: null,
                 requiresNote: false,
@@ -103,6 +104,9 @@ function parseDecisionOptions(record) {
             id,
             label,
             description: typeof candidate.description === "string" ? candidate.description : null,
+            consequences: (typeof candidate.consequences === "string" && candidate.consequences.trim()) ||
+                (typeof candidate.impact === "string" && candidate.impact.trim()) ||
+                null,
             impliedStatus: normalizeOptionStatus(candidate.implied_status) ??
                 normalizeOptionStatus(candidate.status) ??
                 normalizeOptionStatus(candidate.disposition),
@@ -202,6 +206,15 @@ export function mapDecisionEntity(entity) {
             : 0);
     const options = parseDecisionOptions(record);
     const evidenceRefs = parseEvidenceRefs(record);
+    const metadataBlocker = asRecord(metadata?.blocker);
+    const envelopeBlocker = asRecord(envelope?.blocker);
+    const blockerContext = (metadataBlocker
+        ? pickString(metadataBlocker, ["description", "summary", "required_action", "requiredAction"])
+        : null) ??
+        (envelopeBlocker
+            ? pickString(envelopeBlocker, ["description", "summary", "required_action", "requiredAction"])
+            : null) ??
+        null;
     return {
         id: String(record.id ?? ""),
         title: pickStringFromRecords(containers, ["title", "name"]) ?? "Decision",
@@ -212,7 +225,7 @@ export function mapDecisionEntity(entity) {
             "details",
             "recommended_action",
             "recommendedAction",
-        ]),
+        ]) ?? blockerContext,
         status: pickStringFromRecords(containers, ["status", "decision_status"]) ?? "pending",
         priority: pickStringFromRecords(containers, ["priority"]),
         decisionType: pickStringFromRecords(containers, ["decision_type", "decisionType"]),
@@ -239,7 +252,11 @@ export function mapDecisionEntity(entity) {
         recommendedAction: pickStringFromRecords(containers, [
             "recommended_action",
             "recommendedAction",
-        ]),
+        ]) ??
+            (metadataBlocker
+                ? pickString(metadataBlocker, ["required_action", "requiredAction"])
+                : null) ??
+            null,
         occurrenceCount: pickNumberFromRecords(containers, ["occurrence_count", "occurrenceCount"]),
         firstSeenAt: toIsoString(pickStringFromRecords(containers, ["first_seen_at", "firstSeenAt"])),
         lastSeenAt: toIsoString(pickStringFromRecords(containers, ["last_seen_at", "lastSeenAt"])),

package/dist/http/helpers/dispatch-lifecycle.js

@@ -278,6 +278,9 @@ export function createDispatchLifecycle(deps) {
             if (typeof record.description === "string" && record.description.trim()) {
                 optionPayload.description = record.description.trim();
             }
+            if (typeof record.consequences === "string" && record.consequences.trim()) {
+                optionPayload.consequences = record.consequences.trim();
+            }
             if (typeof record.implied_status === "string" && record.implied_status.trim()) {
                 const implied = record.implied_status.trim().toLowerCase();
                 if (implied === "approved" ||

package/dist/http/helpers/mission-control.d.ts

@@ -92,6 +92,7 @@ export declare function isBlockedStatus(status: string): boolean;
 export declare function isInProgressStatus(status: string): boolean;
 export declare function deriveInitiativeLifecycleStatus(currentStatus: string, childStatuses: string[]): string;
 export declare function isDispatchableWorkstreamStatus(status: string): boolean;
+export declare function normalizeMissionControlStatus(status: string | null | undefined): string;
 export declare function isDoneStatus(status: string): boolean;
 export declare function listEntitiesSafe(client: OrgXClient, type: MissionControlNodeType, filters: Record<string, unknown>): Promise<{
     items: Entity[];

package/dist/http/helpers/mission-control.js

@@ -681,7 +681,7 @@ export function deriveInitiativeLifecycleStatus(currentStatus, childStatuses) {
     return currentStatus;
 }
 export function isDispatchableWorkstreamStatus(status) {
-    const normalized = status.toLowerCase();
+    const normalized = normalizeMissionControlStatus(status);
     if (!normalized)
         return true;
     return !(normalized === "blocked" ||
@@ -691,8 +691,11 @@ export function isDispatchableWorkstreamStatus(status) {
         normalized === "archived" ||
         normalized === "deleted");
 }
+export function normalizeMissionControlStatus(status) {
+    return (status ?? "").trim().toLowerCase().replace(/[\s-]+/g, "_");
+}
 export function isDoneStatus(status) {
-    const normalized = status.toLowerCase();
+    const normalized = normalizeMissionControlStatus(status);
     return (normalized === "done" ||
         normalized === "completed" ||
         normalized === "cancelled" ||

package/dist/http/helpers/slice-run-projections.d.ts

@@ -16,6 +16,31 @@ export type SliceRunDecisionOption = {
     impliedStatus: string | null;
     requiresNote: boolean;
 };
+export type SliceRunPendingDecision = {
+    id: string;
+    title: string;
+    summary: string | null;
+    status: string;
+    blocking: boolean;
+    decisionType: string | null;
+    recommendedAction: string | null;
+    updatedAt: string | null;
+    sourceRunId: string | null;
+    sourceClient: string | null;
+    evidenceCount: number;
+    options: SliceRunDecisionOption[];
+};
+export type SliceRunBlockerSummary = {
+    id: string;
+    reason: string;
+    waitingOn: string | null;
+    requiredAction: string | null;
+    source: string | null;
+    eventType: string | null;
+    eventAt: string | null;
+    severity: "info" | "warn" | "error";
+    decisionIds: string[];
+};
 export type SliceRunProjection = {
     id: string;
     sliceRunId: string;
@@ -38,6 +63,8 @@ export type SliceRunProjection = {
     decisionCount: number;
     blockingDecisionCount: number;
     decisionOptions: SliceRunDecisionOption[];
+    pendingDecisions: SliceRunPendingDecision[];
+    blockers: SliceRunBlockerSummary[];
     sourceClient: string | null;
     runtimeState: string | null;
     startedAt: string | null;

package/dist/http/helpers/slice-run-projections.js

@@ -257,6 +257,8 @@ function createProjection(sliceRunId) {
         decisionCount: 0,
         blockingDecisionCount: 0,
         decisionOptions: [],
+        pendingDecisions: [],
+        blockers: [],
         sourceClient: null,
         runtimeState: null,
         startedAt: null,
@@ -274,6 +276,8 @@ function createProjection(sliceRunId) {
         _artifactIds: new Set(),
         _hasExplicitCompletion: false,
         _peakReportedArtifacts: 0,
+        _pendingDecisionById: new Map(),
+        _blockerByKey: new Map(),
     };
 }
 function upsertProjection(map, sliceRunId) {
@@ -403,6 +407,19 @@ function maybeAddArtifact(projection, item, metadata) {
 function mergeDecisionOptions(projection, optionsRaw) {
     if (!Array.isArray(optionsRaw))
         return;
+    const next = parseDecisionOptions(optionsRaw);
+    if (next.length === 0)
+        return;
+    const merged = new Map();
+    for (const option of projection.decisionOptions)
+        merged.set(option.id, option);
+    for (const option of next)
+        merged.set(option.id, option);
+    projection.decisionOptions = Array.from(merged.values()).slice(0, 8);
+}
+function parseDecisionOptions(optionsRaw) {
+    if (!Array.isArray(optionsRaw))
+        return [];
     const next = [];
     for (const option of optionsRaw) {
         const record = asRecord(option);
@@ -420,14 +437,169 @@ function mergeDecisionOptions(projection, optionsRaw) {
             requiresNote: metadataBoolean(record, ["requiresNote", "requires_note"]) ?? false,
         });
     }
-    if (next.length === 0)
+    return next;
+}
+function extractDecisionIdsFromMetadata(metadata) {
+    if (!metadata)
+        return [];
+    const ids = new Set();
+    for (const id of metadataStringArray(metadata, [
+        "decision_id",
+        "decisionId",
+        "decision_ids",
+        "decisionIds",
+        "blocking_decision_ids",
+        "blockingDecisionIds",
+        "non_blocking_decision_ids",
+        "nonBlockingDecisionIds",
+    ])) {
+        ids.add(id);
+    }
+    const decisionsNeededRaw = metadata.decisions_needed ?? metadata.decisionsNeeded;
+    if (Array.isArray(decisionsNeededRaw)) {
+        for (const item of decisionsNeededRaw) {
+            const record = asRecord(item);
+            if (!record)
+                continue;
+            const directId = normalizeText(record.id) ??
+                normalizeText(record.decision_id) ??
+                normalizeText(record.decisionId);
+            if (directId)
+                ids.add(directId);
+        }
+    }
+    return Array.from(ids);
+}
+function normalizePendingDecisionStatus(value) {
+    return (value ?? "pending").trim().toLowerCase() || "pending";
+}
+function isDecisionResolvedStatus(status) {
+    return (status === "approved" ||
+        status === "declined" ||
+        status === "cancelled" ||
+        status === "resolved" ||
+        status === "closed");
+}
+function upsertPendingDecision(projection, decisionRecord, metadata) {
+    const decisionId = normalizeText(decisionRecord.id) ??
+        normalizeText(decisionRecord.decision_id) ??
+        normalizeText(decisionRecord.entity_id);
+    if (!decisionId)
         return;
-    const merged = new Map();
-    for (const option of projection.decisionOptions)
-        merged.set(option.id, option);
-    for (const option of next)
-        merged.set(option.id, option);
-    projection.decisionOptions = Array.from(merged.values()).slice(0, 8);
+    const status = normalizePendingDecisionStatus(normalizeText(decisionRecord.status));
+    if (isDecisionResolvedStatus(status)) {
+        projection._pendingDecisionById.delete(decisionId);
+        return;
+    }
+    const options = parseDecisionOptions(decisionRecord.options ??
+        decisionRecord.decision_options ??
+        metadata?.options ??
+        metadata?.decision_options);
+    if (options.length > 0) {
+        mergeDecisionOptions(projection, options);
+    }
+    const evidenceGroup = decisionRecord.evidenceRefs ??
+        decisionRecord.evidence_refs ??
+        metadata?.evidence_refs ??
+        metadata?.decision_evidence;
+    const evidenceCount = Array.isArray(evidenceGroup) ? evidenceGroup.length : 0;
+    const updatedAt = toIso(normalizeText(decisionRecord.updatedAt)) ??
+        toIso(normalizeText(decisionRecord.updated_at)) ??
+        toIso(normalizeText(decisionRecord.requestedAt)) ??
+        toIso(normalizeText(decisionRecord.requested_at)) ??
+        projection.updatedAt;
+    projection._pendingDecisionById.set(decisionId, {
+        id: decisionId,
+        title: normalizeText(decisionRecord.title) ??
+            normalizeText(decisionRecord.name) ??
+            "Pending decision",
+        summary: normalizeText(decisionRecord.context) ??
+            normalizeText(decisionRecord.summary) ??
+            normalizeText(decisionRecord.description) ??
+            normalizeText(metadata?.summary) ??
+            null,
+        status,
+        blocking: metadataBoolean(metadata, ["blocking"]) !== false,
+        decisionType: normalizeText(decisionRecord.decisionType) ??
+            normalizeText(decisionRecord.decision_type) ??
+            normalizeText(metadata?.decision_type) ??
+            null,
+        recommendedAction: normalizeText(decisionRecord.recommendedAction) ??
+            normalizeText(decisionRecord.recommended_action) ??
+            normalizeText(metadata?.recommended_action) ??
+            null,
+        updatedAt,
+        sourceRunId: normalizeText(decisionRecord.sourceRunId) ??
+            normalizeText(decisionRecord.source_run_id) ??
+            normalizeText(metadata?.source_run_id) ??
+            normalizeText(metadata?.run_id) ??
+            normalizeText(metadata?.correlation_id) ??
+            null,
+        sourceClient: normalizeText(decisionRecord.sourceClient) ??
+            normalizeText(decisionRecord.source_client) ??
+            normalizeText(metadata?.source_client) ??
+            null,
+        evidenceCount,
+        options: options.slice(0, 4),
+    });
+}
+function inferBlockerFromActivity(item, metadata, event, atIso) {
+    const blocker = asRecord(metadata?.blocker);
+    const reason = normalizeText(blocker?.description) ??
+        normalizeText(blocker?.summary) ??
+        metadataString(metadata, ["error", "reason", "blocked_reason", "blockedReason", "last_error", "lastError"]) ??
+        normalizeText(item.summary) ??
+        normalizeText(item.description) ??
+        null;
+    if (!reason)
+        return null;
+    const waitingOn = normalizeText(blocker?.waiting_on) ??
+        normalizeText(blocker?.required_actor) ??
+        metadataString(metadata, ["waiting_on", "required_actor", "requiredActor"]) ??
+        null;
+    const requiredAction = normalizeText(blocker?.required_action) ??
+        normalizeText(blocker?.requiredAction) ??
+        metadataString(metadata, ["next_step", "nextStep", "recommended_action", "recommendedAction"]) ??
+        null;
+    const source = metadataString(metadata, ["source", "source_system", "sourceSystem"]) ??
+        null;
+    const severity = item.type === "run_failed" || event.includes("failed") || event.includes("error")
+        ? "error"
+        : item.type === "blocker_created" || event.includes("blocked")
+            ? "warn"
+            : "info";
+    const decisionIds = extractDecisionIdsFromMetadata(metadata);
+    return {
+        id: normalizeText(item.id) ?? `${event || item.type}:${atIso ?? "unknown"}`,
+        reason,
+        waitingOn,
+        requiredAction,
+        source,
+        eventType: event || item.type,
+        eventAt: atIso,
+        severity,
+        decisionIds,
+    };
+}
+function upsertBlocker(projection, blocker) {
+    const key = [
+        blocker.reason.trim().toLowerCase(),
+        blocker.waitingOn?.trim().toLowerCase() ?? "",
+        blocker.requiredAction?.trim().toLowerCase() ?? "",
+    ].join("|");
+    const existing = projection._blockerByKey.get(key);
+    if (!existing) {
+        projection._blockerByKey.set(key, blocker);
+        return;
+    }
+    const existingEpoch = toEpoch(existing.eventAt);
+    const nextEpoch = toEpoch(blocker.eventAt);
+    const keep = nextEpoch >= existingEpoch ? blocker : existing;
+    keep.decisionIds = dedupeStrings([
+        ...(existing.decisionIds ?? []),
+        ...(blocker.decisionIds ?? []),
+    ]);
+    projection._blockerByKey.set(key, keep);
 }
 function applySessionFallback(projection, session) {
     const status = (session.status ?? "").trim().toLowerCase();
@@ -500,6 +672,10 @@ export function buildSliceRunProjections(input) {
         const projection = upsertProjection(projections, sliceRunId);
         updateProjectionContext(projection, item, metadata);
         const atIso = toIso(item.timestamp);
+        const blockerFromEvent = inferBlockerFromActivity(item, metadata, event, atIso);
+        if (blockerFromEvent) {
+            upsertBlocker(projection, blockerFromEvent);
+        }
         if (item.type === "artifact_created") {
             maybeAddArtifact(projection, item, metadata);
             if (projection.status !== "failed" && projection.status !== "archived") {
@@ -716,14 +892,20 @@ export function buildSliceRunProjections(input) {
         if (!projection)
             continue;
         const status = (normalizeText(decisionRecord?.status) ?? "pending").toLowerCase();
-        if (status === "approved" || status === "declined" || status === "cancelled" || status === "resolved") {
-            continue;
+        if (decisionRecord) {
+            upsertPendingDecision(projection, decisionRecord, metadata);
         }
+        if (isDecisionResolvedStatus(status))
+            continue;
         projection.decisionCount += 1;
         const isBlocking = metadataBoolean(metadata, ["blocking"]) !== false;
         if (isBlocking)
             projection.blockingDecisionCount += 1;
-        mergeDecisionOptions(projection, decisionRecord?.options ?? null);
+        mergeDecisionOptions(projection, decisionRecord?.options ??
+            decisionRecord?.decision_options ??
+            metadata?.options ??
+            metadata?.decision_options ??
+            null);
         const updatedAt = toIso(normalizeText(decisionRecord?.updatedAt)) ??
             toIso(normalizeText(decisionRecord?.requestedAt)) ??
             projection.updatedAt;
@@ -851,6 +1033,12 @@ export function buildSliceRunProjections(input) {
             decisionCount: projection.decisionCount,
             blockingDecisionCount: projection.blockingDecisionCount,
             decisionOptions: projection.decisionOptions,
+            pendingDecisions: Array.from(projection._pendingDecisionById.values())
+                .sort((a, b) => toEpoch(b.updatedAt) - toEpoch(a.updatedAt))
+                .slice(0, 8),
+            blockers: Array.from(projection._blockerByKey.values())
+                .sort((a, b) => toEpoch(b.eventAt) - toEpoch(a.eventAt))
+                .slice(0, 6),
             sourceClient: projection.sourceClient,
             runtimeState: projection.runtimeState,
             startedAt: projection.startedAt,