@useorgx/openclaw-plugin 0.7.18 → 0.7.23

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,