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

package/dist/heart/daemon/message-router.js

@@ -42,20 +42,26 @@ const ouro_version_manager_1 = require("../versioning/ouro-version-manager");
 function getDaemonMessageRouterDir(homeDir) {
     return path.join((0, ouro_version_manager_1.getOuroCliHome)(homeDir), "daemon", "messages");
 }
-function messageId(nowIso) {
-    return `msg-${nowIso.replace(/[^0-9]/g, "")}`;
+function messageId(nowIso, sequence) {
+    const base = `msg-${nowIso.replace(/[^0-9]/g, "")}`;
+    return sequence === 1 ? base : `${base}-${sequence}`;
 }
 class FileMessageRouter {
     baseDir;
     now;
+    maxMessagesPerInbox;
+    messageIdSequences = new Map();
     constructor(options = {}) {
         this.baseDir = options.baseDir ?? getDaemonMessageRouterDir(options.homeDir);
         this.now = options.now ?? (() => new Date().toISOString());
+        this.maxMessagesPerInbox = Math.max(1, Math.floor(options.maxMessagesPerInbox ?? 1000));
         fs.mkdirSync(this.baseDir, { recursive: true });
     }
     async send(input) {
         const queuedAt = this.now();
-        const id = messageId(queuedAt);
+        const sequence = (this.messageIdSequences.get(queuedAt) ?? 0) + 1;
+        this.messageIdSequences.set(queuedAt, sequence);
+        const id = messageId(queuedAt, sequence);
         const message = {
             id,
             from: input.from,
@@ -68,6 +74,7 @@ class FileMessageRouter {
         };
         const inboxPath = this.inboxPath(input.to);
         fs.appendFileSync(inboxPath, `${JSON.stringify(message)}\n`, "utf-8");
+        this.trimInbox(inboxPath);
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.message_queued",
@@ -107,5 +114,34 @@ class FileMessageRouter {
     inboxPath(agent) {
         return path.join(this.baseDir, `${agent}-inbox.jsonl`);
     }
+    trimInbox(inboxPath) {
+        const raw = fs.readFileSync(inboxPath, "utf-8");
+        const entries = raw
+            .split("\n")
+            .filter((line) => line.trim().length > 0)
+            .map((line) => {
+            try {
+                JSON.parse(line);
+                return { line, valid: true };
+            }
+            catch {
+                return { line, valid: false };
+            }
+        });
+        const validCount = entries.filter((entry) => entry.valid).length;
+        if (validCount <= this.maxMessagesPerInbox)
+            return;
+        let validSeen = 0;
+        const keepAfterValidIndex = validCount - this.maxMessagesPerInbox;
+        const kept = entries
+            .filter((entry) => {
+            if (!entry.valid)
+                return true;
+            validSeen += 1;
+            return validSeen > keepAfterValidIndex;
+        })
+            .map((entry) => entry.line);
+        fs.writeFileSync(inboxPath, `${kept.join("\n")}\n`, "utf-8");
+    }
 }
 exports.FileMessageRouter = FileMessageRouter;

package/dist/heart/daemon/pulse.js

@@ -41,6 +41,7 @@ exports.buildPulseState = buildPulseState;
 exports.findNovelBrokenAgents = findNovelBrokenAgents;
 exports.findRecoveredAgents = findRecoveredAgents;
 exports.buildRecoveryAlertId = buildRecoveryAlertId;
+exports.buildPulsePrivateWakeRequest = buildPulsePrivateWakeRequest;
 exports.pickWakeRecipient = pickWakeRecipient;
 exports.writePulse = writePulse;
 exports.readPulse = readPulse;
@@ -88,7 +89,7 @@ function buildAlertId(agent, errorReason) {
     return `${agent}:${hashErrorReason(errorReason)}`;
 }
 /**
- * Read an agent's inner-dialog runtime state and format it as a short
+ * Read an agent's private-runtime state and format it as a short
  * activity hint string suitable for display in another agent's pulse
  * section. Returns null when the file is missing or malformed — both
  * cases are silent (the pulse just doesn't include activity for that
@@ -164,8 +165,8 @@ function buildPulseState(snapshots, bundlesRoot, daemonVersion, now, readActivit
 /**
  * A "novel broken transition" is an agent that is currently broken AND
  * either (a) wasn't broken in the previous pulse state, OR (b) was broken
- * but with a different alertId. Used to decide when to fire an inner.wake
- * for proactive notification.
+ * but with a different alertId. Used to decide when to queue a proactive
+ * pulse wake.
  *
  * Pure: takes prev and next states, returns the list of newly-broken
  * agents that warrant a wake.
@@ -218,8 +219,24 @@ function findRecoveredAgents(prev, next) {
 function buildRecoveryAlertId(agent, recoveredAt) {
     return `recovery:${agent}:${recoveredAt}`;
 }
+function buildPulsePrivateWakeRequest(options) {
+    const prefix = options.triggerSource === "pulse-alert" ? "pulse alert" : "pulse recovery";
+    const detail = options.subject.errorReason ? `: ${options.subject.errorReason}` : "";
+    const originKind = options.triggerSource === "pulse-alert" ? "pulse-alert" : "pulse-recovery";
+    return {
+        agent: options.recipient,
+        reason: `${prefix} for ${options.subject.name}${detail}`,
+        triggerSource: options.triggerSource,
+        budgetClass: "scheduled",
+        idempotencyKey: `pulse:${options.recipient}:${options.alertId}`,
+        originRefs: [
+            { kind: originKind, id: options.alertId },
+            { kind: "agent", id: options.subject.name },
+        ],
+    };
+}
 /**
- * Pick which agent should receive an inner.wake for a fleet alert. Heuristic:
+ * Pick which agent should receive a pulse wake for a fleet alert. Heuristic:
  * the most-recently-active running agent (by `lastSeenAt`), excluding the
  * broken agent itself and any agents that aren't currently running. Returns
  * null if there's no eligible recipient (e.g., the only other agent on the
@@ -394,7 +411,7 @@ function pruneDeliveredState(delivered, state) {
 /**
  * Single entry point the daemon's onSnapshotChange callback uses. Builds
  * the new pulse state, diffs against the previous, writes the file, and
- * fires inner.wake on novel broken transitions to the most-recently-active
+ * queues pulse wakes on novel broken transitions for the most-recently-active
  * sibling. Persistent at-most-once delivery via the delivered state file.
  *
  * Pure-ish: all I/O goes through dep callbacks so tests can pin every
@@ -409,6 +426,7 @@ function flushPulse(deps) {
     const readDelivered = deps.readDelivered ?? (() => readDeliveredState());
     const writeDelivered = deps.writeDelivered ?? ((d) => writeDeliveredState(d));
     const fireInnerWake = deps.fireInnerWake ?? null;
+    const firePrivateWake = deps.firePrivateWake ?? null;
     /* v8 ignore stop */
     const prev = readPrev();
     let delivered = readDelivered();
@@ -437,7 +455,16 @@ function flushPulse(deps) {
         if (broken.alertId === null)
             continue;
         const recipient = pickWakeRecipient(state, broken.name);
-        if (recipient !== null && fireInnerWake !== null) {
+        if (recipient !== null && firePrivateWake !== null) {
+            firePrivateWake(buildPulsePrivateWakeRequest({
+                recipient,
+                subject: broken,
+                alertId: broken.alertId,
+                triggerSource: "pulse-alert",
+            }));
+            wakeFiredFor.push(recipient);
+        }
+        else if (recipient !== null && fireInnerWake !== null) {
             fireInnerWake(recipient);
             wakeFiredFor.push(recipient);
         }
@@ -453,7 +480,16 @@ function flushPulse(deps) {
         const recoveredAgent = undeliveredRecovered[i];
         const recoveryAlertId = buildRecoveryAlertId(recoveredAgent.name, state.generatedAt);
         const recipient = pickWakeRecipient(state, recoveredAgent.name);
-        if (recipient !== null && fireInnerWake !== null) {
+        if (recipient !== null && firePrivateWake !== null) {
+            firePrivateWake(buildPulsePrivateWakeRequest({
+                recipient,
+                subject: recoveredAgent,
+                alertId: recoveryAlertId,
+                triggerSource: "pulse-recovery",
+            }));
+            wakeFiredFor.push(recipient);
+        }
+        else if (recipient !== null && fireInnerWake !== null) {
             fireInnerWake(recipient);
             wakeFiredFor.push(recipient);
         }

package/dist/heart/daemon/socket-client.js

@@ -38,6 +38,7 @@ exports.__bypassVitestGuardForTests = __bypassVitestGuardForTests;
 exports.sendDaemonCommand = sendDaemonCommand;
 exports.checkDaemonSocketAlive = checkDaemonSocketAlive;
 exports.requestInnerWake = requestInnerWake;
+exports.requestPrivateWake = requestPrivateWake;
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
 const runtime_1 = require("../../nerves/runtime");
@@ -326,7 +327,7 @@ async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKE
             level: "warn",
             component: "daemon",
             event: "daemon.inner_wake_test_blocked",
-            message: "blocked inner wake from leaking into real daemon under vitest",
+            message: "blocked legacy private-runtime wake alias from leaking into real daemon under vitest",
             meta: { agent, socketPath, isProductionSocket: isProductionDaemonSocket(socketPath) },
         });
         return null;
@@ -335,7 +336,7 @@ async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKE
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.inner_wake_request",
-        message: "requesting daemon-managed inner wake",
+        message: "requesting daemon-managed legacy private-runtime wake alias",
         meta: {
             agent,
             socketPath,
@@ -347,3 +348,14 @@ async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKE
     }
     return sendDaemonCommand(socketPath, { kind: "inner.wake", agent });
 }
+async function requestPrivateWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH, options = {}) {
+    if (shouldSuppressSocketCall(socketPath))
+        return null;
+    if (!fs.existsSync(socketPath))
+        return null;
+    return sendDaemonCommand(socketPath, {
+        kind: "private.wake",
+        agent,
+        ...options,
+    });
+}

package/dist/heart/daemon/startup-tui.js

@@ -42,7 +42,10 @@ function assessStability(payload, now) {
     const degraded = [];
     let allResolved = true;
     for (const worker of payload.workers) {
-        if (worker.status === "crashed") {
+        if (isPassiveStoppedWorker(worker)) {
+            continue;
+        }
+        else if (worker.status === "crashed") {
             degraded.push({
                 agent: worker.agent,
                 errorReason: worker.errorReason ?? "unknown error",
@@ -281,6 +284,8 @@ function buildTimedOutStartupResult(payload, assessment, maxWaitMs) {
         degradedAgents.add(worker.agent);
     const seconds = (maxWaitMs / 1000).toFixed(0);
     for (const worker of payload.workers) {
+        if (isPassiveStoppedWorker(worker))
+            continue;
         if (stableAgents.has(worker.agent) || degradedAgents.has(worker.agent))
             continue;
         degraded.push({
@@ -293,6 +298,9 @@ function buildTimedOutStartupResult(payload, assessment, maxWaitMs) {
     }
     return { stable, degraded };
 }
+function isPassiveStoppedWorker(worker) {
+    return worker.autoStart === false && worker.status === "stopped";
+}
 function formatStartupWorkerLine(payload) {
     const base = `- ${payload.agent}/${payload.worker}: ${payload.status}`;
     if (payload.status === "crashed" && payload.errorReason) {

package/dist/heart/daemon/thoughts.js

@@ -1,5 +1,5 @@
 "use strict";
-// Formats inner dialog session turns for human consumption.
+// Formats private-runtime session turns for human consumption.
 // Used by `ouro thoughts` CLI command to show what the agent has been thinking.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -36,15 +36,15 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSurfacedValue = formatSurfacedValue;
-exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
+exports.derivePrivateRuntimeStatus = derivePrivateRuntimeStatus;
 exports.deriveInnerJob = deriveInnerJob;
-exports.formatInnerDialogStatus = formatInnerDialogStatus;
+exports.formatPrivateRuntimeStatus = formatPrivateRuntimeStatus;
 exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
-exports.parseInnerDialogSession = parseInnerDialogSession;
+exports.parsePrivateRuntimeSession = parsePrivateRuntimeSession;
 exports.formatThoughtTurns = formatThoughtTurns;
-exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
-exports.readInnerDialogStatus = readInnerDialogStatus;
-exports.readInnerDialogRawData = readInnerDialogRawData;
+exports.getPrivateRuntimeSessionPath = getPrivateRuntimeSessionPath;
+exports.readPrivateRuntimeStatus = readPrivateRuntimeStatus;
+exports.readPrivateRuntimeRawData = readPrivateRuntimeRawData;
 exports.followThoughts = followThoughts;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -167,11 +167,11 @@ function extractEnrichedFields(pendingMessages) {
         ...(delegated.obligationStatus === "pending" ? { obligationPending: true } : {}),
     };
 }
-function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
+function derivePrivateRuntimeStatus(pendingMessages, turns, runtimeState) {
     if (runtimeState?.status === "running") {
         if (pendingMessages.length > 0) {
             return {
-                queue: "queued to inner/dialog",
+                queue: "queued to private runtime",
                 wake: "queued behind active turn",
                 processing: "pending",
                 surfaced: "nothing yet",
@@ -187,8 +187,8 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
     }
     if (pendingMessages.length > 0) {
         return {
-            queue: "queued to inner/dialog",
-            wake: "awaiting inner session",
+            queue: "queued to private runtime",
+            wake: "awaiting private-runtime turn",
             processing: "pending",
             surfaced: "nothing yet",
             ...extractEnrichedFields(pendingMessages),
@@ -224,8 +224,8 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
     if (isRunning) {
         (0, runtime_1.emitNervesEvent)({
             component: "engine",
-            event: "engine.inner_job_derive",
-            message: "derived inner job state",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
             meta: { status: "running", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
         });
         return {
@@ -243,8 +243,8 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
     if (pendingMessages.length > 0) {
         (0, runtime_1.emitNervesEvent)({
             component: "engine",
-            event: "engine.inner_job_derive",
-            message: "derived inner job state",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
             meta: { status: "queued", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
         });
         return {
@@ -269,8 +269,8 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
         ]);
         (0, runtime_1.emitNervesEvent)({
             component: "engine",
-            event: "engine.inner_job_derive",
-            message: "derived inner job state",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
             meta: { status: "surfaced", mode: "reflect", hasOrigin: false, hasObligation: false },
         });
         return {
@@ -288,8 +288,8 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
     }
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
-        event: "engine.inner_job_derive",
-        message: "derived inner job state",
+        event: "engine.private_runtime_job_derive",
+        message: "derived private-runtime job state",
         meta: { status: "idle", mode: "reflect", hasOrigin: false, hasObligation: false },
     });
     return {
@@ -304,7 +304,7 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
         surfacedAt: null,
     };
 }
-function formatInnerDialogStatus(status) {
+function formatPrivateRuntimeStatus(status) {
     const lines = [
         `queue: ${status.queue}`,
         `wake: ${status.wake}`,
@@ -418,11 +418,11 @@ function extractThoughtResponseFromMessages(messages) {
         ? contentToText(lastAssistant.content).trim()
         : extractSettleAnswer(messages) || extractToolActionSummary(messages);
 }
-function parseInnerDialogSession(sessionPath) {
+function parsePrivateRuntimeSession(sessionPath) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.thoughts_parse",
-        message: "parsing inner dialog session",
+        message: "parsing private-runtime session",
         meta: { sessionPath },
     });
     let raw;
@@ -494,11 +494,11 @@ function parseInnerDialogSession(sessionPath) {
 }
 function formatThoughtTurns(turns, lastN) {
     if (turns.length === 0)
-        return "no inner dialog activity";
+        return "no private-runtime activity";
     const selected = lastN > 0 ? turns.slice(-lastN) : turns;
     /* v8 ignore next -- unreachable: turns.length > 0 checked above, slice always returns ≥1 @preserve */
     if (selected.length === 0)
-        return "no inner dialog activity";
+        return "no private-runtime activity";
     const lines = [];
     for (const turn of selected) {
         const typeLabel = turn.type === "task" && turn.taskId
@@ -518,13 +518,13 @@ function formatThoughtTurns(turns, lastN) {
     }
     return lines.join("\n").trim();
 }
-function getInnerDialogSessionPath(agentRoot) {
+function getPrivateRuntimeSessionPath(agentRoot) {
     return path.join(agentRoot, "state", "sessions", "self", "inner", "dialog.json");
 }
-function getInnerDialogRuntimeStatePath(sessionPath) {
+function getPrivateRuntimeStatePath(sessionPath) {
     return path.join(path.dirname(sessionPath), "runtime.json");
 }
-function readInnerDialogRuntimeState(runtimePath) {
+function readPrivateRuntimeState(runtimePath) {
     try {
         const raw = fs.readFileSync(runtimePath, "utf-8");
         const parsed = JSON.parse(raw);
@@ -543,17 +543,17 @@ function readInnerDialogRuntimeState(runtimePath) {
         return null;
     }
 }
-function readInnerDialogStatus(sessionPath, pendingDir, runtimePath = getInnerDialogRuntimeStatePath(sessionPath)) {
+function readPrivateRuntimeStatus(sessionPath, pendingDir, runtimePath = getPrivateRuntimeStatePath(sessionPath)) {
     const pendingMessages = readPendingMessagesForStatus(pendingDir);
-    const turns = parseInnerDialogSession(sessionPath);
-    const runtimeState = readInnerDialogRuntimeState(runtimePath);
-    return deriveInnerDialogStatus(pendingMessages, turns, runtimeState);
+    const turns = parsePrivateRuntimeSession(sessionPath);
+    const runtimeState = readPrivateRuntimeState(runtimePath);
+    return derivePrivateRuntimeStatus(pendingMessages, turns, runtimeState);
 }
-function readInnerDialogRawData(sessionPath, pendingDir) {
-    const runtimePath = getInnerDialogRuntimeStatePath(sessionPath);
+function readPrivateRuntimeRawData(sessionPath, pendingDir) {
+    const runtimePath = getPrivateRuntimeStatePath(sessionPath);
     const pendingMessages = readPendingMessagesForStatus(pendingDir);
-    const turns = parseInnerDialogSession(sessionPath);
-    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    const turns = parsePrivateRuntimeSession(sessionPath);
+    const runtimeState = readPrivateRuntimeState(runtimePath);
     return { pendingMessages, turns, runtimeState };
 }
 /**
@@ -561,15 +561,15 @@ function readInnerDialogRawData(sessionPath, pendingDir) {
  * Returns a cleanup function that stops the watcher.
  */
 function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
-    let displayedCount = parseInnerDialogSession(sessionPath).length;
+    let displayedCount = parsePrivateRuntimeSession(sessionPath).length;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.thoughts_follow_start",
-        message: "started following inner dialog session",
+        message: "started following private-runtime session",
         meta: { sessionPath, initialTurns: displayedCount },
     });
     fs.watchFile(sessionPath, { interval: pollIntervalMs }, () => {
-        const turns = parseInnerDialogSession(sessionPath);
+        const turns = parsePrivateRuntimeSession(sessionPath);
         if (turns.length > displayedCount) {
             const newTurns = turns.slice(displayedCount);
             onNewTurns(formatThoughtTurns(newTurns, 0));
@@ -584,7 +584,7 @@ function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.thoughts_follow_end",
-            message: "stopped following inner dialog session",
+            message: "stopped following private-runtime session",
             meta: { sessionPath, totalTurns: displayedCount },
         });
     };

package/dist/heart/habits/habit-scheduler.js

@@ -108,7 +108,9 @@ class HabitScheduler {
                     message: "firing overdue habit (never run)",
                     meta: { habitName: habit.name, agent: this.agent },
                 });
-                this.onHabitFire(habit.name, "overdue");
+                this.onHabitFire(habit.name, "overdue", {
+                    occurrenceId: this.overdueOccurrenceId(habit),
+                });
                 continue;
             }
             const lastRunMs = new Date(habit.lastRun).getTime();
@@ -120,7 +122,9 @@ class HabitScheduler {
                     message: "firing overdue habit",
                     meta: { habitName: habit.name, agent: this.agent, elapsedMs: elapsed },
                 });
-                this.onHabitFire(habit.name, "overdue");
+                this.onHabitFire(habit.name, "overdue", {
+                    occurrenceId: this.overdueOccurrenceId(habit),
+                });
             }
         }
     }
@@ -184,7 +188,9 @@ class HabitScheduler {
         if (!job) {
             return { ok: false, message: `unknown habit job: ${jobId}` };
         }
-        this.onHabitFire(job.taskId, trigger);
+        this.onHabitFire(job.taskId, trigger, {
+            occurrenceId: this.jobOccurrenceId(job, trigger),
+        });
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.habit_job_triggered",
@@ -312,7 +318,9 @@ class HabitScheduler {
     createTimerFallback(habitName, cadenceMs) {
         const schedule = () => {
             const timer = setTimeout(() => {
-                this.onHabitFire(habitName, "overdue");
+                this.onHabitFire(habitName, "overdue", {
+                    occurrenceId: this.timerOccurrenceId(habitName, cadenceMs),
+                });
                 schedule();
             }, cadenceMs);
             this.timerFallbacks.set(habitName, timer);
@@ -387,5 +395,17 @@ class HabitScheduler {
         }
         return jobs;
     }
+    overdueOccurrenceId(habit) {
+        if (habit.lastRun === null)
+            return `overdue:first-run:${habit.cadence}`;
+        return `overdue:last-run:${habit.lastRun}:cadence:${habit.cadence}`;
+    }
+    jobOccurrenceId(job, trigger) {
+        return `job:${job.id}:${trigger}:last-run:${job.lastRun ?? "never"}`;
+    }
+    timerOccurrenceId(habitName, cadenceMs) {
+        const slot = Math.floor(this.deps.now() / cadenceMs);
+        return `timer:${habitName}:cadence-ms:${cadenceMs}:slot:${slot}`;
+    }
 }
 exports.HabitScheduler = HabitScheduler;

package/dist/heart/mailbox/mailbox-view.js

@@ -154,7 +154,7 @@ function buildRecentActivity(agent) {
             kind: "inner",
             at: agent.inner.latestActivityAt,
             label: agent.inner.surfacedSummary ?? agent.inner.status,
-            detail: agent.inner.hasPending ? "pending inner work" : agent.inner.obligationStatus ?? "no linked obligation",
+            detail: agent.inner.hasPending ? "pending private-runtime work" : agent.inner.obligationStatus ?? "no linked obligation",
         });
     }
     return items

package/dist/heart/mailbox/readers/agent-machine.js

@@ -177,9 +177,9 @@ function readSessionSummary(agentName, agentRoot, now) {
     return { items };
 }
 function readInnerSummary(agentRoot) {
-    const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+    const sessionPath = (0, thoughts_1.getPrivateRuntimeSessionPath)(agentRoot);
     const pendingDir = path.join(agentRoot, "state", "pending", "self", "inner", "dialog");
-    const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
+    const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readPrivateRuntimeRawData)(sessionPath, pendingDir);
     const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
     const surfacedSummary = job.surfacedResult ? (0, thoughts_1.formatSurfacedValue)(job.surfacedResult) : null;
     const latestPendingTimestamp = pendingMessages.length > 0
@@ -189,11 +189,11 @@ function readInnerSummary(agentRoot) {
         ?? runtimeState?.startedAt
         ?? runtimeState?.lastCompletedAt
         ?? null;
-    // Read the return-obligation queue so the Inner tab can show what the
-    // agent is actually holding right now. Before this, the "Inner work"
-    // panel only consulted the pending-messages dir (inbox-style); it
-    // reported "No pending inner work" even when dozens of held items were
-    // sitting in arc/obligations/inner/ waiting to be reinjected next turn.
+    // Read the return-obligation queue so the Private Runtime tab can show what the
+    // agent is actually holding right now. Before this, the private-runtime work
+    // panel only consulted the pending-messages dir (inbox-style), so it
+    // looked empty even when dozens of held items were sitting in
+    // arc/obligations/inner/ waiting to be reinjected next turn.
     const returnObligationQueue = readReturnObligationQueueSummary(agentRoot);
     return {
         summary: {

package/dist/heart/primitives.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HARNESS_BOOTSTRAP_PHASES = void 0;
-exports.HARNESS_BOOTSTRAP_PHASES = ["bundle", "psyche", "inner-dialog"];
+exports.HARNESS_BOOTSTRAP_PHASES = ["bundle", "psyche", "private-runtime"];