@ouro.bot/cli 0.1.0-alpha.70 → 0.1.0-alpha.700

package/dist/heart/migrate-config.js

@@ -0,0 +1,100 @@
+"use strict";
+// v1 → v2 agent.json migration.
+// Creates explicit humanFacing/agentFacing blocks from the legacy provider.
+// Uses raw fs and provider-model defaults — NO import from config.ts.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateAgentConfigV1ToV2 = migrateAgentConfigV1ToV2;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const provider_models_1 = require("./provider-models");
+function isAgentProvider(value) {
+    return value === "azure" ||
+        value === "minimax" ||
+        value === "anthropic" ||
+        value === "openai-codex" ||
+        value === "github-copilot";
+}
+function migrateAgentConfigV1ToV2(agentRoot) {
+    const configPath = path.join(agentRoot, "agent.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf-8");
+    }
+    catch {
+        return; // No agent.json — nothing to migrate
+    }
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Cannot parse agent.json at ${configPath} — invalid JSON`);
+    }
+    const version = typeof config.version === "number" ? config.version : 1;
+    if (version >= 2) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config_identity.migrate_skip",
+            message: "agent config already v2, skipping migration",
+            meta: { agentRoot },
+        });
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_start",
+        message: "migrating agent config v1 → v2",
+        meta: { agentRoot },
+    });
+    const provider = isAgentProvider(config.provider) ? config.provider : "anthropic";
+    const model = (0, provider_models_1.getDefaultModelForProvider)(provider);
+    // Write v2 config
+    const { provider: _removed, ...rest } = config;
+    const v2Config = {
+        ...rest,
+        version: 2,
+        humanFacing: { provider, model },
+        agentFacing: { provider, model },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(v2Config, null, 2) + "\n", "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_end",
+        message: "agent config migration complete",
+        meta: { agentRoot, provider, model },
+    });
+}

package/dist/heart/model-capabilities.js

@@ -8,30 +8,41 @@ exports.MODEL_CAPABILITIES = {
         reasoningEffort: ["low", "medium", "high", "max"],
         thinkingFormat: "anthropic",
         maxOutputTokens: 128000,
+        vision: true,
     },
     "claude-sonnet-4-6": {
         reasoningEffort: ["low", "medium", "high"],
         thinkingFormat: "anthropic",
         maxOutputTokens: 64000,
+        vision: true,
     },
     "claude-opus-4.6": {
         reasoningEffort: ["low", "medium", "high", "max"],
         maxOutputTokens: 128000,
+        vision: true,
     },
     "claude-sonnet-4.6": {
         reasoningEffort: ["low", "medium", "high"],
         maxOutputTokens: 64000,
+        vision: true,
     },
     "gpt-5.4": {
         reasoningEffort: ["low", "medium", "high"],
         phase: true,
         maxOutputTokens: 100000,
+        vision: true,
     },
     "gpt-5.3-codex": {
         reasoningEffort: ["low", "medium", "high"],
         phase: true,
         maxOutputTokens: 100000,
     },
+    "MiniMax-Text-01": {
+        vision: true,
+    },
+    "MiniMax-VL-01": {
+        vision: true,
+    },
 };
 const EMPTY_CAPABILITIES = Object.freeze({});
 function getModelCapabilities(modelId) {

package/dist/heart/orientation-frame.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMessageText = extractMessageText;
+exports.extractOrderedListReferents = extractOrderedListReferents;
+exports.buildOrientationFrame = buildOrientationFrame;
+exports.renderOrientationFrame = renderOrientationFrame;
+const runtime_1 = require("../nerves/runtime");
+const structured_output_1 = require("./structured-output");
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function extractMessageText(message) {
+    if (!message)
+        return "";
+    const content = message.content;
+    const toolText = message.role === "assistant"
+        ? (0, structured_output_1.extractVisibleTextFromAssistantToolCalls)(message.tool_calls)
+        : "";
+    if (typeof content === "string")
+        return [content, toolText].filter((part) => part.trim().length > 0).join("\n").trim();
+    if (!Array.isArray(content))
+        return toolText.trim();
+    const parts = [];
+    for (const part of content) {
+        if (!isRecord(part))
+            continue;
+        const text = part.text;
+        if (typeof text === "string") {
+            parts.push(text.trim());
+        }
+    }
+    if (toolText)
+        parts.push(toolText);
+    return parts.filter(Boolean).join("\n").trim();
+}
+function currentUserMessagesFrom(messages) {
+    const collected = [];
+    let firstIndex = messages.length;
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message?.role !== "user") {
+            if (collected.length > 0)
+                break;
+            continue;
+        }
+        collected.unshift(message);
+        firstIndex = index;
+    }
+    return { messages: collected, firstIndex };
+}
+function latestAssistantBefore(messages, beforeIndex) {
+    for (let index = Math.min(beforeIndex - 1, messages.length - 1); index >= 0; index--) {
+        const message = messages[index];
+        if (message?.role === "assistant")
+            return message;
+    }
+    return undefined;
+}
+function extractOrderedListReferents(text) {
+    const referents = [];
+    for (const line of text.split(/\r?\n/)) {
+        const match = line.match(/^\s*(\d+)[.)]\s+(.+?)\s*$/);
+        if (!match)
+            continue;
+        referents.push({
+            kind: "ordered_list_item",
+            label: match[1],
+            text: match[2].trim(),
+        });
+        if (referents.length >= 12)
+            break;
+    }
+    return referents;
+}
+function hasCorrectionMarker(text) {
+    return /\b(hang on|wait|actually|not that|not this|wrong|misunderstood|you(?:'re| are) right|correct)\b/i.test(text)
+        || /^\s*no[\s,]/i.test(text);
+}
+function isTerseReferent(text) {
+    const normalized = text.trim().toLowerCase().replace(/[.!?]+$/g, "");
+    return /^(same|correct|exactly|yes|no|that one|this one|the first one|the second one|the third one|first|second|third|option \d+|number \d+|item \d+|\d+)$/.test(normalized);
+}
+function hasNumericStructuredReferent(text) {
+    return /\b(?:number|item|option|#)\s*\d+\b/i.test(text) || /^\s*\d+\b/.test(text.trim());
+}
+function latestStructuredOutputFrom(outputs) {
+    if (!outputs || outputs.length === 0)
+        return undefined;
+    return outputs.at(-1);
+}
+function shouldAttachStructuredOutput(combinedSpeech, signals) {
+    if (hasNumericStructuredReferent(combinedSpeech))
+        return true;
+    return signals.some((signal) => signal === "terse_referent" || signal === "correction_marker");
+}
+function deriveSignals(currentUserSpeech, priorAssistantReferents, latestStructuredOutput) {
+    const combined = currentUserSpeech.join("\n").trim();
+    if (!combined)
+        return [];
+    const signals = [];
+    if (hasCorrectionMarker(combined))
+        signals.push("correction_marker");
+    if (priorAssistantReferents.length > 0 && isTerseReferent(combined))
+        signals.push("terse_referent");
+    if (latestStructuredOutput && hasNumericStructuredReferent(combined))
+        signals.push("structured_referent");
+    return [...new Set(signals)];
+}
+function deriveActionPolicy(signals) {
+    if (signals.length === 0)
+        return { mode: "normal" };
+    return {
+        mode: "correction_hold",
+        reason: signals.includes("terse_referent")
+            ? "Current user speech appears referent-dependent; inspect orientation before mutating durable state."
+            : "Current user speech appears to correct or revise prior understanding; inspect orientation before mutating durable state.",
+        blockedMutationKinds: ["durable_state_write", "external_side_effect"],
+    };
+}
+function buildOrientationFrame(input) {
+    const derivedCurrent = input.currentUserMessages
+        ? { messages: input.currentUserMessages, firstIndex: input.messages.length }
+        : currentUserMessagesFrom(input.messages);
+    const currentUserSpeech = derivedCurrent.messages
+        .map((message) => extractMessageText(message))
+        .filter((text) => text.length > 0);
+    const previousAssistant = latestAssistantBefore(input.messages, derivedCurrent.firstIndex);
+    const priorAssistantReferents = extractOrderedListReferents(extractMessageText(previousAssistant));
+    const candidateStructuredOutput = latestStructuredOutputFrom(input.structuredOutputs);
+    const signals = deriveSignals(currentUserSpeech, priorAssistantReferents, candidateStructuredOutput);
+    const combinedSpeech = currentUserSpeech.join("\n").trim();
+    const latestStructuredOutput = candidateStructuredOutput && shouldAttachStructuredOutput(combinedSpeech, signals)
+        ? candidateStructuredOutput
+        : undefined;
+    const actionPolicy = deriveActionPolicy(signals);
+    const frame = {
+        schemaVersion: 1,
+        channel: input.channel,
+        currentUserSpeech,
+        priorAssistantReferents,
+        ...(latestStructuredOutput ? { latestStructuredOutput } : {}),
+        signals,
+        actionPolicy,
+        ...(input.source ? { source: input.source } : {}),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "orientation.frame_built",
+        message: "orientation frame built",
+        meta: {
+            channel: input.channel,
+            signalCount: signals.length,
+            referentCount: priorAssistantReferents.length,
+            structuredOutput: latestStructuredOutput?.id ?? null,
+            policy: actionPolicy.mode,
+        },
+    });
+    return frame;
+}
+function renderOrientationFrame(frame) {
+    const lines = [
+        "## orientation frame",
+        `channel: ${frame.channel}`,
+        `action policy: ${frame.actionPolicy.mode}`,
+    ];
+    if (frame.actionPolicy.mode === "correction_hold") {
+        lines.push(`policy reason: ${frame.actionPolicy.reason}`);
+    }
+    if (frame.source) {
+        lines.push("source:");
+        lines.push(`- kind: ${frame.source.kind}`);
+        if (frame.source.lane)
+            lines.push(`- lane: ${frame.source.lane}`);
+        if (frame.source.defaultReplyTarget)
+            lines.push(`- default reply target: ${frame.source.defaultReplyTarget}`);
+        if (frame.source.threadId)
+            lines.push(`- thread id: ${frame.source.threadId}`);
+        if (frame.source.replyingToText)
+            lines.push(`- replying to: ${frame.source.replyingToText}`);
+        if (frame.source.repairNotice)
+            lines.push(`- repair notice: ${frame.source.repairNotice}`);
+        if (frame.source.routingHint)
+            lines.push(`- routing hint: ${frame.source.routingHint}`);
+        if (frame.source.recentLanes && frame.source.recentLanes.length > 0) {
+            lines.push("- recent lanes:");
+            for (const lane of frame.source.recentLanes) {
+                lines.push(`  - ${lane.label || lane.key}: ${lane.snippet}`);
+            }
+        }
+    }
+    lines.push("current user speech:");
+    if (frame.currentUserSpeech.length === 0) {
+        lines.push("- (none)");
+    }
+    else {
+        for (const speech of frame.currentUserSpeech)
+            lines.push(`- ${speech}`);
+    }
+    if (frame.signals.length > 0) {
+        lines.push(`signals: ${frame.signals.join(", ")}`);
+    }
+    if (frame.priorAssistantReferents.length > 0) {
+        lines.push("prior assistant referents:");
+        for (const item of frame.priorAssistantReferents) {
+            lines.push(`${item.label}. ${item.text}`);
+        }
+    }
+    if (frame.latestStructuredOutput) {
+        lines.push(`latest structured output: ${frame.latestStructuredOutput.id}`);
+        if (frame.latestStructuredOutput.heading)
+            lines.push(`heading: ${frame.latestStructuredOutput.heading}`);
+        for (const item of frame.latestStructuredOutput.items) {
+            lines.push(`${item.label}. ${item.text}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/heart/platform.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPlatform = detectPlatform;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+function detectPlatform(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const readFile = deps.readFileSync ?? ((p) => fs.readFileSync(p, "utf-8"));
+    let result;
+    if (platform === "darwin") {
+        result = "macos";
+    }
+    else if (platform === "win32") {
+        result = "windows-native";
+    }
+    else if (platform === "linux") {
+        result = detectLinuxOrWsl(env, readFile);
+    }
+    else {
+        // Unknown platform — treat as linux
+        result = "linux";
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.platform_detected",
+        message: "detected platform",
+        meta: { platform, result },
+    });
+    return result;
+}
+function detectLinuxOrWsl(env, readFile) {
+    // Primary: WSL_DISTRO_NAME env var
+    if (env.WSL_DISTRO_NAME && env.WSL_DISTRO_NAME.length > 0) {
+        return "wsl";
+    }
+    // Fallback: /proc/version containing "microsoft" (case-insensitive)
+    try {
+        const procVersion = readFile("/proc/version");
+        if (/microsoft/i.test(procVersion)) {
+            return "wsl";
+        }
+    }
+    catch {
+        // /proc/version not readable — not WSL
+    }
+    return "linux";
+}

package/dist/heart/primitives.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HARNESS_BOOTSTRAP_PHASES = void 0;
-exports.HARNESS_BOOTSTRAP_PHASES = ["bundle", "psyche", "inner-dialog"];
+exports.HARNESS_BOOTSTRAP_PHASES = ["bundle", "psyche", "private-runtime"];

package/dist/heart/private-runtime/decision-renderer.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizePrivateDecision = sanitizePrivateDecision;
+exports.buildPrivateDecisionReadPayload = buildPrivateDecisionReadPayload;
+exports.privateDecisionReadPayloadFromDaemonData = privateDecisionReadPayloadFromDaemonData;
+exports.privateDecisionCountSummary = privateDecisionCountSummary;
+exports.formatPrivateDecisionReadText = formatPrivateDecisionReadText;
+exports.formatPrivateDecisionReadJson = formatPrivateDecisionReadJson;
+const runtime_1 = require("../../nerves/runtime");
+function stringField(value, fallback = "") {
+    return typeof value === "string" ? value : fallback;
+}
+function booleanField(value) {
+    return typeof value === "boolean" ? value : false;
+}
+function originRefsField(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        if (!entry
+            || typeof entry !== "object"
+            || Array.isArray(entry)
+            || typeof entry.kind !== "string"
+            || typeof entry.id !== "string") {
+            return [];
+        }
+        const row = entry;
+        return [{ kind: row.kind, id: row.id }];
+    });
+}
+function providerLaneField(value) {
+    const row = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    return {
+        lane: stringField(row.lane, "inner"),
+        provider: stringField(row.provider, "unknown"),
+        model: stringField(row.model, "unknown"),
+        source: "agent.json",
+        ...(typeof row.credentialRevision === "string" ? { credentialRevision: row.credentialRevision } : {}),
+    };
+}
+function ledgerLocatorField(value, ledgerPath) {
+    const row = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    return {
+        path: stringField(row.path, ledgerPath ?? ""),
+        ...(typeof row.line === "number" ? { line: row.line } : {}),
+    };
+}
+function resultField(value) {
+    return value === "allow" ? "allow" : "deny";
+}
+function sanitizePrivateDecision(row, ledgerPath) {
+    const record = row && typeof row === "object" && !Array.isArray(row)
+        ? row
+        : {};
+    const deniedReason = stringField(record.deniedReason);
+    const duplicateOf = stringField(record.duplicateOf);
+    const error = stringField(record.error);
+    return {
+        schemaVersion: 1,
+        receiptId: stringField(record.receiptId),
+        agent: stringField(record.agent),
+        origin: stringField(record.origin),
+        reason: stringField(record.reason),
+        providerLane: providerLaneField(record.providerLane),
+        triggerSource: stringField(record.triggerSource),
+        idempotencyKey: stringField(record.idempotencyKey),
+        budgetClass: stringField(record.budgetClass),
+        originRefs: originRefsField(record.originRefs),
+        requestFingerprint: stringField(record.requestFingerprint),
+        result: resultField(record.result),
+        executable: booleanField(record.executable),
+        decidedAt: stringField(record.decidedAt),
+        ledgerLocator: ledgerLocatorField(record.ledgerLocator, ledgerPath),
+        ...(deniedReason ? { deniedReason } : {}),
+        ...(duplicateOf ? { duplicateOf } : {}),
+        ...(error ? { error } : {}),
+    };
+}
+function decisionSortKey(decision) {
+    return decision.decidedAt || `${decision.ledgerLocator.line ?? 0}`.padStart(12, "0");
+}
+function sortedRecentDecisions(decisions, limit) {
+    return [...decisions]
+        .sort((a, b) => decisionSortKey(b).localeCompare(decisionSortKey(a)))
+        .slice(0, limit);
+}
+function buildPrivateDecisionReadPayload(input) {
+    const limit = Number.isInteger(input.limit) && input.limit && input.limit > 0 ? input.limit : input.decisions.length;
+    const decisions = sortedRecentDecisions(input.decisions.map((row) => sanitizePrivateDecision(row, input.ledgerPath)), limit);
+    (0, runtime_1.emitNervesEvent)({
+        component: "private-runtime",
+        event: "private_runtime.decision_read_payload_built",
+        message: "private-runtime decision read payload built",
+        meta: { agent: input.agent, count: decisions.length, hasLedgerPath: !!input.ledgerPath },
+    });
+    return {
+        agent: input.agent,
+        ...(input.ledgerPath ? { ledgerPath: input.ledgerPath } : {}),
+        decisions,
+        ...(input.guidance ? { guidance: input.guidance } : {}),
+    };
+}
+function privateDecisionReadPayloadFromDaemonData(data, fallbackAgent) {
+    const record = data && typeof data === "object" && !Array.isArray(data)
+        ? data
+        : {};
+    const ledgerPath = stringField(record.ledgerPath);
+    const guidance = stringField(record.guidance);
+    return buildPrivateDecisionReadPayload({
+        agent: stringField(record.agent, fallbackAgent),
+        decisions: Array.isArray(record.decisions) ? record.decisions : [],
+        ...(ledgerPath ? { ledgerPath } : {}),
+        ...(guidance ? { guidance } : {}),
+    });
+}
+function privateDecisionCountSummary(count) {
+    return `${count} private-runtime ${count === 1 ? "decision" : "decisions"}`;
+}
+function decisionReason(decision) {
+    return decision.deniedReason || decision.reason || "(no reason recorded)";
+}
+function formatLocator(locator) {
+    const line = locator.line === undefined ? "" : `:${locator.line}`;
+    return `${locator.path}${line}`;
+}
+function formatPrivateDecisionReadText(payload) {
+    const lines = [`private decisions: ${payload.agent}`];
+    if (payload.ledgerPath)
+        lines.push(`ledger: ${payload.ledgerPath}`);
+    if (payload.guidance)
+        lines.push(`guidance: ${payload.guidance}`);
+    if (payload.decisions.length === 0) {
+        lines.push("no private-runtime decisions found");
+        return lines.join("\n");
+    }
+    for (const decision of payload.decisions) {
+        lines.push([
+            `- ${decision.decidedAt || "undated"}`,
+            decision.result,
+            decision.origin,
+            `key=${decision.idempotencyKey}`,
+            `lane=${decision.providerLane.lane}`,
+            `receipt=${decision.receiptId}`,
+            `reason=${decisionReason(decision)}`,
+            `locator=${formatLocator(decision.ledgerLocator)}`,
+        ].join(" "));
+    }
+    return lines.join("\n");
+}
+function formatPrivateDecisionReadJson(payload) {
+    return JSON.stringify(payload, null, 2);
+}

package/dist/heart/private-runtime/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizePrivateDecision = exports.privateDecisionReadPayloadFromDaemonData = exports.privateDecisionCountSummary = exports.formatPrivateDecisionReadText = exports.formatPrivateDecisionReadJson = exports.buildPrivateDecisionReadPayload = exports.recordPrivateTurnDecision = exports.readPrivateTurnLedger = exports.privateTurnLedgerPath = exports.requestPrivateTurnDecision = exports.createPrivateTurnRequestFingerprint = exports.createPrivateTurnIdempotencyKey = void 0;
+var policy_1 = require("./policy");
+Object.defineProperty(exports, "createPrivateTurnIdempotencyKey", { enumerable: true, get: function () { return policy_1.createPrivateTurnIdempotencyKey; } });
+Object.defineProperty(exports, "createPrivateTurnRequestFingerprint", { enumerable: true, get: function () { return policy_1.createPrivateTurnRequestFingerprint; } });
+Object.defineProperty(exports, "requestPrivateTurnDecision", { enumerable: true, get: function () { return policy_1.requestPrivateTurnDecision; } });
+var ledger_1 = require("./ledger");
+Object.defineProperty(exports, "privateTurnLedgerPath", { enumerable: true, get: function () { return ledger_1.privateTurnLedgerPath; } });
+Object.defineProperty(exports, "readPrivateTurnLedger", { enumerable: true, get: function () { return ledger_1.readPrivateTurnLedger; } });
+Object.defineProperty(exports, "recordPrivateTurnDecision", { enumerable: true, get: function () { return ledger_1.recordPrivateTurnDecision; } });
+var decision_renderer_1 = require("./decision-renderer");
+Object.defineProperty(exports, "buildPrivateDecisionReadPayload", { enumerable: true, get: function () { return decision_renderer_1.buildPrivateDecisionReadPayload; } });
+Object.defineProperty(exports, "formatPrivateDecisionReadJson", { enumerable: true, get: function () { return decision_renderer_1.formatPrivateDecisionReadJson; } });
+Object.defineProperty(exports, "formatPrivateDecisionReadText", { enumerable: true, get: function () { return decision_renderer_1.formatPrivateDecisionReadText; } });
+Object.defineProperty(exports, "privateDecisionCountSummary", { enumerable: true, get: function () { return decision_renderer_1.privateDecisionCountSummary; } });
+Object.defineProperty(exports, "privateDecisionReadPayloadFromDaemonData", { enumerable: true, get: function () { return decision_renderer_1.privateDecisionReadPayloadFromDaemonData; } });
+Object.defineProperty(exports, "sanitizePrivateDecision", { enumerable: true, get: function () { return decision_renderer_1.sanitizePrivateDecision; } });