@useorgx/openclaw-plugin 0.7.20 → 0.7.24

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

@@ -5,6 +5,298 @@
  * `LiveTriageItem` objects with proof bundles and recommended actions.
  */
 import { callLlmJson } from "./llm-client.js";
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function pickString(record, keys) {
+    if (!record)
+        return null;
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value !== "string")
+            continue;
+        const normalized = value.trim();
+        if (normalized.length > 0)
+            return normalized;
+    }
+    return null;
+}
+function pickStringArray(record, keys) {
+    if (!record)
+        return [];
+    const values = [];
+    for (const key of keys) {
+        const candidate = record[key];
+        if (!Array.isArray(candidate))
+            continue;
+        for (const entry of candidate) {
+            if (typeof entry !== "string")
+                continue;
+            const normalized = entry.trim();
+            if (normalized.length > 0)
+                values.push(normalized);
+        }
+        if (values.length > 0)
+            break;
+    }
+    return values;
+}
+function countArray(record, keys) {
+    if (!record)
+        return 0;
+    for (const key of keys) {
+        const candidate = record[key];
+        if (Array.isArray(candidate))
+            return candidate.length;
+    }
+    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);
+    const blocker = asRecord(metadata?.blocker) ?? asRecord(result?.blocker);
+    const blockerReason = pickString(blocker, ["description", "summary"]) ??
+        pickString(result, ["blocked_reason", "blockedReason", "error"]) ??
+        pickString(metadata, ["blocked_reason", "blockedReason", "error", "reason"]) ??
+        (typeof input.reason === "string" && input.reason.trim().length > 0 ? input.reason.trim() : null);
+    const waitingOn = pickString(blocker, ["waiting_on", "required_actor", "requiredActor"]) ??
+        pickString(result, ["waiting_on", "required_actor", "requiredActor"]) ??
+        pickString(metadata, ["waiting_on", "required_actor", "requiredActor"]);
+    const nextActions = [
+        ...pickStringArray(result, ["next_actions", "nextActions"]),
+        ...pickStringArray(metadata, ["next_actions", "nextActions"]),
+    ];
+    const requiredAction = pickString(blocker, ["required_action", "requiredAction"]) ??
+        pickString(result, ["required_action", "requiredAction"]) ??
+        pickString(metadata, ["required_action", "requiredAction"]) ??
+        (nextActions[0] ?? null);
+    const requiredActor = pickString(blocker, ["required_actor", "requiredActor"]) ??
+        pickString(result, ["required_actor", "requiredActor"]) ??
+        pickString(metadata, ["required_actor", "requiredActor"]);
+    const suggestedActions = [
+        ...pickStringArray(blocker, ["suggested_actions", "suggestedActions"]),
+        ...pickStringArray(result, ["suggested_actions", "suggestedActions"]),
+        ...pickStringArray(metadata, ["suggested_actions", "suggestedActions"]),
+    ];
+    const decisionIds = [
+        ...pickStringArray(result, ["decision_ids", "decisionIds"]),
+        ...pickStringArray(metadata, ["decision_ids", "decisionIds"]),
+    ];
+    const retryable = typeof blocker?.retryable === "boolean"
+        ? blocker.retryable
+        : typeof result?.retryable === "boolean"
+            ? result.retryable
+            : typeof metadata?.retryable === "boolean"
+                ? metadata.retryable
+                : null;
+    const errorCode = pickString(blocker, ["error_code", "errorCode"]) ??
+        pickString(result, ["error_code", "errorCode"]) ??
+        pickString(metadata, ["error_code", "errorCode"]);
+    const errorCategory = pickString(blocker, ["error_category", "errorCategory"]) ??
+        pickString(result, ["error_category", "errorCategory"]) ??
+        pickString(metadata, ["error_category", "errorCategory"]);
+    const taskUpdateCount = countArray(result, ["task_updates", "taskUpdates"]) ||
+        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,
+        requiredAction,
+        requiredActor,
+        retryable,
+        errorCode,
+        errorCategory,
+        suggestedActions: suggestedActions.length > 0 ? Array.from(new Set(suggestedActions)) : [],
+        nextActions: nextActions.length > 0 ? Array.from(new Set(nextActions)) : [],
+        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,
+        context.waitingOn,
+        context.requiredAction,
+        context.requiredActor,
+        context.errorCode,
+        context.errorCategory,
+        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;
+        return entry != null && String(entry).trim().length > 0;
+    });
+    return hasValue ? context : null;
+}
 const FAILURE_MAPPINGS = {
     credential_missing: {
         kind: "blocked_intervention",
@@ -180,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",
@@ -288,16 +646,33 @@ export async function mapFailureToTriageItem(input) {
         metadata: input.metadata,
     };
     const now = input.timestamp ?? new Date().toISOString();
+    const intervention = deriveInterventionContext({
+        reason: input.reason ?? null,
+        metadata: input.metadata,
+    });
     const proofBundle = {
         artifactRefs: [],
         fileChanges: [],
         prRefs: [],
         logRefs: input.logPath ? [input.logPath] : [],
-        decisionRefs: [],
+        decisionRefs: intervention?.decisionIds ?? [],
     };
     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,
@@ -380,6 +755,25 @@ export async function mapFailureToTriageItem(input) {
             },
         ];
     }
+    const summaryDetails = [];
+    if (intervention?.waitingOn)
+        summaryDetails.push(`Waiting on ${intervention.waitingOn}.`);
+    if (intervention?.requiredAction)
+        summaryDetails.push(`Required action: ${intervention.requiredAction}.`);
+    if (intervention?.errorCode)
+        summaryDetails.push(`Error code: ${intervention.errorCode}.`);
+    if (intervention?.taskUpdateCount && intervention.taskUpdateCount > 0) {
+        summaryDetails.push(`${intervention.taskUpdateCount} task update${intervention.taskUpdateCount === 1 ? "" : "s"} pending apply.`);
+    }
+    if (intervention?.milestoneUpdateCount && intervention.milestoneUpdateCount > 0) {
+        summaryDetails.push(`${intervention.milestoneUpdateCount} milestone update${intervention.milestoneUpdateCount === 1 ? "" : "s"} pending apply.`);
+    }
+    if (summaryDetails.length > 0) {
+        summary = `${summary} ${summaryDetails.join(" ")}`.trim();
+    }
+    if (intervention?.requiredAction) {
+        recommendedAction = intervention.requiredAction;
+    }
     return {
         id: input.id,
         kind,
@@ -407,6 +801,7 @@ export async function mapFailureToTriageItem(input) {
         blocking: kind === "blocked_intervention" || kind === "decision_required",
         recommendedAction,
         agentId: input.agentId ?? null,
+        intervention,
         impact,
         proofBundle,
         actionContract,
@@ -426,7 +821,73 @@ export function mapDecisionToTriageItem(decision) {
     const now = new Date().toISOString();
     const decisionType = decision.decisionType ?? "decision_required";
     const mapping = FAILURE_MAPPINGS[decisionType];
-    const actions = [
+    const metadata = decision.metadata && typeof decision.metadata === "object" && !Array.isArray(decision.metadata)
+        ? decision.metadata
+        : null;
+    const intervention = deriveInterventionContext({
+        reason: decision.context ?? null,
+        metadata: metadata ?? undefined,
+    });
+    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();
+        const action = implied === "declined" || implied === "cancelled" ? "reject" : "approve";
+        const optionConsequences = typeof option.consequences === "string" && option.consequences.trim().length > 0
+            ? option.consequences.trim()
+            : null;
+        const consequences = optionConsequences ??
+            (action === "approve"
+                ? "Will continue execution using this option."
+                : "Will decline this direction and keep the run blocked.");
+        return {
+            action,
+            label: option.label,
+            description: option.description ?? (action === "approve" ? "Approve this option" : "Reject with this rationale"),
+            consequences,
+            requiresNote: option.requiresNote === true,
+            available: true,
+            optionId: option.id,
+        };
+    })
+        .slice(0, 4);
+    const fallbackActions = [
         {
             action: "approve",
             label: "Approve",
@@ -434,6 +895,7 @@ export function mapDecisionToTriageItem(decision) {
             consequences: "Will proceed with the recommended action.",
             requiresNote: false,
             available: true,
+            optionId: null,
         },
         {
             action: "reject",
@@ -442,7 +904,20 @@ export function mapDecisionToTriageItem(decision) {
             consequences: "Agent will pause and await new instructions.",
             requiresNote: true,
             available: true,
+            optionId: null,
         },
+    ];
+    const optionActionsWithCoverage = [...optionActions];
+    if (optionActionsWithCoverage.length > 0) {
+        if (!optionActionsWithCoverage.some((action) => action.action === "approve")) {
+            optionActionsWithCoverage.unshift(fallbackActions[0]);
+        }
+        if (!optionActionsWithCoverage.some((action) => action.action === "reject")) {
+            optionActionsWithCoverage.push(fallbackActions[1]);
+        }
+    }
+    const actions = [
+        ...(optionActionsWithCoverage.length > 0 ? optionActionsWithCoverage.slice(0, 4) : fallbackActions),
         {
             action: "snooze",
             label: "Snooze",
@@ -450,6 +925,7 @@ export function mapDecisionToTriageItem(decision) {
             consequences: "Item reappears after snooze period.",
             requiresNote: false,
             available: true,
+            optionId: null,
         },
     ];
     const proofBundle = {
@@ -457,20 +933,36 @@ export function mapDecisionToTriageItem(decision) {
         fileChanges: [],
         prRefs: [],
         logRefs: [],
-        decisionRefs: [decision.id],
+        decisionRefs: Array.from(new Set([decision.id, ...(enrichedIntervention?.decisionIds ?? [])].filter(Boolean))),
     };
     if (decision.evidenceRefs) {
         for (const ref of decision.evidenceRefs) {
             if (ref.sourceUrl)
                 proofBundle.artifactRefs.push(ref.sourceUrl);
+            if (ref.sourcePointer)
+                proofBundle.logRefs.push(ref.sourcePointer);
         }
     }
+    const summaryBase = (typeof decision.context === "string" && decision.context.trim()) ||
+        enrichedIntervention?.blockerReason ||
+        decision.title;
+    const summarySuffix = [
+        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 ??
+        enrichedIntervention?.recommendedAction ??
+        enrichedIntervention?.requiredAction ??
+        null;
     return {
         id: `triage-decision-${decision.id}`,
         kind: mapping?.kind ?? "decision_required",
         status: decision.status === "pending" ? "open" : decision.status === "resolved" ? "resolved" : "open",
         title: decision.title,
-        summary: decision.context ?? decision.title,
+        summary,
         initiativeId: decision.initiativeId ?? null,
         initiativeTitle: null,
         workstreamId: decision.workstreamId ?? null,
@@ -482,9 +974,10 @@ export function mapDecisionToTriageItem(decision) {
         dedupeKey: decision.dedupeKey ?? null,
         occurrenceCount: decision.occurrenceCount ?? 1,
         severity: decision.priority === "urgent" ? "critical" : decision.priority === "high" ? "high" : "medium",
-        blocking: true,
-        recommendedAction: decision.recommendedAction ?? null,
+        blocking,
+        recommendedAction,
         agentId: decision.agentId ?? null,
+        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.d.ts

@@ -70,6 +70,7 @@ interface OnboardingController {
         apiKey: string;
         userId?: string;
     }) => Promise<OnboardingState>;
+    cancelPairing?: () => Promise<OnboardingState>;
     disconnect: () => Promise<OnboardingState>;
 }
 interface DiagnosticsProvider {