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

package/README.md

@@ -97,7 +97,12 @@ Task docs do not live in this repo anymore. Planning and doing docs live in the
 ## Runtime Truths
 
 - `agent.json` is the source of truth for identity, phrase pools, context settings, enabled senses, vault coordinates, and provider+model selection. It has two provider lanes: `outward` for CLI, Teams, BlueBubbles, Mail, and Voice turns, and `inner` for private agent-facing turns.
+- The `inner` lane is a provider/model lane, not the private-runtime system name.
+- Provider/model selection belongs to `agent.json` lanes; `privateRuntime` cannot select providers or models.
 - Legacy `humanFacing`/`agentFacing` provider fields are read only as compatibility aliases for `outward`/`inner`; they are not a second config surface.
+- Starting the private runtime worker is process supervision, not a model turn.
+- Denied/default private-runtime policy records or queues work with zero provider calls.
+- Provider-readiness pings are explicit readiness checks, not private turns.
 - Each agent has one credential vault for provider, runtime, sense, integration, travel, and tool credentials. There is no machine-wide credential pool.
 - Vault unlock material is local machine state. Prefer macOS Keychain, Windows DPAPI, or Linux Secret Service; plaintext fallback is allowed only by explicit human choice.
 - New vault unlock secrets are confirmed before use and rejected if they do not meet the minimum strength requirements.
@@ -134,7 +139,7 @@ When you want this machine to use a provider/model for a lane, use:
 ouro use --agent <name> --lane <outward|inner> --provider <provider> --model <model>
 ```
 
-The outward lane handles user-facing senses. The inner lane handles the agent's private thinking. `ouro use` performs the provider/model check before committing the lane, so a broken local choice fails fast with a repair path instead of surprising the next turn.
+The outward lane selects the provider/model for user-facing senses. The `inner` lane selects the provider/model for private agent-facing turns; private-runtime policy decides whether those turns may run. `ouro use` performs the provider/model check before committing the lane, so a broken local choice fails fast with a repair path instead of surprising the next turn.
 
 For the full locked auth/provider contract, including refresh, repair actors, caching, and SerpentGuide hatch bootstrap, see `docs/auth-and-providers.md`.
 
@@ -207,7 +212,8 @@ ouro poke <agent> --task <task-id>
 ouro poke <agent> --habit <habit-name>
 ouro habit list --agent <agent>
 ouro habit create --agent <agent> <name> --cadence <interval>
-ouro inner --agent <agent>           # private turn status
+ouro private status --agent <agent>
+ouro private decisions --agent <agent>
 ouro attention --agent <agent>       # attention queue
 ouro link <agent> --friend <id> --provider <provider> --external-id <external-id>
 ouro setup --tool <tool> --agent <name>   # register MCP server + hooks with a dev tool
@@ -221,13 +227,13 @@ The generic secret primitive is a vault item / credential in the owning agent va
 
 To clone an existing agent onto a new machine (macOS, Linux, or Windows via WSL2), see **[docs/cross-machine-setup.md](docs/cross-machine-setup.md)**. The short version is bundle plus vault: `npx ouro.bot@latest`, open the home deck, choose clone, enter the bundle's git remote URL, unlock the agent vault, refresh/verify credentials, and start with `ouro up`.
 
-## The Agent's Inner Life
+## The Agent's Private Runtime And Rhythms
 
-Agents in Ouroboros aren't just responders — they have an autonomous inner life.
+Agents in Ouroboros aren't just responders — they have private agent-facing turns, recurring rhythms, durable records, and explicit spend policy.
 
 **Habits** are the agent's rhythms. A habit is an Ouro-native cron wrapper: it fires a private agent-facing session, can surface to family or the habit originator when it needs help or needs to report back, and leaves an audit receipt.
 
-**The inner lane** is where private sessions run. Habit runs, private returns, awaits, and self-maintenance can happen there, but the lane is not a record substrate. Anything durable leaves the lane: live continuity and audit go to Arc; work goes to Desk; learned facts and reference notes go to the Desk record.
+**The private runtime** is where private agent-facing turns run. It uses the `inner` provider/model lane, but the lane is only provider selection; the runtime is governed by private-runtime policy, receipts, and attention queues. Habit runs, private returns, awaits, and self-maintenance can happen privately, but private context is not a record substrate. Anything durable leaves the turn: live continuity and audit go to Arc; work goes to Desk; learned facts and reference notes go to the Desk record.
 
 **Desk and Arc** are the durable orientation pair. Arc owns live continuity, claims, obligations, and habit run receipts. Desk owns durable work and the maintained record. The target substrate is captured in [Agent Orientation Substrate](docs/agent-orientation-substrate.md).
 

package/changelog.json

@@ -1,6 +1,25 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.676",
+      "changes": [
+        "Make npm release-channel authority explicit: current clients consume the selected latest dist-tag under trusted publishing, legacy alpha is not treated as a supported pre-stable client channel, and tests guard install surfaces from teaching stale alpha usage."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.675",
+      "changes": [
+        "Render private-runtime prompt metadata without current inner channel/sense labels: private-runtime turns now show channel private-runtime and current sense private runtime (agent-facing runtime, not a sense), with tests and guards preventing channel/current-sense inner labels from returning.",
+        "Render canonical private-runtime CLI commands in prompt and usage surfaces: normal command lists now show ouro private status/decisions, ouro inner is labeled as a legacy alias only, and vocabulary guards reject unqualified ouro inner outside explicit compatibility fixtures.",
+        "Bind private-runtime spend receipts to resolved provider lane metadata and keep legacy inner terminology out of active prompt, ponder, socket, and generic CLI usage surfaces; direct ouro inner help remains a hidden compatibility alias only.",
+        "Bind production private-runtime receipts to cached provider credential revisions and fail closed when the receipt revision is missing, the selected lane's credential revision is unavailable, or the revision changes before execution.",
+        "Route fresh-session task, habit, and await private-runtime wakes through their payload-specific prompt builders instead of spending an approved receipt on generic bootstrap text.",
+        "Treat non-autostart private-runtime workers as intentionally parked in daemon status and startup polling while preloading provider credential metadata for revision-bound provider readiness.",
+        "Refresh live provider readiness during ouro up only when daemon status has configured provider rows with unknown readiness, preserving passive private-runtime startup without repeated provider-worker wakeups.",
+        "Keep the private-runtime coverage gate at 100% after the passive-startup hardening by covering credential-cache misses, legacy compatibility shims, passive timeout parking, and explicit daemon initial-alive branches."
+      ]
+    },
     {
       "version": "0.1.0-alpha.674",
       "changes": [

package/dist/arc/evolution.js

@@ -82,19 +82,19 @@ const ALL_ACTIONS = [
     "ratify",
 ];
 const HUMAN_REQUIRED_ACTIONS = new Set([
+    "mutate_credentials",
+]);
+const REVIEWER_REQUIRED_ACTIONS = new Set([
+    "merge_pr",
     "release_publish",
+    "install_local",
+    "mutate_shared_skill",
     "mutate_identity",
     "mutate_voice",
-    "mutate_credentials",
     "mutate_provider_config",
     "send_external_message",
     "change_hosted_infra",
 ]);
-const ASK_BEFORE_ACTIONS = new Set([
-    "merge_pr",
-    "install_local",
-    "mutate_shared_skill",
-]);
 function nowIso() {
     return new Date().toISOString();
 }
@@ -135,14 +135,14 @@ function defaultAuthority(updatedAt) {
     for (const action of ALL_ACTIONS) {
         actions[action] = HUMAN_REQUIRED_ACTIONS.has(action)
             ? "human_required"
-            : ASK_BEFORE_ACTIONS.has(action)
-                ? "ask_before_action"
+            : REVIEWER_REQUIRED_ACTIONS.has(action)
+                ? "reviewer_required"
                 : "allowed";
     }
     return {
         actions,
         updatedAt,
-        reason: "default conservative evolution authority",
+        reason: "default conservative evolution authority with reviewer gates",
     };
 }
 function isEvolutionCase(value) {
@@ -227,6 +227,9 @@ function budgetExhausted(item, action) {
     }
     return false;
 }
+function fallbackAuthorityForAction(action) {
+    return HUMAN_REQUIRED_ACTIONS.has(action) ? "human_required" : "reviewer_required";
+}
 function spendBudget(item, action) {
     const budget = {
         ...item.budget,
@@ -370,7 +373,7 @@ function evaluateEvolutionAction(agentRoot, caseId, action) {
         return { allowed: false, code: "case_not_found", reason: `Evolution case not found: ${caseId}` };
     if (isTerminal(item))
         return { allowed: false, code: "terminal_case", reason: `Evolution case is ${item.status}` };
-    const authority = item.authority.actions[action] ?? "human_required";
+    const authority = item.authority.actions[action] ?? fallbackAuthorityForAction(action);
     if (authority !== "allowed")
         return { allowed: false, code: authority, reason: `${action} is ${authority}` };
     if (budgetExhausted(item, action))

package/dist/arc/obligations.js

@@ -280,7 +280,7 @@ function advanceReturnObligation(agentName, obligationId, update) {
     });
     return updated;
 }
-// Inner return obligations that have been sitting in queued/running state
+// Private-runtime return obligations that have been sitting in queued/running state
 // longer than this are auto-pruned from the "held work items" injection.
 // Anything older is overwhelmingly noise: the agent has had many turns to
 // resolve them and has not, and reinjecting them every turn just burns

package/dist/heart/active-work.js

@@ -199,7 +199,7 @@ function formatActiveLane(frame, obligation) {
         return "this same thread";
     }
     if (frame.inner?.job?.status === "running") {
-        return "inner lane";
+        return "private runtime";
     }
     return null;
 }
@@ -681,7 +681,7 @@ function buildActiveWorkFrame(input) {
 }
 function formatActiveWorkFrame(frame, options) {
     const lines = ["## what i'm holding"];
-    lines.push("this is my top-level live world-state right now. inner work, coding lanes, other sessions, and return obligations all belong inside this picture.");
+    lines.push("this is my top-level live world-state right now. private-runtime work, coding lanes, other sessions, and return obligations all belong inside this picture.");
     lines.push("if older checkpoints elsewhere in the transcript disagree with this picture, this picture wins.");
     const primaryObligation = findPrimaryOpenObligation(frame);
     const currentSessionObligation = findCurrentSessionOpenObligation(frame);
@@ -847,7 +847,7 @@ function formatActiveWorkFrame(frame, options) {
     }
     if (frame.innerReturnObligations && frame.innerReturnObligations.length > 0) {
         lines.push("");
-        lines.push("## inner return obligations");
+        lines.push("## private-runtime return obligations");
         for (const ob of frame.innerReturnObligations) {
             const preview = ob.delegatedContent.length > 60
                 ? `${ob.delegatedContent.slice(0, 57)}...`

package/dist/heart/agent-entry.js

@@ -48,17 +48,17 @@ const runtime_1 = require("../nerves/runtime");
 (0, runtime_1.emitNervesEvent)({
     component: "senses",
     event: "senses.entry_boot",
-    message: "booting inner-dialog entrypoint",
-    meta: { entry: "inner-dialog", agentName },
+    message: "starting private-runtime process entrypoint",
+    meta: { entry: "private-runtime", agentName },
 });
-// Dynamic import: agent-entry is boot-time wiring that starts a sense process.
+// Dynamic import: agent-entry is process-start wiring that starts a sense process.
 // Using dynamic import avoids a static heart/ -> senses/ dependency.
 Promise.resolve().then(() => __importStar(require("./runtime-credentials"))).then(async ({ readMachineRuntimeCredentialConfig, readRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, refreshRuntimeCredentialConfig, waitForRuntimeCredentialBootstrap, }) => {
     await waitForRuntimeCredentialBootstrap(agentName);
     if (!readRuntimeCredentialConfig(agentName).ok) {
         void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
     }
-    /* v8 ignore next 7 -- boot-time best-effort machine credential refresh runs in a child entrypoint and is covered operationally by daemon startup tests @preserve */
+    /* v8 ignore next 7 -- process-start best-effort machine credential refresh runs in a child entrypoint and is covered operationally by daemon startup tests @preserve */
     if (!readMachineRuntimeCredentialConfig(agentName).ok) {
         void Promise.resolve().then(() => __importStar(require("./machine-identity"))).then(({ loadOrCreateMachineIdentity }) => {
             const machine = loadOrCreateMachineIdentity();
@@ -66,16 +66,16 @@ Promise.resolve().then(() => __importStar(require("./runtime-credentials"))).the
         })
             .catch(() => undefined);
     }
-    const { startInnerDialogWorker } = await Promise.resolve().then(() => __importStar(require("../senses/inner-dialog-worker")));
-    await startInnerDialogWorker();
+    const { startPrivateRuntimeWorker } = await Promise.resolve().then(() => __importStar(require("../senses/private-runtime-worker")));
+    await startPrivateRuntimeWorker();
 })
     .catch((error) => {
     (0, runtime_1.emitNervesEvent)({
         level: "error",
         component: "senses",
         event: "senses.entry_error",
-        message: "inner-dialog entrypoint failed",
-        meta: { entry: "inner-dialog", agentName, error: error instanceof Error ? error.message : String(error) },
+        message: "private-runtime entrypoint failed",
+        meta: { entry: "private-runtime", agentName, error: error instanceof Error ? error.message : String(error) },
     });
     // eslint-disable-next-line no-console -- fatal startup guard for worker process
     console.error(error instanceof Error ? error.message : String(error));

package/dist/heart/commitments.js

@@ -72,7 +72,7 @@ function deriveCommitments(activeWorkFrame, innerJob, pendingObligations, pendin
     }
     // Safe to ignore
     if (innerJob.status === "idle" && !(activeWorkFrame.inner?.hasPending)) {
-        safeToIgnore.push("no private thinking in progress");
+        safeToIgnore.push("no private-runtime work in progress");
     }
     if (activeWorkFrame.bridges.length === 0) {
         safeToIgnore.push("no shared work to coordinate");

package/dist/heart/core.js

@@ -334,7 +334,7 @@ async function habitToolBatchBlockReason(habitSession, toolCalls, delegatedOrigi
     return null;
 }
 /** Chat-style channels expose the `speak` tool — outer human-conversation channels
- *  where mid-turn delivery is meaningful. Inner dialog has `ponder`. MCP returns
+ *  where mid-turn delivery is meaningful. The private runtime has `ponder`. MCP returns
  *  synchronously. Mail is batch. Anything else (unknown channel) treats as non-chat. */
 function isChatStyleChannel(channel) {
     return channel === "cli" || channel === "teams" || channel === "bluebubbles" || channel === "voice";
@@ -483,7 +483,7 @@ function claimsPrivateReturnQueued(answer) {
     if (!answer)
         return false;
     const normalized = answer.toLowerCase();
-    return /\b(queued|queue|will return|return when|when .*complete|when .*completes|private pass|inner dialog completes|later)\b/.test(normalized)
+    return /\b(queued|queue|will return|return when|when .*complete|when .*completes|private pass|private runtime completes|inner dialog completes|later)\b/.test(normalized)
         && /\b(private|inner|return|queued|later)\b/.test(normalized);
 }
 function privateReturnMissingPonderError(input) {
@@ -493,7 +493,7 @@ function privateReturnMissingPonderError(input) {
         return null;
     if (!claimsPrivateReturnQueued(input.answer))
         return null;
-    return "private-return acknowledgement claimed work was queued, but no ponder packet was created this turn. Call ponder(action=create, ...) first so the return has a packet, return obligation, and inner wake; then settle with only a queued acknowledgement. If you cannot create the packet, ask a blocking clarification without saying it is queued.";
+    return "private-return acknowledgement claimed work was queued, but no ponder packet was created this turn. Call ponder(action=create, ...) first so the return has a packet, return obligation, and private-runtime wake; then settle with only a queued acknowledgement. If you cannot create the packet, ask a blocking clarification without saying it is queued.";
 }
 function activeReturnObligationId(agentName, obligationId) {
     if (!obligationId)
@@ -501,6 +501,27 @@ function activeReturnObligationId(agentName, obligationId) {
     const obligation = (0, obligations_1.readReturnObligation)(agentName, obligationId);
     return obligation?.status === "queued" || obligation?.status === "running" ? obligationId : null;
 }
+function ponderReturnSessionId(packet) {
+    const origin = packet.origin;
+    if (!origin)
+        return "unknown/unknown/unknown";
+    return `${origin.friendId}/${origin.channel}/${origin.key}`;
+}
+function buildPonderReturnPrivateWakeOptions(input) {
+    const sessionId = ponderReturnSessionId(input.packet);
+    return {
+        reason: "ponder return obligation private attention",
+        triggerSource: "ponder-return-obligation",
+        budgetClass: "interactive",
+        idempotencyKey: `ponder-return:${input.agentName}:${input.returnObligationId}:${input.packet.id}:${sessionId}`,
+        originRefs: [
+            { kind: "tool", id: "ponder" },
+            { kind: "ponder-packet", id: input.packet.id },
+            { kind: "return-obligation", id: input.returnObligationId },
+            { kind: "session", id: sessionId },
+        ],
+    };
+}
 function buildPonderResult(packet, action, returnObligationId) {
     return JSON.stringify({
         ok: true,
@@ -509,7 +530,7 @@ function buildPonderResult(packet, action, returnObligationId) {
         status: packet.status,
         return_obligation_id: returnObligationId,
         private_return_contract: returnObligationId
-            ? "queued for inner attention; do not present the requested private answer as complete in this same outward turn. if you answer now, only say the private pass is queued and will return when ready."
+            ? "queued for private-runtime attention; do not present the requested private answer as complete in this same outward turn. if you answer now, only say the private pass is queued and will return when ready."
             : null,
     }, null, 2);
 }
@@ -885,30 +906,30 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     providerRuntime.resetTurnState(messages);
     while (!done) {
         // Channel-based tool filtering:
-        // - Inner dialog: exclude send_message (delivery via surface), observe (no one to observe)
+        // - Private runtime: exclude send_message (delivery via surface), observe (no one to observe)
         // - All outward channels (1:1, group, reaction): observe available
         //
         // ponder, settle/rest, surface, and observe are always assembled based on channel context.
         // ponder is available in ALL channels (outer: think privately, inner: keep turning).
-        // Inner dialog gets restTool instead of settleTool (rest = end turn, gated by attention queue).
+        // Private runtime gets restTool instead of settleTool (rest = end turn, gated by attention queue).
         // toolChoiceRequired only controls whether tool_choice: "required" is set in the API call.
-        const isInnerDialog = channel === "inner";
-        const innerHabitCanSendMessage = isInnerDialog
+        const isPrivateRuntimeChannel = channel === "inner";
+        const privateRuntimeHabitCanSendMessage = isPrivateRuntimeChannel
             && habitSession?.toolPolicy.outwardMessagingAllowed === true
             && habitSession.toolPolicy.grantedTools.includes("send_message");
-        const innerHabitCanSurface = isInnerDialog
+        const privateRuntimeHabitCanSurface = isPrivateRuntimeChannel
             && (!habitSession || (habitSession.toolPolicy.outwardMessagingAllowed === true
                 && habitSession.toolPolicy.grantedTools.includes("surface")));
-        const filteredBaseTools = isInnerDialog
-            ? baseTools.filter((t) => innerHabitCanSendMessage || t.function.name !== "send_message")
+        const filteredBaseTools = isPrivateRuntimeChannel
+            ? baseTools.filter((t) => privateRuntimeHabitCanSendMessage || t.function.name !== "send_message")
             : baseTools;
         const activeTools = [
             ...filteredBaseTools,
             tools_1.ponderTool,
-            ...(isInnerDialog && innerHabitCanSurface ? [tools_2.surfaceToolDef] : []),
-            ...(isInnerDialog ? [tools_1.restTool] : []),
-            ...(!isInnerDialog ? [tools_1.observeTool] : []),
-            ...(!isInnerDialog ? [tools_1.settleTool] : []),
+            ...(isPrivateRuntimeChannel && privateRuntimeHabitCanSurface ? [tools_2.surfaceToolDef] : []),
+            ...(isPrivateRuntimeChannel ? [tools_1.restTool] : []),
+            ...(!isPrivateRuntimeChannel ? [tools_1.observeTool] : []),
+            ...(!isPrivateRuntimeChannel ? [tools_1.settleTool] : []),
             ...(isChatStyleChannel(channel ?? "") ? [tools_1.speakTool] : []),
         ];
         const activeToolNames = new Set(activeTools.map((tool) => tool.function.name));
@@ -1179,7 +1200,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     messages.push(msg);
                     messages.push({
                         role: "user",
-                        content: isInnerDialog
+                        content: isPrivateRuntimeChannel
                             ? "no tool was called this turn. you must end every turn by calling rest (or surface, ponder, observe). emit the tool call now."
                             : "no tool was called this turn. you must end every turn by calling settle with your answer (or ponder/observe). emit the tool call now.",
                     });
@@ -1222,9 +1243,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         return {};
                     } })();
                     callbacks.onToolStart("settle", settleArgs);
-                    // Inner dialog attention queue gate: reject settle if items remain
+                    // Private-runtime attention queue gate: reject settle if items remain
                     const attentionQueue = (augmentedToolContext ?? options?.toolContext)?.delegatedOrigins;
-                    if (isInnerDialog && attentionQueue && attentionQueue.length > 0) {
+                    if (isPrivateRuntimeChannel && attentionQueue && attentionQueue.length > 0) {
                         callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
                         callbacks.onClearText?.();
                         messages.push(msg);
@@ -1236,8 +1257,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     // Extract answer from the tool call arguments.
                     // Supports: {"answer":"text","intent":"..."} or "text" (JSON string).
                     const { answer, intent } = parseSettlePayload(result.toolCalls[0].arguments);
-                    // Inner dialog settle: no CompletionMetadata, "(settled)" ack
-                    if (isInnerDialog) {
+                    // Private-runtime settle: no CompletionMetadata, "(settled)" ack
+                    if (isPrivateRuntimeChannel) {
                         callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), true);
                         messages.push(msg);
                         const settled = "(settled)";
@@ -1407,7 +1428,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     }
                     if (tc.name === "send_message" && args.friendId === "self") {
                         const latestUserText = latestUserMessageText(messages);
-                        if (!isInnerDialog && looksLikePrivateReturnRequest(latestUserText)) {
+                        if (!isPrivateRuntimeChannel && looksLikePrivateReturnRequest(latestUserText)) {
                             const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
                             const rejection = "private-return requests must use ponder, not send_message(friendId=self). Create a typed ponder packet with the marker/source request preserved, then only acknowledge that the private pass is queued.";
                             callbacks.onToolStart(tc.name, args);
@@ -1498,7 +1519,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             let privateReturnSourceRequest = "";
                             if (action === "create") {
                                 if (isInnerChannel && attentionQueue.length > 0) {
-                                    throw new Error("inner dialog already has held return work in the attention queue; surface the existing delegationId instead of creating a replacement ponder packet.");
+                                    throw new Error("private runtime already has held return work in the attention queue; surface the existing delegationId instead of creating a replacement ponder packet.");
                                 }
                                 const kind = parsedArgs.kind;
                                 const objective = typeof parsedArgs.objective === "string" ? parsedArgs.objective.trim() : "";
@@ -1608,7 +1629,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                 for (const token of extractPrivateReturnHeldTokens(privateReturnSourceRequest)) {
                                     privateReturnHeldTokens.add(token);
                                 }
-                                await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)(), augmentedToolContext?.daemonSocketPath).catch(() => undefined);
+                                const agentName = (0, identity_2.getAgentName)();
+                                await (0, socket_client_1.requestPrivateWake)(agentName, augmentedToolContext?.daemonSocketPath, buildPonderReturnPrivateWakeOptions({ agentName, packet, returnObligationId })).catch(() => undefined);
                             }
                             sawPonder = true;
                             toolResult = buildPonderResult(packet, resultAction, returnObligationId);

package/dist/heart/daemon/agent-config-check.js

@@ -101,6 +101,27 @@ function resolveFacingProvider(parsed, facing, agentName, agentJsonPath) {
         : (0, provider_models_1.getDefaultModelForProvider)(provider);
     return { ok: true, selected: { facing, lane: laneForFacing(facing), provider, model } };
 }
+function validatePrivateRuntimeConfig(agentName, agentJsonPath, parsed) {
+    const privateRuntime = parsed.privateRuntime;
+    if (privateRuntime === undefined)
+        return null;
+    if (!privateRuntime || typeof privateRuntime !== "object" || Array.isArray(privateRuntime)) {
+        return {
+            ok: false,
+            error: `agent.json for '${agentName}' has invalid privateRuntime config; privateRuntime must be an object.`,
+            fix: `Use privateRuntime only for private-runtime policy such as { autoStart: false } in ${agentJsonPath}. Provider/model selection belongs to the inner lane: ouro use --agent ${agentName} --lane inner --provider <provider> --model <model>.`,
+        };
+    }
+    const privateRuntimeRecord = privateRuntime;
+    const forbidden = ["provider", "model"].filter((key) => Object.prototype.hasOwnProperty.call(privateRuntimeRecord, key));
+    if (forbidden.length === 0)
+        return null;
+    return {
+        ok: false,
+        error: `agent.json for '${agentName}' cannot set ${forbidden.map((key) => `privateRuntime.${key}`).join(" or ")}; privateRuntime cannot select providers or models.`,
+        fix: `Remove ${forbidden.map((key) => `privateRuntime.${key}`).join(" and ")} from ${agentJsonPath}. Provider/model selection belongs to the inner lane: ouro use --agent ${agentName} --lane inner --provider <provider> --model <model>.`,
+    };
+}
 function readAgentConfigForProviderCheck(agentName, bundlesRoot) {
     const agentJsonPath = configPathFor(agentName, bundlesRoot);
     let raw;
@@ -134,6 +155,9 @@ function readAgentConfigForProviderCheck(agentName, bundlesRoot) {
     if (parsed.enabled === false) {
         return { ok: true, disabled: true, agentJsonPath, parsed };
     }
+    const privateRuntimeError = validatePrivateRuntimeConfig(agentName, agentJsonPath, parsed);
+    if (privateRuntimeError)
+        return { ok: false, result: privateRuntimeError };
     return { ok: true, disabled: false, agentJsonPath, parsed };
 }
 function readProviderSelectionForCheck(agentName, bundlesRoot) {

package/dist/heart/daemon/agent-discovery.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isLibraryKind = isLibraryKind;
 exports.listAllBundleAgents = listAllBundleAgents;
 exports.listEnabledBundleAgents = listEnabledBundleAgents;
+exports.readPrivateRuntimeConfig = readPrivateRuntimeConfig;
 exports.isInnerDialogAutoStartEnabled = isInnerDialogAutoStartEnabled;
 exports.listBundleSyncRows = listBundleSyncRows;
 const fs = __importStar(require("fs"));
@@ -117,44 +118,54 @@ function listEnabledBundleAgents(options = {}) {
         .filter((row) => row.enabled && !isLibraryKind(row.kind))
         .map((row) => row.name);
 }
-/**
- * Per-agent runtime policy for the always-on inner-dialog worker. Agents
- * default to the historic behavior (auto-start on daemon boot), but a bundle
- * can opt out with:
- *
- *   "innerDialog": { "autoStart": false }
- *
- * This keeps the agent enabled for sync/status/senses while preventing an
- * autonomous boot turn from spending model credits.
- */
-function isInnerDialogAutoStartEnabled(agent, options = {}) {
+function readPrivateRuntimeConfig(agent, options = {}) {
     const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
     const readFileSync = options.readFileSync ?? fs.readFileSync;
     const configPath = path.join(bundlesRoot, `${agent}.ouro`, "agent.json");
     try {
         const raw = readFileSync(configPath, "utf-8");
         const parsed = JSON.parse(raw);
+        const privateRuntime = parsed.privateRuntime;
+        if (privateRuntime && typeof privateRuntime === "object" && !Array.isArray(privateRuntime)) {
+            return {
+                autoStart: privateRuntime.autoStart === true,
+                source: "privateRuntime",
+            };
+        }
         const innerDialog = parsed.innerDialog;
         if (innerDialog && typeof innerDialog === "object" && !Array.isArray(innerDialog)) {
-            return innerDialog.autoStart !== false;
+            return {
+                autoStart: innerDialog.autoStart === true,
+                source: "legacy-innerDialog",
+                compatibilityNote: "innerDialog.autoStart is a legacy migration input; use privateRuntime.autoStart.",
+            };
         }
-        return true;
+        return { autoStart: false, source: "default" };
     }
     catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "daemon",
-            event: "daemon.inner_dialog_policy_read_failed",
-            message: "failed to read inner-dialog auto-start policy; refusing autonomous worker start",
+            event: "daemon.private_runtime_policy_read_failed",
+            message: "failed to read private-runtime auto-start policy; refusing autonomous private-runtime start",
             meta: {
                 agent,
                 configPath,
-                error: error instanceof Error ? error.message : String(error),
+                error: message,
             },
         });
-        return false;
+        return { autoStart: false, source: "unreadable", error: message };
     }
 }
+/**
+ * Legacy compatibility shim for older call sites. New code should use
+ * readPrivateRuntimeConfig() so compatibility notes and failure provenance are
+ * preserved.
+ */
+function isInnerDialogAutoStartEnabled(agent, options = {}) {
+    return readPrivateRuntimeConfig(agent, options).autoStart;
+}
 /**
  * Read the per-agent sync block from each enabled bundle's agent.json.
  * Used by the daemon (and stopped-state status renderer) to build per-agent

package/dist/heart/daemon/agent-service.js

@@ -75,8 +75,8 @@ function readAgentFile(agent, ...segments) {
 function agentDiaryRoot(agent) {
     return (0, record_paths_1.resolveRecordDiaryRoot)((0, identity_1.getAgentRoot)(agent));
 }
-/** Read inner dialog runtime status. */
-function readInnerDialogStatus(agent) {
+/** Read private-runtime status. */
+function readPrivateRuntimeStatus(agent) {
     const content = readAgentFile(agent, "state", "sessions", "self", "inner", "runtime.json");
     if (!content)
         return null;
@@ -302,7 +302,7 @@ async function handleAgentStatus(params) {
     (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.agent_service_start", message: "handling agent.status", meta: { agent: params.agent } });
     const diaryRoot = agentDiaryRoot(params.agent);
     const facts = (0, diary_1.readDiaryEntries)(diaryRoot);
-    const innerStatus = readInnerDialogStatus(params.agent);
+    const innerStatus = readPrivateRuntimeStatus(params.agent);
     const sessions = enumerateSessions(params.agent);
     const mcpVersion = readMcpRuntimeVersion();
     const runtime = await readRuntimeStatus(params.socketPath ?? socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, params.agent);
@@ -354,10 +354,10 @@ async function handleAgentCatchup(params) {
     const sessions = enumerateSessions(params.agent);
     const sorted = sessions.sort((a, b) => (b.lastUsage || "").localeCompare(a.lastUsage || ""));
     const recentSessions = sorted.slice(0, 5);
-    const innerStatus = readInnerDialogStatus(params.agent);
+    const innerStatus = readPrivateRuntimeStatus(params.agent);
     const parts = [];
     if (innerStatus) {
-        parts.push(`Inner dialog: ${innerStatus.status} (last completed: ${innerStatus.lastCompletedAt || "never"})`);
+        parts.push(`Private runtime: ${innerStatus.status} (last completed: ${innerStatus.lastCompletedAt || "never"})`);
     }
     if (recentSessions.length > 0) {
         parts.push(`Recent sessions (${recentSessions.length}):`);
@@ -391,7 +391,7 @@ async function handleAgentGetContext(params) {
     const query = (params.question ?? params.query ?? params.topic);
     const diaryRoot = agentDiaryRoot(params.agent);
     const facts = (0, diary_1.readDiaryEntries)(diaryRoot);
-    const innerStatus = readInnerDialogStatus(params.agent);
+    const innerStatus = readPrivateRuntimeStatus(params.agent);
     const sessions = enumerateSessions(params.agent);
     const taskFiles = listTaskFiles(params.agent);
     let recordSummary = null;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAwaitPrivateWakeCommand = buildAwaitPrivateWakeCommand;
+exports.awaitNameFromPrivateWakeCommand = awaitNameFromPrivateWakeCommand;
+const runtime_1 = require("../../nerves/runtime");
+const reasonPrefixByTrigger = {
+    "await-poke": "manual await condition check",
+    "await-scheduler": "scheduled await condition check",
+    "await-expiry": "queued await expiry alert",
+};
+function awaitOriginRefs(awaitName, triggerSource) {
+    if (triggerSource === "await-poke") {
+        return [
+            { kind: "await", id: awaitName },
+            { kind: "daemon-command", id: "await.poke" },
+        ];
+    }
+    if (triggerSource === "await-scheduler") {
+        return [
+            { kind: "await", id: awaitName },
+            { kind: "scheduler", id: "await-scheduler" },
+        ];
+    }
+    return [
+        { kind: "await", id: awaitName },
+        { kind: "await-alert", id: "expired" },
+    ];
+}
+function buildAwaitPrivateWakeCommand(options) {
+    const firedAt = (options.now ?? (() => new Date()))().toISOString();
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.await_private_wake_built",
+        message: "built await private-runtime wake command",
+        meta: {
+            agent: options.agent,
+            awaitName: options.awaitName,
+            triggerSource: options.triggerSource,
+        },
+    });
+    return {
+        kind: "private.wake",
+        agent: options.agent,
+        reason: `${reasonPrefixByTrigger[options.triggerSource]} for ${options.awaitName}`,
+        triggerSource: options.triggerSource,
+        budgetClass: "scheduled",
+        idempotencyKey: `await:${options.agent}:${options.awaitName}:${options.triggerSource}:${firedAt}`,
+        originRefs: awaitOriginRefs(options.awaitName, options.triggerSource),
+    };
+}
+function awaitNameFromPrivateWakeCommand(command) {
+    if (command.kind !== "private.wake")
+        return null;
+    const awaitRef = command.originRefs?.find((ref) => ref.kind === "await" && typeof ref.id === "string");
+    if (!awaitRef || typeof awaitRef.id !== "string")
+        return null;
+    const trimmed = awaitRef.id.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}