@ouro.bot/cli 0.1.0-alpha.925 → 0.1.0-alpha.926

package/changelog.json

@@ -1,6 +1,16 @@
 {
   "_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.926",
+      "changes": [
+        "Open a compact independent Ouro session composer with short About labels, draft preservation, canonical replies and no blind resubmission.",
+        "Install a managed cmux Swift Talk to Ouro entry that opens a browser split without moving coding focus; pin each conversation independently and retain the existing family-only terminal authority.",
+        "Preserve the original session and request identity through lost acknowledgements and listener restarts; refresh choices without retargeting, recover definitively refused starts, and keep one-off web views from replacing the managed native entry.",
+        "Validate the UTF-8 request budget before arming a send, keep explicitly oversized unsent drafts editable, and decode multibyte HTTP messages without corruption; an earlier unknown acknowledgement still retains its original identity.",
+        "Trace independent view generation, native entry generation and expected frontend conflicts without logging entry credentials, nonces, session keys or human feedback."
+      ]
+    },
     {
       "version": "0.1.0-alpha.925",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.925",
+  "runtimeVersion": "0.1.0-alpha.926",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.925</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.926</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/daemon/cli-exec.js

@@ -7912,7 +7912,11 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         const { frontendSocketPathForDaemon } = await Promise.resolve().then(() => __importStar(require("../frontend-socket")));
         const socketPath = frontendSocketPathForDaemon(deps.socketPath);
         if (deps.startShepherdChat) {
-            await deps.startShepherdChat({ agent: command.agent, ...(command.session ? { session: command.session } : {}), socketPath });
+            await deps.startShepherdChat({ agent: command.agent, ...(command.session ? { session: command.session } : {}), ...(command.web ? { web: true } : {}), socketPath });
+        }
+        else if (command.web) {
+            const { runShepherdAttention } = await Promise.resolve().then(() => __importStar(require("../../senses/shepherd/attention")));
+            await runShepherdAttention({ agent: command.agent, ...(command.session ? { session: command.session } : {}), socketPath });
         }
         else {
             const { runShepherdComposer } = await Promise.resolve().then(() => __importStar(require("../../senses/shepherd/composer")));

package/dist/heart/daemon/cli-help.js

@@ -120,8 +120,8 @@ exports.COMMAND_REGISTRY = {
     },
     shepherd: {
         category: "Agents",
-        description: "Open an independent Ouro composer for one coding terminal. Uses a named picker when ambiguous; /cancel cancels only Ouro's turn, /quit exits. Not an input hook in the coding agent.",
-        usage: "ouro shepherd chat --agent <name> [--session <UUID>]",
+        description: "Open an independent Ouro composer for one coding terminal. --web opens the compact graphical view in cmux; the managed cmux Shepherd sense also installs a native Talk to Ouro button. Without --web, /cancel cancels only Ouro's turn and /quit exits. Not an input hook in the coding agent.",
+        usage: "ouro shepherd chat --agent <name> [--session <UUID>] [--web]",
         example: "ouro shepherd chat --agent ouroboros",
         subcommands: ["chat"],
     },

package/dist/heart/daemon/cli-parse.js

@@ -3122,22 +3122,27 @@ function parseOuroCommand(args) {
     if (head === "mcp")
         return parseMcpCommand(args.slice(1));
     if (head === "shepherd") {
-        const usage = "Usage: ouro shepherd chat --agent <name> [--session <UUID>]";
+        const usage = "Usage: ouro shepherd chat --agent <name> [--session <UUID>] [--web]";
         if (args[1] !== "chat")
             throw new Error(usage);
         const values = new Map();
-        for (let i = 2; i < args.length; i += 2) {
+        for (let i = 2; i < args.length; i += 1) {
             const flag = args[i];
+            if (flag === "--web" && !values.has(flag)) {
+                values.set(flag, "true");
+                continue;
+            }
             const value = args[i + 1];
             if (!["--agent", "--session"].includes(flag) || values.has(flag) || !value || value.startsWith("--"))
                 throw new Error(usage);
             values.set(flag, value);
+            i += 1;
         }
         const agent = values.get("--agent");
         const session = values.get("--session");
         if (!agent || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(agent) || (session !== undefined && !surface_1.SHEPHERD_UUID.test(session)))
             throw new Error(usage);
-        return { kind: "shepherd.chat", agent, ...(session ? { session } : {}) };
+        return { kind: "shepherd.chat", agent, ...(session ? { session } : {}), ...(values.has("--web") ? { web: true } : {}) };
     }
     if (head === "voice")
         return parseVoiceCommand(args.slice(1));

package/dist/heart/frontend-session-service.js

@@ -1,23 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FrontendSessionService = exports.FrontendSessionConflictError = exports.FrontendTurnConflictError = void 0;
+exports.FrontendSessionService = exports.FrontendTurnConflictError = exports.FrontendSessionConflictError = void 0;
 const shared_turn_1 = require("../senses/shared-turn");
 const runtime_1 = require("../nerves/runtime");
 const surface_1 = require("../senses/shepherd/surface");
-class FrontendTurnConflictError extends Error {
-    constructor(turnId) {
-        super(`frontend turn already exists: ${turnId}`);
-        this.name = "FrontendTurnConflictError";
-    }
-}
-exports.FrontendTurnConflictError = FrontendTurnConflictError;
-class FrontendSessionConflictError extends Error {
-    constructor(sessionKey) {
-        super(`frontend session already has an active turn: ${sessionKey}`);
-        this.name = "FrontendSessionConflictError";
-    }
-}
-exports.FrontendSessionConflictError = FrontendSessionConflictError;
+const frontend_turn_errors_1 = require("./frontend-turn-errors");
+var frontend_turn_errors_2 = require("./frontend-turn-errors");
+Object.defineProperty(exports, "FrontendSessionConflictError", { enumerable: true, get: function () { return frontend_turn_errors_2.FrontendSessionConflictError; } });
+Object.defineProperty(exports, "FrontendTurnConflictError", { enumerable: true, get: function () { return frontend_turn_errors_2.FrontendTurnConflictError; } });
 const JOURNALED_FRONTEND_EVENTS = new Set([
     "assistant_delivery",
     "tool_started",
@@ -144,12 +134,12 @@ class FrontendSessionService {
             ...(request.shepherdSession ? { shepherdSession: Object.freeze({ ...request.shepherdSession }) } : {}),
         };
         if (this.activeTurns.has(turnId))
-            throw new FrontendTurnConflictError(turnId);
+            throw new frontend_turn_errors_1.FrontendTurnConflictError(turnId);
         if (this.journal && this.turnStatus(normalized, turnId).state !== "unknown")
-            throw new FrontendTurnConflictError(turnId);
+            throw new frontend_turn_errors_1.FrontendTurnConflictError(turnId);
         const sessionIdentity = [normalized.agent, normalized.friendId, normalized.channel, normalized.sessionKey].join("\0");
         if (this.activeSessions.has(sessionIdentity))
-            throw new FrontendSessionConflictError(normalized.sessionKey);
+            throw new frontend_turn_errors_1.FrontendSessionConflictError(normalized.sessionKey);
         const controller = new AbortController();
         this.activeTurns.set(turnId, controller);
         this.turnRefs.set(turnId, normalized);

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

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocketFrontendClient = void 0;
+exports.SocketFrontendClient = exports.FrontendRequestError = void 0;
 const net = __importStar(require("node:net"));
 const runtime_1 = require("../nerves/runtime");
 // A dropped or refused frontend socket is a transient transport condition, not a
@@ -45,6 +45,15 @@ function markTransientTransport(error) {
 function transientTransportError(message) {
     return markTransientTransport(new Error(message));
 }
+class FrontendRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "FrontendRequestError";
+    }
+}
+exports.FrontendRequestError = FrontendRequestError;
 class SocketFrontendClient {
     socketPath;
     pending = new Map();
@@ -143,7 +152,7 @@ class SocketFrontendClient {
                     continue;
                 this.pending.delete(frame.id);
                 if (frame.ok === false) {
-                    pending.reject(new Error(String(frame.error?.message ?? "frontend request failed")));
+                    pending.reject(new FrontendRequestError(String(frame.error?.code ?? "request_failed"), String(frame.error?.message ?? "frontend request failed")));
                 }
                 else {
                     pending.resolve(frame.result);

package/dist/heart/frontend-socket.js

@@ -41,6 +41,7 @@ const fs = __importStar(require("node:fs"));
 const net = __importStar(require("node:net"));
 const path = __importStar(require("node:path"));
 const readline = __importStar(require("node:readline"));
+const frontend_turn_errors_1 = require("./frontend-turn-errors");
 const runtime_1 = require("../nerves/runtime");
 const PROTOCOL_VERSION = 1;
 const MAX_SOCKET_PATH_BYTES = 100;
@@ -302,36 +303,44 @@ async function startFrontendSocketServer(options) {
             return;
         }
         if (method === "turn.start" || method === "turn.start.observe-only") {
-            const observeOnly = method === "turn.start.observe-only";
-            if (params.toolMode !== undefined) {
-                throw new Error("toolMode is unsupported; use turn.start.observe-only");
-            }
-            if (observeOnly && params.runtimeMcpServers !== undefined) {
-                throw new Error("turn.start.observe-only cannot include runtimeMcpServers");
-            }
-            const runtimeMcpServers = validatedRuntimeMcpServers(params.runtimeMcpServers);
-            const shepherdSession = params.shepherdSession === undefined ? undefined : await options.service.resolveShepherdSession(requiredString(params.agent, "agent"), requiredString(params.friendId, "friendId"), params.shepherdSession, params.composerTty === undefined ? undefined : requiredString(params.composerTty, "composerTty"));
-            if (shepherdSession && (observeOnly || params.channel !== "cli" || params.sessionKey !== `shepherd:${shepherdSession.id}`)) {
-                throw new Error("Shepherd routing requires a cli turn and the exact per-surface session key");
+            let prepared;
+            // Only preparation can be definitively refused; duplicate IDs must still reconcile.
+            try {
+                const observeOnly = method === "turn.start.observe-only";
+                if (params.toolMode !== undefined) {
+                    throw new Error("toolMode is unsupported; use turn.start.observe-only");
+                }
+                if (observeOnly && params.runtimeMcpServers !== undefined) {
+                    throw new Error("turn.start.observe-only cannot include runtimeMcpServers");
+                }
+                const runtimeMcpServers = validatedRuntimeMcpServers(params.runtimeMcpServers);
+                const shepherdSession = params.shepherdSession === undefined ? undefined : await options.service.resolveShepherdSession(requiredString(params.agent, "agent"), requiredString(params.friendId, "friendId"), params.shepherdSession, params.composerTty === undefined ? undefined : requiredString(params.composerTty, "composerTty"));
+                if (shepherdSession && (observeOnly || params.channel !== "cli" || params.sessionKey !== `shepherd:${shepherdSession.id}`)) {
+                    throw new Error("Shepherd routing requires a cli turn and the exact per-surface session key");
+                }
+                const turnRequest = {
+                    turnId: requiredString(params.turnId, "turnId"),
+                    agent: requiredString(params.agent, "agent"),
+                    friendId: requiredString(params.friendId, "friendId"),
+                    channel: requiredString(params.channel, "channel"),
+                    sessionKey: requiredString(params.sessionKey, "sessionKey"),
+                    message: (requiredString(params.message, "message"), params.message),
+                    ...(shepherdSession ? { shepherdSession } : {}),
+                    ...(observeOnly ? { disableTools: true, ephemeral: true } : {}),
+                    ...(runtimeMcpServers ? { runtimeMcpServers } : {}),
+                };
+                // Validation may await the host while this connection exits. Ownership must
+                // never be acquired after cleanup has already drained this client's turns.
+                if (client.closed || client.socket.destroyed || stopped)
+                    return;
+                prepared = options.service.prepareTurn(turnRequest);
             }
-            const turnRequest = {
-                turnId: requiredString(params.turnId, "turnId"),
-                agent: requiredString(params.agent, "agent"),
-                friendId: requiredString(params.friendId, "friendId"),
-                channel: requiredString(params.channel, "channel"),
-                sessionKey: requiredString(params.sessionKey, "sessionKey"),
-                message: (requiredString(params.message, "message"), params.message),
-                ...(shepherdSession ? { shepherdSession } : {}),
-                ...(observeOnly ? { disableTools: true, ephemeral: true } : {}),
-                ...(runtimeMcpServers ? { runtimeMcpServers } : {}),
-            };
-            // Validation may await the host while this connection exits. Ownership must
-            // never be acquired after cleanup has already drained this client's turns.
-            if (client.closed || client.socket.destroyed || stopped)
+            catch (error) {
+                client.writer.send(errorResponse(id, error instanceof frontend_turn_errors_1.FrontendTurnConflictError ? "turn_conflict" : "turn_rejected", error instanceof Error ? error.message : String(error)));
                 return;
-            const prepared = options.service.prepareTurn(turnRequest);
-            client.ownedTurnIds.add(turnRequest.turnId);
-            client.writer.send(response(id, { accepted: true, turnId: turnRequest.turnId }));
+            }
+            client.ownedTurnIds.add(prepared.request.turnId);
+            client.writer.send(response(id, { accepted: true, turnId: prepared.request.turnId }));
             queueMicrotask(() => {
                 void options.service.runPreparedTurn(prepared).catch(() => undefined);
             });

package/dist/heart/frontend-turn-errors.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrontendSessionConflictError = exports.FrontendTurnConflictError = void 0;
+const runtime_1 = require("../nerves/runtime");
+class FrontendTurnConflictError extends Error {
+    constructor(turnId) {
+        super(`frontend turn already exists: ${turnId}`);
+        this.name = "FrontendTurnConflictError";
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.frontend_turn_conflict", message: "frontend request named an already-owned turn" });
+    }
+}
+exports.FrontendTurnConflictError = FrontendTurnConflictError;
+class FrontendSessionConflictError extends Error {
+    constructor(sessionKey) {
+        super(`frontend session already has an active turn: ${sessionKey}`);
+        this.name = "FrontendSessionConflictError";
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "heart.frontend_session_conflict", message: "frontend session refused a competing turn" });
+    }
+}
+exports.FrontendSessionConflictError = FrontendSessionConflictError;

package/dist/senses/shepherd/attention-page.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ATTENTION_BODY_BYTES = void 0;
+exports.attentionPage = attentionPage;
+exports.MAX_ATTENTION_BODY_BYTES = 16_384;
+/** No model content or target metadata is interpolated into executable HTML. */
+function attentionPage(nonce) {
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_attention_page_rendered", message: "rendered the independent session attention view" });
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Ouro</title>
+<style nonce="${nonce}">
+:root{color-scheme:dark;font:15px -apple-system,BlinkMacSystemFont,sans-serif;color:#eee;background:#17191d}
+*{box-sizing:border-box}body{margin:0}main{max-width:680px;height:100dvh;min-height:340px;margin:auto;display:flex;flex-direction:column;padding:20px;gap:16px}
+header{display:flex;align-items:center;gap:10px}h1{font-size:21px;margin:0;letter-spacing:-.5px}.badge{font-size:12px;color:#9da4ae}
+label{display:flex;align-items:center;gap:10px;color:#aab1bb;font-size:13px}select{min-width:0;flex:1}
+select,textarea,button{font:inherit;color:inherit;border:1px solid #3b4049;background:#22262c;border-radius:10px;padding:10px}
+textarea{width:100%;resize:none;min-height:82px;outline:none}textarea:focus{border-color:#9bafff}
+#conversation{flex:1;overflow:auto;display:flex;flex-direction:column;gap:14px;min-height:70px}
+.message{white-space:pre-wrap;overflow-wrap:anywhere;line-height:1.55;margin:0}.you{align-self:flex-end;background:#2c354a;padding:10px 14px;border-radius:14px;max-width:90%}.notice{font-size:13px;color:#e0b275}
+#empty{color:#9da4ae;line-height:1.6;margin:auto 0}footer{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:10px}.actions{display:flex;gap:8px;margin-left:auto}
+button{cursor:pointer}button:disabled{opacity:.45;cursor:default}#send{background:#a8b8ff;color:#141823;border-color:transparent;font-weight:600}
+#status{font-size:12px;color:#9da4ae}#error{color:#e0b275;font-size:13px;margin:0}form{display:flex;flex-direction:column;gap:8px}
+</style></head><body><main>
+<header><h1>Ouro</h1><span class="badge">Your session companion</span></header>
+<label for="target">About<select id="target" aria-label="Session to discuss"></select><button id="refresh" type="button" aria-label="Refresh session choices">Refresh</button></label>
+<section id="conversation" aria-live="polite"><p id="empty">Ask Ouro about this session, steer the work, or correct a handback.<br>Your coding agent's input stays untouched.</p></section>
+<p id="error" role="alert"></p><form id="compose"><textarea id="draft" aria-label="Message Ouro" placeholder="Message Ouro..." maxlength="12000"></textarea>
+<footer><span id="status">Independent of the coding agent</span><div class="actions"><button id="recover" type="button" hidden>Reconnect</button><button id="cancel" type="button" hidden>Cancel Ouro</button><button id="send" type="submit" disabled>Send</button></div></footer></form>
+</main><script nonce="${nonce}">
+const fragment=new URLSearchParams(location.hash.slice(1));const initialTarget=fragment.get('session');const token=fragment.get('token')||location.hash.slice(1).split('&')[0]||sessionStorage.getItem('ouroAttentionToken');
+if(token){sessionStorage.setItem('ouroAttentionToken',token);history.replaceState(null,'',location.pathname);}
+const view=sessionStorage.getItem('ouroAttentionView')||crypto.randomUUID();sessionStorage.setItem('ouroAttentionView',view);
+const el=id=>document.getElementById(id);
+let state=null,pending=null,sending=false,targetsSignature='',messagesSignature='';
+let bindingReady=sessionStorage.getItem('ouroAttentionInitialized')==='true',pendingFault=false;
+try {
+  pending=JSON.parse(sessionStorage.getItem('ouroAttentionPending')||'null');
+  if(pending&&(typeof pending.id!=='string'||typeof pending.target!=='string'||typeof pending.message!=='string'))throw Error('Stored send identity is incomplete.');
+} catch(error) {
+  pendingFault=true;
+  el('error').textContent=error.message+' Check this conversation before resending; its request identity has not been discarded.';
+}
+let pendingWasUncertain=!!pending;
+el('draft').value=sessionStorage.getItem('ouroAttentionDraft')||'';el('draft').oninput=()=>sessionStorage.setItem('ouroAttentionDraft',el('draft').value);
+async function api(route,body) {
+  const response=await fetch(route,{
+    method:body?'POST':'GET',
+    headers:{'X-Ouro-Attention':token||'','X-Ouro-View':view,...(pending?{'X-Ouro-Pending':pending.id}:{}),...(body?{'Content-Type':'application/json'}:{})},
+    ...(body?{body:JSON.stringify(body)}:{})
+  });
+  const data=await response.json();
+  if(!response.ok) {const error=Error(data.error||'Ouro could not accept this action.');error.status=response.status;throw error;}
+  return data;
+}
+function acknowledge(submitted) {
+  if(!pending||pending.id!==submitted.id)return;
+  pending=null;
+  pendingWasUncertain=false;
+  sessionStorage.removeItem('ouroAttentionPending');
+  if(el('draft').value===submitted.message) {
+    el('draft').value='';
+    sessionStorage.removeItem('ouroAttentionDraft');
+  }
+  el('error').textContent='';
+}
+function render(next) {
+  state=next;
+  if(pending&&next.acknowledged?.id===pending.id&&next.acknowledged.target===pending.target)acknowledge(pending);
+  const picker=el('target'),signature=JSON.stringify(next.targets);
+  if(signature!==targetsSignature) {
+    targetsSignature=signature;picker.replaceChildren();
+    const prompt=document.createElement('option');prompt.value='';prompt.textContent='Choose a session';picker.append(prompt);
+    for(const target of next.targets) {
+      const option=document.createElement('option');option.value=target.id;option.textContent=target.label;picker.append(option);
+    }
+  }
+  picker.value=bindingReady?next.target||'':'';
+  picker.disabled=next.active||sending||!!pending||pendingFault;
+  const conversation=el('conversation'),nextMessages=JSON.stringify(next.messages);
+  if(next.messages.length&&nextMessages!==messagesSignature) {
+    const atBottom=conversation.scrollHeight-conversation.scrollTop-conversation.clientHeight<60;
+    conversation.replaceChildren();
+    for(const message of next.messages) {
+      const p=document.createElement('p');p.className='message '+message.role;p.textContent=message.text;conversation.append(p);
+    }
+    if(atBottom)conversation.scrollTop=conversation.scrollHeight;
+  } else if(!next.messages.length&&!el('empty')) {
+    conversation.replaceChildren();
+    const p=document.createElement('p');p.id='empty';p.textContent="Ask Ouro about this session. Your coding agent's input stays untouched.";conversation.append(p);
+  }
+  messagesSignature=nextMessages;
+  const available=next.targets.some(target=>target.id===next.target);
+  el('send').disabled=next.active||sending||!bindingReady||!available||pendingFault||!!(pending&&pending.target!==next.target);
+  el('cancel').hidden=!next.active;el('recover').hidden=!next.active&&!pending;
+  el('status').textContent=next.active?'Ouro is replying...':!next.targets.length?'No coding sessions available':!available?'Choose an available session':'Independent of the coding agent';
+}
+async function refresh() {
+  try {render(await api('/state'));}
+  catch(error) {el('error').textContent=error.message;el('send').disabled=true;}
+}
+async function select(target) {
+  const next=await api('/select',{target});
+  bindingReady=true;sessionStorage.setItem('ouroAttentionInitialized','true');render(next);
+}
+el('target').onchange=async()=>{
+  if(pending||pendingFault||sending) {el('error').textContent='Resolve the original message acknowledgement before changing About.';if(state)render(state);return;}
+  try {await select(el('target').value);el('error').textContent='';}
+  catch(error) {el('error').textContent=error.message;await refresh();}
+};
+el('refresh').onclick=async()=>{
+  try {render(await api('/targets',{}));}
+  catch(error) {el('error').textContent=error.message;}
+};
+el('compose').onsubmit=async event=>{
+  event.preventDefault();
+  if(sending||!bindingReady||pendingFault||!state?.target||state.active)return;
+  const message=el('draft').value;
+  if(!message.replace(/^@ouro(?:\\s+|$)/i,'').trim())return;
+  if(pending&&(pending.message!==message||pending.target!==state.target)) {
+    el('error').textContent='Reconnect before changing a message whose acknowledgement was lost.';return;
+  }
+  const submitted=pending||{id:crypto.randomUUID(),target:state.target,message};
+  if(new TextEncoder().encode(JSON.stringify(submitted)).byteLength>${exports.MAX_ATTENTION_BODY_BYTES}) {
+    el('error').textContent=pending?'The saved request is too large; check its original receipt before changing it.':'Message too large; shorten it. Nothing was sent.';
+    return;
+  }
+  pending=submitted;
+  sessionStorage.setItem('ouroAttentionPending',JSON.stringify(pending));
+  sending=true;render(state);
+  try {const next=await api('/send',submitted);acknowledge(submitted);render(next);}
+  catch(error) {
+    if(pending?.id===submitted.id) {
+      if(error.status===413&&!pendingWasUncertain) {
+        pending=null;sessionStorage.removeItem('ouroAttentionPending');
+        el('error').textContent=error.message+' Nothing was submitted; shorten the preserved draft.';
+      } else {
+        pendingWasUncertain=true;
+        el('error').textContent=error.message+' Your draft and original request identity are preserved.';
+      }
+    }
+  }
+  finally {sending=false;if(state)render(state);}
+};
+el('cancel').onclick=async()=>{
+  try {await api('/cancel',{});await refresh();}catch(error) {el('error').textContent=error.message;}
+};
+el('recover').onclick=async()=>{
+  try {await api('/recover',{});await refresh();}catch(error) {el('error').textContent=error.message;}
+};
+el('draft').onkeydown=event=>{
+  if(event.key==='Enter'&&!event.shiftKey&&!event.isComposing) {event.preventDefault();if(!el('send').disabled)el('compose').requestSubmit();}
+};
+async function initialize() {
+  try {
+    if(pending&&bindingReady)await refresh();
+    else if(initialTarget||!bindingReady)await select(pending?.target||initialTarget||'current');
+    else await refresh();
+  } catch(error) {bindingReady=false;el('error').textContent=error.message;await refresh();}
+}
+initialize();setInterval(refresh,1000);
+</script></body></html>`;
+}
+const runtime_1 = require("../../nerves/runtime");

package/dist/senses/shepherd/attention-sidebar.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attentionSidebar = attentionSidebar;
+exports.installAttentionSidebar = installAttentionSidebar;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+const MARKER = "// Generated by Ouro session attention.";
+/** Opens beside the coding terminal without moving focus; the view then pins a fresh hint. */
+function attentionSidebar(url) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" || parsed.hostname !== "127.0.0.1" || !/^[0-9a-f]{64}$/.test(parsed.hash.slice(1))) {
+        throw new Error("Attention sidebar requires its private loopback entry.");
+    }
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_attention_sidebar_generated", message: "generated the native session attention entry", meta: { format: "swift" } });
+    return `${MARKER}
+VStack(alignment: .leading, spacing: 12) {
+    Text("Ouro").font(.headline)
+    Text("Talk about this session without touching its input.").font(.caption).foregroundColor(.secondary)
+    ForEach(workspaces.filter { $0.selected }) { w in
+        Button(action: { cmux("browser.open_split", focus: false, workspace_id: w.id, url: ${JSON.stringify(url)}) }) {
+            Text("Talk to Ouro")
+        }
+    }
+}.padding(16)
+`;
+}
+function installAttentionSidebar(directory, url, agent = "ouro") {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(agent))
+        throw new Error("Attention requires a safe agent name.");
+    const file = path.join(directory, `ouro-attention-${agent}.swift`);
+    fs.mkdirSync(directory, { recursive: true });
+    if (fs.existsSync(file) && !fs.readFileSync(file, "utf8").startsWith(MARKER)) {
+        throw new Error("An independently authored ouro-attention sidebar already exists; it was not overwritten.");
+    }
+    const staging = `${file}.pending`;
+    fs.writeFileSync(staging, attentionSidebar(url), { mode: 0o600 });
+    fs.chmodSync(staging, 0o600);
+    fs.renameSync(staging, file);
+    return file;
+}

package/dist/senses/shepherd/attention.js

@@ -0,0 +1,280 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startShepherdAttention = startShepherdAttention;
+exports.startManagedShepherdAttention = startManagedShepherdAttention;
+exports.runShepherdAttention = runShepherdAttention;
+const node_crypto_1 = require("node:crypto");
+const http = __importStar(require("node:http"));
+const node_child_process_1 = require("node:child_process");
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const frontend_socket_client_1 = require("../../heart/frontend-socket-client");
+const runtime_1 = require("../../nerves/runtime");
+const composer_1 = require("./composer");
+const surface_1 = require("./surface");
+const attention_page_1 = require("./attention-page");
+const attention_sidebar_1 = require("./attention-sidebar");
+function suggestedTarget(targets) {
+    const hints = targets.filter(target => target.selected);
+    return hints.length === 1 ? hints[0] : targets.length === 1 ? targets[0] : null;
+}
+/** An owner-only loopback view of the existing fixed-target composer, not another model runtime. */
+async function startShepherdAttention(options) {
+    const friendId = await (options.resolveOwner ?? (() => (0, surface_1.resolveExistingLocalOwner)((0, surface_1.localShepherdFriendStore)(options.agent))))();
+    const makeClient = options.client ?? (() => new frontend_socket_client_1.SocketFrontendClient(options.socketPath));
+    const discovery = makeClient();
+    let targets;
+    try {
+        targets = (await discovery.request("shepherd.targets", { agent: options.agent, friendId })).targets;
+    }
+    finally {
+        discovery.close();
+    }
+    const selected = options.session
+        ? (0, composer_1.selectShepherdTarget)(targets, options.session)
+        : suggestedTarget(targets);
+    const views = new Map();
+    const submissions = new Map();
+    const token = (0, node_crypto_1.randomBytes)(32).toString("hex");
+    const nonce = (0, node_crypto_1.randomBytes)(24).toString("base64");
+    let origin = "";
+    const append = (view, role, text) => {
+        view.messages.push({ role, text });
+        view.messages = view.messages.slice(-40);
+    };
+    const getComposer = (view, target) => {
+        if (!view.composer)
+            view.composer = new composer_1.ShepherdComposer({
+                client: makeClient(), agent: options.agent, friendId, target,
+                notice: text => append(view, "notice", text), answer: text => append(view, "ouro", text),
+            });
+        return view.composer;
+    };
+    const state = (view, viewId, requestId) => ({
+        targets: targets.map(item => ({ id: item.id, label: item.displayLabel ?? "Coding session" })),
+        target: view.target?.id ?? null, active: view.composer?.busy ?? false, messages: view.messages,
+        acknowledged: requestId && submissions.get(requestId)?.view === viewId
+            ? { id: requestId, target: submissions.get(requestId).target } : null,
+    });
+    const server = http.createServer((request, response) => {
+        const json = (status, value) => {
+            response.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+            response.end(JSON.stringify(value));
+        };
+        void (async () => {
+            if (request.headers.host !== new URL(origin).host)
+                return json(403, { error: "Invalid attention host." });
+            if (request.method === "GET" && request.url === "/") {
+                response.writeHead(200, {
+                    "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store",
+                    "Content-Security-Policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'none'`,
+                    "Referrer-Policy": "no-referrer", "X-Content-Type-Options": "nosniff",
+                });
+                return response.end((0, attention_page_1.attentionPage)(nonce));
+            }
+            if (request.headers["x-ouro-attention"] !== token)
+                return json(403, { error: "Open attention from its local entry." });
+            const viewId = request.headers["x-ouro-view"] ?? "default";
+            if (typeof viewId !== "string" || (viewId !== "default" && !surface_1.SHEPHERD_UUID.test(viewId)))
+                return json(400, { error: "Invalid attention view." });
+            let view = views.get(viewId);
+            if (!view) {
+                if (views.size >= 64)
+                    return json(409, { error: "Attention reached its view limit. Restart Shepherd before opening another view." });
+                view = { target: selected ?? null, composer: null, messages: [] };
+                views.set(viewId, view);
+            }
+            const pendingId = typeof request.headers["x-ouro-pending"] === "string" ? request.headers["x-ouro-pending"] : undefined;
+            if (request.method === "GET" && request.url === "/state")
+                return json(200, state(view, viewId, pendingId));
+            if (request.method !== "POST" || request.headers.origin !== origin
+                || request.headers["content-type"] !== "application/json")
+                return json(403, { error: "Invalid attention origin or content type." });
+            const chunks = [];
+            let bytes = 0;
+            for await (const chunk of request) {
+                const buffer = Buffer.from(chunk);
+                bytes += buffer.length;
+                if (bytes > attention_page_1.MAX_ATTENTION_BODY_BYTES)
+                    return json(413, { error: "Message is too large." });
+                chunks.push(buffer);
+            }
+            const body = Buffer.concat(chunks).toString("utf8");
+            let input;
+            try {
+                input = JSON.parse(body);
+            }
+            catch {
+                return json(400, { error: "Invalid JSON." });
+            }
+            if (!input || typeof input !== "object" || Array.isArray(input))
+                return json(400, { error: "Invalid request." });
+            const fields = input;
+            if (request.url === "/targets") {
+                const refresh = makeClient();
+                try {
+                    targets = (await refresh.request("shepherd.targets", { agent: options.agent, friendId })).targets;
+                }
+                finally {
+                    refresh.close();
+                }
+                return json(200, state(view, viewId, pendingId));
+            }
+            if (request.url === "/select") {
+                if (view.composer?.busy)
+                    return json(409, { error: "Wait for or cancel Ouro before changing the session." });
+                if (typeof fields.target !== "string")
+                    return json(400, { error: "Choose a session." });
+                const refresh = makeClient();
+                try {
+                    targets = (await refresh.request("shepherd.targets", { agent: options.agent, friendId })).targets;
+                }
+                finally {
+                    refresh.close();
+                }
+                if (view.composer?.busy)
+                    return json(409, { error: "Ouro started replying while the session list refreshed; the conversation was not changed." });
+                const next = fields.target === "current" ? suggestedTarget(targets) : (0, composer_1.selectShepherdTarget)(targets, fields.target);
+                if (view.target?.id !== next?.id) {
+                    view.composer?.close();
+                    view.composer = null;
+                    view.target = next;
+                    view.messages = [];
+                }
+                return json(200, state(view, viewId, pendingId));
+            }
+            if (request.url === "/send") {
+                if (typeof fields.id !== "string" || !surface_1.SHEPHERD_UUID.test(fields.id)
+                    || typeof fields.message !== "string" || !fields.message.replace(/^@ouro(?:\s+|$)/i, "").trim())
+                    return json(400, { error: "Enter a message for Ouro." });
+                if (!view.target)
+                    return json(409, { error: "Choose the session you want to discuss." });
+                if (fields.target !== undefined && fields.target !== view.target.id)
+                    return json(409, { error: "This pending message is pinned to another session." });
+                const prior = submissions.get(fields.id);
+                if (prior) {
+                    if (prior.view !== viewId || prior.target !== view.target.id || prior.message !== fields.message)
+                        return json(409, { error: "This request id belongs to a different message or session." });
+                    return json(202, state(view, viewId, fields.id));
+                }
+                if (view.composer?.busy)
+                    return json(409, { error: "Ouro is already replying. Your draft has not been sent." });
+                if (submissions.size >= 2_000)
+                    return json(409, { error: "Attention reached its message limit. Restart Shepherd before sending more messages." });
+                const bound = getComposer(view, view.target);
+                submissions.set(fields.id, { view: viewId, target: view.target.id, message: fields.message });
+                append(view, "you", fields.message);
+                const submittedView = view;
+                void bound.submit(fields.message, fields.id).catch(error => append(submittedView, "notice", String(error)));
+                return json(202, state(view, viewId, fields.id));
+            }
+            if (request.url === "/cancel") {
+                const cancelled = await view.composer?.cancel() ?? false;
+                return json(200, { cancelled });
+            }
+            if (request.url === "/recover") {
+                await view.composer?.recover();
+                return json(200, state(view, viewId, pendingId));
+            }
+            return json(404, { error: "Unknown attention action." });
+        })().catch(error => {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_attention_error", message: "attention action failed", meta: { error: String(error) } });
+            if (!response.headersSent)
+                json(400, { error: String(error) });
+            else
+                response.destroy(error instanceof Error ? error : new Error(String(error)));
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new Error("Attention did not bind a loopback port.");
+    }
+    origin = `http://127.0.0.1:${address.port}`;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_attention_started", message: "opened independent graphical session attention", meta: { agent: options.agent } });
+    return {
+        url: `${origin}/#${token}`,
+        async close() {
+            try {
+                await Promise.all([...views.values()].map(view => view.composer?.cancel()));
+            }
+            finally {
+                for (const view of views.values())
+                    view.composer?.close();
+                server.closeAllConnections();
+                await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
+            }
+        },
+    };
+}
+async function startManagedShepherdAttention(options) {
+    const app = await startShepherdAttention(options);
+    try {
+        (0, attention_sidebar_1.installAttentionSidebar)(path.join(os.homedir(), ".config/cmux/sidebars"), app.url, options.agent);
+        const validated = (0, node_child_process_1.spawnSync)("cmux", ["sidebar", "validate", `ouro-attention-${options.agent}`], { encoding: "utf8" });
+        if (validated.error || validated.status !== 0)
+            throw new Error(`Could not validate Ouro's native entry: ${validated.error?.message ?? validated.stderr}`);
+        return app;
+    }
+    catch (error) {
+        await app.close();
+        throw error;
+    }
+}
+async function runShepherdAttention(options) {
+    const app = await startShepherdAttention(options);
+    try {
+        const opened = (0, node_child_process_1.spawnSync)("cmux", ["browser", "open", app.url + (options.session ? `&session=${options.session}` : ""), "--focus", "false"], { encoding: "utf8" });
+        if (opened.error || opened.status !== 0)
+            throw new Error(`Could not open Ouro attention in cmux: ${opened.error?.message ?? opened.stderr}`);
+        await new Promise(resolve => {
+            const stop = () => {
+                process.removeListener("SIGINT", stop);
+                process.removeListener("SIGTERM", stop);
+                resolve();
+            };
+            process.once("SIGINT", stop);
+            process.once("SIGTERM", stop);
+        });
+    }
+    finally {
+        await app.close();
+    }
+}

package/dist/senses/shepherd/cmux.js

@@ -142,6 +142,8 @@ function createCmuxHost(client, options = {}) {
             cwd: hooked.get(str(surface.id) ?? "")?.cwd ?? null,
             // The human's terminal: the focused surface of the selected workspace in a visible window.
             focused: surface.focused === true && workspace.selected === true && window.visible !== false,
+            ...(surface.focused === true && workspace.selected === true && window.visible !== false && window.key === true
+                ? { selected: true } : {}),
         })));
         const identities = await (options.identifyTerminals ?? terminal_process_1.identifyTerminalProcesses)(entries.filter((entry) => entry.type === "terminal" && entry.tty).map((entry) => entry.tty));
         return entries.map((entry) => {

package/dist/senses/shepherd/composer.js

@@ -77,6 +77,7 @@ class ShepherdComposer {
     unsubscribe;
     unsubscribeClose;
     notice;
+    answer;
     constructor(options) {
         this.client = options.client;
         this.agent = options.agent;
@@ -85,6 +86,7 @@ class ShepherdComposer {
         this.target = Object.freeze({ ...options.target });
         this.sessionKey = `shepherd:${this.target.id}`;
         this.notice = options.notice ?? (() => { });
+        this.answer = options.answer ?? (() => { });
         this.unsubscribe = this.client.onEvent(frame => {
             if (frame.event === "replay_required") {
                 const turn = this.active;
@@ -103,14 +105,17 @@ class ShepherdComposer {
                 this.fail(error, true); });
         });
     }
-    async submit(input) {
+    get busy() { return this.active !== null; }
+    async submit(input, requestId) {
         if (this.active)
             throw new Error("Ouro already has an active turn; use /cancel");
+        if (requestId !== undefined && !surface_1.SHEPHERD_UUID.test(requestId))
+            throw new Error("Ouro request id must be a UUID");
         const message = input.replace(/^@ouro(?:\s+|$)/i, "");
         if (!message.trim())
             throw new Error("message must not be empty");
         const completion = Promise.withResolvers();
-        const turn = { id: (0, node_crypto_1.randomUUID)(), events: [], seen: new Set(), recovering: 0, reconciliationPending: false, dispatched: false, cancelled: false,
+        const turn = { id: requestId ?? (0, node_crypto_1.randomUUID)(), events: [], seen: new Set(), recovering: 0, reconciliationPending: false, dispatched: false, cancelled: false,
             unresolved: false, resolve: completion.resolve, reject: completion.reject };
         this.active = turn;
         // Attach a rejection handler before transport work to avoid unhandled rejection races.
@@ -128,6 +133,11 @@ class ShepherdComposer {
             (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_composer_turn_submitted", message: "submitted an independent fixed-target Ouro turn", meta: { agent: this.agent, session: this.target.id, turnId } });
         }
         catch (sendError) {
+            if (sendError instanceof frontend_socket_client_1.FrontendRequestError && sendError.code === "turn_rejected") {
+                if (this.active === turn)
+                    this.fail(sendError);
+                return completion.promise;
+            }
             // Unknown acknowledgement is never retried. Even a rejected send may have run.
             if (this.active === turn) {
                 try {
@@ -230,6 +240,7 @@ class ShepherdComposer {
             }
             else {
                 const answer = deliveries.length ? deliveries.join("\n") : String(data.result?.response ?? "");
+                this.answer(answer);
                 if (turn.unresolved)
                     this.notice(`Ouro: ${answer}`);
                 turn.resolve(answer);

package/dist/senses/shepherd/surface.js

@@ -99,6 +99,10 @@ async function listShepherdTargets(host, composerTty) {
         host: "cmux",
         label: [session.agent, session.cwd, session.workspaceTitle, session.title]
             .filter(Boolean).map(part => part.replace(/[\x00-\x1f\x7f-\x9f]/g, "").slice(0, 160)).join(" / "),
+        displayLabel: [session.title, session.workspaceTitle, `${session.agent} session`, "Coding session"]
+            .map(part => (part ?? "").replace(/[\x00-\x1f\x7f-\x9f]/g, "").trim())
+            .find(part => part && !/[\\/]/.test(part) && !/[0-9a-f]{8}-[0-9a-f-]{27,}/i.test(part)).slice(0, 72),
+        selected: session.selected === true,
     }));
 }
 async function validateShepherdTarget(host, id) {

package/dist/senses/shepherd-entry.js

@@ -57,9 +57,29 @@ Promise.resolve().then(() => __importStar(require("../heart/runtime-credentials"
     }
     const { startShepherdSenseApp } = await Promise.resolve().then(() => __importStar(require("./shepherd/sense")));
     const app = await startShepherdSenseApp({ agentName: agentName });
+    let attention;
+    if (process.platform === "darwin") {
+        const { resolveShepherdConnection } = await Promise.resolve().then(() => __importStar(require("../heart/shepherd-config")));
+        const machine = readMachineRuntimeCredentialConfig(agentName);
+        const connection = machine.ok ? resolveShepherdConnection(agentName, machine.config) : null;
+        if (connection?.ok && connection.connection.host === "cmux") {
+            const { startManagedShepherdAttention } = await Promise.resolve().then(() => __importStar(require("./shepherd/attention")));
+            const { DEFAULT_DAEMON_SOCKET_PATH } = await Promise.resolve().then(() => __importStar(require("../heart/daemon/socket-client")));
+            const { frontendSocketPathForDaemon } = await Promise.resolve().then(() => __importStar(require("../heart/frontend-socket")));
+            try {
+                attention = await startManagedShepherdAttention({ agent: agentName, socketPath: frontendSocketPathForDaemon(DEFAULT_DAEMON_SOCKET_PATH) });
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_attention_unavailable", message: "native session attention is unavailable; Shepherd supervision remains running", meta: { agentName, error: String(error) } });
+            }
+        }
+    }
     const shutdown = () => {
         app.stop();
-        process.exit(0);
+        void (attention?.close() ?? Promise.resolve()).then(() => process.exit(0), error => {
+            (0, runtime_1.emitNervesEvent)({ level: "error", component: "senses", event: "senses.shepherd_attention_shutdown_error", message: "could not close native session attention", meta: { error: String(error) } });
+            process.exit(1);
+        });
     };
     process.once("SIGTERM", shutdown);
     process.once("SIGINT", shutdown);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.925",
+  "version": "0.1.0-alpha.926",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.925",
+      "version": "0.1.0-alpha.926",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.925",
+  "version": "0.1.0-alpha.926",
   "engines": {
     "node": ">=22"
   },