@muxoai/sdk 1.4.2 → 1.4.4

package/dist/index.d.ts

@@ -1,6 +1,9 @@
 export { getConfig, ROOT_DIR, type MuxoConfig } from "./config.js";
+export * from "./durable-workflow.js";
 export { MuxoEngine, type ExecutionContext } from "./engine.js";
 export { handleJsonRpcMcpRequest, MUXO_MCP_TOOLS, type McpToolDefinition } from "./mcp.js";
+export * from "./memory-graph.js";
+export * from "./oss-suite.js";
 export { MuxoClient, type MuxoClientOptions } from "./sdk.js";
 export { createMuxoServer } from "./server.js";
 export { MuxoStore } from "./store.js";

package/dist/index.js

@@ -1,6 +1,9 @@
 export { getConfig, ROOT_DIR } from "./config.js";
+export * from "./durable-workflow.js";
 export { MuxoEngine } from "./engine.js";
 export { handleJsonRpcMcpRequest, MUXO_MCP_TOOLS } from "./mcp.js";
+export * from "./memory-graph.js";
+export * from "./oss-suite.js";
 export { MuxoClient } from "./sdk.js";
 export { createMuxoServer } from "./server.js";
 export { MuxoStore } from "./store.js";

package/dist/mcp-schema.d.ts

@@ -202,6 +202,20 @@ export interface ApprovalGatePlan {
     toolSlug: string;
     riskLevel: string;
     approvalStatus: string;
+    creditCost?: number;
+    estimatedCostUsd?: number;
+    changePreview?: {
+        whatChanges: string;
+        whoIsAffected: string;
+        targetEntity: string;
+        estimatedCostUsd: number;
+        creditCost: number;
+        fundingMode: "muxo_funded" | "byok";
+        costDisplay: string;
+        triggeredRule: string;
+        reversibility: string;
+        recoveryBehavior: string;
+    };
 }
 export declare function buildApprovalUrl(baseUrl: string, planId: string): string;
 export declare function buildApprovalHumanHandoff(baseUrl: string, plan: ApprovalGatePlan): HumanHandoff;

package/dist/mcp-schema.js

@@ -266,9 +266,16 @@ export const MUXO_MCP_RESOURCE_TEMPLATES = [
         uriTemplate: "skill://muxo/{skillName}/SKILL.md",
         name: "Muxo Agent Skill Markdown (SEP-2640)",
         title: "Muxo Agent Skill Markdown (SEP-2640)",
-        description: "Read the SKILL.md entry point for a published Muxo Agent Skill ('muxo' or 'setup').",
+        description: "Read the SKILL.md entry point for a published Muxo Agent Skill ('muxo', 'setup', or domain automation/provisioning skills such as 'github-automation', 'supabase-provisioning').",
         mimeType: "text/markdown",
     },
+    {
+        uriTemplate: "muxo://skills/{skillSlug}",
+        name: "Muxo Governed Domain & Workflow Skill (SKILL.md + Metadata)",
+        title: "Muxo Governed Domain & Workflow Skill (SKILL.md + Metadata)",
+        description: "Read a transpiled Muxo Governed Skill (e.g. muxo://skills/github-automation, muxo://skills/supabase-provisioning, muxo://skills/changelog-generator) with tool sequences, pitfalls, and zero-OAuth Stripe Projects overrides.",
+        mimeType: "application/json",
+    },
 ];
 /**
  * Evaluates MCP `completion/complete` requests for prompt arguments and resource templates.
@@ -280,8 +287,27 @@ export function completeMcpArgument(params, toolSlugs = []) {
     const argName = String(argObj.name || "").trim();
     const prefix = String(argObj.value || "").trim().toLowerCase();
     let candidates = [];
-    if (argName === "skillName" || argName === "name") {
-        candidates = ["muxo", "setup"];
+    if (argName === "skillName" || argName === "name" || argName === "skillSlug") {
+        candidates = [
+            "muxo",
+            "setup",
+            "github-automation",
+            "gmail-automation",
+            "slack-automation",
+            "notion-automation",
+            "linear-automation",
+            "hubspot-automation",
+            "salesforce-automation",
+            "shopify-automation",
+            "metaads-automation",
+            "stripe-automation",
+            "supabase-provisioning",
+            "vercel-provisioning",
+            "turso-provisioning",
+            "changelog-generator",
+            "lead-research-assistant",
+            "security-audit",
+        ];
     }
     else if (argName === "focus") {
         candidates = ["full", "pending_approvals", "billing", "receipts", "memory"];
@@ -631,8 +657,17 @@ export function buildApprovalHumanHandoff(baseUrl, plan) {
     const approvalUrl = buildApprovalUrl(baseUrl, plan.id);
     const ctaLabel = "Review & approve";
     const headline = `Muxo needs your approval to run ${plan.toolSlug}`;
-    const instructions = `Open ${approvalUrl} to review and approve this ${plan.riskLevel}-risk action with one click (or run \`muxo approve ${plan.id}\`). Nothing runs until you approve.`;
-    const markdownForUser = `### Muxo Approval Required\n**[${ctaLabel} in Muxo](${approvalUrl})**\n\nPlan \`${plan.id}\` (\`${plan.toolSlug}\` · **${plan.riskLevel} risk**) is held by your Muxo workspace guardrails. Open the link above to review and approve it in one click (or run \`muxo approve ${plan.id}\`). Nothing executes until you approve.`;
+    const preview = plan.changePreview;
+    const costSnippet = preview?.costDisplay
+        ? ` · Est. cost: ${preview.costDisplay}`
+        : typeof plan.creditCost === "number"
+            ? ` · Est. cost: $${((plan.creditCost || 0) * 0.01).toFixed(2)} USD (${plan.creditCost} cr)`
+            : "";
+    const instructions = `Open ${approvalUrl} to review and approve this ${plan.riskLevel}-risk action with one click (or run \`muxo approve ${plan.id}\`).${costSnippet} Nothing runs until you approve.`;
+    const previewMarkdown = preview
+        ? `\n\n- **What changes:** ${preview.whatChanges}\n- **Affected target:** ${preview.whoIsAffected}\n- **Estimated cost:** ${preview.costDisplay}\n- **Triggered guardrail:** ${preview.triggeredRule}`
+        : "";
+    const markdownForUser = `### Muxo Approval Required\n**[${ctaLabel} in Muxo](${approvalUrl})**\n\nPlan \`${plan.id}\` (\`${plan.toolSlug}\` · **${plan.riskLevel} risk**) is held by your Muxo workspace guardrails.${previewMarkdown}\n\nOpen the link above to review and approve it in one click (or run \`muxo approve ${plan.id}\`). Nothing executes until you approve.`;
     return {
         kind: "approval",
         brand: "Muxo",
@@ -1057,6 +1092,17 @@ export const MUXO_MCP_TOOLS = [
                         "set_guardrail",
                         "reset_guardrails",
                         "check_policy",
+                        "cedar_policy",
+                        "otel_traces",
+                        "roi_analytics",
+                        "playbooks",
+                        "create_playbook",
+                        "run_playbook",
+                        "rollback_workflow",
+                        "signal_workflow",
+                        "workflow_history",
+                        "configure_harness",
+                        "harness_presets",
                         "kill_switch",
                         "governance_status",
                         "scan_context",
@@ -1064,11 +1110,11 @@ export const MUXO_MCP_TOOLS = [
                         "switch_workspace",
                         "onboard_team",
                     ],
-                    description: "Control-plane operation: 'inspect' (default), 'remember' (save fact/preference), 'recall' (list memories), 'forget' (delete matching memories), 'memory_graph' (bi-temporal entity/relationship lineage), 'set_guardrail' (apply plain-English or structured parameter_rules guardrail), 'reset_guardrails' (restore default safe guardrails), 'check_policy' (dry-run evaluate tool_slug + input against policy and parameter guardrails before planning), 'kill_switch' (pause/resume agent execution), 'governance_status' (Microsoft 9-module status + LLM policy brief), 'scan_context' (OWASP ASI-06 check), 'list_workspaces', 'switch_workspace', or 'onboard_team'",
+                    description: "Control-plane operation (or omit action and pass any plain-English prompt): 'inspect' (default), 'remember' (save fact/preference), 'recall' (list memories), 'forget' (delete matching memories), 'memory_graph' (Graphiti bi-temporal entity/relationship lineage with optional as_of time-travel & focal_entity 2-hop BFS), 'set_guardrail' (apply plain-English or structured parameter_rules guardrail), 'reset_guardrails' (restore default safe guardrails), 'check_policy' (dry-run evaluate tool_slug + input against policy and parameter guardrails before planning), 'cedar_policy' (compile/evaluate AWS Cedar & OPA Rego policy-as-code), 'otel_traces' (export W3C OpenTelemetry GenAI/MCP spans & Langfuse batch), 'roi_analytics' (FinOps & BYOK unit-economics ROI report), 'playbooks' / 'create_playbook' / 'run_playbook' (list, author custom, or execute multi-step Temporal Saga playbooks), 'rollback_workflow' / 'signal_workflow' / 'workflow_history' (Temporal workflow lifecycle; accepts workflow_id='latest'), 'configure_harness' / 'harness_presets' (apply turnkey harness presets like startup-builder, strict-production, read-only-auditor, finops-byok-zero-cost and generate ready-to-paste harness config blocks), 'kill_switch' (pause/resume agent execution), 'governance_status' (Microsoft 9-module status + LLM policy brief), 'scan_context' (OWASP ASI-06 check), 'list_workspaces', 'switch_workspace', or 'onboard_team'",
                 },
                 prompt: {
                     type: "string",
-                    description: "Natural-language instruction when action is 'remember', 'set_guardrail', 'kill_switch', or 'scan_context' (e.g. 'Only allow sending emails to @muxo.ai' or 'Require approval for Stripe refunds over $50, auto-approve under $50')",
+                    description: "Plain-English instruction for any control-plane or OSS operation (e.g. 'Run the fullstack cloud bootstrap playbook for acme', 'Rollback the latest workflow because staging failed', 'Show my knowledge graph as of yesterday within 2 hops of workspace', 'Configure harness preset strict-production', or 'Only allow sending emails to @muxo.ai')",
                 },
                 tool_slug: {
                     type: "string",
@@ -1161,6 +1207,38 @@ export const MUXO_MCP_TOOLS = [
                     type: "boolean",
                     description: "If true, attach the Bi-Temporal Knowledge Graph (nodes, activeEdges, historicalEdges, mermaid) to the context response",
                 },
+                as_of: {
+                    type: "string",
+                    description: "Optional ISO-8601 timestamp for Graphiti point-in-time ('as-of') bi-temporal knowledge graph reconstruction",
+                },
+                focal_entity: {
+                    type: "string",
+                    description: "Optional entity ID or label for k-hop BFS neighborhood subgraph extraction",
+                },
+                max_hops: {
+                    type: "number",
+                    description: "Maximum BFS traversal hops around focal_entity (1 to 4, default 2)",
+                },
+                slug: {
+                    type: "string",
+                    description: "Optional playbook slug or natural-language name when action='run_playbook' (e.g. 'fullstack-cloud-bootstrap', 'competitor-seo-growth-brief', 'incident-containment-audit', 'customer-release-readiness')",
+                },
+                workflow_id: {
+                    type: "string",
+                    description: "Workflow ID or 'latest' when action is 'rollback_workflow', 'signal_workflow', or 'workflow_history'",
+                },
+                signal_name: {
+                    type: "string",
+                    description: "Temporal signal name when action='signal_workflow' (default: 'human.approval.granted')",
+                },
+                preset: {
+                    type: "string",
+                    description: "Turnkey harness preset slug when action='configure_harness' ('startup-builder', 'strict-production', 'read-only-auditor', 'finops-byok-zero-cost')",
+                },
+                harness: {
+                    type: "string",
+                    description: "Target agent harness when action='configure_harness' ('claude-code', 'cursor', 'codex', 'chatgpt', 'claude-desktop', 'factory-droid', or 'all')",
+                },
                 plan_id: {
                     type: "string",
                     description: "Optional plan ID to inspect context for",

package/dist/mcp.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { ROOT_DIR } from "./config.js";
 import { APPROVED_PLAN_STATUSES, DEFAULT_LEGACY_MCP_PROTOCOL_VERSION, DEFAULT_TOOL_SECURITY_SCHEMES, LATEST_MCP_PROTOCOL_VERSION, MCP_ERR_HEADER_MISMATCH, MCP_ERR_MISSING_REQUIRED_CLIENT_CAPABILITY, MCP_ERR_UNSUPPORTED_PROTOCOL_VERSION, MUXO_MCP_RESOURCE_TEMPLATES, MUXO_MCP_SERVER_INSTRUCTIONS, MUXO_MCP_TOOLS, MUXO_UI_MCP_APP_URI, MUXO_UI_RESOURCES, MUXO_UI_WIDGET_URI, OPENAI_COMPANY_KNOWLEDGE_TOOLS, PUBLIC_MCP_TOOL_NAMES, PUBLIC_TOOL_SECURITY_SCHEMES, SUPPORTED_MCP_PROTOCOL_VERSIONS, UI_RENDERED_MCP_TOOL_NAMES, attachMcpHarnessGuidance, MuxoToolError, buildApprovalUrl, buildMcpDiscoverResult, buildMcpErrorResultMeta, buildMcpToolDescriptor, buildMcpToolResultMeta, buildOnboardTeamGuide, clampWaitSeconds, completeMcpArgument, decodeMcpHeaderValue, errorPayloadFrom, extractOpenAiClientMeta, findMcpSkill, isSupportedMcpProtocolVersion, renderMuxoUiWidgetHtml, securitySchemesForTool, validateMcpHttpHeadersAndMeta, } from "./mcp-schema.js";
+import { buildMuxoMcpSkillBundles, getMuxoSkill, listMuxoSkills, renderMuxoSkillMarkdown, } from "./skills-catalog.js";
 import { MUXO_VERSION } from "./version.js";
 export { DEFAULT_LEGACY_MCP_PROTOCOL_VERSION, DEFAULT_TOOL_SECURITY_SCHEMES, LATEST_MCP_PROTOCOL_VERSION, MCP_ERR_HEADER_MISMATCH, MCP_ERR_MISSING_REQUIRED_CLIENT_CAPABILITY, MCP_ERR_UNSUPPORTED_PROTOCOL_VERSION, MUXO_MCP_RESOURCE_TEMPLATES, MUXO_MCP_SERVER_INSTRUCTIONS, MUXO_MCP_TOOLS, MUXO_UI_MCP_APP_URI, MUXO_UI_RESOURCES, MUXO_UI_WIDGET_URI, OPENAI_COMPANY_KNOWLEDGE_TOOLS, PUBLIC_MCP_TOOL_NAMES, PUBLIC_TOOL_SECURITY_SCHEMES, SUPPORTED_MCP_PROTOCOL_VERSIONS, UI_RENDERED_MCP_TOOL_NAMES, attachMcpHarnessGuidance, buildMcpDiscoverResult, buildMcpErrorResultMeta, buildMcpToolDescriptor, buildMcpToolResultMeta, completeMcpArgument, decodeMcpHeaderValue, extractOpenAiClientMeta, isSupportedMcpProtocolVersion, renderMuxoUiWidgetHtml, securitySchemesForTool, validateMcpHttpHeadersAndMeta, };
 function sha256Digest(content) {
@@ -123,6 +124,24 @@ Call \`get_profile\` and \`get_organization\` to verify your workspace connectio
     const setupName = setupFm.name || "setup";
     const setupDesc = setupFm.description ||
         "Guided onboarding skill for setting up the Muxo plugin in OpenAI ChatGPT and Codex.";
+    const catalogBundles = buildMuxoMcpSkillBundles().map((bundle) => {
+        const fileEntries = bundle.files.map((f) => ({
+            path: f.path,
+            uri: f.uri,
+            size: Buffer.byteLength(f.content, "utf8"),
+            digest: sha256Digest(f.content),
+            mimeType: f.mimeType,
+            content: f.content,
+        }));
+        return {
+            name: bundle.name,
+            description: bundle.description,
+            uri: bundle.uri,
+            version: fileEntries[0].digest,
+            frontmatter: bundle.frontmatter,
+            files: fileEntries,
+        };
+    });
     return [
         {
             name: muxoName,
@@ -146,6 +165,7 @@ Call \`get_profile\` and \`get_organization\` to verify your workspace connectio
             },
             files: setupFiles,
         },
+        ...catalogBundles,
     ];
 }
 export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
@@ -223,8 +243,102 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
                 : Array.isArray(args.parameterRules)
                     ? args.parameterRules
                     : undefined;
+            const asOf = args.as_of || args.asOf ? String(args.as_of || args.asOf) : null;
+            const focalEntity = args.focal_entity || args.focalEntity
+                ? String(args.focal_entity || args.focalEntity)
+                : null;
+            const rawMaxHops = args.max_hops ?? args.maxHops;
+            const maxHops = rawMaxHops !== undefined && rawMaxHops !== null
+                ? Number(rawMaxHops)
+                : undefined;
             if (action === "memory_graph") {
-                return engine.getMemoryGraph(ctx, query);
+                return engine.getMemoryGraph(ctx, {
+                    query,
+                    asOf,
+                    focalEntity,
+                    maxHops,
+                });
+            }
+            if (action === "cedar_policy" || action === "policy_as_code") {
+                if (args.tool_slug || args.slug) {
+                    return engine.evaluatePolicyAsCode(ctx, {
+                        toolSlug: String(args.tool_slug || args.slug),
+                        input: (args.input || args.arguments) || {},
+                    });
+                }
+                return engine.getPolicyAsCodeBundle(ctx);
+            }
+            if (action === "otel_traces" || action === "telemetry") {
+                return engine.exportOtelTraces(ctx, Number(args.limit || 25));
+            }
+            if (action === "roi_analytics" || action === "roi") {
+                return engine.getCommercialRoiReport(ctx);
+            }
+            if (action === "playbooks") {
+                return {
+                    ok: true,
+                    playbooks: engine.listCommercialPlaybooks(ctx),
+                };
+            }
+            if (action === "create_playbook") {
+                return engine.createCustomPlaybook(ctx, {
+                    prompt: prompt || query || String(args.slug || ""),
+                    input: (args.input || args.arguments) || {},
+                });
+            }
+            if (action === "run_playbook") {
+                const slug = String(args.slug ||
+                    args.playbook ||
+                    query ||
+                    prompt ||
+                    "fullstack-cloud-bootstrap").trim();
+                return engine.runCommercialPlaybook(ctx, {
+                    slug,
+                    input: (args.input || args.arguments) || {},
+                });
+            }
+            if (action === "rollback_workflow") {
+                const wfId = String(args.workflow_id || args.workflowId || args.slug || query || "latest").trim();
+                const rolledBack = engine.rollbackDurableWorkflow(ctx, wfId, {
+                    reason: prompt || query || undefined,
+                });
+                return {
+                    ok: true,
+                    action: "rollback_workflow",
+                    workflow: rolledBack,
+                };
+            }
+            if (action === "signal_workflow") {
+                const wfId = String(args.workflow_id || args.workflowId || args.slug || "latest").trim();
+                const signalName = String(args.signal_name ||
+                    args.signalName ||
+                    query ||
+                    "human.approval.granted").trim();
+                const signaled = engine.signalDurableWorkflow(ctx, wfId, {
+                    signalName,
+                    payload: (args.input || args.arguments) || {},
+                });
+                return {
+                    ok: true,
+                    action: "signal_workflow",
+                    workflow: signaled,
+                };
+            }
+            if (action === "workflow_history") {
+                const wfId = String(args.workflow_id || args.workflowId || args.slug || query || "latest").trim();
+                return {
+                    ok: true,
+                    action: "workflow_history",
+                    workflow: engine.getDurableWorkflow(ctx, wfId),
+                    history: engine.getDurableWorkflowHistory(ctx, wfId),
+                };
+            }
+            if (action === "configure_harness" || action === "harness_presets") {
+                return engine.configureHarness(ctx, {
+                    preset: args.preset ? String(args.preset) : query || null,
+                    harness: args.harness ? String(args.harness) : null,
+                    prompt: prompt || null,
+                });
             }
             if (action === "governance_status") {
                 return engine.getGovernanceOverview(ctx);
@@ -338,12 +452,21 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
                     explanation: overview.explanation,
                 };
             }
-            if (prompt && !action) {
-                return engine.doNaturalLanguage(ctx, { prompt });
+            if (prompt && (!action || action === "inspect")) {
+                return engine.doNaturalLanguage(ctx, {
+                    prompt,
+                    input: (args.input || args.arguments) ||
+                        undefined,
+                });
             }
             const runCtx = await engine.getRunContext(ctx, query);
             if (args.include_graph === true) {
-                const memoryGraph = await engine.getMemoryGraph(ctx, query);
+                const memoryGraph = await engine.getMemoryGraph(ctx, {
+                    query,
+                    asOf,
+                    focalEntity,
+                    maxHops,
+                });
                 return { ...runCtx, memoryGraph };
             }
             return runCtx;
@@ -425,7 +548,16 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
             return engine.forgetWorkspaceMemoryMatching(ctx, query);
         }
         case "memory_graph":
-            return engine.getMemoryGraph(ctx, args.query ? String(args.query) : undefined);
+            return engine.getMemoryGraph(ctx, {
+                query: args.query ? String(args.query) : undefined,
+                asOf: args.as_of || args.asOf ? String(args.as_of || args.asOf) : null,
+                focalEntity: args.focal_entity || args.focalEntity
+                    ? String(args.focal_entity || args.focalEntity)
+                    : null,
+                maxHops: args.max_hops !== undefined || args.maxHops !== undefined
+                    ? Number(args.max_hops ?? args.maxHops)
+                    : undefined,
+            });
         case "set_guardrail":
         case "configure_guardrails": {
             const rawParamRules = Array.isArray(args.parameter_rules)
@@ -674,6 +806,35 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                             description: "Load the structured LLM Policy & Governance Brief (riskLaneMatrix, conditional parameterRules with compliance guidance, budget caps, kill switch status, and control-plane commands).",
                             arguments: [],
                         },
+                        {
+                            name: "harness_setup",
+                            title: "Turnkey Agent Harness Configuration & Natural-Language Cheatsheet",
+                            description: "Generate ready-to-paste MCP configuration snippets, system prompt directives, turnkey governance presets (startup-builder, strict-production, read-only-auditor, finops-byok-zero-cost), and natural-language cheatsheets for Claude Code, Cursor, Codex, ChatGPT, Claude Desktop, and Factory Droid.",
+                            arguments: [
+                                {
+                                    name: "preset",
+                                    description: "Optional preset slug ('startup-builder', 'strict-production', 'read-only-auditor', 'finops-byok-zero-cost')",
+                                    required: false,
+                                },
+                                {
+                                    name: "harness",
+                                    description: "Optional target harness ('claude-code', 'cursor', 'codex', 'chatgpt', 'claude-desktop', 'factory-droid')",
+                                    required: false,
+                                },
+                            ],
+                        },
+                        {
+                            name: "commercial_playbook",
+                            title: "Multi-Step Temporal Saga Playbook Runner & Author",
+                            description: "List, create, or execute multi-step Temporal-compatible Saga playbooks with automatic LIFO rollback compensations.",
+                            arguments: [
+                                {
+                                    name: "playbook",
+                                    description: "Playbook slug or plain-English description (e.g. 'fullstack-cloud-bootstrap', 'competitor-seo-growth-brief', 'incident-containment-audit', 'customer-release-readiness')",
+                                    required: false,
+                                },
+                            ],
+                        },
                     ],
                 },
             };
@@ -782,6 +943,59 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     },
                 };
             }
+            if (promptName === "harness_setup") {
+                const bundle = await engine.configureHarness(ctx, {
+                    preset: promptArgs.preset ? String(promptArgs.preset) : null,
+                    harness: promptArgs.harness ? String(promptArgs.harness) : null,
+                });
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        description: "Turnkey Agent Harness Configuration, Presets, and Natural-Language Cheatsheet",
+                        messages: [
+                            {
+                                role: "user",
+                                content: {
+                                    type: "text",
+                                    text: [
+                                        bundle.systemPromptDirective,
+                                        `### Harness Configuration Bundle (JSON)\n\`\`\`json\n${JSON.stringify(bundle, null, 2)}\n\`\`\``,
+                                    ].join("\n\n"),
+                                },
+                            },
+                        ],
+                    },
+                };
+            }
+            if (promptName === "commercial_playbook") {
+                const playbooks = engine.listCommercialPlaybooks(ctx);
+                const requested = promptArgs.playbook ? String(promptArgs.playbook) : "";
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        description: "Multi-Step Temporal Saga Playbook Runner & Author",
+                        messages: [
+                            {
+                                role: "user",
+                                content: {
+                                    type: "text",
+                                    text: [
+                                        `# Muxo Multi-Step Temporal Saga Playbooks`,
+                                        requested
+                                            ? `Requested Playbook: **${requested}** — call \`get_run_context({ prompt: "Run the ${requested} playbook" })\` or \`get_run_context({ action: "run_playbook", slug: "${requested}" })\`.`
+                                            : `Call \`get_run_context({ prompt: "Run the fullstack cloud bootstrap playbook" })\` or create a custom playbook in plain English with \`get_run_context({ prompt: "Create playbook daily-seo-slack that runs instant.seo.audit and app.slack.send_message" })\`.`,
+                                        `### Available Playbooks (${playbooks.length})\n\`\`\`json\n${JSON.stringify(playbooks, null, 2)}\n\`\`\``,
+                                    ].join("\n\n"),
+                                },
+                            },
+                        ],
+                    },
+                };
+            }
             return {
                 jsonrpc: "2.0",
                 id,
@@ -968,6 +1182,24 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     description: "Tamper-evident SHA-256 + portable Ed25519 AgenticReceipt chain verification report.",
                     mimeType: "application/json",
                 },
+                {
+                    uri: "muxo://harness/config",
+                    name: "Turnkey Agent Harness Configuration & Presets",
+                    description: "Ready-to-paste MCP config snippets, system prompt directives, turnkey governance presets, and natural-language cheatsheet for Claude Code, Cursor, Codex, ChatGPT, Claude Desktop, and Factory Droid.",
+                    mimeType: "application/json",
+                },
+                {
+                    uri: "muxo://playbooks",
+                    name: "Multi-Step Temporal Saga Playbooks",
+                    description: "Turnkey and custom workspace Temporal-compatible Saga playbooks with LIFO rollback compensation actions.",
+                    mimeType: "application/json",
+                },
+                {
+                    uri: "muxo://skills",
+                    name: "Muxo Governed Domain & Workflow Skills Catalog",
+                    description: "Catalog of transpiled domain automation, zero-OAuth cloud infrastructure (Stripe Projects), and multi-app workflow skills with pitfalls and tool sequences.",
+                    mimeType: "application/json",
+                },
             ];
             return {
                 jsonrpc: "2.0",
@@ -1159,6 +1391,94 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     },
                 };
             }
+            if (uri === "muxo://harness/config") {
+                const bundle = await engine.configureHarness(ctx);
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
+                        contents: [
+                            {
+                                uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify(bundle, null, 2),
+                            },
+                        ],
+                    },
+                };
+            }
+            if (uri === "muxo://playbooks") {
+                const playbooks = engine.listCommercialPlaybooks(ctx);
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
+                        contents: [
+                            {
+                                uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify({ ok: true, playbooks }, null, 2),
+                            },
+                        ],
+                    },
+                };
+            }
+            if (uri === "muxo://skills") {
+                const skills = listMuxoSkills();
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
+                        contents: [
+                            {
+                                uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify({ ok: true, count: skills.length, skills }, null, 2),
+                            },
+                        ],
+                    },
+                };
+            }
+            if (uri.startsWith("muxo://skills/")) {
+                const skillSlug = decodeURIComponent(uri.slice("muxo://skills/".length)).trim();
+                const skillDef = getMuxoSkill(skillSlug);
+                const markdown = renderMuxoSkillMarkdown(skillSlug);
+                if (!skillDef || !markdown) {
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        error: {
+                            code: -32602,
+                            message: `Resource not found: ${uri}`,
+                        },
+                    };
+                }
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        ttlMs: 300_000,
+                        cacheScope: "public",
+                        contents: [
+                            {
+                                uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify({ ok: true, skill: skillDef, markdown }, null, 2),
+                            },
+                        ],
+                    },
+                };
+            }
             if (uri.startsWith("muxo://tools/")) {
                 const slug = decodeURIComponent(uri.slice("muxo://tools/".length)).trim();
                 try {

package/dist/memory-graph.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionRecord, GovernancePolicy, MemoryKnowledgeGraph, ProvisionedResource, TemporalGraphFact } from "./types.js";
+import type { ConnectionRecord, GovernancePolicy, MemoryGraphEdge, MemoryGraphNode, MemoryKnowledgeGraph, ProvisionedResource, TemporalGraphFact } from "./types.js";
 export interface MemoryGraphInput {
     workspace: {
         id: string;
@@ -9,13 +9,37 @@ export interface MemoryGraphInput {
     };
     namespace: string;
     query?: string;
+    asOf?: string | null;
+    focalEntity?: string | null;
+    maxHops?: number;
     facts: TemporalGraphFact[];
     resources: Array<Pick<ProvisionedResource, "resourceName" | "status" | "providerName" | "serviceSlug">>;
     activeConnections: Array<Pick<ConnectionRecord, "id" | "providerSlug" | "providerName" | "createdAt">>;
     memoriesCount: number;
 }
 /**
- * Builds the bi-temporal knowledge graph (nodes, active/historical edges, Mermaid preview)
+ * Graphiti-style Point-in-Time ("As-Of") Bi-Temporal Fact Filter.
+ * Reconstructs which facts were active at `asOf` vs. already retired by `asOf`,
+ * excluding facts created after `asOf`.
+ */
+export declare function filterFactsAsOf(facts: TemporalGraphFact[], asOf?: string | null): {
+    scopedFacts: TemporalGraphFact[];
+    isActiveAtPointInTime: (fact: TemporalGraphFact) => boolean;
+};
+/**
+ * Graphiti-style Multi-Hop Subgraph Community Traversal (BFS).
+ * Finds all nodes and edges within `maxHops` (default 2) of a focal entity.
+ */
+export declare function traverseSubgraphBfs(nodes: MemoryGraphNode[], edges: MemoryGraphEdge[], focalQuery: string, maxHops?: number): {
+    focalEntity: string;
+    maxHops: number;
+    nodes: MemoryGraphNode[];
+    edges: MemoryGraphEdge[];
+    hopDistances: Record<string, number>;
+};
+/**
+ * Builds the Graphiti-inspired Bi-Temporal Knowledge Graph (nodes, active/historical edges,
+ * episodic provenance, point-in-time `asOf` time-travel, 2-hop BFS subgraph, and Mermaid preview)
  * from runtime-agnostic inputs so the Node engine and the Edge Worker render identical graphs.
  */
 export declare function buildMemoryKnowledgeGraph(input: MemoryGraphInput): MemoryKnowledgeGraph;