@muxoai/platform 1.4.2 → 1.4.4

package/dist/memory-graph.js

@@ -1,11 +1,102 @@
 import { formatHumanFriendlyExplanation } from "./policy.js";
 /**
- * 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 function filterFactsAsOf(facts, asOf) {
+    if (!asOf || !asOf.trim()) {
+        return {
+            scopedFacts: facts,
+            isActiveAtPointInTime: (fact) => fact.validTo === null,
+        };
+    }
+    const asOfMs = Date.parse(asOf);
+    if (!Number.isFinite(asOfMs)) {
+        return {
+            scopedFacts: facts,
+            isActiveAtPointInTime: (fact) => fact.validTo === null,
+        };
+    }
+    const scopedFacts = facts.filter((fact) => {
+        const validFromMs = Date.parse(fact.validFrom || fact.createdAt);
+        return !Number.isFinite(validFromMs) || validFromMs <= asOfMs;
+    });
+    return {
+        scopedFacts,
+        isActiveAtPointInTime: (fact) => {
+            if (!fact.validTo)
+                return true;
+            const validToMs = Date.parse(fact.validTo);
+            return Number.isFinite(validToMs) && validToMs > asOfMs;
+        },
+    };
+}
+/**
+ * Graphiti-style Multi-Hop Subgraph Community Traversal (BFS).
+ * Finds all nodes and edges within `maxHops` (default 2) of a focal entity.
+ */
+export function traverseSubgraphBfs(nodes, edges, focalQuery, maxHops = 2) {
+    const needle = focalQuery.trim().toLowerCase();
+    const clampedHops = Math.min(4, Math.max(1, Number(maxHops) || 2));
+    const seedNode = nodes.find((n) => n.id.toLowerCase() === needle) ||
+        nodes.find((n) => n.label.toLowerCase() === needle) ||
+        nodes.find((n) => n.id.toLowerCase().includes(needle) ||
+            n.label.toLowerCase().includes(needle)) ||
+        nodes[0];
+    if (!seedNode) {
+        return {
+            focalEntity: focalQuery,
+            maxHops: clampedHops,
+            nodes: [],
+            edges: [],
+            hopDistances: {},
+        };
+    }
+    const hopDistances = { [seedNode.id]: 0 };
+    const queue = [
+        { nodeId: seedNode.id, depth: 0 },
+    ];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current.depth >= clampedHops)
+            continue;
+        for (const edge of edges) {
+            let neighborId = null;
+            if (edge.source === current.nodeId)
+                neighborId = edge.target;
+            else if (edge.target === current.nodeId)
+                neighborId = edge.source;
+            if (neighborId && hopDistances[neighborId] === undefined) {
+                hopDistances[neighborId] = current.depth + 1;
+                queue.push({ nodeId: neighborId, depth: current.depth + 1 });
+            }
+        }
+    }
+    const subNodes = nodes
+        .filter((n) => hopDistances[n.id] !== undefined)
+        .map((n) => ({ ...n, hopDistance: hopDistances[n.id] }));
+    const subEdges = edges.filter((e) => hopDistances[e.source] !== undefined &&
+        hopDistances[e.target] !== undefined);
+    return {
+        focalEntity: seedNode.id,
+        maxHops: clampedHops,
+        nodes: subNodes,
+        edges: subEdges,
+        hopDistances,
+    };
+}
+/**
+ * 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 function buildMemoryKnowledgeGraph(input) {
     const ws = input.workspace;
     const query = input.query;
+    const asOf = input.asOf ?? null;
+    const maxHops = Math.min(4, Math.max(1, Number(input.maxHops || 2)));
+    const { scopedFacts, isActiveAtPointInTime } = filterFactsAsOf(input.facts, asOf);
     const nodeMap = new Map();
     const rootId = `workspace:${ws.slug}`;
     nodeMap.set(rootId, {
@@ -34,7 +125,9 @@ export function buildMemoryKnowledgeGraph(input) {
                         ? "tool"
                         : id.startsWith("guardrail:")
                             ? "guardrail"
-                            : fallbackKind;
+                            : id.startsWith("episode:")
+                                ? "episode"
+                                : fallbackKind;
         const label = id.includes(":")
             ? id.split(":").slice(1).join(":")
             : id.length > 36
@@ -50,8 +143,11 @@ export function buildMemoryKnowledgeGraph(input) {
         nodeMap.set(id, created);
         return created;
     };
-    const edges = input.facts.map((fact) => {
-        const status = fact.validTo === null ? "active" : "historical";
+    let episodesCount = 0;
+    const edges = scopedFacts.map((fact) => {
+        const status = isActiveAtPointInTime(fact)
+            ? "active"
+            : "historical";
         const objKind = fact.sourceKind === "preference"
             ? "preference"
             : fact.sourceKind === "policy_decision"
@@ -61,6 +157,15 @@ export function buildMemoryKnowledgeGraph(input) {
                     : "entity";
         ensureNode(fact.subject, status, "entity", fact.subject);
         ensureNode(fact.object, status, objKind, fact.summary);
+        const episodeId = fact.episodeId || fact.sourceReferenceId || null;
+        if (episodeId) {
+            const epNodeId = episodeId.startsWith("episode:")
+                ? episodeId
+                : `episode:${episodeId}`;
+            if (!nodeMap.has(epNodeId))
+                episodesCount += 1;
+            ensureNode(epNodeId, status, "episode", `Episodic provenance (${episodeId})`);
+        }
         return {
             id: fact.id,
             source: fact.subject,
@@ -72,7 +177,10 @@ export function buildMemoryKnowledgeGraph(input) {
             confidence: fact.confidence,
             status,
             validFrom: fact.validFrom,
-            validTo: fact.validTo,
+            validTo: status === "active" && asOf ? null : fact.validTo,
+            transactionFrom: fact.transactionFrom || fact.createdAt,
+            transactionTo: fact.transactionTo ?? fact.validTo,
+            episodeId,
             supersededById: fact.supersededById ?? null,
             sourceKind: fact.sourceKind,
             sourceReferenceId: fact.sourceReferenceId ?? null,
@@ -95,6 +203,9 @@ export function buildMemoryKnowledgeGraph(input) {
                 status: "active",
                 validFrom: conn.createdAt,
                 validTo: null,
+                transactionFrom: conn.createdAt,
+                transactionTo: null,
+                episodeId: conn.id,
                 supersededById: null,
                 sourceKind: "system",
                 sourceReferenceId: conn.id,
@@ -104,6 +215,10 @@ export function buildMemoryKnowledgeGraph(input) {
     const activeEdges = edges.filter((e) => e.status === "active");
     const historicalEdges = edges.filter((e) => e.status === "historical");
     const nodes = Array.from(nodeMap.values());
+    const focalTarget = input.focalEntity || query || null;
+    const subgraph = focalTarget
+        ? traverseSubgraphBfs(nodes, edges, focalTarget, maxHops)
+        : null;
     const safeMermaidId = (raw, idx) => `N${idx}_${raw.replace(/[^a-zA-Z0-9]/g, "_").slice(0, 14)}`;
     const nodeIndex = new Map();
     nodes.slice(0, 24).forEach((n, idx) => {
@@ -128,7 +243,7 @@ export function buildMemoryKnowledgeGraph(input) {
             mermaidLines.push(`  ${srcId} -.->|RETIRED: ${pred}| ${tgtId}`);
         }
     }
-    const headline = `Bi-Temporal Knowledge Graph (${ws.name}): ${activeEdges.length} active relationship${activeEdges.length === 1 ? "" : "s"}, ${historicalEdges.length} superseded historical relationship${historicalEdges.length === 1 ? "" : "s"} across ${nodes.length} node${nodes.length === 1 ? "" : "s"}.`;
+    const headline = `Bi-Temporal Knowledge Graph (${ws.name}${asOf ? ` as of ${asOf}` : ""}): ${activeEdges.length} active relationship${activeEdges.length === 1 ? "" : "s"}, ${historicalEdges.length} superseded historical relationship${historicalEdges.length === 1 ? "" : "s"} across ${nodes.length} node${nodes.length === 1 ? "" : "s"}.`;
     const activePreview = activeEdges
         .slice(0, 4)
         .map((e) => `${e.source} --[${e.predicate}]--> ${e.target}`)
@@ -142,7 +257,7 @@ export function buildMemoryKnowledgeGraph(input) {
             ? `Time-travel lineage: ${historicalEdges.length} older fact${historicalEdges.length === 1 ? " was" : "s were"} automatically retired when newer workspace settings or facts replaced them.`
             : "No superseded historical facts yet.",
     ].join(" ");
-    const technical = `workspace=${ws.id} | namespace=${input.namespace} | nodes=${nodes.length} | activeEdges=${activeEdges.length} | historicalEdges=${historicalEdges.length} | memories=${input.memoriesCount} | activePreview=[${activePreview || "none"}]`;
+    const technical = `workspace=${ws.id} | namespace=${input.namespace} | asOf=${asOf || "latest"} | nodes=${nodes.length} | activeEdges=${activeEdges.length} | historicalEdges=${historicalEdges.length} | episodes=${episodesCount} | memories=${input.memoriesCount} | activePreview=[${activePreview || "none"}]`;
     const explanation = formatHumanFriendlyExplanation({
         headline,
         nonTechnical,
@@ -154,11 +269,15 @@ export function buildMemoryKnowledgeGraph(input) {
         workspaceSlug: ws.slug,
         namespace: input.namespace,
         generatedAt: new Date().toISOString(),
+        asOf,
+        focalEntity: subgraph?.focalEntity ?? null,
+        maxHops,
         query: query ?? null,
         nodes,
         edges,
         activeEdges,
         historicalEdges,
+        subgraph,
         stats: {
             nodesCount: nodes.length,
             activeEdgesCount: activeEdges.length,
@@ -166,6 +285,7 @@ export function buildMemoryKnowledgeGraph(input) {
             memoriesCount: input.memoriesCount,
             resourcesCount: input.resources.length,
             connectionsCount: input.activeConnections.length,
+            episodesCount,
         },
         mermaid: mermaidLines.join("\n"),
         explanation,

package/dist/oss-suite.d.ts

@@ -0,0 +1,401 @@
+/**
+ * Unified Open-Source & Commercial Enterprise Suite (Runtime-Agnostic: Node.js + Cloudflare Workers):
+ * 1. AWS Cedar & Open Policy Agent (OPA / Rego) Policy-as-Code Compiler & Evaluator
+ * 2. OpenTelemetry (OTel GenAI / MCP Semantic Conventions) OTLP JSON & Langfuse Trace Exporter
+ * 3. Turnkey Commercial Business Saga Playbooks (backed by Temporal-compatible DurableWorkflows)
+ * 4. FinOps & Commercial ROI Unit-Economics Analytics
+ */
+import { type DurableWorkflow } from "./durable-workflow.js";
+import type { ActionPlan, ApprovalImpactPreview, BusinessReceiptSummary, ByokKeyRecord, ExecutionReceipt, ExecutionRun, GovernanceDecisionRecord, GovernancePolicy, HumanFriendlyExplanation, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlement, TemporalGraphFact, Workspace } from "./types.js";
+export interface CompiledPolicyAsCodeBundle {
+    workspaceId: string;
+    workspaceSlug: string;
+    generatedAt: string;
+    engines: ["aws-cedar-4.x", "open-policy-agent-rego-v1"];
+    cedarSchemaVersion: "4.0";
+    cedarPolicyText: string;
+    opaRegoText: string;
+    statements: Array<{
+        id: string;
+        effect: "permit" | "forbid";
+        description: string;
+        statement: string;
+    }>;
+    cedar: {
+        schemaNamespace: "Muxo";
+        statementsCount: number;
+        policyText: string;
+        statements: Array<{
+            id: string;
+            effect: "permit" | "forbid";
+            description: string;
+            statement: string;
+        }>;
+    };
+    opa: {
+        packageName: "muxo.authz";
+        rulesCount: number;
+        regoText: string;
+    };
+    plainEnglishSummary: string[];
+    explanation: HumanFriendlyExplanation;
+}
+export interface PolicyAsCodeEvaluationResult {
+    workspaceId: string;
+    toolSlug: string;
+    riskLevel: RiskLevel;
+    creditCost: number;
+    allowed: boolean;
+    decision: "ALLOW" | "DENY" | "REQUIRE_APPROVAL";
+    policyDecision: "allow" | "deny" | "require_approval";
+    cedarResult: {
+        decision: "ALLOW" | "DENY";
+        determiningPolicies: string[];
+        errors: string[];
+    };
+    opaResult: {
+        allow: boolean;
+        decision: "allow" | "deny" | "review";
+        denyReasons: string[];
+        reviewReasons: string[];
+    };
+    matchedStatements: string[];
+    remediationForLlm: string;
+    compiledBundle: CompiledPolicyAsCodeBundle;
+}
+export declare function compileWorkspacePolicyToCedarAndRego(policy: GovernancePolicy, workspace: Pick<Workspace, "id" | "slug" | "name">): CompiledPolicyAsCodeBundle;
+export declare function evaluateCedarAndOpaPolicy(params: {
+    policy: GovernancePolicy;
+    workspace: Pick<Workspace, "id" | "slug" | "name">;
+    toolSlug: string;
+    input?: Record<string, unknown>;
+    riskLevel?: RiskLevel;
+    creditCost?: number;
+    lane?: string;
+}): PolicyAsCodeEvaluationResult;
+export interface OtelSpanAttribute {
+    key: string;
+    value: {
+        stringValue?: string;
+        intValue?: number;
+        boolValue?: boolean;
+    };
+}
+export interface OtelTraceExportBundle {
+    workspaceId: string;
+    workspaceSlug: string;
+    exportedAt: string;
+    protocol: "OTLP/HTTP-JSON-v1";
+    semanticConventions: ["gen_ai.1.29.0", "mcp.2026-07-28", "muxo.governance.v5"];
+    w3cTraceParent: string;
+    w3cTraceContextSample: string;
+    spansCount: number;
+    otlpPayload: {
+        resourceSpans: OtelTraceExportBundle["resourceSpans"];
+    };
+    resourceSpans: Array<{
+        resource: {
+            attributes: OtelSpanAttribute[];
+        };
+        scopeSpans: Array<{
+            scope: {
+                name: string;
+                version: string;
+            };
+            spans: Array<{
+                traceId: string;
+                spanId: string;
+                parentSpanId?: string;
+                traceparent: string;
+                name: string;
+                kind: "SPAN_KIND_SERVER" | "SPAN_KIND_CLIENT";
+                startTimeUnixNano: string;
+                endTimeUnixNano: string;
+                status: {
+                    code: "STATUS_CODE_OK" | "STATUS_CODE_ERROR";
+                    message?: string;
+                };
+                attributes: OtelSpanAttribute[];
+            }>;
+        }>;
+    }>;
+    langfuseBatch: Array<{
+        id: string;
+        type: "trace-create" | "span-create";
+        timestamp: string;
+        body: Record<string, unknown>;
+    }>;
+}
+export declare function buildOtelTraceExport(params: {
+    workspace: Pick<Workspace, "id" | "slug" | "name" | "tier">;
+    runs: ExecutionRun[];
+    receipts: ExecutionReceipt[];
+    plans?: ActionPlan[];
+    version?: string;
+}): OtelTraceExportBundle;
+export interface CommercialPlaybookDefinition {
+    slug: string;
+    name: string;
+    persona: "Customer Operations & Support" | "Engineering & DevOps" | "Marketing & Growth" | "SecOps & Compliance" | "Product & Founders" | "Custom Workspace Saga";
+    summary: string;
+    commercialValue: string;
+    estimatedMinutesSaved: number;
+    creditCost: number;
+    expectedCostUsd: number;
+    defaultProvider: string;
+    defaultServiceRef: string;
+    requiredConnections: string[];
+    explicitPermissions: string[];
+    approvalRules: string[];
+    failureAndRecoveryBehavior: string;
+    usableBusinessOutcome: string;
+    naturalLanguageTriggers?: string[];
+    custom?: boolean;
+    steps: Array<{
+        name: string;
+        toolSlug: string;
+        primitive: "step.do" | "step.waitForEvent";
+        compensationAction?: string;
+        description: string;
+    }>;
+}
+export declare const MUXO_COMMERCIAL_PLAYBOOKS: CommercialPlaybookDefinition[];
+export declare function getCommercialPlaybook(slugOrQuery: string, customPlaybooks?: CommercialPlaybookDefinition[]): CommercialPlaybookDefinition | null;
+export declare function parseNaturalLanguageCustomPlaybook(prompt: string, explicitInput?: Record<string, unknown>): CommercialPlaybookDefinition;
+export declare function buildPlaybookSagaExecution(params: {
+    id: string;
+    workspaceId: string;
+    workspaceSlug: string;
+    playbook: CommercialPlaybookDefinition;
+    input?: Record<string, unknown>;
+}): {
+    playbook: CommercialPlaybookDefinition;
+    workflow: DurableWorkflow;
+    usableResult: {
+        playbookSlug: string;
+        playbookName: string;
+        status: "completed";
+        summary: string;
+        deliverableOutcome: string;
+        targetProvider: string;
+        targetEntity: string;
+        completedStepsCount: number;
+        registeredCompensationsCount: number;
+        estimatedCostUsd: number;
+        creditsMetered: number;
+        estimatedMinutesSaved: number;
+        recoveryGuarantee: string;
+    };
+    temporalFact: {
+        subject: string;
+        predicate: string;
+        object: string;
+        summary: string;
+        episodeId: string;
+    };
+};
+export interface CommercialRoiReport {
+    workspaceId: string;
+    workspaceSlug: string;
+    workspaceName: string;
+    tier: string;
+    generatedAt: string;
+    unitEconomics: {
+        creditsBalance: number;
+        totalRunsAnalyzed: number;
+        succeededRunsCount: number;
+        byokZeroCreditRunsCount: number;
+        managedFundedRunsCount: number;
+        totalCreditsConsumed: number;
+        totalMonetarySpendUsd: number;
+        byokCreditsSaved: number;
+        byokDollarsSavedUsd: number;
+        estimatedEngineeringMinutesSaved: number;
+        estimatedEngineeringHoursSaved: number;
+        estimatedLaborValueSavedUsd: number;
+        preventedPolicyViolationsCount: number;
+        activeCloudResourcesCount: number;
+        activeBiTemporalFactsCount: number;
+        configuredByokProviders: string[];
+    };
+    validationMetrics: {
+        timeToFirstSuccessfulActionSeconds: number;
+        completionRateWithoutManualRepairPct: number;
+        avgTimeSavedPerWorkflowMinutes: number;
+        avgCostPerCompletedWorkflowUsd: number;
+        repeatWorkflowExecutionsCount: number;
+        zeroChargeFailedRunsCount: number;
+    };
+    workflowBreakdown: Array<{
+        toolSlug: string;
+        lane: ProviderLane;
+        runsCount: number;
+        succeededCount: number;
+        completionRatePct: number;
+        creditsConsumed: number;
+        costUsd: number;
+        estimatedMinutesSaved: number;
+    }>;
+    laneBreakdown: Record<ProviderLane, {
+        runsCount: number;
+        creditsConsumed: number;
+        costUsd: number;
+        estimatedMinutesSaved: number;
+    }>;
+    recommendations: Array<{
+        id: string;
+        category: "byok_savings" | "cloud_consolidation" | "governance_safety" | "playbook_automation";
+        title: string;
+        impact: string;
+        actionCommand: string;
+    }>;
+    explanation: HumanFriendlyExplanation;
+}
+export declare function buildCommercialRoiReport(params: {
+    workspace: Workspace;
+    runs: ExecutionRun[];
+    plans?: ActionPlan[];
+    resources: ProvisionedResource[];
+    byokKeys: ByokKeyRecord[];
+    temporalFacts: TemporalGraphFact[];
+}): CommercialRoiReport;
+export type HarnessPresetSlug = "startup-builder" | "strict-production" | "read-only-auditor" | "finops-byok-zero-cost";
+export interface HarnessPresetDefinition {
+    slug: HarnessPresetSlug;
+    name: string;
+    summary: string;
+    recommendedFor: string;
+    naturalLanguageTriggers: string[];
+    policyPatch: Partial<GovernancePolicy>;
+}
+export declare const MUXO_HARNESS_PRESETS: HarnessPresetDefinition[];
+export declare function resolveHarnessPreset(presetOrPrompt?: string | null): HarnessPresetDefinition | null;
+export interface HarnessConfigurationBundle {
+    ok: true;
+    workspaceId: string;
+    workspaceSlug: string;
+    targetHarness: string;
+    appliedPreset: HarnessPresetDefinition | null;
+    availablePresets: HarnessPresetDefinition[];
+    policy: GovernancePolicy;
+    harnessConfigs: {
+        claudeCode: {
+            installPluginCommand: string;
+            addMcpCommand: string;
+            mcpJson: Record<string, unknown>;
+        };
+        cursor: {
+            filePath: ".cursor/mcp.json";
+            mcpJson: Record<string, unknown>;
+        };
+        codex: {
+            filePath: "~/.codex/config.toml";
+            toml: string;
+        };
+        chatgpt: {
+            mcpServerUrl: string;
+            authMode: string;
+            instructions: string;
+        };
+        claudeDesktop: {
+            filePath: "claude_desktop_config.json";
+            mcpJson: Record<string, unknown>;
+        };
+        factoryDroid: {
+            mcpServerUrl: string;
+            skillCommand: string;
+        };
+    };
+    systemPromptDirective: string;
+    naturalLanguageCheatsheet: Array<{
+        category: string;
+        sayInPlainEnglish: string;
+        mcpEquivalent: Record<string, unknown>;
+        restEndpoint: string;
+    }>;
+    explanation: HumanFriendlyExplanation;
+    humanMessage: string;
+}
+export declare function buildHarnessConfigurationBundle(params: {
+    workspace: Pick<Workspace, "id" | "slug" | "name" | "tier" | "policy">;
+    baseUrl?: string;
+    targetHarness?: string;
+    appliedPreset?: HarnessPresetDefinition | null;
+}): HarnessConfigurationBundle;
+export type NaturalLanguageOssIntentKind = "list_playbooks" | "run_playbook" | "create_playbook" | "rollback_workflow" | "signal_workflow" | "workflow_history" | "memory_graph" | "cedar_compile" | "cedar_evaluate" | "otel_traces" | "roi_analytics" | "configure_harness";
+export interface ParsedNaturalLanguageOssIntent {
+    matched: boolean;
+    kind: NaturalLanguageOssIntentKind | null;
+    playbookSlug?: string;
+    playbookInput?: Record<string, unknown>;
+    customPlaybook?: CommercialPlaybookDefinition;
+    workflowId?: string;
+    workflowReason?: string;
+    signalName?: string;
+    signalPayload?: Record<string, unknown>;
+    asOf?: string | null;
+    focalEntity?: string | null;
+    maxHops?: number;
+    toolSlug?: string;
+    evaluationInput?: Record<string, unknown>;
+    preset?: HarnessPresetDefinition | null;
+    targetHarness?: string;
+    extraGuardrailPrompt?: string | null;
+    limit?: number;
+    summary: string;
+}
+export declare function extractPlaybookInputFromNaturalLanguage(prompt: string, explicitInput?: Record<string, unknown>): Record<string, unknown>;
+export declare function parseNaturalLanguageOssIntent(prompt: string, options?: {
+    customPlaybooks?: CommercialPlaybookDefinition[];
+    explicitInput?: Record<string, unknown>;
+}): ParsedNaturalLanguageOssIntent;
+export declare function buildApprovalImpactPreview(params: {
+    toolSlug: string;
+    lane: ProviderLane;
+    riskLevel: RiskLevel;
+    input: Record<string, unknown>;
+    reason?: string;
+    creditCost: number;
+    fundingMode?: "muxo_funded" | "byok";
+    supplierSettlement?: SupplierSettlement | null;
+    decisionRecord?: GovernanceDecisionRecord | null;
+    workspaceName?: string;
+}): ApprovalImpactPreview;
+export declare function buildBusinessReceiptSummary(params: {
+    toolSlug: string;
+    lane: ProviderLane;
+    riskLevel: RiskLevel;
+    status: "succeeded" | "failed" | "cancelled";
+    creditsMetered: number;
+    input?: Record<string, unknown>;
+    output?: unknown;
+    error?: string | null;
+    approvedBy?: string | null;
+    actorId?: string;
+    decisionRecord?: GovernanceDecisionRecord | null;
+    supplierSettlement?: SupplierSettlement | null;
+}): BusinessReceiptSummary;
+export interface RunReconciliationReport {
+    ok: true;
+    runId: string;
+    planId: string;
+    workspaceId: string;
+    toolSlug: string;
+    status: ExecutionRun["status"];
+    reconciliationStatus: "verified_complete" | "failed_zero_charge" | "cancelled" | "needs_reconciliation";
+    executeOnceEnforced: boolean;
+    idempotentReplaySafe: boolean;
+    zeroChargeOnFailureVerified: boolean;
+    creditsMetered: number;
+    estimatedCostUsd: number;
+    receiptVerified: boolean;
+    receiptId: string | null;
+    businessSummary: BusinessReceiptSummary;
+    recommendedNextAction: string;
+}
+export declare function buildRunReconciliationReport(params: {
+    run?: ExecutionRun | null;
+    plan?: ActionPlan | null;
+    receipt?: ExecutionReceipt | null;
+    signatureValid?: boolean;
+}): RunReconciliationReport;