@muxoai/platform 1.4.2 → 1.4.3

package/.agents/plugins/marketplace.json

@@ -6,7 +6,7 @@
   "plugins": [
     {
       "name": "muxo",
-      "version": "1.4.2",
+      "version": "1.4.3",
       "description": "Governed execution across 1,000+ Connected Apps, Instant Tools (search, scrape, crawl, SEO audit), Cloud Infrastructure provisioning, Workspace Memory recall, and cryptographic execution receipts.",
       "source": {
         "source": "local",

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
   },
   "metadata": {
     "description": "Official Muxo plugin marketplace for governed execution across Connected Apps, Instant Tools, Cloud Infrastructure, and Workspace Memory.",
-    "version": "1.4.2"
+    "version": "1.4.3"
   },
   "plugins": [
     {
@@ -19,7 +19,7 @@
       },
       "strict": false,
       "description": "Governed execution across 1,000+ Connected Apps, Instant Tools (search, scrape, crawl, SEO audit), Cloud Infrastructure provisioning, Workspace Memory recall, and verifiable audit records.",
-      "version": "1.4.2",
+      "version": "1.4.3",
       "category": "Productivity",
       "skills": [
         "./plugins/muxo/skills/muxo",

package/README.md

@@ -1,6 +1,6 @@
 # Muxo (`@muxoai/platform` / `@muxoai/cli` / `@muxoai/sdk`)
 
-Muxo (`v1.4.2`) is the unified execution, cloud infrastructure provisioning, contextual memory, and cryptographic governance platform for AI agents and applications. Customers and their agents interact exclusively with **Muxo** — either via structured tool slugs or free-form **Natural Language** (`muxo do`, `POST /api/v1/do`, `client.do()`, and MCP `plan_action`).
+Muxo (`v1.4.3`) is the unified execution, cloud infrastructure provisioning, contextual memory, and cryptographic governance platform for AI agents and applications. Customers and their agents interact exclusively with **Muxo** — either via structured tool slugs or free-form **Natural Language** (`muxo do`, `POST /api/v1/do`, `client.do()`, and MCP `plan_action`).
 
 See [`ARCHITECTURE.md`](./ARCHITECTURE.md) for the complete internal engineering blueprint, open-source ecosystem Keep/Adopt/Drop matrix, and 4-pillar architecture.
 

package/dist/cli.js

@@ -2321,6 +2321,90 @@ async function runCli() {
         console.log(JSON.stringify(result, null, 2));
         return;
     }
+    if (cmd === "playbooks" || cmd === "playbook") {
+        const sub = positional[1];
+        if (sub === "run") {
+            const slug = positional[2] ||
+                flags.slug ||
+                "fullstack-cloud-bootstrap";
+            const input = flags.input
+                ? JSON.parse(String(flags.input))
+                : {};
+            if (remoteUrl) {
+                const res = await remoteFetch(`/api/v1/playbooks/${encodeURIComponent(slug)}/run`, {
+                    method: "POST",
+                    body: { input },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { engine, ctx } = getLocalContext();
+            const res = engine.runCommercialPlaybook(ctx, { slug, input });
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        if (remoteUrl) {
+            const res = await remoteFetch("/api/v1/playbooks");
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const { engine } = getLocalContext();
+        const playbooks = engine.listCommercialPlaybooks();
+        console.log(JSON.stringify({ ok: true, count: playbooks.length, playbooks }, null, 2));
+        return;
+    }
+    if (cmd === "roi") {
+        if (remoteUrl) {
+            const res = await remoteFetch("/api/v1/analytics/roi");
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const { engine, ctx } = getLocalContext();
+        console.log(JSON.stringify({ ok: true, ...engine.getCommercialRoiReport(ctx) }, null, 2));
+        return;
+    }
+    if (cmd === "cedar") {
+        const sub = positional[1];
+        if (sub === "evaluate" || sub === "eval") {
+            const toolSlug = positional[2] || flags.tool || "instant.web.search";
+            const input = flags.input
+                ? JSON.parse(String(flags.input))
+                : {};
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/governance/cedar/evaluate", {
+                    method: "POST",
+                    body: { toolSlug, input },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { engine, ctx } = getLocalContext();
+            console.log(JSON.stringify({
+                ok: true,
+                ...engine.evaluatePolicyAsCode(ctx, { toolSlug, input }),
+            }, null, 2));
+            return;
+        }
+        if (remoteUrl) {
+            const res = await remoteFetch("/api/v1/governance/cedar");
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const { engine, ctx } = getLocalContext();
+        console.log(JSON.stringify({ ok: true, ...engine.getPolicyAsCodeBundle(ctx) }, null, 2));
+        return;
+    }
+    if (cmd === "telemetry" || cmd === "otel") {
+        const limit = flags.limit ? Number(flags.limit) : 25;
+        if (remoteUrl) {
+            const res = await remoteFetch(`/api/v1/telemetry/otlp?limit=${limit}`);
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const { engine, ctx } = getLocalContext();
+        console.log(JSON.stringify({ ok: true, ...engine.exportOtelTraces(ctx, limit) }, null, 2));
+        return;
+    }
     console.log(`
 Muxo CLI — Unified Agent Execution, Cloud Infrastructure, Memory & Safety Platform
 
@@ -2365,6 +2449,10 @@ Core Commands:
   muxo governance scan <text>                  Check text for prompt injection before storing or sending it
   muxo governance policy [--mode enforce|monitor] [--ring 0-3] [--require-approval write,admin|none]
                          [--block-destructive-sql true|false] [--max-credits <n>]
+  muxo cedar [evaluate <tool_slug>]            Compile or evaluate AWS Cedar 4.x & OPA Rego v1 policy-as-code
+  muxo telemetry [--limit 25]                  Export OpenTelemetry GenAI / MCP OTLP & Langfuse trace spans
+  muxo playbooks [run <slug>]                  List or execute Temporal-compatible commercial Saga playbooks
+  muxo roi                                     Compute FinOps unit economics, BYOK savings, and engineering ROI
   muxo harness                                 Check API, MCP, auth, governance and catalog; print MCP config
   muxo serve [--port 4310]                     Start unified HTTP Console, Landing, OAuth Callback & MCP server
   muxo mcp                                     Run stdio MCP server (19 canonical tools)

package/dist/durable-workflow.d.ts

@@ -1,22 +1,54 @@
-/** Cloud provisioning pipeline modelled on Cloudflare Workflows primitives, shared by the Node engine and the edge worker. */
+/**
+ * Temporal-compatible Durable Workflows, Saga Compensations, Signals, and Cloudflare Workflows primitives,
+ * shared by the Node engine (src/engine.ts) and the Cloudflare Edge Worker (worker/index.ts).
+ */
 import { MuxoToolError } from "./mcp-schema.js";
-export type DurableWorkflowStepStatus = "completed" | "waiting" | "pending";
+export type DurableWorkflowStepStatus = "completed" | "waiting" | "pending" | "failed" | "compensated";
 export interface DurableWorkflowStep {
     name: string;
     primitive: "step.do" | "step.waitForEvent" | "step.sleep";
     status: DurableWorkflowStepStatus;
     output?: Record<string, unknown>;
     completedAt?: string;
+    compensationAction?: string;
+    compensatedAt?: string;
+}
+export type TemporalEventType = "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED" | "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED" | "EVENT_TYPE_ACTIVITY_TASK_COMPLETED" | "EVENT_TYPE_ACTIVITY_TASK_FAILED" | "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED" | "EVENT_TYPE_TIMER_STARTED" | "EVENT_TYPE_TIMER_FIRED" | "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED" | "EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED" | "EVENT_TYPE_WORKFLOW_EXECUTION_FAILED";
+export interface TemporalHistoryEvent {
+    eventId: number;
+    eventTime: string;
+    eventType: TemporalEventType;
+    taskQueue: string;
+    attributes: Record<string, unknown>;
+}
+export interface SagaCompensationRecord {
+    stepName: string;
+    compensationAction: string;
+    status: "registered" | "executed" | "skipped";
+    description: string;
+    output?: Record<string, unknown>;
+    executedAt?: string;
+}
+export interface DurableWorkflowSignalRecord {
+    signalName: string;
+    payload: Record<string, unknown>;
+    receivedAt: string;
 }
 export interface DurableWorkflow {
     id: string;
+    runId?: string;
     workspaceId: string;
-    workflowType: "cloud_provisioning_pipeline" | "approval_handoff_pipeline";
-    status: "running" | "waiting_for_event" | "completed" | "failed";
+    workflowType: "cloud_provisioning_pipeline" | "approval_handoff_pipeline" | "commercial_playbook_saga";
+    playbookSlug?: string | null;
+    status: "running" | "waiting_for_event" | "completed" | "failed" | "rolled_back";
     provider: string;
     serviceRef: string;
     resourceId: string | null;
     steps: DurableWorkflowStep[];
+    compensations?: SagaCompensationRecord[];
+    signals?: DurableWorkflowSignalRecord[];
+    temporalEventHistory?: TemporalHistoryEvent[];
+    rollbackReason?: string | null;
     createdAt: string;
     updatedAt: string;
 }
@@ -43,3 +75,38 @@ export declare function completeCloudProvisioningWorkflow(wf: DurableWorkflow, p
     secretKeys: string[];
     triggerEvent?: unknown;
 }): DurableWorkflow;
+/**
+ * Executes LIFO Saga Compensations on a DurableWorkflow, rolling back completed steps in reverse order
+ * and recording Temporal compensation activity events.
+ */
+export declare function rollbackDurableWorkflow(wf: DurableWorkflow, params?: {
+    reason?: string;
+    failedStepName?: string;
+    failedStep?: string;
+}): DurableWorkflow;
+/**
+ * Sends a named Temporal signal to a DurableWorkflow (`human.approval.granted`, `oauth.connection.active`,
+ * `saga.abort`, or `v2.provisioning.resource.completed`).
+ */
+export declare function signalDurableWorkflow(wf: DurableWorkflow, params: {
+    signalName: string;
+    payload?: Record<string, unknown>;
+    secretKeys?: string[];
+}): DurableWorkflow;
+/**
+ * Exports a DurableWorkflow in Temporal Web UI / `temporal workflow show` compatible EventHistory JSON format.
+ */
+export declare function exportTemporalEventHistory(wf: DurableWorkflow): {
+    namespace: string;
+    workflowExecution: {
+        workflowId: string;
+        runId: string;
+    };
+    workflowType: {
+        name: string;
+    };
+    status: DurableWorkflow["status"];
+    eventsCount: number;
+    compensationsCount: number;
+    events: TemporalHistoryEvent[];
+};

package/dist/durable-workflow.js

@@ -1,4 +1,7 @@
-/** Cloud provisioning pipeline modelled on Cloudflare Workflows primitives, shared by the Node engine and the edge worker. */
+/**
+ * Temporal-compatible Durable Workflows, Saga Compensations, Signals, and Cloudflare Workflows primitives,
+ * shared by the Node engine (src/engine.ts) and the Cloudflare Edge Worker (worker/index.ts).
+ */
 import { MuxoToolError } from "./mcp-schema.js";
 export const WORKFLOW_RESOURCE_COMPLETED_EVENT = "v2.provisioning.resource.completed";
 export function workflowNotFoundError(workflowId) {
@@ -14,12 +17,70 @@ export function normalizeWorkflowTarget(params) {
         serviceRef: (params.serviceRef || "postgres").toLowerCase().trim(),
     };
 }
+function appendTemporalEvent(history, eventType, attributes, now = new Date().toISOString()) {
+    history.push({
+        eventId: history.length + 1,
+        eventTime: now,
+        eventType,
+        taskQueue: "muxo-durable-execution-queue",
+        attributes,
+    });
+}
 export function createCloudProvisioningWorkflow(params) {
     const now = new Date().toISOString();
+    const region = params.region || "aws-us-east-1";
+    const apiVersion = params.apiVersion || "2026-09-30.preview";
+    const history = [];
+    appendTemporalEvent(history, "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", {
+        workflowType: "cloud_provisioning_pipeline",
+        workflowId: params.id,
+        workspaceId: params.workspaceId,
+        provider: params.provider,
+        serviceRef: params.serviceRef,
+        region,
+    }, now);
+    appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+        activityName: "check_stripe_v2_eligibility",
+        result: { status: "eligible", apiVersion },
+    }, now);
+    appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+        activityName: "ensure_payment_profile_and_provider_connection",
+        result: { provider: params.provider, paymentProfileStatus: "active" },
+    }, now);
+    appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+        activityName: "create_v2_provisioning_resource",
+        result: {
+            resourceId: params.resourceId,
+            provider: params.provider,
+            service_ref: params.serviceRef,
+            region,
+        },
+        compensationAction: `resource.${params.provider}.remove`,
+    }, now);
+    appendTemporalEvent(history, "EVENT_TYPE_TIMER_STARTED", {
+        waitingForSignal: WORKFLOW_RESOURCE_COMPLETED_EVENT,
+        resourceId: params.resourceId,
+    }, now);
+    const compensations = [
+        {
+            stepName: "ensure_payment_profile_and_provider_connection",
+            compensationAction: `provisioning.provider_connection.unlink`,
+            status: "registered",
+            description: `Unlink provider connection for ${params.provider} if downstream provisioning aborts`,
+        },
+        {
+            stepName: "create_v2_provisioning_resource",
+            compensationAction: `resource.${params.provider}.remove`,
+            status: "registered",
+            description: `Deprovision ${params.provider}/${params.serviceRef} (${params.resourceId}) and release reservation`,
+        },
+    ];
     return {
         id: params.id,
+        runId: `run_${params.id}`,
         workspaceId: params.workspaceId,
         workflowType: "cloud_provisioning_pipeline",
+        playbookSlug: null,
         status: "waiting_for_event",
         provider: params.provider,
         serviceRef: params.serviceRef,
@@ -29,7 +90,7 @@ export function createCloudProvisioningWorkflow(params) {
                 name: "check_stripe_v2_eligibility",
                 primitive: "step.do",
                 status: "completed",
-                output: { status: "eligible", apiVersion: params.apiVersion || "2026-09-30.preview" },
+                output: { status: "eligible", apiVersion },
                 completedAt: now,
             },
             {
@@ -38,6 +99,7 @@ export function createCloudProvisioningWorkflow(params) {
                 status: "completed",
                 output: { provider: params.provider, paymentProfileStatus: "active" },
                 completedAt: now,
+                compensationAction: "provisioning.provider_connection.unlink",
             },
             {
                 name: "create_v2_provisioning_resource",
@@ -47,22 +109,31 @@ export function createCloudProvisioningWorkflow(params) {
                     resourceId: params.resourceId,
                     provider: params.provider,
                     service_ref: params.serviceRef,
-                    region: params.region || "aws-us-east-1",
+                    region,
                 },
                 completedAt: now,
+                compensationAction: `resource.${params.provider}.remove`,
             },
             {
                 name: "wait_for_v2_provisioning_resource_completed",
                 primitive: "step.waitForEvent",
                 status: "waiting",
-                output: { expectedEvent: WORKFLOW_RESOURCE_COMPLETED_EVENT, resourceId: params.resourceId },
+                output: {
+                    expectedEvent: WORKFLOW_RESOURCE_COMPLETED_EVENT,
+                    resourceId: params.resourceId,
+                },
             },
             {
                 name: "reveal_access_configuration_and_seal_vault",
                 primitive: "step.do",
                 status: "pending",
+                compensationAction: "vault.revoke_secrets",
             },
         ],
+        compensations,
+        signals: [],
+        temporalEventHistory: history,
+        rollbackReason: null,
         createdAt: now,
         updatedAt: now,
     };
@@ -70,6 +141,12 @@ export function createCloudProvisioningWorkflow(params) {
 /** Completes every outstanding step once the resource-completed event (or a manual advance) arrives. */
 export function completeCloudProvisioningWorkflow(wf, params) {
     const now = new Date().toISOString();
+    const history = wf.temporalEventHistory || [];
+    const trigger = String(params.triggerEvent || WORKFLOW_RESOURCE_COMPLETED_EVENT);
+    appendTemporalEvent(history, "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", {
+        signalName: trigger,
+        resourceId: wf.resourceId,
+    }, now);
     for (const step of wf.steps) {
         if (step.status === "completed")
             continue;
@@ -80,11 +157,128 @@ export function completeCloudProvisioningWorkflow(wf, params) {
                 vaultEncrypted: true,
                 cipher: "AES-256-GCM",
                 secretKeys: params.secretKeys,
-                triggerEvent: params.triggerEvent || WORKFLOW_RESOURCE_COMPLETED_EVENT,
+                triggerEvent: trigger,
             };
         }
+        appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+            activityName: step.name,
+            result: step.output || { status: "completed" },
+        }, now);
     }
+    appendTemporalEvent(history, "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", {
+        workflowId: wf.id,
+        status: "completed",
+        secretKeysSealed: params.secretKeys,
+    }, now);
+    wf.temporalEventHistory = history;
     wf.status = "completed";
     wf.updatedAt = now;
     return wf;
 }
+/**
+ * Executes LIFO Saga Compensations on a DurableWorkflow, rolling back completed steps in reverse order
+ * and recording Temporal compensation activity events.
+ */
+export function rollbackDurableWorkflow(wf, params) {
+    const now = new Date().toISOString();
+    const failedStepName = params?.failedStepName || params?.failedStep;
+    const reason = params?.reason ||
+        "Saga rollback requested by operator or downstream step failure";
+    const history = wf.temporalEventHistory || [];
+    const compensations = wf.compensations || [];
+    if (failedStepName) {
+        appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_FAILED", {
+            activityName: failedStepName,
+            reason,
+        }, now);
+    }
+    // Execute registered compensations in reverse (LIFO) order
+    for (let i = compensations.length - 1; i >= 0; i--) {
+        const comp = compensations[i];
+        if (comp.status === "executed")
+            continue;
+        comp.status = "executed";
+        comp.executedAt = now;
+        comp.output = {
+            rolledBack: true,
+            action: comp.compensationAction,
+            resourceId: wf.resourceId,
+            reason,
+        };
+        appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+            activityName: `compensate:${comp.stepName}`,
+            compensationAction: comp.compensationAction,
+            result: comp.output,
+        }, now);
+    }
+    for (const step of wf.steps) {
+        if (step.status === "completed" && step.compensationAction) {
+            step.status = "compensated";
+            step.compensatedAt = now;
+        }
+        else if (step.status === "waiting" || step.status === "pending") {
+            step.status = "failed";
+        }
+    }
+    appendTemporalEvent(history, "EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED", {
+        workflowId: wf.id,
+        status: "rolled_back",
+        reason,
+        compensatedStepsCount: compensations.filter((c) => c.status === "executed")
+            .length,
+    }, now);
+    wf.compensations = compensations;
+    wf.temporalEventHistory = history;
+    wf.rollbackReason = reason;
+    wf.status = "rolled_back";
+    wf.updatedAt = now;
+    return wf;
+}
+/**
+ * Sends a named Temporal signal to a DurableWorkflow (`human.approval.granted`, `oauth.connection.active`,
+ * `saga.abort`, or `v2.provisioning.resource.completed`).
+ */
+export function signalDurableWorkflow(wf, params) {
+    const now = new Date().toISOString();
+    const signalName = String(params.signalName || WORKFLOW_RESOURCE_COMPLETED_EVENT).trim();
+    const payload = params.payload || {};
+    wf.signals = wf.signals || [];
+    wf.signals.push({
+        signalName,
+        payload,
+        receivedAt: now,
+    });
+    if (signalName === "saga.abort" ||
+        signalName === "human.approval.rejected" ||
+        payload.action === "rollback") {
+        return rollbackDurableWorkflow(wf, {
+            reason: String(payload.reason || `Rolled back via signal ${signalName}`),
+        });
+    }
+    return completeCloudProvisioningWorkflow(wf, {
+        secretKeys: params.secretKeys || ["DATABASE_URL"],
+        triggerEvent: signalName,
+    });
+}
+/**
+ * Exports a DurableWorkflow in Temporal Web UI / `temporal workflow show` compatible EventHistory JSON format.
+ */
+export function exportTemporalEventHistory(wf) {
+    const events = wf.temporalEventHistory || [];
+    return {
+        namespace: `muxo.${wf.workspaceId}`,
+        workflowExecution: {
+            workflowId: wf.id,
+            runId: wf.runId || `run_${wf.id}`,
+        },
+        workflowType: {
+            name: wf.playbookSlug
+                ? `MuxoPlaybookSaga::${wf.playbookSlug}`
+                : `MuxoWorkflow::${wf.workflowType}`,
+        },
+        status: wf.status,
+        eventsCount: events.length,
+        compensationsCount: (wf.compensations || []).length,
+        events,
+    };
+}

package/dist/engine.d.ts

@@ -1,5 +1,6 @@
 import type { MuxoConfig } from "./config.js";
 import { type DurableWorkflow } from "./durable-workflow.js";
+import { type CommercialPlaybookDefinition, type CommercialRoiReport, type CompiledPolicyAsCodeBundle, type OtelTraceExportBundle, type PolicyAsCodeEvaluationResult } from "./oss-suite.js";
 import { type NaturalLanguageResolution } from "./nl.js";
 import { describePolicyInPlainEnglish, type GuardrailCompileOptions, type LlmPolicyAndGovernanceBrief, type ParsedNaturalLanguageGuardrail, type PolicySimulationResult } from "./policy.js";
 import { ComposioInstantAdapter } from "./providers/composio-instant.js";
@@ -191,9 +192,15 @@ export declare class MuxoEngine {
     }>;
     /**
      * Synthesizes a Bi-Temporal Knowledge Graph (entities, active relationships, superseded historical relationships,
-     * Mermaid diagram, and human + technical explanations) directly from SQLite temporal_facts, memories, resources, and connections.
+     * Mermaid diagram, point-in-time `asOf` time-travel, 2-hop BFS subgraph, and human + technical explanations)
+     * directly from SQLite temporal_facts, memories, resources, and connections.
      */
-    getMemoryGraph(ctx: ExecutionContext, query?: string): Promise<MemoryKnowledgeGraph>;
+    getMemoryGraph(ctx: ExecutionContext, queryOrOptions?: string | {
+        query?: string;
+        asOf?: string | null;
+        focalEntity?: string | null;
+        maxHops?: number;
+    }): Promise<MemoryKnowledgeGraph>;
     activateWorkspaceKillSwitch(ctx: ExecutionContext, params: {
         reason: string;
         action?: "terminate" | "quarantine" | "suspend";
@@ -417,6 +424,61 @@ export declare class MuxoEngine {
     }): Promise<DurableWorkflow>;
     advanceDurableWorkflow(ctx: ExecutionContext, workflowId: string, eventPayload?: Record<string, unknown>): Promise<DurableWorkflow>;
     listDurableWorkflows(workspaceId: string): DurableWorkflow[];
+    getDurableWorkflow(ctx: ExecutionContext, workflowId: string): DurableWorkflow;
+    getDurableWorkflowHistory(ctx: ExecutionContext, workflowId: string): {
+        namespace: string;
+        workflowExecution: {
+            workflowId: string;
+            runId: string;
+        };
+        workflowType: {
+            name: string;
+        };
+        status: DurableWorkflow["status"];
+        eventsCount: number;
+        compensationsCount: number;
+        events: import("./durable-workflow.js").TemporalHistoryEvent[];
+    };
+    signalDurableWorkflow(ctx: ExecutionContext, workflowId: string, params: {
+        signalName: string;
+        payload?: Record<string, unknown>;
+    }): DurableWorkflow;
+    rollbackDurableWorkflow(ctx: ExecutionContext, workflowId: string, params?: {
+        reason?: string;
+        failedStep?: string;
+    }): DurableWorkflow;
+    /**
+     * AWS Cedar & Open Policy Agent (OPA / Rego) Policy-as-Code Compiler & Evaluator.
+     */
+    getPolicyAsCodeBundle(ctx: ExecutionContext): CompiledPolicyAsCodeBundle;
+    evaluatePolicyAsCode(ctx: ExecutionContext, params: {
+        toolSlug: string;
+        input?: Record<string, unknown>;
+        riskLevel?: RiskLevel;
+        creditCost?: number;
+        lane?: string;
+    }): Promise<PolicyAsCodeEvaluationResult>;
+    /**
+     * OpenTelemetry (OTel GenAI / MCP Semantic Conventions) & Langfuse Trace Exporter.
+     */
+    exportOtelTraces(ctx: ExecutionContext, limit?: number): OtelTraceExportBundle;
+    /**
+     * Turnkey Commercial Business Saga Playbooks.
+     */
+    listCommercialPlaybooks(): CommercialPlaybookDefinition[];
+    runCommercialPlaybook(ctx: ExecutionContext, params: {
+        slug: string;
+        input?: Record<string, unknown>;
+    }): {
+        ok: true;
+        playbook: CommercialPlaybookDefinition;
+        workflow: DurableWorkflow;
+        temporalFact: import("./types.js").TemporalGraphFact;
+    };
+    /**
+     * FinOps & Commercial ROI Unit-Economics Analytics.
+     */
+    getCommercialRoiReport(ctx: ExecutionContext): CommercialRoiReport;
     /**
      * Hybrid Semantic Vector + Bi-Temporal Recall (`@cf/baai/bge-base-en-v1.5` + Vectorize model).
      */