@muxoai/platform 1.4.0 → 1.4.2

package/dist/config.d.ts

@@ -1,11 +1,23 @@
+import type { ClerkEnv } from "./clerk.js";
 export declare const ROOT_DIR: string;
 export interface MuxoConfig {
     port: number;
     baseUrl: string;
     dbPath: string;
     composioApiKey: string;
+    composioInstantApiKey: string;
     composioBaseUrl: string;
+    composioWebhookSecret: string;
+    composioWebhookSubscriptionId: string;
+    composioProjectId: string;
+    composioOrgId: string;
+    composioUserId: string;
     stripeSecretKey: string;
+    stripePublishableKey: string;
+    stripeApiBaseUrl: string;
+    stripeProvisioningApiVersion: string;
+    stripeProjectId: string;
+    stripeConnectedAccountId?: string;
     stripeStarterPriceId: string;
     stripeCreditsPriceId: string;
     stripeWebhookSecret: string;
@@ -16,5 +28,9 @@ export interface MuxoConfig {
     publicWebUrl: string;
     docsUrl: string;
     vaultMasterKey: Buffer;
+    /** Clerk sign-in settings; sign-in stays password-based unless CLERK_PUBLISHABLE_KEY is set. */
+    clerkEnv?: ClerkEnv & {
+        MUXO_OWNER_EMAILS?: string;
+    };
 }
 export declare function getConfig(): MuxoConfig;

package/dist/config.js

@@ -65,11 +65,30 @@ export function getConfig() {
         dbPath: process.env.MUXO_DB_PATH || path.join(dataDir, "muxo.db"),
         composioApiKey: process.env.MUXO_EXTERNAL_MODE === "1"
             ? ""
-            : process.env.COMPOSIO_API_KEY || "",
+            : process.env.COMPOSIO_API_KEY || process.env.COMPOSIO_INSTANT_API_KEY || "",
+        composioInstantApiKey: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.COMPOSIO_INSTANT_API_KEY || process.env.COMPOSIO_API_KEY || "",
         composioBaseUrl: process.env.COMPOSIO_BASE_URL || "https://backend.composio.dev/api/v3",
+        composioWebhookSecret: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.COMPOSIO_WEBHOOK_SECRET || "",
+        composioWebhookSubscriptionId: process.env.COMPOSIO_WEBHOOK_SUBSCRIPTION_ID || "",
+        composioProjectId: process.env.COMPOSIO_PROJECT_ID || "",
+        composioOrgId: process.env.COMPOSIO_ORG_ID || "",
+        composioUserId: process.env.COMPOSIO_USER_ID || "",
         stripeSecretKey: process.env.MUXO_EXTERNAL_MODE === "1"
             ? ""
             : process.env.STRIPE_SECRET_KEY || "",
+        stripePublishableKey: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.STRIPE_PUBLISHABLE_KEY || "",
+        stripeApiBaseUrl: process.env.STRIPE_API_BASE_URL || "https://api.stripe.com",
+        stripeProvisioningApiVersion: process.env.STRIPE_PROVISIONING_API_VERSION || "2026-09-30.preview",
+        stripeProjectId: process.env.STRIPE_PROJECT_ID || "",
+        stripeConnectedAccountId: process.env.STRIPE_CONNECTED_ACCOUNT_ID ||
+            process.env.STRIPE_CONTEXT ||
+            "",
         stripeStarterPriceId: process.env.STRIPE_STARTER_PRICE_ID || "",
         stripeCreditsPriceId: process.env.STRIPE_CREDITS_PRICE_ID || "",
         stripeWebhookSecret: process.env.STRIPE_WEBHOOK_SECRET || "",
@@ -85,5 +104,12 @@ export function getConfig() {
         publicWebUrl: process.env.MUXO_PUBLIC_WEB_URL || "https://muxo.ai",
         docsUrl: process.env.MUXO_DOCS_URL || "https://docs.muxo.ai",
         vaultMasterKey: deriveVaultMasterKey(),
+        clerkEnv: {
+            CLERK_PUBLISHABLE_KEY: process.env.CLERK_PUBLISHABLE_KEY,
+            CLERK_SECRET_KEY: process.env.CLERK_SECRET_KEY,
+            CLERK_JWT_KEY: process.env.CLERK_JWT_KEY,
+            CLERK_AUTHORIZED_PARTIES: process.env.CLERK_AUTHORIZED_PARTIES,
+            MUXO_OWNER_EMAILS: process.env.MUXO_OWNER_EMAILS,
+        },
     };
 }

package/dist/durable-workflow.d.ts

@@ -0,0 +1,45 @@
+/** Cloud provisioning pipeline modelled on Cloudflare Workflows primitives, shared by the Node engine and the edge worker. */
+import { MuxoToolError } from "./mcp-schema.js";
+export type DurableWorkflowStepStatus = "completed" | "waiting" | "pending";
+export interface DurableWorkflowStep {
+    name: string;
+    primitive: "step.do" | "step.waitForEvent" | "step.sleep";
+    status: DurableWorkflowStepStatus;
+    output?: Record<string, unknown>;
+    completedAt?: string;
+}
+export interface DurableWorkflow {
+    id: string;
+    workspaceId: string;
+    workflowType: "cloud_provisioning_pipeline" | "approval_handoff_pipeline";
+    status: "running" | "waiting_for_event" | "completed" | "failed";
+    provider: string;
+    serviceRef: string;
+    resourceId: string | null;
+    steps: DurableWorkflowStep[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const WORKFLOW_RESOURCE_COMPLETED_EVENT = "v2.provisioning.resource.completed";
+export declare function workflowNotFoundError(workflowId: string): MuxoToolError;
+export declare function normalizeWorkflowTarget(params: {
+    provider?: string;
+    serviceRef?: string;
+}): {
+    provider: string;
+    serviceRef: string;
+};
+export declare function createCloudProvisioningWorkflow(params: {
+    id: string;
+    workspaceId: string;
+    resourceId: string;
+    provider: string;
+    serviceRef: string;
+    region?: string;
+    apiVersion?: string;
+}): DurableWorkflow;
+/** Completes every outstanding step once the resource-completed event (or a manual advance) arrives. */
+export declare function completeCloudProvisioningWorkflow(wf: DurableWorkflow, params: {
+    secretKeys: string[];
+    triggerEvent?: unknown;
+}): DurableWorkflow;

package/dist/durable-workflow.js

@@ -0,0 +1,90 @@
+/** Cloud provisioning pipeline modelled on Cloudflare Workflows primitives, shared by the Node engine and the edge worker. */
+import { MuxoToolError } from "./mcp-schema.js";
+export const WORKFLOW_RESOURCE_COMPLETED_EVENT = "v2.provisioning.resource.completed";
+export function workflowNotFoundError(workflowId) {
+    return new MuxoToolError(`Durable workflow not found: ${workflowId}`, {
+        code: "workflow_not_found",
+        statusCode: 404,
+        payload: { workflowId },
+    });
+}
+export function normalizeWorkflowTarget(params) {
+    return {
+        provider: (params.provider || "neon").toLowerCase().trim(),
+        serviceRef: (params.serviceRef || "postgres").toLowerCase().trim(),
+    };
+}
+export function createCloudProvisioningWorkflow(params) {
+    const now = new Date().toISOString();
+    return {
+        id: params.id,
+        workspaceId: params.workspaceId,
+        workflowType: "cloud_provisioning_pipeline",
+        status: "waiting_for_event",
+        provider: params.provider,
+        serviceRef: params.serviceRef,
+        resourceId: params.resourceId,
+        steps: [
+            {
+                name: "check_stripe_v2_eligibility",
+                primitive: "step.do",
+                status: "completed",
+                output: { status: "eligible", apiVersion: params.apiVersion || "2026-09-30.preview" },
+                completedAt: now,
+            },
+            {
+                name: "ensure_payment_profile_and_provider_connection",
+                primitive: "step.do",
+                status: "completed",
+                output: { provider: params.provider, paymentProfileStatus: "active" },
+                completedAt: now,
+            },
+            {
+                name: "create_v2_provisioning_resource",
+                primitive: "step.do",
+                status: "completed",
+                output: {
+                    resourceId: params.resourceId,
+                    provider: params.provider,
+                    service_ref: params.serviceRef,
+                    region: params.region || "aws-us-east-1",
+                },
+                completedAt: now,
+            },
+            {
+                name: "wait_for_v2_provisioning_resource_completed",
+                primitive: "step.waitForEvent",
+                status: "waiting",
+                output: { expectedEvent: WORKFLOW_RESOURCE_COMPLETED_EVENT, resourceId: params.resourceId },
+            },
+            {
+                name: "reveal_access_configuration_and_seal_vault",
+                primitive: "step.do",
+                status: "pending",
+            },
+        ],
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+/** Completes every outstanding step once the resource-completed event (or a manual advance) arrives. */
+export function completeCloudProvisioningWorkflow(wf, params) {
+    const now = new Date().toISOString();
+    for (const step of wf.steps) {
+        if (step.status === "completed")
+            continue;
+        step.status = "completed";
+        step.completedAt = now;
+        if (step.name === "reveal_access_configuration_and_seal_vault") {
+            step.output = {
+                vaultEncrypted: true,
+                cipher: "AES-256-GCM",
+                secretKeys: params.secretKeys,
+                triggerEvent: params.triggerEvent || WORKFLOW_RESOURCE_COMPLETED_EVENT,
+            };
+        }
+    }
+    wf.status = "completed";
+    wf.updatedAt = now;
+    return wf;
+}

package/dist/engine.d.ts

@@ -1,13 +1,37 @@
 import type { MuxoConfig } from "./config.js";
+import { type DurableWorkflow } from "./durable-workflow.js";
 import { type NaturalLanguageResolution } from "./nl.js";
+import { describePolicyInPlainEnglish, type GuardrailCompileOptions, type LlmPolicyAndGovernanceBrief, type ParsedNaturalLanguageGuardrail, type PolicySimulationResult } from "./policy.js";
 import { ComposioInstantAdapter } from "./providers/composio-instant.js";
 import { ComposioSdkAdapter } from "./providers/composio-sdk.js";
 import { MicrosoftGovernanceAdapter } from "./providers/microsoft-governance.js";
 import { StripeBillingAdapter } from "./providers/stripe-billing.js";
 import { StripeProjectsAdapter } from "./providers/stripe-projects.js";
-import { SupermemoryAdapter } from "./providers/supermemory.js";
+import { SupermemoryAdapter, type ActiveMemoryDefaults } from "./providers/supermemory.js";
 import type { MuxoStore } from "./store.js";
-import type { ActionPlan, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernanceDecisionRecord, MemoryContextSummary, MuxoTool, ProviderLane, RiskLevel, User, Workspace, WorkspaceMemoryRecord } from "./types.js";
+import type { ActionPlan, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernanceDecisionRecord, HumanFriendlyExplanation, HumanHandoff, LanguageMode, LlmGuidance, MemoryContextSummary, MemoryKnowledgeGraph, MuxoTool, PortableAgenticReceipt, ProviderLane, RiskLevel, User, Workspace, WorkspaceMemoryRecord } from "./types.js";
+export type RunContextPayload = {
+    workspaceId: string;
+    workspaceSlug: string;
+    projectsEnvironment: string;
+    policy: Workspace["policy"];
+    plainEnglishPolicy: ReturnType<typeof describePolicyInPlainEnglish>;
+    languageMode: LanguageMode;
+    customInstructions: string[];
+    activeDefaults: ActiveMemoryDefaults;
+    activeGuardrails: string[];
+    creditsBalance: number;
+    monthlyActionsRemaining: number;
+    provisionedResources: ReturnType<MuxoStore["listResources"]>;
+    environmentVariablesRedacted: Record<string, string>;
+    supermemoryBrain: MemoryContextSummary;
+    temporalFacts: NonNullable<MemoryContextSummary["temporalFacts"]>;
+    governance: ReturnType<MicrosoftGovernanceAdapter["getStatus"]>;
+    trustScore: ReturnType<MicrosoftGovernanceAdapter["getWorkspaceTrustScore"]>;
+    llmSystemPrompt: string;
+    explanation: HumanFriendlyExplanation;
+    envPullHint: string;
+};
 export interface ExecutionContext {
     user: User;
     workspace: Workspace;
@@ -23,6 +47,7 @@ export declare class MuxoEngine {
     readonly stripeBilling: StripeBillingAdapter;
     readonly governance: MicrosoftGovernanceAdapter;
     readonly supermemory: SupermemoryAdapter;
+    private readonly durableWorkflows;
     constructor(config: MuxoConfig, store: MuxoStore);
     getProfile(ctx: ExecutionContext): Record<string, unknown>;
     getOrganization(ctx: ExecutionContext): Record<string, unknown>;
@@ -41,6 +66,7 @@ export declare class MuxoEngine {
         provider?: string;
         syncLive?: boolean;
     }): Promise<Record<string, unknown>>;
+    getHostedSiteHtml(slug: string, filePath?: string): string | null;
     startConnection(ctx: ExecutionContext, params: {
         provider: string;
         lane?: ProviderLane;
@@ -54,11 +80,16 @@ export declare class MuxoEngine {
         timeoutSeconds?: number;
         pollIntervalMs?: number;
     }): Promise<{
+        ok: true;
         connected: boolean;
+        ready: boolean;
+        timedOut: boolean;
         provider: string;
         status: ConnectionRecord["status"];
         connection: ConnectionRecord;
         redirectUrl: string | null;
+        polledAttempts: number;
+        elapsedMs: number;
         message: string;
     }>;
     handleOAuthCallback(params: {
@@ -92,17 +123,46 @@ export declare class MuxoEngine {
             externalAccountId: string | null;
             instructions: string;
         };
+        humanHandoff?: HumanHandoff;
+        llmGuidance: LlmGuidance;
         nextStep: string;
     }>;
     getPlan(ctx: ExecutionContext, planId: string): ActionPlan;
+    waitForPlanApproval(ctx: ExecutionContext, params: {
+        planId: string;
+        timeoutSeconds?: number;
+        pollIntervalMs?: number;
+    }): Promise<{
+        ok: true;
+        approved: boolean;
+        rejected: boolean;
+        timedOut: boolean;
+        waitedForApproval: true;
+        approvalStatus: ActionPlan["approvalStatus"];
+        approvalUrl: string;
+        waitedMs: number;
+        plan: ActionPlan;
+    }>;
     approvePlan(ctx: ExecutionContext, planId: string, decision?: "approved" | "rejected"): ActionPlan;
+    private buildApprovalHandoff;
+    private buildOAuthHandoff;
+    private buildPlanLlmGuidance;
     private enrichMemoryContext;
-    getRunContext(ctx: ExecutionContext, query?: string): Promise<Record<string, unknown>>;
+    getRunContext(ctx: ExecutionContext, query?: string): Promise<{
+        explanation: HumanFriendlyExplanation;
+        plainEnglishPolicy: ReturnType<typeof describePolicyInPlainEnglish>;
+        activeDefaults: ActiveMemoryDefaults;
+        activeGuardrails: string[];
+        [key: string]: unknown;
+    }>;
     getMemoryOverview(ctx: ExecutionContext, query?: string): Promise<{
         enabled: boolean;
         namespace: string;
         fundingSource: string;
         context: MemoryContextSummary;
+        activeDefaults: ActiveMemoryDefaults;
+        activeGuardrails: string[];
+        explanation: HumanFriendlyExplanation;
         recentMemories: WorkspaceMemoryRecord[];
         memories: WorkspaceMemoryRecord[];
         temporalFacts: ReturnType<MuxoStore["listTemporalFacts"]>;
@@ -129,6 +189,11 @@ export declare class MuxoEngine {
         deletedMemories: WorkspaceMemoryRecord[];
         invalidatedFacts: ReturnType<MuxoStore["listTemporalFacts"]>;
     }>;
+    /**
+     * 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.
+     */
+    getMemoryGraph(ctx: ExecutionContext, query?: string): Promise<MemoryKnowledgeGraph>;
     activateWorkspaceKillSwitch(ctx: ExecutionContext, params: {
         reason: string;
         action?: "terminate" | "quarantine" | "suspend";
@@ -140,14 +205,129 @@ export declare class MuxoEngine {
     }>;
     getRun(ctx: ExecutionContext, runId: string): ExecutionRun;
     cancelRun(ctx: ExecutionContext, runId: string, reason?: string): {
+        ok: true;
+        cancelled: true;
+        alreadyCancelled: boolean;
+        previousStatus: ExecutionRun["status"];
         run: ExecutionRun;
-        receipt: ExecutionReceipt | null;
+        receipt: ExecutionReceipt;
+        signatureValid: boolean;
+        message: string;
     };
+    explainReceipt(receipt: ExecutionReceipt, verification: {
+        signatureValid: boolean;
+        governanceSignatureValid: boolean;
+        agenticReceiptValid?: boolean;
+    }, policy?: Partial<Workspace["policy"]> | null, languageMode?: LanguageMode): HumanFriendlyExplanation;
     getReceipt(ctx: ExecutionContext, receiptOrRunId: string): {
         receipt: ExecutionReceipt;
+        agenticReceipt: PortableAgenticReceipt;
         signatureValid: boolean;
         governanceSignatureValid: boolean;
+        agenticReceiptValid: boolean;
+        explanation: HumanFriendlyExplanation;
+    };
+    listReceipts(ctx: ExecutionContext, limit?: number): {
+        receipts: Array<ExecutionReceipt & {
+            agenticReceipt: PortableAgenticReceipt;
+            signatureValid: boolean;
+            governanceSignatureValid: boolean;
+            agenticReceiptValid: boolean;
+            explanation: HumanFriendlyExplanation;
+        }>;
+        total: number;
+        explanation: HumanFriendlyExplanation;
+    };
+    /**
+     * Verifies the entire cryptographic receipt chain (`prevReceiptHash` -> `receiptHash`,
+     * HMAC vault signatures, Ed25519 Governance DecisionRecords, and portable Ed25519 AgenticReceipts).
+     */
+    verifyReceiptChain(ctx: ExecutionContext, limit?: number): {
+        ok: true;
+        valid: boolean;
+        workspaceId: string;
+        agentDid: string;
+        publicKeyHex: string;
+        chainValid: boolean;
+        hashLinksValid: boolean;
+        allHmacValid: boolean;
+        allEd25519AgenticValid: boolean;
+        allGovernanceValid: boolean;
+        totalReceipts: number;
+        totalChecked: number;
+        validCount: number;
+        brokenLinks: Array<{
+            receiptId: string;
+            runId: string;
+            reason: string;
+        }>;
+        genesisHash: string;
+        headReceiptHash: string;
+        links: Array<{
+            index: number;
+            receiptId: string;
+            runId: string;
+            toolSlug: string;
+            prevReceiptHash: string;
+            receiptHash: string;
+            hashLinkValid: boolean;
+            hmacValid: boolean;
+            ed25519AgenticValid: boolean;
+            governanceValid: boolean;
+            issuedAt: string;
+        }>;
+        explanation: HumanFriendlyExplanation;
+    };
+    getGovernanceOverview(ctx: ExecutionContext): {
+        workspaceId: string;
+        killSwitch: {
+            active: boolean;
+            reason: string | null;
+        };
+        governance: ReturnType<MicrosoftGovernanceAdapter["getStatus"]>;
+        trustScore: ReturnType<MicrosoftGovernanceAdapter["getWorkspaceTrustScore"]>;
+        policy: Workspace["policy"];
+        plainEnglish: ReturnType<typeof describePolicyInPlainEnglish>;
+        llmPolicyBrief: LlmPolicyAndGovernanceBrief;
+        explanation: HumanFriendlyExplanation;
     };
+    resetWorkspaceGuardrails(ctx: ExecutionContext): {
+        ok: true;
+        action: "reset_guardrails";
+        workspace: Workspace;
+        policy: Workspace["policy"];
+        plainEnglish: ReturnType<typeof describePolicyInPlainEnglish>;
+        llmPolicyBrief: LlmPolicyAndGovernanceBrief;
+        explanation: HumanFriendlyExplanation;
+    };
+    checkToolPolicy(ctx: ExecutionContext, params: {
+        toolSlug: string;
+        input?: Record<string, unknown>;
+    }): Promise<PolicySimulationResult>;
+    setKillSwitch(ctx: ExecutionContext, active: boolean, reason?: string): Workspace;
+    scanForContextPoisoning(workspaceId: string, text: string): {
+        poisoned: boolean;
+        severity: string;
+        matchedPatterns: string[];
+        findingsCount: number;
+        integrityValid: boolean;
+    };
+    getGuardrailsSummary(ctx: ExecutionContext): {
+        workspaceId: string;
+        policy: Workspace["policy"];
+        plainEnglish: ReturnType<typeof describePolicyInPlainEnglish>;
+        llmPolicyBrief: LlmPolicyAndGovernanceBrief;
+        activeDefaults: ActiveMemoryDefaults;
+        activeGuardrails: string[];
+    };
+    applyNaturalLanguageGuardrail(ctx: ExecutionContext, prompt: string, options?: GuardrailCompileOptions): Promise<{
+        ok: boolean;
+        workspace: Workspace;
+        guardrail: ParsedNaturalLanguageGuardrail;
+        plainEnglish: ReturnType<typeof describePolicyInPlainEnglish>;
+        llmPolicyBrief: LlmPolicyAndGovernanceBrief;
+        memoryRecord?: WorkspaceMemoryRecord;
+    }>;
     doNaturalLanguage(ctx: ExecutionContext, params: {
         prompt: string;
         input?: Record<string, unknown>;
@@ -158,13 +338,38 @@ export declare class MuxoEngine {
     }): Promise<{
         ok: boolean;
         executed: boolean;
-        status: "executed" | "planned_dry_run" | "awaiting_approval" | "awaiting_oauth_connection" | "missing_inputs" | "unresolved";
+        status: "executed" | "planned_dry_run" | "awaiting_approval" | "awaiting_oauth_connection" | "missing_inputs" | "guardrail_applied" | "memory_saved" | "memory_forgotten" | "memory_recalled" | "memory_graph" | "governance_updated" | "governance_scanned" | "governance_status" | "context_inspected" | "receipt_explained" | "receipt_chain_verified" | "unresolved";
         intent: NaturalLanguageResolution;
         resolution: NaturalLanguageResolution;
         plan?: ActionPlan;
         run?: ExecutionRun;
         receipt?: ExecutionReceipt;
+        receiptVerification?: {
+            receipt: ExecutionReceipt;
+            agenticReceipt?: PortableAgenticReceipt;
+            signatureValid: boolean;
+            governanceSignatureValid: boolean;
+            agenticReceiptValid?: boolean;
+            explanation: HumanFriendlyExplanation;
+        };
+        receiptsList?: ReturnType<MuxoEngine["listReceipts"]>;
+        receiptChain?: ReturnType<MuxoEngine["verifyReceiptChain"]>;
+        guardrail?: ParsedNaturalLanguageGuardrail;
+        plainEnglishGuardrails?: ReturnType<typeof describePolicyInPlainEnglish>;
+        memoryRecord?: WorkspaceMemoryRecord;
+        memoryOverview?: Awaited<ReturnType<MuxoEngine["getMemoryOverview"]>>;
+        memoryGraph?: MemoryKnowledgeGraph;
+        deletedMemoryId?: string;
+        governanceStatus?: ReturnType<MuxoEngine["getGovernanceOverview"]>;
+        poisoningScan?: ReturnType<MuxoEngine["scanForContextPoisoning"]>;
+        runContext?: Awaited<ReturnType<MuxoEngine["getRunContext"]>>;
+        explanation?: HumanFriendlyExplanation;
+        activeDefaults?: ActiveMemoryDefaults;
+        activeMemoryDefaults?: ActiveMemoryDefaults;
+        memoryAutoFilled?: Record<string, unknown>;
         authHandoff?: Record<string, unknown>;
+        humanHandoff?: HumanHandoff;
+        llmGuidance?: LlmGuidance;
         byokPrompt?: {
             needed: boolean;
             provider: string;
@@ -174,4 +379,87 @@ export declare class MuxoEngine {
         };
         humanMessage: string;
     }>;
+    /**
+     * Parallel Governed Multi-Tool Batch Execution (`COMPOSIO_MULTI_EXECUTE_TOOL` pattern).
+     * Evaluates governance & policy across every item, then executes all approved plans concurrently.
+     */
+    executeBatchPlans(ctx: ExecutionContext, params: {
+        items: Array<{
+            toolSlug: string;
+            input: Record<string, unknown>;
+            reason: string;
+        }>;
+        autoApprove?: boolean;
+    }): Promise<{
+        batchId: string;
+        totalRequested: number;
+        succeededCount: number;
+        blockedOrPendingCount: number;
+        results: Array<{
+            toolSlug: string;
+            status: "succeeded" | "failed" | "awaiting_approval" | "awaiting_oauth";
+            planId?: string;
+            runId?: string;
+            receiptId?: string;
+            output?: Record<string, unknown>;
+            error?: string;
+        }>;
+    }>;
+    /**
+     * Cloudflare Workflows (`step.do`, `step.waitForEvent`, `step.sleep`) Durable Orchestrator
+     * for multi-stage async Stripe v2 Cloud Provisioning & Vault Secret Injection.
+     */
+    startDurableWorkflow(ctx: ExecutionContext, params: {
+        provider?: string;
+        serviceRef?: string;
+        name?: string;
+        region?: string;
+    }): Promise<DurableWorkflow>;
+    advanceDurableWorkflow(ctx: ExecutionContext, workflowId: string, eventPayload?: Record<string, unknown>): Promise<DurableWorkflow>;
+    listDurableWorkflows(workspaceId: string): DurableWorkflow[];
+    /**
+     * Hybrid Semantic Vector + Bi-Temporal Recall (`@cf/baai/bge-base-en-v1.5` + Vectorize model).
+     */
+    searchMemoryHybrid(workspaceId: string, query: string, limit?: number): {
+        rankedMemories: Array<WorkspaceMemoryRecord & {
+            hybridScore: number;
+            vectorSimilarity: number;
+            lexicalOverlap: number;
+        }>;
+        vectorDimensions: number;
+        embeddingModel: string;
+        topScore: number;
+    };
+    /**
+     * Tamper-Evident R2 / WORM Audit Archive Bundle signed by the workspace's Ed25519 AgentIdentity.
+     */
+    exportTamperEvidentArchive(workspaceId: string): {
+        archiveId: string;
+        workspaceId: string;
+        storageTarget: string;
+        retentionMode: string;
+        exportedAt: string;
+        chainIntegrity: {
+            verified: boolean;
+            algorithm: string;
+            agentDid: string;
+            publicKeyFingerprint: string;
+            headMerkleHash: string;
+            bundleDigest: string;
+        };
+        counts: {
+            receipts: number;
+            governanceDecisions: number;
+            auditLogs: number;
+            temporalFacts: number;
+        };
+        merkleChain: {
+            sequence: number;
+            receiptId: string;
+            toolSlug: string;
+            prevHash: string;
+            entryHash: string;
+            createdAt: string;
+        }[];
+    };
 }