@muxoai/platform 1.3.1 → 1.3.2

package/dist/server.js

@@ -6,7 +6,9 @@ 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 { MuxoStore } from "./store.js";
-import { renderConsoleHtml, renderLandingHtml } from "./ui/console-html.js";
+import { sanitizePolicyPatch } from "./policy.js";
+import { MUXO_VERSION } from "./version.js";
+import { isConsolePath, renderConsoleHtml, renderLandingHtml } from "./ui/console-html.js";
 function renderSkillMarkdown(baseUrl) {
     return `---
 name: muxo
@@ -170,7 +172,7 @@ export function createMuxoServer(customConfig) {
                     ok: true,
                     status: "ready",
                     service: "muxo-platform",
-                    version: "1.3.1",
+                    version: MUXO_VERSION,
                     environment: "production",
                     live_execution: true,
                     customer_billing: true,
@@ -464,7 +466,7 @@ export function createMuxoServer(customConfig) {
                     openapi: "3.1.0",
                     info: {
                         title: "Muxo Unified Agent Execution, Infrastructure, Memory & Governance API",
-                        version: "1.3.1",
+                        version: MUXO_VERSION,
                         description: "One governed boundary over Connected Apps (Composio SDK), Instant Tools (Composio Instant), Cloud Infrastructure (Stripe Projects), Supermemory v5 Brain, and Microsoft Agent Governance Toolkit.",
                     },
                     servers: [{ url: config.baseUrl }],
@@ -634,12 +636,20 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 });
                 return;
             }
-            // Web Console UI (app.muxo.ai)
-            if ((pathname === "/" || pathname === "/console") && req.method === "GET") {
+            // Web Console UI (app.muxo.ai) & SPA deep-links
+            if (isConsolePath(pathname) && req.method === "GET") {
                 res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
                 res.end(renderConsoleHtml());
                 return;
             }
+            if (pathname === "/downloads/muxo-cli.zip" && req.method === "GET") {
+                res.writeHead(302, {
+                    Location: "https://muxo.ai/plugins/muxo-chatgpt-plugin.zip",
+                    "Cache-Control": "no-store",
+                });
+                res.end();
+                return;
+            }
             // Built-in Interactive Landing & Provider Canvas (muxo.ai)
             if (pathname === "/landing" && req.method === "GET") {
                 res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
@@ -753,8 +763,11 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
 </html>`);
                 return;
             }
-            // Autonomous Agent 2-Call Signup (agents.composio.dev pattern) — Public
-            if (pathname === "/api/v1/agents/signup" && req.method === "POST") {
+            // Autonomous Agent 2-Call Signup — Public
+            if ((pathname === "/api/v1/agents/signup" ||
+                pathname === "/api/v1/auth/signup" ||
+                pathname === "/api/signup") &&
+                req.method === "POST") {
                 const body = JSON.parse((await readBody(req)) || "{}");
                 const created = store.createAutonomousAgentSignup({
                     agentName: body.agentName ? String(body.agentName) : undefined,
@@ -805,7 +818,7 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                     protocolVersion: "2025-06-18",
                     serverInfo: {
                         name: "muxo-mcp-server",
-                        version: "1.3.1",
+                        version: MUXO_VERSION,
                     },
                     instructions: MUXO_MCP_SERVER_INSTRUCTIONS,
                     toolsCount: MUXO_MCP_TOOLS.length,
@@ -845,6 +858,10 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 return;
             }
             // Auth Endpoints
+            if (pathname === "/api/v1/auth/config" && req.method === "GET") {
+                sendJson(res, 200, { ok: true, provider: "password", clerk: null, signInUrl: "/login" });
+                return;
+            }
             if (pathname === "/api/v1/auth/register" && req.method === "POST") {
                 const body = JSON.parse((await readBody(req)) || "{}");
                 const created = store.registerUser({
@@ -853,7 +870,16 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                     password: String(body.password || ""),
                     workspaceName: body.workspaceName ? String(body.workspaceName) : undefined,
                 });
-                sendJson(res, 201, { ok: true, ...created });
+                const initialKey = store.createApiKey({
+                    workspaceId: created.workspace.id,
+                    name: "Default Live Key",
+                    environment: "live",
+                });
+                sendJson(res, 201, {
+                    ok: true,
+                    ...created,
+                    apiKey: initialKey.secretKey,
+                });
                 return;
             }
             if (pathname === "/api/v1/auth/login" && req.method === "POST") {
@@ -917,11 +943,49 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
             }
             // Microsoft Agent Governance Status & Audit Verification
             if (pathname === "/api/v1/governance" && req.method === "GET") {
+                const ws = store.getWorkspace(ctx.workspace.id) || ctx.workspace;
+                const fullReport = engine.governance.getGovernanceStatus(ws);
                 sendJson(res, 200, {
                     ok: true,
-                    governance: engine.governance.getStatus(),
-                    workspacePolicy: ctx.workspace.policy,
+                    governance: {
+                        ...engine.governance.getStatus(ws),
+                        modules: fullReport.modules,
+                        trustScore: fullReport.trustScore,
+                        killSwitch: fullReport.killSwitch,
+                        contextPoisoning: fullReport.contextPoisoning,
+                        auditChain: fullReport.auditChain,
+                    },
+                    workspacePolicy: ws.policy,
+                });
+                return;
+            }
+            if (pathname === "/api/v1/governance/kill-switch" && req.method === "POST") {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const action = String(body.action || "quarantine").toLowerCase();
+                if (action === "resume" || body.active === false) {
+                    const out = engine.resumeWorkspaceKillSwitch(ctx);
+                    sendJson(res, 200, { ok: true, ...out });
+                    return;
+                }
+                const out = await engine.activateWorkspaceKillSwitch(ctx, {
+                    reason: String(body.reason || "Emergency kill-switch activated by workspace operator"),
+                    action: action === "terminate" || action === "suspend"
+                        ? action
+                        : "quarantine",
+                });
+                sendJson(res, 200, { ok: true, ...out });
+                return;
+            }
+            if (pathname === "/api/v1/governance/scan-context" && req.method === "POST") {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const scan = engine.governance.scanMemoryContent({
+                    workspaceId: ctx.workspace.id,
+                    sessionId: String(body.sessionId || "default"),
+                    role: body.role || "user",
+                    content: String(body.content || ""),
+                    recordInDetector: Boolean(body.recordInDetector),
                 });
+                sendJson(res, 200, { ok: true, scan });
                 return;
             }
             // Supermemory v5 Workspace Brain Endpoints
@@ -933,6 +997,37 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 sendJson(res, 200, { ok: true, ...overview });
                 return;
             }
+            if (pathname === "/api/v1/memory/facts" && req.method === "GET") {
+                const query = url.searchParams.get("query") ||
+                    url.searchParams.get("q") ||
+                    undefined;
+                const includeHistorical = url.searchParams.get("historical") !== "false";
+                const facts = store.listTemporalFacts(ctx.workspace.id, {
+                    includeHistorical,
+                    subject: url.searchParams.get("subject") || undefined,
+                    predicate: url.searchParams.get("predicate") || undefined,
+                    query,
+                    limit: Number(url.searchParams.get("limit") || 50),
+                });
+                sendJson(res, 200, {
+                    ok: true,
+                    activeFacts: facts.filter((f) => f.validTo === null),
+                    historicalFacts: facts.filter((f) => f.validTo !== null),
+                    facts,
+                });
+                return;
+            }
+            if (pathname === "/api/v1/memory/forget" && req.method === "POST") {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const query = String(body.query || body.q || "").trim();
+                if (!query) {
+                    sendJson(res, 400, { ok: false, error: "query is required to forget matching memories" });
+                    return;
+                }
+                const pruned = await engine.forgetWorkspaceMemoryMatching(ctx, query);
+                sendJson(res, 200, { ok: true, ...pruned });
+                return;
+            }
             if (pathname === "/api/v1/memory" && req.method === "POST") {
                 const body = JSON.parse((await readBody(req)) || "{}");
                 const record = await engine.addWorkspaceMemory(ctx, {
@@ -940,6 +1035,9 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                     content: String(body.content || ""),
                     kind: body.kind || "fact",
                     metadata: body.metadata || {},
+                    subject: body.subject ? String(body.subject) : undefined,
+                    predicate: body.predicate ? String(body.predicate) : undefined,
+                    object: body.object ? String(body.object) : undefined,
                 });
                 sendJson(res, 201, { ok: true, memory: record });
                 return;
@@ -961,6 +1059,15 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 sendJson(res, 201, { ok: true, ...created });
                 return;
             }
+            if (pathname.startsWith("/api/v1/api-keys/") && req.method === "DELETE") {
+                const keyId = decodeURIComponent(pathname.slice("/api/v1/api-keys/".length));
+                if (!store.revokeApiKey(ctx.workspace.id, keyId)) {
+                    sendJson(res, 404, { ok: false, error: "API key not found" });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, revoked: keyId });
+                return;
+            }
             // Profile & Organization (v1 and api/v1)
             if ((pathname === "/api/v1/profile" || pathname === "/v1/profile") && req.method === "GET") {
                 sendJson(res, 200, { ok: true, ...engine.getProfile(ctx) });
@@ -1060,7 +1167,7 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
             // Governance Policy
             if (pathname === "/api/v1/policy" && req.method === "POST") {
                 const body = JSON.parse((await readBody(req)) || "{}");
-                const updated = store.updateWorkspacePolicy(ctx.workspace.id, body);
+                const updated = store.updateWorkspacePolicy(ctx.workspace.id, sanitizePolicyPatch(body));
                 sendJson(res, 200, { ok: true, workspace: updated });
                 return;
             }
@@ -1074,10 +1181,17 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
             }
             if (pathname === "/api/v1/plans" && req.method === "POST") {
                 const body = JSON.parse((await readBody(req)) || "{}");
+                const rawFunding = body.fundingMode || body.funding_mode;
+                const fundingMode = rawFunding === "byok" || rawFunding === "customer_funded"
+                    ? "byok"
+                    : rawFunding === "muxo_funded"
+                        ? "muxo_funded"
+                        : undefined;
                 const planned = await engine.planAction(ctx, {
                     toolSlug: String(body.toolSlug || body.tool_slug || ""),
                     input: body.input || {},
                     reason: body.reason ? String(body.reason) : undefined,
+                    fundingMode,
                 });
                 sendJson(res, 201, { ok: true, ...planned });
                 return;
@@ -1101,6 +1215,13 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 });
                 return;
             }
+            const planGetMatch = pathname.match(/^\/api\/v1\/plans\/([^/]+)$/);
+            if (planGetMatch && req.method === "GET") {
+                const planId = decodeURIComponent(planGetMatch[1]);
+                const plan = engine.getPlan(ctx, planId);
+                sendJson(res, 200, { ok: true, plan });
+                return;
+            }
             // Runs & Receipts
             if (pathname === "/api/v1/runs" && req.method === "GET") {
                 sendJson(res, 200, {
@@ -1109,6 +1230,21 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 });
                 return;
             }
+            const runCancelMatch = pathname.match(/^\/api\/v1\/runs\/([^/]+)\/cancel$/);
+            if (runCancelMatch && req.method === "POST") {
+                const runId = decodeURIComponent(runCancelMatch[1]);
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const cancelled = engine.cancelRun(ctx, runId, body.reason ? String(body.reason) : undefined);
+                sendJson(res, 200, { ok: true, ...cancelled });
+                return;
+            }
+            const runGetMatch = pathname.match(/^\/api\/v1\/runs\/([^/]+)$/);
+            if (runGetMatch && req.method === "GET") {
+                const runId = decodeURIComponent(runGetMatch[1]);
+                const run = engine.getRun(ctx, runId);
+                sendJson(res, 200, { ok: true, run });
+                return;
+            }
             if (pathname.startsWith("/api/v1/receipts/") && req.method === "GET") {
                 const receiptId = decodeURIComponent(pathname.slice("/api/v1/receipts/".length));
                 const verified = engine.getReceipt(ctx, receiptId);
@@ -1158,7 +1294,13 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
             if ((pathname === "/api/v1/do" || pathname === "/v1/do") &&
                 req.method === "POST") {
                 const body = JSON.parse((await readBody(req)) || "{}");
-                const prompt = String(body.prompt || body.instruction || body.query || body.command || "").trim();
+                const prompt = String(body.prompt ||
+                    body.instruction ||
+                    body.query ||
+                    body.command ||
+                    body.toolSlug ||
+                    body.tool ||
+                    "").trim();
                 if (!prompt) {
                     sendJson(res, 400, {
                         ok: false,
@@ -1166,19 +1308,37 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                     });
                     return;
                 }
+                const dryRun = body.dryRun === true ||
+                    body.dry_run === true ||
+                    body.planOnly === true ||
+                    body.autoExecute === false ||
+                    body.auto_execute === false;
+                const autoApprove = body.autoApprove !== false &&
+                    body.auto_approve !== false &&
+                    body.approveRisky !== false &&
+                    body.approve_risky !== false;
+                const rawFunding = body.fundingMode || body.funding_mode;
+                const fundingMode = rawFunding === "byok" || rawFunding === "customer_funded"
+                    ? "byok"
+                    : rawFunding === "muxo_funded"
+                        ? "muxo_funded"
+                        : undefined;
                 const result = await engine.doNaturalLanguage(ctx, {
                     prompt,
                     input: body.input && typeof body.input === "object"
                         ? body.input
                         : undefined,
-                    autoApprove: body.autoApprove !== false,
-                    dryRun: body.dryRun === true,
+                    autoApprove,
+                    dryRun,
+                    planOnly: dryRun,
+                    fundingMode,
                 });
                 sendJson(res, 200, result);
                 return;
             }
             // Live Stripe Billing, Credit Top-Up & Supplier Settlement Ledger
-            if (pathname === "/api/v1/billing/status" && req.method === "GET") {
+            if ((pathname === "/api/v1/billing/status" || pathname === "/api/v1/billing") &&
+                req.method === "GET") {
                 const ws = store.getWorkspace(ctx.workspace.id);
                 const settlementSummary = store.getSupplierSettlementSummary(ctx.workspace.id);
                 const byokKeys = store.listByokKeys(ctx.workspace.id);

package/dist/store.d.ts

@@ -1,5 +1,5 @@
 import { DatabaseSync } from "node:sqlite";
-import type { ActionPlan, ApiKeyRecord, ByokKeyRecord, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernanceDecisionRecord, GovernancePolicy, LedgerEntry, MemoryContextSummary, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlement, SupplierSettlementSummary, User, Workspace, WorkspaceMemoryRecord } from "./types.js";
+import type { ActionPlan, ApiKeyRecord, ByokKeyRecord, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernanceDecisionRecord, GovernancePolicy, LedgerEntry, MemoryContextSummary, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlement, SupplierSettlementSummary, TemporalGraphFact, User, Workspace, WorkspaceMemoryRecord } from "./types.js";
 export declare const BYOK_PROVIDER_CATALOG: Record<string, {
     category: "llm" | "supplier";
     envVarName: string;
@@ -173,6 +173,30 @@ export declare class MuxoStore {
     }): WorkspaceMemoryRecord;
     listMemoryRecords(workspaceId: string, limit?: number): WorkspaceMemoryRecord[];
     deleteMemoryRecord(workspaceId: string, idOrDocId: string): WorkspaceMemoryRecord | null;
+    upsertTemporalFact(params: {
+        workspaceId: string;
+        subject: string;
+        predicate: string;
+        object: string;
+        summary: string;
+        confidence?: number;
+        sourceKind?: TemporalGraphFact["sourceKind"];
+        sourceReferenceId?: string | null;
+        metadata?: Record<string, unknown>;
+        supersedeExisting?: boolean;
+    }): TemporalGraphFact;
+    listTemporalFacts(workspaceId: string, opts?: {
+        includeHistorical?: boolean;
+        subject?: string;
+        predicate?: string;
+        query?: string;
+        limit?: number;
+    }): TemporalGraphFact[];
+    forgetMatchingMemoryRecords(workspaceId: string, query: string): {
+        deletedMemories: WorkspaceMemoryRecord[];
+        invalidatedFacts: TemporalGraphFact[];
+    };
+    private mapTemporalFact;
     createAutonomousAgentSignup(params?: {
         agentName?: string;
         harness?: string;

package/dist/store.js

@@ -186,6 +186,23 @@ export class MuxoStore {
         created_at TEXT NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS temporal_facts (
+        id TEXT PRIMARY KEY,
+        workspace_id TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        predicate TEXT NOT NULL,
+        object TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        confidence REAL NOT NULL DEFAULT 0.95,
+        valid_from TEXT NOT NULL,
+        valid_to TEXT,
+        superseded_by_id TEXT,
+        source_kind TEXT NOT NULL DEFAULT 'fact',
+        source_reference_id TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      );
+
       CREATE TABLE IF NOT EXISTS agent_claims (
         claim_slug TEXT PRIMARY KEY,
         workspace_id TEXT NOT NULL,
@@ -516,7 +533,23 @@ export class MuxoStore {
           metadata_json = excluded.metadata_json,
           updated_at = excluded.updated_at`)
             .run(id, params.workspaceId, params.lane, params.providerSlug, params.providerName, params.status, params.externalAccountId ?? null, params.redirectUrl ?? null, JSON.stringify(params.metadata || {}), now, now);
-        return this.getConnection(id);
+        const connRecord = this.getConnection(id);
+        this.upsertTemporalFact({
+            workspaceId: params.workspaceId,
+            subject: `app:${params.providerSlug}`,
+            predicate: "CONNECTION_STATUS",
+            object: `${params.lane}:${params.status}`,
+            summary: `App ${params.providerName} (${params.providerSlug}) connection on ${params.lane} is ${params.status}`,
+            confidence: 1.0,
+            sourceKind: "resource_topology",
+            sourceReferenceId: connRecord.id,
+            metadata: {
+                lane: params.lane,
+                providerSlug: params.providerSlug,
+                status: params.status,
+            },
+        });
+        return connRecord;
     }
     getConnection(id) {
         const row = this.db
@@ -566,7 +599,25 @@ export class MuxoStore {
           metadata_json = excluded.metadata_json,
           updated_at = excluded.updated_at`)
             .run(id, params.workspaceId, params.resourceName, params.providerSlug, params.providerName, params.serviceSlug, params.planSlug ?? null, params.status, JSON.stringify(envVarKeys), encryptedHex, params.externalResourceId ?? null, JSON.stringify(params.metadata || {}), now, now);
-        return this.getResource(params.workspaceId, params.resourceName);
+        const resRecord = this.getResource(params.workspaceId, params.resourceName);
+        this.upsertTemporalFact({
+            workspaceId: params.workspaceId,
+            subject: `resource:${params.resourceName}`,
+            predicate: "PROVISIONED_ON",
+            object: `${params.serviceSlug}:${params.status}`,
+            summary: `Resource "${params.resourceName}" provisioned on ${params.serviceSlug} (${params.providerName}) with status ${params.status} [${resRecord.envVarKeys.join(", ") || "no env keys"}]`,
+            confidence: 1.0,
+            sourceKind: "resource_topology",
+            sourceReferenceId: resRecord.id,
+            metadata: {
+                providerSlug: params.providerSlug,
+                serviceSlug: params.serviceSlug,
+                planSlug: params.planSlug ?? null,
+                status: params.status,
+                envVarKeys: resRecord.envVarKeys,
+            },
+        });
+        return resRecord;
     }
     getResource(workspaceId, resourceNameOrId) {
         const row = this.db
@@ -793,7 +844,8 @@ export class MuxoStore {
            SET monthly_actions_used = ?, credits_balance = ?, updated_at = ?
            WHERE id = ?`)
                 .run(newActionsUsed, newCreditsBalance, now, params.workspaceId);
-            const byokUsed = this.hasByokForLane(params.workspaceId, run.lane, run.toolSlug);
+            const byokUsed = params.creditsMetered === 0 &&
+                this.hasByokForLane(params.workspaceId, run.lane, run.toolSlug);
             const settlement = this.computeSupplierSettlement(run.lane, run.toolSlug, params.creditsMetered, byokUsed ? "settled_by_customer_byok" : "settled_by_muxo_master_wallet", params.workspaceId);
             this.addLedgerEntry({
                 workspaceId: params.workspaceId,
@@ -1138,6 +1190,17 @@ export class MuxoStore {
             totalSupplierWholesalePaidCents,
             totalMuxoNetMarginCents,
             bySupplier,
+            masterWalletProtection: {
+                status: process.env.MUXO_MASTER_WALLET_DEPLETED === "true"
+                    ? "failover_active"
+                    : "healthy",
+                zeroChargeOnFailure: true,
+                instantFailoverMode: "zero_cost_native_edge",
+                paidProvisioningPolicy: "muxo_master_wallet_or_customer_stripe_byok",
+                retailToWholesaleCoverageRatio: totalSupplierWholesalePaidCents > 0
+                    ? Math.round((totalUserRetailSpendCents / totalSupplierWholesalePaidCents) * 100) / 100
+                    : 1.67,
+            },
         };
     }
     listLedgerEntries(workspaceId, limit = 50) {
@@ -1220,6 +1283,15 @@ export class MuxoStore {
         this.db
             .prepare("DELETE FROM memories WHERE id = ? AND workspace_id = ?")
             .run(String(row.id), workspaceId);
+        // Also mark any temporal facts sourced from this memory record as invalidated (valid_to = now)
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`UPDATE temporal_facts
+         SET valid_to = ?
+         WHERE workspace_id = ?
+           AND valid_to IS NULL
+           AND (source_reference_id = ? OR source_reference_id = ? OR id = ?)`)
+            .run(now, workspaceId, String(row.id), String(row.document_id), idOrDocId);
         return {
             id: String(row.id),
             workspaceId: String(row.workspace_id),
@@ -1232,6 +1304,166 @@ export class MuxoStore {
             createdAt: String(row.created_at),
         };
     }
+    // --- Bi-Temporal Resource & Fact Lineage (Zero-Dependency Graphiti Alternative) ---
+    upsertTemporalFact(params) {
+        const now = new Date().toISOString();
+        const subject = params.subject.trim();
+        const predicate = params.predicate.trim().toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+        const object = params.object.trim();
+        const confidence = params.confidence !== undefined ? Number(params.confidence) : 0.95;
+        const sourceKind = params.sourceKind || "fact";
+        // Check if an active fact already exists for (workspace_id, subject, predicate)
+        const activeRow = this.db
+            .prepare(`SELECT * FROM temporal_facts
+         WHERE workspace_id = ? AND subject = ? AND predicate = ? AND valid_to IS NULL
+         ORDER BY created_at DESC LIMIT 1`)
+            .get(params.workspaceId, subject, predicate);
+        if (activeRow && String(activeRow.object) === object) {
+            // Same object is still valid — update summary/confidence/metadata in place
+            const existingId = String(activeRow.id);
+            this.db
+                .prepare(`UPDATE temporal_facts
+           SET summary = ?, confidence = ?, metadata_json = ?, source_reference_id = COALESCE(?, source_reference_id)
+           WHERE id = ?`)
+                .run(params.summary, confidence, JSON.stringify(params.metadata || {}), params.sourceReferenceId ?? null, existingId);
+            return this.mapTemporalFact({
+                ...activeRow,
+                summary: params.summary,
+                confidence,
+                metadata_json: JSON.stringify(params.metadata || {}),
+                source_reference_id: params.sourceReferenceId ?? activeRow.source_reference_id,
+            });
+        }
+        const newId = `tf_${crypto.randomBytes(8).toString("hex")}`;
+        if (activeRow && params.supersedeExisting !== false) {
+            this.db
+                .prepare(`UPDATE temporal_facts
+           SET valid_to = ?, superseded_by_id = ?
+           WHERE id = ? AND workspace_id = ?`)
+                .run(now, newId, String(activeRow.id), params.workspaceId);
+        }
+        this.db
+            .prepare(`INSERT INTO temporal_facts (
+          id, workspace_id, subject, predicate, object, summary, confidence,
+          valid_from, valid_to, superseded_by_id, source_kind, source_reference_id,
+          metadata_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, ?, ?)`)
+            .run(newId, params.workspaceId, subject, predicate, object, params.summary, confidence, now, sourceKind, params.sourceReferenceId ?? null, JSON.stringify(params.metadata || {}), now);
+        return {
+            id: newId,
+            workspaceId: params.workspaceId,
+            subject,
+            predicate,
+            object,
+            summary: params.summary,
+            confidence,
+            validFrom: now,
+            validTo: null,
+            supersededById: null,
+            sourceKind,
+            sourceReferenceId: params.sourceReferenceId ?? null,
+            metadata: params.metadata || {},
+            createdAt: now,
+        };
+    }
+    listTemporalFacts(workspaceId, opts) {
+        const limit = Math.min(200, Math.max(1, Number(opts?.limit || 50)));
+        const includeHistorical = Boolean(opts?.includeHistorical);
+        const rows = this.db
+            .prepare(includeHistorical
+            ? `SELECT * FROM temporal_facts WHERE workspace_id = ? ORDER BY created_at DESC LIMIT ?`
+            : `SELECT * FROM temporal_facts WHERE workspace_id = ? AND valid_to IS NULL ORDER BY created_at DESC LIMIT ?`)
+            .all(workspaceId, limit);
+        let facts = rows.map((r) => this.mapTemporalFact(r));
+        if (opts?.subject) {
+            const subj = opts.subject.toLowerCase();
+            facts = facts.filter((f) => f.subject.toLowerCase().includes(subj));
+        }
+        if (opts?.predicate) {
+            const pred = opts.predicate.toUpperCase();
+            facts = facts.filter((f) => f.predicate.toUpperCase().includes(pred));
+        }
+        if (opts?.query && opts.query.trim()) {
+            const tokens = opts.query
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((t) => t.length >= 2);
+            if (tokens.length > 0) {
+                facts = facts.filter((f) => {
+                    const hay = `${f.subject} ${f.predicate} ${f.object} ${f.summary}`.toLowerCase();
+                    return tokens.some((tok) => hay.includes(tok));
+                });
+            }
+        }
+        return facts;
+    }
+    forgetMatchingMemoryRecords(workspaceId, query) {
+        const trimmed = query.trim().toLowerCase();
+        if (!trimmed) {
+            return { deletedMemories: [], invalidatedFacts: [] };
+        }
+        const tokens = trimmed.split(/\s+/).filter((t) => t.length >= 2);
+        const allMemories = this.listMemoryRecords(workspaceId, 200);
+        const matchingMemories = allMemories.filter((m) => {
+            const hay = `${m.title} ${m.content} ${m.kind}`.toLowerCase();
+            return (hay.includes(trimmed) ||
+                (tokens.length > 0 && tokens.every((tok) => hay.includes(tok))));
+        });
+        // Snapshot before deleting: deleteMemoryRecord retires sourced facts itself,
+        // and those must still be reported as invalidated.
+        const activeFacts = this.listTemporalFacts(workspaceId, {
+            includeHistorical: false,
+            limit: 200,
+        });
+        const deletedMemories = [];
+        for (const mem of matchingMemories) {
+            const deleted = this.deleteMemoryRecord(workspaceId, mem.id);
+            if (deleted)
+                deletedMemories.push(deleted);
+        }
+        const deletedSourceIds = new Set(deletedMemories.flatMap((m) => [m.id, m.documentId]));
+        const matchingFacts = activeFacts.filter((f) => {
+            const hay = `${f.subject} ${f.predicate} ${f.object} ${f.summary}`.toLowerCase();
+            return (hay.includes(trimmed) ||
+                (tokens.length > 0 && tokens.every((tok) => hay.includes(tok))) ||
+                Boolean(f.sourceReferenceId && deletedSourceIds.has(f.sourceReferenceId)));
+        });
+        const now = new Date().toISOString();
+        const invalidatedFacts = [];
+        for (const fact of matchingFacts) {
+            this.db
+                .prepare(`UPDATE temporal_facts SET valid_to = ? WHERE id = ? AND workspace_id = ?`)
+                .run(now, fact.id, workspaceId);
+            invalidatedFacts.push({
+                ...fact,
+                validTo: now,
+            });
+        }
+        return {
+            deletedMemories,
+            invalidatedFacts,
+        };
+    }
+    mapTemporalFact(row) {
+        return {
+            id: String(row.id),
+            workspaceId: String(row.workspace_id),
+            subject: String(row.subject),
+            predicate: String(row.predicate),
+            object: String(row.object),
+            summary: String(row.summary),
+            confidence: Number(row.confidence ?? 0.95),
+            validFrom: String(row.valid_from),
+            validTo: row.valid_to ? String(row.valid_to) : null,
+            supersededById: row.superseded_by_id ? String(row.superseded_by_id) : null,
+            sourceKind: String(row.source_kind || "fact"),
+            sourceReferenceId: row.source_reference_id
+                ? String(row.source_reference_id)
+                : null,
+            metadata: JSON.parse(String(row.metadata_json || "{}")),
+            createdAt: String(row.created_at),
+        };
+    }
     // --- Autonomous Agent Onboarding (agents.composio.dev pattern) ---
     createAutonomousAgentSignup(params) {
         const suffix = crypto.randomBytes(4).toString("hex");
@@ -1426,6 +1658,7 @@ export class MuxoStore {
             input: JSON.parse(String(row.input_json || "{}")),
             output: row.output_json ? JSON.parse(String(row.output_json)) : null,
             error: row.error ? String(row.error) : null,
+            errorMessage: row.error ? String(row.error) : null,
             actionsMetered: Number(row.actions_metered),
             creditsMetered: Number(row.credits_metered),
             durationMs: row.duration_ms !== null ? Number(row.duration_ms) : null,