@ouro.bot/cli 0.1.0-alpha.674 → 0.1.0-alpha.676

package/dist/senses/inner-dialog-worker.js

@@ -36,532 +36,26 @@ 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 = exports.MAX_CONSECUTIVE_INSTINCT_TURNS = void 0;
 exports.createInnerDialogWorker = createInnerDialogWorker;
 exports.startInnerDialogWorker = startInnerDialogWorker;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const inner_dialog_1 = require("./inner-dialog");
 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");
-/**
- * Cap on consecutive `instinct` follow-on turns triggered by `hasPendingWork()`
- * with no externally-queued work in between. Without this cap, a turn that
- * writes anything back into the inner-dialog pending dir as a side effect of
- * processing (e.g. a surface tool routing a response) puts the worker into
- * a self-sustaining loop where the next turn's drain produces another write,
- * and so on. Real workflows rarely chain more than 2–3 instinct turns; an
- * external trigger (habit, poke, chat) resets the counter so legitimate
- * follow-on work is unaffected.
- *
- * Three feels right: legitimate cascading follow-ups (e.g. processing a
- * batch of delegated returns) get through; a true self-loop caps fast.
- */
+const innerDialog = __importStar(require("./inner-dialog"));
+const privateRuntimeWorker = __importStar(require("./private-runtime-worker"));
 exports.MAX_CONSECUTIVE_INSTINCT_TURNS = 3;
-/**
- * Habit recursion detector thresholds. The instinct cap above protects
- * against pending-dir self-loops; 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 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 fallbackHabitFile(habitName) {
-    return {
-        name: habitName,
-        title: habitName,
-        cadence: null,
-        status: "active",
-        lastRun: null,
-        created: null,
-        tools: [],
-        origin: null,
-        surface: { family: false, originator: false, extra: [] },
-        continuity: { mode: "fresh" },
-        body: "",
-    };
-}
-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 fallbackHabitFile(habitName);
-    }
-}
-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));
-    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 toolPolicy = (0, habit_session_1.filterHabitToolsForEnvelope)([...tools_base_1.baseToolDefinitions, tools_surface_1.surfaceToolDefinition], habit.tools ?? null, permissionEnvelope, riskProfileForHabitPolicy);
-    return {
-        agentRoot,
-        habit,
-        runId,
-        operationId,
-        trigger,
-        startedAt,
-        priorSessionSummary,
-        paths,
-        permissionEnvelope,
-        toolPolicy,
-        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 createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = (pendingDir) => (0, pending_1.hasPendingMessages)(pendingDir ?? (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)())), nowSource = () => Date.now()) {
-    let running = false;
-    const queue = [];
-    const lastFireByHabit = new Map();
-    const recentHabitFires = [];
-    let heartbeatOkRestedAt = null;
-    function recordHabitCompletion(habitRun, endedAt = habitRun.startedAt) {
-        (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);
-        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,
-                },
-            });
-        }
-    }
-    async function run(reason, taskId, habitName, awaitName, trigger) {
-        if (running) {
-            queue.push({ reason, taskId, habitName, awaitName, trigger });
-            return;
-        }
-        running = true;
-        try {
-            let nextReason = reason;
-            let nextTaskId = taskId;
-            let nextHabitName = habitName;
-            let nextAwaitName = awaitName;
-            let nextTrigger = trigger;
-            let nextHabitRun = null;
-            let consecutiveInstinctTurns = reason === "instinct" ? 1 : 0;
-            runLoop: do {
-                const currentReason = nextReason;
-                const currentHabitName = nextHabitName;
-                const currentTrigger = nextTrigger ?? "overdue";
-                const currentHabitRun = currentReason === "habit" && currentHabitName
-                    ? nextHabitRun && nextHabitRun.habit.name === currentHabitName
-                        ? nextHabitRun
-                        : await prepareHabitRun(currentHabitName, currentTrigger, new Date(nowSource()).toISOString())
-                    : null;
-                nextHabitRun = 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;
-                try {
-                    const turnOptions = {
-                        reason: nextReason,
-                        taskId: nextTaskId,
-                        habitName: nextHabitName,
-                        awaitName: nextAwaitName,
-                        ...(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,
-                                    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.inner_dialog_worker_error",
-                        message: "inner dialog worker turn failed",
-                        meta: {
-                            reason: nextReason,
-                            error: error instanceof Error ? error.message : String(error),
-                        },
-                    });
-                }
-                if (currentReason === "habit" && currentHabitName === "heartbeat") {
-                    heartbeatOkRestedAt = isHeartbeatOkRestResult(turnResult) ? nowSource() : null;
-                }
-                if (currentHabitRun) {
-                    currentHabitRun.results.push(turnResult);
-                    currentHabitRun.errors.push(...turnErrors);
-                }
-                // Drain queue first. Externally-queued work resets the instinct cap
-                // because a real outside trigger arrived between turns.
-                while (queue.length > 0) {
-                    const next = queue.shift();
-                    if (next.reason === "habit" && next.habitName === "heartbeat" && shouldReuseHeartbeatOkRest(next.habitName)) {
-                        finalizeCurrentHabitRun();
-                        await reuseHeartbeatOkRest(next.habitName);
-                        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;
-                    consecutiveInstinctTurns = nextReason === "instinct" ? consecutiveInstinctTurns + 1 : 0;
-                    continue runLoop;
-                }
-                // Then check hasPendingWork fallback. This is the loop site: any
-                // tool that writes to the inner-dialog pending dir during a turn
-                // would cause hasPendingWork() to be true here, producing a
-                // self-sustaining "instinct" loop with no external input. Cap it.
-                if (hasPendingWork(currentHabitRun?.paths.pendingDir)) {
-                    clearHeartbeatRestShield();
-                    if (consecutiveInstinctTurns >= exports.MAX_CONSECUTIVE_INSTINCT_TURNS) {
-                        (0, runtime_1.emitNervesEvent)({
-                            level: "warn",
-                            component: "senses",
-                            event: "senses.inner_dialog_worker_instinct_loop_capped",
-                            message: "inner dialog worker stopped chaining instinct turns; pending work remains for next external trigger",
-                            meta: {
-                                consecutiveInstinctTurns,
-                                cap: exports.MAX_CONSECUTIVE_INSTINCT_TURNS,
-                                lastReason: nextReason,
-                            },
-                        });
-                        finalizeCurrentHabitRun();
-                        break;
-                    }
-                    if (currentReason === "habit" && currentHabitName && currentHabitRun) {
-                        consecutiveInstinctTurns += 1;
-                        nextReason = "habit";
-                        nextTaskId = undefined;
-                        nextHabitName = currentHabitName;
-                        nextAwaitName = undefined;
-                        nextTrigger = currentTrigger;
-                        nextHabitRun = currentHabitRun;
-                    }
-                    else {
-                        finalizeCurrentHabitRun();
-                        consecutiveInstinctTurns += 1;
-                        nextReason = "instinct";
-                        nextTaskId = undefined;
-                        nextHabitName = undefined;
-                        nextAwaitName = undefined;
-                        nextTrigger = undefined;
-                    }
-                    continue;
-                }
-                finalizeCurrentHabitRun();
-                break;
-            } while (true);
-        }
-        finally {
-            running = false;
-        }
-    }
-    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");
-            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);
-            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");
-            return;
-        }
-        if (maybeMessage.type === "poke") {
-            clearHeartbeatRestShield();
-            await run("instinct", maybeMessage.taskId);
-            return;
-        }
-        if (maybeMessage.type === "chat" ||
-            maybeMessage.type === "message") {
-            clearHeartbeatRestShield();
-            await run("instinct");
-            return;
-        }
-        if (maybeMessage.type === "shutdown") {
-            process.exit(0);
-        }
-    }
-    return { run, handleMessage };
+function createInnerDialogWorker(runTurn = (options) => {
+    return innerDialog.runInnerDialogTurn(options);
+}, hasPendingWork, nowSource) {
+    return privateRuntimeWorker.createPrivateRuntimeWorker(runTurn, hasPendingWork, nowSource);
 }
 async function startInnerDialogWorker() {
-    const worker = createInnerDialogWorker();
-    process.on("message", (message) => {
-        void worker.handleMessage(message);
-    });
-    process.on("disconnect", () => {
-        process.exit(0);
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "senses",
+        event: "senses.inner_dialog_worker_compat_start",
+        message: "legacy inner-dialog worker startup delegated to private-runtime worker",
+        meta: { target: "private-runtime-worker" },
     });
-    await worker.run("boot");
+    await privateRuntimeWorker.startPrivateRuntimeWorker();
 }