@muxoai/platform 1.4.0 → 1.4.1

package/.agents/plugins/marketplace.json

@@ -6,8 +6,8 @@
   "plugins": [
     {
       "name": "muxo",
-      "version": "1.3.1",
-      "description": "Governed execution across 1,000+ Connected Apps, Instant Tools (search, scrape, crawl, SEO audit), Cloud Infrastructure provisioning, Supermemory v5 recall, and Microsoft Agent Governance Ed25519 receipts.",
+      "version": "1.4.1",
+      "description": "Governed execution across 1,000+ Connected Apps, Instant Tools (search, scrape, crawl, SEO audit), Cloud Infrastructure provisioning, Workspace Memory recall, and cryptographic execution receipts.",
       "source": {
         "source": "local",
         "path": "./plugins/muxo"

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
   },
   "metadata": {
     "description": "Official Muxo plugin marketplace for governed execution across Connected Apps, Instant Tools, Cloud Infrastructure, and Workspace Memory.",
-    "version": "1.3.1"
+    "version": "1.4.1"
   },
   "plugins": [
     {
@@ -19,7 +19,7 @@
       },
       "strict": false,
       "description": "Governed execution across 1,000+ Connected Apps, Instant Tools (search, scrape, crawl, SEO audit), Cloud Infrastructure provisioning, Workspace Memory recall, and verifiable audit records.",
-      "version": "1.3.1",
+      "version": "1.4.1",
       "category": "Productivity",
       "skills": [
         "./plugins/muxo/skills/muxo",

package/ARCHITECTURE.md

@@ -42,7 +42,7 @@ Across `muxoai` (gen 1) and `muxo2` (gen 2, 203,443 LOC), the biggest mistake wa
 | :--- | :--- | :--- | :--- |
 | **Composio SDK & Tool Router** (`backend.composio.dev/api/v3`) | **ADOPT (Core Lane)** | Provides 500+ managed OAuth integrations (`app.*`), user-scoped Connect Links, and schema discovery without Muxo maintaining custom OAuth apps for every SaaS provider. | Replaces custom per-provider OAuth brokers and bespoke SaaS connectors. |
 | **Composio Instant & `agents.composio.dev` Pattern** | **ADOPT (Core Lane + Onboarding)** | 1) Zero-setup `instant.*` tools work immediately on workspace creation.<br>2) We adopt the **`agents.composio.dev` 2-call autonomous signup pattern** (`POST /api/v1/agents/signup` + `POST /api/v1/agents/claim`) so an agent can self-provision a Muxo workspace in one HTTP call and later hand ownership over to its human via a claim slug. | Replaces complex multi-step human-only bootstrap ceremonies for CLI/agent onboarding. |
-| **Stripe Projects CLI** (`stripe projects` v0.50.0) | **ADOPT (Core Lane — Node Runtime)** | Provisions real databases, caches, and cloud services (`neon/postgres`, `upstash/redis`, `turso`, `supabase`, `supermemory/memory`, etc.) and pulls credentials (`stripe projects env --pull`) into Muxo's AES-256-GCM vault. | Replaces `muxo2`'s broken 4-worker Cloudflare Container + mTLS bridge (`projects-gateway` + `projects-executor`). See Section 3 below. |
+| **Stripe v2 Provisioning REST API & CLI** (`https://api.stripe.com/v2/provisioning/*`, `Stripe-Version: 2026-09-30.preview` + `stripe projects` v0.50.0) | **ADOPT (Core Lane — HTTP v2 + Node Runtime)** | Provisions real databases, caches, and cloud services (`neon/postgres`, `upstash/redis`, `turso`, `supabase`, `supermemory/memory`, etc.) directly over HTTP via `POST /v2/provisioning/resources` and reveals secrets via `POST /v2/provisioning/resources/:id/reveal_access_configuration` (with automatic CLI/managed fallback) into Muxo's AES-256-GCM vault. Works natively in both Node.js and Cloudflare Workers V8 isolates! | Replaces `muxo2`'s broken 4-worker Cloudflare Container + mTLS bridge (`projects-gateway` + `projects-executor`). See Section 3 below. |
 | **Microsoft Agent Governance Toolkit** (`@microsoft/agent-governance-sdk` v5.0.0) | **ADOPT (Core Governance)** | A 40 KB, zero-dependency, MIT-licensed SDK providing `McpSecurityScanner` (prompt-injection & exfiltration detection), `PolicyEngine` (YAML/JSON rules + risk gates), `AgentIdentity` (Ed25519 DIDs), and `AuditLogger` (SHA-256 tamper-evident hash chain). | Replaces **~18,000 LOC** of custom authority seals, custom policy DSLs, and hand-rolled audit chains in `muxo2`. |
 | **Supermemory v5** (`supermemory` `^5.0.1`) | **ADOPT (Fail-Open Contextual Brain)** | Gives every Muxo workspace an isolated `/ns/muxo-v5-{hash}` brain with automatic `static` + `dynamic` profiles (`client.profile`), sub-50ms hybrid search (`client.search`), and governed post-run memory (`client.add`). Also natively deployable via Stripe Projects (`supermemory/memory`)! | Replaces **~25,000 LOC** of `muxoai/packages/brain` + Python `context-engine` (Graphiti + Neo4j + Vectorize + D1). |
 | **Mastra (`@mastra/mcp`), Pi (`pi`), Vercel AI SDK (`ai`), Google ADK** | **CLIENT ECOSYSTEM (Do Not Bundle Inside Server)** | These are **agent harnesses** that *consume* Muxo over `/mcp` and `/skill.md`. Bundling an agent framework inside the Muxo server violates "Existing-Agent First" and bloats the runtime. Instead, `app.muxo.ai` and `muxo mcp-config` generate instant copy-paste connectors for Mastra, Pi, Vercel AI SDK, Claude Code, Cursor, and Factory Droid. | Drops `muxoai/packages/harness` (`@cloudflare/think` + custom chat UI) from the core execution server. |
@@ -58,11 +58,21 @@ In `muxo2` (`projects-production-completion-plan.md`), the runtime was built on
 1. `muxo2` tried to wrap the Stripe CLI inside a separate **Cloudflare Container (`apps/projects-executor`)** behind a second **Cloudflare Worker (`apps/projects-gateway`)** with custom CA fingerprint pinning, UID=0 root directory checks, and 55-second container cold-start budgets.
 2. Inside the container, the `stripe-projects-cli` plugin was invoked directly without `PROJECTS_STANDALONE=1` or exceeded container memory/startup deadlines, resulting in `SIGKILL` and 9 consumed diagnostic attempts.
 
-### Why It Works 100% Live in `muxo3`
-In `muxo3` (`src/providers/stripe-projects.ts`):
-1. **Native Node.js 22 Runtime:** `muxo3` runs as a standard Node.js 22 process (locally or in a standard persistent Linux container on Railway/Fly.io/Render) and invokes `/Users/test/.local/bin/stripe projects ... --json` directly via `node:child_process`.
-2. **Automatic Companion Plan Resolution:** When a deployable service (like `neon/postgres`) returns `PLAN_REQUIRED`, `StripeProjectsAdapter.provisionResource()` automatically inspects the provider catalog, provisions the free/default plan (`neon/free`), and completes `neon/postgres` provisioning in one seamless transaction.
-3. **Encrypted Vault Custody:** Immediately after provisioning, `StripeProjectsAdapter` runs `stripe projects env --pull`, captures the real credentials (e.g., `NEON_POSTGRES_CONNECTION_STRING`), encrypts them with **AES-256-GCM** using a per-workspace HKDF-derived key in `MuxoStore` (`src/store.ts`), and exposes them only via explicit owner-authenticated `muxo env pull` or `GET /api/v1/resources/env`.
+### Why It Works 100% Live in `muxo3` (Native Stripe v2 Provisioning HTTP API + CLI)
+In `muxo3` (`src/providers/stripe-projects.ts` and `worker/index.ts`), we integrate Stripe's gated **v2 Provisioning REST API** (`https://api.stripe.com/v2/provisioning/*` with header `Stripe-Version: 2026-09-30.preview`) alongside the local CLI:
+1. **Direct Stripe v2 Provisioning HTTP REST Client (Zero Container Required, V8 Isolate Ready):** Both `StripeProjectsAdapter` (Node.js) and `worker/index.ts` (Cloudflare Workers) call Stripe's `/v2/provisioning/*` REST endpoints directly over HTTPS using `Authorization: Bearer <sk_live_...|rk_live_...>` and `Stripe-Version: 2026-09-30.preview`:
+   - **Eligibilities:** `GET /v2/provisioning/eligibility` (`v2.provisioning.eligibility`)
+   - **Catalog Providers:** `GET /v2/provisioning/catalog/providers` (`v2.provisioning.provider`)
+   - **Catalog Service Details:** `GET /v2/provisioning/catalog/services` (`v2.provisioning.provider_service_detail`)
+   - **Payment Profiles & Spend Limits:** `GET /v2/provisioning/payment_profile` & `POST /v2/provisioning/payment_profile/update_limit` (`v2.provisioning.payment_profile`)
+   - **Payment Method Requests:** `POST /v2/provisioning/payment_method_requests` (`v2.provisioning.payment_method_request`)
+   - **Projects:** `POST /v2/provisioning/projects` (`v2.provisioning.project`)
+   - **Provider Connections:** `GET /v2/provisioning/provider_connections` & `POST /v2/provisioning/provider_connections/:id/unlink` (`v2.provisioning.provider_connection`)
+   - **Provider Connection Requests:** `POST /v2/provisioning/provider_connection_requests`, `GET /v2/provisioning/provider_connection_requests/:id`, & `POST /v2/provisioning/provider_connection_requests/:id/submit_information` (`v2.provisioning.provider_connection_request`)
+   - **Resources:** `POST /v2/provisioning/resources`, `POST /v2/provisioning/resources/link`, `GET /v2/provisioning/resources/:id`, `POST /v2/provisioning/resources/:id`, `POST /v2/provisioning/resources/:id/remove`, `POST /v2/provisioning/resources/:id/unlink`, `POST /v2/provisioning/resources/:id/rotate_credentials`, & `POST /v2/provisioning/resources/:id/submit_information` (`v2.provisioning.resource`)
+   - **Access Configurations (Secret Reveal):** `POST /v2/provisioning/resources/:id/reveal_access_configuration` (`v2.provisioning.resource.access_configuration` returning `{ configuration: Record<string, string>, expires_at }`)
+2. **Automatic Multi-Tier Fallback:** If the Stripe key does not yet have the `2026-09-30.preview` gate enabled, `StripeProjectsAdapter` transparently falls back to the local `stripe projects` CLI (when a `.projects` directory is present) or Muxo Cloud Managed Infrastructure.
+3. **Encrypted Vault Custody:** Immediately after `POST /v2/provisioning/resources` and `POST /v2/provisioning/resources/:id/reveal_access_configuration` (or `stripe projects env --pull`), `StripeProjectsAdapter` encrypts the returned credentials with **AES-256-GCM** using a per-workspace HKDF-derived key in `MuxoStore` (`src/store.ts`), exposing them only via owner-authenticated `muxo env pull`, `GET /api/v1/resources/env`, or `POST /api/v1/provisioning/resources/:id/reveal_access_configuration`.
 
 ---
 

package/README.md

@@ -116,7 +116,7 @@ Muxo ships a portable OpenAI Plugin (`plugins/muxo/plugin.json` & `plugins/muxo/
 | `src/store.ts` | SQLite (`node:sqlite`) store, AES-256-GCM secret vault, credit/settlement ledger, memories, agent claims, and HMAC-SHA256 receipt chain |
 | `src/providers/composio-sdk.ts` | Live Composio v3 Connected Apps adapter (catalog search, OAuth sessions/links, tool execution) |
 | `src/providers/composio-instant.ts` | Live Composio Instant adapter (`search`, `scrape`, `crawl`, `seo.audit`, `hackernews`, `github.repo_intel`, `dns.lookup`, `workbench`) |
-| `src/providers/stripe-projects.ts` | Live Stripe Projects CLI bridge (`status`, `catalog`, `add`, `rotate`, `remove`, `env --pull`) |
+| `src/providers/stripe-projects.ts` | Live Stripe v2 Provisioning REST API (`2026-09-30.preview`) & Stripe Projects CLI bridge (`eligibility`, `catalog`, `payment_profile`, `provider_connections`, `resources`, `reveal_access_configuration`, `rotate`, `remove`, `env --pull`) |
 | `src/providers/stripe-billing.ts` | Live Stripe Checkout billing (Starter `$29/mo`, Pro `$99/mo`, yearly billing & credit packs with volume discounts) |
 | `src/providers/microsoft-governance.ts` | Microsoft Agent Governance Toolkit v5.0.0 (`McpSecurityScanner`, `PolicyEngine`, `AgentIdentity` Ed25519 DID, `AuditLogger`) |
 | `src/providers/supermemory.ts` | Supermemory v5 Contextual Brain (`profile`, hybrid `search`, secret-redacted `add`, `delete`) |

package/dist/cli.js

@@ -6,7 +6,7 @@ import readline from "node:readline";
 import { getConfig } from "./config.js";
 import { MuxoEngine } from "./engine.js";
 import { handleJsonRpcMcpRequest } from "./mcp.js";
-import { sanitizePolicyPatch } from "./policy.js";
+import { DEFAULT_WORKSPACE_POLICY, describePolicyInPlainEnglish, sanitizePolicyPatch, } from "./policy.js";
 import { RING_LABELS } from "./providers/microsoft-governance.js";
 import { BYOK_PROVIDER_CATALOG, MuxoStore } from "./store.js";
 import { MUXO_VERSION } from "./version.js";
@@ -337,17 +337,27 @@ async function runCli() {
             ? flags["api-key"].trim()
             : typeof flags.key === "string"
                 ? flags.key.trim()
-                : "";
+                : positional[1]?.startsWith("mk_")
+                    ? positional[1].trim()
+                    : "";
         let activeConfig = savedCliConfig;
         if (explicitKey) {
             const agentName = typeof flags.name === "string" ? flags.name : "Muxo Agent";
             if (remoteUrl) {
                 apiKeyFlag = explicitKey;
-                const orgRes = (await remoteFetch("/api/v1/organization").catch(() => ({})));
+                const joinRes = (await remoteFetch("/api/v1/workspaces/join", {
+                    method: "POST",
+                    body: { apiKey: explicitKey },
+                    apiKey: explicitKey,
+                }).catch(() => null));
+                const orgRes = joinRes?.workspace
+                    ? { organization: joinRes.workspace }
+                    : (await remoteFetch("/api/v1/organization").catch(() => ({})));
                 const org = orgRes?.organization || orgRes?.workspace || {};
                 activeConfig = {
                     authenticated: true,
                     apiKey: explicitKey,
+                    apiUrl: remoteUrl,
                     workspaceId: org.id || "ws_remote",
                     workspaceName: org.name || agentName,
                     agentId: "usr_remote",
@@ -995,7 +1005,7 @@ async function runCli() {
             provider,
             timeoutSeconds,
         });
-        console.log(JSON.stringify({ ok: true, ...waited }, null, 2));
+        console.log(JSON.stringify(waited, null, 2));
         return;
     }
     if (cmd === "plan") {
@@ -1229,17 +1239,17 @@ async function runCli() {
                 console.log(JSON.stringify(res, null, 2));
             }
             else {
-                const runsRes = await remoteFetch("/api/v1/runs");
-                console.log(JSON.stringify(runsRes.runs || runsRes, null, 2));
+                const res = await remoteFetch("/api/v1/receipts?limit=20");
+                console.log(JSON.stringify(res, null, 2));
             }
             return;
         }
-        const { store, engine, ctx } = getLocalContext();
+        const { engine, ctx } = getLocalContext();
         if (receiptId) {
             console.log(JSON.stringify(engine.getReceipt(ctx, receiptId), null, 2));
         }
         else {
-            console.log(JSON.stringify(store.listReceipts(ctx.workspace.id, 20), null, 2));
+            console.log(JSON.stringify({ ok: true, ...engine.listReceipts(ctx, 20) }, null, 2));
         }
         return;
     }
@@ -1833,6 +1843,125 @@ async function runCli() {
         }, null, 2));
         return;
     }
+    if (cmd === "context") {
+        const query = positional.slice(1).join(" ") ||
+            (typeof flags.query === "string" ? flags.query : "") ||
+            undefined;
+        if (remoteUrl) {
+            const suffix = query ? `?query=${encodeURIComponent(query)}` : "";
+            const res = await remoteFetch(`/api/v1/context${suffix}`);
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const { engine, ctx } = getLocalContext();
+        const runContext = await engine.getRunContext(ctx, query);
+        console.log(JSON.stringify({ ok: true, ...runContext }, null, 2));
+        return;
+    }
+    if (cmd === "guardrails" || cmd === "guardrail") {
+        const sub = positional[1];
+        if (sub === "set" || sub === "add") {
+            const prompt = positional.slice(2).join(" ").trim() ||
+                String(flags.prompt || flags.rule || "").trim();
+            const rawRulesJson = typeof flags["rules-json"] === "string"
+                ? flags["rules-json"]
+                : typeof flags.rules === "string"
+                    ? flags.rules
+                    : undefined;
+            const parsedParamRules = rawRulesJson
+                ? JSON.parse(rawRulesJson)
+                : undefined;
+            if (!prompt && (!parsedParamRules || parsedParamRules.length === 0)) {
+                throw new Error('Usage: muxo guardrails set "<plain-English rule>" [--rules-json \'[...]\'] (e.g. muxo guardrails set "auto approve under $50 and require approval over $50")');
+            }
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/guardrails", {
+                    method: "POST",
+                    body: {
+                        prompt,
+                        ...(parsedParamRules ? { parameterRules: parsedParamRules } : {}),
+                    },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { engine, ctx } = getLocalContext();
+            const applied = await engine.applyNaturalLanguageGuardrail(ctx, prompt, {
+                parameterRules: parsedParamRules,
+                source: parsedParamRules ? "mcp_harness" : "deterministic",
+            });
+            console.log(JSON.stringify({
+                ...applied,
+                humanMessage: `Guardrail active: ${applied.guardrail.summary}`,
+            }, null, 2));
+            return;
+        }
+        if (sub === "reset") {
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/guardrails", {
+                    method: "POST",
+                    body: { reset: true },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { store, ctx } = getLocalContext();
+            const updated = store.updateWorkspacePolicy(ctx.workspace.id, DEFAULT_WORKSPACE_POLICY);
+            console.log(JSON.stringify({
+                ok: true,
+                workspace: updated,
+                plainEnglish: describePolicyInPlainEnglish(updated.policy),
+                humanMessage: "Reset workspace guardrails to Safe Default.",
+            }, null, 2));
+            return;
+        }
+        if (remoteUrl) {
+            const res = await remoteFetch("/api/v1/guardrails");
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const { engine, ctx } = getLocalContext();
+        const summary = engine.getGuardrailsSummary(ctx);
+        console.log(JSON.stringify({ ok: true, ...summary }, null, 2));
+        return;
+    }
+    if (cmd === "policy") {
+        const nlText = positional.slice(1).join(" ").trim() ||
+            String(flags.rule || flags.prompt || "").trim();
+        if (nlText) {
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/guardrails", {
+                    method: "POST",
+                    body: { prompt: nlText },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { engine, ctx } = getLocalContext();
+            const applied = await engine.applyNaturalLanguageGuardrail(ctx, nlText);
+            console.log(JSON.stringify({
+                ...applied,
+                humanMessage: `Guardrail active: ${applied.guardrail.summary}`,
+            }, null, 2));
+            return;
+        }
+        if (remoteUrl) {
+            const res = await remoteFetch("/api/v1/policy");
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const { engine, ctx } = getLocalContext();
+        const summary = engine.getGuardrailsSummary(ctx);
+        console.log(JSON.stringify({
+            ok: true,
+            policy: summary.policy,
+            plainEnglish: summary.plainEnglish,
+            explanation: summary.plainEnglish.explanation,
+            activeDefaults: summary.activeDefaults,
+            activeGuardrails: summary.activeGuardrails,
+        }, null, 2));
+        return;
+    }
     if (cmd === "governance") {
         const sub = positional[1];
         const ringLabel = (policy) => policy?.executionRing !== undefined
@@ -1957,6 +2086,178 @@ async function runCli() {
         }, null, 2));
         return;
     }
+    if (cmd === "workspaces" || cmd === "workspace") {
+        const sub = positional[1] || "list";
+        if (sub === "list" || sub === "ls") {
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/workspaces");
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { store, ctx } = getLocalContext();
+            const workspaces = store.listUserWorkspaces(ctx.user.id, ctx.workspace.id);
+            console.log(JSON.stringify({ ok: true, currentWorkspaceId: ctx.workspace.id, workspaces }, null, 2));
+            return;
+        }
+        if (sub === "create" || sub === "new") {
+            const name = positional.slice(2).join(" ").trim() ||
+                (typeof flags.name === "string" ? flags.name.trim() : "");
+            if (!name) {
+                throw new Error("Usage: muxo workspaces create <name> [--team <teamName>]");
+            }
+            const teamName = typeof flags.team === "string" ? flags.team.trim() : undefined;
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/workspaces", {
+                    method: "POST",
+                    body: { name, teamName },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { store, ctx } = getLocalContext();
+            const created = store.createWorkspaceForUser({
+                userId: ctx.user.id,
+                name,
+                teamName,
+            });
+            console.log(JSON.stringify({
+                ok: true,
+                workspace: created.workspace,
+                apiKey: created.apiKey,
+                workspaces: store.listUserWorkspaces(ctx.user.id, created.workspace.id),
+            }, null, 2));
+            return;
+        }
+        if (sub === "switch" || sub === "use") {
+            const workspaceId = positional[2]?.trim() ||
+                (typeof flags.id === "string" ? flags.id.trim() : "");
+            if (!workspaceId) {
+                throw new Error("Usage: muxo workspaces switch <workspace_id>");
+            }
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/workspaces/switch", {
+                    method: "POST",
+                    body: { workspaceId },
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { store, ctx } = getLocalContext();
+            const switched = store.switchUserWorkspace(ctx.user.id, workspaceId);
+            if (!switched) {
+                throw new Error(`Workspace '${workspaceId}' not found or not accessible.`);
+            }
+            console.log(JSON.stringify({
+                ok: true,
+                workspace: switched.workspace,
+                workspaces: store.listUserWorkspaces(ctx.user.id, switched.workspace.id),
+            }, null, 2));
+            return;
+        }
+        if (sub === "join") {
+            const keyToJoin = positional[2]?.trim() ||
+                (typeof flags["api-key"] === "string"
+                    ? flags["api-key"].trim()
+                    : typeof flags.key === "string"
+                        ? flags.key.trim()
+                        : "");
+            if (!keyToJoin) {
+                throw new Error("Usage: muxo workspaces join <mk_live_...>");
+            }
+            if (remoteUrl) {
+                const res = await remoteFetch("/api/v1/workspaces/join", {
+                    method: "POST",
+                    body: { apiKey: keyToJoin },
+                });
+                const ws = res.workspace || {};
+                writeCliAuthConfig({
+                    authenticated: true,
+                    apiKey: keyToJoin,
+                    apiUrl: remoteUrl,
+                    workspaceId: String(ws.id || "ws_remote"),
+                    workspaceName: String(ws.name || "Muxo Workspace"),
+                    agentId: "usr_remote",
+                    governanceDid: `did:muxo:${ws.id || "ws_remote"}`,
+                    supermemoryNamespace: `muxo_${ws.id || "ws_remote"}`,
+                    updatedAt: new Date().toISOString(),
+                });
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const { store, ctx, engine } = getLocalContext();
+            const joined = store.joinWorkspaceWithApiKey({
+                apiKey: keyToJoin,
+                userId: ctx.user.id,
+            });
+            if (!joined) {
+                throw new Error("Invalid or revoked Muxo API key.");
+            }
+            writeCliAuthConfig({
+                authenticated: true,
+                apiKey: keyToJoin,
+                workspaceId: joined.workspace.id,
+                workspaceName: joined.workspace.name,
+                agentId: ctx.user.id,
+                governanceDid: engine.governance.getStatus(joined.workspace).agentDid,
+                supermemoryNamespace: engine.supermemory.getWorkspaceNamespace(joined.workspace.id),
+                updatedAt: new Date().toISOString(),
+            });
+            console.log(JSON.stringify({
+                ok: true,
+                mode: "api_key_join",
+                workspace: joined.workspace,
+                keyRecord: joined.keyRecord,
+                membership: joined.membership,
+            }, null, 2));
+            return;
+        }
+    }
+    if (cmd === "team" || cmd === "teams") {
+        const sub = positional[1] || "onboard";
+        const teamName = (sub === "onboard" || sub === "invite" || sub === "add"
+            ? positional.slice(2).join(" ")
+            : positional.slice(1).join(" ")).trim() ||
+            (typeof flags.name === "string" ? flags.name.trim() : "") ||
+            (typeof flags.team === "string" ? flags.team.trim() : "");
+        if (!teamName) {
+            throw new Error('Usage: muxo team onboard "<team_name>" [--mode shared|dedicated] [--role operator|admin|member]');
+        }
+        const rawMode = typeof flags.mode === "string" ? flags.mode.trim() : "";
+        const mode = rawMode === "dedicated" || rawMode === "dedicated_workspace"
+            ? "dedicated_workspace"
+            : "shared_workspace";
+        const role = typeof flags.role === "string" &&
+            ["owner", "admin", "operator", "member"].includes(flags.role)
+            ? flags.role
+            : "operator";
+        const environment = flags.test ? "test" : "live";
+        if (remoteUrl) {
+            const res = await remoteFetch("/api/v1/workspaces/onboard-team", {
+                method: "POST",
+                body: { teamName, mode, role, environment },
+            });
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const { store, ctx } = getLocalContext();
+        const kit = store.onboardTeam({
+            userId: ctx.user.id,
+            userEmail: ctx.user.email,
+            currentWorkspaceId: ctx.workspace.id,
+            teamName,
+            role,
+            mode,
+            environment,
+            baseUrl: config.baseUrl,
+        });
+        console.log(JSON.stringify({
+            ok: true,
+            kit,
+            workspace: kit.workspace,
+            apiKey: kit.apiKey,
+        }, null, 2));
+        return;
+    }
     if (cmd === "serve") {
         const { createMuxoServer } = await import("./server.js");
         const port = flags.port ? Number(flags.port) : config.port;
@@ -2021,12 +2322,17 @@ async function runCli() {
 Muxo CLI — Unified Agent Execution, Cloud Infrastructure, Memory & Safety Platform
 
 Natural Language & Interactive TUI:
-  muxo setup                                   1-command auto-signup + MCP setup (.mcp.json + ~/.muxo/config.json)
+  muxo setup [--api-key <key>]                 1-command auto-signup (or join via team API key) + MCP setup
   muxo do "<instruction>"                      Execute any goal in plain English (LLM/semantic router -> plan -> execute)
   muxo ask "<instruction>" [--plan-only]       Alias for 'muxo do' (pass --plan-only to inspect plan before running)
   muxo tui                                     Launch interactive Terminal UI dashboard (BYOK, Billing, OAuth, Infra)
   muxo byok [list|set|delete] [<provider>]     Manage BYOK API keys in AES-256-GCM Vault (0 credit cost when active)
 
+Workspaces & Team Onboarding:
+  muxo workspaces [list|create|switch|join]    List, create, switch, or join workspaces via API key
+  muxo team onboard "<team>" [--mode shared|dedicated] [--role operator|admin|member]
+                                               Mint a scoped team API key & onboarding kit for another team
+
 Core Commands:
   muxo login [--api-key <key> | --signup]      Sign in or create an autonomous workspace (~/.muxo/config.json)
   muxo logout                                  Remove saved CLI authentication config
@@ -2042,6 +2348,7 @@ Core Commands:
   muxo approve <plan_id>                       Approve a pending high-risk plan
   muxo run <plan_id>                           Execute an approved plan and issue a verifiable audit record
   muxo exec <tool_slug> --input '{...}'        Plan and execute in one step (pass --approve for high-risk)
+  muxo provision <provider> [--name <name>]    Provision cloud infrastructure (e.g., turso, neon, supabase, upstash)
   muxo resources                               List provisioned Muxo Cloud Infrastructure resources
   muxo env pull [--out .env.muxo]              Decrypt and write provisioned credentials to local .env
   muxo receipts [<receipt_id>]                 List or verify execution audit records
@@ -2057,7 +2364,7 @@ Core Commands:
                          [--block-destructive-sql true|false] [--max-credits <n>]
   muxo harness                                 Check API, MCP, auth, governance and catalog; print MCP config
   muxo serve [--port 4310]                     Start unified HTTP Console, Landing, OAuth Callback & MCP server
-  muxo mcp                                     Run stdio MCP server (20 canonical tools)
+  muxo mcp                                     Run stdio MCP server (19 canonical tools)
 `);
 }
 runCli()

package/dist/composio-catalog.d.ts

@@ -0,0 +1,58 @@
+/** SDK-free Composio enterprise toolkit and trigger catalogue shared by the Node server and the edge worker. */
+export interface ComposioToolkitMetadata {
+    slug: string;
+    name: string;
+    description: string;
+    categories: string[];
+    authSchemes: Array<"OAUTH2" | "API_KEY" | "BEARER_TOKEN" | "NO_AUTH">;
+    pinnedVersion: string;
+    readOnlyScopes: string[];
+    fullAccessScopes: string[];
+    sampleActions: Array<{
+        upstreamSlug: string;
+        muxoSlug: string;
+        name: string;
+        riskLevel: "read" | "write" | "destructive" | "financial";
+    }>;
+}
+export interface ComposioTriggerSubscription {
+    id: string;
+    workspaceId: string;
+    triggerSlug: string;
+    providerSlug: string;
+    connectedAccountId: string;
+    webhookUrl: string;
+    config: Record<string, unknown>;
+    status: "active" | "paused" | "disabled";
+    createdAt: string;
+}
+export interface ComposioTriggerEventRecord {
+    id: string;
+    workspaceId: string;
+    triggerSlug: string;
+    providerSlug: string;
+    receivedAt: string;
+    promptInjectionScan: {
+        safe: boolean;
+        riskScore: number;
+        findings: string[];
+    };
+    disposition: "dispatched" | "quarantined";
+    payloadPreview: Record<string, unknown>;
+}
+export declare const ENTERPRISE_TOOLKITS_CATALOG: ComposioToolkitMetadata[];
+export declare function getSampleActionSchema(muxoSlug: string, upstreamSlug?: string): Record<string, unknown>;
+export interface ComposioTriggerType {
+    slug: string;
+    providerSlug: string;
+    name: string;
+    description: string;
+}
+export declare const COMPOSIO_TRIGGER_CATALOGUE: ComposioTriggerType[];
+export declare function listComposioTriggerTypes(providerSlug?: string): ComposioTriggerType[];
+export declare function filterComposioToolkits(params?: {
+    category?: string;
+    search?: string;
+}): ComposioToolkitMetadata[];
+/** Least-privilege scopes for a custom auth config: explicit scopes win, then the toolkit's read-only or full set. */
+export declare function composioAuthConfigScopes(toolkitSlug: string, scopeMode: "read_only" | "full_access", customScopes?: string[]): string[];