@muxoai/sdk 1.2.3 → 1.4.2

package/dist/engine.js

@@ -0,0 +1,2560 @@
+import crypto from "node:crypto";
+import { isStripeProjectsExclusiveProvider, normalizeStripeProjectsProviderSlug, wrapMuxoConnectUrl, } from "./composio-catalog.js";
+import { APPROVED_PLAN_STATUSES, approvalRequiredError, buildApprovalHumanHandoff, buildApprovalUrl, buildOAuthHumanHandoff, clampWaitSeconds, looksLikeToolSlug, unknownToolError, } from "./mcp-schema.js";
+import { completeCloudProvisioningWorkflow, createCloudProvisioningWorkflow, normalizeWorkflowTarget, workflowNotFoundError, } from "./durable-workflow.js";
+import { buildMemoryKnowledgeGraph } from "./memory-graph.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, 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;
+    composioSdk;
+    composioInstant;
+    stripeProjects;
+    stripeBilling;
+    governance;
+    supermemory;
+    durableWorkflows = new Map();
+    constructor(config, store) {
+        this.config = config;
+        this.store = store;
+        this.composioSdk = new ComposioSdkAdapter(config);
+        this.composioInstant = new ComposioInstantAdapter(config);
+        this.stripeProjects = new StripeProjectsAdapter(config);
+        this.stripeBilling = new StripeBillingAdapter(config, store);
+        this.governance = new MicrosoftGovernanceAdapter(config.vaultMasterKey);
+        this.supermemory = new SupermemoryAdapter(config);
+    }
+    // 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,
+            workspaceId: ctx.workspace.id,
+            workspaceName: ctx.workspace.name,
+            tier: ctx.workspace.tier,
+        };
+    }
+    // 2. get_organization
+    getOrganization(ctx) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        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,
+                name: ws.name,
+                slug: ws.slug,
+                tier: ws.tier,
+                usage: {
+                    monthlyActionsUsed: ws.monthlyActionsUsed,
+                    monthlyActionsLimit: ws.monthlyActionsLimit,
+                    monthlyActionsRemaining: Math.max(0, ws.monthlyActionsLimit - ws.monthlyActionsUsed),
+                    creditsBalance: ws.creditsBalance,
+                },
+                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
+    async searchTools(params) {
+        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));
+        }
+        if (lane === "all" || lane === "composio_sdk") {
+            const sdkTools = await this.composioSdk.searchTools(query, limit);
+            results.push(...sdkTools);
+        }
+        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;
+                const q = query.toLowerCase();
+                const hay = `${t.slug} ${t.name} ${t.description} ${t.categories.join(" ")}`.toLowerCase();
+                return q.split(/\s+/).some((tok) => hay.includes(tok));
+            });
+            results.push(...billingTools);
+        }
+        const filtered = params.riskLevel
+            ? results.filter((t) => t.riskLevel === params.riskLevel)
+            : results;
+        return {
+            tools: filtered.slice(0, limit),
+            total: filtered.length,
+        };
+    }
+    async listAllCatalogTools() {
+        const instant = this.composioInstant.searchTools(undefined, 100);
+        const sdk = await this.composioSdk.searchTools(undefined, 100);
+        const proj = this.stripeProjects.getTools();
+        const billing = this.stripeBilling.listTools();
+        return [...instant, ...billing, ...sdk, ...proj];
+    }
+    // 4. inspect_tool
+    async inspectTool(slug) {
+        const normalized = slug.trim();
+        const billing = this.stripeBilling
+            .listTools()
+            .find((t) => t.slug.toLowerCase() === normalized.toLowerCase() ||
+            t.upstreamSlug.toLowerCase() === normalized.toLowerCase());
+        if (billing)
+            return billing;
+        const instant = this.composioInstant.inspectTool(normalized);
+        if (instant)
+            return instant;
+        const proj = this.stripeProjects.inspectTool(normalized);
+        if (proj)
+            return proj;
+        const sdk = await this.composioSdk.inspectTool(normalized);
+        if (sdk)
+            return sdk;
+        throw unknownToolError(normalized);
+    }
+    // 5. connection_status
+    async connectionStatus(ctx, params) {
+        if (params?.syncLive !== false) {
+            // Sync live Composio connected accounts for this workspace
+            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",
+                    providerSlug: c.providerSlug,
+                    providerName: c.providerName,
+                    status: c.status,
+                    externalAccountId: c.externalAccountId,
+                });
+            }
+            // Sync live Stripe Projects linked providers
+            try {
+                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,
+                        lane: "stripe_projects",
+                        providerSlug: p.slug,
+                        providerName: p.name,
+                        status: p.status,
+                        externalAccountId: p.id,
+                        redirectUrl: p.redirectUrl,
+                    });
+                }
+            }
+            catch {
+                // Keep cached connections if CLI is busy
+            }
+        }
+        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 = 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,
+                active: connections.filter((c) => c.status === "active").length,
+                pending: connections.filter((c) => c.status === "pending").length,
+                expired: connections.filter((c) => c.status === "expired").length,
+            },
+        };
+    }
+    getHostedSiteHtml(slug, filePath) {
+        return this.stripeProjects.getHostedSiteHtml(slug, filePath);
+    }
+    // 6. start_connection
+    async startConnection(ctx, params) {
+        const rawProvider = params.provider.trim().toLowerCase();
+        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 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 === "requires_review" ? "pending" : linked.status,
+                externalAccountId: linked.connectionRequestId || null,
+                redirectUrl: linked.redirectUrl,
+            });
+            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,
+            lane: "composio_sdk",
+            providerSlug: started.providerSlug,
+            providerName: started.providerName,
+            status: started.status,
+            externalAccountId: started.externalAccountId,
+            redirectUrl: started.redirectUrl,
+            metadata: { callbackUrl: started.callbackUrl },
+        });
+        return {
+            ...record,
+            callbackUrl: started.callbackUrl,
+            message: started.message,
+        };
+    }
+    // 6b. wait_for_connection (OAuth handoff polling & recovery, like COMPOSIO_WAIT_FOR_CONNECTIONS)
+    async waitForConnection(ctx, params) {
+        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 = 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);
+        if (!current || (!current.redirectUrl && current.status !== "active")) {
+            try {
+                current = await this.startConnection(ctx, { provider: cleanSlug });
+            }
+            catch {
+                // Proceed with status check
+            }
+        }
+        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 connectedResult(latestLocal, `${latestLocal.providerName} OAuth handoff completed and connection is active.`);
+                }
+            }
+            if (current?.externalAccountId && current.lane === "composio_sdk") {
+                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,
+                        lane: "composio_sdk",
+                        providerSlug: cleanSlug,
+                        providerName: cleanSlug.charAt(0).toUpperCase() + cleanSlug.slice(1),
+                        status: "active",
+                        externalAccountId: direct.id,
+                        redirectUrl: null,
+                    });
+                    return connectedResult(current, `${current.providerName} OAuth handoff completed and connection is active.`);
+                }
+            }
+            const synced = await this.connectionStatus(ctx, {
+                provider: cleanSlug,
+                syncLive: true,
+            });
+            const list = synced.connections || [];
+            const found = list.find((c) => c.providerSlug.toLowerCase() === cleanSlug);
+            if (found) {
+                current = found;
+                if (found.status === "active") {
+                    return connectedResult(found, `${found.providerName} connection is active and ready for governed execution.`);
+                }
+            }
+            if (Date.now() >= deadline) {
+                break;
+            }
+            await new Promise((r) => setTimeout(r, pollIntervalMs));
+        }
+        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}.`,
+        };
+    }
+    // 6c. Browser OAuth callback handoff handler (GET /oauth/callback)
+    async handleOAuthCallback(params) {
+        const cleanSlug = params.provider
+            .trim()
+            .toLowerCase()
+            .replace(/^(app\.|resource\.)/, "");
+        const providerName = cleanSlug.charAt(0).toUpperCase() + cleanSlug.slice(1);
+        const ws = this.store.getWorkspace(params.workspaceId);
+        if (!ws) {
+            throw new Error(`Workspace '${params.workspaceId}' not found`);
+        }
+        const existing = this.store
+            .listConnections(ws.id)
+            .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, composioByok);
+            if (live) {
+                resolvedStatus = live.status;
+            }
+        }
+        if (resolvedStatus !== "active") {
+            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 === "failed" ||
+            rawCallbackStatus === "error" ||
+            rawCallbackStatus === "expired" ||
+            rawCallbackStatus === "cancelled" ||
+            rawCallbackStatus === "denied") {
+            resolvedStatus = "expired";
+        }
+        else if (rawCallbackStatus === "success" ||
+            rawCallbackStatus === "active" ||
+            rawCallbackStatus === "connected") {
+            resolvedStatus = "active";
+        }
+        const updated = this.store.upsertConnection({
+            workspaceId: ws.id,
+            lane: "composio_sdk",
+            providerSlug: cleanSlug,
+            providerName,
+            status: resolvedStatus,
+            externalAccountId: accountId,
+            redirectUrl: resolvedStatus === "active" ? null : existing?.redirectUrl,
+        });
+        return {
+            ok: true,
+            workspaceId: ws.id,
+            providerSlug: cleanSlug,
+            providerName,
+            status: updated.status,
+            externalAccountId: updated.externalAccountId,
+        };
+    }
+    // 7. plan_action
+    async planAction(ctx, params) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        let tool;
+        let resolvedInput = { ...(params.input || {}) };
+        let resolvedReason = params.reason || `Planned execution of ${params.toolSlug}`;
+        try {
+            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();
+            const byokEnv = this.store.getDecryptedWorkspaceEnv(ws.id);
+            const nl = await resolveNaturalLanguageIntent({
+                prompt: nlSource,
+                tools: allTools,
+                explicitInput: resolvedInput,
+                byokKeys: byokEnv,
+            });
+            if (!nl.resolved || !nl.tool) {
+                throw inspectErr;
+            }
+            tool = nl.tool;
+            resolvedInput = nl.input;
+            resolvedReason = params.reason || nl.reason || nlSource;
+        }
+        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.`);
+        }
+        if (effectiveCreditCost > ws.creditsBalance) {
+            throw new Error(`Insufficient workspace credits for ${tool.slug} (requires ${effectiveCreditCost}, available ${ws.creditsBalance}). Top up credits or configure a BYOK key.`);
+        }
+        if (effectiveCreditCost > ws.policy.maxCreditsPerRun) {
+            throw new Error(`Tool credit cost (${effectiveCreditCost}) exceeds workspace policy maxCreditsPerRun (${ws.policy.maxCreditsPerRun}).`);
+        }
+        // 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,
+            actorId: ctx.actorId,
+            tool,
+            input: resolvedInput,
+            reason: resolvedReason,
+        });
+        if (decisionRecord.verdict === "deny") {
+            throw new Error(`Microsoft Agent Governance denied plan for ${tool.slug} (rule: ${decisionRecord.matchedRule}): ${decisionRecord.reason}`);
+        }
+        const requiresHumanApproval = decisionRecord.verdict === "escalate";
+        const approvalStatus = requiresHumanApproval
+            ? "pending_approval"
+            : "auto_approved";
+        const plan = this.store.createPlan({
+            workspaceId: ws.id,
+            actorId: ctx.actorId,
+            toolSlug: tool.slug,
+            upstreamSlug: tool.upstreamSlug,
+            lane: tool.lane,
+            riskLevel: tool.riskLevel,
+            input: resolvedInput,
+            reason: resolvedReason,
+            creditCost: effectiveCreditCost,
+            approvalStatus,
+            decisionRecord,
+            memoryContext,
+        });
+        // 3. Check external user OAuth connection state for Connected Apps (composio_sdk)
+        let authHandoff;
+        if (tool.lane === "composio_sdk" && tool.requiresAuth) {
+            let existingConn = this.store
+                .listConnections(ws.id)
+                .find((c) => c.lane === "composio_sdk" &&
+                c.providerSlug.toLowerCase() === tool.providerSlug.toLowerCase());
+            if (!existingConn || existingConn.status !== "active") {
+                try {
+                    if (!existingConn || !existingConn.redirectUrl) {
+                        existingConn = await this.startConnection(ctx, {
+                            provider: tool.providerSlug,
+                        });
+                    }
+                }
+                catch {
+                    // 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: wrappedRedirectUrl,
+                        externalAccountId: existingConn?.externalAccountId || null,
+                        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}.`,
+                    };
+                }
+            }
+        }
+        const executeToolName = `execute_${tool.riskLevel}`;
+        let nextStep = approvalStatus === "pending_approval"
+            ? `Plan ${plan.id} requires human owner approval in the Muxo Console or via approve_plan before calling ${executeToolName}.`
+            : `Plan ${plan.id} is auto-approved. Call ${executeToolName}({ plan_id: "${plan.id}" }) to execute.`;
+        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,
+        };
+    }
+    // 8. get_plan
+    getPlan(ctx, planId) {
+        const plan = this.store.getPlan(ctx.workspace.id, planId);
+        if (!plan)
+            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);
+        if (plan.approvalStatus === "executed") {
+            throw new Error(`Plan '${planId}' has already been executed.`);
+        }
+        return this.store.updatePlanApproval({
+            workspaceId: ctx.workspace.id,
+            planId,
+            approvalStatus: decision,
+            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 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: actionsRemaining,
+            provisionedResources: activeResources,
+            environmentVariablesRedacted: redactedEnv,
+            supermemoryBrain: memoryContext,
+            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 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: ws.id,
+            title: params.title,
+            content: params.content,
+            kind,
+            metadata: params.metadata,
+            apiKeyOverride: supermemoryByok,
+            dreaming: "instant",
+        });
+        const record = this.store.saveMemoryRecord({
+            workspaceId: ws.id,
+            namespace: remote.namespace,
+            documentId: remote.documentId,
+            title: params.title,
+            content: remote.sanitizedContent,
+            kind,
+            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 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, and human + technical explanations) directly from SQLite temporal_facts, memories, resources, and connections.
+     */
+    async getMemoryGraph(ctx, query) {
+        const ws = this.store.getWorkspace(ctx.workspace.id);
+        const overview = await this.getMemoryOverview(ctx, query);
+        return buildMemoryKnowledgeGraph({
+            workspace: ws,
+            namespace: overview.namespace,
+            query,
+            facts: this.store.listTemporalFacts(ws.id, {
+                includeHistorical: true,
+                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);
+        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) {
+            const existingRun = this.store.getRun(ctx.workspace.id, plan.runId);
+            const existingReceipt = this.store.getReceipt(ctx.workspace.id, plan.runId);
+            if (existingRun && existingReceipt) {
+                return { run: existingRun, receipt: existingReceipt };
+            }
+            throw new Error(`Plan '${plan.id}' was already claimed by run '${plan.runId}' (execute-once invariant).`);
+        }
+        if (plan.approvalStatus === "pending_approval") {
+            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,
+            plan,
+            tool,
+        });
+        if (execDecisionRecord.verdict === "deny") {
+            throw new Error(`Microsoft Agent Governance denied execution of plan '${plan.id}': ${execDecisionRecord.reason}`);
+        }
+        let activeConnId = null;
+        if (plan.lane === "composio_sdk" && tool.requiresAuth) {
+            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");
+            if (!activeConn) {
+                await this.waitForConnection(ctx, {
+                    provider: tool.providerSlug,
+                    timeoutSeconds: 0,
+                }).catch(() => { });
+                connections = this.store.listConnections(ctx.workspace.id);
+                activeConn = connections.find((c) => c.lane === "composio_sdk" &&
+                    c.providerSlug === tool.providerSlug &&
+                    c.status === "active");
+            }
+            if (!activeConn) {
+                throw new Error(`No active OAuth connection for ${tool.providerSlug}. Complete OAuth handoff and call wait_for_connection({ provider: "${tool.providerSlug}" }) before executing plan '${plan.id}'.`);
+            }
+            activeConnId = activeConn.externalAccountId;
+        }
+        const run = this.store.createRun(plan, ctx.actorId);
+        const startedMs = Date.now();
+        try {
+            let output;
+            if (plan.toolSlug.startsWith("billing.")) {
+                output = await this.stripeBilling.executeTool({
+                    workspace: ws,
+                    customerEmail: ctx.user.email,
+                    toolSlug: plan.toolSlug,
+                    input: plan.input,
+                });
+            }
+            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: enrichedInput,
+                    stripeApiKey: stripeByok,
+                });
+                output = projResult.output;
+                if (projResult.provisionedResource) {
+                    this.store.upsertResource({
+                        workspaceId: ctx.workspace.id,
+                        ...projResult.provisionedResource,
+                    });
+                }
+            }
+            else {
+                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: 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,
+                    toolSlug: plan.toolSlug,
+                    lane: plan.lane,
+                    riskLevel: plan.riskLevel,
+                    reason: plan.reason,
+                    status: "succeeded",
+                    summary,
+                    apiKeyOverride: supermemoryByok,
+                })
+                    .then((docId) => {
+                    if (docId) {
+                        this.store.saveMemoryRecord({
+                            workspaceId: ctx.workspace.id,
+                            namespace: this.supermemory.getWorkspaceNamespace(ctx.workspace.id),
+                            documentId: docId,
+                            title: `Execution: ${plan.toolSlug} (succeeded)`,
+                            content: this.supermemory.sanitizeContent(summary),
+                            kind: "execution_outcome",
+                            metadata: {
+                                runId: finalized.run.id,
+                                receiptId: finalized.receipt.id,
+                                toolSlug: plan.toolSlug,
+                            },
+                        });
+                    }
+                })
+                    .catch(() => { });
+            }
+            return finalized;
+        }
+        catch (err) {
+            const durationMs = Date.now() - startedMs;
+            this.governance.recordAgentOutcome(ctx.workspace.id, false, 0.08);
+            const errorMessage = String(err?.message || err || "Execution failed");
+            const failedFinalized = this.store.finalizeRun({
+                workspaceId: ctx.workspace.id,
+                runId: run.id,
+                status: "failed",
+                output: { error: errorMessage },
+                error: errorMessage,
+                actionsMetered: 1,
+                creditsMetered: 0,
+                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
+    getRun(ctx, runId) {
+        const run = this.store.getRun(ctx.workspace.id, runId);
+        if (!run)
+            throw new Error(`Run '${runId}' not found in workspace.`);
+        return run;
+    }
+    // 17. cancel_run
+    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 previousStatus = run.status;
+        const cancelled = this.store.cancelRun({
+            workspaceId: ctx.workspace.id,
+            runId: run.id,
+            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,
+        });
+    }
+    // 18. get_receipt
+    getReceipt(ctx, 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;
+        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
+            .listConnections(ctx.workspace.id)
+            .filter((c) => c.status === "active")
+            .map((c) => c.providerSlug.toLowerCase()));
+        const resolution = await resolveNaturalLanguageIntent({
+            prompt: params.prompt,
+            tools: allTools,
+            explicitInput: params.input,
+            byokKeys: byokEnv,
+            activeConnectionProviders: activeConns,
+        });
+        if (!resolution.resolved || !resolution.tool) {
+            return {
+                ok: false,
+                executed: false,
+                status: "unresolved",
+                intent: resolution,
+                resolution,
+                byokPrompt: {
+                    needed: !byokEnv.OPENAI_API_KEY && !byokEnv.ANTHROPIC_API_KEY && !byokEnv.OPENROUTER_API_KEY,
+                    provider: "openai",
+                    envVarName: "OPENAI_API_KEY",
+                    cliCommand: "muxo byok set openai <sk-...>",
+                    message: "Tip: Add an OpenAI, Anthropic, or OpenRouter BYOK key (`muxo byok set openai <key>`) for unrestricted natural-language LLM routing.",
+                },
+                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,
+                executed: false,
+                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.`,
+            };
+        }
+        const planned = await this.planAction(ctx, {
+            toolSlug: resolution.tool.slug,
+            input: resolution.input,
+            reason: params.prompt,
+            fundingMode: params.fundingMode,
+        });
+        if (planned.authHandoff?.required) {
+            return {
+                ok: false,
+                executed: false,
+                status: "awaiting_oauth_connection",
+                intent: resolution,
+                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,
+                executed: false,
+                status: "planned_dry_run",
+                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.`,
+            };
+        }
+        let currentPlan = planned.plan;
+        if (currentPlan.approvalStatus === "pending_approval" &&
+            params.autoApprove !== false) {
+            currentPlan = this.approvePlan(ctx, currentPlan.id, "approved");
+        }
+        if (currentPlan.approvalStatus === "pending_approval") {
+            return {
+                ok: true,
+                executed: false,
+                status: "awaiting_approval",
+                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.`,
+            };
+        }
+        const executed = await this.executePlanForRisk(ctx, currentPlan.id, currentPlan.riskLevel);
+        const isSuccess = executed.run.status === "succeeded";
+        return {
+            ok: isSuccess,
+            executed: isSuccess,
+            status: "executed",
+            intent: resolution,
+            resolution,
+            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);
+    }
+    /**
+     * 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,
+        };
+    }
+}