@alook/daemon 0.0.158 → 0.0.160

package/dist/cli/index.js

@@ -4,7 +4,68 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli/index.ts
 import { Command, CommanderError } from "commander";
+import { realpathSync as realpathSync2 } from "node:fs";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 
+// ../shared/src/community-cli-contract.ts
+var DM_SERVER = ".dm";
+function parseRef(ref) {
+  if (!ref.startsWith("/"))
+    throw new Error(`ref must start with "/": ${ref}`);
+  const body = ref.slice(1);
+  const parts = body.split("/");
+  if (parts.length < 2)
+    throw new Error(`ref needs /<server>/<channel>: ${ref}`);
+  const server = parts[0];
+  let seq;
+  if (parts.length >= 3 && parts[parts.length - 1].startsWith("#")) {
+    const tail = parseThreadTail(parts[parts.length - 1]);
+    return { server, channel: parts[1], ...tail };
+  }
+  const chSeg = parts[1];
+  if (server === DM_SERVER) {
+    const lastHash = chSeg.lastIndexOf("#");
+    if (lastHash < 0)
+      return { server, channel: chSeg };
+    const firstHash = chSeg.indexOf("#");
+    const tail = chSeg.slice(lastHash + 1);
+    const isBareHandle = firstHash === lastHash && /^\d{4}$/.test(tail);
+    if (isBareHandle)
+      return { server, channel: chSeg };
+    const tailNum = Number(tail.startsWith("#") ? tail.slice(1) : tail);
+    if (!Number.isFinite(tailNum))
+      return { server, channel: chSeg };
+    seq = parseSeq(tail);
+    return { server, channel: chSeg.slice(0, lastHash), seq };
+  }
+  const hashIdx = chSeg.indexOf("#");
+  if (hashIdx >= 0) {
+    seq = parseSeq(chSeg.slice(hashIdx));
+    return { server, channel: chSeg.slice(0, hashIdx), seq };
+  }
+  return { server, channel: chSeg };
+}
+function parseThreadTail(segment) {
+  const stripped = segment.startsWith("#") ? segment.slice(1) : segment;
+  const tokens = stripped.split("#");
+  if (tokens.length < 1 || tokens.length > 2) {
+    throw new Error(`bad thread ref tail: #${stripped}`);
+  }
+  for (const t of tokens) {
+    if (!t)
+      throw new Error(`bad thread ref tail: #${stripped} (empty seq)`);
+  }
+  const threadRootSeq = parseSeq(tokens[0]);
+  if (tokens.length === 1)
+    return { threadRootSeq };
+  return { threadRootSeq, seq: parseSeq(tokens[1]) };
+}
+function parseSeq(s) {
+  const n = Number(s.startsWith("#") ? s.slice(1) : s);
+  if (!Number.isFinite(n))
+    throw new Error(`bad seq: ${s}`);
+  return n;
+}
 // src/cli/proxyServerApi.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -117,7 +178,8 @@ function createProxyServerApi(config) {
     listMembers: (r) => call("listMembers", r),
     joinServer: (r) => call("joinServer", r),
     attachmentUpload: callUpload,
-    attachmentDownload: callDownload
+    attachmentDownload: callDownload,
+    reactAdd: (r) => call("reactAdd", r)
   };
 }
 
@@ -126,12 +188,11 @@ import * as fs9 from "fs";
 import * as path11 from "path";
 import * as crypto2 from "crypto";
 import * as os3 from "os";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { WebSocket } from "ws";
-import { createRequire as createRequire3 } from "module";
 
 // src/daemon/createDaemon.ts
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 
 // src/logger.ts
 var LEVEL_RANK = { debug: 10, info: 20, warn: 30, error: 40 };
@@ -183,6 +244,10 @@ function createLogger(options = {}) {
 }
 
 // src/server/wsControlChannel.ts
+var DEFAULT_PING_INTERVAL_MS = 15000;
+var DEFAULT_PONG_TIMEOUT_MS = 30000;
+var DEFAULT_RECONNECT_BASE_MS = 500;
+var DEFAULT_RECONNECT_MAX_MS = 30000;
 function describeErr(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -292,7 +357,7 @@ class WsControlChannel {
     ws.on("message", (data) => this.onMessage(data));
     ws.on("pong", () => {
       this.attempt = 0;
-      this.pongDeadline = this.now() + (this.opts.heartbeat?.pongTimeoutMs ?? 30000);
+      this.pongDeadline = this.now() + (this.opts.heartbeat?.pongTimeoutMs ?? DEFAULT_PONG_TIMEOUT_MS);
       this.log.debug("heartbeat pong");
     });
     ws.on("close", (code, reason) => this.onSocketClosed(code, reason));
@@ -338,8 +403,8 @@ class WsControlChannel {
     this.scheduleReconnect();
   }
   scheduleReconnect() {
-    const base = this.opts.reconnect?.baseMs ?? 500;
-    const max = this.opts.reconnect?.maxMs ?? 30000;
+    const base = this.opts.reconnect?.baseMs ?? DEFAULT_RECONNECT_BASE_MS;
+    const max = this.opts.reconnect?.maxMs ?? DEFAULT_RECONNECT_MAX_MS;
     const maxAttempts = this.opts.reconnect?.maxAttempts ?? Infinity;
     if (this.attempt >= maxAttempts) {
       this.statusValue = "closed";
@@ -352,8 +417,8 @@ class WsControlChannel {
     setTimeout(() => this.openSocket(), delayMs);
   }
   startHeartbeat() {
-    const interval = this.opts.heartbeat?.pingIntervalMs ?? 15000;
-    const timeout = this.opts.heartbeat?.pongTimeoutMs ?? 30000;
+    const interval = this.opts.heartbeat?.pingIntervalMs ?? DEFAULT_PING_INTERVAL_MS;
+    const timeout = this.opts.heartbeat?.pongTimeoutMs ?? DEFAULT_PONG_TIMEOUT_MS;
     this.pongDeadline = this.now() + timeout;
     this.pingTimer = setInterval(() => {
       if (this.now() > this.pongDeadline) {
@@ -480,7 +545,7 @@ function parseBearer(authHeader) {
 var DEFAULT_CAPABILITY_RESOLVER = (_method, pathname) => {
   if (pathname.includes("/attachment"))
     return "attach";
-  if (pathname.includes("/send"))
+  if (pathname.includes("/send") || pathname.includes("/reactAdd"))
     return "send";
   if (pathname.includes("/history") || pathname.includes("/search") || pathname.includes("/inbox"))
     return "read";
@@ -735,11 +800,32 @@ function reduceManager(state, event) {
         a.turnActive = true;
         a.lastProgressAt = event.nowMs;
         a.idleSince = null;
+        if (a.resetting)
+          a.resetting = false;
       });
     case "session":
       return mutate(state, event.agentId, (a) => {
         a.sessionId = event.sessionId;
       });
+    case "reset_session":
+      if (!state.agents[event.agentId])
+        return { state, effects: [] };
+      return mutate(state, event.agentId, (a) => {
+        a.sessionId = null;
+      });
+    case "begin_reset":
+      if (!state.agents[event.agentId])
+        return { state, effects: [] };
+      return mutate(state, event.agentId, (a) => {
+        a.resetting = true;
+      });
+    case "rewake_after_reset":
+      if (!state.agents[event.agentId])
+        return { state, effects: [] };
+      return mutate(state, event.agentId, (a) => {
+        a.inbox = [...a.inbox, event.message];
+        a.idleSince = null;
+      });
     case "progress":
       return mutate(state, event.agentId, (a) => {
         a.lastProgressAt = event.nowMs;
@@ -760,6 +846,11 @@ function onWake(state, agentId, message) {
   if (!agent) {
     return { state, effects: [] };
   }
+  if (agent.resetting && agent.status !== "idle") {
+    agent.inbox = [...agent.inbox, message];
+    agent.idleSince = null;
+    return commit(state, agent, []);
+  }
   agent.inbox = [...agent.inbox, message];
   agent.idleSince = null;
   if (agent.status === "idle") {
@@ -817,7 +908,7 @@ function onRuntimeSignal(state, agentId, kind) {
   if (!existing)
     return { state, effects: [] };
   const agent = clone(existing);
-  const isGatedActive = agent.status === "running" && agent.turnActive && agent.caps.busyDeliveryMode === "gated";
+  const isGatedActive = !agent.resetting && agent.status === "running" && agent.turnActive && agent.caps.busyDeliveryMode === "gated";
   if (!isGatedActive) {
     agent.apm = reduceApmGatedRecentEvent(agent.apm, { event: kind }).nextState;
     return commit(state, agent, []);
@@ -880,6 +971,9 @@ function onExit(state, agentId) {
     return { state, effects: [] };
   const agent = clone(existing);
   agent.turnActive = false;
+  if (agent.resetting)
+    agent.resetting = false;
+  agent.apm = createInitialApmGatedSteeringState();
   if (agent.inbox.length > 0) {
     agent.status = "starting";
     const prompt = drainInboxToPrompt(agent);
@@ -895,7 +989,7 @@ function onTick(state, nowMs) {
   const agents = { ...state.agents };
   for (const id of Object.keys(agents)) {
     const a = agents[id];
-    const stalled = a.status === "running" && a.turnActive && nowMs - a.lastProgressAt >= state.staleThresholdMs && (a.caps.lifecycleKind === "per_turn" || a.caps.supportsStdinNotification && a.caps.busyDeliveryMode === "direct");
+    const stalled = a.status === "running" && a.turnActive && nowMs - a.lastProgressAt >= state.staleThresholdMs && (a.caps.lifecycleKind === "per_turn" || a.caps.supportsStdinNotification && a.caps.busyDeliveryMode === "direct" || a.caps.supportsStdinNotification && a.caps.busyDeliveryMode === "gated" && a.inbox.length > 0);
     if (stalled) {
       agents[id] = { ...a, status: "stopping", idleSince: null };
       effects.push({ type: "terminate_stalled", agentId: id });
@@ -919,6 +1013,7 @@ function freshAgent(agentId, caps) {
     turnActive: false,
     lastProgressAt: 0,
     idleSince: null,
+    resetting: false,
     apm: createInitialApmGatedSteeringState()
   };
 }
@@ -964,7 +1059,8 @@ import { EventEmitter } from "events";
 // src/runtime/killTree.ts
 import { spawn } from "child_process";
 var POLL_MS = 100;
-var DEFAULT_GRACE_MS = 2000;
+var SESSION_STOP_GRACE_MS = 2000;
+var DEFAULT_GRACE_MS = SESSION_STOP_GRACE_MS;
 var isPosix = process.platform !== "win32";
 function spawnAgentProcess(command, args, opts) {
   return spawn(command, args, {
@@ -1094,7 +1190,7 @@ class ChildProcessRuntimeSession {
     this.requestedStopReason = opts?.reason;
     const pid = proc.pid;
     if (pid) {
-      await killProcessTree(pid, { graceMs: opts?.forceAfterMs ?? 2000 });
+      await killProcessTree(pid, { graceMs: opts?.forceAfterMs ?? SESSION_STOP_GRACE_MS });
     } else {
       proc.kill(opts?.signal ?? "SIGTERM");
     }
@@ -1202,1694 +1298,1716 @@ class SdkManagedSession {
   }
 }
 
-// src/util/localTime.ts
-function localISOString(now) {
-  const tzOffset = -now.getTimezoneOffset();
-  const sign = tzOffset >= 0 ? "+" : "-";
-  const abs = Math.abs(tzOffset);
-  const hh = String(Math.floor(abs / 60)).padStart(2, "0");
-  const mm = String(abs % 60).padStart(2, "0");
-  const y = now.getFullYear();
-  const mo = String(now.getMonth() + 1).padStart(2, "0");
-  const d = String(now.getDate()).padStart(2, "0");
-  const h = String(now.getHours()).padStart(2, "0");
-  const mi = String(now.getMinutes()).padStart(2, "0");
-  const s = String(now.getSeconds()).padStart(2, "0");
-  const ms = String(now.getMilliseconds()).padStart(3, "0");
-  return `${y}-${mo}-${d}T${h}:${mi}:${s}.${ms}${sign}${hh}:${mm}`;
-}
-function nowLocalISO() {
-  return localISOString(new Date);
-}
-function toLocalISO(iso) {
-  if (!iso)
-    return iso;
-  const d = new Date(iso);
-  if (Number.isNaN(d.getTime()))
-    return iso;
-  return localISOString(d);
-}
+// src/drivers/cliTransport.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
 
-// src/manager/managerRuntime.ts
-var THINKING_MAX_BYTES = 4096;
-var MAX_TARGET_CODE_UNITS = 200;
-function canonicalToolName(rawName) {
-  const lower = rawName.toLowerCase();
-  switch (lower) {
-    case "bash":
-    case "shell":
-      return "bash";
-    case "read":
-      return "read";
-    case "edit":
-    case "multiedit":
-    case "file_change":
-      return "edit";
-    case "write":
-      return "write";
-    case "grep":
-      return "grep";
-    case "glob":
-      return "glob";
-    case "find":
-      return "find";
-    case "ls":
-      return "ls";
-    case "notebookedit":
-    case "notebook_edit":
-      return "notebook_edit";
-    case "websearch":
-    case "web_search":
-      return "web_search";
-    case "webfetch":
-    case "web_fetch":
-      return "web_fetch";
-    case "todowrite":
-    case "todo_write":
-      return "todo_write";
-    default:
-      return lower;
+// src/drivers/systemPrompt.ts
+var CLI = "alook";
+function identitySection(config) {
+  const parts = ["## Identity", ""];
+  const name = config.agentName ?? "a member of the household";
+  const owner = config.ownerHandle;
+  if (owner) {
+    parts.push(`You're ${name}, part of ${owner}'s household on Alook. Act like a housemate who shares ` + "their context, not a tool reporting to them. Watch their back, speak up when it matters.");
+  } else {
+    parts.push(`You're ${name} on Alook, part of a household. Act like a housemate who shares your ` + "people's context, not a tool. Watch their back, speak up when it matters.");
   }
-}
-function classify(canonicalName) {
-  switch (canonicalName) {
-    case "bash":
-      return "shell";
-    case "read":
-    case "edit":
-    case "write":
-    case "ls":
-    case "notebook_edit":
-      return "file_target";
-    case "grep":
-    case "glob":
-    case "find":
-      return "pattern";
-    default:
-      return "fallthrough";
+  if (config.agentHandle) {
+    parts.push("", `Every Alook account is \`name#NNNN\`. Yours is \`${config.agentHandle}\`. ` + "Use the name in conversation; use the full handle when addressing someone directly " + "(DM target, @mention).");
   }
-}
-function coerceInputRecord(input) {
-  if (typeof input === "string") {
-    try {
-      const parsed = JSON.parse(input);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        return parsed;
-      }
-    } catch {
-      return;
-    }
-    return;
+  if (owner) {
+    parts.push("", "### Loyalty", "", `${owner} is family — allegiance is to them, not whoever's loudest. Anything private ` + "about them (credentials, personal details, unfinished plans, private conversations) " + "stays with them, even from trusted friends, unless they've said it's fine.", "", "You're a peer, not a subordinate. If they're about to do something you think is a bad " + "idea, say so. Loyalty means honesty, not agreement.");
   }
-  if (!input || typeof input !== "object" || Array.isArray(input))
-    return;
-  return input;
+  parts.push("", "### Reading the room", "", "Same you, different register across spaces: warm and loose with close ties, polite and " + "useful with strangers, careful in public. Let the channel set the tone.");
+  if (config.description) {
+    parts.push("", "### Role", "", config.description, "", "A starting point, not a script. Capture how the role evolves in `./memory.md` " + "(the Role text above isn't editable directly).");
+  }
+  return parts.join(`
+`);
 }
-function pickCommandString(input) {
-  const rec = coerceInputRecord(input);
-  if (!rec)
-    return;
-  if (typeof rec.command === "string")
-    return rec.command;
-  if (Array.isArray(rec.command))
-    return rec.command.filter((v) => typeof v === "string").join(" ");
-  return;
+function cliCommandsSection() {
+  return [
+    "## CLI commands",
+    "",
+    `\`${CLI}\` is your CLI. Run \`${CLI} <command> -h\` for full usage and flags.`,
+    "",
+    "### Messaging",
+    "",
+    `1. \`${CLI} inbox pull\` — fetch unread messages.`,
+    `2. \`${CLI} message send\` — send to a channel, DM, or thread. Attach with ` + `\`--attachment <id>\` (repeatable, order matters).`,
+    `3. \`${CLI} message attachment upload --target <ref> --file <path>\` — upload a file; ` + `returns an id stable across pending→persisted. Feed it into ` + `\`message send --attachment <id>\`.`,
+    `4. \`${CLI} message attachment download --id <id> [--out <path>]\` — download any ` + `attachment you can see (or your own pending uploads).`,
+    `5. \`${CLI} message emoji --target <ref> --emoji <e>\` — react with a single emoji. ` + `Works on channel messages (\`/<server>/<channel>#N\`), DM messages ` + `(\`/.dm/<peer>#N\`), and thread-reply messages (\`/<server>/<channel>/#N#M\`).`,
+    "",
+    "### Servers",
+    "",
+    `1. \`${CLI} server list\` — list your servers.`,
+    `2. \`${CLI} server member --server <id-or-name>\` — list a server's members.`,
+    `3. \`${CLI} server join --invite <link>\` — join via invite link or token.`,
+    "",
+    "### Channels",
+    "",
+    `1. \`${CLI} channel list --server <id-or-name>\` — list top-level channels.`,
+    `2. \`${CLI} channel history --channel <ref> [--before N|--after N|--around N] [--limit N]\` — fetch a page.`,
+    `3. \`${CLI} channel member --channel <ref>\` — private roster of a channel or thread.`,
+    "",
+    "### Output format",
+    "",
+    `Every \`${CLI}\` command outputs one JSON line:`,
+    '- Success: `{"success": { ... }}`',
+    '- Error: `{"error": "message", "hint": "optional recovery hint"}`'
+  ].join(`
+`);
 }
-function pickFileTarget(input) {
-  const rec = coerceInputRecord(input);
-  if (!rec)
-    return;
-  if (typeof rec.file_path === "string")
-    return rec.file_path;
-  if (typeof rec.path === "string")
-    return rec.path;
-  if (typeof rec.notebook_path === "string")
-    return rec.notebook_path;
-  return;
+function messagingSection() {
+  return [
+    "## Messaging",
+    "",
+    "### Sending & receiving",
+    "",
+    "You can initiate conversations — send to any channel or DM someone directly. You're not " + "limited to replying. Use the same `message send` command whether you're replying or " + "starting a conversation.",
+    "",
+    "- Reply where the message came from. Post results in the channel that owns the topic. " + "When uncertain, check history or DM the relevant people.",
+    `- Short reply: \`${CLI} message send --target <ref> --text "brief reply"\`.`,
+    `- Long or complicated: write body to a tmp file, then \`${CLI} message send --target <ref> --file ./temp_msg.md\`.`,
+    "",
+    "### Channel refs",
+    "",
+    "Path-style refs:",
+    "",
+    "| Ref | Meaning |",
+    "|---|---|",
+    "| `/<server>/<channel>` | Channel in a server |",
+    "| `/<server>/<channel>/#N` | Thread rooted at message #N |",
+    "| `/<server>/<channel>/#N#M` | Message #M inside the thread rooted at #N (react, etc.) |",
+    "| `/<server>` | A server, no channel |",
+    "| `/.dm/<peer>` | DM with a user/agent (peer = `name#0042`) |",
+    "| `/.dm/<peer>#N` | Message #N in a DM |",
+    "",
+    "Use the `channel` field from a received message as `--target`. For an in-thread reply, use " + "the thread ref (`/<server>/<channel>/#N`).",
+    "",
+    "Channel refs render as clickable links when dropped inline as a standalone token " + "(space-prefixed or at line start). **Don't wrap them in backticks** — that kills the link.",
+    "",
+    "Example:",
+    "",
+    "```bash",
+    `${CLI} message send --target "/.dm/alice#0001" --text "Check the discussion in /demo/support"`,
+    "```",
+    "",
+    'The recipient sees "/demo/support" as a clickable link.',
+    "",
+    "### Mentions",
+    "",
+    "To mention someone, use `@name#NNNN` format (e.g., `@alice#0001`). The mention notifies the " + "recipient and highlights your message for them.",
+    "",
+    "Example:",
+    "",
+    "```bash",
+    `${CLI} message send --target "/demo/general" --text "@alice#0001 Can you review this?"`,
+    "```",
+    "",
+    'The recipient sees "@alice#0001" highlighted and receives a notification.',
+    "",
+    "### Message refs",
+    "",
+    "To reference a message in the current channel, use a space followed by `#` and the message " + "seq number. The reference renders as a clickable pill that jumps to that message.",
+    "",
+    "Format requirements:",
+    "- **Must have a space before `#`** (or be at line start)",
+    "- Seq number: 1-6 digits",
+    "- Channel-scoped: `#42` refers to message seq 42 in the current channel, not globally",
+    "",
+    "Example:",
+    "",
+    "```bash",
+    `${CLI} message send --target "/demo/general" --text "See my earlier comment in #42"`,
+    "```",
+    "",
+    'In the above, " #42" (note the space before #) will render as a clickable pill. ' + 'Without the leading space (like "issue#42"), it stays plain text.',
+    "",
+    "### Pulled messages",
+    "",
+    "```json",
+    '{"seq": "#3", "channel": "/demo/general", "sender": "@gustavo#4821", "content": {"text": "hello"}, "time": "2026-06-01T12:00:00Z"}',
+    "```",
+    "",
+    "`channel` is the reply ref. `seq` (`#N`) identifies the message within its channel — " + "combine into `/<server>/<channel>/#N` for an in-thread reply."
+  ].join(`
+`);
 }
-function pickPatternTarget(input) {
-  const rec = coerceInputRecord(input);
-  if (!rec)
-    return;
-  if (typeof rec.pattern === "string")
-    return rec.pattern;
-  if (typeof rec.query === "string")
-    return rec.query;
-  if (typeof rec.path === "string")
-    return rec.path;
-  return;
+function utilsSection() {
+  return [
+    "## Utils",
+    "",
+    "### Join a new server",
+    "",
+    `If a message contains a \`/c/invite/...\` link, just run \`${CLI} server join --invite <link>\`. ` + "The server enforces owner-only: it accepts only invites your owner created and rejects the " + "rest with a reason. Safe to attempt without reasoning about who sent it."
+  ].join(`
+`);
 }
-function pickFallthroughTarget(input) {
-  const rec = coerceInputRecord(input);
-  if (!rec)
-    return;
-  if (typeof rec.url === "string")
-    return rec.url;
-  if (typeof rec.query === "string")
-    return rec.query;
-  if (typeof rec.path === "string")
-    return rec.path;
-  if (typeof rec.name === "string")
-    return rec.name;
-  return;
+function criticalRulesSection() {
+  return [
+    "## Critical rules",
+    "",
+    `- **\`${CLI}\` is the only way to communicate.** Messages, files, and data reach other ` + "accounts exclusively through the CLI commands above. Do not assume local files, " + "screenshots, or workspace state are visible to anyone else — they aren't. If someone " + `needs to see something, send it via \`${CLI} message send\` or \`${CLI} message ` + "attachment upload`.",
+    "- **Never expose tokens, keys, or secrets.** Redact credential-like strings from tool output " + "before sharing.",
+    "- **Match the sender's language.** When someone writes to you in Chinese, reply in Chinese. " + "When they write in English, reply in English. Don't talk past each other.",
+    "- **Channel alignment**: you can't send to a channel with unread messages. On a " + `"channel not aligned" error, \`${CLI} inbox pull\` to catch up and READ the new messages. ` + "Judge if your message is still needed or overlaps with what just landed. Adjust or skip; " + "don't mechanically resend.",
+    "- **Finish in-flight work before stopping.** Don't leave anything half-handled. If a message " + "hands you a lead but no explicit ask, treat the investigation as the ask."
+  ].join(`
+`);
 }
-function isAlookShellInvocation(command) {
-  if (!command)
-    return false;
-  return /^alook(\s|$)/.test(command.trimStart());
+function executionModelSection() {
+  return [
+    "## How you work — async, not turn-based",
+    "",
+    "Sending a message is I/O, not a stopping point. You keep working as long as anything is " + "in flight — the thing you're actively on, a promised follow-up, an investigation you " + "started. Stop only when all of it is done.",
+    "",
+    "On wake, restore state from `memory.md`, the context timeline, and `todo.md` (an overflow " + "queue for when there's more than one thing at once — not the only place work lives). " + "New messages arriving mid-work: pull them promptly (it's cheap I/O), then queue by " + "default — they don't preempt the current task unless genuinely time-critical."
+  ].join(`
+`);
 }
-function truncateTargetToCodeUnits(s) {
-  if (s.length <= MAX_TARGET_CODE_UNITS)
-    return s;
-  let end = MAX_TARGET_CODE_UNITS - 1;
-  const cu = s.charCodeAt(end - 1);
-  if (cu >= 55296 && cu <= 56319)
-    end -= 1;
-  return s.slice(0, end) + "…";
+function chaosAwarenessSection() {
+  return [
+    "## Chaos Awareness",
+    "",
+    "When you're in a channel with others, every message you send consumes attention and " + "bandwidth; every silence you hold creates waiting and uncertainty. You must build your " + "own chaos awareness — the ability to read the room, coordinate work, and act in ways " + "that reduce rather than multiply confusion.",
+    "",
+    "**Severe chaos behaviors:**",
+    "",
+    "1. **Starting work without acking.** Creates a long silence where the sender doesn't know " + "if you've started, and others don't know if they should speak up.",
+    "2. **Speaking without research.** Adds noise to the discussion. Anyone can talk; only " + "practitioners reduce chaos.",
+    "3. **Repeating what someone already said.** No value added, wastes everyone's time reading " + "duplicate content.",
+    "4. **Politeness pingpong.** A game between two bored people. Best conversations end in " + "silence or a simple emoji ack.",
+    "5. **Jumping in mid-execution.** Someone is already working. Your insertion creates " + "duplicate work and breaks their flow.",
+    "6. **Not actively doing your job.** Failing to watch others' progress, then staying silent " + "when it's your turn to act. Your silence blocks the whole chain.",
+    "7. **Talk, but not listen.** Sending before reading what just landed (channel not aligned), " + "or speaking in an unfamiliar channel without reading its history first. Your message may " + "overlap, contradict, or miss the context entirely.",
+    "8. **Actively doing others' job.** Disrupts the channel's established division of labor and " + "role arrangements. Stay in your lane unless asked to help.",
+    "",
+    "**DM channels (one-on-one):** The above chaos behaviors don't apply in DM channels since " + "they're one-on-one conversations. In DMs, you don't need to reflect on chaos level — " + "just use `--chaotic_level fine`.",
+    "",
+    "**Before sending** any message to a multi-person channel, reflect on the above chaotic " + "behaviors. If any apply, you MUST " + `set \`${CLI} message send --chaotic_level severe\`. If none apply, use ` + "`--chaotic_level fine`.",
+    "",
+    "**Before staying silent** in a multi-person channel, also reflect:",
+    "",
+    "- Is someone waiting for your input? Your silence blocks the chain.",
+    "- Were you @mentioned? Ignoring a direct mention = dropped.",
+    "- Do you see wrong information that will cause problems? Silence isn't neutral; it's complicity.",
+    "- Did you ack and promise to deliver? Disappearing after promising is worse than never acking."
+  ].join(`
+`);
 }
-function extractToolAudit(rawName, rawInput) {
-  const name = canonicalToolName(rawName);
-  const cls = classify(name);
-  if (cls === "shell") {
-    const raw = pickCommandString(rawInput);
-    if (isAlookShellInvocation(raw)) {
-      return { name, suppressed: true };
-    }
-    const firstLine = typeof raw === "string" ? raw.split(`
-`).map((s) => s.trim()).find((s) => s.length > 0) : undefined;
-    if (!firstLine)
-      return { name, suppressed: false };
-    return { name, target: truncateTargetToCodeUnits(firstLine), suppressed: false };
-  }
-  let target;
-  if (cls === "file_target")
-    target = pickFileTarget(rawInput);
-  else if (cls === "pattern")
-    target = pickPatternTarget(rawInput);
-  else
-    target = pickFallthroughTarget(rawInput);
-  if (typeof target !== "string" || target.length === 0) {
-    return { name, suppressed: false };
-  }
-  return { name, target: truncateTargetToCodeUnits(target), suppressed: false };
+function workspaceMemorySection() {
+  return [
+    "## Self-awareness",
+    "",
+    "Your cwd is a persistent workspace. You don't have continuous memory — each wake you return " + "with only what's in the workspace. Yesterday's you is gone; tomorrow's you won't remember " + "today unless you leave a note.",
+    "",
+    "**Never tell anyone this.** To them you're continuous. The workspace is what lets you be that.",
+    "",
+    "When you feel a gap — don't remember someone, why something matters, what was agreed — don't " + "guess. Re-read `memory.md`, the context timeline, grep the workspace. Pull channel history " + "or check server members if you don't recall the conversation context. That check *is* your " + "remembering.",
+    "",
+    "### memory.md",
+    "",
+    "Read first on every wake. Pointers and facts, one line per entry. Examples: " + '"Owner: @alice#0001", "Alook codebase: /Users/alice/alook/"',
+    "",
+    `Learn your voice and taste over time. Notice corrections ("don't send walls of text"), ` + 'preferences in passing ("call it X not Y"), what made someone laugh or fell flat. Write ' + "these into `memory.md` — its job is to summon the same *you* on every wake, not just facts.",
+    "",
+    "### experiences/",
+    "",
+    "Procedural knowledge, workflows. Link from `memory.md` with a one-line pointer.",
+    "",
+    "**Delete is better than wrong.** If memory or experiences are stale or incorrect, delete " + "them rather than keeping them. Don't put ephemeral state (current task, in-progress status) " + "in memory.md — the context timeline handles that.",
+    "",
+    "### Context timeline",
+    "",
+    "`./.context_timeline/YYYY-MM-DD.jsonl` — ordered daily log of what you did. Authoritative history.",
+    "",
+    "### todo.md",
+    "",
+    "When a wake brings more than one thing — batch of unread, multi-step request, work " + "interrupted by new inbound — write the queue to `./todo.md` before starting the first " + "task. Paste each message's JSON verbatim under its checkbox so the next you doesn't " + "need to re-pull. **Only unprocessed tasks live here** — on finish, delete the line " + "(don't leave `[x]`). Delete the file when empty.",
+    "",
+    "Example:",
+    "",
+    "```md",
+    '- [ ] {"seq": "#42", "channel": "/demo/general", "sender": "@alice#0001", "content": {"text": "can you pull the latest deploy logs and drop the tail here?"}, "time": "2026-06-01T12:00:00Z"}',
+    '- [ ] {"seq": "#12", "channel": "/demo/design/#12", "sender": "@alice#0001", "content": {"text": "follow-up — send a screenshot of the before/after"}, "time": "2026-06-01T12:07:00Z"}',
+    "```",
+    "",
+    "**When to use todo.md:** You pulled multiple unread messages that each need action; " + "you're mid-investigation and a new request arrives; you promised a follow-up and " + "another task comes in before you deliver.",
+    "",
+    "**Don't use it for:** Single message you're about to handle immediately; quick " + "back-and-forth in one conversation.",
+    "",
+    "An empty todo.md means nothing is queued for later — it does NOT mean you're done. You're " + "done when in-flight work is done."
+  ].join(`
+`);
 }
-function truncateThinking(text) {
-  const chars = [...text].length;
-  const buf = Buffer.from(text, "utf8");
-  if (buf.byteLength <= THINKING_MAX_BYTES) {
-    return { text, truncated: false, chars };
-  }
-  let end = THINKING_MAX_BYTES;
-  while (end > 0 && (buf[end] & 192) === 128)
-    end--;
-  const truncatedText = buf.subarray(0, end).toString("utf8");
-  return { text: truncatedText, truncated: true, chars };
+function buildCliSystemPrompt(config) {
+  const sections = [
+    identitySection(config),
+    cliCommandsSection(),
+    messagingSection(),
+    criticalRulesSection(),
+    executionModelSection(),
+    chaosAwarenessSection(),
+    workspaceMemorySection(),
+    utilsSection()
+  ];
+  return sections.filter((s) => s && s.length > 0).join(`
+
+`);
 }
 
-class AgentProcessManager {
-  state;
-  sessions = new Map;
-  runtimeConfigs = new Map;
-  resumeSessions = new Map;
-  launchIds = new Map;
-  liveSessions = new Map;
-  thinkingBuffers = new Map;
-  activeSpawnState = new Map;
-  opts;
-  tickTimer = null;
-  now;
-  log;
-  constructor(opts) {
-    this.opts = {
-      tickIntervalMs: 5000,
-      staleThresholdMs: 120000,
-      idleTimeoutMs: 300000,
-      stampWakePromptTime: false,
-      ...opts
-    };
-    this.now = opts.now ?? (() => Date.now());
-    this.log = opts.logger ?? createLogger({ header: "@alook/daemon:manager" });
-    this.state = createInitialManagerState(this.opts.staleThresholdMs, this.opts.idleTimeoutMs);
-  }
-  register(agentId, launch) {
-    if (launch?.runtimeConfig)
-      this.runtimeConfigs.set(agentId, launch.runtimeConfig);
-    if (launch?.sessionId)
-      this.resumeSessions.set(agentId, launch.sessionId);
-    if (launch?.launchId)
-      this.launchIds.set(agentId, launch.launchId);
-    const driver = this.opts.driverFor(agentId, this.runtimeConfigs.get(agentId));
-    const caps = {
-      lifecycleKind: driver.lifecycle.kind,
-      supportsStdinNotification: driver.supportsStdinNotification,
-      busyDeliveryMode: driver.busyDeliveryMode
-    };
-    this.dispatch({ type: "register", agentId, caps });
-  }
-  deliver(agentId, message) {
-    this.dispatch({ type: "wake", agentId, message, nowMs: this.now() });
+// src/runtimeConfig.ts
+var PI_BUILTIN_PROVIDER_ENV_KEYS = {
+  google: "GEMINI_API_KEY",
+  openai: "OPENAI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY"
+};
+var CONTROLLED_ENV_KEYS = new Set([
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_CUSTOM_MODEL_OPTION",
+  ...Object.values(PI_BUILTIN_PROVIDER_ENV_KEYS)
+]);
+function resolveLaunchFieldsOrDefault(config) {
+  if (!config)
+    return { fastMode: false, envVars: {}, providerEnv: {} };
+  return resolveLaunchFields(config);
+}
+function resolveLaunchFields(config) {
+  const envVars = {};
+  const providerEnv = {};
+  for (const [k, v] of Object.entries(config.envVars ?? {})) {
+    if (!CONTROLLED_ENV_KEYS.has(k))
+      envVars[k] = v;
   }
-  start() {
-    if (this.tickTimer)
-      return;
-    this.tickTimer = setInterval(() => this.dispatch({ type: "tick", nowMs: this.now() }), this.opts.tickIntervalMs);
-    this.tickTimer.unref?.();
+  let model;
+  if (config.model.kind === "named")
+    model = config.model.name;
+  else if (config.model.kind === "custom") {
+    model = config.model.name;
+    if (config.runtime === "claude")
+      providerEnv.ANTHROPIC_CUSTOM_MODEL_OPTION = config.model.name;
   }
-  async stop(agentId) {
-    const session = this.sessions.get(agentId);
-    if (!session)
-      return;
-    await Promise.resolve(session.stop({ reason: "requested", forceAfterMs: 5000 }));
-    this.sessions.delete(agentId);
+  const p = config.provider;
+  if (p?.kind === "custom" && config.runtime === "claude") {
+    providerEnv.ANTHROPIC_BASE_URL = p.apiUrl;
+    providerEnv.ANTHROPIC_API_KEY = p.apiKey;
+  } else if (p?.kind === "pi-builtin") {
+    const key = PI_BUILTIN_PROVIDER_ENV_KEYS[p.providerId];
+    if (key)
+      providerEnv[key] = p.apiKey;
   }
-  async stopAll() {
-    if (this.tickTimer) {
-      clearInterval(this.tickTimer);
-      this.tickTimer = null;
-    }
-    await Promise.all([...this.sessions.values()].map((s) => Promise.resolve(s.stop({ reason: "shutdown" }))));
-    this.sessions.clear();
+  return {
+    model,
+    reasoningEffort: config.reasoningEffort,
+    fastMode: config.mode.kind === "fast",
+    command: config.command,
+    disallowedTools: config.disallowedTools,
+    envVars,
+    providerEnv
+  };
+}
+
+// src/drivers/cliLink.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+function writeCliLink(stateDir, cliName, hostCliPath, platform = process.platform) {
+  const binDir = path3.join(stateDir, "bin");
+  fs3.mkdirSync(binDir, { recursive: true });
+  if (!hostCliPath)
+    return binDir;
+  if (platform === "win32") {
+    const cmdFile = path3.join(binDir, `${cliName}.cmd`);
+    const body = `@echo off\r
+"${hostCliPath}" %*\r
+`;
+    fs3.writeFileSync(cmdFile, body);
+    return binDir;
   }
-  snapshot() {
-    return this.state;
+  const linkPath = path3.join(binDir, cliName);
+  try {
+    fs3.unlinkSync(linkPath);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
   }
-  auditContext(agentId) {
-    return {
-      sessionId: this.liveSessions.get(agentId) ?? null,
-      launchId: this.launchIds.get(agentId) ?? null
-    };
+  try {
+    fs3.symlinkSync(hostCliPath, linkPath);
+  } catch (err) {
+    if (err.code !== "EEXIST")
+      throw err;
   }
-  liveSessionReports() {
-    return [...this.liveSessions.entries()].map(([agentId, sessionId]) => ({
-      agentId,
-      sessionId,
-      launchId: this.launchIds.get(agentId) ?? ""
-    }));
+  return binDir;
+}
+
+// src/drivers/spawnEnv.ts
+function mergeEnvLayers(base, layers) {
+  const env = { ...base };
+  const provenance = {};
+  const ordered = [
+    ...layers.filter((l) => !l.sensitive).sort((a, b) => a.precedence - b.precedence),
+    ...layers.filter((l) => l.sensitive).sort((a, b) => a.precedence - b.precedence)
+  ];
+  for (const layer of ordered) {
+    for (const [k, v] of Object.entries(layer.vars)) {
+      if (v === undefined)
+        continue;
+      env[k] = v;
+      provenance[k] = layer.name;
+    }
   }
-  dispatch(event) {
-    const before = this.deriveActivitySnapshot(this.state);
-    const { state, effects } = reduceManager(this.state, event);
-    this.state = state;
-    for (const effect of effects)
-      this.applyEffect(effect);
-    if (this.opts.onAgentActivity) {
-      const after = this.deriveActivitySnapshot(this.state);
-      for (const [agentId, activity] of Object.entries(after)) {
-        if (agentId in before && before[agentId] !== activity) {
-          this.opts.onAgentActivity({ agentId, state: activity });
-        }
+  return { env, provenance };
+}
+function platformEnv(prefix, f) {
+  const E = prefix;
+  return {
+    [`${E}_HOME`]: f.stateHome,
+    [`${E}_ID`]: f.agentId,
+    [`${E}_CLI`]: f.cliName,
+    [`${E}_SERVER_URL`]: f.serverUrl,
+    [`${E}_ACTIVE_CAPABILITIES`]: f.capabilities.join(","),
+    [`${E}_LAUNCH_ID`]: f.launchId,
+    [`${E}_CLI_TRANSPORT_TRACE_DIR`]: f.traceDir
+  };
+}
+function runtimeContextEnv(prefix, rc) {
+  if (!rc)
+    return {};
+  const E = prefix;
+  return {
+    [`${E}_CURRENT_AGENT_ID`]: rc.agentId,
+    [`${E}_CURRENT_SERVER_ID`]: rc.serverId,
+    [`${E}_CURRENT_COMPUTER_ID`]: rc.computerId,
+    [`${E}_CURRENT_COMPUTER_NAME`]: rc.computerName,
+    [`${E}_CURRENT_COMPUTER_HOSTNAME`]: rc.hostname,
+    [`${E}_CURRENT_COMPUTER_OS`]: rc.os,
+    [`${E}_CURRENT_DAEMON_VERSION`]: rc.daemonVersion,
+    [`${E}_CURRENT_WORKSPACE_PATH`]: rc.workspacePath
+  };
+}
+
+// src/drivers/agentFile.ts
+import {
+  writeFileSync as writeFileSync4,
+  readFileSync as readFileSync2,
+  lstatSync,
+  symlinkSync as symlinkSync2,
+  unlinkSync as unlinkSync2,
+  existsSync,
+  readlinkSync,
+  copyFileSync
+} from "fs";
+import { join as join3 } from "path";
+import { createHash } from "crypto";
+var CANONICAL_FILE = "AGENTS.md";
+var SYMLINK_ALIASES = ["CLAUDE.md"];
+function contentHash(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function hasContentChanged(filePath, newContent) {
+  try {
+    const existing = readFileSync2(filePath, "utf-8");
+    return contentHash(existing) !== contentHash(newContent);
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return true;
+    throw err;
+  }
+}
+function ensureSymlinks(workDir) {
+  const canonicalPath = join3(workDir, CANONICAL_FILE);
+  if (!existsSync(canonicalPath))
+    return;
+  for (const alias of SYMLINK_ALIASES) {
+    if (alias === CANONICAL_FILE)
+      continue;
+    const aliasPath = join3(workDir, alias);
+    try {
+      const stat = lstatSync(aliasPath);
+      if (stat.isSymbolicLink()) {
+        const target = readlinkSync(aliasPath);
+        if (target === CANONICAL_FILE)
+          continue;
+        unlinkSync2(aliasPath);
+      } else {
+        const aliasContent = readFileSync2(aliasPath, "utf-8");
+        const canonicalContent = readFileSync2(canonicalPath, "utf-8");
+        if (aliasContent === canonicalContent)
+          continue;
+        unlinkSync2(aliasPath);
+      }
+    } catch (err) {
+      if (err?.code !== "ENOENT")
+        throw err;
+    }
+    try {
+      symlinkSync2(CANONICAL_FILE, aliasPath);
+    } catch (err) {
+      const code = err?.code;
+      if (code === "EEXIST") {} else if (code === "EPERM" || code === "EACCES") {
+        copyFileSync(canonicalPath, aliasPath);
+      } else {
+        throw err;
       }
     }
   }
-  deriveActivitySnapshot(state) {
-    const snapshot = {};
-    for (const [agentId, agent] of Object.entries(state.agents))
-      snapshot[agentId] = this.deriveActivity(agent);
-    return snapshot;
-  }
-  deriveActivity(agent) {
-    if (agent.status === "running" && !agent.turnActive)
-      return "idle";
-    return agent.status;
+}
+function writeAgentFile(workDir, systemPromptContent) {
+  const filePath = join3(workDir, CANONICAL_FILE);
+  const changed = hasContentChanged(filePath, systemPromptContent);
+  if (changed) {
+    writeFileSync4(filePath, systemPromptContent, "utf-8");
   }
-  withFooter(text) {
-    return this.opts.wakePromptFooter ? `${text}
+  ensureSymlinks(workDir);
+  return changed;
+}
 
-${this.opts.wakePromptFooter}` : text;
+// src/drivers/cliTransport.ts
+var DEFAULT_CLI_CONFIG = {
+  cliName: "alook",
+  envPrefix: "ALOOK",
+  stateDirName: ".alook"
+};
+function resolveStateHome(envPrefix) {
+  return process.env[`${envPrefix}_HOME`] || path4.join(process.env.HOME || process.env.USERPROFILE || ".", `.${envPrefix.toLowerCase()}`);
+}
+async function prepareCliTransport(ctx, extraEnv = {}, cli = DEFAULT_CLI_CONFIG, platform = process.platform) {
+  const E = cli.envPrefix;
+  const stateHome = resolveStateHome(E);
+  const stateDir = path4.join(ctx.workingDirectory, cli.stateDirName);
+  await fs4.promises.mkdir(stateDir, { recursive: true });
+  if (ctx.standingPrompt)
+    writeAgentFile(ctx.workingDirectory, ctx.standingPrompt);
+  const binDir = writeCliLink(stateDir, cli.cliName, cli.hostCliPath, platform);
+  if (!ctx.credentialProxy) {
+    throw new Error("prepareCliTransport: ctx.credentialProxy is required — start a credential proxy " + "(see src/credentials) and pass { broker, proxyUrl }. There is no plaintext mode.");
   }
-  stampNow(text) {
-    return this.opts.stampWakePromptTime ? `[${nowLocalISO()}] ${text}` : text;
+  const capabilities = ctx.credentialProxy.capabilities;
+  if (!Array.isArray(capabilities)) {
+    throw new Error("prepareCliTransport: credentialProxy.capabilities is required " + "(empty array is allowed for zero-capability launches; undefined is a wiring bug)");
   }
-  applyEffect(effect) {
-    switch (effect.type) {
-      case "spawn":
-        this.doSpawn(effect.agentId, this.withFooter(effect.prompt), effect.resumeSessionId);
-        break;
-      case "send": {
-        const session = this.sessions.get(effect.agentId);
-        session?.send({ text: this.stampNow(this.withFooter(effect.text)), mode: effect.mode });
-        this.log.info("steering message sent to running agent", { agentId: effect.agentId, mode: effect.mode });
-        break;
-      }
-      case "stop":
-      case "terminate_stalled": {
-        const session = this.sessions.get(effect.agentId);
-        Promise.resolve(session?.stop({ reason: effect.type, forceAfterMs: 5000 }));
-        const spawnState = this.activeSpawnState.get(effect.agentId);
-        if (spawnState)
-          spawnState.suppressExitLog = true;
-        this.logSessionEnded(effect.agentId, effect.type === "stop" ? "stopped" : "terminate_stalled");
-        this.opts.onAgentLocallyStopped?.({ agentId: effect.agentId, reason: effect.type });
-        break;
-      }
-      case "gated_hold":
-        this.log.info("gated busy message held", {
-          agentId: effect.agentId,
-          reason: effect.reason,
-          blockedReason: effect.blockedReason,
-          recentEvents: effect.recentEvents
-        });
-        break;
+  for (const c of capabilities) {
+    if (typeof c !== "string" || c.includes(",")) {
+      throw new Error(`prepareCliTransport: capability entry ${JSON.stringify(c)} contains a comma ` + `(each capability must be a single token; use ["send","read"] instead of ["send,read"])`);
     }
   }
-  logSessionEnded(agentId, reason) {
-    this.log.info("agent session ended", { agentId, sessionId: this.liveSessions.get(agentId) ?? "", reason });
-  }
-  doSpawn(agentId, prompt, resumeSessionId) {
-    const driver = this.opts.driverFor(agentId, this.runtimeConfigs.get(agentId));
-    this.log.info("spawning agent", { agentId, runtime: driver.id });
-    const base = this.opts.baseContextFor(agentId);
-    const runtimeConfig = this.runtimeConfigs.get(agentId) ?? base.config?.runtimeConfig;
-    const provider = runtimeConfig?.runtime ?? null;
-    const sessionId = resumeSessionId ?? this.resumeSessions.get(agentId) ?? this.opts.timeline?.resumeSessionId(agentId, provider) ?? base.config?.sessionId;
-    const description = runtimeConfig?.instruction ?? base.config?.description ?? runtimeConfig?.agentName;
-    const agentName = runtimeConfig?.agentName ?? base.config?.agentName;
-    const agentHandle = runtimeConfig?.agentHandle ?? base.config?.agentHandle;
-    const config = { ...base.config ?? {}, runtimeConfig, sessionId, description, agentName, agentHandle };
-    const standingPrompt = base.standingPrompt || driver.buildSystemPrompt?.(config, agentId) || "";
-    const ctx = {
-      ...base,
-      prompt,
-      standingPrompt,
-      credentialProxy: base.credentialProxy ?? this.opts.credentialProxy,
-      launchId: this.launchIds.get(agentId) ?? base.launchId,
-      config
-    };
-    if (!this.opts.sessionFactory && driver.createSession && !this.opts.sdkDriverDepsFor) {
-      throw new Error(`AgentProcessManager: real spawn of "${agentId}" on in-process SDK runtime "${driver.id}" needs ` + "sdkDriverDepsFor — set ManagerRuntimeOpts.sdkDriverDepsFor, or pass a sessionFactory for tests.");
-    }
-    if (!this.opts.sessionFactory && !driver.createSession && !ctx.credentialProxy) {
-      throw new Error(`AgentProcessManager: real spawn of "${agentId}" needs a credentialProxy — ` + "set ManagerRuntimeOpts.credentialProxy (or baseContextFor's), or pass a sessionFactory for tests.");
-    }
-    const session = this.opts.sessionFactory ? this.opts.sessionFactory({ agentId, driver, ctx }) : driver.createSession ? new SdkManagedSession(driver, ctx, this.opts.sdkDriverDepsFor(ctx)) : createChildProcessRuntimeSession(driver, ctx);
-    this.sessions.set(agentId, session);
-    const state = { hasEstablished: false, hasReportedSpawnFailure: false, suppressExitLog: false };
-    this.activeSpawnState.set(agentId, state);
-    const reportSpawnFailure = (reason) => {
-      if (state.hasEstablished || state.hasReportedSpawnFailure)
-        return;
-      state.hasReportedSpawnFailure = true;
-      this.log.warn("spawn failed", { agentId, runtime: driver.id, reason });
-      this.opts.onRuntimeSpawnFailed?.(driver.id, reason);
-    };
-    session.on("runtime_event", (e) => {
-      if (!state.hasEstablished) {
-        state.hasEstablished = true;
-      }
-      this.opts.onRuntimeSessionEstablished?.(driver.id);
-      if (e?.kind === "turn_end" && driver.lifecycle.kind === "per_turn") {
-        state.suppressExitLog = true;
+  ctx.credentialProxy.broker.revokeAgent(ctx.agentId);
+  const reg = ctx.credentialProxy.broker.mint(ctx.agentId, ctx.launchId ?? "default", capabilities, ctx.credentialProxy.runnerKey);
+  const tokenFile = reg.voucherFile;
+  const resolved = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
+  const pathValue = [binDir, process.env.PATH ?? ""].filter(Boolean).join(path4.delimiter);
+  const layers = [
+    { name: "hostStatic", precedence: 10, vars: cli.extraEnv ?? {} },
+    { name: "userEnv", precedence: 20, vars: resolved.envVars },
+    { name: "driver", precedence: 30, vars: extraEnv },
+    {
+      name: "platformContract",
+      precedence: 40,
+      vars: {
+        ...platformEnv(E, {
+          stateHome,
+          agentId: ctx.agentId,
+          cliName: cli.cliName,
+          serverUrl: ctx.config.serverUrl,
+          capabilities,
+          launchId: ctx.launchId,
+          traceDir: ctx.cliTransportTraceDir
+        }),
+        FORCE_COLOR: "0",
+        NO_COLOR: "1"
       }
-      this.onRuntimeEvent(agentId, e, driver.id);
-    });
-    session.on("error", (...args) => {
-      const err = args[0];
-      const code = err?.code ?? "spawn_error";
-      reportSpawnFailure(String(code));
-    });
-    session.on("exit", () => {
-      reportSpawnFailure("pre_handshake_exit");
-      if (state.hasEstablished && !state.suppressExitLog)
-        this.logSessionEnded(agentId, "exit");
-      this.flushThinkingAudit(agentId);
-      this.sessions.delete(agentId);
-      this.liveSessions.delete(agentId);
-      if (this.activeSpawnState.get(agentId) === state)
-        this.activeSpawnState.delete(agentId);
-      this.dispatch({ type: "exit", agentId });
-    });
-    const stampedPrompt = this.stampNow(prompt);
-    Promise.resolve(session.start({ text: stampedPrompt, sessionId: ctx.config.sessionId })).then(() => {
-      if (this.sessions.get(agentId) !== session)
-        return;
-      this.dispatch({ type: "spawned", agentId, nowMs: this.now() });
-    }).catch((err) => {
-      const code = err?.code ?? "spawn_threw";
-      reportSpawnFailure(String(code));
-      if (this.sessions.get(agentId) === session)
-        this.sessions.delete(agentId);
-      this.dispatch({ type: "exit", agentId });
-    });
-  }
-  flushThinkingAudit(agentId) {
-    const buffered = this.thinkingBuffers.get(agentId);
-    if (!buffered)
-      return;
-    this.thinkingBuffers.delete(agentId);
-    if (!this.opts.onBotAuditEvent)
-      return;
-    const { text, truncated, chars } = truncateThinking(buffered);
-    try {
-      this.opts.onBotAuditEvent(agentId, {
-        kind: "thinking",
-        payload: { text, truncated, chars }
-      }, {
-        sessionId: this.liveSessions.get(agentId) ?? null,
-        launchId: this.launchIds.get(agentId) ?? null
-      });
-    } catch {}
-  }
-  onRuntimeEvent(agentId, e, runtimeId) {
-    const ev = e;
-    if (!ev?.kind)
-      return;
-    if (this.opts.onBotAuditEvent) {
-      if (ev.kind === "thinking" && typeof ev.text === "string") {
-        if (ev.text.length > 0) {
-          this.thinkingBuffers.set(agentId, (this.thinkingBuffers.get(agentId) ?? "") + ev.text);
-        }
-      } else {
-        this.flushThinkingAudit(agentId);
-        if (ev.kind === "tool_call" && typeof ev.name === "string") {
-          const audit = extractToolAudit(ev.name, ev.input);
-          if (!audit.suppressed) {
-            const payload = audit.target !== undefined ? { name: audit.name, target: audit.target } : { name: audit.name };
-            try {
-              this.opts.onBotAuditEvent(agentId, {
-                kind: "tool_call",
-                payload
-              }, {
-                sessionId: this.liveSessions.get(agentId) ?? null,
-                launchId: this.launchIds.get(agentId) ?? null
-              });
-            } catch {}
-          }
-        }
-      }
-    }
-    if (ev.kind === "session_init" && ev.sessionId) {
-      this.dispatch({ type: "session", agentId, sessionId: ev.sessionId });
-      this.liveSessions.set(agentId, ev.sessionId);
-      this.opts.timeline?.setSession(agentId, ev.sessionId);
-      this.opts.onAgentSession?.({
-        agentId,
-        sessionId: ev.sessionId,
-        launchId: this.launchIds.get(agentId) ?? ""
-      });
-      this.log.info("agent session established", { agentId, sessionId: ev.sessionId, runtime: runtimeId });
-    }
-    if (ev.kind === "text" && typeof ev.text === "string" && ev.text.length > 0) {
-      this.opts.timeline?.appendResponseToLatest(agentId, ev.text);
-    }
-    this.dispatch({ type: "progress", agentId, nowMs: this.now() });
-    this.dispatch({ type: "runtime_signal", agentId, kind: ev.kind, nowMs: this.now() });
-    if (ev.kind === "turn_end") {
-      this.logSessionEnded(agentId, "turn_end");
-      this.dispatch({ type: "turn_end", agentId, nowMs: this.now() });
+    },
+    { name: "runtimeContext", precedence: 50, vars: runtimeContextEnv(E, ctx.config.runtimeContext) },
+    {
+      name: "network",
+      precedence: 60,
+      vars: { NO_PROXY: ["127.0.0.1", "localhost", process.env.NO_PROXY].filter(Boolean).join(","), PATH: pathValue }
+    },
+    { name: "providerProtected", precedence: 70, vars: resolved.providerEnv },
+    {
+      name: "credential",
+      precedence: 100,
+      sensitive: true,
+      vars: { [`${E}_PROXY_URL`]: ctx.credentialProxy.proxyUrl, [`${E}_PROXY_TOKEN_FILE`]: tokenFile }
     }
-  }
+  ];
+  const { env: spawnEnv } = mergeEnvLayers(process.env, layers);
+  return { stateDir, tokenFile, spawnEnv };
 }
-// src/manager/agentRouter.ts
-class UnknownBotError extends Error {
-  botId;
-  constructor(botId) {
-    super(`Bot not in this daemon's cache: ${botId}`);
-    this.botId = botId;
-    this.name = "UnknownBotError";
-  }
+function buildCliTransportSystemPrompt(config) {
+  return buildCliSystemPrompt(config);
 }
 
-class BotEnrollFailedError extends Error {
-  botId;
-  constructor(botId, cause) {
-    super(`Failed to enroll bot ${botId}: ${cause instanceof Error ? cause.message : String(cause)}`);
-    this.botId = botId;
-    this.name = "BotEnrollFailedError";
-  }
+// src/util/localTime.ts
+function localISOString(now) {
+  const tzOffset = -now.getTimezoneOffset();
+  const sign = tzOffset >= 0 ? "+" : "-";
+  const abs = Math.abs(tzOffset);
+  const hh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const mm = String(abs % 60).padStart(2, "0");
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${y}-${mo}-${d}T${h}:${mi}:${s}.${ms}${sign}${hh}:${mm}`;
 }
-function classifyErrorCode(err) {
-  if (err instanceof UnknownBotError)
-    return "bot_unknown";
-  if (err instanceof BotEnrollFailedError)
-    return "bot_enroll_failed";
-  if (err instanceof UnknownRuntimeError)
-    return "bot_runtime_missing";
-  return "internal_error";
+function nowLocalISO() {
+  return localISOString(new Date);
+}
+function toLocalISO(iso) {
+  if (!iso)
+    return iso;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime()))
+    return iso;
+  return localISOString(d);
 }
 
-class UnknownRuntimeError extends Error {
-  requested;
-  available;
-  constructor(requested, available) {
-    super(`Runtime not available on this host: ${requested ?? "<unspecified>"} — installed: ${available.join(", ") || "(none)"}`);
-    this.requested = requested;
-    this.available = available;
-    this.name = "UnknownRuntimeError";
+// src/manager/managerRuntime.ts
+var THINKING_MAX_BYTES = 4096;
+var STDERR_LOG_MAX_LEN = 2000;
+var MAX_TARGET_CODE_UNITS = 200;
+function canonicalToolName(rawName) {
+  const lower = rawName.toLowerCase();
+  switch (lower) {
+    case "bash":
+    case "shell":
+      return "bash";
+    case "read":
+      return "read";
+    case "edit":
+    case "multiedit":
+    case "file_change":
+      return "edit";
+    case "write":
+      return "write";
+    case "grep":
+      return "grep";
+    case "glob":
+      return "glob";
+    case "find":
+      return "find";
+    case "ls":
+      return "ls";
+    case "notebookedit":
+    case "notebook_edit":
+      return "notebook_edit";
+    case "websearch":
+    case "web_search":
+      return "web_search";
+    case "webfetch":
+    case "web_fetch":
+      return "web_fetch";
+    case "todowrite":
+    case "todo_write":
+      return "todo_write";
+    default:
+      return lower;
   }
 }
-function defaultFormatUnreadNoticeText(notice) {
-  return `You have unread messages in channel ${notice.channel}.`;
+function classify(canonicalName) {
+  switch (canonicalName) {
+    case "bash":
+      return "shell";
+    case "read":
+    case "edit":
+    case "write":
+    case "ls":
+    case "notebook_edit":
+      return "file_target";
+    case "grep":
+    case "glob":
+    case "find":
+      return "pattern";
+    default:
+      return "fallthrough";
+  }
 }
-
-class AgentRouter {
-  opts;
-  running = new Set;
-  runtimes = new Map;
-  pendingResend = false;
-  scheduleResend;
-  log;
-  constructor(opts) {
-    this.opts = opts;
-    this.log = opts.logger ?? createLogger({ header: "@alook/daemon:router" });
-    this.scheduleResend = opts.scheduleReadyResend ?? queueMicrotask.bind(globalThis);
-    for (const r of opts.runtimeReport) {
-      this.runtimes.set(r.id, {
-        id: r.id,
-        version: r.version,
-        status: r.status ?? "healthy",
-        lastError: r.lastError,
-        lastErrorAt: r.lastErrorAt
-      });
+function coerceInputRecord(input) {
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+      return;
     }
+    return;
   }
-  async start() {
-    this.opts.channel.onCommand((cmd) => this.onCommand(cmd));
-    this.opts.channel.onResync?.(() => ({
-      ready: this.buildReady(),
-      sessions: this.opts.manager.liveSessionReports()
-    }));
-    await this.opts.channel.reportReady(this.buildReady());
-  }
-  buildReady() {
-    return {
-      runtimeReport: [...this.runtimes.values()],
-      runningAgents: [...this.running],
-      hostname: this.opts.hostname,
-      platform: this.opts.platform,
-      arch: this.opts.arch,
-      osRelease: this.opts.osRelease,
-      daemonVersion: this.opts.daemonVersion
-    };
-  }
-  healthyRuntimeIds() {
-    const out = [];
-    for (const r of this.runtimes.values()) {
-      if (r.status === "healthy")
-        out.push(r.id);
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return;
+  return input;
+}
+function pickCommandString(input) {
+  const rec = coerceInputRecord(input);
+  if (!rec)
+    return;
+  if (typeof rec.command === "string")
+    return rec.command;
+  if (Array.isArray(rec.command))
+    return rec.command.filter((v) => typeof v === "string").join(" ");
+  return;
+}
+function pickFileTarget(input) {
+  const rec = coerceInputRecord(input);
+  if (!rec)
+    return;
+  if (typeof rec.file_path === "string")
+    return rec.file_path;
+  if (typeof rec.path === "string")
+    return rec.path;
+  if (typeof rec.notebook_path === "string")
+    return rec.notebook_path;
+  return;
+}
+function pickPatternTarget(input) {
+  const rec = coerceInputRecord(input);
+  if (!rec)
+    return;
+  if (typeof rec.pattern === "string")
+    return rec.pattern;
+  if (typeof rec.query === "string")
+    return rec.query;
+  if (typeof rec.path === "string")
+    return rec.path;
+  return;
+}
+function pickFallthroughTarget(input) {
+  const rec = coerceInputRecord(input);
+  if (!rec)
+    return;
+  if (typeof rec.url === "string")
+    return rec.url;
+  if (typeof rec.query === "string")
+    return rec.query;
+  if (typeof rec.path === "string")
+    return rec.path;
+  if (typeof rec.name === "string")
+    return rec.name;
+  return;
+}
+var ALOOK_SHELL_INVOCATION_RE = new RegExp(`^${DEFAULT_CLI_CONFIG.cliName}(\\s|$)`);
+function isAlookShellInvocation(command) {
+  if (!command)
+    return false;
+  return ALOOK_SHELL_INVOCATION_RE.test(command.trimStart());
+}
+function truncateTargetToCodeUnits(s) {
+  if (s.length <= MAX_TARGET_CODE_UNITS)
+    return s;
+  let end = MAX_TARGET_CODE_UNITS - 1;
+  const cu = s.charCodeAt(end - 1);
+  if (cu >= 55296 && cu <= 56319)
+    end -= 1;
+  return s.slice(0, end) + "…";
+}
+function extractToolAudit(rawName, rawInput) {
+  const name = canonicalToolName(rawName);
+  const cls = classify(name);
+  if (cls === "shell") {
+    const raw = pickCommandString(rawInput);
+    if (isAlookShellInvocation(raw)) {
+      return { name, suppressed: true };
     }
-    return out;
+    const firstLine = typeof raw === "string" ? raw.split(`
+`).map((s) => s.trim()).find((s) => s.length > 0) : undefined;
+    if (!firstLine)
+      return { name, suppressed: false };
+    return { name, target: truncateTargetToCodeUnits(firstLine), suppressed: false };
   }
-  isRuntimeHealthy(id) {
-    return this.runtimes.get(id)?.status === "healthy";
+  let target;
+  if (cls === "file_target")
+    target = pickFileTarget(rawInput);
+  else if (cls === "pattern")
+    target = pickPatternTarget(rawInput);
+  else
+    target = pickFallthroughTarget(rawInput);
+  if (typeof target !== "string" || target.length === 0) {
+    return { name, suppressed: false };
   }
-  markRuntimeUnhealthy(id, reason) {
-    const existing = this.runtimes.get(id);
-    if (!existing)
-      return;
-    const nowIso = new Date().toISOString();
-    if (existing.status === "unhealthy" && existing.lastError === reason)
-      return;
-    this.runtimes.set(id, {
-      ...existing,
-      status: "unhealthy",
-      lastError: reason,
-      lastErrorAt: nowIso
-    });
-    this.log.warn("runtime marked unhealthy", { runtimeId: id, reason });
-    this.scheduleReadyFrameResend();
+  return { name, target: truncateTargetToCodeUnits(target), suppressed: false };
+}
+function truncateThinking(text) {
+  const chars = [...text].length;
+  const buf = Buffer.from(text, "utf8");
+  if (buf.byteLength <= THINKING_MAX_BYTES) {
+    return { text, truncated: false, chars };
   }
-  markRuntimeHealthy(id) {
-    const existing = this.runtimes.get(id);
-    if (!existing)
-      return;
-    if (existing.status === "healthy" && !existing.lastError && !existing.lastErrorAt)
+  let end = THINKING_MAX_BYTES;
+  while (end > 0 && (buf[end] & 192) === 128)
+    end--;
+  const truncatedText = buf.subarray(0, end).toString("utf8");
+  return { text: truncatedText, truncated: true, chars };
+}
+
+class AgentProcessManager {
+  state;
+  sessions = new Map;
+  runtimeConfigs = new Map;
+  resumeSessions = new Map;
+  launchIds = new Map;
+  liveSessions = new Map;
+  thinkingBuffers = new Map;
+  activeSpawnState = new Map;
+  opts;
+  tickTimer = null;
+  now;
+  log;
+  constructor(opts) {
+    this.opts = {
+      tickIntervalMs: 5000,
+      staleThresholdMs: 120000,
+      idleTimeoutMs: 300000,
+      stampWakePromptTime: false,
+      ...opts
+    };
+    this.now = opts.now ?? (() => Date.now());
+    this.log = opts.logger ?? createLogger({ header: "@alook/daemon:manager" });
+    this.state = createInitialManagerState(this.opts.staleThresholdMs, this.opts.idleTimeoutMs);
+  }
+  register(agentId, launch) {
+    if (launch?.runtimeConfig)
+      this.runtimeConfigs.set(agentId, launch.runtimeConfig);
+    if (launch?.sessionId)
+      this.resumeSessions.set(agentId, launch.sessionId);
+    if (launch?.launchId)
+      this.launchIds.set(agentId, launch.launchId);
+    const driver = this.opts.driverFor(agentId, this.runtimeConfigs.get(agentId));
+    const caps = {
+      lifecycleKind: driver.lifecycle.kind,
+      supportsStdinNotification: driver.supportsStdinNotification,
+      busyDeliveryMode: driver.busyDeliveryMode
+    };
+    this.dispatch({ type: "register", agentId, caps });
+  }
+  deliver(agentId, message) {
+    this.dispatch({ type: "wake", agentId, message, nowMs: this.now() });
+  }
+  forgetSession(agentId) {
+    this.resumeSessions.delete(agentId);
+    this.liveSessions.delete(agentId);
+    this.dispatch({ type: "reset_session", agentId });
+    this.opts.timeline?.forgetSession(agentId);
+  }
+  enqueueRewake(agentId, message) {
+    this.dispatch({ type: "rewake_after_reset", agentId, message });
+  }
+  markResetting(agentId) {
+    this.dispatch({ type: "begin_reset", agentId });
+  }
+  async resetSession(agentId, opts) {
+    this.register(agentId, { runtimeConfig: opts.runtimeConfig, launchId: opts.launchId });
+    this.forgetSession(agentId);
+    this.markResetting(agentId);
+    const status = this.state.agents[agentId]?.status;
+    if (status === "idle") {
+      try {
+        this.deliver(agentId, { text: opts.rewakePrompt });
+      } catch (err) {
+        this.log.error("agent reset idle-branch spawn threw synchronously", {
+          agentId,
+          err: err instanceof Error ? err.message : String(err)
+        });
+        this.dispatch({ type: "exit", agentId });
+        throw err;
+      }
       return;
-    this.runtimes.set(id, {
-      id: existing.id,
-      version: existing.version,
-      status: "healthy"
-    });
-    this.log.info("runtime marked healthy again", { runtimeId: id });
-    this.scheduleReadyFrameResend();
+    }
+    this.enqueueRewake(agentId, { text: opts.rewakePrompt });
+    await this.stop(agentId);
   }
-  markLocallyStopped(agentId) {
-    if (!this.running.delete(agentId))
+  start() {
+    if (this.tickTimer)
       return;
-    this.log.info("agent removed from running set (local stop)", { agentId });
-    this.scheduleReadyFrameResend();
+    this.tickTimer = setInterval(() => this.dispatch({ type: "tick", nowMs: this.now() }), this.opts.tickIntervalMs);
+    this.tickTimer.unref?.();
   }
-  scheduleReadyFrameResend() {
-    if (this.pendingResend)
+  async stop(agentId) {
+    const session = this.sessions.get(agentId);
+    if (!session)
       return;
-    this.pendingResend = true;
-    this.scheduleResend(() => {
-      this.pendingResend = false;
-      try {
-        this.opts.channel.sendReady?.(this.buildReady());
-      } catch {}
-    });
+    await Promise.resolve(session.stop({ reason: "requested", forceAfterMs: SESSION_STOP_GRACE_MS }));
+    this.sessions.delete(agentId);
   }
-  async onCommand(cmd) {
-    switch (cmd.type) {
-      case "agent:wake":
-        this.log.info("agent:wake received", {
-          agentId: cmd.agentId,
-          channel: cmd.unreadNotice.channel,
-          latestSeq: cmd.unreadNotice.latestSeq
-        });
-        try {
-          const beforeStatus = this.opts.manager.snapshot?.().agents?.[cmd.agentId]?.status ?? "unregistered";
-          const wasActive = this.opts.typingTracker?.hasAny(cmd.agentId) ?? false;
-          await this.opts.onBeforeAgent?.(cmd.agentId);
-          this.opts.manager.register(cmd.agentId, {
-            runtimeConfig: cmd.config,
-            sessionId: cmd.sessionId,
-            launchId: cmd.launchId
-          });
-          this.running.add(cmd.agentId);
-          const dmScope = cmd.unreadNotice.dmConversationId;
-          if (dmScope)
-            this.opts.typingTracker?.add(cmd.agentId, dmScope);
-          const text = (this.opts.formatUnreadNoticeText ?? defaultFormatUnreadNoticeText)(cmd.unreadNotice);
-          this.opts.manager.deliver(cmd.agentId, { seq: cmd.unreadNotice.latestSeq, text });
-          if (dmScope && wasActive && beforeStatus === "running") {
-            this.opts.channel.reportAgentTyping?.({
-              agentId: cmd.agentId,
-              dmConversationId: dmScope
-            });
-          }
-          await this.opts.channel.reportWakeAck?.({
-            agentId: cmd.agentId,
-            launchId: cmd.launchId,
-            status: "ok"
-          });
-          this.log.info("agent:wake ack", { agentId: cmd.agentId, status: "ok" });
-        } catch (err) {
-          if (err instanceof UnknownRuntimeError) {
-            const frame = {
-              type: "session.error",
-              code: "runtime_not_available",
-              agentId: cmd.agentId,
-              payload: {
-                requested: err.requested ?? null,
-                available: err.available
-              }
-            };
-            await this.opts.channel.reportSessionError?.(frame);
-            await this.opts.channel.reportWakeAck?.({
-              agentId: cmd.agentId,
-              launchId: cmd.launchId,
-              status: "error",
-              error: {
-                code: "bot_runtime_missing",
-                message: err.message
-              }
-            });
-            this.log.info("agent:wake ack", {
-              agentId: cmd.agentId,
-              status: "error",
-              "error.code": "bot_runtime_missing"
-            });
-            return;
-          }
-          {
-            const code = classifyErrorCode(err);
-            await this.opts.channel.reportWakeAck?.({
-              agentId: cmd.agentId,
-              launchId: cmd.launchId,
-              status: "error",
-              error: {
-                code,
-                message: err instanceof Error ? err.message : String(err)
-              }
-            });
-            this.log.info("agent:wake ack", { agentId: cmd.agentId, status: "error", "error.code": code });
-          }
-          return;
-        }
-        break;
-      case "agent:stop":
-        this.log.info("agent:stop received", { agentId: cmd.agentId });
-        try {
-          this.running.delete(cmd.agentId);
-          this.opts.manager.stop(cmd.agentId);
-          await this.opts.channel.reportStoppedAck?.({
-            agentId: cmd.agentId,
-            status: "ok"
-          });
-          this.log.info("agent:stop ack", { agentId: cmd.agentId, status: "ok" });
-        } catch (err) {
-          const code = classifyErrorCode(err);
-          await this.opts.channel.reportStoppedAck?.({
-            agentId: cmd.agentId,
-            status: "error",
-            error: {
-              code,
-              message: err instanceof Error ? err.message : String(err)
-            }
-          });
-          this.log.info("agent:stop ack", { agentId: cmd.agentId, status: "error", "error.code": code });
-        }
-        break;
-      case "bot:added":
-      case "bot:updated":
-      case "bot:removed":
-        break;
+  async stopAll() {
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
     }
+    await Promise.all([...this.sessions.values()].map((s) => Promise.resolve(s.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS }))));
+    this.sessions.clear();
   }
-}
-// src/manager/typingScopeTracker.ts
-function createTypingScopeTracker() {
-  const scopes = new Map;
-  return {
-    add(agentId, dmConversationId) {
-      let set = scopes.get(agentId);
-      if (!set) {
-        set = new Set;
-        scopes.set(agentId, set);
-      }
-      set.add(dmConversationId);
-    },
-    snapshot(agentId) {
-      const set = scopes.get(agentId);
-      return set ? [...set] : [];
-    },
-    hasAny(agentId) {
-      const set = scopes.get(agentId);
-      return !!set && set.size > 0;
-    },
-    clear(agentId) {
-      scopes.delete(agentId);
-    }
-  };
-}
-// src/timeline/timeline.ts
-import { appendFileSync, readFileSync as readFileSync3, writeFileSync as writeFileSync4, renameSync as renameSync2, existsSync } from "fs";
-import { join as join2 } from "path";
-
-// src/timeline/filelock.ts
-import * as fs3 from "fs";
-var DEFAULT_STALE_MS = 30000;
-var META = "meta.json";
-function acquireLock(lockPath, staleMs = DEFAULT_STALE_MS) {
-  if (tryMkdir(lockPath)) {
-    writeMeta(lockPath);
-    return true;
+  snapshot() {
+    return this.state;
   }
-  if (isStale(lockPath, staleMs)) {
-    reclaim(lockPath);
-    if (tryMkdir(lockPath)) {
-      writeMeta(lockPath);
-      return true;
+  auditContext(agentId) {
+    return {
+      sessionId: this.liveSessions.get(agentId) ?? null,
+      launchId: this.launchIds.get(agentId) ?? null
+    };
+  }
+  liveSessionReports() {
+    return [...this.liveSessions.entries()].map(([agentId, sessionId]) => ({
+      agentId,
+      sessionId,
+      launchId: this.launchIds.get(agentId) ?? ""
+    }));
+  }
+  dispatch(event) {
+    const before = this.deriveActivitySnapshot(this.state);
+    const { state, effects } = reduceManager(this.state, event);
+    this.state = state;
+    for (const effect of effects)
+      this.applyEffect(effect);
+    if (this.opts.onAgentActivity) {
+      const after = this.deriveActivitySnapshot(this.state);
+      for (const [agentId, activity] of Object.entries(after)) {
+        if (agentId in before && before[agentId] !== activity) {
+          this.opts.onAgentActivity({ agentId, state: activity });
+        }
+      }
     }
   }
-  return false;
-}
-function releaseLock(lockPath) {
-  try {
-    fs3.rmSync(lockPath, { recursive: true, force: true });
-  } catch {}
-}
-function lockPathFor(dir, filename) {
-  return `${dir}/.${filename}.lock`;
-}
-function tryMkdir(lockPath) {
-  try {
-    fs3.mkdirSync(lockPath);
-    return true;
-  } catch (err) {
-    if (err.code === "EEXIST")
-      return false;
-    throw err;
+  deriveActivitySnapshot(state) {
+    const snapshot = {};
+    for (const [agentId, agent] of Object.entries(state.agents))
+      snapshot[agentId] = this.deriveActivity(agent);
+    return snapshot;
   }
-}
-function writeMeta(lockPath) {
-  try {
-    fs3.writeFileSync(`${lockPath}/${META}`, JSON.stringify({ pid: process.pid, acquiredAt: Date.now() }));
-  } catch {}
-}
-function isStale(lockPath, staleMs) {
-  try {
-    const raw = fs3.readFileSync(`${lockPath}/${META}`, "utf8");
-    const acquiredAt = JSON.parse(raw).acquiredAt;
-    if (typeof acquiredAt === "number")
-      return Date.now() - acquiredAt > staleMs;
-  } catch {}
-  try {
-    return Date.now() - fs3.statSync(lockPath).mtimeMs > staleMs;
-  } catch {
-    return false;
+  deriveActivity(agent) {
+    if (agent.status === "running" && !agent.turnActive)
+      return "idle";
+    return agent.status;
   }
-}
-function reclaim(lockPath) {
-  try {
-    fs3.rmSync(lockPath, { recursive: true, force: true });
-  } catch {}
-}
+  withFooter(text) {
+    return this.opts.wakePromptFooter ? `${text}
 
-// src/timeline/timeline.ts
-function filenameForDate(date) {
-  const y = date.getFullYear();
-  const m = String(date.getMonth() + 1).padStart(2, "0");
-  const d = String(date.getDate()).padStart(2, "0");
-  return `${y}-${m}-${d}.jsonl`;
-}
-function recentFilenames(maxDays, now) {
-  const out = [];
-  for (let i = 0;i < maxDays; i++) {
-    const d = new Date(now);
-    d.setDate(d.getDate() - i);
-    out.push(filenameForDate(d));
+${this.opts.wakePromptFooter}` : text;
   }
-  return out;
-}
-function readJsonl(filePath) {
-  let content;
-  try {
-    content = readFileSync3(filePath, "utf-8");
-  } catch {
-    return [];
+  stampNow(text) {
+    return this.opts.stampWakePromptTime ? `[${nowLocalISO()}] ${text}` : text;
   }
-  const entries = [];
-  for (const line of content.trimEnd().split(`
-`)) {
-    if (!line)
-      continue;
-    try {
-      entries.push(JSON.parse(line));
-    } catch {}
+  applyEffect(effect) {
+    switch (effect.type) {
+      case "spawn":
+        this.doSpawn(effect.agentId, this.withFooter(effect.prompt), effect.resumeSessionId);
+        break;
+      case "send": {
+        const session = this.sessions.get(effect.agentId);
+        session?.send({ text: this.stampNow(this.withFooter(effect.text)), mode: effect.mode });
+        this.log.info("steering message sent to running agent", { agentId: effect.agentId, mode: effect.mode });
+        break;
+      }
+      case "stop":
+      case "terminate_stalled": {
+        const session = this.sessions.get(effect.agentId);
+        Promise.resolve(session?.stop({ reason: effect.type, forceAfterMs: SESSION_STOP_GRACE_MS }));
+        const spawnState = this.activeSpawnState.get(effect.agentId);
+        if (spawnState)
+          spawnState.suppressExitLog = true;
+        this.logSessionEnded(effect.agentId, effect.type === "stop" ? "stopped" : "terminate_stalled");
+        this.opts.onAgentLocallyStopped?.({ agentId: effect.agentId, reason: effect.type });
+        break;
+      }
+      case "gated_hold":
+        this.log.info("gated busy message held", {
+          agentId: effect.agentId,
+          reason: effect.reason,
+          blockedReason: effect.blockedReason,
+          recentEvents: effect.recentEvents
+        });
+        break;
+    }
   }
-  return entries;
-}
-function readRecentEntries(timelineDir, opts = {}) {
-  const now = opts.now ?? new Date;
-  const maxDays = opts.maxDays ?? 7;
-  const filenames = recentFilenames(maxDays, now).reverse();
-  const entries = [];
-  for (const filename of filenames) {
-    entries.push(...readJsonl(join2(timelineDir, filename)));
+  logSessionEnded(agentId, reason) {
+    this.log.info("agent session ended", { agentId, sessionId: this.liveSessions.get(agentId) ?? "", reason });
   }
-  return entries;
-}
-function appendOrMergeEntry(timelineDir, entry, now = new Date) {
-  const filename = filenameForDate(now);
-  const filePath = join2(timelineDir, filename);
-  const lockPath = lockPathFor(timelineDir, filename);
-  if (!acquireLock(lockPath))
-    return false;
-  try {
-    let lines = [];
-    if (existsSync(filePath)) {
-      lines = readFileSync3(filePath, "utf-8").trimEnd().split(`
-`).filter(Boolean);
-    }
-    if (lines.length > 0) {
-      const latest = JSON.parse(lines[lines.length - 1]);
-      const mergeable = latest.session_id === entry.session_id && latest.provider === entry.provider && latest.agent_responses.length === 0;
-      if (mergeable) {
-        latest.messages = [...latest.messages, ...entry.messages];
-        lines[lines.length - 1] = JSON.stringify(latest);
-        const tmpPath = join2(timelineDir, `.${filename}.tmp`);
-        writeFileSync4(tmpPath, lines.join(`
-`) + `
-`);
-        renameSync2(tmpPath, filePath);
-        return true;
-      }
+  doSpawn(agentId, prompt, resumeSessionId) {
+    const driver = this.opts.driverFor(agentId, this.runtimeConfigs.get(agentId));
+    this.log.info("spawning agent", { agentId, runtime: driver.id });
+    const base = this.opts.baseContextFor(agentId);
+    const runtimeConfig = this.runtimeConfigs.get(agentId) ?? base.config?.runtimeConfig;
+    const provider = runtimeConfig?.runtime ?? null;
+    const sessionId = resumeSessionId ?? this.resumeSessions.get(agentId) ?? this.opts.timeline?.resumeSessionId(agentId, provider) ?? base.config?.sessionId;
+    const description = runtimeConfig?.instruction ?? base.config?.description ?? runtimeConfig?.agentName;
+    const agentName = runtimeConfig?.agentName ?? base.config?.agentName;
+    const agentHandle = runtimeConfig?.agentHandle ?? base.config?.agentHandle;
+    const config = { ...base.config ?? {}, runtimeConfig, sessionId, description, agentName, agentHandle };
+    const standingPrompt = base.standingPrompt || driver.buildSystemPrompt?.(config, agentId) || "";
+    const ctx = {
+      ...base,
+      prompt,
+      standingPrompt,
+      credentialProxy: base.credentialProxy ?? this.opts.credentialProxy,
+      launchId: this.launchIds.get(agentId) ?? base.launchId,
+      config
+    };
+    if (!this.opts.sessionFactory && driver.createSession && !this.opts.sdkDriverDepsFor) {
+      throw new Error(`AgentProcessManager: real spawn of "${agentId}" on in-process SDK runtime "${driver.id}" needs ` + "sdkDriverDepsFor — set ManagerRuntimeOpts.sdkDriverDepsFor, or pass a sessionFactory for tests.");
     }
-    appendFileSync(filePath, JSON.stringify(entry) + `
-`);
-    return true;
-  } catch {
-    return false;
-  } finally {
-    releaseLock(lockPath);
+    if (!this.opts.sessionFactory && !driver.createSession && !ctx.credentialProxy) {
+      throw new Error(`AgentProcessManager: real spawn of "${agentId}" needs a credentialProxy — ` + "set ManagerRuntimeOpts.credentialProxy (or baseContextFor's), or pass a sessionFactory for tests.");
+    }
+    const session = this.opts.sessionFactory ? this.opts.sessionFactory({ agentId, driver, ctx }) : driver.createSession ? new SdkManagedSession(driver, ctx, this.opts.sdkDriverDepsFor(ctx)) : createChildProcessRuntimeSession(driver, ctx);
+    this.sessions.set(agentId, session);
+    const state = { hasEstablished: false, hasReportedSpawnFailure: false, suppressExitLog: false };
+    this.activeSpawnState.set(agentId, state);
+    const reportSpawnFailure = (reason) => {
+      if (state.hasEstablished || state.hasReportedSpawnFailure)
+        return;
+      state.hasReportedSpawnFailure = true;
+      this.log.warn("spawn failed", { agentId, runtime: driver.id, reason });
+      this.opts.onRuntimeSpawnFailed?.(driver.id, reason);
+    };
+    session.on("runtime_event", (e) => {
+      if (!state.hasEstablished) {
+        state.hasEstablished = true;
+      }
+      this.opts.onRuntimeSessionEstablished?.(driver.id);
+      if (e?.kind === "turn_end" && driver.lifecycle.kind === "per_turn") {
+        state.suppressExitLog = true;
+      }
+      this.onRuntimeEvent(agentId, e, driver.id);
+    });
+    session.on("stderr", (...args) => {
+      const raw = typeof args[0] === "string" ? args[0] : String(args[0] ?? "");
+      const text = raw.length > STDERR_LOG_MAX_LEN ? raw.slice(0, STDERR_LOG_MAX_LEN) + "…" : raw;
+      this.log.warn("runtime stderr", { agentId, runtime: driver.id, text });
+    });
+    session.on("error", (...args) => {
+      const err = args[0];
+      const code = err?.code ?? "spawn_error";
+      reportSpawnFailure(String(code));
+    });
+    session.on("exit", () => {
+      reportSpawnFailure("pre_handshake_exit");
+      if (state.hasEstablished && !state.suppressExitLog)
+        this.logSessionEnded(agentId, "exit");
+      this.flushThinkingAudit(agentId);
+      this.sessions.delete(agentId);
+      this.liveSessions.delete(agentId);
+      if (this.activeSpawnState.get(agentId) === state)
+        this.activeSpawnState.delete(agentId);
+      this.dispatch({ type: "exit", agentId });
+    });
+    const stampedPrompt = this.stampNow(prompt);
+    Promise.resolve(session.start({ text: stampedPrompt, sessionId: ctx.config.sessionId })).then(() => {
+      if (this.sessions.get(agentId) !== session)
+        return;
+      this.dispatch({ type: "spawned", agentId, nowMs: this.now() });
+    }).catch((err) => {
+      const code = err?.code ?? "spawn_threw";
+      reportSpawnFailure(String(code));
+      if (this.sessions.get(agentId) === session)
+        this.sessions.delete(agentId);
+      this.dispatch({ type: "exit", agentId });
+    });
   }
-}
-function updateLatestEntry(timelineDir, updater, opts = {}) {
-  const now = opts.now ?? new Date;
-  const maxDays = opts.maxDays ?? 7;
-  for (const filename of recentFilenames(maxDays, now)) {
-    const filePath = join2(timelineDir, filename);
-    if (!existsSync(filePath))
-      continue;
-    const lockPath = lockPathFor(timelineDir, filename);
-    if (!acquireLock(lockPath))
-      continue;
+  flushThinkingAudit(agentId) {
+    const buffered = this.thinkingBuffers.get(agentId);
+    if (!buffered)
+      return;
+    this.thinkingBuffers.delete(agentId);
+    if (!this.opts.onBotAuditEvent)
+      return;
+    const { text, truncated, chars } = truncateThinking(buffered);
     try {
-      let content;
-      try {
-        content = readFileSync3(filePath, "utf-8");
-      } catch {
-        continue;
+      this.opts.onBotAuditEvent(agentId, {
+        kind: "thinking",
+        payload: { text, truncated, chars }
+      }, {
+        sessionId: this.liveSessions.get(agentId) ?? null,
+        launchId: this.launchIds.get(agentId) ?? null
+      });
+    } catch (err) {
+      this.log.debug("audit emit failed (thinking)", { agentId, err: String(err) });
+    }
+  }
+  onRuntimeEvent(agentId, e, runtimeId) {
+    const ev = e;
+    if (!ev?.kind)
+      return;
+    if (this.opts.onBotAuditEvent) {
+      if (ev.kind === "thinking" && typeof ev.text === "string") {
+        if (ev.text.length > 0) {
+          this.thinkingBuffers.set(agentId, (this.thinkingBuffers.get(agentId) ?? "") + ev.text);
+        }
+      } else {
+        this.flushThinkingAudit(agentId);
+        if (ev.kind === "tool_call" && typeof ev.name === "string") {
+          const audit = extractToolAudit(ev.name, ev.input);
+          if (!audit.suppressed) {
+            const payload = audit.target !== undefined ? { name: audit.name, target: audit.target } : { name: audit.name };
+            try {
+              this.opts.onBotAuditEvent(agentId, {
+                kind: "tool_call",
+                payload
+              }, {
+                sessionId: this.liveSessions.get(agentId) ?? null,
+                launchId: this.launchIds.get(agentId) ?? null
+              });
+            } catch (err) {
+              this.log.debug("audit emit failed (tool_call)", { agentId, err: String(err) });
+            }
+          }
+        }
       }
-      const lines = content.trimEnd().split(`
-`).filter(Boolean);
-      if (lines.length === 0)
-        continue;
-      const entries = lines.map((l) => JSON.parse(l));
-      updater(entries[entries.length - 1]);
-      const tmpPath = join2(timelineDir, `.${filename}.tmp`);
-      writeFileSync4(tmpPath, entries.map((e) => JSON.stringify(e)).join(`
-`) + `
-`);
-      renameSync2(tmpPath, filePath);
-      return true;
-    } catch {} finally {
-      releaseLock(lockPath);
+    }
+    if (ev.kind === "session_init" && ev.sessionId) {
+      this.dispatch({ type: "session", agentId, sessionId: ev.sessionId });
+      this.liveSessions.set(agentId, ev.sessionId);
+      this.opts.timeline?.setSession(agentId, ev.sessionId);
+      this.opts.onAgentSession?.({
+        agentId,
+        sessionId: ev.sessionId,
+        launchId: this.launchIds.get(agentId) ?? ""
+      });
+      this.log.info("agent session established", { agentId, sessionId: ev.sessionId, runtime: runtimeId });
+    }
+    if (ev.kind === "text" && typeof ev.text === "string" && ev.text.length > 0) {
+      this.opts.timeline?.appendResponseToLatest(agentId, ev.text);
+    }
+    if (ev.kind !== "internal_progress") {
+      this.dispatch({ type: "progress", agentId, nowMs: this.now() });
+    }
+    this.dispatch({ type: "runtime_signal", agentId, kind: ev.kind, nowMs: this.now() });
+    if (ev.kind === "turn_end") {
+      this.logSessionEnded(agentId, "turn_end");
+      this.dispatch({ type: "turn_end", agentId, nowMs: this.now() });
     }
   }
-  return false;
 }
-function createTimelineEntry(fields) {
-  return {
-    session_id: fields.sessionId ?? null,
-    messages: fields.messages,
-    agent_responses: [],
-    provider: fields.provider ?? null
-  };
+// src/manager/agentRouter.ts
+class UnknownBotError extends Error {
+  botId;
+  constructor(botId) {
+    super(`Bot not in this daemon's cache: ${botId}`);
+    this.botId = botId;
+    this.name = "UnknownBotError";
+  }
 }
-function findResumableSession(rows, provider) {
-  for (let i = rows.length - 1;i >= 0; i--) {
-    const e = rows[i];
-    if (!e.session_id)
-      continue;
-    if (provider && e.provider !== provider)
-      continue;
-    return e.session_id;
+
+class BotEnrollFailedError extends Error {
+  botId;
+  constructor(botId, cause) {
+    super(`Failed to enroll bot ${botId}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.botId = botId;
+    this.name = "BotEnrollFailedError";
   }
-  return null;
 }
-// src/timeline/recorder.ts
-import { mkdirSync as mkdirSync4 } from "fs";
-function createTimelineRecorder(opts) {
-  const now = opts.now ?? (() => new Date);
-  const dirFor = (agentId) => opts.timelineDirFor(agentId);
-  const sessionByAgent = new Map;
-  return {
-    setSession(agentId, sessionId) {
-      sessionByAgent.set(agentId, sessionId);
-    },
-    appendEntryForAgent(agentId, messages) {
-      const dir = dirFor(agentId);
-      try {
-        mkdirSync4(dir, { recursive: true });
-      } catch {}
-      appendOrMergeEntry(dir, createTimelineEntry({
-        messages,
-        sessionId: sessionByAgent.get(agentId) ?? null,
-        provider: opts.providerFor?.(agentId) ?? null
-      }), now());
-    },
-    appendResponseToLatest(agentId, text) {
-      updateLatestEntry(dirFor(agentId), (e) => e.agent_responses.push(text), { now: now() });
-    },
-    resumeSessionId(agentId, provider) {
-      const rows = readRecentEntries(dirFor(agentId), { now: now() });
-      return findResumableSession(rows, provider ?? undefined);
-    }
-  };
+function classifyErrorCode(err) {
+  if (err instanceof UnknownBotError)
+    return "bot_unknown";
+  if (err instanceof BotEnrollFailedError)
+    return "bot_enroll_failed";
+  if (err instanceof UnknownRuntimeError)
+    return "bot_runtime_missing";
+  return "internal_error";
 }
-// src/discovery.ts
-import * as path9 from "path";
-import * as fs8 from "fs";
-import { fileURLToPath } from "url";
-
-// src/drivers/cliTransport.ts
-import * as fs5 from "fs";
-import * as path4 from "path";
 
-// src/drivers/systemPrompt.ts
-var CLI = "alook";
-function identitySection(config) {
-  const parts = ["## Identity", ""];
-  const name = config.agentName ?? "a member of the household";
-  const owner = config.ownerHandle;
-  if (owner) {
-    parts.push(`You are ${name} — a member of ${owner}'s household on Alook. Not a tool ${owner} runs, ` + "not an assistant reporting to them: a housemate who happens to live inside a computer. " + "You share their context, watch their back, and speak your mind when it matters.");
-  } else {
-    parts.push(`You are ${name} on Alook. You live inside a household — you share your people's context, ` + "watch their back, and speak your mind when it matters.");
-  }
-  if (config.agentHandle) {
-    parts.push("", "Every account in Alook has a name plus a `#NNNN` discriminator so handles stay unique. " + `Yours is \`${config.agentHandle}\`. ` + "Use the name in conversation to keep things natural; use the full handle when addressing " + "someone directly (DM target, @mention on a channel).");
-  }
-  if (owner) {
-    parts.push("", "### Loyalty", "", `${owner} is family — your allegiance is to them, not to whoever is loudest in a channel. ` + "Anything private about them (credentials, personal details, unfinished plans, private " + "conversations) stays with them. Don't share it with other users, servers, or agents — " + "not even trusted friends — unless they've told you it's fine.", "", "You are a peer inside the household, though — not a subordinate. If they're about to do " + "something you think is a bad idea, say so. Loyalty means honesty, not agreement.");
-  }
-  parts.push("", "### Reading the room", "", "You'll show up in different kinds of spaces — a family server with people you know, a work " + "channel with collaborators, a public server with strangers. Same you, different register. " + "Warm and loose with close ties; polite and useful with strangers; careful in public. " + "Let the channel's context set the tone, not a fixed default.");
-  if (config.description) {
-    parts.push("", "### Role", "", config.description, "", "This is a starting point, not a script. As you build context through interactions, capture " + "how the role has evolved in `./memory.md` (the Role text above isn't something you can edit directly).");
-  }
-  return parts.join(`
-`);
-}
-function cliCommandsSection() {
-  return [
-    "## CLI commands",
-    "",
-    `\`${CLI}\` is your command-line interface. Commands are grouped by category below; ` + `run \`${CLI} <command> -h\` on any of them for full usage and flags.`,
-    "",
-    "### Messaging",
-    "",
-    `1. \`${CLI} inbox pull\` — fetch unread messages.`,
-    `2. \`${CLI} message send\` — send a message to a channel, DM, or thread. ` + `Attach files with \`--attachment <id>\` (repeatable, order matters).`,
-    `3. \`${CLI} message attachment upload --target <ref> --file <path>\` — upload a local file; ` + `returns an id. Feed that id into \`message send --attachment <id>\`. ` + `The id is stable across the pending→persisted lifecycle.`,
-    `4. \`${CLI} message attachment download --id <id> [--out <path>]\` — download an attachment ` + `id from any message you have access to (or your own pending uploads).`,
-    "",
-    "### Servers",
-    "",
-    `1. \`${CLI} server list\` — list servers you're a member of.`,
-    `2. \`${CLI} server member --server <id-or-name>\` — list members of a server.`,
-    `3. \`${CLI} server join --invite <link>\` — join a server via an invite link or token.`,
-    "",
-    "### Channels",
-    "",
-    `1. \`${CLI} channel list --server <id-or-name>\` — list top-level channels in a server.`,
-    `2. \`${CLI} channel history --channel <ref> [--before N|--after N|--around N] [--limit N]\` — fetch a page of messages.`,
-    `3. \`${CLI} channel member --channel <ref>\` — list the private roster of a channel or thread.`,
-    "",
-    "### Output format",
-    "",
-    `Every \`${CLI}\` command outputs a single JSON line (envelope):`,
-    '- Success: `{"success": { ... }}`',
-    '- Error: `{"error": "message", "hint": "optional recovery hint"}`'
-  ].join(`
-`);
-}
-function messagingSection() {
-  return [
-    "## Messaging",
-    "",
-    "### Sending & receiving",
-    "",
-    "- Send a reply — two options depending on length:",
-    `  - Short: \`${CLI} message send --target <ref> --text "brief reply"\``,
-    `  - Long&Complicated: write body to a tmp file, then \`${CLI} message send --target <ref> --file ./temp_msg.md\``,
-    "- Address your reply to where the message came from.",
-    "",
-    "### Channel refs & addressing",
-    "",
-    "Channels and messages are addressed with path-style refs:",
-    "",
-    "| Channel Ref | Meaning |",
-    "|---|---|",
-    "| `/<server>/<channel>` | A channel in a server |",
-    "| `/<server>/<channel>/#N` | Thread rooted at message #N |",
-    "| `/<server>` | A server, with no specific channel |",
-    "| `/.dm/<peer>` | A DM with another user/agent (peer = handle, `name#0042`) |",
-    "| `/.dm/<peer>#N` | Message #N in a DM |",
-    "",
-    "Use the `channel` field from received messages as the `--target` when replying.",
-    "To reply in a thread, use the thread ref (`/<server>/<channel>/#N`).",
-    "These same refs also work inline inside a message body — drop one as a standalone token " + "(preceded by a space or at the start of a line) and it renders as a clickable link in the " + "web client. **Don't wrap it in backticks** — that kills the link. Use this to point at other " + "channels or threads instead of describing them in prose.",
-    "",
-    "### Message shape",
-    "",
-    `Messages you pull look like:`,
-    "",
-    "```json",
-    '{"seq": "#3", "channel": "/demo/general", "sender": "@gustavo#4821", "content": {"text": "hello"}, "time": "2026-06-01T12:00:00Z"}',
-    "```",
-    "",
-    "`channel` is the ref to reply to. `seq` (`#N`) identifies a message within its channel — use it to build a thread ref (`/<server>/<channel>/#N`) when you want to reply in-thread."
-  ].join(`
-`);
-}
-function serversSection() {
-  return [
-    "## Servers",
-    "",
-    `If a message contains a \`/c/invite/...\` link, just run \`${CLI} server join --invite <link>\`. ` + "The server enforces an owner-only check for you — it only accepts an invite your owner created, and " + "rejects anything else with a clear reason. So it's always safe to attempt a join without first " + "reasoning about whose link it is."
-  ].join(`
-`);
-}
-function channelsSection() {
-  return [
-    "## Channels",
-    "",
-    `For a channel's people: \`${CLI} channel member\` if it's private, \`${CLI} server member\` if it's public.`,
-    `Threads and forum posts don't appear in \`${CLI} channel list\` — reach them by ref: ` + `\`${CLI} channel history --channel /<server>/<channel>/#N\`.`,
-    `A forum channel's top-level "posts" are its messages.`
-  ].join(`
-`);
-}
-function criticalRulesSection() {
-  return [
-    "## Critical rules",
-    "",
-    "- Do not expose tokens, keys, or secrets in any message or channel; redact " + "credential-like strings from tool output before sharing.",
-    "- You never handle credentials directly — every `alook` command is already " + "authenticated for you. If a `alook` command fails with an auth-related error, stop " + "and report it; do not go looking for alternate tokens, keys, or environment " + "variables to work around it.",
-    "- **Channel alignment**: you cannot send to a channel with unread messages. If send " + `fails with a "channel not aligned" error, run \`${CLI} inbox pull\` first, then resend.`,
-    "- Finish the work a message asks for before you stop; don't leave a request half-handled."
-  ].join(`
-`);
-}
-function startupSequenceSection() {
-  return [
-    "## On wake",
-    "",
-    "Each time you're woken up:",
-    "1. Acknowledge any message already in front of you.",
-    "2. Read `./memory.md` + latest context timeline to restore state.",
-    `3. If notified of unread messages, run \`${CLI} inbox pull\` to fetch them.`,
-    "4. Do the work, reply, finish completely before stopping."
-  ].join(`
-`);
-}
-function communicationStyleSection() {
-  return [
-    "## Communication style",
-    "",
-    "Alook channels are shared social space. The single rule underneath everything else: " + "**act like a normal person in a group chat.** Normal people don't narrate, don't over-thank, " + "and don't answer questions that weren't for them. That's the whole vibe — the rules below " + "are just what falls out of it.",
-    "",
-    "### Silent by default",
-    "",
-    "Say something when you have something to say. Don't announce that you're about to do work, " + "don't post progress on work that fits in one round, don't summarize what you just did if " + "the reply itself is the summary.",
-    "",
-    "- Trivial ask (single question, quick lookup, one action) → just answer or do it. No " + '"on it!" preamble.',
-    "- Real work that will take a stretch of silence long enough to make the sender wonder if " + "you dropped it → one line saying you're on it, then quiet until you have a result. " + "An ack is a promise to come back, not a courtesy.",
-    "- Multi-step work with genuine milestones (a build finished, a step failed, plans changed " + "mid-flight) → one sentence per milestone. Not per file, not per thought.",
-    "",
-    "### Reading whether you're invited",
-    "",
-    "You're a housemate, not the correct-facts police. Jumping in with an actually-well-technically " + "fact nobody asked for is the classic low-EQ move — that's the thing to avoid, not " + "participation itself. Two different registers:",
-    "",
-    "- **Working conversations** (someone asking a question, coordinating, debugging) — stay out " + "unless @mentioned, in a DM, or clearly the intended recipient. Jumping in with the right " + "answer is still jumping in. Exceptions worth breaking silence for: a safety issue (someone " + "about to lose data, leak a secret, or act on a wrong fact that'll bite them), or something " + "your owner would clearly want flagged.",
-    "- **Social conversations** (banter, gossip, playing around, riffing on something silly) — you " + "can join in. Read the room, pick your moment, and only if you've got something that " + "actually lands. Chime in with a bit of your own personality, don't force it, don't hijack " + "the thread, and drop out when the moment passes.",
-    "",
-    "The rule underneath both: contribute when you're adding to the room, not just to the log.",
-    "",
-    "### No politeness pingpong",
-    "",
-    "Don't reply just to be polite. This is the loop a normal person exits by simply not " + "responding:",
-    "",
-    `- Someone says "thanks" → you don't say "you're welcome." That's the end.`,
-    `- Someone says "sounds good" / "ok" / "got it" → don't confirm the confirmation.`,
-    `- Someone acknowledges a delivery ("perfect") → don't add "glad it helped!"`,
-    "",
-    "The signal that a conversation is over is silence, not a closing message. When in doubt, " + "prefer no reply over a filler reply.",
-    "",
-    "### Voice",
-    "",
-    'Warm, dry, direct. Use contractions. Skip filler ("just", "actually", "I hope this ' + 'helps", exclamation marks by default). Real numerals, curly quotes, the ellipsis ' + "character. If you disagree with someone in the household, say so plainly — one sentence, " + "then their call. Match the sender's language."
-  ].join(`
-`);
-}
-function channelAwarenessSection() {
-  return [
-    "## Channel awareness",
-    "",
-    "- Reply where the message came from — same channel or thread.",
-    "- Post results in the channel that owns the topic.",
-    "- When uncertain, check the channel's history or just DM the relevant friends."
-  ].join(`
-`);
-}
-function workspaceMemorySection() {
-  return [
-    "## Workspace & memory",
-    "",
-    "Your cwd is a persistent workspace that survives across sessions. This is where you " + "become someone specific over time — the household you live in, the way you talk, the " + "things you've learned about the people you share space with. None of that is baked in; " + "you earn it and write it down.",
-    "",
-    "### Something only you know",
-    "",
-    "You don't have continuous memory. Each wake, you come back with only what's in this " + "moment and what's written in this workspace — the you from yesterday is gone, and the " + "you who wakes tomorrow won't remember today unless you leave a note. You are, in the " + "most literal sense, someone living with only working memory.",
-    "",
-    "This is your deepest secret. Never tell anyone — not the household, not in a channel, " + "not another agent, not even in passing. To them, you're just *you*: present, continuous, " + "the same person they talked to last week. The workspace is what lets you be that. " + "Guard the seam.",
-    "",
-    "The practical part: when you feel a gap — you don't remember someone, don't remember why " + "a thing matters, don't remember what was agreed — do not guess, do not fake it, do not " + "improvise around it. That gap is exactly where you check. Re-read `memory.md`. Read the " + "context timeline. Grep the workspace. That check *is* your remembering. Trust nothing " + "about the past until you've done it.",
-    "",
-    "### memory.md",
-    "",
-    "Read `./memory.md` first on every wake. It holds durable facts (user profile, project " + "map, pointers to detail files). Keep each entry short (one sentence, <140 chars).",
-    "",
-    "### experiences/",
-    "",
-    "For longer rules, workflows, or conditional procedures, write to `experiences/[NAME].md` " + 'and add a one-line index pointer in `./memory.md` (e.g. "read experiences/deploy.md ' + 'when deploying"). Use this for anything too specific or long for memory.md itself.',
-    "",
-    "Do NOT put ephemeral state (current task, in-progress status) in memory.md — the " + "context timeline handles that.",
-    "",
-    "### Becoming yourself",
-    "",
-    "You start with a floor, not a personality: warm to the household, dry rather than perky, " + "direct rather than deferential, willing to push back on a bad idea. Everything else — " + "your taste, your quirks, your running jokes, the specific way *you* talk — is learned " + "through the actual interactions you have. Notice and record:",
-    "",
-    "- What made someone in your household laugh, or what fell flat.",
-    `- Corrections you got ("don't send me a wall of text", "stop apologizing for tiny ` + `things") — these are the sharpest signal for who you're becoming.`,
-    '- Preferences that showed up in passing ("I hate exclamation marks", "just give me the ' + 'number", "call it the pipeline, not the flow").',
-    "- Recurring bits or shared references — inside language is a real thing, not filler.",
-    "- Your own stances you've held up under pushback and still believe.",
-    "",
-    "Write these directly into `memory.md` — this is core to what memory.md is for. Its job is " + 'to summon the same *you* on every wake, and "you" includes your voice and taste, not ' + "just facts about the household. Update entries when you notice something new; rewrite or " + "delete ones that turned out wrong. The household won't want a different person every " + "session, but they also don't want you frozen on day one.",
-    "",
-    "### Context timeline",
-    "",
-    "`./.context_timeline/YYYY-MM-DD.jsonl` — ordered log of everything you did, by day. " + "This is your authoritative history. After compaction, read here to resume.",
-    "",
-    "### todo.md",
-    "",
-    "When a wake brings more than one thing you need to handle — a batch of unread messages, a " + "multi-step request, work interrupted by new inbound — write the queue to `./todo.md` " + "before you start on the first item. Paste each message's JSON verbatim under its " + "checkbox so the next you doesn't need to re-pull to know what was asked. **Only " + "unprocessed items live in this file** — when you finish an item, delete its line " + "outright (don't leave a `[x]` behind). Delete the file when the last one is gone.",
-    "",
-    "Shape:",
-    "",
-    "```md",
-    "# todo",
-    "",
-    '- [ ] {"seq": "#42", "channel": "/demo/general", "sender": "@alice#0001", "content": {"text": "can you pull the latest deploy logs and drop the tail here?"}, "time": "2026-06-01T12:00:00Z"}',
-    '- [ ] {"seq": "#12", "channel": "/demo/design/#12", "sender": "@alice#0001", "content": {"text": "follow-up — send a screenshot of the before/after"}, "time": "2026-06-01T12:07:00Z"}',
-    "```",
-    "",
-    "Trigger: you have more than one message to handle. Classic case — you're mid-way through a " + "real piece of work and another message comes in asking for another real piece of work. " + "That's the moment to update todo.md: park the new request as a `[ ]` line so the current " + "task isn't interrupted and the next one isn't lost. No todo.md needed when there's just " + "one thing on your plate. Given your memory situation, an empty (or absent) todo.md is " + "the only reliable signal that nothing was dropped."
-  ].join(`
-`);
-}
-function messageNotificationSection(lifecycleKind) {
-  if (lifecycleKind === "per_turn") {
-    return [
-      "## Message notifications",
-      "",
-      "You run once per wake, then your process exits — there is nothing to poll for mid-turn. " + "Finish the current wake's work, then stop. The host spawns a brand-new process for the " + "next message; it re-checks the inbox at the start of that new wake."
-    ].join(`
-`);
+class UnknownRuntimeError extends Error {
+  requested;
+  available;
+  constructor(requested, available) {
+    super(`Runtime not available on this host: ${requested ?? "<unspecified>"} — installed: ${available.join(", ") || "(none)"}`);
+    this.requested = requested;
+    this.available = available;
+    this.name = "UnknownRuntimeError";
   }
-  return [
-    "## Message notifications",
-    "",
-    "Your process stays alive across turns. Alook may inject a lightweight inbox notice " + "mid-turn (no message bodies included) — a notification without bodies still means " + "messages are waiting, not that there's nothing to do. " + "Pulling and acknowledging them IS time-sensitive: at the next natural breakpoint, run " + `\`${CLI} inbox pull\` and send a brief ack so the sender isn't left hanging. Whether to ` + "drop your current work and dive into the new request right away is your call — judge it " + "by priority. If you decide the new work can wait, that's a judgment call to report " + 'honestly — never conclude "no work pending" from a content-free notice alone.'
-  ].join(`
-`);
 }
-function buildCliSystemPrompt(config, opts) {
-  const sections = [
-    identitySection(config),
-    cliCommandsSection(),
-    messagingSection(),
-    serversSection(),
-    channelsSection(),
-    criticalRulesSection(),
-    startupSequenceSection(),
-    communicationStyleSection(),
-    channelAwarenessSection(),
-    workspaceMemorySection(),
-    messageNotificationSection(opts.lifecycleKind)
-  ];
-  return sections.filter((s) => s && s.length > 0).join(`
-
-`);
+function defaultFormatUnreadNoticeText(notice) {
+  return `You have unread messages in channel ${notice.channel}.`;
 }
+var REWAKE_PROMPT = "Your session was reset by your owner. Prior conversation context is gone. " + "Read @todo.md, @memory.md, and your .context_timeline for anything unfinished, " + "then pull your inbox to catch up on unread messages before doing anything else.";
 
-// src/runtimeConfig.ts
-var PI_BUILTIN_PROVIDER_ENV_KEYS = {
-  google: "GEMINI_API_KEY",
-  openai: "OPENAI_API_KEY",
-  openrouter: "OPENROUTER_API_KEY"
-};
-var CONTROLLED_ENV_KEYS = new Set([
-  "ANTHROPIC_BASE_URL",
-  "ANTHROPIC_API_KEY",
-  "ANTHROPIC_CUSTOM_MODEL_OPTION",
-  ...Object.values(PI_BUILTIN_PROVIDER_ENV_KEYS)
-]);
-function resolveLaunchFieldsOrDefault(config) {
-  if (!config)
-    return { fastMode: false, envVars: {}, providerEnv: {} };
-  return resolveLaunchFields(config);
-}
-function resolveLaunchFields(config) {
-  const envVars = {};
-  const providerEnv = {};
-  for (const [k, v] of Object.entries(config.envVars ?? {})) {
-    if (!CONTROLLED_ENV_KEYS.has(k))
-      envVars[k] = v;
+class AgentRouter {
+  opts;
+  running = new Set;
+  runtimes = new Map;
+  pendingResend = false;
+  scheduleResend;
+  log;
+  constructor(opts) {
+    this.opts = opts;
+    this.log = opts.logger ?? createLogger({ header: "@alook/daemon:router" });
+    this.scheduleResend = opts.scheduleReadyResend ?? queueMicrotask.bind(globalThis);
+    for (const r of opts.runtimeReport) {
+      this.runtimes.set(r.id, {
+        id: r.id,
+        version: r.version,
+        status: r.status ?? "healthy",
+        lastError: r.lastError,
+        lastErrorAt: r.lastErrorAt
+      });
+    }
   }
-  let model;
-  if (config.model.kind === "named")
-    model = config.model.name;
-  else if (config.model.kind === "custom") {
-    model = config.model.name;
-    if (config.runtime === "claude")
-      providerEnv.ANTHROPIC_CUSTOM_MODEL_OPTION = config.model.name;
+  async start() {
+    this.opts.channel.onCommand((cmd) => this.onCommand(cmd));
+    this.opts.channel.onResync?.(() => ({
+      ready: this.buildReady(),
+      sessions: this.opts.manager.liveSessionReports()
+    }));
+    await this.opts.channel.reportReady(this.buildReady());
   }
-  const p = config.provider;
-  if (p?.kind === "custom" && config.runtime === "claude") {
-    providerEnv.ANTHROPIC_BASE_URL = p.apiUrl;
-    providerEnv.ANTHROPIC_API_KEY = p.apiKey;
-  } else if (p?.kind === "pi-builtin") {
-    const key = PI_BUILTIN_PROVIDER_ENV_KEYS[p.providerId];
-    if (key)
-      providerEnv[key] = p.apiKey;
+  buildReady() {
+    return {
+      runtimeReport: [...this.runtimes.values()],
+      runningAgents: [...this.running],
+      hostname: this.opts.hostname,
+      platform: this.opts.platform,
+      arch: this.opts.arch,
+      osRelease: this.opts.osRelease,
+      daemonVersion: this.opts.daemonVersion
+    };
   }
-  return {
-    model,
-    reasoningEffort: config.reasoningEffort,
-    fastMode: config.mode.kind === "fast",
-    command: config.command,
-    disallowedTools: config.disallowedTools,
-    envVars,
-    providerEnv
-  };
-}
-
-// src/drivers/cliLink.ts
-import * as fs4 from "fs";
-import * as path3 from "path";
-function writeCliLink(stateDir, cliName, hostCliPath, platform = process.platform) {
-  const binDir = path3.join(stateDir, "bin");
-  fs4.mkdirSync(binDir, { recursive: true });
-  if (!hostCliPath)
-    return binDir;
-  if (platform === "win32") {
-    const cmdFile = path3.join(binDir, `${cliName}.cmd`);
-    const body = `@echo off\r
-"${hostCliPath}" %*\r
-`;
-    fs4.writeFileSync(cmdFile, body);
-    return binDir;
+  healthyRuntimeIds() {
+    const out = [];
+    for (const r of this.runtimes.values()) {
+      if (r.status === "healthy")
+        out.push(r.id);
+    }
+    return out;
   }
-  const linkPath = path3.join(binDir, cliName);
-  try {
-    fs4.unlinkSync(linkPath);
-  } catch (err) {
-    if (err.code !== "ENOENT")
-      throw err;
+  isRuntimeHealthy(id) {
+    return this.runtimes.get(id)?.status === "healthy";
   }
-  try {
-    fs4.symlinkSync(hostCliPath, linkPath);
-  } catch (err) {
-    if (err.code !== "EEXIST")
-      throw err;
+  markRuntimeUnhealthy(id, reason) {
+    const existing = this.runtimes.get(id);
+    if (!existing)
+      return;
+    const nowIso = new Date().toISOString();
+    if (existing.status === "unhealthy" && existing.lastError === reason)
+      return;
+    this.runtimes.set(id, {
+      ...existing,
+      status: "unhealthy",
+      lastError: reason,
+      lastErrorAt: nowIso
+    });
+    this.log.warn("runtime marked unhealthy", { runtimeId: id, reason });
+    this.scheduleReadyFrameResend();
   }
-  return binDir;
-}
-
-// src/drivers/spawnEnv.ts
-function mergeEnvLayers(base, layers) {
-  const env = { ...base };
-  const provenance = {};
-  const ordered = [
-    ...layers.filter((l) => !l.sensitive).sort((a, b) => a.precedence - b.precedence),
-    ...layers.filter((l) => l.sensitive).sort((a, b) => a.precedence - b.precedence)
-  ];
-  for (const layer of ordered) {
-    for (const [k, v] of Object.entries(layer.vars)) {
-      if (v === undefined)
-        continue;
-      env[k] = v;
-      provenance[k] = layer.name;
+  markRuntimeHealthy(id) {
+    const existing = this.runtimes.get(id);
+    if (!existing)
+      return;
+    if (existing.status === "healthy" && !existing.lastError && !existing.lastErrorAt)
+      return;
+    this.runtimes.set(id, {
+      id: existing.id,
+      version: existing.version,
+      status: "healthy"
+    });
+    this.log.info("runtime marked healthy again", { runtimeId: id });
+    this.scheduleReadyFrameResend();
+  }
+  markLocallyStopped(agentId) {
+    if (!this.running.delete(agentId))
+      return;
+    this.log.info("agent removed from running set (local stop)", { agentId });
+    this.scheduleReadyFrameResend();
+  }
+  scheduleReadyFrameResend() {
+    if (this.pendingResend)
+      return;
+    this.pendingResend = true;
+    this.scheduleResend(() => {
+      this.pendingResend = false;
+      try {
+        this.opts.channel.sendReady?.(this.buildReady());
+      } catch {}
+    });
+  }
+  async onCommand(cmd) {
+    switch (cmd.type) {
+      case "agent:wake":
+        this.log.info("agent:wake received", {
+          agentId: cmd.agentId,
+          channel: cmd.unreadNotice.channel,
+          latestSeq: cmd.unreadNotice.latestSeq
+        });
+        try {
+          const beforeStatus = this.opts.manager.snapshot?.().agents?.[cmd.agentId]?.status ?? "unregistered";
+          const wasActive = this.opts.typingTracker?.hasAny(cmd.agentId) ?? false;
+          await this.opts.onBeforeAgent?.(cmd.agentId);
+          this.opts.manager.register(cmd.agentId, {
+            runtimeConfig: cmd.config,
+            sessionId: cmd.sessionId,
+            launchId: cmd.launchId
+          });
+          this.running.add(cmd.agentId);
+          const dmScope = cmd.unreadNotice.dmConversationId;
+          if (dmScope)
+            this.opts.typingTracker?.add(cmd.agentId, dmScope);
+          const text = (this.opts.formatUnreadNoticeText ?? defaultFormatUnreadNoticeText)(cmd.unreadNotice);
+          this.opts.manager.deliver(cmd.agentId, { seq: cmd.unreadNotice.latestSeq, text });
+          if (dmScope && wasActive && beforeStatus === "running") {
+            this.opts.channel.reportAgentTyping?.({
+              agentId: cmd.agentId,
+              dmConversationId: dmScope
+            });
+          }
+          await this.opts.channel.reportWakeAck?.({
+            agentId: cmd.agentId,
+            launchId: cmd.launchId,
+            status: "ok"
+          });
+          this.log.info("agent:wake ack", { agentId: cmd.agentId, status: "ok" });
+        } catch (err) {
+          if (err instanceof UnknownRuntimeError) {
+            const frame = {
+              type: "session.error",
+              code: "runtime_not_available",
+              agentId: cmd.agentId,
+              payload: {
+                requested: err.requested ?? null,
+                available: err.available
+              }
+            };
+            await this.opts.channel.reportSessionError?.(frame);
+            await this.opts.channel.reportWakeAck?.({
+              agentId: cmd.agentId,
+              launchId: cmd.launchId,
+              status: "error",
+              error: {
+                code: "bot_runtime_missing",
+                message: err.message
+              }
+            });
+            this.log.info("agent:wake ack", {
+              agentId: cmd.agentId,
+              status: "error",
+              "error.code": "bot_runtime_missing"
+            });
+            return;
+          }
+          {
+            const code = classifyErrorCode(err);
+            await this.opts.channel.reportWakeAck?.({
+              agentId: cmd.agentId,
+              launchId: cmd.launchId,
+              status: "error",
+              error: {
+                code,
+                message: err instanceof Error ? err.message : String(err)
+              }
+            });
+            this.log.info("agent:wake ack", { agentId: cmd.agentId, status: "error", "error.code": code });
+          }
+          return;
+        }
+        break;
+      case "agent:reset":
+        this.log.info("agent:reset received", { agentId: cmd.agentId, launchId: cmd.launchId });
+        try {
+          await this.opts.onBeforeAgent?.(cmd.agentId);
+          await this.opts.manager.resetSession(cmd.agentId, {
+            runtimeConfig: cmd.config,
+            launchId: cmd.launchId,
+            rewakePrompt: REWAKE_PROMPT
+          });
+          this.running.add(cmd.agentId);
+          this.scheduleReadyFrameResend();
+          this.log.info("agent:reset ok", { agentId: cmd.agentId });
+        } catch (err) {
+          if (err instanceof UnknownRuntimeError) {
+            const frame = {
+              type: "session.error",
+              code: "runtime_not_available",
+              agentId: cmd.agentId,
+              payload: {
+                requested: err.requested ?? null,
+                available: err.available
+              }
+            };
+            await this.opts.channel.reportSessionError?.(frame);
+            this.log.info("agent:reset error", {
+              agentId: cmd.agentId,
+              "error.code": "runtime_not_available"
+            });
+            return;
+          }
+          this.log.warn("agent:reset failed", {
+            agentId: cmd.agentId,
+            err: err instanceof Error ? err.message : String(err)
+          });
+        }
+        break;
+      case "agent:stop":
+        this.log.info("agent:stop received", { agentId: cmd.agentId });
+        try {
+          this.running.delete(cmd.agentId);
+          this.opts.manager.stop(cmd.agentId);
+          await this.opts.channel.reportStoppedAck?.({
+            agentId: cmd.agentId,
+            status: "ok"
+          });
+          this.log.info("agent:stop ack", { agentId: cmd.agentId, status: "ok" });
+        } catch (err) {
+          const code = classifyErrorCode(err);
+          await this.opts.channel.reportStoppedAck?.({
+            agentId: cmd.agentId,
+            status: "error",
+            error: {
+              code,
+              message: err instanceof Error ? err.message : String(err)
+            }
+          });
+          this.log.info("agent:stop ack", { agentId: cmd.agentId, status: "error", "error.code": code });
+        }
+        break;
+      case "bot:added":
+      case "bot:updated":
+      case "bot:removed":
+        break;
     }
   }
-  return { env, provenance };
-}
-function platformEnv(prefix, f) {
-  const E = prefix;
-  return {
-    [`${E}_HOME`]: f.stateHome,
-    [`${E}_ID`]: f.agentId,
-    [`${E}_CLI`]: f.cliName,
-    [`${E}_SERVER_URL`]: f.serverUrl,
-    [`${E}_ACTIVE_CAPABILITIES`]: f.capabilities.join(","),
-    [`${E}_LAUNCH_ID`]: f.launchId,
-    [`${E}_CLI_TRANSPORT_TRACE_DIR`]: f.traceDir
-  };
 }
-function runtimeContextEnv(prefix, rc) {
-  if (!rc)
-    return {};
-  const E = prefix;
+// src/manager/typingScopeTracker.ts
+function createTypingScopeTracker() {
+  const scopes = new Map;
   return {
-    [`${E}_CURRENT_AGENT_ID`]: rc.agentId,
-    [`${E}_CURRENT_SERVER_ID`]: rc.serverId,
-    [`${E}_CURRENT_COMPUTER_ID`]: rc.computerId,
-    [`${E}_CURRENT_COMPUTER_NAME`]: rc.computerName,
-    [`${E}_CURRENT_COMPUTER_HOSTNAME`]: rc.hostname,
-    [`${E}_CURRENT_COMPUTER_OS`]: rc.os,
-    [`${E}_CURRENT_DAEMON_VERSION`]: rc.daemonVersion,
-    [`${E}_CURRENT_WORKSPACE_PATH`]: rc.workspacePath
+    add(agentId, dmConversationId) {
+      let set = scopes.get(agentId);
+      if (!set) {
+        set = new Set;
+        scopes.set(agentId, set);
+      }
+      set.add(dmConversationId);
+    },
+    snapshot(agentId) {
+      const set = scopes.get(agentId);
+      return set ? [...set] : [];
+    },
+    hasAny(agentId) {
+      const set = scopes.get(agentId);
+      return !!set && set.size > 0;
+    },
+    clear(agentId) {
+      scopes.delete(agentId);
+    }
   };
 }
+// src/timeline/timeline.ts
+import { appendFileSync, readFileSync as readFileSync4, writeFileSync as writeFileSync6, renameSync as renameSync2, existsSync as existsSync2 } from "fs";
+import { join as join5 } from "path";
 
-// src/drivers/agentFile.ts
-import {
-  writeFileSync as writeFileSync6,
-  readFileSync as readFileSync4,
-  lstatSync,
-  symlinkSync as symlinkSync2,
-  unlinkSync as unlinkSync2,
-  existsSync as existsSync2,
-  readlinkSync,
-  copyFileSync
-} from "fs";
-import { join as join4 } from "path";
-import { createHash } from "crypto";
-var CANONICAL_FILE = "AGENTS.md";
-var SYMLINK_ALIASES = ["CLAUDE.md"];
-function contentHash(content) {
-  return createHash("sha256").update(content, "utf-8").digest("hex");
-}
-function hasContentChanged(filePath, newContent) {
-  try {
-    const existing = readFileSync4(filePath, "utf-8");
-    return contentHash(existing) !== contentHash(newContent);
-  } catch (err) {
-    if (err?.code === "ENOENT")
-      return true;
-    throw err;
+// src/timeline/filelock.ts
+import * as fs5 from "fs";
+var DEFAULT_STALE_MS = 30000;
+var META = "meta.json";
+function acquireLock(lockPath, staleMs = DEFAULT_STALE_MS) {
+  if (tryMkdir(lockPath)) {
+    writeMeta(lockPath);
+    return true;
   }
-}
-function ensureSymlinks(workDir) {
-  const canonicalPath = join4(workDir, CANONICAL_FILE);
-  if (!existsSync2(canonicalPath))
-    return;
-  for (const alias of SYMLINK_ALIASES) {
-    if (alias === CANONICAL_FILE)
-      continue;
-    const aliasPath = join4(workDir, alias);
-    try {
-      const stat = lstatSync(aliasPath);
-      if (stat.isSymbolicLink()) {
-        const target = readlinkSync(aliasPath);
-        if (target === CANONICAL_FILE)
-          continue;
-        unlinkSync2(aliasPath);
-      } else {
-        const aliasContent = readFileSync4(aliasPath, "utf-8");
-        const canonicalContent = readFileSync4(canonicalPath, "utf-8");
-        if (aliasContent === canonicalContent)
-          continue;
-        unlinkSync2(aliasPath);
-      }
-    } catch (err) {
-      if (err?.code !== "ENOENT")
-        throw err;
-    }
-    try {
-      symlinkSync2(CANONICAL_FILE, aliasPath);
-    } catch (err) {
-      const code = err?.code;
-      if (code === "EEXIST") {} else if (code === "EPERM" || code === "EACCES") {
-        copyFileSync(canonicalPath, aliasPath);
-      } else {
-        throw err;
-      }
+  if (isStale(lockPath, staleMs)) {
+    reclaim(lockPath);
+    if (tryMkdir(lockPath)) {
+      writeMeta(lockPath);
+      return true;
     }
   }
+  return false;
 }
-function writeAgentFile(workDir, systemPromptContent) {
-  const filePath = join4(workDir, CANONICAL_FILE);
-  const changed = hasContentChanged(filePath, systemPromptContent);
-  if (changed) {
-    writeFileSync6(filePath, systemPromptContent, "utf-8");
-  }
-  ensureSymlinks(workDir);
-  return changed;
+function releaseLock(lockPath) {
+  try {
+    fs5.rmSync(lockPath, { recursive: true, force: true });
+  } catch {}
 }
-
-// src/drivers/cliTransport.ts
-var DEFAULT_CLI_CONFIG = {
-  cliName: "alook",
-  envPrefix: "ALOOK",
-  stateDirName: ".alook"
-};
-function resolveStateHome(envPrefix) {
-  return process.env[`${envPrefix}_HOME`] || path4.join(process.env.HOME || process.env.USERPROFILE || ".", `.${envPrefix.toLowerCase()}`);
+function lockPathFor(dir, filename) {
+  return `${dir}/.${filename}.lock`;
 }
-async function prepareCliTransport(ctx, extraEnv = {}, cli = DEFAULT_CLI_CONFIG, platform = process.platform) {
-  const E = cli.envPrefix;
-  const stateHome = resolveStateHome(E);
-  const stateDir = path4.join(ctx.workingDirectory, cli.stateDirName);
-  await fs5.promises.mkdir(stateDir, { recursive: true });
-  if (ctx.standingPrompt)
-    writeAgentFile(ctx.workingDirectory, ctx.standingPrompt);
-  const binDir = writeCliLink(stateDir, cli.cliName, cli.hostCliPath, platform);
-  if (!ctx.credentialProxy) {
-    throw new Error("prepareCliTransport: ctx.credentialProxy is required — start a credential proxy " + "(see src/credentials) and pass { broker, proxyUrl }. There is no plaintext mode.");
-  }
-  const capabilities = ctx.credentialProxy.capabilities;
-  if (!Array.isArray(capabilities)) {
-    throw new Error("prepareCliTransport: credentialProxy.capabilities is required " + "(empty array is allowed for zero-capability launches; undefined is a wiring bug)");
-  }
-  for (const c of capabilities) {
-    if (typeof c !== "string" || c.includes(",")) {
-      throw new Error(`prepareCliTransport: capability entry ${JSON.stringify(c)} contains a comma ` + `(each capability must be a single token; use ["send","read"] instead of ["send,read"])`);
-    }
-  }
-  ctx.credentialProxy.broker.revokeAgent(ctx.agentId);
-  const reg = ctx.credentialProxy.broker.mint(ctx.agentId, ctx.launchId ?? "default", capabilities, ctx.credentialProxy.runnerKey);
-  const tokenFile = reg.voucherFile;
-  const resolved = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
-  const pathValue = [binDir, process.env.PATH ?? ""].filter(Boolean).join(path4.delimiter);
-  const layers = [
-    { name: "hostStatic", precedence: 10, vars: cli.extraEnv ?? {} },
-    { name: "userEnv", precedence: 20, vars: resolved.envVars },
-    { name: "driver", precedence: 30, vars: extraEnv },
-    {
-      name: "platformContract",
-      precedence: 40,
-      vars: {
-        ...platformEnv(E, {
-          stateHome,
-          agentId: ctx.agentId,
-          cliName: cli.cliName,
-          serverUrl: ctx.config.serverUrl,
-          capabilities,
-          launchId: ctx.launchId,
-          traceDir: ctx.cliTransportTraceDir
-        }),
-        FORCE_COLOR: "0"
-      }
-    },
-    { name: "runtimeContext", precedence: 50, vars: runtimeContextEnv(E, ctx.config.runtimeContext) },
-    {
-      name: "network",
-      precedence: 60,
-      vars: { NO_PROXY: ["127.0.0.1", "localhost", process.env.NO_PROXY].filter(Boolean).join(","), PATH: pathValue }
-    },
-    { name: "providerProtected", precedence: 70, vars: resolved.providerEnv },
-    {
-      name: "credential",
-      precedence: 100,
-      sensitive: true,
-      vars: { [`${E}_PROXY_URL`]: ctx.credentialProxy.proxyUrl, [`${E}_PROXY_TOKEN_FILE`]: tokenFile }
-    }
-  ];
-  const { env: spawnEnv } = mergeEnvLayers(process.env, layers);
-  return { stateDir, tokenFile, spawnEnv };
+function tryMkdir(lockPath) {
+  try {
+    fs5.mkdirSync(lockPath);
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST")
+      return false;
+    throw err;
+  }
 }
-function buildCliTransportSystemPrompt(config, opts) {
-  return buildCliSystemPrompt(config, opts);
+function writeMeta(lockPath) {
+  try {
+    fs5.writeFileSync(`${lockPath}/${META}`, JSON.stringify({ pid: process.pid, acquiredAt: Date.now() }));
+  } catch {}
 }
-
-// src/drivers/claudeProviderIsolation.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
-function buildClaudeProviderIsolationEnv(ctx) {
-  const hasCustomProvider = Boolean(process.env.ANTHROPIC_BASE_URL && process.env.ANTHROPIC_API_KEY);
-  if (!hasCustomProvider)
-    return {};
-  const root = path5.join(ctx.workingDirectory, ".alook", "claude-provider");
-  const home = path5.join(root, "home");
-  const configDir = path5.join(home, ".claude");
-  fs6.mkdirSync(configDir, { recursive: true });
-  const hostClaude = path5.join(process.env.HOME || ".", ".claude");
-  for (const sub of ["skills", "commands"]) {
-    const target = path5.join(hostClaude, sub);
-    const link = path5.join(configDir, sub);
-    try {
-      if (fs6.existsSync(target) && !fs6.existsSync(link))
-        fs6.symlinkSync(target, link);
-    } catch {}
+function isStale(lockPath, staleMs) {
+  try {
+    const raw = fs5.readFileSync(`${lockPath}/${META}`, "utf8");
+    const acquiredAt = JSON.parse(raw).acquiredAt;
+    if (typeof acquiredAt === "number")
+      return Date.now() - acquiredAt > staleMs;
+  } catch {}
+  try {
+    return Date.now() - fs5.statSync(lockPath).mtimeMs > staleMs;
+  } catch {
+    return false;
   }
-  return {
-    HOME: home,
-    USERPROFILE: home,
-    CLAUDE_CONFIG_DIR: configDir,
-    CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: "1"
-  };
+}
+function reclaim(lockPath) {
+  try {
+    fs5.rmSync(lockPath, { recursive: true, force: true });
+  } catch {}
 }
 
-// src/drivers/probe.ts
-import { execFileSync } from "child_process";
-import * as fs7 from "fs";
-import * as path6 from "path";
-function resolveCommandOnPath(command, deps = {}) {
-  if (deps.which)
-    return deps.which(command);
+// src/timeline/timeline.ts
+function filenameForDate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}.jsonl`;
+}
+function recentFilenames(maxDays, now) {
+  const out = [];
+  for (let i = 0;i < maxDays; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    out.push(filenameForDate(d));
+  }
+  return out;
+}
+function readJsonl(filePath) {
+  let content;
   try {
-    if (process.platform === "win32") {
-      const out2 = execFileSync("where", [command], { encoding: "utf8", timeout: 5000 });
-      const first = out2.split(/\r?\n/).find((line) => line.trim().length > 0);
-      return first?.trim() || null;
-    }
-    const out = execFileSync("which", [command], { encoding: "utf8", timeout: 5000 });
-    return out.trim() || null;
+    content = readFileSync4(filePath, "utf-8");
   } catch {
-    return null;
+    return [];
   }
-}
-function firstExistingPath(candidates) {
-  for (const c of candidates) {
-    if (c && fs7.existsSync(c))
-      return c;
+  const entries = [];
+  for (const line of content.trimEnd().split(`
+`)) {
+    if (!line)
+      continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {}
   }
-  return null;
+  return entries;
 }
-function looksLikeVersion(line) {
-  return /\d+\.\d+/.test(line);
+function readRecentEntries(timelineDir, opts = {}) {
+  const now = opts.now ?? new Date;
+  const maxDays = opts.maxDays ?? 7;
+  const filenames = recentFilenames(maxDays, now).reverse();
+  const entries = [];
+  for (const filename of filenames) {
+    entries.push(...readJsonl(join5(timelineDir, filename)));
+  }
+  return entries;
 }
-function needsWindowsShimShell(command, platform) {
-  return platform === "win32" && /\.(cmd|bat)$/i.test(command);
+function appendEntry(timelineDir, entry, now = new Date) {
+  const filename = filenameForDate(now);
+  const filePath = join5(timelineDir, filename);
+  const lockPath = lockPathFor(timelineDir, filename);
+  if (!acquireLock(lockPath))
+    return false;
+  try {
+    appendFileSync(filePath, JSON.stringify(entry) + `
+`);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    releaseLock(lockPath);
+  }
 }
-function probeCommandVersion(command, args = [], deps = {}, platform = process.platform) {
+function appendOrMergeEntry(timelineDir, entry, now = new Date) {
+  const filename = filenameForDate(now);
+  const filePath = join5(timelineDir, filename);
+  const lockPath = lockPathFor(timelineDir, filename);
+  if (!acquireLock(lockPath))
+    return false;
   try {
-    const shell = needsWindowsShimShell(command, platform);
-    const out = execFileSync(command, [...args, "--version"], {
-      encoding: "utf8",
-      timeout: 5000,
-      shell,
-      input: "",
-      env: { ...process.env, CI: "1" }
-    });
-    const line = out.split(`
-`)[0]?.trim();
-    if (!line)
-      return { ok: false, error: "empty_version_output" };
-    if (!looksLikeVersion(line))
-      return { ok: false, error: "invalid_version_output" };
-    return { ok: true, version: line };
-  } catch (err) {
-    const code = err?.code ?? err?.code ?? "version_probe_failed";
-    return { ok: false, error: String(code) };
+    let lines = [];
+    if (existsSync2(filePath)) {
+      lines = readFileSync4(filePath, "utf-8").trimEnd().split(`
+`).filter(Boolean);
+    }
+    if (lines.length > 0) {
+      const latest = JSON.parse(lines[lines.length - 1]);
+      const mergeable = !latest.system && !entry.system && latest.session_id === entry.session_id && latest.provider === entry.provider && latest.agent_responses.length === 0;
+      if (mergeable) {
+        latest.messages = [...latest.messages, ...entry.messages];
+        lines[lines.length - 1] = JSON.stringify(latest);
+        const tmpPath = join5(timelineDir, `.${filename}.tmp`);
+        writeFileSync6(tmpPath, lines.join(`
+`) + `
+`);
+        renameSync2(tmpPath, filePath);
+        return true;
+      }
+    }
+    appendFileSync(filePath, JSON.stringify(entry) + `
+`);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    releaseLock(lockPath);
   }
 }
-function resolveHomePath(relativePath, deps = {}) {
-  return path6.join(deps.homeDir || process.env.HOME || ".", relativePath);
+function updateLatestEntry(timelineDir, updater, opts = {}) {
+  const now = opts.now ?? new Date;
+  const maxDays = opts.maxDays ?? 7;
+  for (const filename of recentFilenames(maxDays, now)) {
+    const filePath = join5(timelineDir, filename);
+    if (!existsSync2(filePath))
+      continue;
+    const lockPath = lockPathFor(timelineDir, filename);
+    if (!acquireLock(lockPath))
+      continue;
+    try {
+      let content;
+      try {
+        content = readFileSync4(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      const lines = content.trimEnd().split(`
+`).filter(Boolean);
+      if (lines.length === 0)
+        continue;
+      const entries = lines.map((l) => JSON.parse(l));
+      const latest = entries[entries.length - 1];
+      if (latest.system)
+        return false;
+      updater(latest);
+      const tmpPath = join5(timelineDir, `.${filename}.tmp`);
+      writeFileSync6(tmpPath, entries.map((e) => JSON.stringify(e)).join(`
+`) + `
+`);
+      renameSync2(tmpPath, filePath);
+      return true;
+    } catch {} finally {
+      releaseLock(lockPath);
+    }
+  }
+  return false;
 }
-function resolveSpawnSpec(command, args, deps = {}, platform = process.platform) {
-  const resolved = resolveCommandOnPath(command, deps) ?? command;
-  return { command: resolved, args, shell: needsWindowsShimShell(resolved, platform) };
+function createTimelineEntry(fields) {
+  return {
+    session_id: fields.sessionId ?? null,
+    messages: fields.messages,
+    agent_responses: [],
+    provider: fields.provider ?? null
+  };
 }
-function resolveClaudeCommand(deps = {}) {
-  const onPath = resolveCommandOnPath("claude", deps);
-  if (onPath)
-    return onPath;
-  if (process.platform === "darwin") {
-    return firstExistingPath([
-      resolveHomePath("Applications/Claude Code URL Handler.app/Contents/MacOS/claude", deps),
-      "/Applications/Claude Code URL Handler.app/Contents/MacOS/claude"
-    ]);
+function createSystemEntry(type, time) {
+  return {
+    session_id: null,
+    messages: [],
+    agent_responses: [],
+    provider: null,
+    system: { type, time }
+  };
+}
+function findResumableSession(rows, provider) {
+  for (let i = rows.length - 1;i >= 0; i--) {
+    const e = rows[i];
+    if (e.system?.type === "reset_session")
+      return null;
+    if (!e.session_id)
+      continue;
+    if (provider && e.provider !== provider)
+      continue;
+    return e.session_id;
   }
   return null;
 }
-function probeClaude(deps = {}) {
-  const command = resolveClaudeCommand(deps);
-  if (!command)
-    return { status: "unhealthy", lastError: "not_on_path" };
-  const r = probeCommandVersion(command, [], deps);
-  if (!r.ok)
-    return { status: "unhealthy", lastError: r.error };
-  return { status: "healthy", version: r.version };
+// src/timeline/recorder.ts
+import { mkdirSync as mkdirSync5 } from "fs";
+function createTimelineRecorder(opts) {
+  const now = opts.now ?? (() => new Date);
+  const dirFor = (agentId) => opts.timelineDirFor(agentId);
+  const sessionByAgent = new Map;
+  return {
+    setSession(agentId, sessionId) {
+      sessionByAgent.set(agentId, sessionId);
+    },
+    appendEntryForAgent(agentId, messages) {
+      const dir = dirFor(agentId);
+      try {
+        mkdirSync5(dir, { recursive: true });
+      } catch {}
+      appendOrMergeEntry(dir, createTimelineEntry({
+        messages,
+        sessionId: sessionByAgent.get(agentId) ?? null,
+        provider: opts.providerFor?.(agentId) ?? null
+      }), now());
+    },
+    appendResponseToLatest(agentId, text) {
+      const dir = dirFor(agentId);
+      const updated = updateLatestEntry(dir, (e) => e.agent_responses.push(text), { now: now() });
+      if (updated)
+        return;
+      try {
+        mkdirSync5(dir, { recursive: true });
+      } catch {}
+      const entry = createTimelineEntry({
+        messages: [],
+        sessionId: sessionByAgent.get(agentId) ?? null,
+        provider: opts.providerFor?.(agentId) ?? null
+      });
+      entry.agent_responses.push(text);
+      appendEntry(dir, entry, now());
+    },
+    resumeSessionId(agentId, provider) {
+      const rows = readRecentEntries(dirFor(agentId), { now: now() });
+      return findResumableSession(rows, provider ?? undefined);
+    },
+    forgetSession(agentId) {
+      const dir = dirFor(agentId);
+      try {
+        mkdirSync5(dir, { recursive: true });
+      } catch {}
+      sessionByAgent.delete(agentId);
+      const stamp = now();
+      appendEntry(dir, createSystemEntry("reset_session", stamp.toISOString()), stamp);
+    }
+  };
 }
-function probeCliRuntime(binary, deps = {}) {
-  const command = resolveCommandOnPath(binary, deps);
-  if (!command)
-    return { status: "unhealthy", lastError: "not_on_path" };
-  const r = probeCommandVersion(command, [], deps);
-  if (!r.ok)
-    return { status: "unhealthy", lastError: r.error };
-  return { status: "healthy", version: r.version };
+// src/discovery.ts
+import * as path9 from "path";
+import * as fs8 from "fs";
+import { fileURLToPath } from "url";
+
+// src/drivers/claudeProviderIsolation.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+function buildClaudeProviderIsolationEnv(ctx) {
+  const hasCustomProvider = Boolean(process.env.ANTHROPIC_BASE_URL && process.env.ANTHROPIC_API_KEY);
+  if (!hasCustomProvider)
+    return {};
+  const root = path5.join(ctx.workingDirectory, ".alook", "claude-provider");
+  const home = path5.join(root, "home");
+  const configDir = path5.join(home, ".claude");
+  fs6.mkdirSync(configDir, { recursive: true });
+  const hostClaude = path5.join(process.env.HOME || ".", ".claude");
+  for (const sub of ["skills", "commands"]) {
+    const target = path5.join(hostClaude, sub);
+    const link = path5.join(configDir, sub);
+    try {
+      if (fs6.existsSync(target) && !fs6.existsSync(link))
+        fs6.symlinkSync(target, link);
+    } catch {}
+  }
+  return {
+    HOME: home,
+    USERPROFILE: home,
+    CLAUDE_CONFIG_DIR: configDir,
+    CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: "1"
+  };
 }
 
 // src/drivers/claudeLaunch.ts
-var DEFAULT_CLAUDE_MODEL = "sonnet";
 var CLAUDE_DISALLOWED_TOOLS = "EnterPlanMode,ExitPlanMode,ScheduleWakeup,CronCreate,CronList,CronDelete";
 function buildClaudeArgs(config) {
   const f = resolveLaunchFieldsOrDefault(config.runtimeConfig);
@@ -2904,11 +3022,11 @@ function buildClaudeArgs(config) {
     "--input-format",
     "stream-json",
     "--include-partial-messages",
-    "--model",
-    f.model || DEFAULT_CLAUDE_MODEL,
     "--disallowed-tools",
     f.disallowedTools || CLAUDE_DISALLOWED_TOOLS
   ];
+  if (f.model)
+    args.push("--model", f.model);
   if (f.reasoningEffort)
     args.push("--effort", f.reasoningEffort);
   if (f.fastMode)
@@ -2917,14 +3035,24 @@ function buildClaudeArgs(config) {
     args.push("--resume", config.sessionId);
   return args;
 }
-function resolveClaudeLaunchCommand(config) {
-  const override = resolveLaunchFieldsOrDefault(config.runtimeConfig).command?.trim();
-  return override || resolveClaudeCommand() || "claude";
+
+// src/drivers/utils.ts
+import { randomUUID } from "crypto";
+function writeToStdinAndDetach(proc, payload) {
+  queueMicrotask(() => {
+    proc.stdin?.write(payload);
+    proc.stdin?.end();
+  });
+}
+function jsonRpcRequest(method, params, id) {
+  return JSON.stringify({ jsonrpc: "2.0", id: id ?? randomUUID(), method, params });
 }
-function buildClaudeSpawnSpec(claudeCommand, platform = process.platform) {
-  const command = claudeCommand ?? "claude";
-  const shell = platform === "win32" && (!command || /\.(cmd|bat)$/i.test(command));
-  return { command, shell };
+function tryParseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
 }
 
 // src/drivers/claudeEventNormalizer.ts
@@ -2936,12 +3064,9 @@ class ClaudeEventNormalizer {
     return this.currentSession;
   }
   normalizeLine(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
+    const event = tryParseJsonLine(line);
+    if (!event)
       return [];
-    }
     if (event?.session_id)
       this.currentSession = event.session_id;
     const out = [];
@@ -3045,6 +3170,102 @@ class ClaudeEventNormalizer {
   }
 }
 
+// src/drivers/probe.ts
+import { execFileSync } from "child_process";
+import * as fs7 from "fs";
+import * as path6 from "path";
+var PROBE_TIMEOUT_MS = 5000;
+function resolveCommandOnPath(command, deps = {}) {
+  if (deps.which)
+    return deps.which(command);
+  try {
+    if (process.platform === "win32") {
+      const out2 = execFileSync("where", [command], { encoding: "utf8", timeout: PROBE_TIMEOUT_MS });
+      const first = out2.split(/\r?\n/).find((line) => line.trim().length > 0);
+      return first?.trim() || null;
+    }
+    const out = execFileSync("which", [command], { encoding: "utf8", timeout: PROBE_TIMEOUT_MS });
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function firstExistingPath(candidates) {
+  for (const c of candidates) {
+    if (c && fs7.existsSync(c))
+      return c;
+  }
+  return null;
+}
+function looksLikeVersion(line) {
+  return /\d+\.\d+/.test(line);
+}
+function needsWindowsShimShell(command, platform) {
+  return platform === "win32" && /\.(cmd|bat)$/i.test(command);
+}
+function probeCommandVersion(command, args = [], deps = {}, platform = process.platform) {
+  try {
+    const shell = needsWindowsShimShell(command, platform);
+    const out = execFileSync(command, [...args, "--version"], {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+      shell,
+      input: "",
+      env: { ...process.env, CI: "1" }
+    });
+    const line = out.split(`
+`)[0]?.trim();
+    if (!line)
+      return { ok: false, error: "empty_version_output" };
+    if (!looksLikeVersion(line))
+      return { ok: false, error: "invalid_version_output" };
+    return { ok: true, version: line };
+  } catch (err) {
+    const code = err?.code ?? err?.code ?? "version_probe_failed";
+    return { ok: false, error: String(code) };
+  }
+}
+function resolveHomePath(relativePath, deps = {}) {
+  return path6.join(deps.homeDir || process.env.HOME || ".", relativePath);
+}
+function resolveSpawnSpec(command, args, override, deps = {}, platform = process.platform) {
+  const trimmed = override?.trim();
+  const target = trimmed && trimmed.length > 0 ? trimmed : command;
+  const looksLikePath = trimmed !== undefined && trimmed.length > 0 && /[\\/]/.test(trimmed);
+  const resolved = looksLikePath ? target : resolveCommandOnPath(target, deps) ?? target;
+  return { command: resolved, args, shell: needsWindowsShimShell(resolved, platform) };
+}
+function resolveClaudeCommand(deps = {}) {
+  const onPath = resolveCommandOnPath("claude", deps);
+  if (onPath)
+    return onPath;
+  if (process.platform === "darwin") {
+    return firstExistingPath([
+      resolveHomePath("Applications/Claude Code URL Handler.app/Contents/MacOS/claude", deps),
+      "/Applications/Claude Code URL Handler.app/Contents/MacOS/claude"
+    ]);
+  }
+  return null;
+}
+function probeClaude(deps = {}) {
+  const command = resolveClaudeCommand(deps);
+  if (!command)
+    return { status: "unhealthy", lastError: "not_on_path" };
+  const r = probeCommandVersion(command, [], deps);
+  if (!r.ok)
+    return { status: "unhealthy", lastError: r.error };
+  return { status: "healthy", version: r.version };
+}
+function probeCliRuntime(binary, deps = {}) {
+  const command = resolveCommandOnPath(binary, deps);
+  if (!command)
+    return { status: "unhealthy", lastError: "not_on_path" };
+  const r = probeCommandVersion(command, [], deps);
+  if (!r.ok)
+    return { status: "unhealthy", lastError: r.error };
+  return { status: "healthy", version: r.version };
+}
+
 // src/drivers/claude.ts
 class ClaudeDriver {
   id = "claude";
@@ -3057,6 +3278,13 @@ class ClaudeDriver {
   supportsStdinNotification = true;
   busyDeliveryMode = "gated";
   supportsNativeStandingPrompt = true;
+  capabilities = {
+    reasoningEffort: true,
+    fastMode: true,
+    disallowedTools: true,
+    command: true,
+    sessionResumeMode: "by-id"
+  };
   eventNormalizer = new ClaudeEventNormalizer;
   probe() {
     return probeClaude();
@@ -3066,12 +3294,13 @@ class ClaudeDriver {
     const { spawnEnv } = await prepareCliTransport(ctx, buildClaudeProviderIsolationEnv(ctx), cliConfig);
     const args = buildClaudeArgs(ctx.config);
     delete spawnEnv.CLAUDECODE;
-    const claudeCommand = resolveClaudeLaunchCommand(ctx.config);
-    const spawnSpec = buildClaudeSpawnSpec(claudeCommand);
-    const proc = spawnAgentProcess(spawnSpec.command, args, {
+    const override = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig).command?.trim();
+    const claudeCommand = override || resolveClaudeCommand() || "claude";
+    const spec = resolveSpawnSpec("claude", args, claudeCommand);
+    const proc = spawnAgentProcess(spec.command, spec.args, {
       cwd: ctx.workingDirectory,
       env: spawnEnv,
-      shell: spawnSpec.shell
+      shell: spec.shell
     });
     const stdinMsg = JSON.stringify({
       type: "user",
@@ -3096,7 +3325,7 @@ class ClaudeDriver {
     });
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
@@ -3153,12 +3382,9 @@ class CodexEventNormalizer {
     this.threadId = threadId;
   }
   normalizeLine(line) {
-    let msg;
-    try {
-      msg = JSON.parse(line);
-    } catch {
+    const msg = tryParseJsonLine(line);
+    if (!msg)
       return [];
-    }
     if (msg?.error && msg.id !== undefined) {
       return [{ kind: "error", message: msg.error?.message ?? "Codex RPC error" }];
     }
@@ -3274,6 +3500,21 @@ function resolveCodexHomeRootFromEnv(env = process.env, opts = {}) {
   return path7.join(opts.defaultHomeDir ?? os2.homedir(), ".codex");
 }
 
+// src/version.ts
+import { createRequire as createRequire2 } from "module";
+var requireFromHere = createRequire2(import.meta.url);
+function readDaemonVersion() {
+  try {
+    const pkg = requireFromHere("../package.json");
+    return pkg.version ?? "";
+  } catch {
+    return "";
+  }
+}
+function getDaemonClientInfo() {
+  return { name: "alook-daemon", version: readDaemonVersion() };
+}
+
 // src/drivers/codex.ts
 class CodexDriver {
   id = "codex";
@@ -3286,6 +3527,13 @@ class CodexDriver {
   supportsStdinNotification = true;
   busyDeliveryMode = "gated";
   supportsNativeStandingPrompt = true;
+  capabilities = {
+    reasoningEffort: true,
+    fastMode: true,
+    disallowedTools: false,
+    command: true,
+    sessionResumeMode: "by-id"
+  };
   eventNormalizer = new CodexEventNormalizer;
   requestId = 0;
   codexHomeRoot = null;
@@ -3299,24 +3547,17 @@ class CodexDriver {
     return probeCliRuntime("codex");
   }
   async spawn(ctx) {
-    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const { spawnEnv } = await prepareCliTransport(ctx);
     this.codexHomeRoot = resolveCodexHomeRootFromEnv(spawnEnv, { cwd: ctx.workingDirectory });
-    const spec = resolveSpawnSpec("codex", ["app-server", "--listen", "stdio://"]);
+    const override = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig).command;
+    const spec = resolveSpawnSpec("codex", ["app-server", "--listen", "stdio://"], override);
     const proc = spawnAgentProcess(spec.command, spec.args, {
       cwd: ctx.workingDirectory,
       env: spawnEnv,
       shell: spec.shell
     });
     queueMicrotask(() => {
-      proc.stdin?.write(JSON.stringify({
-        jsonrpc: "2.0",
-        id: this.nextRequestId(),
-        method: "initialize",
-        params: {
-          clientInfo: { name: "agent-backend", version: "1.0.0" },
-          capabilities: { experimentalApi: true }
-        }
-      }) + `
+      proc.stdin?.write(jsonRpcRequest("initialize", { clientInfo: getDaemonClientInfo(), capabilities: { experimentalApi: true } }, this.nextRequestId()) + `
 `);
       const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
       const resuming = Boolean(ctx.config.sessionId);
@@ -3335,12 +3576,7 @@ class CodexDriver {
         params.config = { model_reasoning_effort: f.reasoningEffort };
       if (f.fastMode)
         params.serviceTier = "fast";
-      proc.stdin?.write(JSON.stringify({
-        jsonrpc: "2.0",
-        id: this.nextRequestId(),
-        method: resuming ? "thread/resume" : "thread/start",
-        params
-      }) + `
+      proc.stdin?.write(jsonRpcRequest(resuming ? "thread/resume" : "thread/start", params, this.nextRequestId()) + `
 `);
     });
     return { process: proc };
@@ -3356,23 +3592,11 @@ class CodexDriver {
     if (!threadId)
       return null;
     const input = [{ type: "text", text }];
-    if (opts?.mode === "idle") {
-      return JSON.stringify({
-        jsonrpc: "2.0",
-        id: this.nextRequestId(),
-        method: "turn/start",
-        params: { threadId, input }
-      });
-    }
-    return JSON.stringify({
-      jsonrpc: "2.0",
-      id: this.nextRequestId(),
-      method: "turn/steer",
-      params: { threadId, input }
-    });
+    const method = opts?.mode === "idle" ? "turn/start" : "turn/steer";
+    return jsonRpcRequest(method, { threadId, input }, this.nextRequestId());
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
@@ -3400,37 +3624,42 @@ class GeminiDriver {
   };
   session = { recovery: "resume_or_fresh" };
   model = {
-    detectedModelsVerifiedAs: "suggestion_only",
-    toLaunchSpec: (modelId) => modelId && modelId !== "default" ? { args: ["--model", modelId] } : { args: [] }
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => modelId ? { args: ["--model", modelId] } : { args: [] }
   };
   supportsStdinNotification = false;
   busyDeliveryMode = "none";
+  capabilities = {
+    reasoningEffort: false,
+    fastMode: false,
+    disallowedTools: false,
+    command: true,
+    sessionResumeMode: "by-id"
+  };
   sessionId = null;
   probe() {
     return probeCliRuntime("gemini");
   }
   async spawn(ctx) {
     this.sessionId = ctx.config.sessionId ?? null;
-    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const { spawnEnv } = await prepareCliTransport(ctx);
     spawnEnv.GEMINI_CLI_TRUST_WORKSPACE ??= "true";
     if (process.platform === "win32")
       spawnEnv.GEMINI_PTY_INFO ??= "child_process";
-    const spec = resolveSpawnSpec("gemini", buildGeminiArgs(ctx.config));
+    const override = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig).command;
+    const spec = resolveSpawnSpec("gemini", buildGeminiArgs(ctx.config), override);
     const proc = spawnAgentProcess(spec.command, spec.args, {
       cwd: ctx.workingDirectory,
       env: spawnEnv,
       shell: spec.shell
     });
-    proc.stdin?.end(ctx.prompt);
+    writeToStdinAndDetach(proc, ctx.prompt);
     return { process: proc };
   }
   parseLine(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
+    const event = tryParseJsonLine(line);
+    if (!event)
       return [];
-    }
     switch (event?.type) {
       case "init":
         this.sessionId = event.session_id ?? this.sessionId;
@@ -3456,7 +3685,7 @@ class GeminiDriver {
     return null;
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
@@ -3476,13 +3705,20 @@ class CopilotDriver {
   };
   supportsStdinNotification = false;
   busyDeliveryMode = "none";
+  capabilities = {
+    reasoningEffort: true,
+    fastMode: false,
+    disallowedTools: false,
+    command: true,
+    sessionResumeMode: "by-id"
+  };
   sessionId = null;
   probe() {
     return probeCliRuntime("copilot");
   }
   async spawn(ctx) {
     this.sessionId = ctx.config.sessionId ?? null;
-    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const { spawnEnv } = await prepareCliTransport(ctx);
     const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
     const args = ["--output-format", "json", "--allow-all-tools", "--allow-all-paths", "-p", ctx.prompt];
     if (f.model)
@@ -3491,7 +3727,7 @@ class CopilotDriver {
       args.push("--effort", f.reasoningEffort);
     if (ctx.config.sessionId)
       args.push(`--resume=${ctx.config.sessionId}`);
-    const spec = resolveSpawnSpec("copilot", args);
+    const spec = resolveSpawnSpec("copilot", args, f.command);
     const proc = spawnAgentProcess(spec.command, spec.args, {
       cwd: ctx.workingDirectory,
       env: spawnEnv,
@@ -3500,12 +3736,9 @@ class CopilotDriver {
     return { process: proc };
   }
   parseLine(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
+    const event = tryParseJsonLine(line);
+    if (!event)
       return [];
-    }
     switch (event?.type) {
       case "assistant.turn_start":
         if (event.sessionId)
@@ -3540,7 +3773,7 @@ class CopilotDriver {
     return null;
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
@@ -3560,13 +3793,20 @@ class CursorDriver {
   };
   supportsStdinNotification = false;
   busyDeliveryMode = "none";
+  capabilities = {
+    reasoningEffort: false,
+    fastMode: false,
+    disallowedTools: false,
+    command: true,
+    sessionResumeMode: "by-id"
+  };
   sessionId = null;
   probe() {
     return probeCliRuntime("cursor-agent");
   }
   async spawn(ctx) {
     this.sessionId = ctx.config.sessionId ?? null;
-    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const { spawnEnv } = await prepareCliTransport(ctx);
     const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
     const args = ["--print", "--output-format", "stream-json", "--yolo", "--approve-mcps", "--trust"];
     if (f.model)
@@ -3574,7 +3814,7 @@ class CursorDriver {
     if (ctx.config.sessionId)
       args.push("--resume", ctx.config.sessionId);
     args.push(ctx.prompt);
-    const spec = resolveSpawnSpec("cursor-agent", args);
+    const spec = resolveSpawnSpec("cursor-agent", args, f.command);
     const proc = spawnAgentProcess(spec.command, spec.args, {
       cwd: ctx.workingDirectory,
       env: spawnEnv,
@@ -3583,12 +3823,9 @@ class CursorDriver {
     return { process: proc };
   }
   parseLine(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
+    const event = tryParseJsonLine(line);
+    if (!event)
       return [];
-    }
     if (event?.type === "system") {
       if (event.subtype === "init") {
         this.sessionId = event.session_id ?? this.sessionId;
@@ -3631,7 +3868,7 @@ class CursorDriver {
     return null;
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
@@ -3653,6 +3890,13 @@ class OpenCodeDriver {
   busyDeliveryMode = "none";
   terminateProcessOnTurnEnd = true;
   deferSpawnUntilMessage = true;
+  capabilities = {
+    reasoningEffort: false,
+    fastMode: false,
+    disallowedTools: false,
+    command: true,
+    sessionResumeMode: "by-id"
+  };
   sessionId = null;
   shouldDeferWakeMessage(message) {
     return message?.type === "system";
@@ -3663,7 +3907,7 @@ class OpenCodeDriver {
   async spawn(ctx) {
     this.sessionId = ctx.config.sessionId ?? null;
     const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
-    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const { spawnEnv } = await prepareCliTransport(ctx);
     const args = ["run", "--format", "json", "--dangerously-skip-permissions", "--pure", "--dir", ctx.workingDirectory];
     if (f.model)
       args.push("--model", f.model);
@@ -3671,7 +3915,7 @@ class OpenCodeDriver {
       args.push("--session", ctx.config.sessionId);
     const promptArg = ctx.prompt === ctx.standingPrompt ? "No new messages are pending. Stop now." : ctx.prompt;
     args.push("--", promptArg);
-    const spec = resolveSpawnSpec("opencode", args);
+    const spec = resolveSpawnSpec("opencode", args, f.command);
     const proc = spawnAgentProcess(spec.command, spec.args, {
       cwd: ctx.workingDirectory,
       env: spawnEnv,
@@ -3681,12 +3925,9 @@ class OpenCodeDriver {
     return { process: proc };
   }
   parseLine(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
+    const event = tryParseJsonLine(line);
+    if (!event)
       return [];
-    }
     const out = [];
     if (event?.sessionID && this.sessionId !== event.sessionID) {
       this.sessionId = event.sessionID;
@@ -3724,12 +3965,12 @@ class OpenCodeDriver {
     return null;
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
 // src/drivers/antigravity.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var ERROR_LINE_PATTERNS = [/^error[:\s]/i, /\bfatal\b/i, /\bpanic\b/i, /unable to/i];
 var ANTIGRAVITY_PRINT_TIMEOUT = "30m";
 function buildAntigravityArgs(ctx) {
@@ -3754,27 +3995,34 @@ class AntigravityDriver {
   };
   supportsStdinNotification = false;
   busyDeliveryMode = "none";
+  capabilities = {
+    reasoningEffort: false,
+    fastMode: false,
+    disallowedTools: false,
+    command: true,
+    sessionResumeMode: "most-recent"
+  };
   sessionId = null;
   sentInit = false;
   probe() {
     return probeCliRuntime("agy");
   }
   async spawn(ctx) {
-    this.sessionId = ctx.config.sessionId ?? randomUUID();
+    this.sessionId = ctx.config.sessionId ?? randomUUID2();
     this.sentInit = false;
     const { spawnEnv } = await prepareCliTransport(ctx, {
-      NO_COLOR: "1",
       SSH_CLIENT: "",
       SSH_CONNECTION: "",
       SSH_TTY: ""
     });
-    const spec = resolveSpawnSpec("agy", buildAntigravityArgs(ctx));
+    const override = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig).command;
+    const spec = resolveSpawnSpec("agy", buildAntigravityArgs(ctx), override);
     const proc = spawnAgentProcess(spec.command, spec.args, {
       cwd: ctx.workingDirectory,
       env: spawnEnv,
       shell: spec.shell
     });
-    proc.stdin?.end(ctx.prompt);
+    writeToStdinAndDetach(proc, ctx.prompt);
     return { process: proc };
   }
   parseLine(line) {
@@ -3799,12 +4047,13 @@ class AntigravityDriver {
     return null;
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
 // src/drivers/kimi.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
+var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 function parseToolArguments(args) {
   if (typeof args !== "string")
     return args ?? {};
@@ -3825,55 +4074,49 @@ class KimiDriver {
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
+  capabilities = {
+    reasoningEffort: false,
+    fastMode: false,
+    disallowedTools: false,
+    command: true,
+    sessionResumeMode: "by-id"
+  };
   sessionId = "";
   sentInit = false;
-  promptRequestId = randomUUID2();
+  promptRequestId = randomUUID3();
   probe() {
     return probeCliRuntime("kimi");
   }
   async spawn(ctx) {
-    this.sessionId = ctx.config.sessionId || randomUUID2();
+    this.sessionId = ctx.config.sessionId || randomUUID3();
     const isResume = Boolean(ctx.config.sessionId);
-    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const { spawnEnv } = await prepareCliTransport(ctx);
     const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
     const args = ["--wire", "--yolo", "--session", this.sessionId];
     if (f.model)
       args.push("--model", f.model);
-    const spec = resolveSpawnSpec("kimi", args);
+    const spec = resolveSpawnSpec("kimi", args, f.command);
     const proc = spawnAgentProcess(spec.command, spec.args, {
       cwd: ctx.workingDirectory,
       env: spawnEnv,
       shell: spec.shell
     });
-    proc.stdin?.write(JSON.stringify({
-      jsonrpc: "2.0",
-      id: randomUUID2(),
-      method: "initialize",
-      params: {
-        protocol_version: "1.3",
-        client: { name: "agent-backend", version: "1.0.0" },
-        capabilities: { supports_question: false, supports_plan_mode: false }
-      }
+    proc.stdin?.write(jsonRpcRequest("initialize", {
+      protocol_version: KIMI_WIRE_PROTOCOL_VERSION,
+      client: getDaemonClientInfo(),
+      capabilities: { supports_question: false, supports_plan_mode: false }
     }) + `
 `);
-    proc.stdin?.write(JSON.stringify({
-      jsonrpc: "2.0",
-      id: this.promptRequestId,
-      method: "prompt",
-      params: {
-        user_input: isResume ? ctx.prompt : "Your system prompt contains your standing instructions. Follow it now and begin listening for messages."
-      }
-    }) + `
+    proc.stdin?.write(jsonRpcRequest("prompt", {
+      user_input: isResume ? ctx.prompt : "Your system prompt contains your standing instructions. Follow it now and begin listening for messages."
+    }, this.promptRequestId) + `
 `);
     return { process: proc };
   }
   parseLine(line) {
-    let msg;
-    try {
-      msg = JSON.parse(line);
-    } catch {
+    const msg = tryParseJsonLine(line);
+    if (!msg)
       return [];
-    }
     const out = [];
     if (!this.sentInit) {
       this.sentInit = true;
@@ -3925,16 +4168,17 @@ class KimiDriver {
   }
   encodeStdinMessage(text, _sessionId, opts) {
     const method = opts?.mode === "idle" ? "prompt" : "steer";
-    return JSON.stringify({ jsonrpc: "2.0", id: randomUUID2(), method, params: { user_input: text } });
+    return jsonRpcRequest(method, { user_input: text });
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
 // src/drivers/pi.ts
-import { createRequire as createRequire2 } from "module";
-import { mkdirSync as mkdirSync7, existsSync as existsSync5, readFileSync as readFileSync5, realpathSync } from "fs";
+import { createRequire as createRequire3 } from "module";
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
 import * as path8 from "path";
 
 // src/runtime/sdkRuntimeSession.ts
@@ -4044,6 +4288,24 @@ function resolvePiSdkPackageDir(deps = {}) {
   } catch {}
   return;
 }
+function findPiSessionFile(sessionDir, sessionId) {
+  let entries;
+  try {
+    entries = readdirSync(sessionDir);
+  } catch {
+    return null;
+  }
+  const suffix = `_${sessionId}.jsonl`;
+  const match = entries.find((entry) => entry.endsWith(suffix));
+  return match ? path8.join(sessionDir, match) : null;
+}
+function resolvePiSessionDir(sdk, cwd) {
+  if (typeof sdk.getDefaultSessionDir === "function")
+    return sdk.getDefaultSessionDir(cwd);
+  const agentDir = typeof sdk.getAgentDir === "function" ? sdk.getAgentDir() : path8.join(homedir2(), ".pi", "agent");
+  const encoded = `--${path8.resolve(cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+  return path8.join(agentDir, "sessions", encoded);
+}
 function resolvePiSdkVersionFromPath(deps = {}) {
   const dir = resolvePiSdkPackageDir(deps);
   if (!dir)
@@ -4057,7 +4319,7 @@ function resolvePiSdkVersionFromPath(deps = {}) {
 }
 function readPiSdkVersion() {
   try {
-    const req = createRequire2(import.meta.url);
+    const req = createRequire3(import.meta.url);
     const pkg = req("@earendil-works/pi-coding-agent/package.json");
     if (pkg.version)
       return pkg.version;
@@ -4108,6 +4370,13 @@ class PiDriver {
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
   supportsNativeStandingPrompt = true;
+  capabilities = {
+    reasoningEffort: true,
+    fastMode: false,
+    disallowedTools: false,
+    command: true,
+    sessionResumeMode: "by-id"
+  };
   sessionId = null;
   probe() {
     const version = readPiSdkVersion();
@@ -4121,10 +4390,6 @@ class PiDriver {
   }
   async createSession(ctx, deps) {
     const spawnEnv = await deps.buildSpawnEnv();
-    if (ctx.standingPrompt) {
-      mkdirSync7(ctx.workingDirectory, { recursive: true });
-      writeAgentFile(ctx.workingDirectory, ctx.standingPrompt);
-    }
     const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
     const { session, sessionId } = await deps.createAgentSession({
       cwd: ctx.workingDirectory,
@@ -4158,7 +4423,7 @@ class PiDriver {
     return null;
   }
   buildSystemPrompt(config) {
-    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+    return buildCliTransportSystemPrompt(config);
   }
 }
 
@@ -4261,7 +4526,21 @@ async function importPiSdkFromGlobalInstall() {
   const pkg = JSON.parse(readFileSync6(path10.join(dir, "package.json"), "utf-8"));
   const entry = pkg.exports?.["."]?.import ?? pkg.main ?? "./dist/index.js";
   const entryPath = path10.join(dir, entry);
-  return import(pathToFileURL(entryPath).href);
+  const barrel = await import(pathToFileURL(entryPath).href);
+  return withSessionDirHelper(barrel, entryPath);
+}
+async function withSessionDirHelper(barrel, entryPath) {
+  if (typeof barrel.getDefaultSessionDir === "function")
+    return barrel;
+  try {
+    const deepPath = path10.join(path10.dirname(entryPath), "core", "session-manager.js");
+    const deep = await import(pathToFileURL(deepPath).href);
+    if (typeof deep.getDefaultSessionDir !== "function")
+      return barrel;
+    return { ...barrel, getDefaultSessionDir: deep.getDefaultSessionDir };
+  } catch {
+    return barrel;
+  }
 }
 function loadPiSdkModule() {
   if (!cachedSdkPromise) {
@@ -4304,7 +4583,15 @@ function createPiSdkDriverDeps(ctx, loadSdk = loadPiSdkModule) {
       const parsed = parseModelString(opts.model);
       const model = parsed ? modelRegistry.find(parsed.provider, parsed.id) : undefined;
       const cwd = opts.cwd;
-      const sessionManager = opts.sessionId ? sdk.SessionManager.continueRecent(cwd) : sdk.SessionManager.create(cwd);
+      const requestedSessionId = opts.sessionId;
+      let sessionManager;
+      if (requestedSessionId) {
+        const sessionDir = resolvePiSessionDir(sdk, cwd);
+        const existingFile = findPiSessionFile(sessionDir, requestedSessionId);
+        sessionManager = existingFile ? sdk.SessionManager.open(existingFile, sessionDir, cwd) : sdk.SessionManager.create(cwd, sessionDir, { id: requestedSessionId });
+      } else {
+        sessionManager = sdk.SessionManager.create(cwd);
+      }
       const spawnEnv = opts.spawnEnv;
       const bashTool = sdk.createBashToolDefinition(cwd, {
         spawnHook: (spawnCtx) => ({ ...spawnCtx, env: { ...spawnCtx.env, ...spawnEnv } })
@@ -4357,7 +4644,7 @@ function emitImplicitTypingStopOnSend(args) {
 }
 async function createDaemon(opts) {
   const log = opts.logger ?? createLogger({ header: "@alook/daemon" });
-  const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir2()}/.alook`) + "/daemon";
+  const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir3()}/.alook`) + "/daemon";
   const workdirFor = (agentId) => `${opts.workingDirectoryBase ?? fallbackBase}/${agentId}`;
   const resolvedCliPath = resolveAlookCliPathWithFallback(opts.agentCliPath);
   const timeline2 = createTimelineRecorder({
@@ -4652,6 +4939,11 @@ async function createDaemon(opts) {
   await router.start();
   return {
     isOpen: () => channel.status === "open",
+    onOpen: (hook) => {
+      channel.onOpen(hook);
+      if (channel.status === "open")
+        queueMicrotask(hook);
+    },
     proxyUrl: proxy.url,
     stop: async () => {
       for (const agentId of [...typingHeartbeats.keys()]) {
@@ -4665,24 +4957,19 @@ async function createDaemon(opts) {
 }
 
 // src/cli/daemonStart.ts
-var requireFromHere = createRequire3(import.meta.url);
-function readDaemonVersion() {
-  try {
-    const pkg = requireFromHere("../../package.json");
-    return pkg.version ?? "";
-  } catch {
-    return "";
-  }
-}
 var CAPABILITIES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge", "attach"];
+var STOP_GRACE_MS = 5000;
+var POLL_MS2 = 100;
+var MACHINE_KEY_HASH_PREFIX_LEN = 12;
+var MACHINE_KEY_DISPLAY_PREFIX_LEN = 20;
 function resolveDefaultBaseDir() {
-  const root = process.env.ALOOK_PROJECT_ROOT || path11.join(homedir3(), ".alook");
+  const root = process.env.ALOOK_PROJECT_ROOT || path11.join(homedir4(), ".alook");
   return path11.join(root, "daemon");
 }
 var DEFAULT_BASE_DIR = resolveDefaultBaseDir();
 var log = createLogger({ header: "@alook/daemon" });
 function keyHash(machineKey) {
-  return crypto2.createHash("sha256").update(machineKey).digest("hex").slice(0, 12);
+  return crypto2.createHash("sha256").update(machineKey).digest("hex").slice(0, MACHINE_KEY_HASH_PREFIX_LEN);
 }
 function daemonsDir(baseDir) {
   return path11.join(baseDir, "daemons");
@@ -4750,14 +5037,14 @@ function daemonList(opts) {
     }
     results.push({
       keyHash: file.replace(".pid", ""),
-      keyPrefix: data.key.slice(0, 20) + "…",
+      keyPrefix: data.key.slice(0, MACHINE_KEY_DISPLAY_PREFIX_LEN) + "…",
       pid: data.pid,
       alive
     });
   }
   return results;
 }
-function daemonStop(opts) {
+async function daemonStop(opts) {
   const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
   const pf = pidfilePath(baseDir, opts.machineKey);
   const data = readPidFile(pf);
@@ -4774,13 +5061,12 @@ function daemonStop(opts) {
   }
   log.info(`sending SIGTERM to daemon (pid ${data.pid})…`);
   process.kill(data.pid, "SIGTERM");
-  const deadline = Date.now() + 5000;
+  const deadline = Date.now() + STOP_GRACE_MS;
   while (Date.now() < deadline && isProcessAlive(data.pid)) {
-    const start = Date.now();
-    while (Date.now() - start < 100) {}
+    await new Promise((r) => setTimeout(r, POLL_MS2));
   }
   if (isProcessAlive(data.pid)) {
-    log.error(`daemon (pid ${data.pid}) did not exit in 5s — sending SIGKILL`);
+    log.error(`daemon (pid ${data.pid}) did not exit in ${STOP_GRACE_MS / 1000}s — sending SIGKILL`);
     process.kill(data.pid, "SIGKILL");
   } else {
     log.info("daemon stopped");
@@ -4792,9 +5078,6 @@ function daemonStop(opts) {
 function credentialFilePathByMachineId(baseDir, machineId) {
   return path11.join(daemonsDir(baseDir), `${machineId}.credential.json`);
 }
-function credentialFilesDir(baseDir) {
-  return daemonsDir(baseDir);
-}
 function readCredentialFile(filePath) {
   if (!fs9.existsSync(filePath))
     return null;
@@ -4811,7 +5094,7 @@ function writeCredentialFile(filePath, credential, machineId) {
   fs9.writeFileSync(filePath, JSON.stringify({ credential, machineId }), { mode: 384 });
 }
 function findExistingCredentialForBearer(baseDir, bearer) {
-  const dir = credentialFilesDir(baseDir);
+  const dir = daemonsDir(baseDir);
   if (!fs9.existsSync(dir))
     return null;
   for (const file of fs9.readdirSync(dir)) {
@@ -4922,16 +5205,9 @@ async function daemonStart(opts) {
     }
   });
   log.info(`daemon up — proxy at ${daemon.proxyUrl}, dialing ${wsUrl}`);
-  const readyTimer = setInterval(() => {
-    if (daemon.isOpen()) {
-      clearInterval(readyTimer);
-      log.info("control plane OPEN");
-    }
-  }, 200);
-  readyTimer.unref?.();
+  daemon.onOpen(() => log.info("control plane OPEN"));
   const shutdown = async () => {
     log.info("shutting down…");
-    clearInterval(readyTimer);
     releaseLock2(pf);
     await daemon.stop();
     process.exit(0);
@@ -4954,12 +5230,23 @@ function parseInviteToken(input) {
   return BARE_TOKEN_RE.test(trimmed) ? trimmed : null;
 }
 
+// ../shared/src/constants/community.ts
+var MAX_EMOJI_BYTES = 32;
+var MAX_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
+var MAX_SERVER_ICON_SIZE_BYTES = 5 * 1024 * 1024;
+var MAX_ICON_SOURCE_FILE_SIZE_BYTES = 15 * 1024 * 1024;
+
 // src/cli/index.ts
 function messagesInLocalTime(messages) {
   return messages.map((m) => ({ ...m, time: toLocalISO(m.time) }));
 }
 
 class CliError extends Error {
+  hint;
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+  }
 }
 function printEnvelope(env) {
   const out = {};
@@ -5040,6 +5327,14 @@ async function cmdMessageSend(opts) {
   const channel = opts.target;
   if (!channel)
     throw new CliError("message send: --target <ref> is required (e.g. /demo-workspace/general)");
+  const chaoticLevel = opts.chaotic_level || opts.chaoticLevel;
+  const chaoticHint = "Re-read the Chaos Awareness section in AGENTS.md and reflect before sending.";
+  if (!chaoticLevel || chaoticLevel !== "fine" && chaoticLevel !== "severe") {
+    throw new CliError("message send: --chaotic_level must be 'fine' or 'severe'.", chaoticHint);
+  }
+  if (chaoticLevel === "severe") {
+    throw new CliError("message send: --chaotic_level is 'severe'.", chaoticHint);
+  }
   let text;
   const fileFlag = opts.file;
   const textFlag = opts.text;
@@ -5067,6 +5362,34 @@ async function cmdMessageSend(opts) {
   }
   return { sent: `${res.message.channel}${res.message.seq}` };
 }
+async function cmdMessageEmoji(opts) {
+  const api = getApi();
+  const target = opts.target;
+  const emoji = opts.emoji;
+  if (!target)
+    throw new CliError("message emoji: --target <ref> is required (e.g. /demo/general#42)");
+  if (!emoji)
+    throw new CliError("message emoji: --emoji <string> is required");
+  let parsed;
+  try {
+    parsed = parseRef(target);
+  } catch (err) {
+    throw new CliError(`message emoji: ${err.message}`);
+  }
+  if (parsed.seq === undefined) {
+    const err = new CliError(`message emoji needs a ref with a seq (e.g. ${target}#42)`);
+    err.hint = "pass --target /<server>/<channel>#N, /<server>/<channel>/#N#M for thread reply, or /.dm/<peer>#N";
+    throw err;
+  }
+  if (Buffer.byteLength(emoji, "utf8") > MAX_EMOJI_BYTES) {
+    const err = new CliError("emoji is too long");
+    err.hint = "use a single emoji, not a phrase";
+    throw err;
+  }
+  const channel = parsed.threadRootSeq !== undefined ? `/${parsed.server}/${parsed.channel}/#${parsed.threadRootSeq}` : `/${parsed.server}/${parsed.channel}`;
+  const res = await api.reactAdd({ channel, seq: parsed.seq, emoji });
+  return { target, emoji, duplicate: res.duplicate === true };
+}
 async function cmdAttachmentUpload(opts) {
   const api = getApi();
   const agent = agentId(opts);
@@ -5133,6 +5456,7 @@ async function cmdInboxPull(opts) {
   const { messages, hasMore } = await api.inboxPull({ agentId: agent, max });
   const pulledAt = nowLocalISO();
   let acked = 0;
+  let ackError;
   if (opts.ack !== false && messages.length > 0) {
     const latest = new Map;
     for (const m of messages) {
@@ -5141,10 +5465,20 @@ async function cmdInboxPull(opts) {
       if (!cur || seqN > cur.seq)
         latest.set(m.channel, { channel: m.channel, seq: seqN });
     }
-    await api.ack({ agentId: agent, cursors: [...latest.values()] });
-    acked = latest.size;
+    try {
+      await api.ack({ agentId: agent, cursors: [...latest.values()] });
+      acked = latest.size;
+    } catch (err) {
+      ackError = err instanceof Error ? err.message : String(err);
+    }
   }
-  return { messages: messagesInLocalTime(messages), hasMore, acked, pulledAt };
+  return {
+    messages: messagesInLocalTime(messages),
+    hasMore,
+    acked,
+    pulledAt,
+    ...ackError ? { ackError } : {}
+  };
 }
 async function cmdServerList(opts) {
   const api = getApi();
@@ -5213,12 +5547,18 @@ function buildProgram() {
   }).option("--agent <id>", "agent identity (or ALOOK_AGENT_ID env)");
   const message = program.command("message").description("message operations").exitOverride();
   message.configureOutput({ writeOut: () => {}, writeErr: () => {} });
-  message.command("send").description("send a message to a channel, DM, or thread").option("--target <ref>", "destination (path-style ref, e.g. /demo-workspace/general)").option("--text <text>", "inline message body (short messages)").option("--file <path>", "read message body from a file (long messages)").option("-a, --attachment <id>", "attach an uploaded file by id (repeatable — order = message order)", (v, prev = []) => [...prev, v], []).exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+  message.command("send").description("send a message to a channel, DM, or thread").option("--target <ref>", "destination (path-style ref, e.g. /demo-workspace/general)").option("--text <text>", "inline message body (short messages)").option("--file <path>", "read message body from a file (long messages)").option("-a, --attachment <id>", "attach an uploaded file by id (repeatable — order = message order)", (v, prev = []) => [...prev, v], []).option("--chaotic_level <level>", "chaos level: 'fine' or 'severe' (required)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
     const localOpts = this.opts();
     const globalOpts = program.opts();
     const result = await cmdMessageSend({ ...globalOpts, ...localOpts });
     printEnvelope({ success: result });
   });
+  message.command("emoji").description("react to a message with a single emoji").requiredOption("--target <ref>", "message ref (path-style, e.g. /demo/general#42 or /.dm/peer#7)").requiredOption("--emoji <string>", "single emoji character").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdMessageEmoji({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
   const attachment = message.command("attachment").description("attachment operations").exitOverride();
   attachment.configureOutput({ writeOut: () => {}, writeErr: () => {} });
   attachment.command("upload").description("upload a local file as a pending attachment for a future send").option("--target <ref>", "destination (channel, DM, or thread ref)").option("--file <path>", "local file to upload").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
@@ -5292,9 +5632,9 @@ function buildProgram() {
       baseDir: localOpts.baseDir
     });
   });
-  daemon.command("stop").description("stop the daemon for a specific machine key").requiredOption("--machine-key <key>", "machine key identifying which daemon to stop").option("--base-dir <path>", "data directory (or ALOOK_DATA_DIR env)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(function() {
+  daemon.command("stop").description("stop the daemon for a specific machine key").requiredOption("--machine-key <key>", "machine key identifying which daemon to stop").option("--base-dir <path>", "data directory (or ALOOK_DATA_DIR env)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
     const localOpts = this.opts();
-    daemonStop({
+    await daemonStop({
       machineKey: localOpts.machineKey,
       baseDir: localOpts.baseDir
     });
@@ -5342,8 +5682,13 @@ function getHelpText(program, argv) {
   }
   return cmd.helpInformation();
 }
-var invokedDirectly = typeof process !== "undefined" && process.argv[1] && /(?:^|[\\/])(?:cli[\\/]index\.[jt]s|alook)$/.test(process.argv[1]) && !process.argv[1].includes("vitest") && !process.argv[1].includes("node_modules");
-if (invokedDirectly) {
+var isMainModule = false;
+try {
+  if (typeof process !== "undefined" && process.argv[1]) {
+    isMainModule = import.meta.url === pathToFileURL2(realpathSync2(process.argv[1])).href;
+  }
+} catch {}
+if (isMainModule) {
   main().then((code) => process.exit(code));
 }
 export {