@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

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

@@ -0,0 +1,158 @@
+"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 denialCode = record.denialCode === "provider_lane_unavailable" ? record.denialCode : undefined;
+    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 } : {}),
+        ...(denialCode ? { denialCode } : {}),
+        ...(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; } });

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

@@ -0,0 +1,221 @@
+"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.privateTurnLedgerPath = privateTurnLedgerPath;
+exports.readPrivateTurnLedger = readPrivateTurnLedger;
+exports.recordPrivateTurnDecision = recordPrivateTurnDecision;
+const fs = __importStar(require("node:fs"));
+const crypto = __importStar(require("node:crypto"));
+const path = __importStar(require("node:path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_LEDGER_DIR = "private-runtime";
+const DEFAULT_LEDGER_FILE = "decisions.jsonl";
+function emitDecisionRecorded(deps, input) {
+    const payload = {
+        level: input.level,
+        component: "private-runtime",
+        event: "private_runtime.decision_recorded",
+        message: "private-runtime decision recorded",
+        meta: {
+            agent: input.decision.agent,
+            origin: input.decision.origin,
+            result: input.decision.result,
+            idempotencyKey: input.decision.idempotencyKey,
+            requestFingerprint: input.decision.requestFingerprint,
+        },
+    };
+    if (deps?.emitNervesEvent) {
+        deps.emitNervesEvent(payload);
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: input.level,
+        component: "private-runtime",
+        event: "private_runtime.decision_recorded",
+        message: "private-runtime decision recorded",
+        meta: payload.meta,
+    });
+}
+function emitDecisionRecordFailed(deps, input) {
+    const payload = {
+        level: "error",
+        component: "private-runtime",
+        event: "private_runtime.decision_record_failed",
+        message: "private-runtime decision ledger write failed",
+        meta: {
+            agent: input.decision.agent,
+            origin: input.decision.origin,
+            idempotencyKey: input.decision.idempotencyKey,
+            requestFingerprint: input.decision.requestFingerprint,
+            error: input.decision.error,
+        },
+    };
+    if (deps?.emitNervesEvent) {
+        deps.emitNervesEvent(payload);
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "private-runtime",
+        event: "private_runtime.decision_record_failed",
+        message: "private-runtime decision ledger write failed",
+        meta: payload.meta,
+    });
+}
+function privateTurnLedgerPath(agent, deps = {}) {
+    if (deps.ledgerPath)
+        return deps.ledgerPath;
+    return path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${agent}.ouro`, "state", DEFAULT_LEDGER_DIR, DEFAULT_LEDGER_FILE);
+}
+function readRows(ledgerPath) {
+    if (!fs.existsSync(ledgerPath))
+        return [];
+    const raw = fs.readFileSync(ledgerPath, "utf-8").trim();
+    if (!raw)
+        return [];
+    return raw.split("\n").filter(Boolean).map((line) => JSON.parse(line));
+}
+function writeRow(ledgerPath, row) {
+    const rowWithLocator = {
+        ...row,
+        ledgerLocator: {
+            path: ledgerPath,
+            line: readRows(ledgerPath).length + 1,
+        },
+    };
+    fs.appendFileSync(ledgerPath, `${JSON.stringify(rowWithLocator)}\n`, "utf-8");
+    return rowWithLocator;
+}
+function receiptIdFor(input) {
+    const hash = crypto
+        .createHash("sha256")
+        .update(`${input.idempotencyKey}\n${input.requestFingerprint}\n${input.result}`)
+        .digest("hex");
+    return `ptrr_${hash}`;
+}
+function mismatchDecision(candidate, existing) {
+    return {
+        ...candidate,
+        receiptId: receiptIdFor({
+            idempotencyKey: candidate.idempotencyKey,
+            requestFingerprint: candidate.requestFingerprint,
+            result: "mismatch",
+        }),
+        result: "deny",
+        executable: false,
+        deniedReason: "idempotency-key fingerprint mismatch",
+        denialCode: undefined,
+        duplicateOf: existing.receiptId,
+    };
+}
+function duplicateDecision(existing) {
+    return {
+        ...existing,
+        executable: false,
+        deniedReason: "duplicate private-turn decision already recorded",
+        duplicateOf: existing.receiptId,
+    };
+}
+function ledgerWriteFailedDecision(candidate, ledgerPath, error) {
+    return {
+        ...candidate,
+        receiptId: receiptIdFor({
+            idempotencyKey: candidate.idempotencyKey,
+            requestFingerprint: candidate.requestFingerprint,
+            result: "ledger-write-failed",
+        }),
+        result: "deny",
+        executable: false,
+        deniedReason: "ledger write failed",
+        denialCode: undefined,
+        ledgerLocator: { path: ledgerPath },
+        error: String(error),
+    };
+}
+function readPrivateTurnLedger(ledgerPath) {
+    return readRows(ledgerPath);
+}
+function recordPrivateTurnDecision(decision, deps = {}) {
+    const ledgerPath = privateTurnLedgerPath(decision.agent, deps);
+    if (!deps.ledgerPath) {
+        fs.mkdirSync(path.dirname(ledgerPath), { recursive: true });
+    }
+    const candidate = {
+        ...decision,
+        receiptId: decision.receiptId || receiptIdFor(decision),
+        ledgerLocator: { path: ledgerPath },
+    };
+    try {
+        const matchingRows = readRows(ledgerPath).filter((row) => row.idempotencyKey === candidate.idempotencyKey);
+        const anchor = matchingRows[0];
+        if (anchor) {
+            if (anchor.requestFingerprint !== candidate.requestFingerprint) {
+                const mismatch = mismatchDecision(candidate, anchor);
+                const writtenMismatch = writeRow(ledgerPath, mismatch);
+                emitDecisionRecorded(deps, { level: "warn", decision: writtenMismatch });
+                return writtenMismatch;
+            }
+            const priorExecutable = matchingRows.find((row) => row.requestFingerprint === candidate.requestFingerprint && row.executable);
+            if (priorExecutable && candidate.executable) {
+                return duplicateDecision(priorExecutable);
+            }
+            const latestSameFingerprint = [...matchingRows].reverse().find((row) => row.requestFingerprint === candidate.requestFingerprint);
+            if (latestSameFingerprint
+                && latestSameFingerprint.result === candidate.result
+                && latestSameFingerprint.executable === candidate.executable
+                && latestSameFingerprint.deniedReason === candidate.deniedReason
+                && latestSameFingerprint.denialCode === candidate.denialCode) {
+                return latestSameFingerprint;
+            }
+            if (priorExecutable && !candidate.executable) {
+                const written = writeRow(ledgerPath, candidate);
+                emitDecisionRecorded(deps, { level: "warn", decision: written });
+                return written;
+            }
+            const written = writeRow(ledgerPath, candidate);
+            emitDecisionRecorded(deps, { level: written.result === "allow" ? "info" : "warn", decision: written });
+            return written;
+        }
+        const written = writeRow(ledgerPath, candidate);
+        emitDecisionRecorded(deps, { level: written.result === "allow" ? "info" : "warn", decision: written });
+        return written;
+    }
+    catch (error) {
+        const failed = ledgerWriteFailedDecision(candidate, ledgerPath, error);
+        emitDecisionRecordFailed(deps, { decision: failed });
+        return failed;
+    }
+}

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

@@ -0,0 +1,252 @@
+"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.createPrivateTurnRequestFingerprint = createPrivateTurnRequestFingerprint;
+exports.createPrivateTurnIdempotencyKey = createPrivateTurnIdempotencyKey;
+exports.requestPrivateTurnDecision = requestPrivateTurnDecision;
+const crypto = __importStar(require("node:crypto"));
+const identity_1 = require("../identity");
+const auth_flow_1 = require("../auth/auth-flow");
+const runtime_1 = require("../../nerves/runtime");
+const provider_credentials_1 = require("../provider-credentials");
+const ledger_1 = require("./ledger");
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function normalizeOriginRefs(refs) {
+    return [...refs].sort((a, b) => stableJson(a).localeCompare(stableJson(b)));
+}
+function providerLaneSpendIdentity(providerLane) {
+    return {
+        lane: providerLane.lane,
+        provider: providerLane.provider,
+        model: providerLane.model,
+        source: providerLane.source,
+        ...(providerLane.credentialRevision ? { credentialRevision: providerLane.credentialRevision } : {}),
+    };
+}
+function spendIdentity(request, options) {
+    return {
+        agent: request.agent,
+        origin: request.origin,
+        reason: request.reason,
+        providerLane: options.providerLane ? providerLaneSpendIdentity(options.providerLane) : request.providerLane,
+        triggerSource: request.triggerSource,
+        ...(options.includeIdempotencyKey ? { idempotencyKey: request.idempotencyKey ?? "" } : {}),
+        budgetClass: request.budgetClass,
+        originRefs: normalizeOriginRefs(request.originRefs ?? []),
+    };
+}
+function sha256Prefix(prefix, value) {
+    const hash = crypto.createHash("sha256").update(stableJson(value)).digest("hex");
+    return `${prefix}_${hash}`;
+}
+function nowIso(deps) {
+    const raw = deps.now?.() ?? new Date();
+    return raw instanceof Date ? raw.toISOString() : raw;
+}
+function emitPolicyEvaluated(deps, input) {
+    const payload = {
+        level: input.result === "allow" ? "info" : "debug",
+        component: "private-runtime",
+        event: "private_runtime.policy_evaluated",
+        message: "private-runtime policy evaluated",
+        meta: {
+            agent: input.request.agent,
+            origin: input.request.origin,
+            result: input.result,
+            idempotencyKey: input.idempotencyKey,
+            requestFingerprint: input.requestFingerprint,
+        },
+    };
+    if (deps.emitNervesEvent) {
+        deps.emitNervesEvent(payload);
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: input.result === "allow" ? "info" : "debug",
+        component: "private-runtime",
+        event: "private_runtime.policy_evaluated",
+        message: "private-runtime policy evaluated",
+        meta: payload.meta,
+    });
+}
+function hasOriginRef(refs, kind, id) {
+    return refs.some((ref) => ref.kind === kind && ref.id === id);
+}
+function hasNonEmptyOriginRef(refs, kind) {
+    return refs.some((ref) => ref.kind === kind && typeof ref.id === "string" && ref.id.trim().length > 0);
+}
+async function defaultResolveProviderLane(agent, lane, deps) {
+    const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const { config } = (0, auth_flow_1.readAgentConfigForAgent)(agent, bundlesRoot);
+    const facing = lane === "inner" ? config.agentFacing : config.humanFacing;
+    const credential = (0, provider_credentials_1.readCachedProviderCredentialRecord)(agent, facing.provider);
+    if (!credential.ok) {
+        throw new Error(`${lane} provider ${facing.provider} (${facing.model}) credential revision unavailable: ${credential.error}`);
+    }
+    return {
+        lane,
+        provider: facing.provider,
+        model: facing.model,
+        source: "agent.json",
+        credentialRevision: credential.record.revision,
+    };
+}
+async function resolveProviderLaneMetadata(request, deps) {
+    return deps.resolveProviderLane
+        ? await deps.resolveProviderLane(request.agent, request.providerLane)
+        : defaultResolveProviderLane(request.agent, request.providerLane, deps);
+}
+async function evaluatePolicy(request, context, deps) {
+    if (deps.evaluatePolicy)
+        return deps.evaluatePolicy(request, context);
+    const originRefs = request.originRefs ?? [];
+    if (request.triggerSource === "external-event"
+        && hasNonEmptyOriginRef(originRefs, "external-event")
+        && hasOriginRef(originRefs, "daemon-command", "external.event.submit")) {
+        return {
+            result: "allow",
+            reason: "verified daemon external event",
+        };
+    }
+    if (request.triggerSource === "operator-cli"
+        && hasOriginRef(originRefs, "cli-command", "ouro msg")
+        && hasNonEmptyOriginRef(originRefs, "daemon-receipt")) {
+        return {
+            result: "allow",
+            reason: "verified operator CLI message",
+        };
+    }
+    if ((request.triggerSource === "await-poke" || request.triggerSource === "await-scheduler" || request.triggerSource === "await-expiry")
+        && hasNonEmptyOriginRef(originRefs, "await")
+        && (hasOriginRef(originRefs, "daemon-command", "await.poke")
+            || hasOriginRef(originRefs, "scheduler", "await-scheduler")
+            || hasOriginRef(originRefs, "await-alert", "expired"))) {
+        return {
+            result: "allow",
+            reason: "verified daemon await check",
+        };
+    }
+    return {
+        result: "deny",
+        reason: "private runtime policy denies by default",
+        deniedReason: "default policy deny",
+    };
+}
+function emptyReceiptId() {
+    return "";
+}
+function createPrivateTurnRequestFingerprint(request, providerLane) {
+    return sha256Prefix("ptr", spendIdentity(request, { includeIdempotencyKey: true, providerLane }));
+}
+function createPrivateTurnIdempotencyKey(request) {
+    return sha256Prefix("ptk", spendIdentity(request, { includeIdempotencyKey: false }));
+}
+async function requestPrivateTurnDecision(request, deps = {}) {
+    const idempotencyKey = request.idempotencyKey ?? createPrivateTurnIdempotencyKey(request);
+    const normalizedRequest = { ...request, idempotencyKey };
+    let providerLane;
+    let requestFingerprint;
+    let evaluation;
+    try {
+        providerLane = await resolveProviderLaneMetadata(normalizedRequest, deps);
+    }
+    catch (error) {
+        providerLane = {
+            lane: normalizedRequest.providerLane,
+            provider: "unconfigured",
+            model: "-",
+            source: "agent.json",
+        };
+        evaluation = {
+            result: "deny",
+            reason: error instanceof Error ? error.message : String(error),
+            deniedReason: "provider lane resolution failed",
+            denialCode: "provider_lane_unavailable",
+        };
+    }
+    requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
+    if (evaluation === undefined) {
+        try {
+            evaluation = await evaluatePolicy(normalizedRequest, {
+                requestFingerprint,
+                idempotencyKey,
+                providerLane,
+            }, deps);
+        }
+        catch (error) {
+            evaluation = {
+                result: "deny",
+                reason: error instanceof Error ? error.message : String(error),
+                deniedReason: "private runtime policy evaluation failed",
+            };
+        }
+    }
+    const result = evaluation.result;
+    emitPolicyEvaluated(deps, { request: normalizedRequest, result, requestFingerprint, idempotencyKey });
+    const reason = evaluation.reason ?? normalizedRequest.reason;
+    const decision = {
+        schemaVersion: 1,
+        receiptId: emptyReceiptId(),
+        agent: normalizedRequest.agent,
+        origin: normalizedRequest.origin,
+        requestReason: normalizedRequest.reason,
+        reason,
+        providerLane,
+        triggerSource: normalizedRequest.triggerSource,
+        idempotencyKey,
+        budgetClass: normalizedRequest.budgetClass,
+        originRefs: normalizeOriginRefs(normalizedRequest.originRefs ?? []),
+        requestFingerprint,
+        result,
+        executable: result === "allow",
+        decidedAt: nowIso(deps),
+        ledgerLocator: { path: deps.ledgerPath ?? "" },
+        ...(result === "deny" ? {
+            deniedReason: evaluation.deniedReason ?? reason,
+            ...(evaluation.denialCode ? { denialCode: evaluation.denialCode } : {}),
+        } : {}),
+    };
+    return (0, ledger_1.recordPrivateTurnDecision)(decision, deps);
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/heart/progress-story.js

@@ -4,7 +4,7 @@ exports.buildProgressStory = buildProgressStory;
 exports.renderProgressStory = renderProgressStory;
 const runtime_1 = require("../nerves/runtime");
 function labelForScope(scope) {
-    return scope === "inner-delegation" ? "inner work" : "shared work";
+    return scope === "inner-delegation" ? "private-runtime work" : "shared work";
 }
 function compactDetail(text) {
     if (typeof text !== "string")