@muxoai/platform 1.3.1 → 1.3.3

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,

package/dist/types.d.ts

@@ -8,6 +8,10 @@ export interface GovernancePolicy {
     allowProvisioning: boolean;
     maxCreditsPerRun: number;
     blockedToolSlugs?: string[];
+    executionRing?: 0 | 1 | 2 | 3;
+    killSwitchActive?: boolean;
+    killSwitchReason?: string | null;
+    blockDestructiveSql?: boolean;
 }
 export interface User {
     id: string;
@@ -126,15 +130,82 @@ export interface GovernanceDecisionRecord {
         previousHash: string;
         chainVerified: boolean;
     };
+    protocolFacets?: {
+        sql?: {
+            verb: string;
+            target: string;
+            tables: string;
+            functions: string;
+            destructive?: boolean;
+        };
+        k8s?: {
+            verb: string;
+            resource: string;
+            namespace: string;
+            name: string;
+            subresource: string;
+        };
+        infra?: {
+            provider: string;
+            service: string;
+            action: string;
+            destructive: boolean;
+        };
+    };
+    ringEnforcement?: {
+        agentRing: number;
+        requiredRing: number;
+        allowed: boolean;
+        ringLabel: string;
+    };
+    trustScore?: {
+        overall: number;
+        tier: "Untrusted" | "Provisional" | "Trusted" | "Verified";
+        reliability: number;
+        consistency: number;
+    };
+    contextPoisoning?: {
+        safe: boolean;
+        riskLevel: "none" | "low" | "medium" | "high" | "critical";
+        findingsCount: number;
+        findings: Array<{
+            patternId: string;
+            patternName: string;
+            severity: string;
+            description: string;
+        }>;
+    };
+    killSwitch?: {
+        active: boolean;
+        killedAt?: string | null;
+        reason?: string | null;
+    };
     ed25519Signature: string;
     signature: string;
     bindingHash: string;
     decidedAt: string;
 }
 export type MemoryRecordKind = "fact" | "preference" | "resource_note" | "operator_note" | "execution_outcome" | "resource_topology" | "policy_decision";
+export interface TemporalGraphFact {
+    id: string;
+    workspaceId: string;
+    subject: string;
+    predicate: string;
+    object: string;
+    summary: string;
+    confidence: number;
+    validFrom: string;
+    validTo: string | null;
+    supersededById?: string | null;
+    sourceKind: MemoryRecordKind | "system";
+    sourceReferenceId?: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+}
 export interface MemoryContextSummary {
     enabled: boolean;
     namespace: string;
+    fundingSource?: "muxo_funded" | "customer_byok_supermemory" | "local_fallback";
     staticFacts: string[];
     dynamicContext: string[];
     recalledMemories: Array<{
@@ -145,6 +216,7 @@ export interface MemoryContextSummary {
         createdAt?: string;
     }>;
     formattedPromptContext: string;
+    profileMarkdown?: string;
     profile: {
         static: string[];
         dynamic: string[];
@@ -157,6 +229,12 @@ export interface MemoryContextSummary {
         similarity: number;
         createdAt?: string;
     }>;
+    temporalFacts?: TemporalGraphFact[];
+    contextPoisoningScan?: {
+        safe: boolean;
+        riskLevel: "none" | "low" | "medium" | "high" | "critical";
+        findingsCount: number;
+    };
 }
 export interface WorkspaceMemoryRecord {
     id: string;
@@ -209,6 +287,13 @@ export interface SupplierSettlementSummary {
         supplierWholesalePaidCents: number;
         muxoNetMarginCents: number;
     }>;
+    masterWalletProtection?: {
+        status: "healthy" | "failover_active";
+        zeroChargeOnFailure: boolean;
+        instantFailoverMode: "zero_cost_native_edge";
+        paidProvisioningPolicy: "muxo_master_wallet_or_customer_stripe_byok";
+        retailToWholesaleCoverageRatio: number;
+    };
 }
 export interface ActionPlan {
     id: string;
@@ -243,6 +328,7 @@ export interface ExecutionRun {
     input: Record<string, unknown>;
     output: Record<string, unknown> | null;
     error: string | null;
+    errorMessage?: string | null;
     actionsMetered: number;
     creditsMetered: number;
     durationMs: number | null;

package/dist/ui/console-html.d.ts

@@ -1,2 +1,25 @@
+export type ConsoleView = "overview" | "setup" | "catalog" | "connections" | "infrastructure" | "memory" | "governance" | "activity" | "billing" | "login" | "signup";
+/** Every path that serves the console shell, mapped to the view it opens. */
+export declare const CONSOLE_ROUTES: Readonly<Record<string, ConsoleView>>;
+export declare function isConsolePath(pathname: string): boolean;
 export declare function renderConsoleHtml(): string;
 export declare function renderLandingHtml(): string;
+export interface OAuthConsentOptions {
+    error?: string;
+    clientName?: string;
+    redirectOrigin?: string;
+    clerk?: {
+        publishableKey: string;
+        frontendApi: string;
+    } | null;
+    request?: Record<string, string>;
+    /** Renders the workspace-claim variant, which posts to `action` instead of /oauth/authorize. */
+    claim?: {
+        workspaceName: string;
+        targetEmail: string;
+        action: string;
+        cancelUrl: string;
+    };
+}
+/** Consent screen for MCP clients (ChatGPT, Claude, CLIs) asking to use a Muxo workspace. */
+export declare function renderOAuthConsentHtml(opts: OAuthConsentOptions): string;