@ouro.bot/cli 0.1.0-alpha.97 → 0.1.0-alpha.970

package/dist/senses/private-runtime-worker.js

@@ -0,0 +1,857 @@
+"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.HEARTBEAT_OK_REST_SUPPRESSION_MS = exports.HABIT_RECURSION_BURST_THRESHOLD = exports.HABIT_RECURSION_BURST_WINDOW_MS = exports.HABIT_RECURSION_MIN_INTERVAL_MS = void 0;
+exports.createPrivateRuntimeWorker = createPrivateRuntimeWorker;
+exports.startPrivateRuntimeWorker = startPrivateRuntimeWorker;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const private_runtime_1 = require("./private-runtime");
+const router_1 = require("../heart/external-events/router");
+const telegram_handoff_1 = require("./telegram-handoff");
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../heart/identity");
+const pending_1 = require("../mind/pending");
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const habit_session_1 = require("../heart/habits/habit-session");
+const flight_recorder_1 = require("../arc/flight-recorder");
+const habit_session_summary_1 = require("../heart/habits/habit-session-summary");
+const friends_1 = require("@ouro.bot/friends");
+const tools_base_1 = require("../repertoire/tools-base");
+const tools_surface_1 = require("../repertoire/tools-surface");
+const tools_1 = require("../repertoire/tools");
+const habit_policy_1 = require("../rsvp/habit-policy");
+const spend_ledger_1 = require("../rsvp/spend-ledger");
+const run_ledger_1 = require("../heart/run-ledger");
+const autonomy_budget_1 = require("../heart/autonomy-budget");
+const habit_lifecycle_guard_1 = require("./habit-lifecycle-guard");
+function createQueueCompletion(rejectOnError) {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return { promise, resolve, reject, errors: [], rejectOnError };
+}
+function isUsageData(value) {
+    const usage = value;
+    return !!usage
+        && typeof usage.input_tokens === "number"
+        && typeof usage.output_tokens === "number"
+        && typeof usage.total_tokens === "number";
+}
+function extractUsageFromHabitResults(results) {
+    const aggregate = {
+        input_tokens: 0,
+        output_tokens: 0,
+        reasoning_tokens: 0,
+        total_tokens: 0,
+    };
+    let found = false;
+    for (const result of results) {
+        if (!result || typeof result !== "object")
+            continue;
+        const usage = result.usage;
+        if (!isUsageData(usage))
+            continue;
+        found = true;
+        aggregate.input_tokens += usage.input_tokens;
+        aggregate.output_tokens += usage.output_tokens;
+        aggregate.reasoning_tokens += typeof usage.reasoning_tokens === "number" ? usage.reasoning_tokens : 0;
+        aggregate.total_tokens += usage.total_tokens;
+    }
+    return found ? aggregate : undefined;
+}
+function habitRunLedgerBase(habitRun) {
+    const target = {
+        habitName: habitRun.habit.name,
+        runId: habitRun.runId,
+        trigger: habitRun.trigger,
+        operationId: habitRun.operationId,
+    };
+    return {
+        agent: (0, identity_1.getAgentName)(),
+        triggerType: "habit",
+        sourceKind: "private-runtime",
+        senseOrHabit: habitRun.habit.name,
+        startedAt: habitRun.startedAt,
+        target,
+        idempotencyScope: target,
+        provider: "unknown",
+        model: "unknown",
+        sessionRef: {
+            channel: "inner",
+            keyHash: (0, run_ledger_1.runLedgerHash)({ habitName: habitRun.habit.name, runId: habitRun.runId }),
+        },
+    };
+}
+function recordHabitRunLedger(habitRun, lifecycle, endedAt) {
+    const usage = extractUsageFromHabitResults(habitRun.results);
+    const record = (0, run_ledger_1.createRunLedgerRecord)({
+        ...habitRunLedgerBase(habitRun),
+        lifecycle,
+        ...(endedAt ? { endedAt } : {}),
+        ...(lifecycle === "completed" || lifecycle === "error"
+            ? { usage: (0, run_ledger_1.usageMetadataFromUsageData)(usage, usage ? "provider" : "none") }
+            : {}),
+    });
+    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(habitRun.agentRoot, record);
+    if (habitRun.rsvpPolicy) {
+        try {
+            (0, spend_ledger_1.recordRsvpSpendLedgerRun)(habitRun.agentRoot, record);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "rsvp",
+                event: "rsvp.spend_ledger_record_error",
+                message: "failed to record RSVP spend ledger row",
+                meta: { runId: record.runId, lifecycle, error: String(error) },
+            });
+        }
+    }
+}
+function reserveHabitAutonomyBudget(habitRun, nowIso) {
+    const target = {
+        habitName: habitRun.habit.name,
+        runId: habitRun.runId,
+        trigger: habitRun.trigger,
+        operationId: habitRun.operationId,
+    };
+    if (habitRun.rsvpPolicy) {
+        target.rsvpSnapshotRef = habitRun.rsvpPolicy.snapshotRef;
+        target.rsvpBudgetRef = habitRun.rsvpPolicy.budgetRef;
+        target.rsvpIdempotencyRef = habitRun.rsvpPolicy.idempotencyRef;
+    }
+    const agentName = (0, identity_1.getAgentName)();
+    return (0, autonomy_budget_1.reserveAutonomyBudget)(habitRun.agentRoot, {
+        agent: agentName,
+        triggerType: "habit",
+        sourceKind: "private-runtime",
+        senseOrHabit: habitRun.habit.name,
+        target,
+        idempotencyKey: `habit:${habitRun.habit.name}:${habitRun.runId}`,
+        now: nowIso,
+    }, (0, autonomy_budget_1.resolveAutonomyBudgetPolicy)(habitRun.agentRoot, agentName));
+}
+/**
+ * External-event turns are paid model work, so they draw on their own daily allowance (the agent's
+ * habitPaidTurnsPerDay, counted under the "external-events" name so a busy event day cannot starve a
+ * habit) and share one storm breaker: three failed event turns within ten minutes pause event turns
+ * for thirty minutes.
+ */
+const EXTERNAL_EVENT_BUDGET_NAME = "external-events";
+function externalEventStorm(agentName) {
+    return {
+        agent: agentName,
+        triggerType: "habit",
+        sourceKind: "private-runtime",
+        senseOrHabit: EXTERNAL_EVENT_BUDGET_NAME,
+        provider: "model",
+        target: { kind: EXTERNAL_EVENT_BUDGET_NAME },
+        normalizedErrorName: "external_event_turn_failed",
+        normalizedErrorCode: "turn_failed",
+        codeLocation: "private-runtime-worker",
+        idempotencyBucket: EXTERNAL_EVENT_BUDGET_NAME,
+    };
+}
+/** A blocked event turn waits this long (the breaker's block length) and keeps its retry attempts. */
+const EXTERNAL_EVENT_BLOCKED_DEFER_MS = 30 * 60_000;
+function reserveExternalEventAutonomyBudget(event, nowIso) {
+    // Disk, parity and array failures always get a turn: the owner must hear about them even on a busy day.
+    if ([event, ...(event.relatedEvents ?? [])].some((member) => (0, telegram_handoff_1.isCriticalNoticeKey)(member.eventId)))
+        return null;
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const agentName = (0, identity_1.getAgentName)();
+    return (0, autonomy_budget_1.reserveAutonomyBudget)(agentRoot, {
+        agent: agentName,
+        triggerType: "habit",
+        sourceKind: "private-runtime",
+        senseOrHabit: EXTERNAL_EVENT_BUDGET_NAME,
+        target: { kind: EXTERNAL_EVENT_BUDGET_NAME },
+        idempotencyKey: `event:${event.recordPath}:${event.generation}:${event.claimOwner}`,
+        now: nowIso,
+        storm: externalEventStorm(agentName),
+    }, (0, autonomy_budget_1.resolveAutonomyBudgetPolicy)(agentRoot, agentName));
+}
+function recordExternalEventTurnFailure(nowIso) {
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    (0, autonomy_budget_1.recordAutonomyFailure)(agentRoot, { ...externalEventStorm((0, identity_1.getAgentName)()), occurredAt: nowIso }, (0, autonomy_budget_1.resolveAutonomyBudgetPolicy)(agentRoot, (0, identity_1.getAgentName)()));
+}
+/**
+ * Habit recursion detector thresholds. This protects against the *external*
+ * IPC self-loop where heartbeat-shaped messages get re-issued faster
+ * than their cadence — e.g. a hook misconfigured to repost on every
+ * heartbeat, a daemon retry storm, or a stuck timer firing back-to-back.
+ *
+ * MIN_INTERVAL_MS — two of the same habit within this window is suspect
+ * regardless of cadence (no realistic habit fires every few seconds).
+ * BURST_THRESHOLD over BURST_WINDOW_MS catches slower runaways that stay
+ * just under MIN_INTERVAL_MS.
+ *
+ * Detection is observation-only: it emits warn-level nerves events, it
+ * does not drop the message. An operator (or follow-up auto-recovery)
+ * decides what to do with the signal.
+ */
+exports.HABIT_RECURSION_MIN_INTERVAL_MS = 5_000;
+exports.HABIT_RECURSION_BURST_WINDOW_MS = 60_000;
+exports.HABIT_RECURSION_BURST_THRESHOLD = 5;
+exports.HEARTBEAT_OK_REST_SUPPRESSION_MS = 20 * 60_000;
+function defaultHasPendingWork(pendingDir) {
+    if (pendingDir)
+        return (0, pending_1.hasPendingMessages)(pendingDir);
+    const agentArgIndex = process.argv.indexOf("--agent");
+    const agentName = agentArgIndex >= 0 ? process.argv[agentArgIndex + 1] : undefined;
+    return agentName ? (0, pending_1.hasPendingMessages)((0, pending_1.getPrivateRuntimePendingDir)(agentName)) : false;
+}
+function isHeartbeatOkRestResult(result) {
+    if (!result || typeof result !== "object")
+        return false;
+    const maybeResult = result;
+    return maybeResult.turnOutcome === "rested" && maybeResult.restStatus === "HEARTBEAT_OK";
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content.trim();
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => isRecord(part) && typeof part.text === "string" ? part.text : "")
+        .filter((text) => text.trim().length > 0)
+        .join("\n")
+        .trim();
+}
+function resultMessages(result) {
+    if (Array.isArray(result))
+        return result.flatMap((entry) => resultMessages(entry));
+    return isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
+}
+function latestAssistantText(results) {
+    for (let resultIndex = results.length - 1; resultIndex >= 0; resultIndex--) {
+        const messages = resultMessages(results[resultIndex]);
+        for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
+            const message = messages[messageIndex];
+            if (!isRecord(message) || message.role !== "assistant")
+                continue;
+            const text = contentToText(message.content);
+            if (text.length > 0)
+                return text.replace(/^checkpoint\s*:\s*/i, "").trim() || text;
+        }
+    }
+    return null;
+}
+function deriveHabitSummarySnapshot(habitRun) {
+    const assistant = latestAssistantText(habitRun.results);
+    if (assistant)
+        return { summary: assistant, decisions: [], nextLikelyStep: null };
+    if (habitRun.errors.length > 0) {
+        return {
+            summary: `Habit ${habitRun.habit.name} finished with errors: ${habitRun.errors.join("; ")}`,
+            decisions: [],
+            nextLikelyStep: null,
+        };
+    }
+    const surfaced = habitRun.surfaceAttempts.find((attempt) => attempt.result !== "blocked" && attempt.result !== "failed" && attempt.result !== "unavailable");
+    if (surfaced) {
+        return {
+            summary: `Habit ${habitRun.habit.name} surfaced via ${surfaced.recipient}/${surfaced.channel}.`,
+            decisions: [],
+            nextLikelyStep: null,
+        };
+    }
+    const produced = habitRun.producedRefs.find((ref) => ref.kind !== "none");
+    if (produced) {
+        return {
+            summary: `Habit ${habitRun.habit.name} produced ${produced.kind}: ${produced.locator}.`,
+            decisions: [],
+            nextLikelyStep: null,
+        };
+    }
+    if (habitRun.results.some(isHeartbeatOkRestResult)) {
+        return {
+            summary: `Habit ${habitRun.habit.name} rested with HEARTBEAT_OK.`,
+            decisions: [],
+            nextLikelyStep: null,
+        };
+    }
+    return {
+        summary: `Habit ${habitRun.habit.name} completed without additional surfaced output.`,
+        decisions: [],
+        nextLikelyStep: null,
+    };
+}
+function readHabitForRun(agentRoot, habitName, errors) {
+    const habitPath = path.join(agentRoot, "habits", `${habitName}.md`);
+    try {
+        return (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        errors.push(`habit file could not be read: ${reason}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.habit_file_read_error",
+            message: "habit file could not be read for habit session",
+            meta: { habitName, habitPath, reason },
+        });
+        return (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error");
+    }
+}
+async function prepareHabitRun(habitName, trigger, startedAt) {
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const errors = [];
+    const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, readHabitForRun(agentRoot, habitName, errors));
+    if (habit.status === "degraded" && habit.degradedDetail !== null) {
+        errors.push(habit.degradedDetail);
+    }
+    const lifecycleBlockedReason = (0, habit_lifecycle_guard_1.privateRuntimeHabitRejectionReason)(habit, "private-runtime-worker");
+    const blockedReason = (0, habit_policy_1.isRsvpHabitName)(habitName) && !habit.rsvp
+        ? "RSVP habit metadata is required before private runtime execution"
+        : lifecycleBlockedReason;
+    if (blockedReason && !errors.includes(blockedReason))
+        errors.push(blockedReason);
+    const runId = (0, flight_recorder_1.createHabitRunId)(habitName, new Date(startedAt));
+    const operationId = habit.continuity.mode === "stateful" ? `habit:${habit.name}` : null;
+    const priorSessionSummary = readPriorSessionSummary(agentRoot, operationId);
+    const paths = (0, habit_session_1.createHabitSessionPaths)(agentRoot, runId, habit.name);
+    const friendStore = new friends_1.FileFriendStore(path.join(agentRoot, "friends"));
+    const permissionEnvelope = await (0, habit_session_1.normalizeHabitPermissionEnvelope)(habit, { agentRoot, friendStore });
+    const rsvpPolicy = habit.rsvp ? (0, habit_policy_1.rsvpHabitRuntimePolicy)(habit.rsvp) : undefined;
+    const requestedTools = blockedReason ? [] : habit.rsvp ? [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS] : habit.tools ?? null;
+    const toolPolicy = (0, habit_session_1.filterHabitToolsForEnvelope)([...tools_base_1.baseToolDefinitions, tools_surface_1.surfaceToolDefinition], requestedTools, permissionEnvelope, riskProfileForHabitPolicy);
+    return {
+        agentRoot,
+        habit,
+        runId,
+        operationId,
+        trigger,
+        startedAt,
+        priorSessionSummary,
+        paths,
+        permissionEnvelope,
+        toolPolicy,
+        ...(rsvpPolicy ? { rsvpPolicy } : {}),
+        ...(blockedReason ? { blockedReason } : {}),
+        friendStore,
+        results: [],
+        errors,
+        producedRefs: [],
+        surfaceAttempts: [],
+    };
+}
+function riskProfileForHabitPolicy(definition, name) {
+    const probeArgs = name === "shell" ? { command: "touch /tmp/habit-policy-probe" } : {};
+    return (0, tools_1.riskProfileForTool)(definition, name, probeArgs);
+}
+function readPriorSessionSummary(agentRoot, operationId) {
+    if (operationId === null)
+        return undefined;
+    try {
+        const summary = (0, habit_session_summary_1.readHabitSessionSummary)(agentRoot, { operationId, which: "latest" });
+        if (!summary)
+            return { mode: "stateful", summary: null, sources: {}, warnings: [] };
+        return {
+            mode: "stateful",
+            summary: summary.summary,
+            sources: summary.sources,
+            warnings: summary.warnings,
+        };
+    }
+    catch (error) {
+        return {
+            mode: "stateful",
+            summary: null,
+            sources: {},
+            warnings: [`prior summary read failed: ${String(error)}`],
+        };
+    }
+}
+function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1.runPrivateRuntimeTurn)(options), hasPendingWork = defaultHasPendingWork, nowSource = () => Date.now()) {
+    let running = false;
+    const queue = [];
+    const lastFireByHabit = new Map();
+    const recentHabitFires = [];
+    const startedHabitLedgerRunIds = new Set();
+    let heartbeatOkRestedAt = null;
+    function recordHabitStartIfNeeded(habitRun) {
+        if (startedHabitLedgerRunIds.has(habitRun.runId))
+            return;
+        recordHabitRunLedger(habitRun, "started");
+        startedHabitLedgerRunIds.add(habitRun.runId);
+    }
+    function recordHabitCompletion(habitRun, endedAt = habitRun.startedAt) {
+        recordHabitStartIfNeeded(habitRun);
+        recordHabitRunLedger(habitRun, habitRun.errors.length > 0 ? "error" : "completed", endedAt);
+        (0, habit_session_1.completeHabitRun)({
+            agentRoot: habitRun.agentRoot,
+            habit: habitRun.habit,
+            runId: habitRun.runId,
+            trigger: habitRun.trigger,
+            startedAt: habitRun.startedAt,
+            endedAt,
+            operationId: habitRun.operationId,
+            permissionEnvelope: habitRun.permissionEnvelope,
+            toolPolicy: habitRun.toolPolicy,
+            producedRefs: habitRun.producedRefs,
+            surfaceAttempts: habitRun.surfaceAttempts,
+            errors: habitRun.errors,
+            summarySnapshot: deriveHabitSummarySnapshot(habitRun),
+        });
+    }
+    function clearHeartbeatRestShield() {
+        heartbeatOkRestedAt = null;
+    }
+    function shouldReuseHeartbeatOkRest(habitName) {
+        if (habitName !== "heartbeat" || heartbeatOkRestedAt === null)
+            return false;
+        if (nowSource() - heartbeatOkRestedAt > exports.HEARTBEAT_OK_REST_SUPPRESSION_MS)
+            return false;
+        if (hasPendingWork()) {
+            clearHeartbeatRestShield();
+            return false;
+        }
+        return true;
+    }
+    async function reuseHeartbeatOkRest(habitName) {
+        const nowIso = new Date(nowSource()).toISOString();
+        const habitRun = await prepareHabitRun(habitName, "overdue", nowIso);
+        if (habitRun.blockedReason) {
+            clearHeartbeatRestShield();
+            recordHabitCompletion(habitRun, nowIso);
+            return;
+        }
+        habitRun.results.push({ turnOutcome: "rested", restStatus: "HEARTBEAT_OK" });
+        recordHabitCompletion(habitRun, nowIso);
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "senses",
+            event: "senses.heartbeat_ok_rest_reused",
+            message: "heartbeat skipped because previous HEARTBEAT_OK rest is still valid and no pending work exists",
+            meta: {
+                habitName,
+                quietWindowMs: exports.HEARTBEAT_OK_REST_SUPPRESSION_MS,
+                restedAgoMs: nowSource() - heartbeatOkRestedAt,
+            },
+        });
+    }
+    function recordHabitFireForRecursion(habitName) {
+        const now = nowSource();
+        const previous = lastFireByHabit.get(habitName);
+        if (previous !== undefined) {
+            const intervalMs = now - previous;
+            if (intervalMs < exports.HABIT_RECURSION_MIN_INTERVAL_MS) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.habit_recursion_suspected",
+                    message: "habit fired suspiciously fast after the previous fire — possible self-recursion or duplicate dispatch",
+                    meta: {
+                        habitName,
+                        intervalMs,
+                        thresholdMs: exports.HABIT_RECURSION_MIN_INTERVAL_MS,
+                    },
+                });
+            }
+        }
+        lastFireByHabit.set(habitName, now);
+        recentHabitFires.push(now);
+        while (recentHabitFires.length > 0 && now - recentHabitFires[0] > exports.HABIT_RECURSION_BURST_WINDOW_MS) {
+            recentHabitFires.shift();
+        }
+        if (recentHabitFires.length >= exports.HABIT_RECURSION_BURST_THRESHOLD) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.habit_recursion_burst",
+                message: "habit messages arriving in a burst — possible runaway loop",
+                meta: {
+                    count: recentHabitFires.length,
+                    windowMs: exports.HABIT_RECURSION_BURST_WINDOW_MS,
+                    thresholdCount: exports.HABIT_RECURSION_BURST_THRESHOLD,
+                    lastHabitName: habitName,
+                },
+            });
+        }
+    }
+    const startExternalEventHeartbeat = (event) => {
+        const renew = () => {
+            for (const member of [event, ...(event.relatedEvents ?? [])]) {
+                try {
+                    (0, router_1.renewExternalEventClaim)(member.recordPath, { owner: member.claimOwner, expectedGeneration: member.generation, leaseMs: 30_000 });
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn", component: "senses", event: "senses.external_event_lease_renew_error",
+                        message: "external-event turn lease renewal failed",
+                        meta: { recordPath: member.recordPath, generation: member.generation, error: error instanceof Error ? error.message : String(error) },
+                    });
+                }
+            }
+        };
+        renew();
+        const timer = setInterval(renew, 10_000);
+        timer.unref?.();
+        return () => clearInterval(timer);
+    };
+    async function run(reason, taskId, habitName, awaitName, trigger, privateTurnDecision, noSend, externalEvent, dispatchId) {
+        const completion = createQueueCompletion(dispatchId !== undefined);
+        let activeCompletion = completion;
+        if (running) {
+            queue.push({ reason, taskId, habitName, awaitName, trigger, privateTurnDecision, noSend, externalEvent, dispatchId, completion, ...(externalEvent ? { stopExternalEventHeartbeat: startExternalEventHeartbeat(externalEvent) } : {}) });
+            return completion.promise;
+        }
+        running = true;
+        void (async () => {
+            try {
+                let nextReason = reason;
+                let nextTaskId = taskId;
+                let nextHabitName = habitName;
+                let nextAwaitName = awaitName;
+                let nextTrigger = trigger;
+                let nextPrivateTurnDecision = privateTurnDecision;
+                let nextExternalEvent = externalEvent;
+                let nextExternalEventHeartbeat = externalEvent ? startExternalEventHeartbeat(externalEvent) : undefined;
+                let nextCompletion = completion;
+                let nextNoSend = reason === "habit" ? noSend : undefined;
+                runLoop: do {
+                    const currentReason = nextReason;
+                    const currentHabitName = nextHabitName;
+                    const currentTrigger = nextTrigger ?? "overdue";
+                    const currentNoSend = nextNoSend;
+                    const currentExternalEvent = nextExternalEvent;
+                    const currentExternalEventHeartbeat = nextExternalEventHeartbeat;
+                    const currentCompletion = nextCompletion;
+                    activeCompletion = currentCompletion;
+                    nextExternalEventHeartbeat = undefined;
+                    nextCompletion = undefined;
+                    const currentHabitRun = currentReason === "habit" && currentHabitName
+                        ? await prepareHabitRun(currentHabitName, currentTrigger, new Date(nowSource()).toISOString())
+                        : null;
+                    let currentHabitRunFinalized = false;
+                    const finalizeCurrentHabitRun = () => {
+                        if (!currentHabitRun || currentHabitRunFinalized)
+                            return;
+                        recordHabitCompletion(currentHabitRun, new Date(nowSource()).toISOString());
+                        currentHabitRunFinalized = true;
+                    };
+                    const turnErrors = [];
+                    if (!(currentReason === "habit" && currentHabitName === "heartbeat")) {
+                        clearHeartbeatRestShield();
+                    }
+                    let turnResult;
+                    let blockedAutonomyTurn = false;
+                    try {
+                        const turnStartedAt = new Date(nowSource()).toISOString();
+                        const autonomyDecision = currentHabitRun && !currentHabitRun.blockedReason
+                            ? reserveHabitAutonomyBudget(currentHabitRun, turnStartedAt)
+                            : currentExternalEvent
+                                ? reserveExternalEventAutonomyBudget(currentExternalEvent, turnStartedAt)
+                                : null;
+                        if (currentHabitRun)
+                            recordHabitStartIfNeeded(currentHabitRun);
+                        if (currentHabitRun?.blockedReason) {
+                            blockedAutonomyTurn = true;
+                            turnResult = {
+                                turnOutcome: "blocked",
+                                reason: currentHabitRun.blockedReason,
+                            };
+                            clearHeartbeatRestShield();
+                        }
+                        else if (autonomyDecision && !autonomyDecision.allowed) {
+                            blockedAutonomyTurn = true;
+                            const reason = `autonomy budget blocked: ${autonomyDecision.reason}`;
+                            turnErrors.push(reason);
+                            turnResult = {
+                                turnOutcome: "blocked",
+                                reason,
+                                autonomyReceiptId: autonomyDecision.receiptId,
+                            };
+                            clearHeartbeatRestShield();
+                        }
+                        else {
+                            const turnOptions = {
+                                reason: nextReason,
+                                taskId: nextTaskId,
+                                habitName: nextHabitName,
+                                awaitName: nextAwaitName,
+                                ...(currentNoSend ? { noSend: true } : {}),
+                                ...(nextPrivateTurnDecision ? { privateTurnDecision: nextPrivateTurnDecision } : {}),
+                                ...(nextExternalEvent ? { externalEvent: nextExternalEvent } : {}),
+                                ...(currentHabitRun
+                                    ? {
+                                        trigger: currentHabitRun.trigger,
+                                        preparedHabit: {
+                                            runId: currentHabitRun.runId,
+                                            trigger: currentHabitRun.trigger,
+                                            operationId: currentHabitRun.operationId,
+                                            habit: currentHabitRun.habit,
+                                            priorSessionSummary: currentHabitRun.priorSessionSummary,
+                                        },
+                                        habitSession: {
+                                            runId: currentHabitRun.runId,
+                                            sessionPath: currentHabitRun.paths.sessionPath,
+                                            pendingDir: currentHabitRun.paths.pendingDir,
+                                            permissionEnvelope: currentHabitRun.permissionEnvelope,
+                                            toolPolicy: currentHabitRun.toolPolicy,
+                                            ...(currentHabitRun.rsvpPolicy ? { rsvpPolicy: currentHabitRun.rsvpPolicy } : {}),
+                                            friendStore: currentHabitRun.friendStore,
+                                            recordProducedRef: (ref) => { currentHabitRun.producedRefs.push(ref); },
+                                            recordSurfaceAttempt: (attempt) => { currentHabitRun.surfaceAttempts.push(attempt); },
+                                            recordError: (error) => { currentHabitRun.errors.push(error); },
+                                        },
+                                    }
+                                    : {}),
+                            };
+                            turnResult = await runTurn(turnOptions);
+                        }
+                    }
+                    catch (error) {
+                        clearHeartbeatRestShield();
+                        turnErrors.push(error instanceof Error ? error.message : String(error));
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "error",
+                            component: "senses",
+                            event: "senses.private_runtime_worker_error",
+                            message: "private-runtime worker turn failed",
+                            meta: {
+                                reason: nextReason,
+                                error: error instanceof Error ? error.message : String(error),
+                            },
+                        });
+                    }
+                    currentExternalEventHeartbeat?.();
+                    if (currentExternalEvent) {
+                        const turnOutcome = turnResult && typeof turnResult === "object" && "turnOutcome" in turnResult
+                            ? turnResult.turnOutcome
+                            : undefined;
+                        const failureReason = turnErrors.length > 0 || turnOutcome === "errored"
+                            ? "private-runtime external-event turn failed"
+                            : blockedAutonomyTurn || turnOutcome === "blocked" || turnOutcome === "suspended"
+                                ? "external-event turn was blocked"
+                                : "external-event turn completed without a terminal disposition";
+                        const settledAt = nowSource();
+                        const deferUntil = blockedAutonomyTurn ? new Date(settledAt + EXTERNAL_EVENT_BLOCKED_DEFER_MS).toISOString() : undefined;
+                        let settledIncomplete = false;
+                        for (const member of [currentExternalEvent, ...(currentExternalEvent.relatedEvents ?? [])]) {
+                            const result = (0, router_1.settleExternalEventFailureIfOwned)(member.recordPath, {
+                                owner: member.claimOwner,
+                                expectedGeneration: member.generation,
+                                error: failureReason,
+                                ...(deferUntil ? { deferUntil } : {}),
+                            });
+                            settledIncomplete = result.settled || settledIncomplete;
+                        }
+                        if (!blockedAutonomyTurn && (turnErrors.length > 0 || turnOutcome === "errored" || settledIncomplete))
+                            recordExternalEventTurnFailure(new Date(settledAt).toISOString());
+                        if (settledIncomplete && turnErrors.length === 0)
+                            turnErrors.push(failureReason);
+                    }
+                    if (currentReason === "habit" && currentHabitName === "heartbeat") {
+                        heartbeatOkRestedAt = isHeartbeatOkRestResult(turnResult) ? nowSource() : null;
+                    }
+                    if (currentHabitRun) {
+                        currentHabitRun.results.push(turnResult);
+                        currentHabitRun.errors.push(...turnErrors);
+                    }
+                    currentCompletion?.errors.push(...turnErrors);
+                    const settleCurrentCompletion = () => {
+                        /* v8 ignore next -- every run and queued entry is constructed with a completion @preserve */
+                        if (!currentCompletion)
+                            return;
+                        if (currentCompletion.rejectOnError && currentCompletion.errors.length > 0)
+                            currentCompletion.reject(new Error(currentCompletion.errors.join("; ")));
+                        else
+                            currentCompletion.resolve();
+                        if (activeCompletion === currentCompletion)
+                            activeCompletion = undefined;
+                    };
+                    // Drain queue first: queued entries carry their own decisions.
+                    if (queue.length > 0)
+                        settleCurrentCompletion();
+                    while (queue.length > 0) {
+                        const next = queue.shift();
+                        activeCompletion = next.completion;
+                        if (next.reason === "habit" && next.habitName === "heartbeat" && shouldReuseHeartbeatOkRest(next.habitName)) {
+                            finalizeCurrentHabitRun();
+                            await reuseHeartbeatOkRest(next.habitName);
+                            next.completion.resolve();
+                            /* v8 ignore next -- activeCompletion was assigned from this exact queue entry immediately above @preserve */
+                            if (activeCompletion === next.completion)
+                                activeCompletion = undefined;
+                            continue;
+                        }
+                        if (!(next.reason === "habit" && next.habitName === "heartbeat")) {
+                            clearHeartbeatRestShield();
+                        }
+                        finalizeCurrentHabitRun();
+                        nextReason = next.reason;
+                        nextTaskId = next.taskId;
+                        nextHabitName = next.habitName;
+                        nextAwaitName = next.awaitName;
+                        nextTrigger = next.trigger;
+                        nextPrivateTurnDecision = next.privateTurnDecision;
+                        nextExternalEvent = next.externalEvent;
+                        nextExternalEventHeartbeat = next.stopExternalEventHeartbeat;
+                        nextCompletion = next.completion;
+                        nextNoSend = next.reason === "habit" ? next.noSend : undefined;
+                        continue runLoop;
+                    }
+                    if (blockedAutonomyTurn) {
+                        finalizeCurrentHabitRun();
+                        settleCurrentCompletion();
+                        break;
+                    }
+                    // Then check hasPendingWork. A follow-up turn would need its own
+                    // approved private-turn decision, which only the daemon issues, so the
+                    // run ends here and the pending work waits for the next authorized turn.
+                    if (hasPendingWork(currentHabitRun?.paths.pendingDir)) {
+                        if (currentExternalEvent && (turnErrors.length > 0
+                            || (turnResult && typeof turnResult === "object" && "turnOutcome" in turnResult && turnResult.turnOutcome === "errored"))) {
+                            finalizeCurrentHabitRun();
+                            settleCurrentCompletion();
+                            break;
+                        }
+                        clearHeartbeatRestShield();
+                        // Pending work remains and the queue is empty. A chained turn would
+                        // carry no daemon-issued decision, and the provider boundary refuses
+                        // decisionless turns, so end the run; the next daemon trigger resumes.
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "info",
+                            component: "senses",
+                            event: "senses.private_runtime_worker_chain_needs_decision",
+                            message: "private-runtime worker stopped: pending work remains but a chained turn has no approved decision",
+                            meta: { reason: currentReason, habitName: currentHabitName ?? null },
+                        });
+                        finalizeCurrentHabitRun();
+                        settleCurrentCompletion();
+                        break;
+                    }
+                    finalizeCurrentHabitRun();
+                    settleCurrentCompletion();
+                    break;
+                } while (true);
+            }
+            finally {
+                running = false;
+            }
+        })().catch((error) => {
+            activeCompletion?.reject(error);
+            for (const queued of queue.splice(0)) {
+                queued.stopExternalEventHeartbeat?.();
+                queued.completion.reject(error);
+            }
+        });
+        return completion.promise;
+    }
+    async function handleMessage(message) {
+        if (!message || typeof message !== "object")
+            return;
+        const maybeMessage = message;
+        if (maybeMessage.type === "habit") {
+            /* v8 ignore next -- defensive fallback: live habit dispatch always sets habitName @preserve */
+            const habitName = maybeMessage.habitName ?? "(unnamed)";
+            if (shouldReuseHeartbeatOkRest(habitName)) {
+                await reuseHeartbeatOkRest(habitName);
+                return;
+            }
+            recordHabitFireForRecursion(habitName);
+            await run("habit", undefined, maybeMessage.habitName, undefined, maybeMessage.trigger ?? "overdue", maybeMessage.privateTurnDecision, maybeMessage.noSend, undefined, maybeMessage.dispatchId);
+            return;
+        }
+        if (maybeMessage.type === "await") {
+            clearHeartbeatRestShield();
+            /* v8 ignore next -- defensive fallback: live await dispatch always sets awaitName @preserve */
+            const awaitName = maybeMessage.awaitName ?? "(unnamed)";
+            recordHabitFireForRecursion(`await:${awaitName}`);
+            await run("await", undefined, undefined, maybeMessage.awaitName, undefined, maybeMessage.privateTurnDecision, undefined, undefined, maybeMessage.dispatchId);
+            return;
+        }
+        if (maybeMessage.type === "heartbeat") {
+            // Backward compatibility: heartbeat -> habit/heartbeat
+            if (shouldReuseHeartbeatOkRest("heartbeat")) {
+                await reuseHeartbeatOkRest("heartbeat");
+                return;
+            }
+            recordHabitFireForRecursion("heartbeat");
+            await run("habit", undefined, "heartbeat", undefined, "overdue", maybeMessage.privateTurnDecision, undefined, undefined, maybeMessage.dispatchId);
+            return;
+        }
+        if (maybeMessage.type === "poke") {
+            clearHeartbeatRestShield();
+            await run("instinct", maybeMessage.taskId, undefined, undefined, undefined, maybeMessage.privateTurnDecision, undefined, undefined, maybeMessage.dispatchId);
+            return;
+        }
+        if (maybeMessage.type === "chat" ||
+            maybeMessage.type === "message") {
+            clearHeartbeatRestShield();
+            await run("instinct", undefined, undefined, undefined, undefined, maybeMessage.privateTurnDecision, undefined, maybeMessage.externalEvent, maybeMessage.dispatchId);
+            return;
+        }
+        if (maybeMessage.type === "shutdown") {
+            process.exit(0);
+        }
+    }
+    function cancelMessage(dispatchId) {
+        const index = queue.findIndex((entry) => entry.dispatchId === dispatchId);
+        if (index < 0)
+            return false;
+        const [cancelled] = queue.splice(index, 1);
+        cancelled?.stopExternalEventHeartbeat?.();
+        cancelled?.completion.reject(new Error(`Private-runtime dispatch ${dispatchId} was cancelled.`));
+        return true;
+    }
+    return { run, handleMessage, cancelMessage };
+}
+async function startPrivateRuntimeWorker(options = {}) {
+    const worker = createPrivateRuntimeWorker();
+    if (options.attachProcessListeners ?? true) {
+        process.on("message", (message) => {
+            void worker.handleMessage(message);
+        });
+        process.on("disconnect", () => {
+            process.exit(0);
+        });
+    }
+    for (const message of options.bufferedMessages ?? []) {
+        void worker.handleMessage(message);
+    }
+    return worker;
+}