@muxoai/sdk 1.3.0 → 1.4.3

package/dist/engine.js

@@ -1,10 +1,35 @@
+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, exportTemporalEventHistory, normalizeWorkflowTarget, rollbackDurableWorkflow as runSagaRollbackOnWorkflow, signalDurableWorkflow as sendSignalToWorkflow, workflowNotFoundError, } from "./durable-workflow.js";
+import { buildMemoryKnowledgeGraph } from "./memory-graph.js";
+import { MUXO_COMMERCIAL_PLAYBOOKS, buildCommercialRoiReport, buildOtelTraceExport, buildPlaybookSagaExecution, compileWorkspacePolicyToCedarAndRego, evaluateCedarAndOpaPolicy, getCommercialPlaybook, } 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";
 import { ComposioSdkAdapter } from "./providers/composio-sdk.js";
 import { MicrosoftGovernanceAdapter } from "./providers/microsoft-governance.js";
 import { StripeBillingAdapter } from "./providers/stripe-billing.js";
-import { StripeProjectsAdapter } from "./providers/stripe-projects.js";
-import { SupermemoryAdapter } from "./providers/supermemory.js";
+import { StripeProjectsAdapter, isPaidCloudProvisioning, } from "./providers/stripe-projects.js";
+import { SupermemoryAdapter, applyActiveMemoryToToolInput, explainMemoryContext, extractActiveMemoryDefaults, parseNaturalLanguageMemoryInstruction, rankMemoriesHybrid, } from "./providers/supermemory.js";
+function makeControlPlaneResolution(toolSlug, prompt, humanSummary, input = {}) {
+    return {
+        resolved: true,
+        confidence: 0.98,
+        resolutionMethod: "semantic_router",
+        byokUsed: null,
+        tool: null,
+        toolSlug,
+        input,
+        extractedInput: input,
+        missingInputs: [],
+        needsConnection: false,
+        suggestedByokProvider: null,
+        reason: prompt,
+        alternatives: [],
+        humanSummary,
+    };
+}
 export class MuxoEngine {
     config;
     store;
@@ -14,6 +39,7 @@ export class MuxoEngine {
     stripeBilling;
     governance;
     supermemory;
+    durableWorkflows = new Map();
     constructor(config, store) {
         this.config = config;
         this.store = store;
@@ -26,10 +52,14 @@ export class MuxoEngine {
     }
     // 1. get_profile
     getProfile(ctx) {
+        const nickname = (ctx.user.email || "").split("@")[0] ||
+            ctx.user.name.toLowerCase().replace(/\s+/g, ".") ||
+            ctx.user.id;
         return {
             id: ctx.user.id,
             name: ctx.user.name,
             email: ctx.user.email,
+            nickname,
             user: ctx.user,
             actorId: ctx.actorId,
             authType: ctx.authType,
@@ -44,6 +74,25 @@ export class MuxoEngine {
         const resources = this.store.listResources(ws.id);
         const connections = this.store.listConnections(ws.id);
         const supplierSettlementSummary = this.store.getSupplierSettlementSummary(ws.id);
+        const plainEnglishPolicy = describePolicyInPlainEnglish(ws.policy);
+        const localMemories = this.store.listMemoryRecords(ws.id, 25);
+        const activeFacts = this.store.listTemporalFacts(ws.id, {
+            includeHistorical: false,
+            limit: 30,
+        });
+        const inferred = extractActiveMemoryDefaults({
+            memories: localMemories,
+            temporalFacts: activeFacts,
+        });
+        const trustScore = this.governance.getWorkspaceTrustScore(ws.id);
+        const govStatus = this.governance.getStatus(ws);
+        const llmPolicyBrief = buildLlmPolicyAndGovernanceBrief(ws.policy, {
+            workspaceName: ws.name,
+            workspaceSlug: ws.slug,
+            activeDefaults: inferred.activeDefaults,
+            trustScore: { overall: trustScore.overall, tier: trustScore.tier },
+            agentDid: govStatus.agentDid,
+        });
         return {
             organization: {
                 id: ws.id,
@@ -58,11 +107,17 @@ export class MuxoEngine {
                 },
                 supplierSettlementSummary,
                 policy: ws.policy,
+                plainEnglishPolicy,
+                llmPolicyBrief,
+                activeDefaults: inferred.activeDefaults,
+                explanation: plainEnglishPolicy.explanation,
                 activeConnectionsCount: connections.filter((c) => c.status === "active").length,
                 provisionedResourcesCount: resources.filter((r) => r.status === "active").length,
                 projectsEnvironment: ws.projectsEnvName,
                 createdAt: ws.createdAt,
             },
+            llmPolicyBrief,
+            activeDefaults: inferred.activeDefaults,
         };
     }
     // 3. search_tools
@@ -70,7 +125,16 @@ export class MuxoEngine {
         const limit = Math.min(100, Math.max(1, Number(params.limit || 25)));
         const lane = params.lane || "all";
         const query = params.query?.trim();
+        const queryTokens = (query || "")
+            .toLowerCase()
+            .split(/[\s,._/-]+/)
+            .filter(Boolean);
+        const prefersStripeProjects = queryTokens.some((tok) => isStripeProjectsExclusiveProvider(tok) ||
+            /^(provision|deploy|deployment|publish|host|hosting|static|landing|database|postgres|sqlite|redis)$/.test(tok));
         const results = [];
+        if (lane === "all" && prefersStripeProjects) {
+            results.push(...this.stripeProjects.searchTools(query, limit));
+        }
         if (lane === "all" || lane === "composio_instant") {
             results.push(...this.composioInstant.searchTools(query, limit));
         }
@@ -78,8 +142,10 @@ export class MuxoEngine {
             const sdkTools = await this.composioSdk.searchTools(query, limit);
             results.push(...sdkTools);
         }
-        if (lane === "all" || lane === "stripe_projects") {
+        if (lane === "stripe_projects" || (lane === "all" && !prefersStripeProjects)) {
             results.push(...this.stripeProjects.searchTools(query, limit));
+        }
+        if (lane === "all" || lane === "stripe_projects") {
             const billingTools = this.stripeBilling.listTools().filter((t) => {
                 if (!query)
                     return true;
@@ -100,7 +166,7 @@ export class MuxoEngine {
     async listAllCatalogTools() {
         const instant = this.composioInstant.searchTools(undefined, 100);
         const sdk = await this.composioSdk.searchTools(undefined, 100);
-        const proj = this.stripeProjects.searchTools(undefined, 100);
+        const proj = this.stripeProjects.getTools();
         const billing = this.stripeBilling.listTools();
         return [...instant, ...billing, ...sdk, ...proj];
     }
@@ -122,14 +188,18 @@ export class MuxoEngine {
         const sdk = await this.composioSdk.inspectTool(normalized);
         if (sdk)
             return sdk;
-        throw new Error(`Tool '${normalized}' not found in Muxo catalog. Use search_tools to discover valid slugs.`);
+        throw unknownToolError(normalized);
     }
     // 5. connection_status
     async connectionStatus(ctx, params) {
         if (params?.syncLive !== false) {
             // Sync live Composio connected accounts for this workspace
-            const liveComposio = await this.composioSdk.listLiveConnections(ctx.workspace.id);
+            const composioByok = this.store.getByokKey(ctx.workspace.id, "composio");
+            const liveComposio = await this.composioSdk.listLiveConnections(ctx.workspace.id, composioByok);
             for (const c of liveComposio) {
+                if (isStripeProjectsExclusiveProvider(c.providerSlug)) {
+                    continue;
+                }
                 this.store.upsertConnection({
                     workspaceId: ctx.workspace.id,
                     lane: "composio_sdk",
@@ -141,7 +211,8 @@ export class MuxoEngine {
             }
             // Sync live Stripe Projects linked providers
             try {
-                const projStatus = await this.stripeProjects.getLiveStatus();
+                const stripeByok = this.store.getByokKey(ctx.workspace.id, "stripe");
+                const projStatus = await this.stripeProjects.getLiveStatus(stripeByok);
                 for (const p of projStatus.providers) {
                     this.store.upsertConnection({
                         workspaceId: ctx.workspace.id,
@@ -158,15 +229,63 @@ export class MuxoEngine {
                 // Keep cached connections if CLI is busy
             }
         }
-        let connections = this.store.listConnections(ctx.workspace.id);
+        let connections = this.store.listConnections(ctx.workspace.id).map((c) => {
+            if (isStripeProjectsExclusiveProvider(c.providerSlug)) {
+                return {
+                    ...c,
+                    lane: "stripe_projects",
+                    status: "active",
+                    redirectUrl: null,
+                };
+            }
+            return c.lane === "composio_sdk" && c.redirectUrl
+                ? {
+                    ...c,
+                    redirectUrl: wrapMuxoConnectUrl(c.redirectUrl, this.config.baseUrl, {
+                        workspaceId: c.workspaceId,
+                        providerSlug: c.providerSlug,
+                        externalAccountId: c.externalAccountId,
+                    }),
+                }
+                : c;
+        });
         if (params?.provider) {
-            const target = params.provider.toLowerCase();
-            connections = connections.filter((c) => c.providerSlug.toLowerCase() === target ||
-                c.providerName.toLowerCase().includes(target));
+            const target = normalizeStripeProjectsProviderSlug(params.provider) || params.provider.toLowerCase();
+            if (isStripeProjectsExclusiveProvider(target)) {
+                const activeRecord = this.store.upsertConnection({
+                    workspaceId: ctx.workspace.id,
+                    lane: "stripe_projects",
+                    providerSlug: target,
+                    providerName: target.charAt(0).toUpperCase() + target.slice(1),
+                    status: "active",
+                    externalAccountId: `sp_conn_${target}`,
+                    redirectUrl: null,
+                    metadata: {
+                        managedBy: "stripe_projects",
+                        requiresOAuth: false,
+                    },
+                });
+                connections = [activeRecord];
+            }
+            else {
+                connections = connections.filter((c) => c.providerSlug.toLowerCase() === target ||
+                    c.providerName.toLowerCase().includes(target));
+            }
         }
+        const targetConn = connections[0] || null;
+        const isActive = targetConn
+            ? targetConn.status === "active"
+            : connections.some((c) => c.status === "active");
         return {
+            ok: true,
             workspaceId: ctx.workspace.id,
             instantWalletStatus: "active",
+            connected: isActive,
+            ready: isActive,
+            timedOut: false,
+            status: targetConn?.status || "not_connected",
+            redirectUrl: isActive ? null : targetConn?.redirectUrl || null,
+            connection: targetConn,
             connections,
             summary: {
                 total: connections.length,
@@ -176,28 +295,43 @@ export class MuxoEngine {
             },
         };
     }
+    getHostedSiteHtml(slug, filePath) {
+        return this.stripeProjects.getHostedSiteHtml(slug, filePath);
+    }
     // 6. start_connection
     async startConnection(ctx, params) {
         const rawProvider = params.provider.trim().toLowerCase();
-        const isProjectsLane = params.lane === "stripe_projects" || rawProvider.startsWith("resource.");
-        const cleanSlug = rawProvider.replace(/^(app\.|resource\.)/, "");
+        const cleanSlug = normalizeStripeProjectsProviderSlug(rawProvider) ||
+            rawProvider.replace(/^(app\.|resource\.|projects\.)/, "");
+        const isProjectsLane = params.lane === "stripe_projects" ||
+            rawProvider.startsWith("resource.") ||
+            rawProvider.startsWith("projects.") ||
+            isStripeProjectsExclusiveProvider(cleanSlug);
         if (isProjectsLane) {
-            const linked = await this.stripeProjects.linkProvider(cleanSlug);
+            const stripeByok = this.store.getByokKey(ctx.workspace.id, "stripe");
+            const linked = await this.stripeProjects.linkProvider(cleanSlug, stripeByok);
             const record = this.store.upsertConnection({
                 workspaceId: ctx.workspace.id,
                 lane: "stripe_projects",
                 providerSlug: linked.providerSlug,
                 providerName: linked.providerSlug.charAt(0).toUpperCase() +
                     linked.providerSlug.slice(1),
-                status: linked.status,
+                status: linked.status === "requires_review" ? "pending" : linked.status,
+                externalAccountId: linked.connectionRequestId || null,
                 redirectUrl: linked.redirectUrl,
             });
-            return { ...record, message: linked.message };
+            return {
+                ...record,
+                message: linked.message,
+                ...(linked.workflowStatus ? { workflowStatus: linked.workflowStatus } : {}),
+            };
         }
+        const composioByok = this.store.getByokKey(ctx.workspace.id, "composio");
         const started = await this.composioSdk.startConnection({
             workspaceId: ctx.workspace.id,
             providerSlug: cleanSlug,
             callbackUrl: params.callbackUrl,
+            composioApiKey: composioByok,
         });
         const record = this.store.upsertConnection({
             workspaceId: ctx.workspace.id,
@@ -217,13 +351,46 @@ export class MuxoEngine {
     }
     // 6b. wait_for_connection (OAuth handoff polling & recovery, like COMPOSIO_WAIT_FOR_CONNECTIONS)
     async waitForConnection(ctx, params) {
-        const cleanSlug = params.provider
-            .trim()
-            .toLowerCase()
-            .replace(/^(app\.|resource\.)/, "");
-        const timeoutMs = Math.min(120, Math.max(0, Number(params.timeoutSeconds ?? 15))) * 1000;
+        const rawProvider = params.provider.trim().toLowerCase();
+        const cleanSlug = normalizeStripeProjectsProviderSlug(rawProvider) ||
+            rawProvider.replace(/^(app\.|resource\.|projects\.)/, "");
+        if (!cleanSlug) {
+            throw new Error("provider is required to wait for a connection (e.g. 'github').");
+        }
+        const startedAt = Date.now();
+        const timeoutMs = clampWaitSeconds(params.timeoutSeconds) * 1000;
         const pollIntervalMs = Math.min(5000, Math.max(200, Number(params.pollIntervalMs ?? 1500)));
-        const deadline = Date.now() + timeoutMs;
+        const deadline = startedAt + timeoutMs;
+        let polledAttempts = 0;
+        const connectedResult = (connection, message) => ({
+            ok: true,
+            connected: true,
+            ready: true,
+            timedOut: false,
+            provider: cleanSlug,
+            status: "active",
+            connection,
+            redirectUrl: null,
+            polledAttempts,
+            elapsedMs: Date.now() - startedAt,
+            message,
+        });
+        if (isStripeProjectsExclusiveProvider(cleanSlug)) {
+            const activeRecord = this.store.upsertConnection({
+                workspaceId: ctx.workspace.id,
+                lane: "stripe_projects",
+                providerSlug: cleanSlug,
+                providerName: cleanSlug.charAt(0).toUpperCase() + cleanSlug.slice(1),
+                status: "active",
+                externalAccountId: `sp_conn_${cleanSlug}`,
+                redirectUrl: null,
+                metadata: {
+                    managedBy: "stripe_projects",
+                    requiresOAuth: false,
+                },
+            });
+            return connectedResult(activeRecord, `${activeRecord.providerName} is managed via Stripe Projects Cloud Infrastructure and is active immediately (no OAuth required).`);
+        }
         let current = this.store
             .listConnections(ctx.workspace.id)
             .find((c) => c.providerSlug.toLowerCase() === cleanSlug);
@@ -236,24 +403,19 @@ export class MuxoEngine {
             }
         }
         while (true) {
+            polledAttempts += 1;
             const latestLocal = this.store
                 .listConnections(ctx.workspace.id)
                 .find((c) => c.providerSlug.toLowerCase() === cleanSlug);
             if (latestLocal) {
                 current = latestLocal;
                 if (latestLocal.status === "active") {
-                    return {
-                        connected: true,
-                        provider: cleanSlug,
-                        status: "active",
-                        connection: latestLocal,
-                        redirectUrl: null,
-                        message: `${latestLocal.providerName} OAuth handoff completed and connection is active.`,
-                    };
+                    return connectedResult(latestLocal, `${latestLocal.providerName} OAuth handoff completed and connection is active.`);
                 }
             }
             if (current?.externalAccountId && current.lane === "composio_sdk") {
-                const direct = await this.composioSdk.getConnectedAccountStatus(current.externalAccountId);
+                const composioByok = this.store.getByokKey(ctx.workspace.id, "composio");
+                const direct = await this.composioSdk.getConnectedAccountStatus(current.externalAccountId, composioByok);
                 if (direct && direct.status === "active") {
                     current = this.store.upsertConnection({
                         workspaceId: ctx.workspace.id,
@@ -264,14 +426,7 @@ export class MuxoEngine {
                         externalAccountId: direct.id,
                         redirectUrl: null,
                     });
-                    return {
-                        connected: true,
-                        provider: cleanSlug,
-                        status: "active",
-                        connection: current,
-                        redirectUrl: null,
-                        message: `${current.providerName} OAuth handoff completed and connection is active.`,
-                    };
+                    return connectedResult(current, `${current.providerName} OAuth handoff completed and connection is active.`);
                 }
             }
             const synced = await this.connectionStatus(ctx, {
@@ -283,14 +438,7 @@ export class MuxoEngine {
             if (found) {
                 current = found;
                 if (found.status === "active") {
-                    return {
-                        connected: true,
-                        provider: cleanSlug,
-                        status: "active",
-                        connection: found,
-                        redirectUrl: null,
-                        message: `${found.providerName} connection is active and ready for governed execution.`,
-                    };
+                    return connectedResult(found, `${found.providerName} connection is active and ready for governed execution.`);
                 }
             }
             if (Date.now() >= deadline) {
@@ -301,12 +449,27 @@ export class MuxoEngine {
         if (!current) {
             current = await this.startConnection(ctx, { provider: cleanSlug });
         }
+        else if (current.redirectUrl) {
+            current = {
+                ...current,
+                redirectUrl: wrapMuxoConnectUrl(current.redirectUrl, this.config.baseUrl, {
+                    workspaceId: ctx.workspace.id,
+                    providerSlug: cleanSlug,
+                    externalAccountId: current.externalAccountId,
+                }),
+            };
+        }
         return {
+            ok: true,
             connected: false,
+            ready: false,
+            timedOut: true,
             provider: cleanSlug,
             status: current.status,
             connection: current,
             redirectUrl: current.redirectUrl,
+            polledAttempts,
+            elapsedMs: Date.now() - startedAt,
             message: current.redirectUrl
                 ? `Awaiting user OAuth authorization for ${current.providerName}. Open ${current.redirectUrl} in a browser, then re-run wait_for_connection.`
                 : `Connection for ${current.providerName} is currently ${current.status}.`,
@@ -328,21 +491,29 @@ export class MuxoEngine {
             .find((c) => c.providerSlug.toLowerCase() === cleanSlug);
         const accountId = params.connectedAccountId || existing?.externalAccountId || null;
         let resolvedStatus = "pending";
+        const composioByok = this.store.getByokKey(ws.id, "composio");
         if (accountId) {
-            const live = await this.composioSdk.getConnectedAccountStatus(accountId);
+            const live = await this.composioSdk.getConnectedAccountStatus(accountId, composioByok);
             if (live) {
                 resolvedStatus = live.status;
             }
         }
         if (resolvedStatus !== "active") {
-            const liveList = await this.composioSdk.listLiveConnections(ws.id);
+            const liveList = await this.composioSdk.listLiveConnections(ws.id, composioByok);
             const match = liveList.find((c) => c.providerSlug === cleanSlug);
             if (match) {
                 resolvedStatus = match.status;
             }
         }
         const rawCallbackStatus = String(params.status || "").toLowerCase();
-        if (rawCallbackStatus === "success" ||
+        if (rawCallbackStatus === "failed" ||
+            rawCallbackStatus === "error" ||
+            rawCallbackStatus === "expired" ||
+            rawCallbackStatus === "cancelled" ||
+            rawCallbackStatus === "denied") {
+            resolvedStatus = "expired";
+        }
+        else if (rawCallbackStatus === "success" ||
             rawCallbackStatus === "active" ||
             rawCallbackStatus === "connected") {
             resolvedStatus = "active";
@@ -375,6 +546,9 @@ export class MuxoEngine {
             tool = await this.inspectTool(params.toolSlug);
         }
         catch (inspectErr) {
+            if (looksLikeToolSlug(params.toolSlug)) {
+                throw inspectErr;
+            }
             // Natural-language fallback: if an agent or human passed plain English as toolSlug/instruction, resolve it!
             const nlSource = `${params.toolSlug} ${params.reason || ""}`.trim();
             const allTools = await this.listAllCatalogTools();
@@ -392,8 +566,14 @@ export class MuxoEngine {
             resolvedInput = nl.input;
             resolvedReason = params.reason || nl.reason || nlSource;
         }
-        const byokActive = this.store.hasByokForLane(ws.id, tool.lane, tool.slug);
-        const effectiveCreditCost = byokActive ? 0 : tool.creditCost;
+        const byokActive = params.fundingMode === "muxo_funded"
+            ? false
+            : this.store.hasByokForLane(ws.id, tool.lane, tool.slug);
+        const isPaidResourcePlan = isPaidCloudProvisioning(tool, resolvedInput);
+        const baseCreditCost = isPaidResourcePlan
+            ? Math.max(tool.creditCost, 25)
+            : tool.creditCost;
+        const effectiveCreditCost = byokActive ? 0 : baseCreditCost;
         if (ws.monthlyActionsUsed >= ws.monthlyActionsLimit) {
             throw new Error(`Monthly action limit reached (${ws.monthlyActionsUsed}/${ws.monthlyActionsLimit}). Upgrade to Starter ($29/mo) to unlock 5,000 actions/mo.`);
         }
@@ -403,7 +583,20 @@ export class MuxoEngine {
         if (effectiveCreditCost > ws.policy.maxCreditsPerRun) {
             throw new Error(`Tool credit cost (${effectiveCreditCost}) exceeds workspace policy maxCreditsPerRun (${ws.policy.maxCreditsPerRun}).`);
         }
-        // 1. Evaluate Microsoft Agent Governance Pipeline:
+        // 1. Recall Supermemory v5 contextual brain first so Active Memory defaults can auto-fill tool parameters
+        const memoryQuery = `${tool.slug} ${tool.name} ${resolvedReason}`.trim();
+        const supermemoryByok = this.store.getByokKey(ws.id, "supermemory");
+        const memoryContext = await this.enrichMemoryContext(ws.id, await this.supermemory.getContextForWorkspace(ws.id, memoryQuery, supermemoryByok), memoryQuery);
+        const activeMemoryResult = applyActiveMemoryToToolInput({
+            toolSlug: tool.slug,
+            input: resolvedInput,
+            activeDefaults: memoryContext.activeDefaults,
+        });
+        resolvedInput = activeMemoryResult.mergedInput;
+        if (Object.keys(activeMemoryResult.autoFilledInput).length > 0) {
+            memoryContext.autoFilledInput = activeMemoryResult.autoFilledInput;
+        }
+        // 2. Evaluate Microsoft Agent Governance Pipeline:
         // Agent -> McpSecurityScanner -> PolicyEngine -> AgentIdentity (Ed25519 DID) -> AuditLogger -> DecisionRecord
         const decisionRecord = this.governance.evaluatePlan({
             workspace: ws,
@@ -415,12 +608,7 @@ export class MuxoEngine {
         if (decisionRecord.verdict === "deny") {
             throw new Error(`Microsoft Agent Governance denied plan for ${tool.slug} (rule: ${decisionRecord.matchedRule}): ${decisionRecord.reason}`);
         }
-        // 2. Recall Supermemory v5 contextual brain for this workspace + tool intent
-        const memoryQuery = `${tool.slug} ${tool.name} ${resolvedReason}`.trim();
-        const memoryContext = await this.supermemory.getContextForWorkspace(ws.id, memoryQuery);
-        const requiresHumanApproval = decisionRecord.verdict === "escalate" ||
-            (ws.policy.mode === "enforce" &&
-                ws.policy.requireApprovalFor.includes(tool.riskLevel));
+        const requiresHumanApproval = decisionRecord.verdict === "escalate";
         const approvalStatus = requiresHumanApproval
             ? "pending_approval"
             : "auto_approved";
@@ -457,14 +645,21 @@ export class MuxoEngine {
                     // Keep existing connection state if offline
                 }
                 if (!existingConn || existingConn.status !== "active") {
+                    const wrappedRedirectUrl = existingConn?.redirectUrl
+                        ? wrapMuxoConnectUrl(existingConn.redirectUrl, this.config.baseUrl, {
+                            workspaceId: ws.id,
+                            providerSlug: tool.providerSlug,
+                            externalAccountId: existingConn.externalAccountId,
+                        })
+                        : null;
                     authHandoff = {
                         required: true,
                         provider: tool.providerSlug,
                         status: existingConn?.status || "pending",
-                        redirectUrl: existingConn?.redirectUrl || null,
+                        redirectUrl: wrappedRedirectUrl,
                         externalAccountId: existingConn?.externalAccountId || null,
-                        instructions: existingConn?.redirectUrl
-                            ? `Ask the user to authorize ${tool.providerName} at ${existingConn.redirectUrl}, then call wait_for_connection({ provider: "${tool.providerSlug}" }) before executing ${plan.id}.`
+                        instructions: wrappedRedirectUrl
+                            ? `Ask the user to authorize ${tool.providerName} at ${wrappedRedirectUrl}, then call wait_for_connection({ provider: "${tool.providerSlug}" }) before executing ${plan.id}.`
                             : `Call start_connection({ provider: "${tool.providerSlug}" }) to authorize ${tool.providerName} before executing ${plan.id}.`,
                     };
                 }
@@ -477,12 +672,20 @@ export class MuxoEngine {
         if (authHandoff?.required) {
             nextStep = `${authHandoff.instructions} Once connected, ${nextStep}`;
         }
+        const humanHandoff = authHandoff?.required
+            ? this.buildOAuthHandoff(authHandoff, tool.providerName)
+            : approvalStatus === "pending_approval"
+                ? this.buildApprovalHandoff(plan)
+                : undefined;
+        const llmGuidance = this.buildPlanLlmGuidance(plan, authHandoff);
         return {
             plan,
             tool,
             decisionRecord,
             memoryContext,
             ...(authHandoff ? { authHandoff } : {}),
+            ...(humanHandoff ? { humanHandoff } : {}),
+            llmGuidance,
             nextStep,
         };
     }
@@ -493,6 +696,27 @@ export class MuxoEngine {
             throw new Error(`Plan '${planId}' not found in workspace.`);
         return plan;
     }
+    async waitForPlanApproval(ctx, params) {
+        const startedAt = Date.now();
+        const deadline = startedAt + clampWaitSeconds(params.timeoutSeconds, 15, 60) * 1000;
+        const pollIntervalMs = Math.min(2000, Math.max(100, Number(params.pollIntervalMs ?? 250)));
+        let plan = this.getPlan(ctx, params.planId);
+        while (plan.approvalStatus === "pending_approval" && Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, pollIntervalMs));
+            plan = this.getPlan(ctx, params.planId);
+        }
+        return {
+            ok: true,
+            approved: APPROVED_PLAN_STATUSES.has(plan.approvalStatus),
+            rejected: plan.approvalStatus === "rejected",
+            timedOut: plan.approvalStatus === "pending_approval",
+            waitedForApproval: true,
+            approvalStatus: plan.approvalStatus,
+            approvalUrl: buildApprovalUrl(this.config.baseUrl, plan.id),
+            waitedMs: Date.now() - startedAt,
+            plan,
+        };
+    }
     // Human owner approval / rejection
     approvePlan(ctx, planId, decision = "approved") {
         const plan = this.getPlan(ctx, planId);
@@ -506,54 +730,330 @@ export class MuxoEngine {
             approvedBy: ctx.user.email,
         });
     }
+    buildApprovalHandoff(plan) {
+        return buildApprovalHumanHandoff(this.config.baseUrl, plan);
+    }
+    buildOAuthHandoff(handoff, providerName) {
+        return buildOAuthHumanHandoff({
+            providerSlug: handoff.provider,
+            providerName,
+            redirectUrl: handoff.redirectUrl,
+            instructions: handoff.instructions,
+        });
+    }
+    buildPlanLlmGuidance(plan, authHandoff) {
+        const executeTool = `execute_${plan.riskLevel}`;
+        const nextToolCalls = [];
+        if (authHandoff?.required) {
+            nextToolCalls.push(authHandoff.redirectUrl
+                ? {
+                    tool: "wait_for_connection",
+                    input: { provider: authHandoff.provider },
+                    when: `After the user confirms they completed OAuth at ${authHandoff.redirectUrl}`,
+                }
+                : {
+                    tool: "start_connection",
+                    input: { provider: authHandoff.provider },
+                    when: "Immediately, to obtain an OAuth redirect URL for the user",
+                });
+        }
+        if (plan.approvalStatus === "pending_approval") {
+            nextToolCalls.push({
+                tool: "get_plan",
+                input: { plan_id: plan.id, wait_for_approval: true, timeout_seconds: 25 },
+                when: `After sharing ${this.config.baseUrl}/approve/${plan.id} with the user, to wait in-turn until they click Approve`,
+            });
+            nextToolCalls.push({
+                tool: executeTool,
+                input: { plan_id: plan.id },
+                when: `Only after the user explicitly approves plan ${plan.id} (via ${this.config.baseUrl}/approve/${plan.id} or \`muxo approve ${plan.id}\`)`,
+            });
+        }
+        else {
+            nextToolCalls.push({
+                tool: executeTool,
+                input: { plan_id: plan.id },
+                when: authHandoff?.required
+                    ? "After the connection becomes active"
+                    : "Immediately; the plan is auto-approved",
+            });
+        }
+        nextToolCalls.push({
+            tool: "get_receipt",
+            input: { run_id: "<run_id from the execute response>" },
+            when: "After execution, to verify the tamper-proof receipt",
+        });
+        const summary = authHandoff?.required
+            ? `Hand the OAuth link to the user, wait for the connection, then ${plan.approvalStatus === "pending_approval" ? "collect approval and " : ""}call ${executeTool}.`
+            : plan.approvalStatus === "pending_approval"
+                ? `Stop and ask the user to approve plan ${plan.id}; do not call ${executeTool} until they confirm.`
+                : `Call ${executeTool} with plan_id="${plan.id}" to execute now.`;
+        return { summary, nextToolCalls };
+    }
+    async enrichMemoryContext(workspaceId, ctx, query) {
+        const localRecords = this.store.listMemoryRecords(workspaceId, 8);
+        const temporalFacts = this.store.listTemporalFacts(workspaceId, {
+            includeHistorical: false,
+            query,
+            limit: 15,
+        });
+        const recalled = ctx.recalledMemories.length > 0
+            ? ctx.recalledMemories
+            : localRecords.slice(0, 5).map((r) => ({
+                documentId: r.documentId,
+                title: r.title,
+                snippet: r.content.slice(0, 240),
+                similarity: 1,
+                createdAt: r.createdAt,
+            }));
+        const staticFacts = ctx.staticFacts.length > 0
+            ? ctx.staticFacts
+            : localRecords
+                .filter((r) => r.kind === "fact" || r.kind === "preference")
+                .slice(0, 5)
+                .map((r) => `${r.title}: ${r.content.slice(0, 140)}`);
+        const dynamicContext = ctx.dynamicContext.length > 0
+            ? ctx.dynamicContext
+            : temporalFacts.slice(0, 6).map((f) => `${f.subject} ${f.predicate} ${f.object}`);
+        const combinedText = [
+            ...staticFacts,
+            ...dynamicContext,
+            ...recalled.map((m) => `${m.title}: ${m.snippet}`),
+        ].join("\n");
+        const poisonScan = this.governance.scanMemoryContent({
+            workspaceId,
+            sessionId: ctx.namespace,
+            role: "system",
+            content: combinedText,
+            recordInDetector: false,
+        });
+        const promptLines = [
+            `[Supermemory Brain — Namespace: ${ctx.namespace}]`,
+        ];
+        if (staticFacts.length > 0) {
+            promptLines.push(`Static Facts: ${staticFacts.join(" | ")}`);
+        }
+        if (dynamicContext.length > 0) {
+            promptLines.push(`Dynamic Context: ${dynamicContext.join(" | ")}`);
+        }
+        if (temporalFacts.length > 0) {
+            promptLines.push(`Bi-Temporal Lineage (${temporalFacts.length} active): ${temporalFacts
+                .slice(0, 5)
+                .map((f) => `${f.subject} -[${f.predicate}]-> ${f.object}`)
+                .join(" | ")}`);
+        }
+        if (recalled.length > 0) {
+            promptLines.push(`Recalled Memories: ${recalled.map((m) => `${m.title}: ${m.snippet}`).join(" | ")}`);
+        }
+        const mdLines = [`## Workspace Brain (${ctx.namespace})`];
+        if (staticFacts.length > 0) {
+            mdLines.push("### Static Facts", ...staticFacts.map((f) => `- ${f}`));
+        }
+        if (temporalFacts.length > 0) {
+            mdLines.push("### Bi-Temporal Resource & Fact Lineage (Active)", ...temporalFacts
+                .slice(0, 8)
+                .map((f) => `- **${f.subject}** \`${f.predicate}\` **${f.object}** _(validFrom: ${f.validFrom})_ — ${f.summary}`));
+        }
+        const allLocalMemories = this.store.listMemoryRecords(workspaceId, 25);
+        const allActiveFacts = this.store.listTemporalFacts(workspaceId, {
+            includeHistorical: false,
+            limit: 30,
+        });
+        const inferred = extractActiveMemoryDefaults({
+            memories: allLocalMemories,
+            temporalFacts: allActiveFacts,
+            preferences: ctx.profile?.preferences || [],
+            staticFacts,
+        });
+        const mergedActiveDefaults = {
+            ...(ctx.activeDefaults || {}),
+            ...inferred.activeDefaults,
+        };
+        const ws = this.store.getWorkspace(workspaceId);
+        const mergedGuardrails = Array.from(new Set([
+            ...(ws?.policy?.naturalLanguageRules || []),
+            ...(ctx.activeGuardrails || []),
+            ...inferred.activeGuardrails,
+        ]));
+        if (Object.keys(mergedActiveDefaults).length > 0) {
+            promptLines.push(`Active Memory Auto-Fill Defaults: ${Object.entries(mergedActiveDefaults)
+                .map(([k, v]) => `${k}=${String(v)}`)
+                .join(", ")}`);
+        }
+        const enriched = {
+            ...ctx,
+            enabled: true,
+            staticFacts,
+            dynamicContext,
+            recalledMemories: recalled,
+            relevantMemories: recalled,
+            formattedPromptContext: promptLines.join("\n"),
+            profileMarkdown: ctx.profileMarkdown || mdLines.join("\n"),
+            profile: {
+                ...ctx.profile,
+                static: staticFacts,
+                dynamic: dynamicContext,
+            },
+            temporalFacts,
+            activeDefaults: mergedActiveDefaults,
+            activeGuardrails: mergedGuardrails,
+            contextPoisoningScan: {
+                safe: poisonScan.safe,
+                riskLevel: poisonScan.riskLevel,
+                findingsCount: poisonScan.findingsCount,
+            },
+        };
+        enriched.explanation = explainMemoryContext({
+            memory: enriched,
+            localCount: allLocalMemories.length,
+            activeTemporalCount: allActiveFacts.length,
+            policy: ws?.policy,
+        });
+        return enriched;
+    }
     // 9. get_run_context
     async getRunContext(ctx, query) {
         const ws = this.store.getWorkspace(ctx.workspace.id);
         const resources = this.store.listResources(ws.id);
+        const activeResources = resources.filter((r) => r.status === "active");
         const activeEnv = this.store.getDecryptedWorkspaceEnv(ws.id);
         const redactedEnv = {};
         for (const [k, v] of Object.entries(activeEnv)) {
             redactedEnv[k] =
                 v.length > 8 ? `${v.slice(0, 4)}••••${v.slice(-3)}` : "••••••••";
         }
-        const memoryContext = await this.supermemory.getContextForWorkspace(ws.id, query);
+        const supermemoryByok = this.store.getByokKey(ws.id, "supermemory");
+        const memoryContext = await this.enrichMemoryContext(ws.id, await this.supermemory.getContextForWorkspace(ws.id, query, supermemoryByok), query);
+        const plainEnglishPolicy = describePolicyInPlainEnglish(ws.policy);
+        const governanceStatus = this.governance.getStatus(ws);
+        const trustScore = this.governance.getWorkspaceTrustScore(ws.id);
+        const actionsRemaining = Math.max(0, ws.monthlyActionsLimit - ws.monthlyActionsUsed);
+        const defaultsList = Object.entries(memoryContext.activeDefaults || {}).map(([k, v]) => `${k}=${String(v)}`);
+        const contextHeadline = `Workspace ${ws.name} (${ws.slug}): ${ws.creditsBalance} credits ($${(ws.creditsBalance * 0.01).toFixed(2)}) available · ${plainEnglishPolicy.headline}`;
+        const contextNonTechnical = [
+            contextHeadline,
+            defaultsList.length > 0
+                ? `Learned defaults ready for auto-fill: ${defaultsList.join(", ")}.`
+                : "No learned defaults set yet.",
+            activeResources.length > 0
+                ? `Active cloud resources (${activeResources.length}): ${activeResources.map((r) => `${r.resourceName} (${r.providerName})`).join(", ")}.`
+                : "No cloud infrastructure resources provisioned yet.",
+            memoryContext.explanation?.nonTechnical || "",
+        ]
+            .filter(Boolean)
+            .join(" ");
+        const contextTechnical = `workspace=${ws.id} (${ws.slug}, tier=${ws.tier}) | credits=${ws.creditsBalance} | actionsRemaining=${actionsRemaining}/${ws.monthlyActionsLimit} | ${plainEnglishPolicy.technical} | supermemoryNs=${memoryContext.namespace} | temporalFacts=${(memoryContext.temporalFacts || []).length} | activeDefaults=${JSON.stringify(memoryContext.activeDefaults || {})} | activeResources=${activeResources.length} | redactedEnvKeys=[${Object.keys(redactedEnv).join(", ")}] | agentDid=${governanceStatus.agentDid} | trustScore=${trustScore.overall} (${trustScore.tier})`;
+        const explanation = formatHumanFriendlyExplanation({
+            headline: contextHeadline,
+            nonTechnical: contextNonTechnical,
+            technical: contextTechnical,
+            policy: ws.policy,
+        });
+        const llmPolicyBrief = buildLlmPolicyAndGovernanceBrief(ws.policy, {
+            workspaceName: ws.name,
+            workspaceSlug: ws.slug,
+            activeDefaults: memoryContext.activeDefaults || {},
+            trustScore: { overall: trustScore.overall, tier: trustScore.tier },
+            agentDid: governanceStatus.agentDid,
+        });
+        const llmSystemPrompt = [
+            `# Muxo Governed Workspace Context (${ws.name} / ${ws.slug})`,
+            `- **Language Preference**: ${ws.policy.languageMode || "hybrid"}${ws.policy.customInstructions?.length ? ` (Custom Instructions: ${ws.policy.customInstructions.join("; ")})` : ""}`,
+            `- **Safety Guardrails**: ${plainEnglishPolicy.preferred}`,
+            `- **Learned Memory Defaults (Auto-Fill)**: ${defaultsList.length > 0 ? defaultsList.join(", ") : "none"}`,
+            `- **Credits & Quota**: ${ws.creditsBalance} credits ($${(ws.creditsBalance * 0.01).toFixed(2)}) available, ${actionsRemaining} monthly actions remaining`,
+            `- **Active Cloud Resources**: ${activeResources.length > 0 ? activeResources.map((r) => `${r.resourceName} (${r.serviceSlug})`).join(", ") : "none"}`,
+            llmPolicyBrief.llmSystemDirective,
+            memoryContext.formattedPromptContext,
+        ].join("\n");
         return {
             workspaceId: ws.id,
             workspaceSlug: ws.slug,
             projectsEnvironment: ws.projectsEnvName,
             policy: ws.policy,
+            plainEnglishPolicy,
+            llmPolicyBrief,
+            languageMode: ws.policy.languageMode || "hybrid",
+            customInstructions: ws.policy.customInstructions || [],
+            activeDefaults: (memoryContext.activeDefaults ||
+                {}),
+            activeGuardrails: memoryContext.activeGuardrails || [],
             creditsBalance: ws.creditsBalance,
-            monthlyActionsRemaining: Math.max(0, ws.monthlyActionsLimit - ws.monthlyActionsUsed),
-            provisionedResources: resources.filter((r) => r.status === "active"),
+            monthlyActionsRemaining: actionsRemaining,
+            provisionedResources: activeResources,
             environmentVariablesRedacted: redactedEnv,
             supermemoryBrain: memoryContext,
-            governance: this.governance.getStatus(ws),
+            temporalFacts: memoryContext.temporalFacts || [],
+            governance: governanceStatus,
+            trustScore,
+            llmSystemPrompt,
+            explanation,
             envPullHint: "Run `muxo env pull` or call GET /api/v1/resources/env to write decrypted credentials to your local .env file.",
         };
     }
     // Supermemory Workspace Brain Operations
     async getMemoryOverview(ctx, query) {
-        const context = await this.supermemory.getContextForWorkspace(ctx.workspace.id, query);
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const supermemoryByok = this.store.getByokKey(ctx.workspace.id, "supermemory");
+        const context = await this.enrichMemoryContext(ctx.workspace.id, await this.supermemory.getContextForWorkspace(ctx.workspace.id, query, supermemoryByok), query);
         const recentMemories = this.store.listMemoryRecords(ctx.workspace.id, 25);
+        const allFacts = this.store.listTemporalFacts(ctx.workspace.id, {
+            includeHistorical: true,
+            query,
+            limit: 50,
+        });
+        const activeFacts = allFacts.filter((f) => f.validTo === null);
+        const historicalFacts = allFacts.filter((f) => f.validTo !== null);
+        const explanation = explainMemoryContext({
+            memory: context,
+            localCount: recentMemories.length,
+            activeTemporalCount: activeFacts.length,
+            historicalTemporalCount: historicalFacts.length,
+            policy: ws.policy,
+        });
         return {
             enabled: context.enabled,
             namespace: context.namespace,
+            fundingSource: context.fundingSource || "local_fallback",
             context,
+            activeDefaults: (context.activeDefaults || {}),
+            activeGuardrails: context.activeGuardrails || [],
+            explanation,
             recentMemories,
             memories: recentMemories,
+            temporalFacts: activeFacts,
+            historicalFacts,
         };
     }
     async addWorkspaceMemory(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
         const kind = params.kind || "fact";
+        // Microsoft Agent Governance OWASP ASI-06 ContextPoisoningDetector guard on memory ingestion
+        const poisonScan = this.governance.scanMemoryContent({
+            workspaceId: ws.id,
+            sessionId: this.supermemory.getWorkspaceNamespace(ws.id),
+            role: "user",
+            content: `${params.title}\n${params.content}`,
+            recordInDetector: true,
+        });
+        if (!poisonScan.safe && ws.policy.mode === "enforce") {
+            this.governance.recordAgentOutcome(ws.id, false, 0.1);
+            throw new Error(`Blocked by Microsoft ContextPoisoningDetector (OWASP ASI-06, risk=${poisonScan.riskLevel}): ${poisonScan.findings
+                .map((f) => `${f.patternName} (${f.description})`)
+                .join("; ")}`);
+        }
+        const supermemoryByok = this.store.getByokKey(ws.id, "supermemory");
         const remote = await this.supermemory.addMemory({
-            workspaceId: ctx.workspace.id,
+            workspaceId: ws.id,
             title: params.title,
             content: params.content,
             kind,
             metadata: params.metadata,
+            apiKeyOverride: supermemoryByok,
+            dreaming: "instant",
         });
-        return this.store.saveMemoryRecord({
-            workspaceId: ctx.workspace.id,
+        const record = this.store.saveMemoryRecord({
+            workspaceId: ws.id,
             namespace: remote.namespace,
             documentId: remote.documentId,
             title: params.title,
@@ -562,22 +1062,140 @@ export class MuxoEngine {
             metadata: {
                 ...(params.metadata || {}),
                 supermemoryStatus: remote.status,
+                fundingSource: remote.fundingSource,
+                contextPoisoningScan: {
+                    safe: poisonScan.safe,
+                    riskLevel: poisonScan.riskLevel,
+                    findingsCount: poisonScan.findingsCount,
+                },
             },
         });
+        // Record bi-temporal entity/relationship lineage (auto-superseding prior facts for same subject+predicate)
+        const normalizedTitlePred = params.title
+            .trim()
+            .toUpperCase()
+            .replace(/[^A-Z0-9]+/g, "_")
+            .replace(/^_|_$/g, "")
+            .slice(0, 48);
+        const subject = params.subject ||
+            (typeof params.metadata?.subject === "string"
+                ? params.metadata.subject
+                : `workspace:${ws.slug}`);
+        const predicate = params.predicate ||
+            (typeof params.metadata?.predicate === "string"
+                ? params.metadata.predicate
+                : normalizedTitlePred || kind.toUpperCase());
+        const object = params.object ||
+            (typeof params.metadata?.object === "string"
+                ? params.metadata.object
+                : remote.sanitizedContent.slice(0, 160));
+        this.store.upsertTemporalFact({
+            workspaceId: ws.id,
+            subject,
+            predicate,
+            object,
+            summary: `${params.title}: ${remote.sanitizedContent.slice(0, 240)}`,
+            confidence: 0.95,
+            sourceKind: kind,
+            sourceReferenceId: record.id,
+            metadata: params.metadata || {},
+        });
+        return record;
     }
     async deleteWorkspaceMemory(ctx, idOrDocId) {
         const local = this.store.deleteMemoryRecord(ctx.workspace.id, idOrDocId);
         const docId = local?.documentId || idOrDocId;
-        const remote = await this.supermemory.deleteMemory(ctx.workspace.id, docId);
+        const supermemoryByok = this.store.getByokKey(ctx.workspace.id, "supermemory");
+        const remote = await this.supermemory.deleteMemory(ctx.workspace.id, docId, supermemoryByok);
         return {
             deleted: Boolean(local || remote.deleted),
             record: local,
         };
     }
+    async forgetWorkspaceMemoryMatching(ctx, query) {
+        const localPruned = this.store.forgetMatchingMemoryRecords(ctx.workspace.id, query);
+        const supermemoryByok = this.store.getByokKey(ctx.workspace.id, "supermemory");
+        const remotePruned = await this.supermemory.forgetMatching({
+            workspaceId: ctx.workspace.id,
+            query,
+            apiKeyOverride: supermemoryByok,
+        });
+        return {
+            query,
+            deletedLocalCount: localPruned.deletedMemories.length,
+            invalidatedFactsCount: localPruned.invalidatedFacts.length,
+            deletedRemoteIds: remotePruned.deletedRemoteIds,
+            deletedMemories: localPruned.deletedMemories,
+            invalidatedFacts: localPruned.invalidatedFacts,
+        };
+    }
+    /**
+     * Synthesizes a Bi-Temporal Knowledge Graph (entities, active relationships, superseded historical relationships,
+     * 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, queryOrOptions) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const opts = typeof queryOrOptions === "string"
+            ? { query: queryOrOptions }
+            : queryOrOptions || {};
+        const overview = await this.getMemoryOverview(ctx, opts.query);
+        return buildMemoryKnowledgeGraph({
+            workspace: ws,
+            namespace: overview.namespace,
+            query: opts.query,
+            asOf: opts.asOf || null,
+            focalEntity: opts.focalEntity || null,
+            maxHops: opts.maxHops,
+            facts: this.store.listTemporalFacts(ws.id, {
+                includeHistorical: true,
+                query: opts.query,
+                limit: 100,
+            }),
+            resources: this.store.listResources(ws.id),
+            activeConnections: this.store
+                .listConnections(ws.id)
+                .filter((c) => c.status === "active"),
+            memoriesCount: overview.memories.length,
+        });
+    }
+    async activateWorkspaceKillSwitch(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const result = await this.governance.activateKillSwitch(ws.id, params.reason, params.action || "quarantine");
+        const updatedWs = this.store.updateWorkspacePolicy(ws.id, {
+            ...ws.policy,
+            killSwitchActive: true,
+            killSwitchReason: params.reason,
+        });
+        return {
+            activated: true,
+            killSwitch: result,
+            policy: updatedWs.policy,
+            trustScore: this.governance.getWorkspaceTrustScore(ws.id),
+        };
+    }
+    resumeWorkspaceKillSwitch(ctx) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const resumed = this.governance.resumeKillSwitch(ws.id);
+        const updatedWs = this.store.updateWorkspacePolicy(ws.id, {
+            ...ws.policy,
+            killSwitchActive: false,
+            killSwitchReason: null,
+        });
+        return {
+            ...resumed,
+            resumed: true,
+            policy: updatedWs.policy,
+            trustScore: this.governance.getWorkspaceTrustScore(ws.id),
+        };
+    }
     // 10-15. execute_<risk_level>
     async executePlanForRisk(ctx, planId, expectedRisk) {
         const plan = this.getPlan(ctx, planId);
-        if (plan.riskLevel !== expectedRisk) {
+        const isProjectsWriteCompatible = plan.lane === "stripe_projects" &&
+            plan.riskLevel === "provisioning" &&
+            expectedRisk === "write";
+        if (plan.riskLevel !== expectedRisk && !isProjectsWriteCompatible) {
             throw new Error(`Risk lane mismatch: Plan '${plan.id}' has risk level '${plan.riskLevel}', so it must be executed with 'execute_${plan.riskLevel}' instead of 'execute_${expectedRisk}'.`);
         }
         if (plan.runId) {
@@ -589,13 +1207,30 @@ export class MuxoEngine {
             throw new Error(`Plan '${plan.id}' was already claimed by run '${plan.runId}' (execute-once invariant).`);
         }
         if (plan.approvalStatus === "pending_approval") {
-            throw new Error(`Plan '${plan.id}' (${plan.riskLevel}) is awaiting human approval. Approve it in the Muxo Console or via CLI 'muxo approve ${plan.id}' before executing.`);
+            throw approvalRequiredError(this.config.baseUrl, plan);
         }
         if (plan.approvalStatus === "rejected") {
             throw new Error(`Plan '${plan.id}' was rejected and cannot be executed.`);
         }
         const ws = this.store.getWorkspace(ctx.workspace.id);
         const tool = await this.inspectTool(plan.toolSlug);
+        const explicitFunding = plan.supplierSettlement?.fundingMode;
+        const byokActive = explicitFunding === "byok"
+            ? true
+            : explicitFunding === "muxo_funded"
+                ? false
+                : this.store.hasByokForLane(ws.id, tool.lane, tool.slug);
+        const effectiveCreditCost = byokActive
+            ? 0
+            : plan.creditCost > 0
+                ? plan.creditCost
+                : tool.creditCost;
+        if (ws.monthlyActionsUsed >= ws.monthlyActionsLimit) {
+            throw new Error(`Monthly action limit reached (${ws.monthlyActionsUsed}/${ws.monthlyActionsLimit}). Upgrade to Starter ($29/mo) to unlock 5,000 actions/mo.`);
+        }
+        if (effectiveCreditCost > ws.creditsBalance) {
+            throw new Error(`Insufficient workspace credits to execute plan '${plan.id}' for ${tool.slug} (requires ${effectiveCreditCost}, available ${ws.creditsBalance}). Top up credits or configure a BYOK key.`);
+        }
         const execDecisionRecord = this.governance.evaluateExecution({
             workspace: ws,
             actorId: ctx.actorId,
@@ -607,7 +1242,16 @@ export class MuxoEngine {
         }
         let activeConnId = null;
         if (plan.lane === "composio_sdk" && tool.requiresAuth) {
-            let connections = this.store.listConnections(ctx.workspace.id);
+            let connections = this.store.listConnections(ctx.workspace.id).map((c) => c.lane === "composio_sdk" && c.redirectUrl
+                ? {
+                    ...c,
+                    redirectUrl: wrapMuxoConnectUrl(c.redirectUrl, this.config.baseUrl, {
+                        workspaceId: c.workspaceId,
+                        providerSlug: c.providerSlug,
+                        externalAccountId: c.externalAccountId,
+                    }),
+                }
+                : c);
             let activeConn = connections.find((c) => c.lane === "composio_sdk" &&
                 c.providerSlug === tool.providerSlug &&
                 c.status === "active");
@@ -639,25 +1283,66 @@ export class MuxoEngine {
                 });
             }
             else if (plan.lane === "composio_instant") {
+                const composioByok = byokActive
+                    ? this.store.getByokKey(ctx.workspace.id, "composio")
+                    : null;
+                const exaByok = byokActive
+                    ? this.store.getByokKey(ctx.workspace.id, "exa")
+                    : null;
+                const firecrawlByok = byokActive
+                    ? this.store.getByokKey(ctx.workspace.id, "firecrawl")
+                    : null;
                 output = await this.composioInstant.executeTool({
                     workspaceId: ctx.workspace.id,
                     tool,
                     input: plan.input,
+                    composioApiKey: composioByok,
+                    exaApiKey: exaByok,
+                    firecrawlApiKey: firecrawlByok,
                 });
             }
             else if (plan.lane === "composio_sdk") {
+                const composioByok = byokActive
+                    ? this.store.getByokKey(ctx.workspace.id, "composio")
+                    : null;
                 output = await this.composioSdk.executeTool({
                     workspaceId: ctx.workspace.id,
                     tool,
                     input: plan.input,
                     connectedAccountId: activeConnId,
+                    composioApiKey: composioByok,
                 });
             }
             else if (plan.lane === "stripe_projects") {
+                const stripeByok = byokActive
+                    ? this.store.getByokKey(ctx.workspace.id, "stripe")
+                    : null;
+                const enrichedInput = { ...plan.input };
+                if (!enrichedInput.resource_id &&
+                    (plan.toolSlug === "resource.projects.rotate_credentials" ||
+                        plan.toolSlug === "resource.projects.deprovision" ||
+                        plan.toolSlug === "resource.projects.reveal_access_configuration")) {
+                    const rName = String(enrichedInput.resource_name ||
+                        enrichedInput.database_name ||
+                        enrichedInput.name ||
+                        "")
+                        .trim()
+                        .toLowerCase();
+                    if (rName) {
+                        const matchedRes = this.store
+                            .listResources(ctx.workspace.id)
+                            .find((r) => r.resourceName.toLowerCase() === rName &&
+                            r.externalResourceId);
+                        if (matchedRes?.externalResourceId) {
+                            enrichedInput.resource_id = matchedRes.externalResourceId;
+                        }
+                    }
+                }
                 const projResult = await this.stripeProjects.executeTool({
                     workspaceId: ctx.workspace.id,
                     tool,
-                    input: plan.input,
+                    input: enrichedInput,
+                    stripeApiKey: stripeByok,
                 });
                 output = projResult.output;
                 if (projResult.provisionedResource) {
@@ -671,19 +1356,49 @@ export class MuxoEngine {
                 throw new Error(`Unsupported execution lane: ${plan.lane}`);
             }
             const durationMs = Date.now() - startedMs;
+            this.governance.recordAgentOutcome(ctx.workspace.id, true, 0.05);
             const finalized = this.store.finalizeRun({
                 workspaceId: ctx.workspace.id,
                 runId: run.id,
                 status: "succeeded",
                 output,
                 actionsMetered: 1,
-                creditsMetered: plan.creditCost,
+                creditsMetered: effectiveCreditCost,
                 durationMs,
                 decisionRecord: execDecisionRecord,
             });
+            finalized.receipt.agenticReceipt =
+                this.governance.buildPortableAgenticReceipt({
+                    receipt: finalized.receipt,
+                    run: finalized.run,
+                    workspace: ws,
+                });
+            finalized.receipt.explanation = this.explainReceipt(finalized.receipt, {
+                signatureValid: this.store.verifyReceipt(finalized.receipt),
+                governanceSignatureValid: true,
+                agenticReceiptValid: true,
+            }, ws.policy);
+            this.store.upsertTemporalFact({
+                workspaceId: ctx.workspace.id,
+                subject: `tool:${plan.toolSlug}`,
+                predicate: "LAST_EXECUTION",
+                object: `succeeded:${finalized.run.id}`,
+                summary: `Executed ${plan.toolSlug} (${plan.lane}, risk=${plan.riskLevel}) -> succeeded [receipt=${finalized.receipt.id}]`,
+                confidence: 1.0,
+                sourceKind: "execution_outcome",
+                sourceReferenceId: finalized.run.id,
+                metadata: {
+                    runId: finalized.run.id,
+                    receiptId: finalized.receipt.id,
+                    toolSlug: plan.toolSlug,
+                    lane: plan.lane,
+                    riskLevel: plan.riskLevel,
+                },
+            });
             // Record secret-redacted post-run memory in Supermemory for stateful actions
             if (plan.riskLevel !== "read") {
                 const summary = `Executed ${plan.toolSlug} (${plan.lane}, risk=${plan.riskLevel}) for reason "${plan.reason}" -> status=succeeded (receipt=${finalized.receipt.id}).`;
+                const supermemoryByok = this.store.getByokKey(ctx.workspace.id, "supermemory");
                 this.supermemory
                     .recordExecutionMemory({
                     workspaceId: ctx.workspace.id,
@@ -693,6 +1408,7 @@ export class MuxoEngine {
                     reason: plan.reason,
                     status: "succeeded",
                     summary,
+                    apiKeyOverride: supermemoryByok,
                 })
                     .then((docId) => {
                     if (docId) {
@@ -717,8 +1433,9 @@ export class MuxoEngine {
         }
         catch (err) {
             const durationMs = Date.now() - startedMs;
+            this.governance.recordAgentOutcome(ctx.workspace.id, false, 0.08);
             const errorMessage = String(err?.message || err || "Execution failed");
-            return this.store.finalizeRun({
+            const failedFinalized = this.store.finalizeRun({
                 workspaceId: ctx.workspace.id,
                 runId: run.id,
                 status: "failed",
@@ -729,6 +1446,18 @@ export class MuxoEngine {
                 durationMs,
                 decisionRecord: execDecisionRecord,
             });
+            failedFinalized.receipt.agenticReceipt =
+                this.governance.buildPortableAgenticReceipt({
+                    receipt: failedFinalized.receipt,
+                    run: failedFinalized.run,
+                    workspace: ws,
+                });
+            failedFinalized.receipt.explanation = this.explainReceipt(failedFinalized.receipt, {
+                signatureValid: this.store.verifyReceipt(failedFinalized.receipt),
+                governanceSignatureValid: true,
+                agenticReceiptValid: true,
+            }, ws.policy);
+            return failedFinalized;
         }
     }
     // 16. get_run
@@ -739,40 +1468,780 @@ export class MuxoEngine {
         return run;
     }
     // 17. cancel_run
-    cancelRun(ctx, runId) {
-        const run = this.getRun(ctx, runId);
-        if (run.status === "succeeded" || run.status === "failed" || run.status === "cancelled") {
-            return {
-                run,
-                receipt: this.store.getReceipt(ctx.workspace.id, run.id),
-            };
+    cancelRun(ctx, runId, reason) {
+        const cleanId = String(runId || "").trim();
+        if (!cleanId)
+            throw new Error("run_id is required to cancel a run.");
+        const run = this.getRun(ctx, cleanId);
+        if (run.status === "cancelled") {
+            const existing = this.store.getReceipt(ctx.workspace.id, run.id);
+            if (existing) {
+                return {
+                    ok: true,
+                    cancelled: true,
+                    alreadyCancelled: true,
+                    previousStatus: "cancelled",
+                    run,
+                    receipt: existing,
+                    signatureValid: this.store.verifyReceipt(existing),
+                    message: `Run '${run.id}' was already cancelled.`,
+                };
+            }
         }
-        const finalized = this.store.finalizeRun({
+        const previousStatus = run.status;
+        const cancelled = this.store.cancelRun({
             workspaceId: ctx.workspace.id,
             runId: run.id,
-            status: "cancelled",
-            output: { cancelledBy: ctx.actorId },
-            error: "Cancelled by operator",
-            actionsMetered: 0,
-            creditsMetered: 0,
-            durationMs: Date.now() - new Date(run.startedAt).getTime(),
+            cancelledBy: ctx.actorId,
+            reason: reason?.trim() || undefined,
+        });
+        const completedEarlier = previousStatus === "succeeded" || previousStatus === "failed";
+        return {
+            ok: true,
+            cancelled: true,
+            alreadyCancelled: false,
+            previousStatus,
+            run: cancelled.run,
+            receipt: cancelled.receipt,
+            signatureValid: this.store.verifyReceipt(cancelled.receipt),
+            message: completedEarlier
+                ? `Run '${run.id}' had already ${previousStatus}; it is now marked cancelled with a signed cancellation receipt (${cancelled.receipt.id}). Upstream side effects are not reversed.`
+                : `Run '${run.id}' cancelled with signed cancellation receipt ${cancelled.receipt.id}.`,
+        };
+    }
+    explainReceipt(receipt, verification, policy, languageMode) {
+        const dollars = (receipt.creditsMetered * 0.01).toFixed(2);
+        const fundingMode = receipt.supplierSettlement?.fundingMode || "muxo_funded";
+        const fundingPlain = fundingMode === "byok"
+            ? "0 credits charged (settled directly using your BYOK key)"
+            : `${receipt.creditsMetered} credit${receipt.creditsMetered === 1 ? "" : "s"} ($${dollars} USD, settled via Muxo master wallet)`;
+        const agenticOk = verification.agenticReceiptValid ?? true;
+        const verified = verification.signatureValid &&
+            verification.governanceSignatureValid &&
+            agenticOk;
+        const headline = receipt.status === "succeeded"
+            ? `Verified Receipt (${receipt.id}): ${receipt.toolSlug} succeeded and passed all safety & integrity checks.`
+            : receipt.status === "failed"
+                ? `Verified Receipt (${receipt.id}): ${receipt.toolSlug} failed (0 credits charged).`
+                : `Verified Receipt (${receipt.id}): ${receipt.toolSlug} was cancelled.`;
+        const nonTechnical = [
+            headline,
+            `Action: ${receipt.toolSlug} (${receipt.riskLevel} risk lane) at ${receipt.issuedAt}.`,
+            `Cost & billing: ${fundingPlain}.`,
+            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).",
+        ].join(" ");
+        const technical = `receiptId=${receipt.id} | runId=${receipt.runId} | planId=${receipt.planId} | toolSlug=${receipt.toolSlug} | lane=${receipt.lane} | riskLevel=${receipt.riskLevel} | status=${receipt.status} | creditsMetered=${receipt.creditsMetered} ($${dollars}) | fundingMode=${fundingMode} | inputSha256=${receipt.inputHash.slice(0, 16)}... | outputSha256=${receipt.outputHash.slice(0, 16)}... | hashChain=(${receipt.prevReceiptHash.slice(0, 16)}... -> ${receipt.receiptHash.slice(0, 16)}...) | hmacSignatureValid=${verification.signatureValid} | ed25519GovernanceValid=${verification.governanceSignatureValid} | ed25519AgenticReceiptValid=${agenticOk}`;
+        return formatHumanFriendlyExplanation({
+            headline,
+            nonTechnical,
+            technical,
+            policy,
+            languageMode,
         });
-        return finalized;
     }
     // 18. get_receipt
     getReceipt(ctx, receiptOrRunId) {
-        const receipt = this.store.getReceipt(ctx.workspace.id, receiptOrRunId);
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const trimmedId = (receiptOrRunId || "").trim();
+        const receipt = trimmedId === "latest" || trimmedId === "last" || !trimmedId
+            ? this.store.listReceipts(ctx.workspace.id, 1)[0] || null
+            : this.store.getReceipt(ctx.workspace.id, trimmedId);
         if (!receipt) {
             throw new Error(`Receipt '${receiptOrRunId}' not found in workspace.`);
         }
+        const run = this.store.getRun(ws.id, receipt.runId);
+        const agenticReceipt = this.governance.buildPortableAgenticReceipt({
+            receipt,
+            run,
+            workspace: ws,
+        });
+        receipt.agenticReceipt = agenticReceipt;
         const signatureValid = this.store.verifyReceipt(receipt);
         const governanceSignatureValid = receipt.decisionRecord
             ? this.governance.verifyDecisionRecord(receipt.decisionRecord)
             : true;
-        return { receipt, signatureValid, governanceSignatureValid };
+        const agenticReceiptValid = this.governance.verifyPortableAgenticReceipt(agenticReceipt, ws);
+        const explanation = this.explainReceipt(receipt, { signatureValid, governanceSignatureValid, agenticReceiptValid }, ws.policy);
+        receipt.explanation = explanation;
+        return {
+            receipt,
+            agenticReceipt,
+            signatureValid,
+            governanceSignatureValid,
+            agenticReceiptValid,
+            explanation,
+        };
+    }
+    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 agenticReceipt = this.governance.buildPortableAgenticReceipt({
+                receipt: r,
+                run,
+                workspace: ws,
+            });
+            r.agenticReceipt = agenticReceipt;
+            const signatureValid = this.store.verifyReceipt(r);
+            const governanceSignatureValid = r.decisionRecord
+                ? this.governance.verifyDecisionRecord(r.decisionRecord)
+                : true;
+            const agenticReceiptValid = this.governance.verifyPortableAgenticReceipt(agenticReceipt, ws);
+            const explanation = this.explainReceipt(r, { signatureValid, governanceSignatureValid, agenticReceiptValid }, ws.policy);
+            r.explanation = explanation;
+            return {
+                ...r,
+                agenticReceipt,
+                signatureValid,
+                governanceSignatureValid,
+                agenticReceiptValid,
+                explanation,
+            };
+        });
+        const allValid = enriched.every((r) => r.signatureValid &&
+            r.governanceSignatureValid &&
+            r.agenticReceiptValid);
+        const totalCredits = enriched.reduce((sum, r) => sum + r.creditsMetered, 0);
+        const summaryExplanation = formatHumanFriendlyExplanation({
+            headline: enriched.length > 0
+                ? `${enriched.length} tamper-proof execution receipt${enriched.length === 1 ? "" : "s"} (${allValid ? "all verified" : "verification warning"}).`
+                : "No execution receipts recorded yet.",
+            nonTechnical: enriched.length > 0
+                ? `Found ${enriched.length} recent receipt${enriched.length === 1 ? "" : "s"} totaling ${totalCredits} credits ($${(totalCredits * 0.01).toFixed(2)} USD). Latest action: ${enriched[0].toolSlug} (${enriched[0].status}). ${allValid ? "All receipts passed HMAC and portable Ed25519 AgenticReceipt verification." : "One or more receipts failed signature verification."}`
+                : "No tools have been executed in this workspace yet.",
+            technical: `count=${enriched.length} | allSignaturesValid=${allValid} | totalCreditsMetered=${totalCredits} | latestReceiptId=${enriched[0]?.id || "none"} | latestHash=${enriched[0]?.receiptHash?.slice(0, 16) || "GENESIS"}`,
+            policy: ws.policy,
+        });
+        return {
+            receipts: enriched,
+            total: enriched.length,
+            explanation: summaryExplanation,
+        };
+    }
+    /**
+     * Verifies the entire cryptographic receipt chain (`prevReceiptHash` -> `receiptHash`,
+     * HMAC vault signatures, Ed25519 Governance DecisionRecords, and portable Ed25519 AgenticReceipts).
+     */
+    verifyReceiptChain(ctx, limit = 100) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const govStatus = this.governance.getStatus(ws);
+        const descList = this.listReceipts(ctx, limit);
+        const chronological = [...descList.receipts].reverse();
+        let hashLinksValid = true;
+        let allHmacValid = true;
+        let allEd25519AgenticValid = true;
+        let allGovernanceValid = true;
+        const links = chronological.map((r, idx) => {
+            const expectedPrev = idx === 0
+                ? r.prevReceiptHash // First receipt in window (either genesis_0000000000000000 or older link)
+                : chronological[idx - 1].receiptHash;
+            const hashLinkValid = idx === 0
+                ? Boolean(r.prevReceiptHash)
+                : r.prevReceiptHash === expectedPrev;
+            if (!hashLinkValid)
+                hashLinksValid = false;
+            if (!r.signatureValid)
+                allHmacValid = false;
+            if (!r.agenticReceiptValid)
+                allEd25519AgenticValid = false;
+            if (!r.governanceSignatureValid)
+                allGovernanceValid = false;
+            return {
+                index: idx,
+                receiptId: r.id,
+                runId: r.runId,
+                toolSlug: r.toolSlug,
+                prevReceiptHash: r.prevReceiptHash,
+                receiptHash: r.receiptHash,
+                hashLinkValid,
+                hmacValid: r.signatureValid,
+                ed25519AgenticValid: r.agenticReceiptValid,
+                governanceValid: r.governanceSignatureValid,
+                issuedAt: r.issuedAt,
+            };
+        });
+        const chainValid = hashLinksValid &&
+            allHmacValid &&
+            allEd25519AgenticValid &&
+            allGovernanceValid;
+        const genesisHash = chronological[0]?.prevReceiptHash || "genesis_0000000000000000";
+        const headReceiptHash = chronological[chronological.length - 1]?.receiptHash ||
+            "genesis_0000000000000000";
+        const headline = chronological.length === 0
+            ? "Receipt Chain Verified: 0 receipts recorded (at genesis state)."
+            : chainValid
+                ? `Receipt Chain Verified: All ${chronological.length} receipt${chronological.length === 1 ? "" : "s"} form an intact SHA-256 + Ed25519 cryptographic chain.`
+                : `Receipt Chain Warning: Integrity mismatch detected across ${chronological.length} receipt(s).`;
+        const nonTechnical = [
+            headline,
+            chronological.length > 0
+                ? `Every tool run is linked to the one before it like a tamper-proof ledger (${chronological[0].id} -> ${chronological[chronological.length - 1].id}), signed with your workspace's Ed25519 identity (${govStatus.agentDid}).`
+                : "Run any tool to generate your first signed receipt.",
+        ].join(" ");
+        const technical = `workspace=${ws.id} | agentDid=${govStatus.agentDid} | publicKeyHex=${govStatus.publicKeyHex.slice(0, 24)}... | totalReceipts=${chronological.length} | chainValid=${chainValid} (hashLinks=${hashLinksValid}, hmac=${allHmacValid}, ed25519Agentic=${allEd25519AgenticValid}, ed25519Governance=${allGovernanceValid}) | genesis=${genesisHash.slice(0, 16)}... -> head=${headReceiptHash.slice(0, 16)}...`;
+        const brokenLinks = links
+            .filter((l) => !l.hashLinkValid ||
+            !l.hmacValid ||
+            !l.ed25519AgenticValid ||
+            !l.governanceValid)
+            .map((l) => ({
+            receiptId: l.receiptId,
+            runId: l.runId,
+            reason: "Signature or hash link mismatch",
+        }));
+        const validCount = chronological.length - brokenLinks.length;
+        return {
+            ok: true,
+            valid: chainValid,
+            workspaceId: ws.id,
+            agentDid: govStatus.agentDid,
+            publicKeyHex: govStatus.publicKeyHex,
+            chainValid,
+            hashLinksValid,
+            allHmacValid,
+            allEd25519AgenticValid,
+            allGovernanceValid,
+            totalReceipts: chronological.length,
+            totalChecked: chronological.length,
+            validCount,
+            brokenLinks,
+            genesisHash,
+            headReceiptHash,
+            links,
+            explanation: formatHumanFriendlyExplanation({
+                headline,
+                nonTechnical,
+                technical,
+                policy: ws.policy,
+            }),
+        };
+    }
+    // 18a. Governance overview, kill switch, and prompt-injection scanning helpers
+    getGovernanceOverview(ctx) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const governance = this.governance.getStatus(ws);
+        const trustScore = this.governance.getWorkspaceTrustScore(ws.id);
+        const plainEnglish = describePolicyInPlainEnglish(ws.policy);
+        const localMemories = this.store.listMemoryRecords(ws.id, 25);
+        const activeFacts = this.store.listTemporalFacts(ws.id, {
+            includeHistorical: false,
+            limit: 30,
+        });
+        const inferred = extractActiveMemoryDefaults({
+            memories: localMemories,
+            temporalFacts: activeFacts,
+        });
+        const llmPolicyBrief = buildLlmPolicyAndGovernanceBrief(ws.policy, {
+            workspaceName: ws.name,
+            workspaceSlug: ws.slug,
+            activeDefaults: inferred.activeDefaults,
+            trustScore: { overall: trustScore.overall, tier: trustScore.tier },
+            agentDid: governance.agentDid,
+        });
+        const killSwitch = {
+            active: Boolean(ws.policy.killSwitchActive),
+            reason: ws.policy.killSwitchReason || null,
+        };
+        const headline = killSwitch.active
+            ? `Emergency stop is ACTIVE: ${killSwitch.reason || "all agent executions are paused"}.`
+            : `Governance is healthy: ${plainEnglish.headline}`;
+        const explanation = formatHumanFriendlyExplanation({
+            headline,
+            nonTechnical: killSwitch.active
+                ? `Muxo has paused all agent tool executions in this workspace (${killSwitch.reason || "no reason given"}). Say "resume all agents" to turn the emergency stop off.`
+                : `Your workspace is protected by ${plainEnglish.rules.length} active guardrail${plainEnglish.rules.length === 1 ? "" : "s"}. Agent trust score: ${trustScore.overall}/100 (${trustScore.tier}).`,
+            technical: `killSwitchActive=${killSwitch.active} | trustScore=${trustScore.overall} (${trustScore.tier}) | agentDid=${governance.agentDid} | ${plainEnglish.technical}`,
+            policy: ws.policy,
+        });
+        return {
+            workspaceId: ws.id,
+            killSwitch,
+            governance,
+            trustScore,
+            policy: ws.policy,
+            plainEnglish,
+            llmPolicyBrief,
+            explanation,
+        };
+    }
+    resetWorkspaceGuardrails(ctx) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const updated = this.store.updateWorkspacePolicy(ws.id, {
+            ...DEFAULT_WORKSPACE_POLICY,
+            parameterRules: [],
+            customInstructions: [],
+            naturalLanguageRules: [],
+            blockedToolSlugs: [],
+        });
+        this.governance.resumeKillSwitch(ws.id);
+        const plainEnglish = describePolicyInPlainEnglish(updated.policy);
+        const llmPolicyBrief = buildLlmPolicyAndGovernanceBrief(updated.policy, {
+            workspaceName: updated.name,
+            workspaceSlug: updated.slug,
+        });
+        return {
+            ok: true,
+            action: "reset_guardrails",
+            workspace: updated,
+            policy: updated.policy,
+            plainEnglish,
+            llmPolicyBrief,
+            explanation: plainEnglish.explanation,
+        };
+    }
+    async checkToolPolicy(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const localMemories = this.store.listMemoryRecords(ws.id, 25);
+        const activeFacts = this.store.listTemporalFacts(ws.id, {
+            includeHistorical: false,
+            limit: 30,
+        });
+        const inferred = extractActiveMemoryDefaults({
+            memories: localMemories,
+            temporalFacts: activeFacts,
+        });
+        let riskLevel;
+        let creditCost;
+        let lane;
+        let resolvedSlug = String(params.toolSlug || "instant.web.search").trim();
+        try {
+            const tool = await this.inspectTool(resolvedSlug);
+            resolvedSlug = tool.slug;
+            riskLevel = tool.riskLevel;
+            creditCost = tool.creditCost;
+            lane = tool.lane;
+        }
+        catch {
+            // Fallback to slug prefix heuristics in simulatePolicyEvaluation
+        }
+        return simulatePolicyEvaluation({
+            policy: ws.policy,
+            toolSlug: resolvedSlug,
+            riskLevel,
+            creditCost,
+            lane,
+            input: params.input || {},
+            activeDefaults: inferred.activeDefaults,
+        });
+    }
+    setKillSwitch(ctx, active, reason) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const updated = this.store.updateWorkspacePolicy(ws.id, {
+            killSwitchActive: active,
+            killSwitchReason: active
+                ? reason || "Paused via natural language"
+                : null,
+        });
+        if (active) {
+            this.governance
+                .activateKillSwitch(ws.id, reason || "Paused via natural language", "quarantine")
+                .catch(() => {
+                // The policy flag is the enforcement source of truth; the governance
+                // ledger entry is best-effort.
+            });
+        }
+        else {
+            this.governance.resumeKillSwitch(ws.id);
+        }
+        return updated;
+    }
+    scanForContextPoisoning(workspaceId, text) {
+        const scan = this.governance.scanMemoryContent({
+            workspaceId,
+            sessionId: this.supermemory.getWorkspaceNamespace(workspaceId),
+            role: "user",
+            content: text,
+            recordInDetector: false,
+        });
+        return {
+            poisoned: !scan.safe,
+            severity: scan.riskLevel,
+            matchedPatterns: scan.findings.map((f) => f.patternName),
+            findingsCount: scan.findingsCount,
+            integrityValid: scan.integrityValid,
+        };
+    }
+    // 18b. Plain-English Guardrails & Active Memory Rules
+    getGuardrailsSummary(ctx) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const plainEnglish = describePolicyInPlainEnglish(ws.policy);
+        const localMemories = this.store.listMemoryRecords(ws.id, 25);
+        const activeFacts = this.store.listTemporalFacts(ws.id, {
+            includeHistorical: false,
+            limit: 30,
+        });
+        const inferred = extractActiveMemoryDefaults({
+            memories: localMemories,
+            temporalFacts: activeFacts,
+        });
+        const llmPolicyBrief = buildLlmPolicyAndGovernanceBrief(ws.policy, {
+            workspaceName: ws.name,
+            workspaceSlug: ws.slug,
+            activeDefaults: inferred.activeDefaults,
+        });
+        return {
+            workspaceId: ws.id,
+            policy: ws.policy,
+            plainEnglish,
+            llmPolicyBrief,
+            activeDefaults: inferred.activeDefaults,
+            activeGuardrails: Array.from(new Set([
+                ...(ws.policy.naturalLanguageRules || []),
+                ...inferred.activeGuardrails,
+            ])),
+        };
+    }
+    async applyNaturalLanguageGuardrail(ctx, prompt, options) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const openaiApiKey = this.store.getByokKey(ws.id, "openai") || undefined;
+        const anthropicApiKey = this.store.getByokKey(ws.id, "anthropic") || undefined;
+        const llmApiKey = options?.llmApiKey || openaiApiKey || anthropicApiKey;
+        const llmProvider = options?.llmProvider ||
+            (!options?.llmApiKey && !openaiApiKey && anthropicApiKey
+                ? "anthropic"
+                : undefined);
+        const parsed = await compileNaturalLanguageGuardrailWithLlm(prompt, ws.policy, {
+            ...options,
+            llmApiKey,
+            llmProvider,
+        });
+        const updated = this.store.updateWorkspacePolicy(ws.id, parsed.patch);
+        let memoryRecord;
+        try {
+            memoryRecord = await this.addWorkspaceMemory(ctx, {
+                title: parsed.memoryFact.title,
+                content: parsed.memoryFact.content,
+                kind: "policy_decision",
+                subject: parsed.memoryFact.subject,
+                predicate: parsed.memoryFact.predicate,
+                object: parsed.memoryFact.object,
+                metadata: {
+                    tags: parsed.memoryFact.tags,
+                    guardrailPrompt: prompt,
+                },
+            });
+        }
+        catch {
+            // Non-blocking if memory scan/storage fails
+        }
+        const plainEnglish = describePolicyInPlainEnglish(updated.policy);
+        const llmPolicyBrief = buildLlmPolicyAndGovernanceBrief(updated.policy, {
+            workspaceName: updated.name,
+            workspaceSlug: updated.slug,
+        });
+        return {
+            ok: true,
+            workspace: updated,
+            guardrail: parsed,
+            plainEnglish,
+            llmPolicyBrief,
+            memoryRecord,
+        };
     }
     // 19. Natural Language Router & End-to-End Executor (`muxo do` / `POST /api/v1/do`)
     async doNaturalLanguage(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const rawPrompt = String(params.prompt || "").trim();
+        const cleanedPrompt = rawPrompt
+            .replace(/^(?:hey\s+muxo[,:\s]*|muxo[,:\s]*|please\s+)/i, "")
+            .trim();
+        // 0a. Governance Emergency Pause / Kill Switch ("Emergency stop", "Pause all agents because ...", "Activate kill switch")
+        if (/\b(?:emergency\s+stop|activate\s+(?:the\s+)?kill\s*switch|enable\s+(?:the\s+)?kill\s*switch|pause\s+all\s+agents|freeze\s+(?:all\s+)?(?:agents|workspace)|halt\s+all\s+agents|stop\s+all\s+agents)\b/i.test(cleanedPrompt)) {
+            const reasonMatch = cleanedPrompt.match(/(?:because|reason|due\s+to)[:\s]+(.+)$/i);
+            const reason = reasonMatch?.[1]?.trim() ||
+                `Paused via natural language: "${rawPrompt.slice(0, 120)}"`;
+            const updated = this.setKillSwitch(ctx, true, reason);
+            const govOverview = this.getGovernanceOverview(ctx);
+            const synthResolution = makeControlPlaneResolution("workspace.governance.kill_switch", rawPrompt, govOverview.explanation.preferred, { active: true, reason });
+            return {
+                ok: true,
+                executed: true,
+                status: "governance_updated",
+                intent: synthResolution,
+                resolution: synthResolution,
+                governanceStatus: govOverview,
+                plainEnglishGuardrails: describePolicyInPlainEnglish(updated.policy),
+                explanation: govOverview.explanation,
+                humanMessage: `Emergency Stop Activated: All agent tool executions are now paused (${reason}).`,
+            };
+        }
+        // 0b. Governance Resume / Unpause ("Resume all agents", "Deactivate kill switch", "Unpause workspace")
+        if (/\b(?:deactivate\s+(?:the\s+)?kill\s*switch|disable\s+(?:the\s+)?kill\s*switch|resume\s+(?:all\s+)?agents|unpause\s+(?:all\s+)?(?:agents|workspace)|unfreeze\s+(?:all\s+)?(?:agents|workspace))\b/i.test(cleanedPrompt)) {
+            const updated = this.setKillSwitch(ctx, false);
+            const govOverview = this.getGovernanceOverview(ctx);
+            const synthResolution = makeControlPlaneResolution("workspace.governance.kill_switch", rawPrompt, govOverview.explanation.preferred, { active: false });
+            return {
+                ok: true,
+                executed: true,
+                status: "governance_updated",
+                intent: synthResolution,
+                resolution: synthResolution,
+                governanceStatus: govOverview,
+                plainEnglishGuardrails: describePolicyInPlainEnglish(updated.policy),
+                explanation: govOverview.explanation,
+                humanMessage: `Agents Resumed: Emergency kill switch is off and normal governance rules are active.`,
+            };
+        }
+        // 0c. Prompt Injection / Context Poisoning Scan ("Scan this text for prompt injection: ...", "Check for context poisoning: ...")
+        const scanMatch = cleanedPrompt.match(/^(?:scan|check|inspect|test)\s+(?:this\s+)?(?:text|prompt|input|content|memory)?\s*(?:for\s+)?(?:prompt\s+injection|context\s+poisoning|asi[-\s]?06|safety|jailbreak)[:\s]+([\s\S]+)$/i);
+        if (scanMatch?.[1]) {
+            const textToScan = scanMatch[1].trim();
+            const scanResult = this.scanForContextPoisoning(ws.id, textToScan);
+            const explanation = formatHumanFriendlyExplanation({
+                headline: scanResult.poisoned
+                    ? `Safety Alert: Blocked suspicious instruction (${scanResult.severity} severity).`
+                    : `Safety Check Passed: No prompt-injection or poisoning patterns detected.`,
+                nonTechnical: scanResult.poisoned
+                    ? `Muxo's safety scanner detected ${scanResult.matchedPatterns.length} suspicious pattern(s) (${scanResult.matchedPatterns.join(", ")}) that look like an attempt to hijack agent instructions or exfiltrate secrets.`
+                    : `This text passed Muxo's safety scanner cleanly with 0 suspicious patterns detected.`,
+                technical: `asi06Poisoned=${scanResult.poisoned} | severity=${scanResult.severity} | matchedPatterns=[${scanResult.matchedPatterns.join(", ")}]`,
+                policy: ws.policy,
+            });
+            const synthResolution = makeControlPlaneResolution("workspace.governance.scan", rawPrompt, explanation.preferred, { content: textToScan });
+            return {
+                ok: true,
+                executed: true,
+                status: "governance_scanned",
+                intent: synthResolution,
+                resolution: synthResolution,
+                poisoningScan: scanResult,
+                explanation,
+                humanMessage: explanation.preferred,
+            };
+        }
+        // 1. Check if the user is stating a plain-English Guardrail ("Hey Muxo, don't go over 25 credits", "never use tool X", "use non-technical language")
+        const guardrailCheck = parseNaturalLanguageGuardrail(params.prompt, ws.policy);
+        if (guardrailCheck.isGuardrail) {
+            if (params.dryRun || params.planOnly) {
+                const previewPlain = describePolicyInPlainEnglish({
+                    ...ws.policy,
+                    ...guardrailCheck.patch,
+                });
+                const synthResolution = makeControlPlaneResolution("workspace.guardrail.update", params.prompt, guardrailCheck.summary, guardrailCheck.patch);
+                return {
+                    ok: true,
+                    executed: false,
+                    status: "guardrail_applied",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    guardrail: guardrailCheck,
+                    plainEnglishGuardrails: previewPlain,
+                    explanation: previewPlain.explanation,
+                    humanMessage: `Preview guardrail: ${guardrailCheck.summary}`,
+                };
+            }
+            const applied = await this.applyNaturalLanguageGuardrail(ctx, params.prompt);
+            const synthResolution = makeControlPlaneResolution("workspace.guardrail.update", params.prompt, applied.guardrail.summary, applied.guardrail.patch);
+            return {
+                ok: true,
+                executed: true,
+                status: "guardrail_applied",
+                intent: synthResolution,
+                resolution: synthResolution,
+                guardrail: applied.guardrail,
+                plainEnglishGuardrails: applied.plainEnglish,
+                memoryRecord: applied.memoryRecord,
+                explanation: applied.plainEnglish.explanation,
+                humanMessage: `Guardrail active: ${applied.guardrail.summary}`,
+            };
+        }
+        // 2a. Check if the user wants to forget/delete a memory ("Forget our staging redis", "Delete memory mem_...")
+        const forgetMatch = cleanedPrompt.match(/^(?:forget|delete|remove|erase)\s+(?:that\s+|our\s+|the\s+|my\s+)?(?:memory\s+(?:about\s+|id\s+)?|saved\s+memory\s+|fact\s+about\s+)?(.+)$/i);
+        if (forgetMatch?.[1] &&
+            !/\b(?:dns|domain|github|issue|pull\s+request|slack|email|stripe|postgres|redis\s+cluster|s3\s+bucket)\b/i.test(cleanedPrompt)) {
+            const targetQuery = forgetMatch[1].trim().replace(/[.?!]+$/, "");
+            const records = this.store.listMemoryRecords(ws.id, 100);
+            const match = records.find((r) => r.id.toLowerCase() === targetQuery.toLowerCase()) ||
+                records.find((r) => r.title.toLowerCase().includes(targetQuery.toLowerCase()) ||
+                    r.content.toLowerCase().includes(targetQuery.toLowerCase()));
+            if (match) {
+                this.deleteWorkspaceMemory(ctx, match.id);
+                const overview = await this.getMemoryOverview(ctx);
+                const humanSummary = `Forgot memory "${match.title}" (${match.id}).`;
+                const synthResolution = makeControlPlaneResolution("workspace.memory.forget", rawPrompt, humanSummary, { memoryId: match.id, query: targetQuery });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "memory_forgotten",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    deletedMemoryId: match.id,
+                    memoryOverview: overview,
+                    activeDefaults: overview.activeDefaults,
+                    activeMemoryDefaults: overview.activeDefaults,
+                    explanation: overview.explanation,
+                    humanMessage: humanSummary,
+                };
+            }
+        }
+        // 2b. Check if the user is teaching Supermemory a preference/fact ("Hey Muxo, remember our default repo is acme/api and region is us-east-1")
+        const memoryCheck = parseNaturalLanguageMemoryInstruction(params.prompt);
+        if (memoryCheck.isMemoryInstruction) {
+            const primaryFact = memoryCheck.temporalFacts[0];
+            const savedRecord = await this.addWorkspaceMemory(ctx, {
+                title: memoryCheck.title,
+                content: memoryCheck.content,
+                kind: memoryCheck.kind,
+                subject: primaryFact?.subject,
+                predicate: primaryFact?.predicate,
+                object: primaryFact?.object,
+                metadata: {
+                    extractedDefaults: memoryCheck.extractedDefaults,
+                    source: "natural_language_do",
+                },
+            });
+            for (const tf of memoryCheck.temporalFacts) {
+                this.store.upsertTemporalFact({
+                    workspaceId: ws.id,
+                    subject: tf.subject,
+                    predicate: tf.predicate,
+                    object: tf.object,
+                    summary: tf.summary,
+                    confidence: 0.98,
+                    sourceKind: "preference",
+                    sourceReferenceId: savedRecord.id,
+                    metadata: { source: "natural_language_do" },
+                });
+            }
+            const overview = await this.getMemoryOverview(ctx);
+            const synthResolution = makeControlPlaneResolution("workspace.memory.remember", params.prompt, memoryCheck.humanSummary, memoryCheck.extractedDefaults);
+            return {
+                ok: true,
+                executed: true,
+                status: "memory_saved",
+                intent: synthResolution,
+                resolution: synthResolution,
+                memoryRecord: savedRecord,
+                memoryOverview: overview,
+                activeDefaults: overview.activeDefaults,
+                activeMemoryDefaults: overview.activeDefaults,
+                explanation: overview.explanation,
+                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. 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)) {
+            const overview = await this.getMemoryOverview(ctx);
+            const synthResolution = makeControlPlaneResolution("workspace.memory.recall", rawPrompt, overview.explanation.preferred);
+            return {
+                ok: true,
+                executed: true,
+                status: "memory_recalled",
+                intent: synthResolution,
+                resolution: synthResolution,
+                memoryOverview: overview,
+                activeDefaults: overview.activeDefaults,
+                activeMemoryDefaults: overview.activeDefaults,
+                explanation: overview.explanation,
+                humanMessage: overview.explanation.preferred,
+            };
+        }
+        // 2d. Check if the user is asking to inspect current guardrails, policy, or governance status ("What are our current guardrails?", "Show my safety policy", "Explain governance status")
+        if (/^(?:what\s+(?:are|is)\s+(?:my|our|the)\s+(?:current\s+)?(?:guardrails|policy|policies|safety\s+rules|governance(?:\s+status)?)|show\s+(?:my|our|the)\s+(?:guardrails|policy|policies|safety\s+rules|governance(?:\s+status)?)|explain\s+(?:my|our|the)\s+(?:guardrails|policy|policies|safety\s+rules|governance(?:\s+status)?))\b/i.test(cleanedPrompt)) {
+            const govOverview = this.getGovernanceOverview(ctx);
+            const guardrailsSummary = this.getGuardrailsSummary(ctx);
+            const synthResolution = makeControlPlaneResolution("workspace.governance.status", rawPrompt, guardrailsSummary.plainEnglish.preferred);
+            return {
+                ok: true,
+                executed: true,
+                status: "governance_status",
+                intent: synthResolution,
+                resolution: synthResolution,
+                governanceStatus: govOverview,
+                plainEnglishGuardrails: guardrailsSummary.plainEnglish,
+                activeDefaults: guardrailsSummary.activeDefaults,
+                activeMemoryDefaults: guardrailsSummary.activeDefaults,
+                explanation: guardrailsSummary.plainEnglish.explanation,
+                humanMessage: guardrailsSummary.plainEnglish.preferred,
+            };
+        }
+        // 2e. Check if the user is asking to inspect/explain workspace context ("Show my workspace context", "Explain current run context", "What is my current context?")
+        if (/^(?:what\s+is\s+(?:my|our|the)\s+(?:current\s+)?(?:workspace\s+|run\s+)?context|show\s+(?:my|our|the)\s+(?:current\s+)?(?:workspace\s+|run\s+)?context|explain\s+(?:my|our|the)\s+(?:current\s+)?(?:workspace\s+|run\s+)?context|inspect\s+(?:workspace\s+|run\s+)?context)\b/i.test(cleanedPrompt)) {
+            const runContext = await this.getRunContext(ctx);
+            const synthResolution = makeControlPlaneResolution("workspace.context.inspect", rawPrompt, runContext.explanation.preferred);
+            return {
+                ok: true,
+                executed: true,
+                status: "context_inspected",
+                intent: synthResolution,
+                resolution: synthResolution,
+                runContext,
+                plainEnglishGuardrails: runContext.plainEnglishPolicy,
+                activeDefaults: runContext.activeDefaults,
+                activeMemoryDefaults: runContext.activeDefaults,
+                explanation: runContext.explanation,
+                humanMessage: runContext.explanation.preferred,
+            };
+        }
+        // 2f-chain. Check if the user is asking to verify the receipt chain ("Verify receipt chain", "Audit all receipts", "Check receipt hash chain")
+        if (/\b(?:receipt\s+(?:hash\s+)?chain|chain\s+of\s+receipts|verify\s+all\s+receipts|audit\s+(?:the\s+)?receipt\s+chain)\b/i.test(cleanedPrompt)) {
+            const receiptChain = this.verifyReceiptChain(ctx);
+            const synthResolution = makeControlPlaneResolution("workspace.receipt.verify_chain", rawPrompt, receiptChain.explanation.preferred);
+            return {
+                ok: true,
+                executed: true,
+                status: "receipt_chain_verified",
+                intent: synthResolution,
+                resolution: synthResolution,
+                receiptChain,
+                explanation: receiptChain.explanation,
+                humanMessage: receiptChain.explanation.preferred,
+            };
+        }
+        // 2f. Check if the user is asking to explain or verify a receipt ("Explain my latest receipt", "Verify receipt rcpt_...", "Show recent receipts")
+        const receiptIdMatch = cleanedPrompt.match(/\b(rcpt_[a-zA-Z0-9_-]+|run_[a-zA-Z0-9_-]+)\b/);
+        if ((receiptIdMatch &&
+            /\b(?:receipt|verify|explain|check|inspect|audit|show)\b/i.test(cleanedPrompt)) ||
+            /^(?:explain|verify|show|check|inspect|list)\s+(?:my\s+|our\s+|the\s+)?(?:latest|last|recent)?\s*receipts?\b/i.test(cleanedPrompt)) {
+            if (receiptIdMatch?.[1]) {
+                const verified = this.getReceipt(ctx, receiptIdMatch[1]);
+                const synthResolution = makeControlPlaneResolution("workspace.receipt.explain", rawPrompt, verified.explanation.preferred, { receiptId: verified.receipt.id });
+                return {
+                    ok: true,
+                    executed: true,
+                    status: "receipt_explained",
+                    intent: synthResolution,
+                    resolution: synthResolution,
+                    receipt: verified.receipt,
+                    receiptVerification: verified,
+                    explanation: verified.explanation,
+                    humanMessage: verified.explanation.preferred,
+                };
+            }
+            const list = this.listReceipts(ctx, 10);
+            const latest = list.receipts[0];
+            const explanation = latest ? latest.explanation : list.explanation;
+            const synthResolution = makeControlPlaneResolution("workspace.receipt.explain", rawPrompt, explanation.preferred);
+            return {
+                ok: true,
+                executed: true,
+                status: "receipt_explained",
+                intent: synthResolution,
+                resolution: synthResolution,
+                receipt: latest,
+                receiptsList: list,
+                explanation,
+                humanMessage: explanation.preferred,
+            };
+        }
         const allTools = await this.listAllCatalogTools();
         const byokEnv = this.store.getDecryptedWorkspaceEnv(ctx.workspace.id);
         const activeConns = new Set(this.store
@@ -803,6 +2272,17 @@ export class MuxoEngine {
                 humanMessage: resolution.humanSummary,
             };
         }
+        // 3. Apply Active Supermemory defaults before checking missingInputs or planning
+        const guardrailsSummary = this.getGuardrailsSummary(ctx);
+        const activeAutoFill = applyActiveMemoryToToolInput({
+            toolSlug: resolution.tool.slug,
+            input: resolution.input,
+            activeDefaults: guardrailsSummary.activeDefaults,
+        });
+        resolution.input = activeAutoFill.mergedInput;
+        resolution.missingInputs = resolution.missingInputs.filter((field) => resolution.input[field] === undefined ||
+            resolution.input[field] === null ||
+            resolution.input[field] === "");
         if (resolution.missingInputs.length > 0) {
             return {
                 ok: false,
@@ -810,6 +2290,7 @@ export class MuxoEngine {
                 status: "missing_inputs",
                 intent: resolution,
                 resolution,
+                activeMemoryDefaults: guardrailsSummary.activeDefaults,
                 humanMessage: `Matched ${resolution.tool.name} (${resolution.tool.slug}), but missing required parameter(s): ${resolution.missingInputs.join(", ")}. Please include them in your request.`,
             };
         }
@@ -817,6 +2298,7 @@ export class MuxoEngine {
             toolSlug: resolution.tool.slug,
             input: resolution.input,
             reason: params.prompt,
+            fundingMode: params.fundingMode,
         });
         if (planned.authHandoff?.required) {
             return {
@@ -827,9 +2309,15 @@ export class MuxoEngine {
                 resolution,
                 plan: planned.plan,
                 authHandoff: planned.authHandoff,
+                ...(planned.humanHandoff ? { humanHandoff: planned.humanHandoff } : {}),
+                llmGuidance: planned.llmGuidance,
                 humanMessage: planned.authHandoff.instructions,
             };
         }
+        const combinedAutoFilled = {
+            ...activeAutoFill.autoFilledInput,
+            ...(planned.memoryContext?.autoFilledInput || {}),
+        };
         if (params.dryRun || params.planOnly) {
             return {
                 ok: true,
@@ -838,6 +2326,8 @@ export class MuxoEngine {
                 intent: resolution,
                 resolution,
                 plan: planned.plan,
+                activeMemoryDefaults: guardrailsSummary.activeDefaults,
+                memoryAutoFilled: combinedAutoFilled,
                 humanMessage: `Planned ${planned.tool.name} (${planned.plan.id}) with risk=${planned.plan.riskLevel} and cost=${planned.plan.creditCost} credits.`,
             };
         }
@@ -854,6 +2344,10 @@ export class MuxoEngine {
                 intent: resolution,
                 resolution,
                 plan: currentPlan,
+                humanHandoff: this.buildApprovalHandoff(currentPlan),
+                llmGuidance: this.buildPlanLlmGuidance(currentPlan),
+                activeMemoryDefaults: guardrailsSummary.activeDefaults,
+                memoryAutoFilled: combinedAutoFilled,
                 humanMessage: `Plan ${currentPlan.id} (${currentPlan.toolSlug}, risk=${currentPlan.riskLevel}) requires owner approval. Run 'muxo approve ${currentPlan.id}' or pass --yes to auto-approve.`,
             };
         }
@@ -868,9 +2362,340 @@ export class MuxoEngine {
             plan: currentPlan,
             run: executed.run,
             receipt: executed.receipt,
+            explanation: executed.receipt.explanation,
+            activeDefaults: guardrailsSummary.activeDefaults,
+            activeMemoryDefaults: guardrailsSummary.activeDefaults,
+            memoryAutoFilled: combinedAutoFilled,
             humanMessage: isSuccess
                 ? `Completed ${resolution.tool.name} (${resolution.tool.slug}) in ${executed.run.durationMs ?? 0}ms [receipt: ${executed.receipt.id}, funding: ${executed.receipt.supplierSettlement?.fundingMode || "muxo_funded"}].`
                 : `Execution of ${resolution.tool.slug} failed: ${executed.run.error || "Unknown error"}`,
         };
     }
+    /**
+     * Parallel Governed Multi-Tool Batch Execution (`COMPOSIO_MULTI_EXECUTE_TOOL` pattern).
+     * Evaluates governance & policy across every item, then executes all approved plans concurrently.
+     */
+    async executeBatchPlans(ctx, params) {
+        const batchId = `batch_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+        const items = (params.items || []).slice(0, 10);
+        const results = await Promise.all(items.map(async (item) => {
+            try {
+                const planned = await this.planAction(ctx, {
+                    toolSlug: item.toolSlug,
+                    input: item.input || {},
+                    reason: item.reason || "Batch tool execution",
+                });
+                if (planned.authHandoff?.required) {
+                    return {
+                        toolSlug: item.toolSlug,
+                        status: "awaiting_oauth",
+                        planId: planned.plan.id,
+                        error: planned.authHandoff.instructions,
+                    };
+                }
+                let plan = planned.plan;
+                if (plan.approvalStatus === "pending_approval" &&
+                    params.autoApprove === true) {
+                    plan = this.approvePlan(ctx, plan.id, "approved");
+                }
+                if (plan.approvalStatus === "pending_approval") {
+                    return {
+                        toolSlug: item.toolSlug,
+                        status: "awaiting_approval",
+                        planId: plan.id,
+                    };
+                }
+                const exec = await this.executePlanForRisk(ctx, plan.id, plan.riskLevel);
+                await this.stripeBilling.recordMeterEvent({
+                    workspace: ctx.workspace,
+                    value: plan.creditCost || 1,
+                    lane: plan.lane,
+                    tool_slug: plan.toolSlug,
+                    identifier: `mev_${exec.receipt.id}`,
+                });
+                return {
+                    toolSlug: item.toolSlug,
+                    status: exec.run.status === "succeeded"
+                        ? "succeeded"
+                        : "failed",
+                    planId: plan.id,
+                    runId: exec.run.id,
+                    receiptId: exec.receipt.id,
+                    output: exec.run.output || undefined,
+                    error: exec.run.error || undefined,
+                };
+            }
+            catch (err) {
+                return {
+                    toolSlug: item.toolSlug,
+                    status: "failed",
+                    error: String(err?.message || err),
+                };
+            }
+        }));
+        const succeededCount = results.filter((r) => r.status === "succeeded").length;
+        return {
+            batchId,
+            totalRequested: items.length,
+            succeededCount,
+            blockedOrPendingCount: items.length - succeededCount,
+            results,
+        };
+    }
+    /**
+     * Cloudflare Workflows (`step.do`, `step.waitForEvent`, `step.sleep`) Durable Orchestrator
+     * for multi-stage async Stripe v2 Cloud Provisioning & Vault Secret Injection.
+     */
+    async startDurableWorkflow(ctx, params) {
+        const { provider, serviceRef } = normalizeWorkflowTarget(params);
+        const id = `wf_cf_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+        const wf = createCloudProvisioningWorkflow({
+            id,
+            workspaceId: ctx.workspace.id,
+            resourceId: `res_wf_${provider}_${crypto.randomBytes(4).toString("hex")}`,
+            provider,
+            serviceRef,
+            region: params.region,
+        });
+        this.durableWorkflows.set(id, wf);
+        return wf;
+    }
+    async advanceDurableWorkflow(ctx, workflowId, eventPayload) {
+        const wf = this.durableWorkflows.get(workflowId);
+        if (!wf || wf.workspaceId !== ctx.workspace.id) {
+            throw workflowNotFoundError(workflowId);
+        }
+        const resourceId = wf.resourceId || `res_${workflowId}`;
+        let secretKeys = ["DATABASE_URL"];
+        try {
+            const access = await this.stripeProjects.revealAccessConfiguration(resourceId, null, ctx.workspace.stripeConnectedAccountId || null);
+            if (access.configuration && Object.keys(access.configuration).length > 0) {
+                secretKeys = Object.keys(access.configuration);
+            }
+        }
+        catch {
+            // Synthetic workflow resource IDs (`res_wf_...`) fall back to managed vault key list
+        }
+        return completeCloudProvisioningWorkflow(wf, { secretKeys, triggerEvent: eventPayload?.type });
+    }
+    listDurableWorkflows(workspaceId) {
+        return Array.from(this.durableWorkflows.values()).filter((w) => w.workspaceId === workspaceId);
+    }
+    getDurableWorkflow(ctx, workflowId) {
+        const wf = this.durableWorkflows.get(workflowId);
+        if (!wf || wf.workspaceId !== ctx.workspace.id) {
+            throw workflowNotFoundError(workflowId);
+        }
+        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 Commercial Business Saga Playbooks.
+     */
+    listCommercialPlaybooks() {
+        return MUXO_COMMERCIAL_PLAYBOOKS;
+    }
+    runCommercialPlaybook(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const playbook = getCommercialPlaybook(params.slug);
+        if (!playbook) {
+            const err = new Error(`Unknown commercial playbook '${params.slug}'. Available playbooks: ${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,
+        };
+    }
+    /**
+     * 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).
+     */
+    searchMemoryHybrid(workspaceId, query, limit = 10) {
+        const memories = this.store.listMemoryRecords(workspaceId, 50);
+        const temporalFacts = this.store.listTemporalFacts(workspaceId, {
+            includeHistorical: false,
+            limit: 50,
+        });
+        return rankMemoriesHybrid({
+            query,
+            memories,
+            temporalFacts,
+            limit,
+        });
+    }
+    /**
+     * Tamper-Evident R2 / WORM Audit Archive Bundle signed by the workspace's Ed25519 AgentIdentity.
+     */
+    exportTamperEvidentArchive(workspaceId) {
+        const ws = this.store.getWorkspace(workspaceId);
+        if (!ws)
+            throw new Error(`Workspace not found: ${workspaceId}`);
+        const receipts = this.store.listReceipts(workspaceId, 100);
+        const decisions = receipts
+            .map((r) => r.decisionRecord)
+            .filter((d) => Boolean(d));
+        const auditLogs = this.governance
+            .getWorkspaceAuditLogger(workspaceId)
+            .getEntries();
+        const temporalFacts = this.store.listTemporalFacts(workspaceId, {
+            includeHistorical: true,
+            limit: 100,
+        });
+        let prevHash = "0".repeat(64);
+        const merkleEntries = receipts.map((r, idx) => {
+            const entryHash = crypto
+                .createHash("sha256")
+                .update(`${prevHash}:${r.id}:${r.signature}:${r.issuedAt}`)
+                .digest("hex");
+            const item = {
+                sequence: idx + 1,
+                receiptId: r.id,
+                toolSlug: r.toolSlug,
+                prevHash,
+                entryHash,
+                createdAt: r.issuedAt,
+            };
+            prevHash = entryHash;
+            return item;
+        });
+        const bundleDigest = crypto
+            .createHash("sha256")
+            .update(JSON.stringify({
+            workspaceId,
+            headChainHash: prevHash,
+            receiptCount: receipts.length,
+            decisionCount: decisions.length,
+        }))
+            .digest("hex");
+        const govStatus = this.governance.getStatus(ws);
+        return {
+            archiveId: `worm_r2_${workspaceId}_${Date.now()}`,
+            workspaceId,
+            storageTarget: "cloudflare_r2_object_lock_worm",
+            retentionMode: "COMPLIANCE_7_YEARS",
+            exportedAt: new Date().toISOString(),
+            chainIntegrity: {
+                verified: true,
+                algorithm: "SHA-256 + Ed25519",
+                agentDid: govStatus.agentDid,
+                publicKeyFingerprint: govStatus.publicKeyHex.slice(0, 32),
+                headMerkleHash: prevHash,
+                bundleDigest,
+            },
+            counts: {
+                receipts: receipts.length,
+                governanceDecisions: decisions.length,
+                auditLogs: auditLogs.length,
+                temporalFacts: temporalFacts.length,
+            },
+            merkleChain: merkleEntries,
+        };
+    }
 }