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

package/dist/heart/daemon/daemon-entry.js

@@ -60,9 +60,12 @@ const daemon_tombstone_1 = require("./daemon-tombstone");
 const agent_config_check_1 = require("./agent-config-check");
 const pulse_1 = require("./pulse");
 const socket_client_1 = require("./socket-client");
+const await_private_wake_1 = require("./await-private-wake");
+const habit_private_wake_1 = require("./habit-private-wake");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const mcp_canary_1 = require("./mcp-canary");
 const context_loss_sentinel_1 = require("../context-loss-sentinel");
+const provider_credentials_1 = require("../provider-credentials");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -93,6 +96,10 @@ if (mode === "dev") {
     });
 }
 const managedAgents = (0, agent_discovery_1.listEnabledBundleAgents)();
+const managedPrivateRuntimes = managedAgents.map((agent) => ({
+    agent,
+    config: (0, agent_discovery_1.readPrivateRuntimeConfig)(agent),
+}));
 function sentinelHealthStatus(receipt) {
     if (receipt.verdict === "ready")
         return "ok";
@@ -118,26 +125,65 @@ async function refreshDaemonSentinel(agent, trigger, daemonHealthResults = []) {
         };
     }
 }
+function emitAwaitPrivateWakeDispatchError(options) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.await_private_wake_dispatch_error",
+        message: "failed to dispatch await private-runtime wake",
+        meta: {
+            agent: options.agent,
+            awaitName: options.awaitName,
+            triggerSource: options.triggerSource,
+            socketPath: options.socketPath,
+            error: options.error instanceof Error ? options.error.message : String(options.error),
+        },
+    });
+}
+function emitPulsePrivateWakeDispatchError(options) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.pulse_private_wake_dispatch_error",
+        message: "failed to dispatch pulse private-runtime wake",
+        meta: {
+            agent: options.request.agent,
+            triggerSource: options.request.triggerSource,
+            idempotencyKey: options.request.idempotencyKey,
+            originRefs: options.request.originRefs,
+            socketPath: options.socketPath,
+            error: options.error instanceof Error ? options.error.message : String(options.error),
+        },
+    });
+}
+function emitHabitPrivateWakeDispatchError(options) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.habit_private_wake_dispatch_error",
+        message: "failed to dispatch habit private-runtime wake",
+        meta: {
+            agent: options.agent,
+            habitName: options.habitName,
+            trigger: options.trigger,
+            triggerSource: options.triggerSource,
+            socketPath: options.socketPath,
+            error: options.error instanceof Error ? options.error.message : String(options.error),
+        },
+    });
+}
 const processManager = new process_manager_1.DaemonProcessManager({
-    agents: managedAgents.map((agent) => ({
+    agents: managedPrivateRuntimes.map(({ agent, config }) => ({
         name: agent,
         entry: "heart/agent-entry.js",
-        channel: "inner-dialog",
-        autoStart: (0, agent_discovery_1.isInnerDialogAutoStartEnabled)(agent),
+        channel: "private-runtime",
+        autoStart: config.autoStart,
     })),
     existsSync: fs.existsSync,
-    /* v8 ignore next 4 -- wiring: delegates to checkAgentConfigWithProviderHealth which has full unit tests @preserve */
+    /* v8 ignore next 4 -- wiring: delegates to checkAgentConfig which has full unit tests @preserve */
     configCheck: async (agent) => {
-        if (!(0, agent_discovery_1.isInnerDialogAutoStartEnabled)(agent)) {
-            return {
-                ok: true,
-                skip: true,
-                error: "inner-dialog auto-start is disabled in agent.json",
-                fix: "Set innerDialog.autoStart to true and rerun `ouro up` to resume autonomous inner-dialog turns.",
-            };
-        }
         const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
-        return (0, agent_config_check_1.checkAgentConfigWithProviderHealth)(agent, bundlesRoot);
+        return (0, agent_config_check_1.checkAgentConfig)(agent, bundlesRoot);
     },
     /* v8 ignore start -- pulse flush wiring: integration code; flushPulse itself has full unit tests @preserve */
     onSnapshotChange: () => {
@@ -146,12 +192,20 @@ const processManager = new process_manager_1.DaemonProcessManager({
             bundlesRoot: (0, identity_1.getAgentBundlesRoot)(),
             daemonVersion: (0, bundle_manifest_1.getPackageVersion)(),
             now: new Date(),
-            // Default I/O wired into pulse.ts (writePulse, readPulse, etc.)
-            // Wake recipient: send inner.wake over the daemon's own socket so
-            // the recipient agent runs an inner-dialog turn that picks up the
-            // pulse alert. Catch errors silently — pulse is best-effort.
-            fireInnerWake: (agent) => {
-                (0, socket_client_1.sendDaemonCommand)(socketPath, { kind: "inner.wake", agent }).catch(() => { });
+            // Default I/O wired into pulse.ts (writePulse, readPulse, etc.).
+            // Pulse alerts queue canonical private-runtime wakes so policy decides
+            // whether a model-backed notification turn may run.
+            firePrivateWake: (request) => {
+                (0, socket_client_1.sendDaemonCommand)(socketPath, {
+                    kind: "private.wake",
+                    ...request,
+                }).catch((error) => {
+                    emitPulsePrivateWakeDispatchError({
+                        request,
+                        socketPath,
+                        error,
+                    });
+                });
             },
         });
     },
@@ -404,8 +458,11 @@ function writeStopCommandHealthState() {
         // Health writes are best-effort during shutdown.
     }
 }
+async function preloadProviderCredentialPools() {
+    await Promise.all(managedAgents.map((agent) => (0, provider_credentials_1.refreshProviderCredentialPool)(agent, { preserveCachedOnFailure: true })));
+}
 /* v8 ignore start -- habit wiring: lambdas delegate to processManager/fs; tested via HabitScheduler unit tests @preserve */
-void daemon.start().then(async () => {
+void preloadProviderCredentialPools().then(() => daemon.start()).then(async () => {
     const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
     const ouroPath = (0, os_cron_deps_1.resolveOuroBinaryPath)();
     const osCronDeps = (0, os_cron_deps_1.createRealOsCronDeps)();
@@ -422,8 +479,24 @@ void daemon.start().then(async () => {
                 agent,
                 habitsDir,
                 osCronManager,
-                onHabitFire: (habitName, trigger) => {
-                    processManager.sendToAgent(agent, { type: "habit", habitName, trigger });
+                onHabitFire: (habitName, trigger, context) => {
+                    const command = (0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
+                        agent,
+                        habitName,
+                        trigger,
+                        sourceRef: { kind: "daemon-entry", id: "habit-scheduler" },
+                        occurrenceId: context?.occurrenceId,
+                    });
+                    (0, socket_client_1.sendDaemonCommand)(socketPath, command).catch((error) => {
+                        emitHabitPrivateWakeDispatchError({
+                            agent,
+                            habitName,
+                            trigger,
+                            triggerSource: command.triggerSource,
+                            socketPath,
+                            error,
+                        });
+                    });
                 },
                 deps: {
                     readdir: (dir) => fs.readdirSync(dir),
@@ -482,7 +555,19 @@ void daemon.start().then(async () => {
                 awaitsDir,
                 osCronManager: awaitOsCronManager,
                 onAwaitFire: (awaitName) => {
-                    processManager.sendToAgent(agent, { type: "await", awaitName });
+                    (0, socket_client_1.sendDaemonCommand)(socketPath, (0, await_private_wake_1.buildAwaitPrivateWakeCommand)({
+                        agent,
+                        awaitName,
+                        triggerSource: "await-scheduler",
+                    })).catch((error) => {
+                        emitAwaitPrivateWakeDispatchError({
+                            agent,
+                            awaitName,
+                            triggerSource: "await-scheduler",
+                            socketPath,
+                            error,
+                        });
+                    });
                 },
                 onAwaitExpire: (awaitName) => {
                     void (0, await_expiry_1.archiveAndAlertExpiredAwait)({
@@ -492,8 +577,20 @@ void daemon.start().then(async () => {
                         deliveryDeps: {
                             agentName: agent,
                             queuePending: () => {
-                                // Best-effort: queue inner-dialog wake so the agent processes the alert path
-                                (0, socket_client_1.sendDaemonCommand)(socketPath, { kind: "inner.wake", agent }).catch(() => { });
+                                // Best-effort: queue private-runtime wake so the agent processes the alert path.
+                                (0, socket_client_1.sendDaemonCommand)(socketPath, (0, await_private_wake_1.buildAwaitPrivateWakeCommand)({
+                                    agent,
+                                    awaitName,
+                                    triggerSource: "await-expiry",
+                                })).catch((error) => {
+                                    emitAwaitPrivateWakeDispatchError({
+                                        agent,
+                                        awaitName,
+                                        triggerSource: "await-expiry",
+                                        socketPath,
+                                        error,
+                                    });
+                                });
                             },
                         },
                     }).catch((err) => {

package/dist/heart/daemon/daemon.js

@@ -66,8 +66,13 @@ const mailbox_types_1 = require("../mailbox/mailbox-types");
 const mailbox_read_1 = require("../mailbox/mailbox-read");
 const mailbox_view_1 = require("../mailbox/mailbox-view");
 const provider_visibility_1 = require("../provider-visibility");
+const private_runtime_1 = require("../private-runtime");
 const socket_client_1 = require("./socket-client");
 const flight_recorder_1 = require("../../arc/flight-recorder");
+const await_private_wake_1 = require("./await-private-wake");
+const habit_private_wake_1 = require("./habit-private-wake");
+const habit_parser_1 = require("../habits/habit-parser");
+const habit_runtime_state_1 = require("../habits/habit-runtime-state");
 const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
 /**
  * Defense-in-depth: detect if we're running under vitest. The pidfile lives
@@ -374,6 +379,7 @@ function buildWorkerRows(snapshots) {
     return snapshots.map((snapshot) => ({
         agent: snapshot.name,
         worker: snapshot.channel,
+        autoStart: snapshot.autoStart ?? true,
         status: snapshot.status,
         pid: snapshot.pid,
         restartCount: snapshot.restartCount,
@@ -395,11 +401,17 @@ function unhealthySenseRows(senses) {
         return true;
     });
 }
+function isParkedWorker(row) {
+    return row.autoStart === false && row.status === "stopped";
+}
+function unhealthyWorkerRows(workers) {
+    return workers.filter((row) => !isParkedWorker(row) && row.status !== "running");
+}
 function unhealthyHealthChecks(healthChecks) {
     return healthChecks.filter((row) => row.status !== "ok");
 }
 function overviewHealth(workers, senses, healthChecks = []) {
-    if (!workers.every((worker) => worker.status === "running"))
+    if (unhealthyWorkerRows(workers).length > 0)
         return "warn";
     if (unhealthySenseRows(senses).length > 0)
         return "warn";
@@ -412,8 +424,7 @@ function formatStatusSummary(payload) {
         return "no managed agents";
     }
     const degraded = [
-        ...payload.workers
-            .filter((row) => row.status !== "running")
+        ...unhealthyWorkerRows(payload.workers)
             .map((row) => `worker:${row.agent}/${row.worker}:${row.status}`),
         ...unhealthySenseRows(payload.senses)
             .map((row) => `sense:${row.agent}/${row.sense}:${row.status}`),
@@ -456,6 +467,27 @@ function isValidSenseReviveCommand(command) {
         && typeof command.sense === "string"
         && typeof command.reason === "string";
 }
+function isValidTaskPokeCommand(command) {
+    return typeof command.agent === "string"
+        && command.agent.trim().length > 0
+        && typeof command.taskId === "string"
+        && command.taskId.trim().length > 0;
+}
+function isValidHabitPokeCommand(command) {
+    return typeof command.agent === "string"
+        && command.agent.trim().length > 0
+        && typeof command.habitName === "string"
+        && command.habitName.trim().length > 0;
+}
+function taskIdFromTaskPokePrivateWakeCommand(command) {
+    if (command.kind !== "private.wake" || command.triggerSource !== "task-poke")
+        return null;
+    const taskRef = command.originRefs?.find((ref) => ref.kind === "task" && typeof ref.id === "string");
+    if (!taskRef || typeof taskRef.id !== "string")
+        return null;
+    const trimmed = taskRef.id.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
 /**
  * Handle agent.senseTurn command: runs a full agent turn via the daemon process.
  * Dynamic import lazy-loads shared-turn. Hot-reload works because ouro dev
@@ -523,6 +555,7 @@ class OuroDaemon {
     socketIdentity = null;
     senseAutostartTimer = null;
     mailboxServerFactory;
+    privateRuntimePolicyDeps;
     onStopCommandComplete;
     constructor(options) {
         this.socketPath = options.socketPath;
@@ -534,6 +567,7 @@ class OuroDaemon {
         this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
         this.mode = options.mode ?? "production";
         this.mailboxServerFactory = options.mailboxServerFactory ?? this.createDefaultMailboxServer.bind(this);
+        this.privateRuntimePolicyDeps = options.privateRuntimePolicyDeps ?? {};
         this.onStopCommandComplete = options.onStopCommandComplete ?? null;
     }
     /* v8 ignore start -- default mailbox server wiring: production-only path, tests inject mailboxServerFactory stub instead. startMailboxHttpServer itself has full coverage in mailbox-http.test.ts @preserve */
@@ -1078,6 +1112,123 @@ class OuroDaemon {
         }
         /* v8 ignore stop */
     }
+    hasManagedPrivateRuntime(agent) {
+        return this.processManager.listAgentSnapshots().some((snapshot) => snapshot.name === agent && snapshot.channel === "private-runtime");
+    }
+    buildPrivateRuntimeWakeRequest(command) {
+        if (command.kind === "inner.wake") {
+            return {
+                agent: command.agent,
+                origin: "daemon.private.wake",
+                reason: "legacy inner.wake compatibility alias",
+                providerLane: "inner",
+                triggerSource: "legacy",
+                budgetClass: "interactive",
+                originRefs: [{ kind: "daemon-command", id: "inner.wake" }],
+            };
+        }
+        return {
+            agent: command.agent,
+            origin: "daemon.private.wake",
+            reason: command.reason ?? "manual private-runtime wake",
+            providerLane: "inner",
+            triggerSource: command.triggerSource ?? "manual",
+            budgetClass: command.budgetClass ?? "interactive",
+            ...(command.idempotencyKey ? { idempotencyKey: command.idempotencyKey } : {}),
+            originRefs: command.originRefs ?? [{ kind: "daemon-command", id: "private.wake" }],
+        };
+    }
+    buildAwaitPrivateWakeCommand(command) {
+        return (0, await_private_wake_1.buildAwaitPrivateWakeCommand)({
+            agent: command.agent,
+            awaitName: command.awaitName,
+            triggerSource: "await-poke",
+        });
+    }
+    buildTaskPokePrivateWakeCommand(command, receiptId) {
+        return {
+            kind: "private.wake",
+            agent: command.agent,
+            reason: `task poke ${command.taskId}`,
+            triggerSource: "task-poke",
+            budgetClass: "scheduled",
+            idempotencyKey: `task-poke:${command.agent}:${command.taskId}:${receiptId}`,
+            originRefs: [
+                { kind: "task", id: command.taskId },
+                { kind: "queue-receipt", id: receiptId },
+                { kind: "daemon-command", id: "task.poke" },
+            ],
+        };
+    }
+    resolveHabitPokeOccurrenceId(command, trigger) {
+        if (trigger === "poke" || trigger === "manual")
+            return undefined;
+        const agentRoot = path.join(this.bundlesRoot, `${command.agent}.ouro`);
+        const habitPath = path.join(agentRoot, "habits", `${command.habitName}.md`);
+        if (!fs.existsSync(habitPath))
+            return { skipReason: "habit file not found" };
+        const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+        if (habit.cadence === null)
+            return { skipReason: "habit has no cadence" };
+        const cadence = habit.cadence;
+        if (habit.lastRun === null)
+            return `${trigger}:first-run:${cadence}`;
+        return `${trigger}:last-run:${habit.lastRun}:cadence:${cadence}`;
+    }
+    buildPrivateRuntimeWorkerWakeMessage(command, decision) {
+        const awaitName = (0, await_private_wake_1.awaitNameFromPrivateWakeCommand)(command);
+        if (awaitName) {
+            return {
+                type: "await",
+                awaitName,
+                privateTurnDecision: decision,
+            };
+        }
+        const taskId = taskIdFromTaskPokePrivateWakeCommand(command);
+        if (taskId) {
+            return {
+                type: "poke",
+                taskId,
+                privateTurnDecision: decision,
+            };
+        }
+        const habitMessage = (0, habit_private_wake_1.habitMessageFromPrivateWakeCommand)(command);
+        if (habitMessage) {
+            return {
+                type: "habit",
+                habitName: habitMessage.habitName,
+                trigger: habitMessage.trigger,
+                privateTurnDecision: decision,
+            };
+        }
+        return { type: "message", privateTurnDecision: decision };
+    }
+    async handlePrivateRuntimeWake(command) {
+        if (!this.hasManagedPrivateRuntime(command.agent)) {
+            return {
+                ok: false,
+                error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
+            };
+        }
+        const decision = await (0, private_runtime_1.requestPrivateTurnDecision)(this.buildPrivateRuntimeWakeRequest(command), {
+            bundlesRoot: this.bundlesRoot,
+            ...this.privateRuntimePolicyDeps,
+        });
+        if (!decision.executable) {
+            return {
+                ok: true,
+                message: `private-runtime wake denied for ${command.agent}: ${decision.deniedReason}`,
+                data: { decision },
+            };
+        }
+        await this.processManager.startAgent(command.agent);
+        this.processManager.sendToAgent?.(command.agent, this.buildPrivateRuntimeWorkerWakeMessage(command, decision));
+        return {
+            ok: true,
+            message: `woke private runtime for ${command.agent}`,
+            data: { decision },
+        };
+    }
     async handleCommandInner(command) {
         switch (command.kind) {
             case "daemon.start":
@@ -1252,11 +1403,11 @@ class OuroDaemon {
                 // (cli-exec.ts) intentionally sends only message.send for tool-use
                 // events to avoid waking the agent on every tool call. The hook's
                 // intent was completely defeated by this handler calling
-                // `sendToAgent({type: "message"})`, which woke the inner-dialog
+                // `sendToAgent({type: "message"})`, which woke the private runtime
                 // worker on EVERY message.send anyway. ~30 message.send/min × the
                 // 3-turn instinct-loop cap = ~90 turns/min sustained for hours.
                 //
-                // Callers that want immediate processing must send `inner.wake`
+                // Callers that want immediate processing must send `private.wake`
                 // explicitly after message.send. The CLI `ouro msg` does so
                 // (lifecycle-boundary delivery should wake); the hook does so
                 // only on session-start / stop, not per tool-use; the API does
@@ -1279,13 +1430,42 @@ class OuroDaemon {
                     data: messages,
                 };
             }
-            case "inner.wake":
-                await this.processManager.startAgent(command.agent);
-                this.processManager.sendToAgent?.(command.agent, { type: "message" });
+            case "private.decisions": {
+                const requestedLimit = Number.isInteger(command.limit) && command.limit && command.limit > 0 ? command.limit : 20;
+                const limit = Math.min(requestedLimit, 1000);
+                const ledgerPath = (0, private_runtime_1.privateTurnLedgerPath)(command.agent, { bundlesRoot: this.bundlesRoot });
+                const ledgerExists = fs.existsSync(ledgerPath);
+                let decisions;
+                try {
+                    decisions = ledgerExists ? (0, private_runtime_1.readPrivateTurnLedger)(ledgerPath) : [];
+                }
+                catch {
+                    return {
+                        ok: false,
+                        error: `private-runtime decision ledger is malformed: ${ledgerPath}; repair or remove malformed JSONL rows before reading decisions`,
+                    };
+                }
+                const guidance = ledgerExists
+                    ? undefined
+                    : `No private-runtime decision ledger exists for ${command.agent}; run an explicit private-runtime trigger or check ${path.dirname(ledgerPath)}.`;
+                const payload = (0, private_runtime_1.buildPrivateDecisionReadPayload)({
+                    agent: command.agent,
+                    ledgerPath,
+                    decisions,
+                    limit,
+                    ...(guidance ? { guidance } : {}),
+                });
                 return {
                     ok: true,
-                    message: `woke inner dialog for ${command.agent}`,
+                    summary: (0, private_runtime_1.privateDecisionCountSummary)(payload.decisions.length),
+                    ...(guidance ? { message: guidance } : {}),
+                    data: payload,
                 };
+            }
+            case "inner.wake":
+                return this.handlePrivateRuntimeWake(command);
+            case "private.wake":
+                return this.handlePrivateRuntimeWake(command);
             case "chat.connect":
                 await this.processManager.startAgent(command.agent);
                 return {
@@ -1293,6 +1473,12 @@ class OuroDaemon {
                     message: `connected to ${command.agent}`,
                 };
             case "task.poke": {
+                if (!isValidTaskPokeCommand(command)) {
+                    return {
+                        ok: false,
+                        error: "Invalid task.poke payload: expected non-empty string fields 'agent' and 'taskId'.",
+                    };
+                }
                 const receipt = await this.router.send({
                     from: "ouro-poke",
                     to: command.agent,
@@ -1301,7 +1487,7 @@ class OuroDaemon {
                     taskRef: command.taskId,
                 });
                 await this.scheduler.recordTaskRun?.(command.agent, command.taskId);
-                this.processManager.sendToAgent?.(command.agent, { type: "poke", taskId: command.taskId });
+                await this.handlePrivateRuntimeWake(this.buildTaskPokePrivateWakeCommand(command, receipt.id));
                 return {
                     ok: true,
                     message: `queued poke ${receipt.id}`,
@@ -1309,22 +1495,39 @@ class OuroDaemon {
                 };
             }
             case "habit.poke": {
+                if (!isValidHabitPokeCommand(command)) {
+                    return {
+                        ok: false,
+                        error: "Invalid habit.poke payload: expected non-empty string fields 'agent' and 'habitName'.",
+                    };
+                }
                 const trigger = command.trigger ?? "poke";
                 if (!(0, flight_recorder_1.isHabitRunTrigger)(trigger)) {
                     return { ok: false, error: `invalid habit trigger: ${String(trigger)}` };
                 }
-                this.processManager.sendToAgent?.(command.agent, { type: "habit", habitName: command.habitName, trigger });
-                return {
-                    ok: true,
-                    message: `poked habit ${command.habitName} for ${command.agent}`,
-                };
+                if (!this.hasManagedPrivateRuntime(command.agent)) {
+                    return {
+                        ok: false,
+                        error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
+                    };
+                }
+                const occurrenceId = this.resolveHabitPokeOccurrenceId(command, trigger);
+                if (typeof occurrenceId === "object") {
+                    return {
+                        ok: true,
+                        message: `skipped scheduled habit ${command.habitName} for ${command.agent}: ${occurrenceId.skipReason}`,
+                    };
+                }
+                return this.handlePrivateRuntimeWake((0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    sourceRef: { kind: "daemon-command", id: "habit.poke" },
+                    occurrenceId,
+                }));
             }
             case "await.poke": {
-                this.processManager.sendToAgent?.(command.agent, { type: "await", awaitName: command.awaitName });
-                return {
-                    ok: true,
-                    message: `poked await ${command.awaitName} for ${command.agent}`,
-                };
+                return this.handlePrivateRuntimeWake(this.buildAwaitPrivateWakeCommand(command));
             }
             case "mcp.list": {
                 (0, identity_1.setAgentName)(command.agent ?? "default");

package/dist/heart/daemon/habit-private-wake.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHabitPrivateWakeCommand = buildHabitPrivateWakeCommand;
+exports.habitMessageFromPrivateWakeCommand = habitMessageFromPrivateWakeCommand;
+const flight_recorder_1 = require("../../arc/flight-recorder");
+const runtime_1 = require("../../nerves/runtime");
+function buildHabitPrivateWakeCommand(options) {
+    const firedAt = (options.now ?? (() => new Date()))().toISOString();
+    const occurrenceId = options.occurrenceId ?? firedAt;
+    const triggerSource = `habit-${options.trigger}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.habit_private_wake_built",
+        message: "built habit private-runtime wake command",
+        meta: {
+            agent: options.agent,
+            habitName: options.habitName,
+            trigger: options.trigger,
+            triggerSource,
+            occurrenceId,
+        },
+    });
+    return {
+        kind: "private.wake",
+        agent: options.agent,
+        reason: `habit ${options.habitName} fired by ${options.trigger}`,
+        triggerSource,
+        budgetClass: "scheduled",
+        idempotencyKey: `habit:${options.agent}:${options.habitName}:${options.trigger}:${occurrenceId}`,
+        originRefs: [
+            { kind: "habit", id: options.habitName },
+            { kind: "habit-trigger", id: options.trigger },
+            { kind: "habit-occurrence", id: occurrenceId },
+            options.sourceRef,
+        ],
+    };
+}
+function habitMessageFromPrivateWakeCommand(command) {
+    if (command.kind !== "private.wake")
+        return null;
+    if (typeof command.triggerSource !== "string" || !command.triggerSource.startsWith("habit-"))
+        return null;
+    const habitRef = command.originRefs?.find((ref) => ref.kind === "habit" && typeof ref.id === "string");
+    const triggerRef = command.originRefs?.find((ref) => ref.kind === "habit-trigger" && typeof ref.id === "string");
+    if (!habitRef || typeof habitRef.id !== "string" || !triggerRef || typeof triggerRef.id !== "string")
+        return null;
+    const habitName = habitRef.id.trim();
+    const trigger = triggerRef.id.trim();
+    if (habitName.length === 0)
+        return null;
+    if (!(0, flight_recorder_1.isHabitRunTrigger)(trigger))
+        return null;
+    if (command.triggerSource !== `habit-${trigger}`)
+        return null;
+    return { habitName, trigger };
+}

package/dist/heart/daemon/inner-status.js

@@ -26,7 +26,7 @@ function formatCadence(cadenceMs) {
 function buildInnerStatusOutput(input) {
     const { agentName, runtimeState, recordSummary, heartbeat, attentionCount, now } = input;
     const lines = [];
-    lines.push(`inner dialog status: ${agentName}`);
+    lines.push(`private runtime status: ${agentName}`);
     // Last turn
     if (runtimeState?.lastCompletedAt) {
         const lastMs = new Date(runtimeState.lastCompletedAt).getTime();
@@ -64,8 +64,8 @@ function buildInnerStatusOutput(input) {
     lines.push(`  attention: ${attentionCount} held ${thoughtWord}`);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
-        event: "daemon.inner_status_read",
-        message: "inner dialog status read",
+        event: "daemon.private_runtime_status_read",
+        message: "private runtime status read",
         meta: {
             agentName,
             status: runtimeState?.status ?? "unknown",