@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.1

package/dist/senses/cli.js

@@ -0,0 +1,523 @@
+"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.MarkdownStreamer = exports.InputController = exports.Spinner = void 0;
+exports.handleSigint = handleSigint;
+exports.addHistory = addHistory;
+exports.renderMarkdown = renderMarkdown;
+exports.createCliCallbacks = createCliCallbacks;
+exports.main = main;
+const readline = __importStar(require("readline"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const core_1 = require("../heart/core");
+const prompt_1 = require("../mind/prompt");
+const phrases_1 = require("../mind/phrases");
+const format_1 = require("../mind/format");
+const config_1 = require("../heart/config");
+const context_1 = require("../mind/context");
+const commands_1 = require("./commands");
+const identity_1 = require("../heart/identity");
+const nerves_1 = require("../nerves");
+const store_file_1 = require("../mind/friends/store-file");
+const resolver_1 = require("../mind/friends/resolver");
+const tokens_1 = require("../mind/friends/tokens");
+const cli_logging_1 = require("../nerves/cli-logging");
+const runtime_1 = require("../nerves/runtime");
+const trust_gate_1 = require("./trust-gate");
+// spinner that only touches stderr, cleans up after itself
+// exported for direct testability (stop-without-start branch)
+class Spinner {
+    frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    i = 0;
+    iv = null;
+    piv = null;
+    msg = "";
+    phrases = null;
+    lastPhrase = "";
+    constructor(m = "working", phrases) {
+        this.msg = m;
+        if (phrases && phrases.length > 0)
+            this.phrases = phrases;
+    }
+    start() {
+        process.stderr.write("\r\x1b[K");
+        this.spin();
+        this.iv = setInterval(() => this.spin(), 80);
+        if (this.phrases) {
+            this.piv = setInterval(() => this.rotatePhrase(), 1500);
+        }
+    }
+    spin() {
+        process.stderr.write(`\r${this.frames[this.i]} ${this.msg}... `);
+        this.i = (this.i + 1) % this.frames.length;
+    }
+    rotatePhrase() {
+        const next = (0, phrases_1.pickPhrase)(this.phrases, this.lastPhrase);
+        this.lastPhrase = next;
+        this.msg = next;
+    }
+    stop(ok) {
+        if (this.iv) {
+            clearInterval(this.iv);
+            this.iv = null;
+        }
+        if (this.piv) {
+            clearInterval(this.piv);
+            this.piv = null;
+        }
+        process.stderr.write("\r\x1b[K");
+        /* v8 ignore next -- ok parameter currently unused by callers @preserve */
+        if (ok)
+            process.stderr.write(`\x1b[32m\u2713\x1b[0m ${ok}\n`);
+    }
+    fail(msg) {
+        this.stop();
+        process.stderr.write(`\x1b[31m\u2717\x1b[0m ${msg}\n`);
+    }
+}
+exports.Spinner = Spinner;
+// Input controller: pauses readline during model/tool execution.
+// Does NOT touch raw mode — readline with terminal:true manages raw mode
+// internally. Touching it causes ^C to be echoed by the terminal driver.
+// During suppress, we consume stdin data ourselves to swallow stray
+// keystrokes and catch Ctrl-C (0x03) for interrupt.
+class InputController {
+    rl;
+    suppressed = false;
+    dataHandler = null;
+    onInterrupt = null;
+    constructor(rl) {
+        this.rl = rl;
+    }
+    suppress(onInterrupt) {
+        if (this.suppressed)
+            return;
+        this.suppressed = true;
+        this.onInterrupt = onInterrupt || null;
+        this.rl.pause();
+        // Consume stdin to swallow keystrokes; catch Ctrl-C (0x03)
+        this.dataHandler = (data) => {
+            if (data[0] === 0x03 && this.onInterrupt) {
+                this.onInterrupt();
+            }
+            // All other input is swallowed
+        };
+        process.stdin.on("data", this.dataHandler);
+        // rl.pause() paused stdin — resume it so our data handler receives keypresses
+        process.stdin.resume();
+    }
+    restore() {
+        if (!this.suppressed)
+            return;
+        this.suppressed = false;
+        if (this.dataHandler) {
+            process.stdin.removeListener("data", this.dataHandler);
+            this.dataHandler = null;
+        }
+        this.onInterrupt = null;
+        this.rl.resume();
+    }
+}
+exports.InputController = InputController;
+// Ctrl-C handling: returns "clear" if input was non-empty, "warn" on first empty press, "exit" on second
+let _ctrlCWarned = false;
+function handleSigint(_rl, currentInput) {
+    if (currentInput.length > 0) {
+        _ctrlCWarned = false;
+        return "clear";
+    }
+    if (_ctrlCWarned) {
+        _ctrlCWarned = false;
+        return "exit";
+    }
+    _ctrlCWarned = true;
+    return "warn";
+}
+// History management
+function addHistory(history, entry) {
+    if (!entry.trim())
+        return;
+    if (history.length > 0 && history[history.length - 1] === entry)
+        return;
+    history.push(entry);
+}
+function renderMarkdown(text) {
+    const placeholders = [];
+    // Protect fenced code blocks
+    let result = text.replace(/```(?:\w*\n)?([\s\S]*?)```/g, (_m, code) => {
+        const idx = placeholders.length;
+        placeholders.push(`\x1b[2m${code.replace(/\n$/, "")}\x1b[22m`);
+        return `\x00${idx}\x00`;
+    });
+    // Protect inline code
+    result = result.replace(/`([^`\n]+)`/g, (_m, code) => {
+        const idx = placeholders.length;
+        placeholders.push(`\x1b[36m${code}\x1b[39m`);
+        return `\x00${idx}\x00`;
+    });
+    // Bold
+    result = result.replace(/\*\*(.+?)\*\*/g, "\x1b[1m$1\x1b[22m");
+    // Italic (avoid matching inside bold remnants)
+    result = result.replace(/(?<!\*)\*(.+?)\*(?!\*)/g, "\x1b[3m$1\x1b[23m");
+    // Restore placeholders
+    result = result.replace(/\x00(\d+)\x00/g, (_m, idx) => placeholders[parseInt(idx)]);
+    return result;
+}
+// Ordered longest-first so we match ``` before ` and ** before *
+const MARKERS = ["```", "**", "*", "`"];
+class MarkdownStreamer {
+    buf = "";
+    openMarker = null;
+    push(text) {
+        this.buf += text;
+        return this.drain(false);
+    }
+    flush() {
+        return this.drain(true);
+    }
+    reset() {
+        this.buf = "";
+        this.openMarker = null;
+    }
+    drain(final) {
+        let out = "";
+        while (this.buf.length > 0) {
+            if (this.openMarker) {
+                const closeIdx = this.buf.indexOf(this.openMarker);
+                if (closeIdx !== -1) {
+                    const segment = this.openMarker + this.buf.slice(0, closeIdx + this.openMarker.length);
+                    out += renderMarkdown(segment);
+                    this.buf = this.buf.slice(closeIdx + this.openMarker.length);
+                    this.openMarker = null;
+                    continue;
+                }
+                if (final) {
+                    out += renderMarkdown(this.openMarker + this.buf);
+                    this.buf = "";
+                    this.openMarker = null;
+                }
+                break;
+            }
+            // Normal mode — look for the next opening marker
+            let earliest = -1;
+            let matched = null;
+            for (const m of MARKERS) {
+                const idx = this.buf.indexOf(m);
+                if (idx !== -1 && (earliest === -1 || idx < earliest)) {
+                    earliest = idx;
+                    matched = m;
+                }
+            }
+            if (matched !== null && earliest !== -1) {
+                // If the tail from the match to end-of-buffer is a proper prefix of a
+                // longer marker, hold it back rather than consuming it prematurely.
+                // E.g. a trailing `*` could be the start of `**`, trailing `` ` `` could be `` ``` ``.
+                const tail = this.buf.slice(earliest);
+                if (!final && MARKERS.some(m => m.length > tail.length && m.startsWith(tail))) {
+                    if (earliest > 0) {
+                        out += renderMarkdown(this.buf.slice(0, earliest));
+                        this.buf = this.buf.slice(earliest);
+                    }
+                    break;
+                }
+                if (earliest > 0) {
+                    out += renderMarkdown(this.buf.slice(0, earliest));
+                }
+                this.buf = this.buf.slice(earliest + matched.length);
+                this.openMarker = matched;
+                continue;
+            }
+            out += renderMarkdown(this.buf);
+            this.buf = "";
+            break;
+        }
+        return out;
+    }
+}
+exports.MarkdownStreamer = MarkdownStreamer;
+function createCliCallbacks() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.cli_callbacks_created",
+        message: "cli callbacks created",
+        meta: {},
+    });
+    let currentSpinner = null;
+    let hadReasoning = false;
+    let hadToolRun = false;
+    let textDirty = false; // true when text/reasoning was written without a trailing newline
+    const streamer = new MarkdownStreamer();
+    return {
+        onModelStart: () => {
+            currentSpinner?.stop();
+            currentSpinner = null;
+            hadReasoning = false;
+            textDirty = false;
+            streamer.reset();
+            const phrases = (0, phrases_1.getPhrases)();
+            const pool = hadToolRun ? phrases.followup : phrases.thinking;
+            const first = (0, phrases_1.pickPhrase)(pool);
+            currentSpinner = new Spinner(first, pool);
+            currentSpinner.start();
+        },
+        onModelStreamStart: () => {
+            currentSpinner?.stop();
+            currentSpinner = null;
+        },
+        onTextChunk: (text) => {
+            if (hadReasoning) {
+                process.stdout.write("\n\n");
+                hadReasoning = false;
+            }
+            const rendered = streamer.push(text);
+            if (rendered)
+                process.stdout.write(rendered);
+            textDirty = text.length > 0 && !text.endsWith("\n");
+        },
+        onReasoningChunk: (text) => {
+            hadReasoning = true;
+            process.stdout.write(`\x1b[2m${text}\x1b[0m`);
+            textDirty = text.length > 0 && !text.endsWith("\n");
+        },
+        onToolStart: (_name, _args) => {
+            // Stop the model-start spinner: when the model returns only tool calls
+            // (no content/reasoning), onModelStreamStart never fires, so the old
+            // spinner's intervals would leak.
+            currentSpinner?.stop();
+            // Ensure the spinner starts on a fresh line so it doesn't overwrite
+            // the last line of text/reasoning output via \r\x1b[K
+            if (textDirty) {
+                process.stdout.write("\n");
+                textDirty = false;
+            }
+            const toolPhrases = (0, phrases_1.getPhrases)().tool;
+            const first = (0, phrases_1.pickPhrase)(toolPhrases);
+            currentSpinner = new Spinner(first, toolPhrases);
+            currentSpinner.start();
+            hadToolRun = true;
+        },
+        onToolEnd: (name, argSummary, success) => {
+            currentSpinner?.stop();
+            currentSpinner = null;
+            const msg = (0, format_1.formatToolResult)(name, argSummary, success);
+            const color = success ? "\x1b[32m" : "\x1b[31m";
+            process.stderr.write(`${color}${msg}\x1b[0m\n`);
+        },
+        onError: (error, severity) => {
+            if (severity === "transient") {
+                currentSpinner?.fail(error.message);
+                currentSpinner = null;
+            }
+            else {
+                currentSpinner?.stop();
+                currentSpinner = null;
+                process.stderr.write(`\x1b[31m${(0, format_1.formatError)(error)}\x1b[0m\n`);
+            }
+        },
+        onKick: () => {
+            currentSpinner?.stop();
+            currentSpinner = null;
+            if (textDirty) {
+                process.stdout.write("\n");
+                textDirty = false;
+            }
+            process.stderr.write(`\x1b[33m${(0, format_1.formatKick)()}\x1b[0m\n`);
+        },
+        flushMarkdown: () => {
+            currentSpinner?.stop();
+            currentSpinner = null;
+            const remaining = streamer.flush();
+            if (remaining)
+                process.stdout.write(remaining);
+        },
+    };
+}
+async function main() {
+    // Fail fast if provider is misconfigured (triggers human-readable error + exit)
+    (0, core_1.getProvider)();
+    const registry = (0, commands_1.createCommandRegistry)();
+    (0, commands_1.registerDefaultCommands)(registry);
+    // Resolve context kernel (identity + channel) for CLI
+    const friendsPath = path.join((0, identity_1.getAgentRoot)(), "friends");
+    const friendStore = new store_file_1.FileFriendStore(friendsPath);
+    const username = os.userInfo().username;
+    const hostname = os.hostname();
+    const localExternalId = `${username}@${hostname}`;
+    const resolver = new resolver_1.FriendResolver(friendStore, {
+        provider: "local",
+        externalId: localExternalId,
+        displayName: username,
+        channel: "cli",
+    });
+    const resolvedContext = await resolver.resolve();
+    const cliToolContext = {
+        /* v8 ignore next -- CLI has no OAuth sign-in; this no-op satisfies the interface @preserve */
+        signin: async () => undefined,
+        context: resolvedContext,
+        friendStore,
+    };
+    const friendId = resolvedContext.friend.id;
+    (0, cli_logging_1.configureCliRuntimeLogger)(friendId);
+    const sessPath = (0, config_1.sessionPath)(friendId, "cli", "session");
+    // Load existing session or start fresh
+    const existing = (0, context_1.loadSession)(sessPath);
+    const messages = existing?.messages && existing.messages.length > 0
+        ? existing.messages
+        : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", undefined, resolvedContext) }];
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    const ctrl = new InputController(rl);
+    let currentAbort = null;
+    const history = [];
+    let closed = false;
+    rl.on("close", () => { closed = true; });
+    // eslint-disable-next-line no-console -- terminal UX: startup banner
+    console.log(`\n${(0, identity_1.getAgentName)()} (type /commands for help)\n`);
+    const cliCallbacks = createCliCallbacks();
+    process.stdout.write("\x1b[36m> \x1b[0m");
+    // Ctrl-C at the input prompt: clear line or warn/exit
+    // readline with terminal:true catches Ctrl-C in raw mode (no ^C echo)
+    rl.on("SIGINT", () => {
+        const rlInt = rl;
+        const currentLine = rlInt.line || "";
+        const result = handleSigint(rl, currentLine);
+        if (result === "clear") {
+            rlInt.line = "";
+            rlInt.cursor = 0;
+            process.stdout.write("\r\x1b[K\x1b[36m> \x1b[0m");
+        }
+        else if (result === "warn") {
+            rlInt.line = "";
+            rlInt.cursor = 0;
+            process.stdout.write("\r\x1b[K");
+            process.stderr.write("press Ctrl-C again to exit\n");
+            process.stdout.write("\x1b[36m> \x1b[0m");
+        }
+        else {
+            rl.close();
+        }
+    });
+    try {
+        for await (const input of rl) {
+            if (closed)
+                break;
+            if (!input.trim()) {
+                process.stdout.write("\x1b[36m> \x1b[0m");
+                continue;
+            }
+            const trustGate = (0, trust_gate_1.enforceTrustGate)({
+                friend: resolvedContext.friend,
+                provider: "local",
+                externalId: localExternalId,
+                channel: "cli",
+            });
+            if (!trustGate.allowed) {
+                if (trustGate.reason === "stranger_first_reply") {
+                    process.stdout.write(`${trustGate.autoReply}\n`);
+                }
+                if (closed)
+                    break;
+                process.stdout.write("\x1b[36m> \x1b[0m");
+                continue;
+            }
+            // Check for slash commands
+            const parsed = (0, commands_1.parseSlashCommand)(input);
+            if (parsed) {
+                const dispatchResult = registry.dispatch(parsed.command, { channel: "cli" });
+                if (dispatchResult.handled && dispatchResult.result) {
+                    if (dispatchResult.result.action === "exit") {
+                        break;
+                    }
+                    else if (dispatchResult.result.action === "new") {
+                        messages.length = 0;
+                        messages.push({ role: "system", content: await (0, prompt_1.buildSystem)("cli") });
+                        (0, context_1.deleteSession)(sessPath);
+                        // eslint-disable-next-line no-console -- terminal UX: session cleared
+                        console.log("session cleared");
+                        process.stdout.write("\x1b[36m> \x1b[0m");
+                        continue;
+                    }
+                    else if (dispatchResult.result.action === "response") {
+                        // eslint-disable-next-line no-console -- terminal UX: command dispatch result
+                        console.log(dispatchResult.result.message || "");
+                        process.stdout.write("\x1b[36m> \x1b[0m");
+                        continue;
+                    }
+                }
+            }
+            // Re-style the echoed input line (readline terminal:true echoes it as "> input")
+            // Calculate terminal rows the echo occupied (prompt "> " + input, wrapped)
+            const cols = process.stdout.columns || 80;
+            const echoLen = 2 + input.length; // "> " prefix + input
+            const rows = Math.ceil(echoLen / cols);
+            process.stdout.write(`\x1b[${rows}A\x1b[K` + `\x1b[1m> ${input}\x1b[0m\n\n`);
+            messages.push({ role: "user", content: input });
+            addHistory(history, input);
+            currentAbort = new AbortController();
+            const traceId = (0, nerves_1.createTraceId)();
+            ctrl.suppress(() => currentAbort.abort());
+            let result;
+            try {
+                result = await (0, core_1.runAgent)(messages, cliCallbacks, "cli", currentAbort.signal, {
+                    toolChoiceRequired: (0, commands_1.getToolChoiceRequired)(),
+                    toolContext: cliToolContext,
+                    traceId,
+                });
+            }
+            catch {
+                // AbortError — silently return to prompt
+            }
+            cliCallbacks.flushMarkdown();
+            ctrl.restore();
+            currentAbort = null;
+            // Safety net: never silently swallow an empty response
+            const lastMsg = messages[messages.length - 1];
+            if (lastMsg?.role === "assistant" && !(typeof lastMsg.content === "string" ? lastMsg.content : "").trim()) {
+                process.stderr.write("\x1b[33m(empty response)\x1b[0m\n");
+            }
+            process.stdout.write("\n\n");
+            (0, context_1.postTurn)(messages, sessPath, result?.usage);
+            await (0, tokens_1.accumulateFriendTokens)(friendStore, resolvedContext.friend.id, result?.usage);
+            if (closed)
+                break;
+            process.stdout.write("\x1b[36m> \x1b[0m");
+        }
+    }
+    finally {
+        rl.close();
+        // eslint-disable-next-line no-console -- terminal UX: goodbye
+        console.log("bye");
+    }
+}

package/dist/senses/commands.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandRegistry = createCommandRegistry;
+exports.getToolChoiceRequired = getToolChoiceRequired;
+exports.resetToolChoiceRequired = resetToolChoiceRequired;
+exports.registerDefaultCommands = registerDefaultCommands;
+exports.parseSlashCommand = parseSlashCommand;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+function createCommandRegistry() {
+    const commands = new Map();
+    return {
+        register(cmd) {
+            commands.set(cmd.name, cmd);
+        },
+        get(name) {
+            return commands.get(name);
+        },
+        list(channel) {
+            return [...commands.values()].filter((c) => c.channels.includes(channel));
+        },
+        dispatch(name, ctx) {
+            const cmd = commands.get(name);
+            if (!cmd)
+                return { handled: false };
+            return { handled: true, result: cmd.handler(ctx) };
+        },
+    };
+}
+// Module-level toggle for tool-required mode
+let _toolChoiceRequired = false;
+function getToolChoiceRequired() {
+    return _toolChoiceRequired;
+}
+function resetToolChoiceRequired() {
+    _toolChoiceRequired = false;
+}
+function registerDefaultCommands(registry) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.load_start",
+        component: "repertoire",
+        message: "registering default commands",
+        meta: {},
+    });
+    registry.register({
+        name: "exit",
+        description: `quit ${(0, identity_1.getAgentName)()}`,
+        channels: ["cli"],
+        handler: () => ({ action: "exit" }),
+    });
+    registry.register({
+        name: "new",
+        description: "start a new conversation",
+        channels: ["cli", "teams"],
+        handler: () => ({ action: "new" }),
+    });
+    registry.register({
+        name: "commands",
+        description: "list available commands",
+        channels: ["cli", "teams"],
+        handler: (ctx) => {
+            const cmds = registry.list(ctx.channel);
+            const lines = cmds.map((c) => `/${c.name} - ${c.description}`);
+            return { action: "response", message: lines.join("\n") };
+        },
+    });
+    registry.register({
+        name: "tool-required",
+        description: "toggle tool_choice required mode (forces tool calls)",
+        channels: ["cli"],
+        handler: () => {
+            _toolChoiceRequired = !_toolChoiceRequired;
+            return { action: "response", message: `tool-required mode: ${_toolChoiceRequired ? "ON" : "OFF"}` };
+        },
+    });
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.load_end",
+        component: "repertoire",
+        message: "registered default commands",
+        meta: {},
+    });
+}
+function parseSlashCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/"))
+        return null;
+    // Reject // (double slash)
+    if (trimmed.startsWith("//"))
+        return null;
+    const rest = trimmed.slice(1);
+    if (!rest)
+        return null;
+    const spaceIdx = rest.indexOf(" ");
+    if (spaceIdx === -1) {
+        return { command: rest.toLowerCase(), args: "" };
+    }
+    return { command: rest.slice(0, spaceIdx).toLowerCase(), args: rest.slice(spaceIdx + 1) };
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInnerDialogWorker = createInnerDialogWorker;
+exports.startInnerDialogWorker = startInnerDialogWorker;
+const inner_dialog_1 = require("./inner-dialog");
+const runtime_1 = require("../nerves/runtime");
+function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options)) {
+    let running = false;
+    async function run(reason) {
+        if (running)
+            return;
+        running = true;
+        try {
+            await runTurn({ reason });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.inner_dialog_worker_error",
+                message: "inner dialog worker turn failed",
+                meta: {
+                    reason,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+        finally {
+            running = false;
+        }
+    }
+    async function handleMessage(message) {
+        if (!message || typeof message !== "object")
+            return;
+        const maybeMessage = message;
+        if (maybeMessage.type === "heartbeat") {
+            await run("heartbeat");
+            return;
+        }
+        if (maybeMessage.type === "poke" ||
+            maybeMessage.type === "chat" ||
+            maybeMessage.type === "message") {
+            await run("instinct");
+            return;
+        }
+        if (maybeMessage.type === "shutdown") {
+            process.exit(0);
+        }
+    }
+    return { run, handleMessage };
+}
+async function startInnerDialogWorker() {
+    const worker = createInnerDialogWorker();
+    process.on("message", (message) => {
+        void worker.handleMessage(message);
+    });
+    process.on("disconnect", () => {
+        process.exit(0);
+    });
+    await worker.run("boot");
+}