@ouro.bot/cli 0.1.0-alpha.95 → 0.1.0-alpha.951

package/dist/senses/shepherd/agent-presentation.js

@@ -0,0 +1,88 @@
+"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.validateAgentDisplayName = validateAgentDisplayName;
+exports.agentPresentation = agentPresentation;
+exports.readAgentPresentation = readAgentPresentation;
+exports.agentAddressPattern = agentAddressPattern;
+exports.stripAgentAddress = stripAgentAddress;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+function validateAgentDisplayName(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !value.length || value.length > 80 || value.trim() !== value ||
+        /[<>\[\]\\\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(value)) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.agent_display_name_invalid",
+            message: "configured agent displayName is invalid", meta: { field: "displayName" } });
+        throw new Error("agent.json displayName must be 1–80 characters without markup, controls or surrounding whitespace");
+    }
+    return value;
+}
+function agentPresentation(agent, config) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(agent) || agent.includes("..")) {
+        throw new Error("agent presentation requires a safe configured identifier");
+    }
+    const name = validateAgentDisplayName(config.displayName) ?? agent;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.agent_presentation_resolved",
+        message: "resolved explicit agent presentation", meta: { configured: config.displayName !== undefined } });
+    return { name, aliases: [...new Set([name, agent])] };
+}
+function readAgentPresentation(agent, root) {
+    let encoded;
+    try {
+        encoded = fs.readFileSync(path.join(root, "agent.json"), "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.agent_presentation_missing",
+            message: "agent presentation config is missing; using its routing identifier", meta: { configured: false } });
+        return agentPresentation(agent, {});
+    }
+    const config = JSON.parse(encoded);
+    if (!config || typeof config !== "object" || Array.isArray(config))
+        throw new Error("agent.json presentation must be an object");
+    return agentPresentation(agent, { displayName: validateAgentDisplayName(config.displayName) });
+}
+function agentAddressPattern(aliases) {
+    if (!aliases.length)
+        return "(?!)";
+    return `^@(?:${aliases.map(alias => alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})(?:\\s+|$)`;
+}
+function stripAgentAddress(message, aliases) {
+    return message.replace(new RegExp(agentAddressPattern(aliases), "iu"), "");
+}

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ATTENTION_BODY_BYTES = void 0;
+exports.attentionPage = attentionPage;
+const agent_presentation_1 = require("./agent-presentation");
+exports.MAX_ATTENTION_BODY_BYTES = 16_384;
+/** No model content or target metadata is interpolated into executable HTML. */
+function attentionPage(nonce, presentation = (0, agent_presentation_1.agentPresentation)("Agent", {})) {
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_attention_page_rendered", message: "rendered the independent session attention view" });
+    const name = presentation.name.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${name}</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>${name}</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 ${name} 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 ${name}" placeholder="Message ${name}..." 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 ${name}</button><button id="send" type="submit" disabled>Send</button></div></footer></form>
+</main><script nonce="${nonce}">
+const agentName=${JSON.stringify(presentation.name).replaceAll("<", "\\u003c")},address=new RegExp(${JSON.stringify((0, agent_presentation_1.agentAddressPattern)(presentation.aliases))},'iu');
+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||agentName+' 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 "+agentName+" 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?agentName+' 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(address,'').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,76 @@
+"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 agent_presentation_1 = require("./agent-presentation");
+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, name = "Agent") {
+    (0, agent_presentation_1.validateAgentDisplayName)(name);
+    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(${JSON.stringify(name)}).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(${JSON.stringify(`Talk to ${name}`)})
+        }
+    }
+}.padding(16)
+`;
+}
+function installAttentionSidebar(directory, url, agent = "ouro", displayName = agent) {
+    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, displayName), { mode: 0o600 });
+    fs.chmodSync(staging, 0o600);
+    fs.renameSync(staging, file);
+    return file;
+}

package/dist/senses/shepherd/attention.js

@@ -0,0 +1,295 @@
+"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");
+const identity_1 = require("../../heart/identity");
+const agent_presentation_1 = require("./agent-presentation");
+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 presentation = options.displayName === undefined
+        ? (0, agent_presentation_1.readAgentPresentation)(options.agent, (0, identity_1.getAgentRoot)(options.agent))
+        : (0, agent_presentation_1.agentPresentation)(options.agent, { displayName: options.displayName });
+    const name = presentation.name;
+    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, displayName: name, 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, presentation));
+            }
+            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 ${name} 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: `${name} 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" || !(0, agent_presentation_1.stripAgentAddress)(fields.message, presentation.aliases).trim())
+                    return json(400, { error: `Enter a message for ${name}.` });
+                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: `${name} 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 presentation = (0, agent_presentation_1.readAgentPresentation)(options.agent, (0, identity_1.getAgentRoot)(options.agent));
+    const app = await startShepherdAttention({ ...options, displayName: presentation.name });
+    try {
+        (0, attention_sidebar_1.installAttentionSidebar)(path.join(os.homedir(), ".config/cmux/sidebars"), app.url, options.agent, presentation.name);
+        const { socketPath, auth } = options.cmuxConnection;
+        const validated = (0, node_child_process_1.spawnSync)("cmux", ["--socket", socketPath, "sidebar", "validate", `ouro-attention-${options.agent}`], {
+            encoding: "utf8",
+            env: {
+                ...process.env,
+                CMUX_SOCKET_CAPABILITY: auth.kind === "capability" ? auth.token : undefined,
+                CMUX_SOCKET_PASSWORD: auth.kind === "password" ? auth.password : undefined,
+            },
+        });
+        if (validated.error || validated.status !== 0)
+            throw new Error(`Could not validate ${presentation.name}'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 session 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();
+    }
+}