@muxoai/platform 1.4.1 → 1.4.2

package/dist/server.js

@@ -5,13 +5,14 @@ import path from "node:path";
 import { getConfig, ROOT_DIR } from "./config.js";
 import { MuxoEngine } from "./engine.js";
 import { getMuxoMcpSkills, handleJsonRpcMcpRequest, MUXO_MCP_SERVER_INSTRUCTIONS, MUXO_MCP_TOOLS, } from "./mcp.js";
-import { APPROVED_PLAN_STATUSES, MuxoToolError, clampWaitSeconds, errorPayloadFrom, isPublicMcpRequest, workspaceAgentDid, } from "./mcp-schema.js";
+import { APPROVED_PLAN_STATUSES, LATEST_MCP_PROTOCOL_VERSION, MuxoToolError, SUPPORTED_MCP_PROTOCOL_VERSIONS, clampWaitSeconds, errorPayloadFrom, isPublicMcpRequest, validateMcpHttpHeadersAndMeta, workspaceAgentDid, } from "./mcp-schema.js";
 import { MuxoStore } from "./store.js";
 import { managedProviderConnectionList, managedProviderConnectionRequest, managedProviderConnectionUnlink, managedResource, managedResourceAction, } from "./provisioning-managed.js";
 import { DEFAULT_WORKSPACE_POLICY, describePolicyInPlainEnglish, sanitizePolicyPatch, } from "./policy.js";
 import { parseNaturalLanguageMemoryInstruction } from "./providers/supermemory.js";
 import { MUXO_VERSION } from "./version.js";
-import { isConsolePath, renderApprovalPageHtml, renderConsoleHtml, renderLandingHtml, renderOAuthConsentHtml, } from "./ui/console-html.js";
+import { fetchMuxoConnectLinkMetadata, isStripeProjectsExclusiveProvider, normalizeStripeProjectsProviderSlug, parseComposioWebhookEnvelope, submitMuxoConnectLink, verifyComposioWebhookSignature, wrapMuxoConnectUrl, } from "./composio-catalog.js";
+import { isConsolePath, renderApprovalPageHtml, renderConsoleHtml, renderLandingHtml, renderOAuthCallbackPageHtml, renderOAuthConnectPageHtml, renderOAuthConsentHtml, } from "./ui/console-html.js";
 import { fetchClerkProfile, looksLikeJwt, readClerkConfig, verifyClerkSessionToken, } from "./clerk.js";
 import { DEFAULT_OAUTH_SCOPE, OAUTH_ACCESS_TOKEN_TTL_SECONDS, OAUTH_CODE_TTL_MS, oauthConnectionKeyName, oauthRedirectOrigin, oauthSecretToken, parseAuthorizeRequest, parseOAuthFormBody, verifyPkce, } from "./oauth.js";
 function renderSkillMarkdown(baseUrl) {
@@ -109,7 +110,20 @@ Users and LLM harnesses can set safety rules in natural language or structured p
 - "Only post Slack messages to #ops-alerts or #deployments" → channel allowlist guardrail
 - "Never spend more than 25 credits per run" → workspace per-run credit cap
 
-Set or inspect them via MCP \`get_run_context({ action: "set_guardrail", prompt: "...", parameter_rules: [...] })\`, \`POST /api/v1/do\` (\`{ "prompt": "..." }\`), \`POST /api/v1/guardrails\` (\`{ "prompt": "...", "parameterRules": [...] }\`), or list them with \`GET /api/v1/guardrails\`. Responses always include \`plainEnglishGuardrails\` so humans and agents can read the active rules.
+Set or inspect them via MCP \`get_run_context({ action: "set_guardrail", prompt: "...", parameter_rules: [...] })\`, dry-run simulate a tool call before planning via \`get_run_context({ action: "check_policy", tool_slug: "...", input: { ... } })\`, reset guardrails via \`get_run_context({ action: "reset_guardrails" })\`, toggle the emergency kill switch via \`get_run_context({ action: "kill_switch", enabled: true, reason: "..." })\`, or scan untrusted inputs for OWASP ASI-06 prompt injection via \`get_run_context({ action: "scan_context", prompt: "..." })\`. Equivalent REST routes: \`POST /api/v1/do\`, \`GET/POST /api/v1/guardrails\`, \`POST /api/v1/guardrails/check\`, and \`POST /api/v1/guardrails/reset\`. Responses always include \`plainEnglishGuardrails\` and a structured \`llmPolicyBrief\` (\`riskLaneMatrix\`, \`parameterRules[].howToComply\`, \`llmSystemDirective\`, and \`agentControlCheatsheet\`).
+
+## MCP Resources & Prompts for AI Harnesses
+
+- **MCP Resources (\`resources/list\` & \`resources/read\`)**:
+  - \`muxo://policy/brief\` — Structured \`llmPolicyBrief\` (risk-lane approval matrix, parameter compliance rules, learned defaults, and agent control cheatsheet)
+  - \`muxo://governance/policy\` — Active guardrails, kill-switch status, trust score, and \`llmPolicyBrief\`
+  - \`muxo://context\` — Live workspace context, active guardrails, provisioned resources, and \`llmSystemPrompt\`
+  - \`muxo://memory/graph\` — Active Supermemory defaults and bi-temporal knowledge graph facts
+- **MCP Prompts (\`prompts/list\` & \`prompts/get\`)**:
+  - \`context\` — Inject workspace memory, active defaults, and guardrail summary
+  - \`policy_guardrails\` — Inject the active \`llmSystemDirective\`, risk-lane matrix, and optional dry-run policy simulation for \`tool_slug\`
+  - \`governed_execution\` — Step-by-step Plan → Approve → Execute → Receipt system instructions
+  - \`security_audit\` — OWASP Agentic Top 10 security and receipt audit workflow
 
 ## Active Supermemory (teach Muxo once, auto-fill forever)
 
@@ -134,8 +148,8 @@ function sendJson(res, status, payload, extraHeaders) {
     res.writeHead(status, {
         "Content-Type": "application/json; charset=utf-8",
         "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Headers": "Content-Type, Authorization, Mcp-Session-Id",
-        "Access-Control-Expose-Headers": "Mcp-Session-Id, WWW-Authenticate",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Muxo-Workspace-Id, Mcp-Session-Id, mcp-session-id, MCP-Protocol-Version, mcp-protocol-version, Mcp-Method, mcp-method, Mcp-Name, mcp-name",
+        "Access-Control-Expose-Headers": "Mcp-Session-Id, MCP-Protocol-Version, WWW-Authenticate",
         "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
         ...(extraHeaders || {}),
     });
@@ -320,7 +334,8 @@ export function createMuxoServer(customConfig) {
         if (req.method === "OPTIONS") {
             res.writeHead(204, {
                 "Access-Control-Allow-Origin": "*",
-                "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Muxo-Workspace-Id",
+                "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Muxo-Workspace-Id, Mcp-Session-Id, mcp-session-id, MCP-Protocol-Version, mcp-protocol-version, Mcp-Method, mcp-method, Mcp-Name, mcp-name",
+                "Access-Control-Expose-Headers": "Mcp-Session-Id, MCP-Protocol-Version, WWW-Authenticate",
                 "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
             });
             res.end();
@@ -746,8 +761,14 @@ export function createMuxoServer(customConfig) {
                         "/api/v1/governance/kill-switch": { post: { summary: "Pause or resume workspace execution via kill switch" } },
                         "/api/v1/governance/scan-context": { post: { summary: "Scan untrusted text for prompt injection before storage or use" } },
                         "/api/v1/guardrails": {
-                            get: { summary: "List active plain-English guardrails, policy, and learned memory defaults" },
-                            post: { summary: "Set or reset guardrails in plain English (e.g. 'never send emails')" },
+                            get: { summary: "List active plain-English guardrails, llmPolicyBrief, policy, and learned memory defaults" },
+                            post: { summary: "Set or reset guardrails in plain English or structured parameterRules" },
+                        },
+                        "/api/v1/guardrails/check": {
+                            post: { summary: "Dry-run evaluate a tool call and arguments against active workspace policy, conditional parameter rules, and memory defaults" },
+                        },
+                        "/api/v1/guardrails/reset": {
+                            post: { summary: "Reset workspace guardrails and parameter rules to Safe Default" },
                         },
                         "/approve/{planId}": { get: { summary: "One-click human approval handoff page for a pending plan" } },
                         "/api/v1/context": {
@@ -806,10 +827,10 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
             }
             if (pathname === "/llms.txt" && req.method === "GET") {
                 res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
-                res.end(`# Muxo\n> Unified agent execution across Connected Apps, Instant Tools, Cloud Infrastructure, Workspace Memory, and Safety Guardrails.\n\n- Skill Document: ${config.baseUrl}/skill.md\n- Auth Guide: ${config.baseUrl}/auth.md\n- OpenAPI 3.1 Spec: ${config.baseUrl}/api/openapi.json\n- MCP Endpoint: ${config.baseUrl}/mcp\n- OAuth Callback Handoff: ${config.baseUrl}/oauth/callback\n- Plugin Marketplace (Codex/OpenAI): ${config.baseUrl}/.agents/plugins/marketplace.json\n- Plugin Marketplace (Claude/Droid): ${config.baseUrl}/.claude-plugin/marketplace.json\n- Console (app.muxo.ai): ${config.baseUrl}/\n- Landing & Provider Canvas (muxo.ai): ${config.baseUrl}/landing\n- Documentation (docs.muxo.ai): ${config.docsUrl}\n`);
+                res.end(`# Muxo\n> Unified agent execution across Connected Apps, Instant Tools, Cloud Infrastructure, Workspace Memory, and Safety Guardrails.\n\n- Skill Document: ${config.baseUrl}/skill.md\n- Auth Guide: ${config.baseUrl}/auth.md\n- OpenAPI 3.1 Spec: ${config.baseUrl}/api/openapi.json\n- MCP Endpoint: ${config.baseUrl}/mcp\n- OAuth Callback Handoff: ${config.baseUrl}/oauth/callback\n- Plugin Marketplace (Codex/OpenAI): ${config.baseUrl}/.agents/plugins/marketplace.json\n- Plugin Marketplace (Claude/Droid): ${config.baseUrl}/.claude-plugin/marketplace.json\n- Console (app.muxo.ai): ${config.baseUrl}/\n- Landing & Provider Canvas (muxo.ai): ${config.baseUrl}/landing\n- Documentation (docs.muxo.ai): ${config.docsUrl}\n\n## Agent-Native Policy, Context & Governance Interface\n- MCP Control Plane (\`get_run_context\`): \`action: "recall" | "remember" | "forget" | "set_guardrail" | "reset_guardrails" | "check_policy" | "governance_status" | "kill_switch" | "scan_context"\`\n- Strict /v1 Organization Brief: \`get_organization({ company_context: { required: false } })\` returns accepted workspace policy facts + learned defaults in \`company_context.packet\`\n- Dry-Run Policy Simulator: \`POST ${config.baseUrl}/api/v1/guardrails/check\` (\`{ "tool_slug": "...", "input": { ... } }\`) or MCP \`get_run_context({ action: "check_policy", tool_slug, input })\`\n- Guardrails & Policy Brief: \`GET/POST ${config.baseUrl}/api/v1/guardrails\`, \`POST ${config.baseUrl}/api/v1/guardrails/reset\`, \`GET ${config.baseUrl}/api/v1/governance\` (includes \`llmPolicyBrief\`)\n- MCP Resources: \`muxo://policy/brief\`, \`muxo://governance/policy\`, \`muxo://context\`, \`muxo://memory/graph\`\n- MCP Prompts: \`context\`, \`policy_guardrails\`, \`governed_execution\`, \`security_audit\`\n`);
                 return;
             }
-            // Serve Installable Muxo Plugin Manifests & Metadata (Portable OpenAI Agent Plugins + Codex + Claude)
+            // Serve Installable Muxo Plugin Manifests & Metadata (Portable OpenAI Agent Plugins + Codex + Claude + Cursor)
             const pluginJsonRoutes = {
                 "/.agents/plugins/marketplace.json": path.join(ROOT_DIR, ".agents", "plugins", "marketplace.json"),
                 "/.claude-plugin/marketplace.json": path.join(ROOT_DIR, ".claude-plugin", "marketplace.json"),
@@ -817,6 +838,7 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 "/plugins/muxo/mcp.json": path.join(ROOT_DIR, "plugins", "muxo", "mcp.json"),
                 "/plugins/muxo/.codex-plugin/plugin.json": path.join(ROOT_DIR, "plugins", "muxo", ".codex-plugin", "plugin.json"),
                 "/plugins/muxo/.claude-plugin/plugin.json": path.join(ROOT_DIR, "plugins", "muxo", ".claude-plugin", "plugin.json"),
+                "/plugins/muxo/.cursor-plugin/plugin.json": path.join(ROOT_DIR, "plugins", "muxo", ".cursor-plugin", "plugin.json"),
                 "/plugins/muxo/.app.json": path.join(ROOT_DIR, "plugins", "muxo", ".app.json"),
                 "/plugins/muxo/.mcp.json": path.join(ROOT_DIR, "plugins", "muxo", ".mcp.json"),
             };
@@ -844,6 +866,10 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                     file: path.join(ROOT_DIR, "plugins", "muxo", "skills", "setup", "SKILL.md"),
                     contentType: "text/markdown; charset=utf-8",
                 },
+                "/plugins/muxo/skills/muxo-activity-summary/SKILL.md": {
+                    file: path.join(ROOT_DIR, "plugins", "muxo", "skills", "muxo-activity-summary", "SKILL.md"),
+                    contentType: "text/markdown; charset=utf-8",
+                },
                 "/.codex/config.toml": {
                     file: path.join(ROOT_DIR, ".codex", "config.toml"),
                     contentType: "text/plain; charset=utf-8",
@@ -864,10 +890,15 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 const portableManifest = JSON.parse(fs.readFileSync(path.join(ROOT_DIR, "plugins", "muxo", "plugin.json"), "utf8"));
                 const mcpConfig = JSON.parse(fs.readFileSync(path.join(ROOT_DIR, "plugins", "muxo", "mcp.json"), "utf8"));
                 const codexManifest = JSON.parse(fs.readFileSync(path.join(ROOT_DIR, "plugins", "muxo", ".codex-plugin", "plugin.json"), "utf8"));
+                const cursorManifestPath = path.join(ROOT_DIR, "plugins", "muxo", ".cursor-plugin", "plugin.json");
+                const cursorManifest = fs.existsSync(cursorManifestPath)
+                    ? JSON.parse(fs.readFileSync(cursorManifestPath, "utf8"))
+                    : undefined;
                 sendJson(res, 200, {
                     ok: true,
                     plugin: portableManifest,
                     codexPlugin: codexManifest,
+                    cursorPlugin: cursorManifest,
                     mcp: mcpConfig,
                     skills: getMuxoMcpSkills().map((s) => ({
                         name: s.name,
@@ -884,11 +915,14 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                         portablePluginJson: `${config.baseUrl}/plugins/muxo/plugin.json`,
                         portableMcpJson: `${config.baseUrl}/plugins/muxo/mcp.json`,
                         onboardingSkill: `${config.baseUrl}/plugins/muxo/skills/setup/SKILL.md`,
+                        activitySummarySkill: `${config.baseUrl}/plugins/muxo/skills/muxo-activity-summary/SKILL.md`,
                         codexPluginJson: `${config.baseUrl}/plugins/muxo/.codex-plugin/plugin.json`,
+                        cursorPluginJson: `${config.baseUrl}/plugins/muxo/.cursor-plugin/plugin.json`,
                         codexConfigToml: `${config.baseUrl}/.codex/config.toml`,
                     },
                     installCommands: {
                         codex: "codex plugin add muxo@muxo",
+                        cursor: "/add-plugin muxo",
                         cliSignup: "muxo login --signup --name my-agent",
                         oauthHandoff: "muxo link github --wait",
                     },
@@ -915,6 +949,35 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 res.end(renderLandingHtml());
                 return;
             }
+            // Public Stripe Projects Hosted Static Sites (GET /sites/:slug and GET /sites/:slug/*)
+            const siteMatch = pathname.match(/^\/sites\/([^/]+)(?:\/(.*))?$/);
+            if (siteMatch && req.method === "GET") {
+                const siteSlug = decodeURIComponent(siteMatch[1]).replace(/\/+$/, "");
+                const filePath = siteMatch[2] ? decodeURIComponent(siteMatch[2]) : undefined;
+                const htmlContent = engine.getHostedSiteHtml(siteSlug, filePath);
+                if (!htmlContent) {
+                    sendJson(res, 404, {
+                        ok: false,
+                        code: "site_not_found",
+                        error: `Hosted site '${siteSlug}' was not found.`,
+                    });
+                    return;
+                }
+                const contentType = filePath && filePath.endsWith(".css")
+                    ? "text/css; charset=utf-8"
+                    : filePath && filePath.endsWith(".js")
+                        ? "application/javascript; charset=utf-8"
+                        : filePath && filePath.endsWith(".json")
+                            ? "application/json; charset=utf-8"
+                            : "text/html; charset=utf-8";
+                res.writeHead(200, {
+                    "Content-Type": contentType,
+                    "Access-Control-Allow-Origin": "*",
+                    "Cache-Control": "no-store",
+                });
+                res.end(htmlContent);
+                return;
+            }
             // Workspace claim link: read-only; accepting requires the invited person's verified sign-in.
             if (pathname.startsWith("/claim/") && req.method === "GET") {
                 const claimSlug = decodeURIComponent(pathname.slice("/claim/".length));
@@ -1041,30 +1104,289 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                     return;
                 }
                 res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-                res.end(`<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <title>Muxo OAuth Handoff Complete</title>
-  <style>
-    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: #090a0f; color: #f4f4f6; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
-    .card { background: #12141f; border: 1px solid #26293d; border-radius: 14px; padding: 32px; max-width: 460px; text-align: center; box-shadow: 0 20px 50px rgba(0,0,0,0.45); }
-    .badge { display: inline-block; background: rgba(16,185,129,0.15); color: #34d399; border: 1px solid rgba(16,185,129,0.35); border-radius: 999px; padding: 4px 12px; font-size: 12px; font-weight: 600; margin-bottom: 16px; }
-    h1 { font-size: 22px; margin: 0 0 10px; }
-    p { color: #a1a7bb; font-size: 14px; line-height: 1.5; margin: 0 0 20px; }
-    code { background: #1c1f30; padding: 3px 7px; border-radius: 6px; color: #e2e8f0; font-size: 12px; }
-    .btn { display: inline-block; background: #6366f1; color: #fff; text-decoration: none; padding: 10px 18px; border-radius: 8px; font-size: 14px; font-weight: 600; }
-  </style>
-</head>
-<body>
-  <div class="card">
-    <div class="badge">OAuth Handoff Complete (${handoff.status.toUpperCase()})</div>
-    <h1>${handoff.providerName} Connected to Muxo</h1>
-    <p>Workspace <code>${handoff.workspaceId}</code> is now linked${handoff.externalAccountId ? ` (<code>${handoff.externalAccountId}</code>)` : ""}. You can close this window and return to ChatGPT, Codex, Claude Code, Droid, or your terminal.</p>
-    <a class="btn" href="/?connected=${encodeURIComponent(handoff.providerSlug)}">Open Muxo Console</a>
-  </div>
-</body>
-</html>`);
+                res.end(renderOAuthCallbackPageHtml({
+                    providerSlug: handoff.providerSlug,
+                    providerName: handoff.providerName,
+                    status: handoff.status,
+                    workspaceId: handoff.workspaceId,
+                    externalAccountId: handoff.externalAccountId,
+                }));
+                return;
+            }
+            // Public bare /oauth/connect or /connect redirector & zero-OAuth status handler
+            if ((pathname === "/oauth/connect" || pathname === "/connect") && req.method === "GET") {
+                const queryToken = (url.searchParams.get("token") ||
+                    url.searchParams.get("link_token") ||
+                    "").trim();
+                const directRedirect = (url.searchParams.get("redirect_url") ||
+                    url.searchParams.get("url") ||
+                    url.searchParams.get("link") ||
+                    "").trim();
+                const workspaceId = url.searchParams.get("workspace_id") ||
+                    url.searchParams.get("user_id") ||
+                    undefined;
+                const rawProvider = url.searchParams.get("provider") ||
+                    url.searchParams.get("toolkit") ||
+                    "";
+                const cleanProvider = normalizeStripeProjectsProviderSlug(rawProvider) ||
+                    rawProvider.trim().toLowerCase().replace(/^(app\.|resource\.|projects\.)/, "");
+                const wantsJson = url.searchParams.get("format") === "json" ||
+                    String(req.headers.accept || "").includes("application/json");
+                if (queryToken) {
+                    const targetUrl = queryToken.startsWith("s_")
+                        ? `https://backend.composio.dev/api/v3/s/${encodeURIComponent(queryToken.slice(2))}`
+                        : `https://connect.composio.dev/link/${encodeURIComponent(queryToken)}`;
+                    if (wantsJson) {
+                        sendJson(res, 200, { ok: true, status: "pending", redirectUrl: targetUrl });
+                        return;
+                    }
+                    res.writeHead(302, { Location: targetUrl, "Cache-Control": "no-store" });
+                    res.end();
+                    return;
+                }
+                if (directRedirect &&
+                    /^https:\/\/(?:connect|backend)\.composio\.dev\//i.test(directRedirect)) {
+                    if (wantsJson) {
+                        sendJson(res, 200, { ok: true, status: "pending", redirectUrl: directRedirect });
+                        return;
+                    }
+                    res.writeHead(302, { Location: directRedirect, "Cache-Control": "no-store" });
+                    res.end();
+                    return;
+                }
+                if (cleanProvider && !isStripeProjectsExclusiveProvider(cleanProvider)) {
+                    const allWs = [
+                        workspaceId
+                            ? store.getWorkspace(workspaceId)
+                            : store.ensureDefaultWorkspace().workspace,
+                    ].filter(Boolean);
+                    for (const ws of allWs) {
+                        if (!ws)
+                            continue;
+                        const pending = store
+                            .listConnections(ws.id)
+                            .find((c) => c.providerSlug.toLowerCase() === cleanProvider &&
+                            c.redirectUrl &&
+                            !isStripeProjectsExclusiveProvider(c.providerSlug));
+                        if (pending?.redirectUrl) {
+                            const nativeUrl = wrapMuxoConnectUrl(pending.redirectUrl);
+                            if (nativeUrl) {
+                                if (wantsJson) {
+                                    sendJson(res, 200, {
+                                        ok: true,
+                                        provider: cleanProvider,
+                                        status: pending.status,
+                                        redirectUrl: nativeUrl,
+                                    });
+                                    return;
+                                }
+                                res.writeHead(302, { Location: nativeUrl, "Cache-Control": "no-store" });
+                                res.end();
+                                return;
+                            }
+                        }
+                    }
+                }
+                else if (!cleanProvider) {
+                    const allWs = [
+                        workspaceId
+                            ? store.getWorkspace(workspaceId)
+                            : store.ensureDefaultWorkspace().workspace,
+                    ].filter(Boolean);
+                    for (const ws of allWs) {
+                        if (!ws)
+                            continue;
+                        const pending = store
+                            .listConnections(ws.id)
+                            .find((c) => c.status === "pending" &&
+                            c.redirectUrl &&
+                            !isStripeProjectsExclusiveProvider(c.providerSlug));
+                        if (pending?.redirectUrl) {
+                            const nativeUrl = wrapMuxoConnectUrl(pending.redirectUrl);
+                            if (nativeUrl &&
+                                (/^https:\/\/(?:connect|backend)\.composio\.dev\//i.test(nativeUrl) ||
+                                    nativeUrl.includes("/oauth/connect/"))) {
+                                if (wantsJson) {
+                                    sendJson(res, 200, {
+                                        ok: true,
+                                        provider: pending.providerSlug,
+                                        status: "pending",
+                                        redirectUrl: nativeUrl,
+                                    });
+                                    return;
+                                }
+                                res.writeHead(302, { Location: nativeUrl, "Cache-Control": "no-store" });
+                                res.end();
+                                return;
+                            }
+                        }
+                    }
+                }
+                const displayProviderSlug = cleanProvider || "supabase";
+                const displayProviderName = cleanProvider
+                    ? cleanProvider.charAt(0).toUpperCase() + cleanProvider.slice(1)
+                    : "Supabase & Vercel (Stripe Projects)";
+                if (wantsJson) {
+                    sendJson(res, 200, {
+                        ok: true,
+                        status: "active",
+                        lane: "stripe_projects",
+                        provider: displayProviderSlug,
+                        noOAuthRequired: true,
+                        redirectUrl: null,
+                        message: "Provisioned Stripe Projects cloud resources (Supabase, Vercel, Cloudflare, Turso, Neon, etc.) are active immediately with zero OAuth required.",
+                    });
+                    return;
+                }
+                res.writeHead(200, {
+                    "Content-Type": "text/html; charset=utf-8",
+                    "Cache-Control": "no-store",
+                });
+                res.end(renderOAuthCallbackPageHtml({
+                    providerSlug: displayProviderSlug,
+                    providerName: displayProviderName,
+                    status: "active",
+                    workspaceId: workspaceId || "default",
+                    externalAccountId: `sp_conn_${displayProviderSlug}`,
+                }));
+                return;
+            }
+            // Muxo OAuth Connection Handoff (GET/POST /oauth/connect/:token or /connect/:token)
+            const connectPageMatch = pathname.match(/^\/(?:oauth\/)?connect\/([^/]+)$/);
+            if (connectPageMatch && (req.method === "GET" || req.method === "POST")) {
+                const token = decodeURIComponent(connectPageMatch[1]);
+                const workspaceId = url.searchParams.get("workspace_id") ||
+                    url.searchParams.get("user_id") ||
+                    undefined;
+                const providerSlug = url.searchParams.get("provider") ||
+                    url.searchParams.get("toolkit") ||
+                    undefined;
+                const callbackUrl = url.searchParams.get("callback_url") || undefined;
+                const connectedAccountId = url.searchParams.get("connected_account_id") || undefined;
+                if (req.method === "GET") {
+                    const wantsJson = url.searchParams.get("format") === "json" ||
+                        String(req.headers.accept || "").includes("application/json");
+                    const isTestToken = token.startsWith("lk_test");
+                    const forceHtml = url.searchParams.get("render") === "html";
+                    // Redirect real Composio link tokens directly to Composio's native hosted OAuth page
+                    if (!wantsJson && !isTestToken && !forceHtml && (token.startsWith("lk_") || token.startsWith("s_"))) {
+                        const nativeComposioUrl = token.startsWith("s_")
+                            ? `https://backend.composio.dev/api/v3/s/${encodeURIComponent(token.slice(2))}`
+                            : `https://connect.composio.dev/link/${encodeURIComponent(token)}`;
+                        res.writeHead(302, {
+                            Location: nativeComposioUrl,
+                            "Cache-Control": "no-store",
+                        });
+                        res.end();
+                        return;
+                    }
+                    const meta = await fetchMuxoConnectLinkMetadata(token, {
+                        workspaceId,
+                        providerSlug,
+                        callbackUrl,
+                        connectedAccountId,
+                    });
+                    if (url.searchParams.get("continue") === "1" ||
+                        url.searchParams.get("auto") === "1") {
+                        const submitted = await submitMuxoConnectLink(token, {}, {
+                            workspaceId,
+                            providerSlug: meta.toolkitSlug,
+                            callbackUrl: meta.callbackUrl || callbackUrl,
+                            connectedAccountId: meta.connectedAccountId,
+                        });
+                        if (submitted.ok && submitted.redirectUrl) {
+                            res.writeHead(302, { Location: submitted.redirectUrl });
+                            res.end();
+                            return;
+                        }
+                    }
+                    if (wantsJson) {
+                        sendJson(res, 200, { ok: true, handoff: meta });
+                        return;
+                    }
+                    res.writeHead(200, {
+                        "Content-Type": "text/html; charset=utf-8",
+                        "Cache-Control": "no-store",
+                        "Referrer-Policy": "no-referrer",
+                    });
+                    res.end(renderOAuthConnectPageHtml({
+                        token: meta.token,
+                        toolkitSlug: meta.toolkitSlug,
+                        toolkitName: meta.toolkitName,
+                        workspaceId,
+                        authMode: meta.authMode,
+                        status: meta.status,
+                        callbackUrl: meta.callbackUrl || callbackUrl,
+                        expectedInputFields: meta.expectedInputFields,
+                    }));
+                    return;
+                }
+                // POST /oauth/connect/:token
+                const rawBody = await readBody(req);
+                let input = {};
+                const contentType = String(req.headers["content-type"] || "");
+                if (contentType.includes("application/x-www-form-urlencoded")) {
+                    const formParams = new URLSearchParams(rawBody);
+                    for (const [k, v] of formParams.entries()) {
+                        if (v !== "")
+                            input[k] = v;
+                    }
+                }
+                else if (rawBody) {
+                    try {
+                        const parsed = JSON.parse(rawBody);
+                        input =
+                            parsed && typeof parsed.input === "object" && parsed.input !== null
+                                ? parsed.input
+                                : parsed;
+                    }
+                    catch {
+                        input = {};
+                    }
+                }
+                const submitted = await submitMuxoConnectLink(token, input, {
+                    workspaceId,
+                    providerSlug,
+                    callbackUrl,
+                    connectedAccountId,
+                });
+                const wantsJson = url.searchParams.get("format") === "json" ||
+                    String(req.headers.accept || "").includes("application/json") ||
+                    contentType.includes("application/json");
+                if (wantsJson) {
+                    sendJson(res, submitted.ok ? 200 : 400, {
+                        ok: submitted.ok,
+                        status: submitted.status,
+                        redirectUrl: submitted.redirectUrl,
+                        redirect_url: submitted.redirectUrl,
+                        connectedAccountId: submitted.connectedAccountId,
+                        ...(submitted.error ? { error: submitted.error } : {}),
+                    });
+                    return;
+                }
+                if (submitted.ok && submitted.redirectUrl) {
+                    res.writeHead(302, { Location: submitted.redirectUrl });
+                    res.end();
+                    return;
+                }
+                const meta = await fetchMuxoConnectLinkMetadata(token, {
+                    workspaceId,
+                    providerSlug,
+                    callbackUrl,
+                    connectedAccountId,
+                });
+                res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+                res.end(renderOAuthConnectPageHtml({
+                    token: meta.token,
+                    toolkitSlug: meta.toolkitSlug,
+                    toolkitName: meta.toolkitName,
+                    workspaceId,
+                    authMode: meta.authMode,
+                    status: meta.status,
+                    callbackUrl: meta.callbackUrl || callbackUrl,
+                    expectedInputFields: meta.expectedInputFields,
+                    error: submitted.error || "Could not start authorization handoff.",
+                }));
                 return;
             }
             // One-click Plan Approval Handoff Page (GET /approve/:planId)
@@ -1151,8 +1473,9 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                         "Cache-Control": "no-cache",
                         Connection: "keep-alive",
                         "Mcp-Session-Id": sessionId,
+                        "MCP-Protocol-Version": LATEST_MCP_PROTOCOL_VERSION,
                         "Access-Control-Allow-Origin": "*",
-                        "Access-Control-Expose-Headers": "Mcp-Session-Id",
+                        "Access-Control-Expose-Headers": "Mcp-Session-Id, MCP-Protocol-Version",
                     });
                     if (req.method !== "HEAD") {
                         res.write(`event: endpoint\ndata: ${JSON.stringify({ uri: `${config.baseUrl}/mcp`, sessionId })}\n\n`);
@@ -1163,15 +1486,20 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 sendJson(res, 200, {
                     ok: true,
                     transport: "streamable-http",
-                    protocolVersion: "2025-06-18",
+                    protocolVersion: LATEST_MCP_PROTOCOL_VERSION,
+                    supportedVersions: [...SUPPORTED_MCP_PROTOCOL_VERSIONS],
                     serverInfo: {
                         name: "muxo-mcp-server",
+                        title: "Muxo Unified Agent Runtime & Governance MCP Server",
                         version: MUXO_VERSION,
                     },
                     instructions: MUXO_MCP_SERVER_INSTRUCTIONS,
                     toolsCount: MUXO_MCP_TOOLS.length,
                     skillsCount: getMuxoMcpSkills().length,
-                }, { "Mcp-Session-Id": sessionId });
+                }, {
+                    "Mcp-Session-Id": sessionId,
+                    "MCP-Protocol-Version": LATEST_MCP_PROTOCOL_VERSION,
+                });
                 return;
             }
             if (pathname === "/mcp" && req.method === "DELETE") {
@@ -1184,15 +1512,39 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
             if (pathname === "/mcp" && req.method === "POST") {
                 const raw = await readBody(req);
                 const parsed = JSON.parse(raw || "{}");
+                const headerCheck = !Array.isArray(parsed)
+                    ? validateMcpHttpHeadersAndMeta({
+                        protocolVersion: String(req.headers["mcp-protocol-version"] || ""),
+                        method: String(req.headers["mcp-method"] || ""),
+                        name: String(req.headers["mcp-name"] || ""),
+                    }, parsed)
+                    : { ok: true, protocolVersion: LATEST_MCP_PROTOCOL_VERSION };
+                if (!headerCheck.ok) {
+                    const fallbackSessionId = String(req.headers["mcp-session-id"] || "") ||
+                        `mcp_sess_${crypto.randomBytes(6).toString("hex")}`;
+                    sendJson(res, 200, {
+                        jsonrpc: "2.0",
+                        id: headerCheck.id,
+                        error: headerCheck.error,
+                    }, {
+                        "Mcp-Session-Id": fallbackSessionId,
+                        "MCP-Protocol-Version": LATEST_MCP_PROTOCOL_VERSION,
+                    });
+                    return;
+                }
                 const resolved = await requireContext(req, res, pathname, !Array.isArray(parsed) && isPublicMcpRequest(parsed));
                 if (!resolved)
                     return;
                 const { ctx } = resolved;
                 const sessionId = String(req.headers["mcp-session-id"] || "") ||
                     `mcp_sess_${ctx.workspace.id}`;
+                const responseHeaders = {
+                    "Mcp-Session-Id": sessionId,
+                    "MCP-Protocol-Version": headerCheck.protocolVersion,
+                };
                 if (Array.isArray(parsed)) {
                     const responses = (await Promise.all(parsed.map((item) => handleJsonRpcMcpRequest(engine, ctx, (item || {}))))).filter((r) => r !== null);
-                    sendJson(res, 200, responses, { "Mcp-Session-Id": sessionId });
+                    sendJson(res, 200, responses, responseHeaders);
                     return;
                 }
                 const rpc = parsed;
@@ -1200,12 +1552,12 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 if (!response) {
                     res.writeHead(202, {
                         "Access-Control-Allow-Origin": "*",
-                        "Mcp-Session-Id": sessionId,
+                        ...responseHeaders,
                     });
                     res.end();
                     return;
                 }
-                sendJson(res, 200, response, { "Mcp-Session-Id": sessionId });
+                sendJson(res, 200, response, responseHeaders);
                 return;
             }
             // Auth Endpoints
@@ -1263,7 +1615,11 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
             const isPublicRoute = ((pathname === "/api/v1/tools" || pathname === "/v1/tools/search") &&
                 (req.method === "GET" || req.method === "POST")) ||
                 (pathname.startsWith("/api/v1/tools/") && req.method === "GET") ||
-                (pathname === "/api/v1/billing/webhook" && req.method === "POST");
+                (pathname === "/api/v1/billing/webhook" && req.method === "POST") ||
+                ((pathname === "/webhooks" ||
+                    pathname === "/webhooks/composio" ||
+                    pathname === "/api/v1/triggers/webhook") &&
+                    req.method === "POST");
             const resolvedCtx = await requireContext(req, res, pathname, isPublicRoute);
             if (!resolvedCtx)
                 return;
@@ -1277,6 +1633,7 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                     profile: engine.getProfile(ctx),
                     organization: org,
                     governance: engine.governance.getStatus(),
+                    llmPolicyBrief: guardrailsSummary.llmPolicyBrief,
                     plainEnglishGuardrails: guardrailsSummary.plainEnglish,
                     activeMemoryDefaults: guardrailsSummary.activeDefaults,
                     activeGuardrails: guardrailsSummary.activeGuardrails,
@@ -1451,6 +1808,7 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                         auditChain: fullReport.auditChain,
                     },
                     workspacePolicy: ws.policy,
+                    llmPolicyBrief: guardrailsSummary.llmPolicyBrief,
                     plainEnglishGuardrails: guardrailsSummary.plainEnglish,
                     activeMemoryDefaults: guardrailsSummary.activeDefaults,
                     activeGuardrails: guardrailsSummary.activeGuardrails,
@@ -1465,16 +1823,37 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 });
                 return;
             }
+            if ((pathname === "/api/v1/guardrails/reset" || pathname === "/api/v1/policy/reset") &&
+                req.method === "POST") {
+                const resetResult = await engine.resetWorkspaceGuardrails(ctx);
+                sendJson(res, 200, {
+                    ...resetResult,
+                    humanMessage: "Reset workspace guardrails to Safe Default.",
+                });
+                return;
+            }
+            if ((pathname === "/api/v1/guardrails/check" ||
+                pathname === "/api/v1/guardrails/simulate" ||
+                pathname === "/api/v1/policy/check") &&
+                req.method === "POST") {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const toolSlug = String(body.tool_slug || body.toolSlug || body.slug || body.tool_id || "instant.web.search").trim();
+                const input = (body.input || body.arguments) || {};
+                const result = await engine.checkToolPolicy(ctx, { toolSlug, input });
+                const summary = engine.getGuardrailsSummary(ctx);
+                sendJson(res, 200, {
+                    ...result,
+                    simulation: result,
+                    llmPolicyBrief: summary.llmPolicyBrief,
+                });
+                return;
+            }
             if (pathname === "/api/v1/guardrails" && req.method === "POST") {
                 const body = JSON.parse((await readBody(req)) || "{}");
                 if (body.reset === true) {
-                    const updated = store.updateWorkspacePolicy(ctx.workspace.id, DEFAULT_WORKSPACE_POLICY);
-                    const plainEnglish = describePolicyInPlainEnglish(updated.policy);
+                    const resetResult = await engine.resetWorkspaceGuardrails(ctx);
                     sendJson(res, 200, {
-                        ok: true,
-                        workspace: updated,
-                        policy: updated.policy,
-                        plainEnglish,
+                        ...resetResult,
                         humanMessage: "Reset workspace guardrails to Safe Default.",
                     });
                     return;
@@ -2968,52 +3347,143 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
             }
             if (pathname === "/api/v1/triggers" && req.method === "GET") {
                 const provider = url.searchParams.get("provider") || undefined;
+                const triggerSlug = url.searchParams.get("triggerSlug") || url.searchParams.get("trigger_slug") || undefined;
+                const composioByok = store.getByokKey(ctx.workspace.id, "composio");
                 const available = engine.composioSdk.listTriggerTypes(provider);
                 const subscriptions = engine.composioSdk.listActiveTriggers(ctx.workspace.id);
                 const events = engine.composioSdk.listTriggerEvents(ctx.workspace.id, 25);
+                const triggerType = triggerSlug
+                    ? await engine.composioSdk.getTriggerType(triggerSlug, composioByok)
+                    : undefined;
                 sendJson(res, 200, {
                     ok: true,
                     availableTriggers: available,
                     activeSubscriptions: subscriptions,
                     recentEvents: events,
+                    webhookConfig: engine.composioSdk.getWebhookConfigInfo(),
+                    ...(triggerType ? { triggerType } : {}),
                 });
                 return;
             }
             if (pathname === "/api/v1/triggers" && req.method === "POST") {
                 const composioByok = store.getByokKey(ctx.workspace.id, "composio");
                 const body = JSON.parse((await readBody(req)) || "{}");
+                const rawConfig = body.triggerConfig && typeof body.triggerConfig === "object"
+                    ? body.triggerConfig
+                    : body.config && typeof body.config === "object"
+                        ? body.config
+                        : {};
                 const subscription = await engine.composioSdk.enableTrigger({
                     workspaceId: ctx.workspace.id,
+                    userId: body.userId ? String(body.userId) : undefined,
                     triggerSlug: String(body.triggerSlug || body.trigger_slug || "GITHUB_COMMIT_EVENT"),
                     providerSlug: String(body.providerSlug || body.provider || "github"),
                     connectedAccountId: body.connectedAccountId
                         ? String(body.connectedAccountId)
                         : undefined,
                     webhookUrl: body.webhookUrl ? String(body.webhookUrl) : undefined,
-                    config: body.config && typeof body.config === "object" ? body.config : {},
+                    config: rawConfig,
+                    subscribe: body.subscribe === true,
                     composioApiKey: composioByok,
                 });
                 sendJson(res, 201, { ok: true, subscription });
                 return;
             }
-            if (pathname === "/api/v1/triggers/webhook" && req.method === "POST") {
-                const body = JSON.parse((await readBody(req)) || "{}");
-                const triggerSlug = String(body.triggerSlug || body.type || "GITHUB_COMMIT_EVENT").toUpperCase();
-                const providerSlug = String(body.providerSlug || triggerSlug.split("_")[0] || "github").toLowerCase();
-                const payloadObj = body.payload && typeof body.payload === "object"
-                    ? body.payload
-                    : body;
-                const rawPayloadText = JSON.stringify(payloadObj);
+            if ((pathname === "/api/v1/triggers/webhook" ||
+                pathname === "/webhooks" ||
+                pathname === "/webhooks/composio") &&
+                req.method === "POST") {
+                const rawBody = await readBody(req);
+                const sigHeader = String(req.headers["webhook-signature"] ||
+                    req.headers["x-composio-webhook-signature"] ||
+                    "").trim();
+                const webhookIdHeader = String(req.headers["webhook-id"] || req.headers["x-composio-webhook-id"] || "").trim();
+                const webhookTimestampHeader = String(req.headers["webhook-timestamp"] ||
+                    req.headers["x-composio-webhook-timestamp"] ||
+                    "").trim();
+                const webhookVersionHeader = String(req.headers["x-composio-webhook-version"] || "").trim();
+                let signatureVerified = false;
+                if (sigHeader) {
+                    const check = await verifyComposioWebhookSignature({
+                        rawPayload: rawBody,
+                        signatureHeader: sigHeader,
+                        webhookIdHeader,
+                        webhookTimestampHeader,
+                        secret: config.composioWebhookSecret,
+                    });
+                    if (config.composioWebhookSecret && !check.verified) {
+                        sendJson(res, 401, {
+                            ok: false,
+                            error: `Invalid Composio webhook signature (${check.reason || "verification_failed"})`,
+                        });
+                        return;
+                    }
+                    signatureVerified = check.verified;
+                }
+                const body = JSON.parse(rawBody || "{}");
+                const envelope = parseComposioWebhookEnvelope(body, {
+                    webhookId: webhookIdHeader || undefined,
+                    webhookTimestamp: webhookTimestampHeader || undefined,
+                    webhookVersion: webhookVersionHeader || undefined,
+                });
+                let targetWorkspaceId = ctx.workspace.id;
+                if (envelope.userId && store.getWorkspace(envelope.userId)) {
+                    targetWorkspaceId = envelope.userId;
+                }
+                if (envelope.eventType === "composio.connected_account.activated" ||
+                    envelope.eventType === "composio.connected_account.expired") {
+                    const nextStatus = envelope.eventType === "composio.connected_account.activated"
+                        ? "active"
+                        : "expired";
+                    store.upsertConnection({
+                        workspaceId: targetWorkspaceId,
+                        lane: "composio_sdk",
+                        providerSlug: envelope.providerSlug,
+                        providerName: envelope.providerSlug.charAt(0).toUpperCase() +
+                            envelope.providerSlug.slice(1),
+                        status: nextStatus,
+                        externalAccountId: envelope.connectedAccountId || null,
+                        metadata: {
+                            webhookEvent: envelope.eventType,
+                            webhookId: envelope.webhookId,
+                            updatedViaWebhookAt: new Date().toISOString(),
+                        },
+                    });
+                    if (nextStatus === "expired") {
+                        engine.composioSdk.disableTriggersMatching({
+                            workspaceId: targetWorkspaceId,
+                            connectedAccountId: envelope.connectedAccountId,
+                        });
+                    }
+                }
+                else if (envelope.eventType === "composio.trigger.disabled") {
+                    engine.composioSdk.disableTriggersMatching({
+                        workspaceId: targetWorkspaceId,
+                        triggerId: envelope.triggerId,
+                        triggerSlug: envelope.triggerSlug,
+                        connectedAccountId: envelope.connectedAccountId,
+                    });
+                }
+                const rawPayloadText = JSON.stringify(envelope.payloadObj);
                 const injectionScan = engine.governance.scanMemoryContent({
-                    workspaceId: ctx.workspace.id,
+                    workspaceId: targetWorkspaceId,
                     content: rawPayloadText,
                 });
                 const disposition = injectionScan.safe ? "dispatched" : "quarantined";
                 const eventRecord = {
                     id: `trgevt_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
-                    workspaceId: ctx.workspace.id,
-                    triggerSlug,
-                    providerSlug,
+                    workspaceId: targetWorkspaceId,
+                    eventType: envelope.eventType,
+                    webhookVersion: envelope.webhookVersion,
+                    signatureVerified,
+                    webhookId: envelope.webhookId,
+                    triggerId: envelope.triggerId,
+                    triggerSlug: envelope.triggerSlug,
+                    providerSlug: envelope.providerSlug,
+                    connectedAccountId: envelope.connectedAccountId,
+                    userId: envelope.userId,
+                    projectId: envelope.projectId,
+                    orgId: envelope.orgId,
                     receivedAt: new Date().toISOString(),
                     promptInjectionScan: {
                         safe: injectionScan.safe,
@@ -3021,7 +3491,7 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                         findings: injectionScan.findings.map((f) => `${f.patternId}: ${f.description}`),
                     },
                     disposition: disposition,
-                    payloadPreview: payloadObj,
+                    payloadPreview: envelope.payloadObj,
                 };
                 engine.composioSdk.recordTriggerEvent(eventRecord);
                 sendJson(res, injectionScan.safe ? 200 : 202, {