@muxoai/platform 1.4.2 → 1.4.4

package/dist/engine.js

@@ -1,8 +1,9 @@
 import crypto from "node:crypto";
 import { isStripeProjectsExclusiveProvider, normalizeStripeProjectsProviderSlug, wrapMuxoConnectUrl, } from "./composio-catalog.js";
 import { APPROVED_PLAN_STATUSES, approvalRequiredError, buildApprovalHumanHandoff, buildApprovalUrl, buildOAuthHumanHandoff, clampWaitSeconds, looksLikeToolSlug, unknownToolError, } from "./mcp-schema.js";
-import { completeCloudProvisioningWorkflow, createCloudProvisioningWorkflow, normalizeWorkflowTarget, workflowNotFoundError, } from "./durable-workflow.js";
+import { completeCloudProvisioningWorkflow, createCloudProvisioningWorkflow, exportTemporalEventHistory, normalizeWorkflowTarget, rollbackDurableWorkflow as runSagaRollbackOnWorkflow, signalDurableWorkflow as sendSignalToWorkflow, workflowNotFoundError, } from "./durable-workflow.js";
 import { buildMemoryKnowledgeGraph } from "./memory-graph.js";
+import { MUXO_COMMERCIAL_PLAYBOOKS, buildApprovalImpactPreview, buildBusinessReceiptSummary, buildCommercialRoiReport, buildHarnessConfigurationBundle, buildOtelTraceExport, buildPlaybookSagaExecution, buildRunReconciliationReport, compileWorkspacePolicyToCedarAndRego, evaluateCedarAndOpaPolicy, getCommercialPlaybook, parseNaturalLanguageCustomPlaybook, parseNaturalLanguageOssIntent, resolveHarnessPreset, } from "./oss-suite.js";
 import { resolveNaturalLanguageIntent, } from "./nl.js";
 import { DEFAULT_WORKSPACE_POLICY, buildLlmPolicyAndGovernanceBrief, compileNaturalLanguageGuardrailWithLlm, describePolicyInPlainEnglish, formatHumanFriendlyExplanation, parseNaturalLanguageGuardrail, simulatePolicyEvaluation, } from "./policy.js";
 import { ComposioInstantAdapter } from "./providers/composio-instant.js";
@@ -39,6 +40,7 @@ export class MuxoEngine {
     governance;
     supermemory;
     durableWorkflows = new Map();
+    customPlaybooks = new Map();
     constructor(config, store) {
         this.config = config;
         this.store = store;
@@ -625,6 +627,19 @@ export class MuxoEngine {
             decisionRecord,
             memoryContext,
         });
+        plan.changePreview = buildApprovalImpactPreview({
+            toolSlug: plan.toolSlug,
+            lane: plan.lane,
+            riskLevel: plan.riskLevel,
+            input: plan.input,
+            reason: plan.reason,
+            creditCost: plan.creditCost,
+            fundingMode: byokActive ? "byok" : "muxo_funded",
+            supplierSettlement: plan.supplierSettlement,
+            decisionRecord: plan.decisionRecord,
+            workspaceName: ws.name,
+        });
+        plan.estimatedCostUsd = plan.changePreview.estimatedCostUsd;
         // 3. Check external user OAuth connection state for Connected Apps (composio_sdk)
         let authHandoff;
         if (tool.lane === "composio_sdk" && tool.requiresAuth) {
@@ -693,6 +708,21 @@ export class MuxoEngine {
         const plan = this.store.getPlan(ctx.workspace.id, planId);
         if (!plan)
             throw new Error(`Plan '${planId}' not found in workspace.`);
+        if (!plan.changePreview) {
+            const ws = this.store.getWorkspace(ctx.workspace.id);
+            plan.changePreview = buildApprovalImpactPreview({
+                toolSlug: plan.toolSlug,
+                lane: plan.lane,
+                riskLevel: plan.riskLevel,
+                input: plan.input,
+                reason: plan.reason,
+                creditCost: plan.creditCost,
+                supplierSettlement: plan.supplierSettlement,
+                decisionRecord: plan.decisionRecord,
+                workspaceName: ws?.name,
+            });
+            plan.estimatedCostUsd = plan.changePreview.estimatedCostUsd;
+        }
         return plan;
     }
     async waitForPlanApproval(ctx, params) {
@@ -1130,18 +1160,25 @@ export 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.
      */
-    async getMemoryGraph(ctx, query) {
+    async getMemoryGraph(ctx, queryOrOptions) {
         const ws = this.store.getWorkspace(ctx.workspace.id);
-        const overview = await this.getMemoryOverview(ctx, query);
+        const opts = typeof queryOrOptions === "string"
+            ? { query: queryOrOptions }
+            : queryOrOptions || {};
+        const overview = await this.getMemoryOverview(ctx, opts.query);
         return buildMemoryKnowledgeGraph({
             workspace: ws,
             namespace: overview.namespace,
-            query,
+            query: opts.query,
+            asOf: opts.asOf || null,
+            focalEntity: opts.focalEntity || null,
+            maxHops: opts.maxHops,
             facts: this.store.listTemporalFacts(ws.id, {
                 includeHistorical: true,
-                query,
+                query: opts.query,
                 limit: 100,
             }),
             resources: this.store.listResources(ws.id),
@@ -1194,6 +1231,13 @@ export class MuxoEngine {
             const existingRun = this.store.getRun(ctx.workspace.id, plan.runId);
             const existingReceipt = this.store.getReceipt(ctx.workspace.id, plan.runId);
             if (existingRun && existingReceipt) {
+                existingRun.idempotentReplay = true;
+                existingRun.reconciliationStatus =
+                    existingRun.status === "succeeded"
+                        ? "verified_complete"
+                        : existingRun.status === "cancelled"
+                            ? "cancelled"
+                            : "failed_zero_charge";
                 return { run: existingRun, receipt: existingReceipt };
             }
             throw new Error(`Plan '${plan.id}' was already claimed by run '${plan.runId}' (execute-once invariant).`);
@@ -1365,6 +1409,24 @@ export class MuxoEngine {
                     run: finalized.run,
                     workspace: ws,
                 });
+            finalized.receipt.businessSummary = buildBusinessReceiptSummary({
+                toolSlug: finalized.receipt.toolSlug,
+                lane: finalized.receipt.lane,
+                riskLevel: finalized.receipt.riskLevel,
+                status: finalized.receipt.status,
+                creditsMetered: finalized.receipt.creditsMetered,
+                input: plan.input,
+                output,
+                approvedBy: plan.approvedBy,
+                actorId: finalized.receipt.actorId,
+                decisionRecord: finalized.receipt.decisionRecord,
+                supplierSettlement: finalized.receipt.supplierSettlement,
+            });
+            finalized.receipt.estimatedCostUsd =
+                finalized.receipt.businessSummary.costUsd;
+            finalized.run.estimatedCostUsd =
+                finalized.receipt.businessSummary.costUsd;
+            finalized.run.reconciliationStatus = "verified_complete";
             finalized.receipt.explanation = this.explainReceipt(finalized.receipt, {
                 signatureValid: this.store.verifyReceipt(finalized.receipt),
                 governanceSignatureValid: true,
@@ -1444,6 +1506,25 @@ export class MuxoEngine {
                     run: failedFinalized.run,
                     workspace: ws,
                 });
+            failedFinalized.receipt.businessSummary = buildBusinessReceiptSummary({
+                toolSlug: failedFinalized.receipt.toolSlug,
+                lane: failedFinalized.receipt.lane,
+                riskLevel: failedFinalized.receipt.riskLevel,
+                status: failedFinalized.receipt.status,
+                creditsMetered: failedFinalized.receipt.creditsMetered,
+                input: plan.input,
+                output: { error: errorMessage },
+                error: errorMessage,
+                approvedBy: plan.approvedBy,
+                actorId: failedFinalized.receipt.actorId,
+                decisionRecord: failedFinalized.receipt.decisionRecord,
+                supplierSettlement: failedFinalized.receipt.supplierSettlement,
+            });
+            failedFinalized.receipt.estimatedCostUsd =
+                failedFinalized.receipt.businessSummary.costUsd;
+            failedFinalized.run.estimatedCostUsd =
+                failedFinalized.receipt.businessSummary.costUsd;
+            failedFinalized.run.reconciliationStatus = "failed_zero_charge";
             failedFinalized.receipt.explanation = this.explainReceipt(failedFinalized.receipt, {
                 signatureValid: this.store.verifyReceipt(failedFinalized.receipt),
                 governanceSignatureValid: true,
@@ -1511,15 +1592,31 @@ export class MuxoEngine {
         const verified = verification.signatureValid &&
             verification.governanceSignatureValid &&
             agenticOk;
+        const businessSummary = receipt.businessSummary ||
+            buildBusinessReceiptSummary({
+                toolSlug: receipt.toolSlug,
+                lane: receipt.lane,
+                riskLevel: receipt.riskLevel,
+                status: receipt.status,
+                creditsMetered: receipt.creditsMetered,
+                decisionRecord: receipt.decisionRecord,
+                supplierSettlement: receipt.supplierSettlement,
+                actorId: receipt.actorId,
+            });
+        receipt.businessSummary = businessSummary;
+        receipt.estimatedCostUsd = businessSummary.costUsd;
         const headline = receipt.status === "succeeded"
-            ? `Verified Receipt (${receipt.id}): ${receipt.toolSlug} succeeded and passed all safety & integrity checks.`
+            ? `Verified Receipt (${receipt.id}): ${receipt.toolSlug} succeeded · ${businessSummary.costDisplay}`
             : receipt.status === "failed"
-                ? `Verified Receipt (${receipt.id}): ${receipt.toolSlug} failed (0 credits charged).`
+                ? `Verified Receipt (${receipt.id}): ${receipt.toolSlug} failed (0 credits charged / $0.00 USD).`
                 : `Verified Receipt (${receipt.id}): ${receipt.toolSlug} was cancelled.`;
         const nonTechnical = [
             headline,
-            `Action: ${receipt.toolSlug} (${receipt.riskLevel} risk lane) at ${receipt.issuedAt}.`,
-            `Cost & billing: ${fundingPlain}.`,
+            `What changed: ${businessSummary.whatChanged}`,
+            `Who authorized it: ${businessSummary.whoAuthorized}.`,
+            `What succeeded: ${businessSummary.whatSucceeded}`,
+            `What remains unresolved: ${businessSummary.whatRemainsUnresolved}`,
+            `Cost & billing: ${businessSummary.costDisplay}.`,
             verified
                 ? "Tamper-proof check: Verified (HMAC vault signature, portable Ed25519 AgenticReceipt envelope, and governance audit trail all match)."
                 : "Tamper-proof check: Warning (signature verification mismatch detected).",
@@ -1544,12 +1641,30 @@ export class MuxoEngine {
             throw new Error(`Receipt '${receiptOrRunId}' not found in workspace.`);
         }
         const run = this.store.getRun(ws.id, receipt.runId);
+        const plan = run ? this.store.getPlan(ws.id, run.planId) : undefined;
         const agenticReceipt = this.governance.buildPortableAgenticReceipt({
             receipt,
             run,
             workspace: ws,
         });
         receipt.agenticReceipt = agenticReceipt;
+        if (!receipt.businessSummary) {
+            receipt.businessSummary = buildBusinessReceiptSummary({
+                toolSlug: receipt.toolSlug,
+                lane: receipt.lane,
+                riskLevel: receipt.riskLevel,
+                status: receipt.status,
+                creditsMetered: receipt.creditsMetered,
+                input: run?.input,
+                output: run?.output,
+                error: run?.error,
+                approvedBy: plan?.approvedBy,
+                actorId: receipt.actorId,
+                decisionRecord: receipt.decisionRecord,
+                supplierSettlement: receipt.supplierSettlement,
+            });
+        }
+        receipt.estimatedCostUsd = receipt.businessSummary.costUsd;
         const signatureValid = this.store.verifyReceipt(receipt);
         const governanceSignatureValid = receipt.decisionRecord
             ? this.governance.verifyDecisionRecord(receipt.decisionRecord)
@@ -1564,19 +1679,84 @@ export class MuxoEngine {
             governanceSignatureValid,
             agenticReceiptValid,
             explanation,
+            businessSummary: receipt.businessSummary,
         };
     }
+    reconcileRun(ctx, runOrPlanId) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const trimmed = String(runOrPlanId || "").trim();
+        const directRun = trimmed === "latest" || trimmed === "last" || !trimmed
+            ? this.store.listRuns(ws.id, 1)[0]
+            : this.store.getRun(ws.id, trimmed);
+        const directPlan = !directRun ? this.store.getPlan(ws.id, trimmed) : undefined;
+        const plan = directPlan ||
+            (directRun ? this.store.getPlan(ws.id, directRun.planId) : undefined) ||
+            null;
+        const run = directRun ||
+            (plan?.runId ? this.store.getRun(ws.id, plan.runId) : undefined) ||
+            null;
+        if (!run && !plan) {
+            throw new Error(`No run or plan '${runOrPlanId}' found in workspace '${ws.slug}' for reconciliation.`);
+        }
+        const receipt = run ? this.store.getReceipt(ws.id, run.id) || null : null;
+        if (receipt && !receipt.businessSummary) {
+            receipt.businessSummary = buildBusinessReceiptSummary({
+                toolSlug: receipt.toolSlug,
+                lane: receipt.lane,
+                riskLevel: receipt.riskLevel,
+                status: receipt.status,
+                creditsMetered: receipt.creditsMetered,
+                input: run?.input,
+                output: run?.output,
+                error: run?.error,
+                approvedBy: plan?.approvedBy,
+                actorId: receipt.actorId,
+                decisionRecord: receipt.decisionRecord,
+                supplierSettlement: receipt.supplierSettlement,
+            });
+            receipt.estimatedCostUsd = receipt.businessSummary.costUsd;
+        }
+        const signatureValid = receipt ? this.store.verifyReceipt(receipt) : false;
+        const report = buildRunReconciliationReport({
+            run,
+            plan,
+            receipt,
+            signatureValid,
+        });
+        if (run) {
+            run.reconciliationStatus = report.reconciliationStatus;
+        }
+        return report;
+    }
     listReceipts(ctx, limit = 25) {
         const ws = this.store.getWorkspace(ctx.workspace.id);
         const rows = this.store.listReceipts(ws.id, limit);
         const enriched = rows.map((r) => {
             const run = this.store.getRun(ws.id, r.runId);
+            const plan = run ? this.store.getPlan(ws.id, run.planId) : undefined;
             const agenticReceipt = this.governance.buildPortableAgenticReceipt({
                 receipt: r,
                 run,
                 workspace: ws,
             });
             r.agenticReceipt = agenticReceipt;
+            if (!r.businessSummary) {
+                r.businessSummary = buildBusinessReceiptSummary({
+                    toolSlug: r.toolSlug,
+                    lane: r.lane,
+                    riskLevel: r.riskLevel,
+                    status: r.status,
+                    creditsMetered: r.creditsMetered,
+                    input: run?.input,
+                    output: run?.output,
+                    error: run?.error,
+                    approvedBy: plan?.approvedBy,
+                    actorId: r.actorId,
+                    decisionRecord: r.decisionRecord,
+                    supplierSettlement: r.supplierSettlement,
+                });
+            }
+            r.estimatedCostUsd = r.businessSummary.costUsd;
             const signatureValid = this.store.verifyReceipt(r);
             const governanceSignatureValid = r.decisionRecord
                 ? this.governance.verifyDecisionRecord(r.decisionRecord)
@@ -2114,20 +2294,218 @@ export class MuxoEngine {
                 humanMessage: memoryCheck.humanSummary,
             };
         }
-        // 2c-graph. Check if the user is asking for the bi-temporal knowledge graph / fact lineage ("Show my memory graph", "What is our knowledge graph?", "Show fact lineage")
-        if (/\b(?:memory\s+graph|knowledge\s+graph|temporal\s+graph|fact\s+lineage|bi[-\s]?temporal\s+(?:graph|lineage|facts))\b/i.test(cleanedPrompt)) {
-            const memoryGraph = await this.getMemoryGraph(ctx);
-            const synthResolution = makeControlPlaneResolution("workspace.memory.graph", rawPrompt, memoryGraph.explanation.preferred);
-            return {
-                ok: true,
-                executed: true,
-                status: "memory_graph",
-                intent: synthResolution,
-                resolution: synthResolution,
-                memoryGraph,
-                explanation: memoryGraph.explanation,
-                humanMessage: memoryGraph.explanation.preferred,
-            };
+        // 2c-oss. Check if the user is invoking an OSS or Commercial Control-Plane capability in plain English
+        const ossIntent = parseNaturalLanguageOssIntent(rawPrompt, {
+            customPlaybooks: this.customPlaybooks.get(ws.id) || [],
+            explicitInput: params.input,
+        });
+        if (ossIntent.matched && ossIntent.kind) {
+            if (ossIntent.kind === "list_playbooks") {
+                const playbooks = this.listCommercialPlaybooks(ctx);
+                const humanMessage = `Available Saga Playbooks (${playbooks.length}): ${playbooks
+                    .map((p) => `${p.slug} (${p.name}, ~${p.estimatedMinutesSaved}m saved)`)
+                    .join("; ")}.`;
+                const synthResolution = makeControlPlaneResolution("workspace.playbooks.list", rawPrompt, humanMessage);
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "playbook_listed",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    playbooks,
+                    humanMessage,
+                };
+            }
+            if (ossIntent.kind === "create_playbook" && ossIntent.customPlaybook) {
+                const created = this.createCustomPlaybook(ctx, {
+                    prompt: rawPrompt,
+                    input: params.input,
+                });
+                const synthResolution = makeControlPlaneResolution("workspace.playbooks.create", rawPrompt, created.humanMessage, { slug: created.playbook.slug });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "playbook_created",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    playbook: created.playbook,
+                    playbooks: created.playbooks,
+                    humanMessage: created.humanMessage,
+                };
+            }
+            if (ossIntent.kind === "run_playbook" && ossIntent.playbookSlug) {
+                const ran = this.runCommercialPlaybook(ctx, {
+                    slug: ossIntent.playbookSlug,
+                    input: ossIntent.playbookInput || params.input,
+                });
+                const humanMessage = `Executed Saga playbook '${ran.playbook.name}' (${ran.playbook.slug}) as workflow ${ran.workflow.id} (${ran.workflow.steps.length} steps completed, ${ran.workflow.compensations?.length || 0} compensations registered).`;
+                const synthResolution = makeControlPlaneResolution(`playbook.${ran.playbook.slug}`, rawPrompt, humanMessage, ossIntent.playbookInput || {});
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "playbook_executed",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    playbook: ran.playbook,
+                    workflow: ran.workflow,
+                    humanMessage,
+                };
+            }
+            if (ossIntent.kind === "rollback_workflow") {
+                const rolledBack = this.rollbackDurableWorkflow(ctx, ossIntent.workflowId || "latest", { reason: ossIntent.workflowReason });
+                const humanMessage = `Rolled back workflow ${rolledBack.id} (${rolledBack.compensations?.length || 0} LIFO Saga compensations executed). Reason: ${rolledBack.rollbackReason}.`;
+                const synthResolution = makeControlPlaneResolution("workspace.workflow.rollback", rawPrompt, humanMessage, { workflowId: rolledBack.id, reason: rolledBack.rollbackReason });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "workflow_rolled_back",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    workflow: rolledBack,
+                    humanMessage,
+                };
+            }
+            if (ossIntent.kind === "signal_workflow") {
+                const signaled = this.signalDurableWorkflow(ctx, ossIntent.workflowId || "latest", {
+                    signalName: ossIntent.signalName || "human.approval.granted",
+                    payload: ossIntent.signalPayload,
+                });
+                const humanMessage = `Delivered Temporal signal '${ossIntent.signalName || "human.approval.granted"}' to workflow ${signaled.id} (status: ${signaled.status}).`;
+                const synthResolution = makeControlPlaneResolution("workspace.workflow.signal", rawPrompt, humanMessage, {
+                    workflowId: signaled.id,
+                    signalName: ossIntent.signalName || "human.approval.granted",
+                });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "workflow_signaled",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    workflow: signaled,
+                    humanMessage,
+                };
+            }
+            if (ossIntent.kind === "workflow_history") {
+                const wf = this.getDurableWorkflow(ctx, ossIntent.workflowId || "latest");
+                const workflowHistory = exportTemporalEventHistory(wf);
+                const humanMessage = `Temporal EventHistory for workflow ${wf.id} (status=${wf.status}, ${workflowHistory.events.length} events).`;
+                const synthResolution = makeControlPlaneResolution("workspace.workflow.history", rawPrompt, humanMessage, { workflowId: wf.id });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "workflow_history",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    workflow: wf,
+                    workflowHistory,
+                    humanMessage,
+                };
+            }
+            if (ossIntent.kind === "cedar_compile") {
+                const cedarBundle = this.getPolicyAsCodeBundle(ctx);
+                const synthResolution = makeControlPlaneResolution("workspace.governance.cedar_compile", rawPrompt, cedarBundle.explanation.preferred);
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "cedar_compiled",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    cedarBundle,
+                    explanation: cedarBundle.explanation,
+                    humanMessage: cedarBundle.explanation.preferred,
+                };
+            }
+            if (ossIntent.kind === "cedar_evaluate") {
+                const cedarEvaluation = await this.evaluatePolicyAsCode(ctx, {
+                    toolSlug: ossIntent.toolSlug || "resource.turso.database",
+                    input: ossIntent.evaluationInput || params.input || {},
+                });
+                const humanMessage = `Cedar 4.0 & OPA Rego evaluation for '${cedarEvaluation.toolSlug}': ${cedarEvaluation.decision} (${cedarEvaluation.remediationForLlm}).`;
+                const synthResolution = makeControlPlaneResolution("workspace.governance.cedar_evaluate", rawPrompt, humanMessage, {
+                    toolSlug: cedarEvaluation.toolSlug,
+                    decision: cedarEvaluation.decision,
+                });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "cedar_evaluated",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    cedarEvaluation,
+                    humanMessage,
+                };
+            }
+            if (ossIntent.kind === "otel_traces") {
+                const otelTraces = this.exportOtelTraces(ctx, ossIntent.limit || 25);
+                const humanMessage = `Exported ${otelTraces.spansCount} OpenTelemetry GenAI 1.29.0 / MCP 2026-07-28 span(s) and ${otelTraces.langfuseBatch.length} Langfuse trace event(s) (traceparent: ${otelTraces.w3cTraceParent}).`;
+                const synthResolution = makeControlPlaneResolution("workspace.telemetry.otlp", rawPrompt, humanMessage);
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "otel_exported",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    otelTraces,
+                    humanMessage,
+                };
+            }
+            if (ossIntent.kind === "roi_analytics") {
+                const roiReport = this.getCommercialRoiReport(ctx);
+                const synthResolution = makeControlPlaneResolution("workspace.analytics.roi", rawPrompt, roiReport.explanation.preferred);
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "roi_analyzed",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    roiReport,
+                    explanation: roiReport.explanation,
+                    humanMessage: roiReport.explanation.preferred,
+                };
+            }
+            if (ossIntent.kind === "configure_harness") {
+                const harnessConfig = await this.configureHarness(ctx, {
+                    preset: ossIntent.preset?.slug,
+                    harness: ossIntent.targetHarness,
+                    prompt: ossIntent.extraGuardrailPrompt || undefined,
+                });
+                const synthResolution = makeControlPlaneResolution("workspace.harness.configure", rawPrompt, harnessConfig.humanMessage, {
+                    preset: harnessConfig.appliedPreset?.slug || "custom",
+                    harness: harnessConfig.targetHarness,
+                });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "harness_configured",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    harnessConfig,
+                    explanation: harnessConfig.explanation,
+                    humanMessage: harnessConfig.humanMessage,
+                };
+            }
+            if (ossIntent.kind === "memory_graph") {
+                const memoryGraph = await this.getMemoryGraph(ctx, {
+                    asOf: ossIntent.asOf || null,
+                    focalEntity: ossIntent.focalEntity || null,
+                    maxHops: ossIntent.maxHops,
+                });
+                const synthResolution = makeControlPlaneResolution("workspace.memory.graph", rawPrompt, memoryGraph.explanation.preferred, {
+                    asOf: ossIntent.asOf || null,
+                    focalEntity: ossIntent.focalEntity || null,
+                    maxHops: ossIntent.maxHops,
+                });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "memory_graph",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    memoryGraph,
+                    explanation: memoryGraph.explanation,
+                    humanMessage: memoryGraph.explanation.preferred,
+                };
+            }
         }
         // 2c. Check if the user is asking what Muxo remembers ("What do you remember?", "Show my saved memories", "What are our default settings in memory?")
         if (/^(?:what\s+do\s+you\s+remember|what\s+(?:are|is)\s+(?:my|our)\s+(?:saved\s+)?(?:memories|memory|defaults|preferences)|show\s+(?:my|our)\s+(?:saved\s+)?(?:memories|memory|defaults)|recall\s+(?:my|our|workspace)\s+memories|list\s+(?:my|our|workspace)\s+memories)\b/i.test(cleanedPrompt)) {
@@ -2473,6 +2851,207 @@ export class MuxoEngine {
     listDurableWorkflows(workspaceId) {
         return Array.from(this.durableWorkflows.values()).filter((w) => w.workspaceId === workspaceId);
     }
+    getDurableWorkflow(ctx, workflowId) {
+        const requested = String(workflowId || "").trim();
+        if (requested.toLowerCase() === "latest" || requested.toLowerCase() === "last") {
+            const list = this.listDurableWorkflows(ctx.workspace.id);
+            const latest = list[list.length - 1];
+            if (!latest) {
+                throw workflowNotFoundError("latest");
+            }
+            return latest;
+        }
+        const wf = this.durableWorkflows.get(requested);
+        if (!wf || wf.workspaceId !== ctx.workspace.id) {
+            throw workflowNotFoundError(requested);
+        }
+        return wf;
+    }
+    getDurableWorkflowHistory(ctx, workflowId) {
+        const wf = this.getDurableWorkflow(ctx, workflowId);
+        return exportTemporalEventHistory(wf);
+    }
+    signalDurableWorkflow(ctx, workflowId, params) {
+        const wf = this.getDurableWorkflow(ctx, workflowId);
+        return sendSignalToWorkflow(wf, params);
+    }
+    rollbackDurableWorkflow(ctx, workflowId, params) {
+        const wf = this.getDurableWorkflow(ctx, workflowId);
+        return runSagaRollbackOnWorkflow(wf, params);
+    }
+    /**
+     * AWS Cedar & Open Policy Agent (OPA / Rego) Policy-as-Code Compiler & Evaluator.
+     */
+    getPolicyAsCodeBundle(ctx) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        return compileWorkspacePolicyToCedarAndRego(ws.policy, ws);
+    }
+    async evaluatePolicyAsCode(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        let resolvedSlug = String(params.toolSlug || "instant.web.search").trim();
+        let riskLevel = params.riskLevel;
+        let creditCost = params.creditCost;
+        let lane = params.lane;
+        try {
+            const tool = await this.inspectTool(resolvedSlug);
+            resolvedSlug = tool.slug;
+            if (!riskLevel)
+                riskLevel = tool.riskLevel;
+            if (typeof creditCost !== "number")
+                creditCost = tool.creditCost;
+            if (!lane)
+                lane = tool.lane;
+        }
+        catch {
+            // Fall back to slug prefix heuristics
+        }
+        return evaluateCedarAndOpaPolicy({
+            policy: ws.policy,
+            workspace: ws,
+            toolSlug: resolvedSlug,
+            input: params.input || {},
+            riskLevel,
+            creditCost,
+            lane,
+        });
+    }
+    /**
+     * OpenTelemetry (OTel GenAI / MCP Semantic Conventions) & Langfuse Trace Exporter.
+     */
+    exportOtelTraces(ctx, limit = 25) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const runs = this.store.listRuns(ws.id, limit);
+        const receipts = this.store.listReceipts(ws.id, limit);
+        const plans = this.store.listPlans(ws.id, limit);
+        return buildOtelTraceExport({
+            workspace: ws,
+            runs,
+            receipts,
+            plans,
+        });
+    }
+    /**
+     * Turnkey & Custom Commercial Business Saga Playbooks.
+     */
+    listCommercialPlaybooks(ctx) {
+        const custom = ctx ? this.customPlaybooks.get(ctx.workspace.id) || [] : [];
+        return [...custom, ...MUXO_COMMERCIAL_PLAYBOOKS];
+    }
+    createCustomPlaybook(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const pb = parseNaturalLanguageCustomPlaybook(params.prompt || String(params.input?.prompt || params.input?.name || ""), params.input);
+        const existing = (this.customPlaybooks.get(ws.id) || []).filter((item) => item.slug !== pb.slug);
+        const updatedList = [pb, ...existing];
+        this.customPlaybooks.set(ws.id, updatedList);
+        this.store.upsertTemporalFact({
+            workspaceId: ws.id,
+            subject: `workspace:${ws.slug}`,
+            predicate: "REGISTERED_CUSTOM_PLAYBOOK",
+            object: `playbook:${pb.slug}`,
+            summary: `Registered custom ${pb.steps.length}-step Saga playbook '${pb.name}' (${pb.slug})`,
+            confidence: 0.99,
+            sourceKind: "preference",
+            sourceReferenceId: `pb_${pb.slug}`,
+        });
+        return {
+            ok: true,
+            playbook: pb,
+            playbooks: this.listCommercialPlaybooks(ctx),
+            humanMessage: `Created custom ${pb.steps.length}-step Saga playbook '${pb.slug}' (${pb.steps.map((s) => s.toolSlug).join(" → ")}).`,
+        };
+    }
+    runCommercialPlaybook(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const custom = this.customPlaybooks.get(ws.id) || [];
+        const playbook = getCommercialPlaybook(params.slug, custom);
+        if (!playbook) {
+            const err = new Error(`Unknown commercial playbook '${params.slug}'. Available playbooks: ${[...custom, ...MUXO_COMMERCIAL_PLAYBOOKS].map((p) => p.slug).join(", ")}`);
+            err.statusCode = 404;
+            err.code = "PLAYBOOK_NOT_FOUND";
+            throw err;
+        }
+        const wfId = `wf_saga_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+        const executed = buildPlaybookSagaExecution({
+            id: wfId,
+            workspaceId: ws.id,
+            workspaceSlug: ws.slug,
+            playbook,
+            input: params.input || {},
+        });
+        this.durableWorkflows.set(wfId, executed.workflow);
+        const savedFact = this.store.upsertTemporalFact({
+            workspaceId: ws.id,
+            subject: executed.temporalFact.subject,
+            predicate: executed.temporalFact.predicate,
+            object: executed.temporalFact.object,
+            summary: executed.temporalFact.summary,
+            confidence: 0.99,
+            sourceKind: "execution_outcome",
+            sourceReferenceId: executed.temporalFact.episodeId,
+        });
+        return {
+            ok: true,
+            playbook: executed.playbook,
+            workflow: executed.workflow,
+            temporalFact: savedFact,
+            usableResult: executed.usableResult,
+        };
+    }
+    /**
+     * Turnkey Harness Preset & One-Shot Agent Configurator.
+     */
+    async configureHarness(ctx, params) {
+        let ws = this.store.getWorkspace(ctx.workspace.id);
+        const matchedPreset = resolveHarnessPreset(params?.preset || params?.prompt || null);
+        if (matchedPreset) {
+            ws = this.store.updateWorkspacePolicy(ws.id, matchedPreset.policyPatch);
+            this.store.upsertTemporalFact({
+                workspaceId: ws.id,
+                subject: `workspace:${ws.slug}`,
+                predicate: "CONFIGURED_HARNESS_PRESET",
+                object: `preset:${matchedPreset.slug}`,
+                summary: `Applied harness preset '${matchedPreset.name}' (${matchedPreset.slug})`,
+                confidence: 1.0,
+                sourceKind: "policy_decision",
+                sourceReferenceId: `preset_${matchedPreset.slug}`,
+            });
+        }
+        if (params?.prompt) {
+            const guardrailCheck = parseNaturalLanguageGuardrail(params.prompt, ws.policy);
+            if (guardrailCheck.isGuardrail) {
+                const applied = await this.applyNaturalLanguageGuardrail(ctx, params.prompt);
+                ws = applied.workspace;
+            }
+        }
+        return buildHarnessConfigurationBundle({
+            workspace: ws,
+            baseUrl: this.config.baseUrl,
+            targetHarness: params?.harness || "all",
+            appliedPreset: matchedPreset,
+        });
+    }
+    /**
+     * FinOps & Commercial ROI Unit-Economics Analytics.
+     */
+    getCommercialRoiReport(ctx) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const runs = this.store.listRuns(ws.id, 100);
+        const plans = this.store.listPlans(ws.id, 100);
+        const resources = this.store.listResources(ws.id);
+        const byokKeys = this.store.listByokKeys(ws.id);
+        const temporalFacts = this.store.listTemporalFacts(ws.id, {
+            includeHistorical: false,
+            limit: 100,
+        });
+        return buildCommercialRoiReport({
+            workspace: ws,
+            runs,
+            plans,
+            resources,
+            byokKeys,
+            temporalFacts,
+        });
+    }
     /**
      * Hybrid Semantic Vector + Bi-Temporal Recall (`@cf/baai/bge-base-en-v1.5` + Vectorize model).
      */