@muxoai/sdk 1.4.3 → 1.4.4

package/.agents/plugins/marketplace.json

@@ -6,7 +6,7 @@
   "plugins": [
     {
       "name": "muxo",
-      "version": "1.4.3",
+      "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.3"
+    "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.3",
+      "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.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`).
+> **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,44 +2310,26 @@ async function runCli() {
         });
         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();
-        const planOnly = flags["plan-only"] === true || flags.plan === true;
-        const autoApprove = flags["no-approve"] ? false : true;
-        const fundingMode = flags.byok || flags.funding === "byok"
-            ? "byok"
-            : flags.funding === "muxo_funded"
-                ? "muxo_funded"
-                : undefined;
-        if (remoteUrl) {
-            const data = await remoteFetch("/api/v1/do", {
-                method: "POST",
-                body: {
-                    prompt: promptText,
-                    dryRun: planOnly,
-                    planOnly,
-                    autoApprove,
-                    autoExecute: !planOnly,
-                    approveRisky: autoApprove,
-                    fundingMode,
-                },
-            });
-            console.log(JSON.stringify(data, null, 2));
-            return;
-        }
-        const { engine, ctx } = getLocalContext();
-        const result = await engine.doNaturalLanguage(ctx, {
-            prompt: promptText,
-            autoApprove,
-            planOnly,
-            fundingMode,
-        });
-        console.log(JSON.stringify(result, null, 2));
-        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 ||
@@ -2348,8 +2355,8 @@ async function runCli() {
             console.log(JSON.stringify(res, null, 2));
             return;
         }
-        const { engine } = getLocalContext();
-        const playbooks = engine.listCommercialPlaybooks();
+        const { engine, ctx } = getLocalContext();
+        const playbooks = engine.listCommercialPlaybooks(ctx);
         console.log(JSON.stringify({ ok: true, count: playbooks.length, playbooks }, null, 2));
         return;
     }
@@ -2405,6 +2412,127 @@ async function runCli() {
         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();
+        const planOnly = flags["plan-only"] === true || flags.plan === true;
+        const autoApprove = flags["no-approve"] ? false : true;
+        const fundingMode = flags.byok || flags.funding === "byok"
+            ? "byok"
+            : flags.funding === "muxo_funded"
+                ? "muxo_funded"
+                : undefined;
+        if (remoteUrl) {
+            const data = await remoteFetch("/api/v1/do", {
+                method: "POST",
+                body: {
+                    prompt: promptText,
+                    dryRun: planOnly,
+                    planOnly,
+                    autoApprove,
+                    autoExecute: !planOnly,
+                    approveRisky: autoApprove,
+                    fundingMode,
+                },
+            });
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const { engine, ctx } = getLocalContext();
+        const result = await engine.doNaturalLanguage(ctx, {
+            prompt: promptText,
+            autoApprove,
+            planOnly,
+            fundingMode,
+        });
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
     console.log(`
 Muxo CLI — Unified Agent Execution, Cloud Infrastructure, Memory & Safety Platform
 
@@ -2452,6 +2580,7 @@ Core Commands:
   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

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/engine.d.ts

@@ -1,6 +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 { exportTemporalEventHistory, type DurableWorkflow } from "./durable-workflow.js";
+import { type CommercialPlaybookDefinition, type CommercialRoiReport, type CompiledPolicyAsCodeBundle, type HarnessConfigurationBundle, type OtelTraceExportBundle, type PolicyAsCodeEvaluationResult, type RunReconciliationReport } 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";
@@ -49,6 +49,7 @@ export declare class MuxoEngine {
     readonly governance: MicrosoftGovernanceAdapter;
     readonly supermemory: SupermemoryAdapter;
     private readonly durableWorkflows;
+    private readonly customPlaybooks;
     constructor(config: MuxoConfig, store: MuxoStore);
     getProfile(ctx: ExecutionContext): Record<string, unknown>;
     getOrganization(ctx: ExecutionContext): Record<string, unknown>;
@@ -233,7 +234,9 @@ export declare class MuxoEngine {
         governanceSignatureValid: boolean;
         agenticReceiptValid: boolean;
         explanation: HumanFriendlyExplanation;
+        businessSummary: NonNullable<ExecutionReceipt["businessSummary"]>;
     };
+    reconcileRun(ctx: ExecutionContext, runOrPlanId: string): RunReconciliationReport;
     listReceipts(ctx: ExecutionContext, limit?: number): {
         receipts: Array<ExecutionReceipt & {
             agenticReceipt: PortableAgenticReceipt;
@@ -345,7 +348,7 @@ export declare class MuxoEngine {
     }): Promise<{
         ok: boolean;
         executed: boolean;
-        status: "executed" | "planned_dry_run" | "awaiting_approval" | "awaiting_oauth_connection" | "missing_inputs" | "guardrail_applied" | "memory_saved" | "memory_forgotten" | "memory_recalled" | "memory_graph" | "governance_updated" | "governance_scanned" | "governance_status" | "context_inspected" | "receipt_explained" | "receipt_chain_verified" | "unresolved";
+        status: "executed" | "planned_dry_run" | "awaiting_approval" | "awaiting_oauth_connection" | "missing_inputs" | "guardrail_applied" | "memory_saved" | "memory_forgotten" | "memory_recalled" | "memory_graph" | "governance_updated" | "governance_scanned" | "governance_status" | "context_inspected" | "receipt_explained" | "receipt_chain_verified" | "playbook_listed" | "playbook_created" | "playbook_executed" | "workflow_rolled_back" | "workflow_signaled" | "workflow_history" | "cedar_compiled" | "cedar_evaluated" | "otel_exported" | "roi_analyzed" | "harness_configured" | "unresolved";
         intent: NaturalLanguageResolution;
         resolution: NaturalLanguageResolution;
         plan?: ActionPlan;
@@ -366,6 +369,15 @@ export declare class MuxoEngine {
         memoryRecord?: WorkspaceMemoryRecord;
         memoryOverview?: Awaited<ReturnType<MuxoEngine["getMemoryOverview"]>>;
         memoryGraph?: MemoryKnowledgeGraph;
+        playbooks?: CommercialPlaybookDefinition[];
+        playbook?: CommercialPlaybookDefinition;
+        workflow?: DurableWorkflow;
+        workflowHistory?: ReturnType<typeof exportTemporalEventHistory>;
+        cedarBundle?: CompiledPolicyAsCodeBundle;
+        cedarEvaluation?: PolicyAsCodeEvaluationResult;
+        otelTraces?: OtelTraceExportBundle;
+        roiReport?: CommercialRoiReport;
+        harnessConfig?: HarnessConfigurationBundle;
         deletedMemoryId?: string;
         governanceStatus?: ReturnType<MuxoEngine["getGovernanceOverview"]>;
         poisoningScan?: ReturnType<MuxoEngine["scanForContextPoisoning"]>;
@@ -463,9 +475,18 @@ export declare class MuxoEngine {
      */
     exportOtelTraces(ctx: ExecutionContext, limit?: number): OtelTraceExportBundle;
     /**
-     * Turnkey Commercial Business Saga Playbooks.
+     * Turnkey & Custom Commercial Business Saga Playbooks.
      */
-    listCommercialPlaybooks(): CommercialPlaybookDefinition[];
+    listCommercialPlaybooks(ctx?: ExecutionContext): CommercialPlaybookDefinition[];
+    createCustomPlaybook(ctx: ExecutionContext, params: {
+        prompt?: string;
+        input?: Record<string, unknown>;
+    }): {
+        ok: true;
+        playbook: CommercialPlaybookDefinition;
+        playbooks: CommercialPlaybookDefinition[];
+        humanMessage: string;
+    };
     runCommercialPlaybook(ctx: ExecutionContext, params: {
         slug: string;
         input?: Record<string, unknown>;
@@ -474,7 +495,30 @@ export declare class MuxoEngine {
         playbook: CommercialPlaybookDefinition;
         workflow: DurableWorkflow;
         temporalFact: import("./types.js").TemporalGraphFact;
+        usableResult: {
+            playbookSlug: string;
+            playbookName: string;
+            status: "completed";
+            summary: string;
+            deliverableOutcome: string;
+            targetProvider: string;
+            targetEntity: string;
+            completedStepsCount: number;
+            registeredCompensationsCount: number;
+            estimatedCostUsd: number;
+            creditsMetered: number;
+            estimatedMinutesSaved: number;
+            recoveryGuarantee: string;
+        };
     };
+    /**
+     * Turnkey Harness Preset & One-Shot Agent Configurator.
+     */
+    configureHarness(ctx: ExecutionContext, params?: {
+        preset?: string | null;
+        harness?: string | null;
+        prompt?: string | null;
+    }): Promise<HarnessConfigurationBundle>;
     /**
      * FinOps & Commercial ROI Unit-Economics Analytics.
      */