@muxoai/platform 1.4.2 → 1.4.4

package/.agents/plugins/marketplace.json

@@ -6,7 +6,7 @@
   "plugins": [
     {
       "name": "muxo",
-      "version": "1.4.2",
+      "version": "1.4.4",
       "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.4"
   },
   "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.4",
       "category": "Productivity",
       "skills": [
         "./plugins/muxo/skills/muxo",

package/README.md

@@ -1,9 +1,23 @@
 # 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`).
+> **Let your AI agents take action across business apps, with approvals, spending controls, and proof of what happened.**
+
+Muxo (`v1.4.4`) is the governed action, workflow automation, cloud provisioning, and business-receipt platform for AI agents and B2B SaaS teams. Before any external write or provisioning action runs, Muxo shows **what changes**, **who is affected**, **the estimated USD cost (`$X.XX` alongside credits or `$0.00` BYOK)**, and **which guardrail triggered approval**. After execution, Muxo issues both a **business-facing receipt** (*what changed, who authorized it, what succeeded, what remains unresolved, and exact USD/credit cost*) and a **cryptographic Ed25519 + SHA-256 audit receipt**.
+
+Customers and their agents interact exclusively with **Muxo** — either via tested workflow packs, 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.
 
+### Tested Commercial Workflow Packs (`muxo playbooks` / `POST /api/v1/playbooks/:slug/run`)
+Muxo ships **7 tested workflow templates** with explicit required connections, permissions, approval rules, upfront USD/credit cost estimates, failure & compensation behavior, and structured business deliverables:
+1. **`customer-operations-agent`** — *Customer Operations Account Change, Approval & Receipt Saga* (`$0.05 USD` / 5 credits; reads support request, looks up customer context, proposes governed CRM/billing update with approval preview, posts verified receipt).
+2. **`customer-onboarding-automation`** — *Agent-Powered Customer Onboarding & Tenant Provisioning* (`$0.30 USD` / 30 credits; provisions dedicated tenant database, configures workspace tracker, sends onboarding confirmation with rollback protection).
+3. **`agency-workspace-automation`** — *Multi-Client Agency Workspace, Budget & Reporting Pack* (`$0.06 USD` / 6 credits; runs client audit, updates client deliverable board, and dispatches itemized USD/credit usage & receipt digest).
+4. **`fullstack-cloud-bootstrap`** — *Full-Stack Cloud Database, Cache & Edge Bootstrap* (`$0.52 USD` / 52 credits).
+5. **`competitor-seo-growth-brief`** — *Autonomous Competitor & SEO Executive Brief* (`$0.06 USD` / 6 credits).
+6. **`incident-containment-audit`** — *Zero-Trust Incident Containment & WORM Forensic Audit* (`$0.05 USD` / 5 credits).
+7. **`customer-release-readiness`** — *Customer Release Readiness & Security Sign-Off* (`$0.05 USD` / 5 credits).
+
 Under the hood, Muxo unifies **four core pillars** plus **Natural Language Routing** and **BYOK (Bring Your Own Key) 0-Credit Execution** behind one **19-operation MCP contract**, OpenAI Plugin (`agent-plugins.org/1.0.0`), REST API, Interactive CLI/TUI (`@muxoai/cli`), TypeScript SDK (`@muxoai/sdk`), and Web Console (`https://app.muxo.ai`):
 
 1. **Connected Apps (`app.*`) & Instant Tools (`instant.*`)** — Managed OAuth SaaS integrations (`app.github.*`, `app.gmail.*`, `app.slack.*`, `app.notion.*`, `app.linear.*`) with live browser OAuth handoff (`wait_for_connection`), zero-OAuth instant capabilities (`instant.web.search`, `instant.web.scrape`, `instant.web.crawl`, `instant.seo.audit`, `instant.hackernews.top_stories`, `instant.github.repo_intel`, `instant.dns.lookup`, `instant.composio.workbench`), plus **CLI-first Autonomous 2-Call Agent Signup & Claim** (`POST /api/v1/agents/signup` + `POST /api/v1/agents/claim`).

package/dist/cli.js

@@ -9,6 +9,7 @@ import { handleJsonRpcMcpRequest, LATEST_MCP_PROTOCOL_VERSION } from "./mcp.js";
 import { DEFAULT_WORKSPACE_POLICY, describePolicyInPlainEnglish, sanitizePolicyPatch, } from "./policy.js";
 import { RING_LABELS } from "./providers/microsoft-governance.js";
 import { BYOK_PROVIDER_CATALOG, MuxoStore } from "./store.js";
+import { buildMuxoMcpSkillBundles, getMuxoSkill, listMuxoSkills, renderMuxoSkillMarkdown, } from "./skills-catalog.js";
 import { MUXO_VERSION } from "./version.js";
 function promptUserLine(question) {
     return new Promise((resolve) => {
@@ -578,6 +579,30 @@ async function runCli() {
         return;
     }
     if (cmd === "harness") {
+        const sub = positional[1];
+        if (sub === "configure" ||
+            sub === "config" ||
+            sub === "preset" ||
+            sub === "presets" ||
+            Boolean(flags.preset)) {
+            const preset = (typeof flags.preset === "string" ? flags.preset : undefined) ||
+                (sub === "preset" || sub === "configure" || sub === "config"
+                    ? positional[2]
+                    : undefined);
+            const harness = typeof flags.harness === "string" ? flags.harness : positional[3];
+            const prompt = typeof flags.prompt === "string" ? flags.prompt : undefined;
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/harness/configure", {
+                    method: "POST",
+                    body: { preset, harness, prompt },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { engine, ctx } = getLocalContext();
+            console.log(JSON.stringify(engine.configureHarness(ctx, { preset, harness, prompt }), null, 2));
+            return;
+        }
         const checks = [];
         const skip = (reason) => ({ skip: reason });
         const runCheck = async (id, name, fn) => {
@@ -2285,6 +2310,193 @@ async function runCli() {
         });
         return;
     }
+    if (cmd === "playbooks" || cmd === "playbook") {
+        const sub = positional[1];
+        if (sub === "create" || sub === "add" || sub === "define") {
+            const prompt = positional.slice(2).join(" ").trim();
+            const input = flags.input
+                ? JSON.parse(String(flags.input))
+                : {};
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/playbooks", {
+                    method: "POST",
+                    body: { prompt, ...input },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { engine, ctx } = getLocalContext();
+            const res = engine.createCustomPlaybook(ctx, { prompt, input });
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        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, ctx } = getLocalContext();
+        const playbooks = engine.listCommercialPlaybooks(ctx);
+        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;
+    }
+    if (cmd === "skills" || cmd === "skill") {
+        const sub = (positional[1] || "list").toLowerCase();
+        const baseUrlForSkill = remoteUrl || "https://api.muxo.ai";
+        if (sub === "list" || sub === "ls") {
+            const category = typeof flags.category === "string" ? flags.category : undefined;
+            const provider = typeof flags.provider === "string" ? flags.provider : undefined;
+            const query = typeof flags.query === "string"
+                ? flags.query
+                : typeof flags.q === "string"
+                    ? flags.q
+                    : positional[2];
+            const skills = listMuxoSkills({ category, provider, query }, baseUrlForSkill);
+            console.log(JSON.stringify({
+                ok: true,
+                count: skills.length,
+                skills: skills.map((s) => ({
+                    slug: s.slug,
+                    title: s.title,
+                    category: s.category,
+                    lane: s.lane,
+                    providerSlug: s.providerSlug,
+                    recommendedTools: s.recommendedTools,
+                    skillUrl: `${baseUrlForSkill}/skills/${s.slug}/SKILL.md`,
+                    mcpResourceUri: `muxo://skills/${s.slug}`,
+                })),
+            }, null, 2));
+            return;
+        }
+        if (sub === "show" || sub === "get" || sub === "inspect") {
+            const slug = positional[2] || "github-automation";
+            const skill = getMuxoSkill(slug, baseUrlForSkill);
+            const markdown = renderMuxoSkillMarkdown(slug, baseUrlForSkill);
+            if (!skill || !markdown) {
+                console.error(`Skill not found: ${slug}`);
+                process.exitCode = 1;
+                return;
+            }
+            if (flags.json) {
+                console.log(JSON.stringify({ ok: true, skill, markdown }, null, 2));
+            }
+            else {
+                console.log(markdown);
+            }
+            return;
+        }
+        if (sub === "install" || sub === "add") {
+            const targetRoot = typeof flags.dir === "string"
+                ? path.resolve(flags.dir)
+                : flags.agents
+                    ? path.resolve(process.cwd(), ".agents", "skills")
+                    : path.resolve(process.cwd(), ".claude", "skills");
+            const slugsToInstall = flags["all-curated"]
+                ? buildMuxoMcpSkillBundles(baseUrlForSkill).map((b) => b.name)
+                : [positional[2] || "github-automation"];
+            const installed = [];
+            for (const rawSlug of slugsToInstall) {
+                const skill = getMuxoSkill(rawSlug, baseUrlForSkill);
+                const markdown = renderMuxoSkillMarkdown(rawSlug, baseUrlForSkill);
+                if (!skill || !markdown) {
+                    console.error(`Skill not found: ${rawSlug}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                const skillDir = path.join(targetRoot, skill.slug);
+                fs.mkdirSync(skillDir, { recursive: true });
+                const filePath = path.join(skillDir, "SKILL.md");
+                fs.writeFileSync(filePath, markdown, "utf8");
+                installed.push({ slug: skill.slug, path: filePath });
+            }
+            console.log(JSON.stringify({
+                ok: true,
+                installedCount: installed.length,
+                targetRoot,
+                installed,
+            }, null, 2));
+            return;
+        }
+        // Default: if `muxo skills <slug>` was called directly
+        const directSkill = getMuxoSkill(sub, baseUrlForSkill);
+        const directMd = renderMuxoSkillMarkdown(sub, baseUrlForSkill);
+        if (directSkill && directMd) {
+            console.log(flags.json ? JSON.stringify({ ok: true, skill: directSkill, markdown: directMd }, null, 2) : directMd);
+            return;
+        }
+    }
     // Natural Language fallback: if user passed plain English directly (`muxo "Audit https://muxo.ai for SEO"`)
     if (cmd !== "help" && !flags.help && !flags.h && positional.length > 0) {
         const promptText = positional.join(" ").trim();
@@ -2365,6 +2577,11 @@ 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 skills [list|show|install] [<slug>]     Browse or install governed domain & workflow SKILL.md 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/composio-catalog.d.ts

@@ -232,3 +232,28 @@ export declare function renderDefaultHostedSiteHtml(params: {
     providerSlug: string;
     liveUrl: string;
 }): string;
+export type ComposioMcpGatewayMetaTool = "COMPOSIO_SEARCH_TOOLS" | "COMPOSIO_GET_TOOL_SCHEMAS" | "COMPOSIO_MANAGE_CONNECTIONS" | "COMPOSIO_MULTI_EXECUTE_TOOL" | "COMPOSIO_REMOTE_WORKBENCH" | "COMPOSIO_WAIT_FOR_CONNECTIONS";
+export interface ComposioMcpGatewayCallOptions {
+    apiKey: string;
+    gatewayUrl?: string | null;
+    workspaceId?: string;
+    sessionId?: string;
+    usingCustomerByok?: boolean;
+    isReadOnly?: boolean;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+export interface ComposioMcpGatewayResult {
+    ok: boolean;
+    gatewayUrl: string;
+    metaTool: ComposioMcpGatewayMetaTool | string;
+    data: Record<string, unknown> | null;
+    error?: string;
+}
+export declare function canUseComposioMcpGatewayForExecution(opts: {
+    apiKey?: string | null;
+    gatewayUrl?: string | null;
+    usingCustomerByok?: boolean;
+    isReadOnly?: boolean;
+}): boolean;
+export declare function callComposioMcpGatewayRpc(metaTool: ComposioMcpGatewayMetaTool | string, toolArgs: Record<string, unknown>, options: ComposioMcpGatewayCallOptions): Promise<ComposioMcpGatewayResult>;

package/dist/composio-catalog.js

@@ -1892,3 +1892,148 @@ export function renderDefaultHostedSiteHtml(params) {
 </body>
 </html>`;
 }
+export function canUseComposioMcpGatewayForExecution(opts) {
+    const key = String(opts.apiKey || "").trim();
+    if (!key)
+        return false;
+    const url = String(opts.gatewayUrl || "").trim();
+    const isCustomTeamGateway = Boolean(url) &&
+        url !== "https://connect.composio.dev/mcp" &&
+        (url.includes("mcp.composio.dev/t/") || !url.includes("connect.composio.dev"));
+    const isConsumerKey = key.startsWith("ck_");
+    if (isCustomTeamGateway || isConsumerKey || opts.usingCustomerByok) {
+        return true;
+    }
+    return Boolean(opts.isReadOnly);
+}
+export async function callComposioMcpGatewayRpc(metaTool, toolArgs, options) {
+    const gatewayUrl = (options.gatewayUrl || "").trim() || "https://connect.composio.dev/mcp";
+    const apiKey = (options.apiKey || "").trim();
+    if (!apiKey) {
+        return {
+            ok: false,
+            gatewayUrl,
+            metaTool,
+            data: null,
+            error: "Missing Composio API key for MCP Gateway call",
+        };
+    }
+    const fetchFn = options.fetchImpl || fetch;
+    const timeoutMs = options.timeoutMs ?? 6000;
+    try {
+        const res = await fetchFn(gatewayUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+                "x-consumer-api-key": apiKey,
+                "x-api-key": apiKey,
+                ...(options.workspaceId ? { "x-user-id": options.workspaceId } : {}),
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: `muxo_gw_${Date.now()}`,
+                method: "tools/call",
+                params: {
+                    name: metaTool,
+                    arguments: toolArgs,
+                },
+            }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok) {
+            return {
+                ok: false,
+                gatewayUrl,
+                metaTool,
+                data: null,
+                error: `Composio MCP Gateway returned HTTP ${res.status}`,
+            };
+        }
+        const rawText = await res.text();
+        let rpcPayload = null;
+        const trimmed = rawText.trim();
+        if (trimmed.startsWith("{")) {
+            rpcPayload = JSON.parse(trimmed);
+        }
+        else {
+            for (const line of trimmed.split(/\r?\n/)) {
+                const clean = line.trim();
+                if (clean.startsWith("data:")) {
+                    const dataStr = clean.slice(5).trim();
+                    if (dataStr && dataStr.startsWith("{")) {
+                        rpcPayload = JSON.parse(dataStr);
+                    }
+                }
+            }
+        }
+        if (!rpcPayload || rpcPayload.error) {
+            const errObj = rpcPayload?.error;
+            return {
+                ok: false,
+                gatewayUrl,
+                metaTool,
+                data: null,
+                error: String(errObj?.message || "Invalid JSON-RPC response from Composio MCP Gateway"),
+            };
+        }
+        const resultObj = (rpcPayload.result || {});
+        if (resultObj.isError === true) {
+            return {
+                ok: false,
+                gatewayUrl,
+                metaTool,
+                data: null,
+                error: "Composio MCP Gateway tool returned isError=true",
+            };
+        }
+        if (resultObj.structuredContent && typeof resultObj.structuredContent === "object") {
+            return {
+                ok: true,
+                gatewayUrl,
+                metaTool,
+                data: resultObj.structuredContent,
+            };
+        }
+        const contentArr = Array.isArray(resultObj.content)
+            ? resultObj.content
+            : [];
+        const firstText = contentArr.find((c) => typeof c.text === "string")?.text;
+        if (firstText) {
+            try {
+                const parsed = JSON.parse(firstText);
+                if (parsed && typeof parsed === "object") {
+                    return {
+                        ok: true,
+                        gatewayUrl,
+                        metaTool,
+                        data: parsed,
+                    };
+                }
+            }
+            catch {
+                return {
+                    ok: true,
+                    gatewayUrl,
+                    metaTool,
+                    data: { text: firstText },
+                };
+            }
+        }
+        return {
+            ok: true,
+            gatewayUrl,
+            metaTool,
+            data: resultObj,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            gatewayUrl,
+            metaTool,
+            data: null,
+            error: String(err?.message || err || "Composio MCP Gateway request failed"),
+        };
+    }
+}

package/dist/config.d.ts

@@ -7,6 +7,7 @@ export interface MuxoConfig {
     composioApiKey: string;
     composioInstantApiKey: string;
     composioBaseUrl: string;
+    composioMcpGatewayUrl: string;
     composioWebhookSecret: string;
     composioWebhookSubscriptionId: string;
     composioProjectId: string;

package/dist/config.js

@@ -70,6 +70,7 @@ export function getConfig() {
             ? ""
             : process.env.COMPOSIO_INSTANT_API_KEY || process.env.COMPOSIO_API_KEY || "",
         composioBaseUrl: process.env.COMPOSIO_BASE_URL || "https://backend.composio.dev/api/v3",
+        composioMcpGatewayUrl: process.env.COMPOSIO_MCP_GATEWAY_URL || "https://connect.composio.dev/mcp",
         composioWebhookSecret: process.env.MUXO_EXTERNAL_MODE === "1"
             ? ""
             : process.env.COMPOSIO_WEBHOOK_SECRET || "",

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[];
+};