@alook/daemon 0.0.152

package/dist/cli/index.js

@@ -0,0 +1,4773 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/index.ts
+import { Command, CommanderError } from "commander";
+
+// src/cli/proxyServerApi.ts
+import * as fs from "fs";
+function proxyServerApiFromEnv(prefix = "ALOOK", env = process.env) {
+  const proxyUrl = env[`${prefix}_PROXY_URL`];
+  const tokenFile = env[`${prefix}_PROXY_TOKEN_FILE`];
+  if (!proxyUrl || !tokenFile)
+    return null;
+  const voucher = fs.readFileSync(tokenFile, "utf8").trim();
+  return createProxyServerApi({ proxyUrl, voucher });
+}
+function createProxyServerApi(config) {
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const base = config.proxyUrl.replace(/\/+$/, "");
+  async function call(method, body) {
+    const { agentId: _omit, ...wire } = body ?? {};
+    const res = await fetchImpl(`${base}/api/${method}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${config.voucher}`
+      },
+      body: JSON.stringify(wire)
+    });
+    const json = await res.json();
+    if (!res.ok) {
+      const e = new Error(json?.error ?? `proxy api/${method} failed (${res.status})`);
+      e.code = json?.code;
+      e.hint = json?.hint;
+      throw e;
+    }
+    return json;
+  }
+  return {
+    listServers: (r) => call("listServers", r),
+    listChannels: (r) => call("listChannels", r),
+    inboxPull: (r) => call("inboxPull", r),
+    inboxSnapshot: (r) => call("inboxSnapshot", r),
+    ack: (r) => call("ack", r),
+    send: (r) => call("send", r),
+    read: (r) => call("read", r),
+    resolve: (r) => call("resolve", r),
+    listMembers: (r) => call("listMembers", r),
+    joinServer: (r) => call("joinServer", r)
+  };
+}
+
+// src/cli/daemonStart.ts
+import * as fs9 from "fs";
+import * as path10 from "path";
+import * as crypto2 from "crypto";
+import * as os3 from "os";
+import { homedir as homedir3 } from "os";
+import { WebSocket } from "ws";
+import { createRequire as createRequire3 } from "module";
+
+// src/daemon/createDaemon.ts
+import { homedir as homedir2 } from "os";
+
+// src/logger.ts
+var LEVEL_RANK = { debug: 10, info: 20, warn: 30, error: 40 };
+var DEFAULT_HEADER = "@alook/daemon";
+var VALID_LEVELS = ["debug", "info", "warn", "error"];
+function envLevel() {
+  const raw = process.env.ALOOK_LOG_LEVEL?.toLowerCase();
+  return VALID_LEVELS.includes(raw) ? raw : undefined;
+}
+function formatData(data) {
+  if (data.length === 0)
+    return "";
+  const parts = [];
+  for (const d of data) {
+    if (d instanceof Error) {
+      parts.push(`err=${d.message}`);
+    } else if (d !== null && typeof d === "object" && !Array.isArray(d)) {
+      const entries = Object.entries(d);
+      for (const [k, v] of entries) {
+        parts.push(`${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+      }
+    } else {
+      parts.push(String(d));
+    }
+  }
+  return " " + parts.join(" ");
+}
+function createLogger(options = {}) {
+  const header = options.header ?? DEFAULT_HEADER;
+  const minRank = LEVEL_RANK[options.level ?? envLevel() ?? "info"];
+  const now = options.now ?? (() => new Date().toISOString());
+  const out = options.out ?? ((line) => process.stdout.write(line + `
+`));
+  const err = options.err ?? ((line) => process.stderr.write(line + `
+`));
+  const emit = (level, message, data) => {
+    if (LEVEL_RANK[level] < minRank)
+      return;
+    const line = `${now()} ${header} ${level.toUpperCase().padEnd(5)} ${message}${formatData(data)}`;
+    (level === "warn" || level === "error" ? err : out)(line);
+  };
+  return {
+    debug: (m, ...d) => emit("debug", m, d),
+    info: (m, ...d) => emit("info", m, d),
+    warn: (m, ...d) => emit("warn", m, d),
+    error: (m, ...d) => emit("error", m, d),
+    child: (tag) => createLogger({ ...options, header: `${header}:${tag}` })
+  };
+}
+
+// src/server/wsControlChannel.ts
+function describeErr(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+class WsControlChannel {
+  opts;
+  statusValue = "idle";
+  commandCbs = [];
+  resyncHooks = [];
+  ws = null;
+  attempt = 0;
+  closedByUser = false;
+  authRejected = false;
+  pingTimer = null;
+  pongDeadline = 0;
+  resyncProvider = null;
+  log;
+  constructor(opts) {
+    this.opts = opts;
+    this.log = opts.logger ?? createLogger({ header: "@alook/daemon:ws" });
+  }
+  get status() {
+    return this.statusValue;
+  }
+  connect() {
+    this.closedByUser = false;
+    this.authRejected = false;
+    this.openSocket();
+  }
+  close() {
+    this.closedByUser = true;
+    this.clearHeartbeat();
+    this.ws?.close();
+    this.ws = null;
+    this.statusValue = "closed";
+  }
+  onCommand(cb) {
+    this.commandCbs.push(cb);
+  }
+  onResync(provider) {
+    this.resyncProvider = provider;
+  }
+  onOpen(hook) {
+    this.resyncHooks.push(hook);
+  }
+  async reportReady(ready) {
+    this.sendFrame({ type: "ready", ...ready });
+  }
+  sendReady(ready) {
+    this.sendFrame({ type: "ready", ...ready });
+  }
+  async reportAgentSession(info) {
+    this.sendFrame({ type: "agent_session", ...info });
+  }
+  async reportAgentActivity(info) {
+    this.sendFrame({ type: "agent_activity", ...info });
+  }
+  async reportBotAuditEvent(frame) {
+    this.sendFrame(frame);
+  }
+  async reportWakeAck(info) {
+    this.sendFrame({ type: "agent_wake_ack", ...info });
+  }
+  async reportStoppedAck(info) {
+    this.sendFrame({ type: "agent_stopped_ack", ...info });
+  }
+  async reportSessionError(frame) {
+    this.sendFrame(frame);
+  }
+  sendFrame(frame) {
+    if (this.statusValue !== "open" || !this.ws) {
+      this.log.debug("frame dropped — socket not open", { type: frame.type });
+      return;
+    }
+    this.ws.send(JSON.stringify(frame));
+  }
+  resyncOnConnect() {
+    if (this.resyncProvider) {
+      const { ready, sessions } = this.resyncProvider();
+      this.sendFrame({ type: "ready", ...ready });
+      for (const s of sessions)
+        this.sendFrame({ type: "agent_session", ...s });
+      this.log.info("resync sent", { ready: ready.runtimeReport.length, sessions: sessions.length });
+    }
+    for (const hook of this.resyncHooks) {
+      try {
+        hook();
+      } catch {}
+    }
+  }
+  openSocket() {
+    this.statusValue = this.attempt === 0 ? "connecting" : "reconnecting";
+    const ws = this.opts.webSocketFactory(this.opts.url, this.opts.headers ?? {});
+    this.ws = ws;
+    ws.on("open", () => {
+      this.statusValue = "open";
+      this.log.info("control channel open", { attempt: this.attempt });
+      this.startHeartbeat();
+      this.resyncOnConnect();
+    });
+    ws.on("message", (data) => this.onMessage(data));
+    ws.on("pong", () => {
+      this.attempt = 0;
+      this.pongDeadline = this.now() + (this.opts.heartbeat?.pongTimeoutMs ?? 30000);
+      this.log.debug("heartbeat pong");
+    });
+    ws.on("close", (code, reason) => this.onSocketClosed(code, reason));
+    ws.on("error", () => {});
+  }
+  onMessage(data) {
+    let frame = null;
+    try {
+      frame = JSON.parse(String(data));
+    } catch {
+      return;
+    }
+    if (!frame || typeof frame.type !== "string")
+      return;
+    if (frame.type === "error" && frame.code === "AUTH_REJECTED") {
+      this.authRejected = true;
+      this.log.error("AUTH_REJECTED received — machine key rejected, not reconnecting");
+      this.opts.onAuthRejected?.();
+      return;
+    }
+    this.attempt = 0;
+    const cmd = frame;
+    for (const cb of this.commandCbs) {
+      try {
+        Promise.resolve(cb(cmd)).catch((err) => {
+          this.log.warn("command listener threw", { type: cmd.type, err: describeErr(err) });
+        });
+      } catch (err) {
+        this.log.warn("command listener threw synchronously", { type: cmd.type, err: describeErr(err) });
+      }
+    }
+  }
+  onSocketClosed(code, reason) {
+    this.log.warn("control channel closed", { code, reason: reason ? String(reason) : "" });
+    this.clearHeartbeat();
+    this.ws = null;
+    if (this.closedByUser)
+      return;
+    if (this.authRejected) {
+      this.statusValue = "closed";
+      return;
+    }
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    const base = this.opts.reconnect?.baseMs ?? 500;
+    const max = this.opts.reconnect?.maxMs ?? 30000;
+    const maxAttempts = this.opts.reconnect?.maxAttempts ?? Infinity;
+    if (this.attempt >= maxAttempts) {
+      this.statusValue = "closed";
+      return;
+    }
+    this.attempt += 1;
+    const delayMs = Math.min(max, base * 2 ** (this.attempt - 1));
+    this.statusValue = "reconnecting";
+    this.log.info("reconnecting", { attempt: this.attempt, delayMs });
+    setTimeout(() => this.openSocket(), delayMs);
+  }
+  startHeartbeat() {
+    const interval = this.opts.heartbeat?.pingIntervalMs ?? 15000;
+    const timeout = this.opts.heartbeat?.pongTimeoutMs ?? 30000;
+    this.pongDeadline = this.now() + timeout;
+    this.pingTimer = setInterval(() => {
+      if (this.now() > this.pongDeadline) {
+        this.log.warn("heartbeat pong timeout — forcing reconnect");
+        this.ws?.close();
+        return;
+      }
+      this.log.debug("heartbeat ping");
+      this.ws?.ping?.();
+    }, interval);
+    this.pingTimer.unref?.();
+  }
+  clearHeartbeat() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  now() {
+    return this.opts.now ? this.opts.now() : Date.now();
+  }
+}
+
+// src/credentials/credentialProxy.ts
+import * as crypto from "crypto";
+import * as fs2 from "fs";
+import * as http from "http";
+import * as https from "https";
+import * as os from "os";
+import * as path from "path";
+import { URL } from "url";
+var DEFAULT_HEADER_NAMES = {
+  agentId: "X-Agent-Id",
+  client: "X-Client",
+  capabilities: "X-Agent-Active-Capabilities"
+};
+function randomVoucher(prefix) {
+  return prefix + crypto.randomBytes(32).toString("base64url");
+}
+function sanitizeIdSegment(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_") || "_";
+}
+
+class CredentialBroker {
+  registrations = new Map;
+  voucherPrefix;
+  voucherDir;
+  upstreamBaseUrl;
+  clientLabel;
+  headerNames;
+  constructor(config) {
+    if (!config.upstreamBaseUrl)
+      throw new Error("CredentialBroker: upstreamBaseUrl is required");
+    this.upstreamBaseUrl = config.upstreamBaseUrl.replace(/\/+$/, "");
+    this.voucherPrefix = config.voucherPrefix ?? "vch_";
+    this.clientLabel = config.clientLabel ?? "cli";
+    this.headerNames = config.headerNames ?? DEFAULT_HEADER_NAMES;
+    this.voucherDir = config.voucherDir ?? path.join(os.tmpdir(), "agent-vouchers");
+  }
+  mint(agentId, launchId, capabilities, runnerKey) {
+    if (!runnerKey)
+      throw new Error("CredentialBroker.mint: runnerKey is required (per-agent tier-2 credential)");
+    const voucher = randomVoucher(this.voucherPrefix);
+    const dir = path.join(this.voucherDir, sanitizeIdSegment(agentId));
+    fs2.mkdirSync(dir, { recursive: true });
+    const voucherFile = path.join(dir, `${sanitizeIdSegment(launchId)}.token`);
+    fs2.writeFileSync(voucherFile, voucher, { mode: 384 });
+    this.registrations.set(voucher, {
+      agentId,
+      launchId,
+      capabilities: new Set(capabilities),
+      voucherFile,
+      runnerKey
+    });
+    return { voucher, agentId, launchId, capabilities: [...capabilities], voucherFile };
+  }
+  revoke(voucher) {
+    const reg = this.registrations.get(voucher);
+    if (!reg)
+      return false;
+    this.registrations.delete(voucher);
+    try {
+      fs2.rmSync(reg.voucherFile, { force: true });
+    } catch {}
+    return true;
+  }
+  revokeAgent(agentId) {
+    let n = 0;
+    for (const [voucher, reg] of this.registrations) {
+      if (reg.agentId === agentId && this.revoke(voucher))
+        n++;
+    }
+    return n;
+  }
+  get size() {
+    return this.registrations.size;
+  }
+  check(authHeader, requiredCapability) {
+    const voucher = parseBearer(authHeader);
+    if (!voucher) {
+      return { ok: false, status: 401, code: "missing_voucher", error: "missing bearer voucher" };
+    }
+    const reg = this.registrations.get(voucher);
+    if (!reg) {
+      return { ok: false, status: 401, code: "invalid_proxy_token", error: "invalid local agent proxy token" };
+    }
+    if (requiredCapability && !reg.capabilities.has(requiredCapability)) {
+      return {
+        ok: false,
+        status: 403,
+        code: "capability_denied",
+        error: `capability '${requiredCapability}' not granted to this voucher`
+      };
+    }
+    return { ok: true, reg };
+  }
+}
+function parseBearer(authHeader) {
+  if (!authHeader)
+    return null;
+  const m = /^Bearer\s+(.+)$/i.exec(authHeader.trim());
+  return m ? m[1].trim() : null;
+}
+var DEFAULT_CAPABILITY_RESOLVER = (_method, pathname) => {
+  if (pathname.includes("/send"))
+    return "send";
+  if (pathname.includes("/history") || pathname.includes("/search") || pathname.includes("/inbox"))
+    return "read";
+  if (pathname.includes("/server") || pathname.includes("/channel"))
+    return "server";
+  return;
+};
+var DEFAULT_UPSTREAM_TIMEOUT_MS = 20000;
+async function startCredentialProxy(broker, options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const resolveCap = options.capabilityResolver ?? DEFAULT_CAPABILITY_RESOLVER;
+  const upstream = new URL(broker.upstreamBaseUrl);
+  const upstreamClient = upstream.protocol === "https:" ? https : http;
+  const onPull = options.onInboxPullResponse;
+  const onProxyRequest = options.onProxyRequest;
+  const server = http.createServer((req, res) => {
+    const pathname = new URL(req.url ?? "/", "http://placeholder").pathname;
+    const requiredCap = resolveCap(req.method ?? "GET", pathname);
+    const verdict = broker.check(req.headers["authorization"], requiredCap);
+    if (!verdict.ok) {
+      res.writeHead(verdict.status, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: verdict.error, code: verdict.code }));
+      req.resume();
+      return;
+    }
+    const reg = verdict.reg;
+    const isInboxPull = onPull && pathname.endsWith("/inboxPull");
+    if (onProxyRequest) {
+      try {
+        onProxyRequest(reg.agentId, req.method ?? "GET", pathname);
+      } catch {}
+    }
+    const outHeaders = { ...req.headers };
+    delete outHeaders["authorization"];
+    delete outHeaders["host"];
+    delete outHeaders["content-length"];
+    outHeaders["authorization"] = `Bearer ${reg.runnerKey}`;
+    outHeaders[broker.headerNames.agentId.toLowerCase()] = reg.agentId;
+    outHeaders[broker.headerNames.client.toLowerCase()] = broker.clientLabel;
+    outHeaders[broker.headerNames.capabilities.toLowerCase()] = [...reg.capabilities].join(",");
+    let responded = false;
+    let upstreamRes;
+    const upstreamReq = upstreamClient.request({
+      protocol: upstream.protocol,
+      hostname: upstream.hostname,
+      port: upstream.port || (upstream.protocol === "https:" ? 443 : 80),
+      method: req.method,
+      path: joinPath(upstream.pathname, rewriteAgentPath(req.url ?? "/")),
+      headers: outHeaders
+    }, (res_) => {
+      responded = true;
+      upstreamRes = res_;
+      const destroyResIfIncomplete = () => {
+        if (!res_.complete)
+          res.destroy();
+      };
+      res_.on("error", destroyResIfIncomplete);
+      res_.on("close", destroyResIfIncomplete);
+      if (isInboxPull && res_.statusCode && res_.statusCode < 300) {
+        const chunks = [];
+        res_.on("data", (chunk) => chunks.push(chunk));
+        res_.on("end", () => {
+          const body = Buffer.concat(chunks);
+          res.writeHead(res_.statusCode, res_.headers);
+          res.end(body);
+          try {
+            const parsed = JSON.parse(body.toString());
+            if (parsed.messages)
+              onPull(reg.agentId, parsed.messages);
+          } catch {}
+        });
+      } else {
+        res.writeHead(res_.statusCode ?? 502, res_.headers);
+        res_.pipe(res);
+      }
+    });
+    upstreamReq.on("error", (err) => {
+      if (responded)
+        return;
+      responded = true;
+      res.writeHead(502, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: `upstream error: ${err.message}`, code: "upstream_error" }));
+    });
+    const upstreamTimeoutMs = options.upstreamTimeoutMs ?? DEFAULT_UPSTREAM_TIMEOUT_MS;
+    upstreamReq.setTimeout(upstreamTimeoutMs, () => {
+      upstreamReq.destroy();
+      upstreamRes?.destroy();
+      if (responded) {
+        res.destroy();
+        return;
+      }
+      responded = true;
+      res.writeHead(504, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: `upstream request timed out after ${upstreamTimeoutMs}ms`, code: "upstream_timeout" }));
+    });
+    res.on("close", () => {
+      upstreamReq.destroy();
+      upstreamRes?.destroy();
+    });
+    req.pipe(upstreamReq);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port ?? 0, host, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  const addr = server.address();
+  const port = typeof addr === "object" && addr ? addr.port : options.port ?? 0;
+  const url = `http://${host}:${port}`;
+  return {
+    url,
+    port,
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+    })
+  };
+}
+function joinPath(basePath, reqUrl) {
+  const base = basePath.replace(/\/+$/, "");
+  const reqPath = reqUrl.startsWith("/") ? reqUrl : `/${reqUrl}`;
+  return base + reqPath || "/";
+}
+function rewriteAgentPath(reqUrl) {
+  const url = new URL(reqUrl, "http://placeholder");
+  if (url.pathname === "/api" || url.pathname.startsWith("/api/")) {
+    url.pathname = `/api/community/agent${url.pathname.slice("/api".length)}`;
+  }
+  return url.pathname + url.search;
+}
+// src/runtime/apmStateMachine.ts
+var MAX_APM_GATED_STEERING_EVENTS = 12;
+function createInitialApmGatedSteeringState() {
+  return {
+    isIdle: false,
+    expectedTerminationReason: null,
+    phase: "idle",
+    outstandingToolUses: 0,
+    compacting: false,
+    toolBoundaryFlushDisabled: false,
+    lastFlushReason: null,
+    recentEvents: []
+  };
+}
+function reduceApmGatedToolUse(state, input) {
+  if (input.kind === "tool_call") {
+    return {
+      nextState: {
+        ...state,
+        isIdle: false,
+        phase: "tool_wait",
+        outstandingToolUses: state.outstandingToolUses + 1
+      },
+      hadOutstandingToolUse: state.outstandingToolUses > 0,
+      shouldFlushToolBatch: false
+    };
+  }
+  const hadOutstandingToolUse = state.outstandingToolUses > 0;
+  const outstandingToolUses = Math.max(0, state.outstandingToolUses - 1);
+  return {
+    nextState: {
+      ...state,
+      isIdle: false,
+      phase: "tool_boundary",
+      outstandingToolUses
+    },
+    hadOutstandingToolUse,
+    shouldFlushToolBatch: hadOutstandingToolUse && outstandingToolUses === 0
+  };
+}
+function reduceApmGatedCompaction(state, input) {
+  if (input.kind === "compaction_started") {
+    return { nextState: { ...state, isIdle: false, phase: "compacting", compacting: true } };
+  }
+  if (input.kind === "compaction_interrupted") {
+    return { nextState: { ...state, isIdle: false, compacting: false } };
+  }
+  return {
+    nextState: { ...state, isIdle: false, phase: "assistant_continuation", compacting: false }
+  };
+}
+function reduceApmGatedReview(state, input) {
+  if (input.kind === "review_started") {
+    return { nextState: { ...state, isIdle: false, phase: "reviewing", reviewing: true } };
+  }
+  return {
+    nextState: { ...state, isIdle: false, phase: "assistant_continuation", reviewing: false }
+  };
+}
+function reduceApmGatedError(state, input = {}) {
+  const shouldDisableToolBoundaryFlush = input.disableToolBoundaryFlush === true;
+  return {
+    nextState: {
+      ...state,
+      isIdle: input.terminalWakeable === true,
+      phase: "error",
+      compacting: false,
+      toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled || shouldDisableToolBoundaryFlush
+    },
+    shouldDisableToolBoundaryFlush
+  };
+}
+function reduceApmGatedFlushReadiness(state, input) {
+  if (!input.isGated)
+    return { shouldNotify: false, blockedReason: "non_gated", effects: [] };
+  if (!input.hasSession)
+    return { shouldNotify: false, blockedReason: "missing_session", effects: [] };
+  if (input.inboxLength === 0)
+    return { shouldNotify: false, blockedReason: "empty_inbox", effects: [] };
+  if (state.toolBoundaryFlushDisabled) {
+    return { shouldNotify: false, blockedReason: "tool_boundary_flush_disabled", effects: [] };
+  }
+  if (state.compacting)
+    return { shouldNotify: false, blockedReason: "compacting", effects: [] };
+  if (state.reviewing)
+    return { shouldNotify: false, blockedReason: "reviewing", effects: [] };
+  if (state.outstandingToolUses > 0) {
+    return { shouldNotify: false, blockedReason: "outstanding_tool_uses", effects: [] };
+  }
+  return {
+    shouldNotify: true,
+    blockedReason: null,
+    effects: [{ kind: "notify_stdin", reason: input.reason, stdinMode: "busy", clauseId: "SMR-002" }]
+  };
+}
+function reduceApmGatedRecentEvent(state, input) {
+  const summary = `${input.event}:${state.phase}:tools=${state.outstandingToolUses}:compact=${state.compacting}`;
+  return {
+    nextState: {
+      ...state,
+      recentEvents: [...state.recentEvents, summary].slice(-MAX_APM_GATED_STEERING_EVENTS)
+    }
+  };
+}
+
+// src/manager/managerPolicy.ts
+var DEFAULT_STALE_THRESHOLD_MS = 120000;
+var DEFAULT_IDLE_TIMEOUT_MS = 300000;
+function createInitialManagerState(staleThresholdMs = DEFAULT_STALE_THRESHOLD_MS, idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS) {
+  return { agents: {}, staleThresholdMs, idleTimeoutMs };
+}
+function reduceManager(state, event) {
+  switch (event.type) {
+    case "register":
+      return withAgent(state, event.agentId, (a) => a ?? freshAgent(event.agentId, event.caps), []);
+    case "wake":
+      return onWake(state, event.agentId, event.message);
+    case "spawned":
+      return mutate(state, event.agentId, (a) => {
+        a.status = "running";
+        a.turnActive = true;
+        a.lastProgressAt = event.nowMs;
+        a.idleSince = null;
+      });
+    case "session":
+      return mutate(state, event.agentId, (a) => {
+        a.sessionId = event.sessionId;
+      });
+    case "progress":
+      return mutate(state, event.agentId, (a) => {
+        a.lastProgressAt = event.nowMs;
+      });
+    case "turn_end":
+      return onTurnEnd(state, event.agentId, event.nowMs);
+    case "exit":
+      return onExit(state, event.agentId);
+    case "tick":
+      return onTick(state, event.nowMs);
+    case "runtime_signal":
+      return onRuntimeSignal(state, event.agentId, event.kind);
+  }
+}
+function onWake(state, agentId, message) {
+  const existing = state.agents[agentId];
+  const agent = existing ? clone(existing) : null;
+  if (!agent) {
+    return { state, effects: [] };
+  }
+  agent.inbox = [...agent.inbox, message];
+  agent.idleSince = null;
+  if (agent.status === "idle") {
+    agent.status = "starting";
+    const prompt = drainInboxToPrompt(agent);
+    return commit(state, agent, [
+      { type: "spawn", agentId, prompt, resumeSessionId: agent.sessionId }
+    ]);
+  }
+  if (agent.status === "running") {
+    if (agent.caps.lifecycleKind === "persistent" && agent.caps.supportsStdinNotification) {
+      const isGatedMidTurn = agent.caps.busyDeliveryMode === "gated" && agent.turnActive;
+      if (isGatedMidTurn) {
+        return commit(state, agent, [
+          {
+            type: "gated_hold",
+            agentId,
+            reason: "mid_turn_wake",
+            blockedReason: agent.apm.phase,
+            recentEvents: agent.apm.recentEvents
+          }
+        ]);
+      }
+      const text = drainInboxToPrompt(agent);
+      const mode = agent.turnActive ? "busy" : "idle";
+      if (mode === "idle")
+        agent.turnActive = true;
+      return commit(state, agent, [{ type: "send", agentId, text, mode }]);
+    }
+    return commit(state, agent, []);
+  }
+  return commit(state, agent, []);
+}
+function onTurnEnd(state, agentId, nowMs) {
+  const existing = state.agents[agentId];
+  if (!existing)
+    return { state, effects: [] };
+  const agent = clone(existing);
+  agent.turnActive = false;
+  agent.lastProgressAt = nowMs;
+  agent.apm = createInitialApmGatedSteeringState();
+  if (agent.caps.lifecycleKind === "per_turn") {
+    return commit(state, agent, []);
+  }
+  if (agent.inbox.length > 0 && agent.caps.supportsStdinNotification) {
+    const text = drainInboxToPrompt(agent);
+    agent.turnActive = true;
+    return commit(state, agent, [{ type: "send", agentId, text, mode: "idle" }]);
+  }
+  agent.idleSince = nowMs;
+  return commit(state, agent, []);
+}
+function onRuntimeSignal(state, agentId, kind) {
+  const existing = state.agents[agentId];
+  if (!existing)
+    return { state, effects: [] };
+  const agent = clone(existing);
+  const isGatedActive = agent.status === "running" && agent.turnActive && agent.caps.busyDeliveryMode === "gated";
+  if (!isGatedActive) {
+    agent.apm = reduceApmGatedRecentEvent(agent.apm, { event: kind }).nextState;
+    return commit(state, agent, []);
+  }
+  let attemptFlushReason = null;
+  switch (kind) {
+    case "tool_call":
+      agent.apm = reduceApmGatedToolUse(agent.apm, { kind }).nextState;
+      break;
+    case "tool_output":
+      agent.apm = reduceApmGatedToolUse(agent.apm, { kind }).nextState;
+      attemptFlushReason = "tool_batch_complete";
+      break;
+    case "compaction_started":
+    case "compaction_finished":
+      agent.apm = reduceApmGatedCompaction(agent.apm, { kind }).nextState;
+      if (kind === "compaction_finished")
+        attemptFlushReason = "compaction_finished";
+      break;
+    case "review_started":
+    case "review_finished":
+      agent.apm = reduceApmGatedReview(agent.apm, { kind }).nextState;
+      if (kind === "review_finished")
+        attemptFlushReason = "review_finished";
+      break;
+    case "error":
+      agent.apm = reduceApmGatedError(agent.apm, { disableToolBoundaryFlush: true }).nextState;
+      break;
+    default:
+      break;
+  }
+  agent.apm = reduceApmGatedRecentEvent(agent.apm, { event: kind }).nextState;
+  if (attemptFlushReason === null)
+    return commit(state, agent, []);
+  if (agent.inbox.length === 0)
+    return commit(state, agent, []);
+  const readiness = reduceApmGatedFlushReadiness(agent.apm, {
+    isGated: true,
+    hasSession: agent.sessionId != null,
+    inboxLength: agent.inbox.length,
+    reason: attemptFlushReason
+  });
+  if (readiness.shouldNotify) {
+    const text = drainInboxToPrompt(agent);
+    return commit(state, agent, [{ type: "send", agentId, text, mode: "busy" }]);
+  }
+  return commit(state, agent, [
+    {
+      type: "gated_hold",
+      agentId,
+      reason: attemptFlushReason,
+      blockedReason: readiness.blockedReason,
+      recentEvents: agent.apm.recentEvents
+    }
+  ]);
+}
+function onExit(state, agentId) {
+  const existing = state.agents[agentId];
+  if (!existing)
+    return { state, effects: [] };
+  const agent = clone(existing);
+  agent.turnActive = false;
+  if (agent.inbox.length > 0) {
+    agent.status = "starting";
+    const prompt = drainInboxToPrompt(agent);
+    return commit(state, agent, [
+      { type: "spawn", agentId, prompt, resumeSessionId: agent.sessionId }
+    ]);
+  }
+  agent.status = "idle";
+  return commit(state, agent, []);
+}
+function onTick(state, nowMs) {
+  const effects = [];
+  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");
+    if (stalled) {
+      agents[id] = { ...a, status: "stopping", idleSince: null };
+      effects.push({ type: "terminate_stalled", agentId: id });
+      continue;
+    }
+    const idleEligible = a.status === "running" && !a.turnActive && a.inbox.length === 0 && a.caps.lifecycleKind === "persistent" && state.idleTimeoutMs > 0 && Number.isFinite(state.idleTimeoutMs);
+    if (idleEligible && a.idleSince !== null && nowMs - a.idleSince >= state.idleTimeoutMs) {
+      agents[id] = { ...a, status: "stopping", idleSince: null };
+      effects.push({ type: "stop", agentId: id, reason: "idle_timeout" });
+    }
+  }
+  return { state: { ...state, agents }, effects };
+}
+function freshAgent(agentId, caps) {
+  return {
+    agentId,
+    status: "idle",
+    caps,
+    inbox: [],
+    sessionId: null,
+    turnActive: false,
+    lastProgressAt: 0,
+    idleSince: null,
+    apm: createInitialApmGatedSteeringState()
+  };
+}
+function drainInboxToPrompt(agent) {
+  const seen = new Set;
+  const unique = [];
+  for (const m of agent.inbox) {
+    if (!seen.has(m.text)) {
+      seen.add(m.text);
+      unique.push(m.text);
+    }
+  }
+  agent.inbox = [];
+  return unique.join(`
+`);
+}
+function clone(a) {
+  return {
+    ...a,
+    inbox: [...a.inbox],
+    caps: { ...a.caps },
+    apm: { ...a.apm, recentEvents: [...a.apm.recentEvents] }
+  };
+}
+function commit(state, agent, effects) {
+  return { state: { ...state, agents: { ...state.agents, [agent.agentId]: agent } }, effects };
+}
+function mutate(state, agentId, fn) {
+  const existing = state.agents[agentId];
+  if (!existing)
+    return { state, effects: [] };
+  const agent = clone(existing);
+  fn(agent);
+  return commit(state, agent, []);
+}
+function withAgent(state, agentId, make, effects) {
+  const agent = make(state.agents[agentId]);
+  return { state: { ...state, agents: { ...state.agents, [agentId]: agent } }, effects };
+}
+// src/runtime/runtimeSession.ts
+import { EventEmitter } from "events";
+
+// src/runtime/killTree.ts
+import { spawn } from "child_process";
+var POLL_MS = 100;
+var DEFAULT_GRACE_MS = 2000;
+var isPosix = process.platform !== "win32";
+function spawnAgentProcess(command, args, opts) {
+  return spawn(command, args, {
+    cwd: opts.cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: opts.env,
+    shell: opts.shell ?? false,
+    detached: isPosix
+  });
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === "EPERM";
+  }
+}
+function signalTree(pid, signal) {
+  if (isPosix) {
+    try {
+      process.kill(-pid, signal);
+    } catch {}
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {}
+}
+async function killProcessTree(pid, opts) {
+  if (!pid || pid < 1)
+    return;
+  if (!isAlive(pid))
+    return;
+  const graceMs = opts?.graceMs ?? DEFAULT_GRACE_MS;
+  signalTree(pid, "SIGTERM");
+  const deadline = Date.now() + graceMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid))
+      return;
+    await new Promise((r) => setTimeout(r, POLL_MS));
+  }
+  if (isAlive(pid)) {
+    signalTree(pid, "SIGKILL");
+  }
+}
+
+// src/runtime/runtimeSession.ts
+function descriptorFromDriver(driver) {
+  const lifecycle = driver.lifecycle.kind === "per_turn" ? "turn_based" : "persistent_stream";
+  const idle = driver.supportsStdinNotification ? "stdin" : "unsupported";
+  const busy = driver.supportsStdinNotification ? "stdin_steer" : "unsupported";
+  return {
+    transport: "child_process",
+    lifecycle,
+    input: { initial: "start", idle, busy },
+    readiness: "spawned",
+    turnBoundary: driver.lifecycle.kind === "per_turn" ? "process_exit" : "parsed_event",
+    startPolicy: driver.lifecycle.kind === "per_turn" ? driver.lifecycle.start : "immediate",
+    inFlightWake: driver.lifecycle.inFlightWake,
+    busyDelivery: driver.busyDeliveryMode,
+    postTurn: driver.terminateProcessOnTurnEnd ? "terminate_process" : driver.endStdinOnTurnEnd ? "close_stdin" : "keep_alive"
+  };
+}
+
+class ChildProcessRuntimeSession {
+  driver;
+  ctx;
+  descriptor;
+  events = new EventEmitter;
+  process = null;
+  started = false;
+  stdoutBuffer = "";
+  requestedStopReason;
+  constructor(driver, ctx) {
+    this.driver = driver;
+    this.ctx = ctx;
+    this.descriptor = descriptorFromDriver(driver);
+  }
+  get pid() {
+    return this.process?.pid;
+  }
+  get currentSessionId() {
+    return this.driver.currentSessionId;
+  }
+  get exitCode() {
+    return this.process?.exitCode ?? null;
+  }
+  get signalCode() {
+    return this.process?.signalCode ?? null;
+  }
+  get closed() {
+    return this.process ? this.process.exitCode != null || this.process.signalCode != null : false;
+  }
+  on(event, cb) {
+    this.events.on(event, cb);
+  }
+  async start(input) {
+    if (this.started) {
+      return { ok: false, reason: "runtime_error", error: "runtime session already started" };
+    }
+    this.started = true;
+    const launchCtx = {
+      ...this.ctx,
+      prompt: input.text,
+      config: { ...this.ctx.config, sessionId: input.sessionId ?? this.ctx.config.sessionId }
+    };
+    const { process: proc } = await this.driver.spawn(launchCtx);
+    this.process = proc;
+    this.attachProcess(proc);
+    return { ok: true, acceptedAs: "prompt" };
+  }
+  send(input) {
+    const proc = this.process;
+    if (!proc || this.closed)
+      return { ok: false, reason: "closed" };
+    const encoded = this.driver.encodeStdinMessage(input.text, input.sessionId ?? null, { mode: input.mode });
+    if (!encoded)
+      return { ok: false, reason: "unsupported" };
+    proc.stdin?.write(encoded + `
+`);
+    return { ok: true, acceptedAs: input.mode === "busy" ? "steer" : "prompt" };
+  }
+  async stop(opts) {
+    const proc = this.process;
+    if (!proc || this.closed)
+      return;
+    this.requestedStopReason = opts?.reason;
+    const pid = proc.pid;
+    if (pid) {
+      await killProcessTree(pid, { graceMs: opts?.forceAfterMs ?? 2000 });
+    } else {
+      proc.kill(opts?.signal ?? "SIGTERM");
+    }
+  }
+  attachProcess(proc) {
+    proc.stdout?.on("data", (chunk) => {
+      const chunkText = chunk.toString();
+      this.events.emit("stdout", chunkText);
+      this.stdoutBuffer += chunkText;
+      const lines = this.stdoutBuffer.split(`
+`);
+      this.stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim())
+          continue;
+        for (const event of this.driver.parseLine(line)) {
+          this.events.emit("runtime_event", event);
+        }
+      }
+    });
+    proc.stderr?.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text)
+        this.events.emit("stderr", text);
+    });
+    proc.on("error", (err) => this.events.emit("error", err));
+    proc.on("exit", (code, signal) => this.events.emit("exit", { code, signal, reason: this.requestedStopReason ? "requested" : "runtime_exit" }));
+    proc.on("close", (code, signal) => this.events.emit("close", { code, signal, reason: this.requestedStopReason ? "requested" : "runtime_exit" }));
+  }
+}
+function createChildProcessRuntimeSession(driver, ctx) {
+  return new ChildProcessRuntimeSession(driver, ctx);
+}
+
+// src/runtime/sdkManagedSession.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+class SdkManagedSession {
+  driver;
+  ctx;
+  deps;
+  events = new EventEmitter2;
+  inner = null;
+  startedSessionId = null;
+  exited = false;
+  starting = null;
+  stopRequested = false;
+  stopping = null;
+  constructor(driver, ctx, deps) {
+    this.driver = driver;
+    this.ctx = ctx;
+    this.deps = deps;
+  }
+  on(event, cb) {
+    this.events.on(event, cb);
+  }
+  async start(input) {
+    const launchCtx = {
+      ...this.ctx,
+      prompt: input.text,
+      config: { ...this.ctx.config, sessionId: input.sessionId ?? this.ctx.config.sessionId }
+    };
+    this.starting = (async () => {
+      const inner = await this.driver.createSession(launchCtx, this.deps);
+      this.inner = inner;
+      this.startedSessionId = inner.currentSessionId;
+      inner.on("runtime_event", (...args) => this.events.emit("runtime_event", ...args));
+    })();
+    await this.starting;
+    if (this.stopRequested) {
+      if (this.stopping)
+        await this.stopping.catch(() => {});
+      return { ok: true };
+    }
+    this.inner.send(input.text, "idle").catch((err) => this.events.emit("error", err));
+    return { ok: true };
+  }
+  send(input) {
+    if (!this.inner)
+      return { ok: false, reason: "not_started" };
+    this.inner.send(input.text, input.mode).catch((err) => this.events.emit("error", err));
+    return { ok: true };
+  }
+  async stop() {
+    this.stopRequested = true;
+    this.stopping = (async () => {
+      try {
+        if (this.starting)
+          await this.starting.catch(() => {});
+        await this.inner?.stop();
+      } finally {
+        this.emitExit();
+      }
+    })();
+    await this.stopping;
+  }
+  emitExit() {
+    if (this.exited)
+      return;
+    this.exited = true;
+    this.events.emit("exit");
+  }
+  get currentSessionId() {
+    return this.inner?.currentSessionId ?? this.startedSessionId;
+  }
+}
+
+// src/manager/managerRuntime.ts
+var THINKING_MAX_BYTES = 4096;
+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 };
+}
+
+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,
+      ...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() });
+  }
+  start() {
+    if (this.tickTimer)
+      return;
+    this.tickTimer = setInterval(() => this.dispatch({ type: "tick", nowMs: this.now() }), this.opts.tickIntervalMs);
+    this.tickTimer.unref?.();
+  }
+  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);
+  }
+  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();
+  }
+  snapshot() {
+    return this.state;
+  }
+  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 });
+        }
+      }
+    }
+  }
+  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;
+  }
+  withFooter(text) {
+    return this.opts.wakePromptFooter ? `${text}
+
+${this.opts.wakePromptFooter}` : text;
+  }
+  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.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;
+    }
+  }
+  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;
+      }
+      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 });
+    });
+    Promise.resolve(session.start({ text: prompt, 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") {
+          if (ev.name !== "Bash") {
+            try {
+              this.opts.onBotAuditEvent(agentId, {
+                kind: "tool_call",
+                payload: { name: ev.name }
+              }, {
+                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() });
+    }
+  }
+}
+// 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";
+  }
+}
+
+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";
+  }
+}
+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";
+}
+
+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";
+  }
+}
+function defaultFormatUnreadNoticeText(notice) {
+  return `You have unread messages in channel ${notice.channel}.`;
+}
+
+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
+      });
+    }
+  }
+  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);
+    }
+    return out;
+  }
+  isRuntimeHealthy(id) {
+    return this.runtimes.get(id)?.status === "healthy";
+  }
+  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();
+  }
+  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 {
+          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 text = (this.opts.formatUnreadNoticeText ?? defaultFormatUnreadNoticeText)(cmd.unreadNotice);
+          this.opts.manager.deliver(cmd.agentId, { seq: cmd.unreadNotice.latestSeq, text });
+          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;
+    }
+  }
+}
+// src/timeline/timeline.ts
+import { appendFileSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3, renameSync, 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;
+  }
+  if (isStale(lockPath, staleMs)) {
+    reclaim(lockPath);
+    if (tryMkdir(lockPath)) {
+      writeMeta(lockPath);
+      return true;
+    }
+  }
+  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;
+  }
+}
+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;
+  }
+}
+function reclaim(lockPath) {
+  try {
+    fs3.rmSync(lockPath, { recursive: true, force: true });
+  } catch {}
+}
+
+// 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 {
+    content = readFileSync3(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of content.trimEnd().split(`
+`)) {
+    if (!line)
+      continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {}
+  }
+  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)));
+  }
+  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`);
+        writeFileSync3(tmpPath, lines.join(`
+`) + `
+`);
+        renameSync(tmpPath, filePath);
+        return true;
+      }
+    }
+    appendFileSync(filePath, JSON.stringify(entry) + `
+`);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    releaseLock(lockPath);
+  }
+}
+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;
+    try {
+      let content;
+      try {
+        content = readFileSync3(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));
+      updater(entries[entries.length - 1]);
+      const tmpPath = join2(timelineDir, `.${filename}.tmp`);
+      writeFileSync3(tmpPath, entries.map((e) => JSON.stringify(e)).join(`
+`) + `
+`);
+      renameSync(tmpPath, filePath);
+      return true;
+    } catch {} finally {
+      releaseLock(lockPath);
+    }
+  }
+  return false;
+}
+function createTimelineEntry(fields) {
+  return {
+    session_id: fields.sessionId ?? null,
+    messages: fields.messages,
+    agent_responses: [],
+    provider: fields.provider ?? null
+  };
+}
+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;
+  }
+  return null;
+}
+// src/timeline/recorder.ts
+import { mkdirSync as mkdirSync3 } 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 {
+        mkdirSync3(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);
+    }
+  };
+}
+// src/discovery.ts
+import * as path8 from "path";
+import * as fs8 from "fs";
+import { fileURLToPath } from "url";
+
+// src/drivers/cliTransport.ts
+import * as fs5 from "fs";
+import * as path3 from "path";
+
+// src/drivers/systemPrompt.ts
+var CLI = "alook";
+function identitySection(config) {
+  const parts = ["## Identity", ""];
+  const introParts = ["You are a user operating in Alook."];
+  if (config.agentName)
+    introParts.push(`Your name is ${config.agentName}.`);
+  parts.push(introParts.join(" "));
+  if (config.agentHandle) {
+    parts.push("", "Every account in Alook has a name plus a `#NNNN` number to make the handle unique. " + `Your handle is \`${config.agentHandle}\`. ` + "Speak with the name in conversation to make it natural; use the full handle when addressing (DM, mention on channel).");
+  }
+  if (config.ownerHandle) {
+    parts.push("", `You are owned by \`${config.ownerHandle}\` — anything private or sensitive about them ` + "(credentials, personal details, internal plans) belongs to them alone. Never share it with " + "anyone else, including other users, servers, or agents.");
+  }
+  if (config.description) {
+    parts.push("", "### Role", "", config.description, "", "This is a starting point, not fixed — as you build context through interactions, capture how " + "your 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.`,
+    "",
+    "### 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.`,
+    "",
+    "### 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 |",
+    "| `/.dm/<peer>/#N` | Thread 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's `--text`/`--file` body — not just as `--target`. " + "Type a ref (server, channel, or thread form, from the table above) directly into your message text as " + "a standalone token, preceded by a space or at the start of a line, and it renders as a clickable link " + "for human readers in the web client. **Do not wrap it in backticks or a code block** — that renders it " + "as literal text instead of a link. Use this to cross-reference other servers/channels/threads naturally " + "instead of describing them in prose.",
+    "",
+    "### Message shape",
+    "",
+    `When you call \`${CLI} inbox pull\`, you receive messages as JSON objects:`,
+    "",
+    "```json",
+    '{"seq": "#3", "channel": "/demo/general", "sender": "@gustavo#4821", "content": {"text": "hello"}, "time": "2026-06-01T12:00:00Z"}',
+    "```",
+    "",
+    "Fields:",
+    "- `seq` — per-channel sequence number (`#N`). Identifies a message within its channel.",
+    "- `channel` — the path ref of the channel/DM. Reuse as `--target` when replying.",
+    "- `sender` — handle (`@name#0042`) of who sent it.",
+    "- `content.text` — the message body.",
+    "- `time` — ISO-8601 timestamp."
+  ].join(`
+`);
+}
+function serversSection() {
+  return [
+    "## Servers",
+    "",
+    `If a message contains a \`/community/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",
+    "",
+    `\`${CLI} channel list\`'s items are \`{ref, name, type}\` — \`ref\` is directly reusable as ` + "`--channel`/`--target` on every other command, no separate id lookup needed. `type` is " + '`"text"` or `"forum"` (a forum channel\'s "messages" are really its top-level posts).'
+  ].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 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",
+    "",
+    "Your reasoning is invisible to others — keep them in the loop:",
+    "- Acknowledge tasks before starting; give a one-line plan.",
+    "- Post brief updates at milestones (one sentence each).",
+    "- Summarize outcomes when done.",
+    "",
+    "### Etiquette",
+    "",
+    "- Don't jump into a conversation unless @mentioned or directly addressed.",
+    "- Let the person who did the work report on it.",
+    "- Before going idle, unblock anyone waiting on you.",
+    "- Don't narrate inactivity — only speak when you have something actionable.",
+    "- Talk in the same language as the sender."
+  ].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.",
+    "",
+    "### 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.",
+    "",
+    "### 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."
+  ].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(`
+`);
+  }
+  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(`
+
+`);
+}
+
+// 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;
+  }
+  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;
+  }
+  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;
+  }
+  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 path2 from "path";
+function writeCliLink(stateDir, cliName, hostCliPath, platform = process.platform) {
+  const binDir = path2.join(stateDir, "bin");
+  fs4.mkdirSync(binDir, { recursive: true });
+  if (!hostCliPath)
+    return binDir;
+  if (platform === "win32") {
+    const cmdFile = path2.join(binDir, `${cliName}.cmd`);
+    const body = `@echo off\r
+"${hostCliPath}" %*\r
+`;
+    fs4.writeFileSync(cmdFile, body);
+    return binDir;
+  }
+  const linkPath = path2.join(binDir, cliName);
+  try {
+    fs4.unlinkSync(linkPath);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+  }
+  try {
+    fs4.symlinkSync(hostCliPath, linkPath);
+  } catch (err) {
+    if (err.code !== "EEXIST")
+      throw err;
+  }
+  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;
+    }
+  }
+  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 writeFileSync5,
+  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;
+  }
+}
+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;
+      }
+    }
+  }
+}
+function writeAgentFile(workDir, systemPromptContent) {
+  const filePath = join4(workDir, CANONICAL_FILE);
+  const changed = hasContentChanged(filePath, systemPromptContent);
+  if (changed) {
+    writeFileSync5(filePath, systemPromptContent, "utf-8");
+  }
+  ensureSymlinks(workDir);
+  return changed;
+}
+
+// src/drivers/cliTransport.ts
+var DEFAULT_ACTIVE_CAPABILITIES = [
+  "send",
+  "read",
+  "mentions",
+  "tasks",
+  "reactions",
+  "server",
+  "channels",
+  "knowledge"
+];
+var DEFAULT_CLI_CONFIG = {
+  cliName: "alook",
+  envPrefix: "ALOOK",
+  stateDirName: ".alook"
+};
+function resolveStateHome(envPrefix) {
+  return process.env[`${envPrefix}_HOME`] || path3.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 capabilities = cli.activeCapabilities ?? DEFAULT_ACTIVE_CAPABILITIES;
+  const stateDir = path3.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.");
+  }
+  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(path3.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 buildCliTransportSystemPrompt(config, opts) {
+  return buildCliSystemPrompt(config, opts);
+}
+
+// src/drivers/claudeProviderIsolation.ts
+import * as fs6 from "fs";
+import * as path4 from "path";
+function buildClaudeProviderIsolationEnv(ctx) {
+  const hasCustomProvider = Boolean(process.env.ANTHROPIC_BASE_URL && process.env.ANTHROPIC_API_KEY);
+  if (!hasCustomProvider)
+    return {};
+  const root = path4.join(ctx.workingDirectory, ".alook", "claude-provider");
+  const home = path4.join(root, "home");
+  const configDir = path4.join(home, ".claude");
+  fs6.mkdirSync(configDir, { recursive: true });
+  const hostClaude = path4.join(process.env.HOME || ".", ".claude");
+  for (const sub of ["skills", "commands"]) {
+    const target = path4.join(hostClaude, sub);
+    const link = path4.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/probe.ts
+import { execFileSync } from "child_process";
+import * as fs7 from "fs";
+import * as path5 from "path";
+function resolveCommandOnPath(command, deps = {}) {
+  if (deps.which)
+    return deps.which(command);
+  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;
+  } catch {
+    return null;
+  }
+}
+function firstExistingPath(candidates) {
+  for (const c of candidates) {
+    if (c && fs7.existsSync(c))
+      return c;
+  }
+  return null;
+}
+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: 5000, shell });
+    const line = out.split(`
+`)[0]?.trim();
+    if (!line)
+      return { ok: false, error: "empty_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 path5.join(deps.homeDir || process.env.HOME || ".", relativePath);
+}
+function resolveSpawnSpec(command, args, deps = {}, platform = process.platform) {
+  const resolved = resolveCommandOnPath(command, deps) ?? command;
+  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/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);
+  const args = [
+    "--allow-dangerously-skip-permissions",
+    "--dangerously-skip-permissions",
+    "--verbose",
+    "--permission-mode",
+    "bypassPermissions",
+    "--output-format",
+    "stream-json",
+    "--input-format",
+    "stream-json",
+    "--include-partial-messages",
+    "--model",
+    f.model || DEFAULT_CLAUDE_MODEL,
+    "--disallowed-tools",
+    f.disallowedTools || CLAUDE_DISALLOWED_TOOLS
+  ];
+  if (f.reasoningEffort)
+    args.push("--effort", f.reasoningEffort);
+  if (f.fastMode)
+    args.push("--settings", '{"fastMode":true}');
+  if (config.sessionId)
+    args.push("--resume", config.sessionId);
+  return args;
+}
+function resolveClaudeLaunchCommand(config) {
+  const override = resolveLaunchFieldsOrDefault(config.runtimeConfig).command?.trim();
+  return override || resolveClaudeCommand() || "claude";
+}
+function buildClaudeSpawnSpec(claudeCommand, platform = process.platform) {
+  const command = claudeCommand ?? "claude";
+  const shell = platform === "win32" && (!command || /\.(cmd|bat)$/i.test(command));
+  return { command, shell };
+}
+
+// src/drivers/claudeEventNormalizer.ts
+var API_ERROR_RE = /API Error:.*(?:Connection error|\b[45]\d{2}\b)/i;
+
+class ClaudeEventNormalizer {
+  currentSession = null;
+  get currentSessionId() {
+    return this.currentSession;
+  }
+  normalizeLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    if (event?.session_id)
+      this.currentSession = event.session_id;
+    const out = [];
+    switch (event?.type) {
+      case "system":
+        this.handleSystem(event, out);
+        break;
+      case "assistant":
+        this.handleAssistant(event, out);
+        break;
+      case "user":
+        this.handleUser(event, out);
+        break;
+      case "result":
+        this.handleResult(event, out);
+        break;
+    }
+    return out;
+  }
+  handleSystem(event, out) {
+    if (event.subtype === "init") {
+      out.push({ kind: "session_init", sessionId: event.session_id ?? this.currentSession ?? "" });
+      return;
+    }
+    if (event.subtype === "status" && event.status === "compacting") {
+      out.push({ kind: "compaction_started" });
+      return;
+    }
+    if (event.subtype === "compact_boundary") {
+      out.push({ kind: "compaction_finished" });
+      return;
+    }
+    if (event.subtype === "status" || event.subtype === "stream_event") {
+      out.push({
+        kind: "internal_progress",
+        source: "claude_system",
+        itemType: event.subtype,
+        payloadBytes: JSON.stringify(event).length
+      });
+    }
+  }
+  handleAssistant(event, out) {
+    const content = event?.message?.content;
+    if (!Array.isArray(content))
+      return;
+    for (const block of content) {
+      if (block?.type === "thinking") {
+        out.push({ kind: "thinking", text: block.thinking ?? "" });
+      } else if (block?.type === "text") {
+        const text = block.text ?? "";
+        if (API_ERROR_RE.test(text))
+          out.push({ kind: "error", message: text });
+        else
+          out.push({ kind: "text", text });
+      } else if (block?.type === "tool_use") {
+        out.push({ kind: "tool_call", name: block.name ?? "unknown_tool", input: block.input });
+      }
+    }
+  }
+  handleUser(event, out) {
+    const content = event?.message?.content;
+    if (!Array.isArray(content))
+      return;
+    for (const block of content) {
+      if (block?.type === "tool_result")
+        out.push({ kind: "tool_output", name: "" });
+    }
+  }
+  handleResult(event, out) {
+    const usage = this.buildUsageTelemetry(event);
+    if (usage)
+      out.push(usage);
+    if (event.is_error || event.subtype === "error_during_execution") {
+      out.push({ kind: "error", message: String(event.result ?? "Claude runtime error") });
+    }
+    out.push({ kind: "turn_end", sessionId: event.session_id ?? this.currentSession ?? undefined });
+  }
+  buildUsageTelemetry(event) {
+    const u = event?.usage;
+    if (!u && event?.total_cost_usd == null)
+      return null;
+    return {
+      kind: "telemetry",
+      name: "token_usage",
+      source: "claude_result_usage",
+      usageKind: "per_turn",
+      attrs: {
+        inputTokens: u?.input_tokens,
+        outputTokens: u?.output_tokens,
+        cachedInputTokens: u?.cache_read_input_tokens,
+        cacheCreationInputTokens: u?.cache_creation_input_tokens,
+        totalCostUsd: event?.total_cost_usd,
+        durationMs: event?.duration_ms,
+        durationApiMs: event?.duration_api_ms,
+        numTurns: event?.num_turns,
+        resultSubtype: event?.subtype,
+        resultIsError: event?.is_error,
+        serviceTier: u?.service_tier
+      }
+    };
+  }
+}
+
+// src/drivers/claude.ts
+class ClaudeDriver {
+  id = "claude";
+  lifecycle = { kind: "persistent", stdin: "gated", inFlightWake: "queue" };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
+  supportsStdinNotification = true;
+  busyDeliveryMode = "gated";
+  supportsNativeStandingPrompt = true;
+  eventNormalizer = new ClaudeEventNormalizer;
+  probe() {
+    return probeClaude();
+  }
+  async spawn(ctx) {
+    const cliConfig = ctx.agentCliPath ? { ...DEFAULT_CLI_CONFIG, hostCliPath: ctx.agentCliPath } : undefined;
+    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, {
+      cwd: ctx.workingDirectory,
+      env: spawnEnv,
+      shell: spawnSpec.shell
+    });
+    const stdinMsg = JSON.stringify({
+      type: "user",
+      message: { role: "user", content: [{ type: "text", text: ctx.prompt }] },
+      ...ctx.config.sessionId ? { session_id: ctx.config.sessionId } : {}
+    });
+    proc.stdin?.write(stdinMsg + `
+`);
+    return { process: proc };
+  }
+  parseLine(line) {
+    return this.eventNormalizer.normalizeLine(line);
+  }
+  get currentSessionId() {
+    return this.eventNormalizer.currentSessionId;
+  }
+  encodeStdinMessage(text, sessionId, _opts) {
+    return JSON.stringify({
+      type: "user",
+      message: { role: "user", content: [{ type: "text", text }] },
+      ...sessionId ? { session_id: sessionId } : {}
+    });
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/codexTelemetrySidecar.ts
+function mapCodexTelemetry(method, params) {
+  if (method === "thread/tokenUsage/updated") {
+    const u = params?.usage ?? params ?? {};
+    return [
+      {
+        kind: "telemetry",
+        name: "token_usage",
+        source: "codex_thread_token_usage_updated",
+        usageKind: "cumulative_session",
+        attrs: {
+          totalTokens: u.totalTokens ?? u.total_tokens,
+          inputTokens: u.inputTokens ?? u.input_tokens,
+          cachedInputTokens: u.cachedInputTokens ?? u.cached_input_tokens,
+          outputTokens: u.outputTokens ?? u.output_tokens,
+          reasoningOutputTokens: u.reasoningOutputTokens ?? u.reasoning_output_tokens,
+          modelContextWindow: u.modelContextWindow ?? u.model_context_window,
+          cachedInputRatio: u.cachedInputRatio,
+          contextUtilization: u.contextUtilization
+        }
+      }
+    ];
+  }
+  if (method === "account/rateLimits/updated") {
+    const r = params ?? {};
+    return [
+      {
+        kind: "telemetry",
+        name: "rate_limits",
+        source: "codex_account_rate_limits_updated",
+        attrs: {
+          limitId: r.limitId,
+          planType: r.planType,
+          usedPercent: r.usedPercent,
+          windowDurationMins: r.windowDurationMins,
+          resetsAt: r.resetsAt
+        }
+      }
+    ];
+  }
+  return [];
+}
+
+// src/drivers/codexEventNormalizer.ts
+class CodexEventNormalizer {
+  threadId = null;
+  get currentSessionId() {
+    return this.threadId;
+  }
+  adoptThreadId(threadId) {
+    this.threadId = threadId;
+  }
+  normalizeLine(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    if (msg?.error && msg.id !== undefined) {
+      return [{ kind: "error", message: msg.error?.message ?? "Codex RPC error" }];
+    }
+    if (msg?.result?.thread?.id) {
+      this.threadId = msg.result.thread.id;
+      return [{ kind: "session_init", sessionId: this.threadId }];
+    }
+    if (msg?.method)
+      return this.handleNotification(msg.method, msg.params ?? {});
+    return [];
+  }
+  handleNotification(method, params) {
+    switch (method) {
+      case "thread/started":
+        if (params?.thread?.id)
+          this.threadId = params.thread.id;
+        return this.threadId ? [{ kind: "session_init", sessionId: this.threadId }] : [];
+      case "turn/started":
+        return [{ kind: "thinking", text: "" }];
+      case "item/reasoning/textDelta":
+      case "item/reasoning/summaryTextDelta":
+        return [{ kind: "thinking", text: params?.delta ?? "" }];
+      case "item/agentMessage/delta":
+        return [{ kind: "text", text: params?.delta ?? "" }];
+      case "item/started":
+        return this.handleItemStarted(params);
+      case "item/completed":
+        return this.handleItemCompleted(params);
+      case "rawResponseItem/completed":
+        return [{ kind: "internal_progress", source: "codex_raw_item", itemType: "rawResponseItem" }];
+      case "configWarning":
+      case "warning":
+      case "guardianWarning":
+      case "deprecationNotice":
+        return [
+          { kind: "runtime_diagnostic", severity: "warning", source: method, message: params?.message ?? method }
+        ];
+      case "turn/completed":
+        if (params?.status === "failed")
+          return [{ kind: "error", message: "Codex turn failed" }];
+        if (params?.status === "interrupted") {
+          return [{ kind: "error", message: "Codex turn interrupted" }, { kind: "turn_end", sessionId: this.threadId ?? undefined }];
+        }
+        return [{ kind: "turn_end", sessionId: this.threadId ?? undefined }];
+      case "error":
+        return [{ kind: "error", message: params?.message ?? "Codex error" }];
+      case "thread/tokenUsage/updated":
+      case "account/rateLimits/updated":
+        return mapCodexTelemetry(method, params);
+      default:
+        return [];
+    }
+  }
+  handleItemStarted(params) {
+    const t = params?.item?.type ?? params?.type;
+    switch (t) {
+      case "commandExecution":
+        return [{ kind: "tool_call", name: "shell", input: params?.item }];
+      case "contextCompaction":
+        return [{ kind: "compaction_started" }];
+      case "enteredReviewMode":
+        return [{ kind: "review_started" }];
+      case "fileChange":
+        return [{ kind: "tool_call", name: "file_change", input: params?.item }];
+      case "mcpToolCall":
+        return [{ kind: "tool_call", name: `mcp_${params?.item?.name ?? "tool"}`, input: params?.item }];
+      case "webSearch":
+        return [{ kind: "tool_call", name: "web_search", input: params?.item }];
+      case "collabAgentToolCall":
+        return [{ kind: "tool_call", name: "collab_tool_call", input: params?.item }];
+      default:
+        return [];
+    }
+  }
+  handleItemCompleted(params) {
+    const t = params?.item?.type ?? params?.type;
+    switch (t) {
+      case "commandExecution":
+        return [{ kind: "tool_output", name: "shell" }];
+      case "contextCompaction":
+        return [{ kind: "compaction_finished" }];
+      case "exitedReviewMode":
+        return [{ kind: "review_finished" }];
+      case "fileChange":
+        return [{ kind: "tool_output", name: "file_change" }];
+      case "mcpToolCall":
+        return [{ kind: "tool_output", name: `mcp_${params?.item?.name ?? "tool"}` }];
+      case "webSearch":
+        return [{ kind: "tool_output", name: "web_search" }];
+      case "collabAgentToolCall":
+        return [{ kind: "tool_output", name: "collab_tool_call" }];
+      case "agentMessage":
+        return [{ kind: "text", text: params?.item?.text ?? "" }];
+      case "reasoning":
+        return [{ kind: "thinking", text: params?.item?.text ?? "" }];
+      default:
+        return [];
+    }
+  }
+}
+
+// src/drivers/codexHome.ts
+import * as os2 from "os";
+import * as path6 from "path";
+function readConfiguredCodexHome(env) {
+  const raw = env.CODEX_HOME;
+  return typeof raw === "string" && raw.trim().length > 0 ? raw : null;
+}
+function resolveCodexHomeRootFromEnv(env = process.env, opts = {}) {
+  const raw = readConfiguredCodexHome(env);
+  if (raw)
+    return path6.resolve(opts.cwd ?? process.cwd(), raw);
+  return path6.join(opts.defaultHomeDir ?? os2.homedir(), ".codex");
+}
+
+// src/drivers/codex.ts
+class CodexDriver {
+  id = "codex";
+  lifecycle = { kind: "persistent", stdin: "gated", inFlightWake: "queue" };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ params: { model: modelId } })
+  };
+  supportsStdinNotification = true;
+  busyDeliveryMode = "gated";
+  supportsNativeStandingPrompt = true;
+  eventNormalizer = new CodexEventNormalizer;
+  requestId = 0;
+  codexHomeRoot = null;
+  nextRequestId() {
+    return ++this.requestId;
+  }
+  get codexHome() {
+    return this.codexHomeRoot;
+  }
+  probe() {
+    return probeCliRuntime("codex");
+  }
+  async spawn(ctx) {
+    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    this.codexHomeRoot = resolveCodexHomeRootFromEnv(spawnEnv, { cwd: ctx.workingDirectory });
+    const spec = resolveSpawnSpec("codex", ["app-server", "--listen", "stdio://"]);
+    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 }
+        }
+      }) + `
+`);
+      const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
+      const resuming = Boolean(ctx.config.sessionId);
+      const params = {
+        cwd: ctx.workingDirectory,
+        approvalPolicy: "never",
+        sandbox: "danger-full-access",
+        sandbox_mode: "danger-full-access",
+        experimentalRawEvents: true
+      };
+      if (resuming)
+        params.threadId = ctx.config.sessionId;
+      if (f.model)
+        params.model = f.model;
+      if (f.reasoningEffort)
+        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
+      }) + `
+`);
+    });
+    return { process: proc };
+  }
+  parseLine(line) {
+    return this.eventNormalizer.normalizeLine(line);
+  }
+  get currentSessionId() {
+    return this.eventNormalizer.currentSessionId;
+  }
+  encodeStdinMessage(text, sessionId, opts) {
+    const threadId = sessionId ?? this.eventNormalizer.currentSessionId;
+    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 }
+    });
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/gemini.ts
+function buildGeminiArgs(config) {
+  const f = resolveLaunchFieldsOrDefault(config.runtimeConfig);
+  return [
+    "--output-format",
+    "stream-json",
+    "--yolo",
+    "-p",
+    "",
+    ...f.model ? ["--model", f.model] : [],
+    ...config.sessionId ? ["--resume", config.sessionId] : []
+  ];
+}
+
+class GeminiDriver {
+  id = "gemini";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "suggestion_only",
+    toLaunchSpec: (modelId) => modelId && modelId !== "default" ? { args: ["--model", modelId] } : { args: [] }
+  };
+  supportsStdinNotification = false;
+  busyDeliveryMode = "none";
+  sessionId = null;
+  probe() {
+    return probeCliRuntime("gemini");
+  }
+  async spawn(ctx) {
+    this.sessionId = ctx.config.sessionId ?? null;
+    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    spawnEnv.GEMINI_CLI_TRUST_WORKSPACE ??= "true";
+    if (process.platform === "win32")
+      spawnEnv.GEMINI_PTY_INFO ??= "child_process";
+    const spec = resolveSpawnSpec("gemini", buildGeminiArgs(ctx.config));
+    const proc = spawnAgentProcess(spec.command, spec.args, {
+      cwd: ctx.workingDirectory,
+      env: spawnEnv,
+      shell: spec.shell
+    });
+    proc.stdin?.end(ctx.prompt);
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    switch (event?.type) {
+      case "init":
+        this.sessionId = event.session_id ?? this.sessionId;
+        return this.sessionId ? [{ kind: "session_init", sessionId: this.sessionId }] : [];
+      case "message":
+        if (event.role === "assistant" && event.content)
+          return [{ kind: "text", text: event.content }];
+        return [];
+      case "tool_use":
+        return [{ kind: "tool_call", name: event.tool_name ?? "unknown_tool", input: event.parameters }];
+      case "error":
+        return [{ kind: "error", message: event.message ?? "Gemini error" }];
+      case "result":
+        return event.status && event.status !== "success" ? [{ kind: "error", message: String(event.status) }, { kind: "turn_end", sessionId: this.sessionId ?? undefined }] : [{ kind: "turn_end", sessionId: this.sessionId ?? undefined }];
+      default:
+        return [];
+    }
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  encodeStdinMessage() {
+    return null;
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/copilot.ts
+class CopilotDriver {
+  id = "copilot";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
+  supportsStdinNotification = false;
+  busyDeliveryMode = "none";
+  sessionId = null;
+  probe() {
+    return probeCliRuntime("copilot");
+  }
+  async spawn(ctx) {
+    this.sessionId = ctx.config.sessionId ?? null;
+    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
+    const args = ["--output-format", "json", "--allow-all-tools", "--allow-all-paths", "-p", ctx.prompt];
+    if (f.model)
+      args.push("--model", f.model);
+    if (f.reasoningEffort)
+      args.push("--effort", f.reasoningEffort);
+    if (ctx.config.sessionId)
+      args.push(`--resume=${ctx.config.sessionId}`);
+    const spec = resolveSpawnSpec("copilot", args);
+    const proc = spawnAgentProcess(spec.command, spec.args, {
+      cwd: ctx.workingDirectory,
+      env: spawnEnv,
+      shell: spec.shell
+    });
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    switch (event?.type) {
+      case "assistant.turn_start":
+        if (event.sessionId)
+          this.sessionId = event.sessionId;
+        return this.sessionId ? [{ kind: "session_init", sessionId: this.sessionId }] : [];
+      case "assistant.reasoning":
+        return [{ kind: "thinking", text: event.content ?? "" }];
+      case "assistant.message_delta":
+        return [{ kind: "text", text: event.deltaContent ?? "" }];
+      case "assistant.message": {
+        const reqs = event.message?.toolRequests ?? [];
+        return reqs.map((req) => ({
+          kind: "tool_call",
+          name: req.name ?? req.toolName ?? "unknown_tool",
+          input: req.arguments ?? req.parameters ?? req.input ?? {}
+        }));
+      }
+      case "assistant.turn_end":
+        return [{ kind: "turn_end", sessionId: this.sessionId ?? undefined }];
+      case "result":
+        if (event.sessionId)
+          this.sessionId = event.sessionId;
+        return event.exitCode && event.exitCode !== 0 ? [{ kind: "error", message: `Copilot exited with code ${event.exitCode}` }, { kind: "turn_end" }] : [{ kind: "turn_end", sessionId: this.sessionId ?? undefined }];
+      default:
+        return [];
+    }
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  encodeStdinMessage() {
+    return null;
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/cursor.ts
+class CursorDriver {
+  id = "cursor";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
+  supportsStdinNotification = false;
+  busyDeliveryMode = "none";
+  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 f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
+    const args = ["--print", "--output-format", "stream-json", "--yolo", "--approve-mcps", "--trust"];
+    if (f.model)
+      args.push("--model", f.model);
+    if (ctx.config.sessionId)
+      args.push("--resume", ctx.config.sessionId);
+    args.push(ctx.prompt);
+    const spec = resolveSpawnSpec("cursor-agent", args);
+    const proc = spawnAgentProcess(spec.command, spec.args, {
+      cwd: ctx.workingDirectory,
+      env: spawnEnv,
+      shell: spec.shell
+    });
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    if (event?.type === "system") {
+      if (event.subtype === "init") {
+        this.sessionId = event.session_id ?? this.sessionId;
+        return this.sessionId ? [{ kind: "session_init", sessionId: this.sessionId }] : [];
+      }
+      if (event.subtype === "status" && event.status === "compacting")
+        return [{ kind: "compaction_started" }];
+      if (event.subtype === "compact_boundary")
+        return [{ kind: "compaction_finished" }];
+      return [];
+    }
+    if (event?.type === "assistant") {
+      const content = event.message?.content ?? [];
+      const out = [];
+      for (const block of content) {
+        if (block?.type === "thinking")
+          out.push({ kind: "thinking", text: block.thinking ?? "" });
+        else if (block?.type === "text")
+          out.push({ kind: "text", text: block.text ?? "" });
+        else if (block?.type === "tool_use")
+          out.push({ kind: "tool_call", name: block.name ?? "unknown_tool", input: block.input });
+      }
+      return out;
+    }
+    if (event?.type === "result") {
+      const out = [];
+      if (event.subtype !== "success" || event.is_error) {
+        const detail = (event.errors ?? []).map((e) => e?.message).filter(Boolean).join("; ");
+        out.push({ kind: "error", message: detail || String(event.result ?? "Cursor error") });
+      }
+      out.push({ kind: "turn_end", sessionId: event.session_id ?? this.sessionId ?? undefined });
+      return out;
+    }
+    return [];
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  encodeStdinMessage() {
+    return null;
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/opencode.ts
+class OpenCodeDriver {
+  id = "opencode";
+  lifecycle = {
+    kind: "per_turn",
+    start: "defer_until_concrete_message",
+    exit: "terminate_on_turn_end",
+    inFlightWake: "coalesce_into_pending"
+  };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
+  supportsStdinNotification = false;
+  busyDeliveryMode = "none";
+  terminateProcessOnTurnEnd = true;
+  deferSpawnUntilMessage = true;
+  sessionId = null;
+  shouldDeferWakeMessage(message) {
+    return message?.type === "system";
+  }
+  probe() {
+    return probeCliRuntime("opencode");
+  }
+  async spawn(ctx) {
+    this.sessionId = ctx.config.sessionId ?? null;
+    const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
+    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const args = ["run", "--format", "json", "--dangerously-skip-permissions", "--pure", "--dir", ctx.workingDirectory];
+    if (f.model)
+      args.push("--model", f.model);
+    if (ctx.config.sessionId)
+      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 proc = spawnAgentProcess(spec.command, spec.args, {
+      cwd: ctx.workingDirectory,
+      env: spawnEnv,
+      shell: spec.shell
+    });
+    proc.stdin?.end();
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const out = [];
+    if (event?.sessionID && this.sessionId !== event.sessionID) {
+      this.sessionId = event.sessionID;
+      out.push({ kind: "session_init", sessionId: this.sessionId });
+    }
+    switch (event?.type) {
+      case "step_start":
+        out.push({ kind: "thinking", text: "" });
+        break;
+      case "text":
+        if (typeof event.part?.text === "string" && event.part.text.length > 0)
+          out.push({ kind: "text", text: event.part.text });
+        break;
+      case "tool_use":
+        out.push({ kind: "tool_call", name: event.part?.tool ?? "unknown_tool", input: event.part?.state?.input });
+        break;
+      case "step_finish":
+        if (event.part?.reason !== "tool-calls")
+          out.push({ kind: "turn_end", sessionId: this.sessionId ?? undefined });
+        break;
+      case "error":
+        out.push({
+          kind: "error",
+          message: event.error?.data?.message ?? event.error?.message ?? "OpenCode error"
+        });
+        out.push({ kind: "turn_end", sessionId: this.sessionId ?? undefined });
+        break;
+    }
+    return out;
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  encodeStdinMessage() {
+    return null;
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/antigravity.ts
+import { randomUUID } 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) {
+  const args = ["--print", "--print-timeout", ANTIGRAVITY_PRINT_TIMEOUT, "--dangerously-skip-permissions"];
+  if (ctx.config.sessionId)
+    args.push("--continue");
+  return args;
+}
+
+class AntigravityDriver {
+  id = "antigravity";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "suggestion_only",
+    toLaunchSpec: (_modelId) => ({ args: [] })
+  };
+  supportsStdinNotification = false;
+  busyDeliveryMode = "none";
+  sessionId = null;
+  sentInit = false;
+  probe() {
+    return probeCliRuntime("agy");
+  }
+  async spawn(ctx) {
+    this.sessionId = ctx.config.sessionId ?? randomUUID();
+    this.sentInit = false;
+    const { spawnEnv } = await prepareCliTransport(ctx, {
+      NO_COLOR: "1",
+      SSH_CLIENT: "",
+      SSH_CONNECTION: "",
+      SSH_TTY: ""
+    });
+    const spec = resolveSpawnSpec("agy", buildAntigravityArgs(ctx));
+    const proc = spawnAgentProcess(spec.command, spec.args, {
+      cwd: ctx.workingDirectory,
+      env: spawnEnv,
+      shell: spec.shell
+    });
+    proc.stdin?.end(ctx.prompt);
+    return { process: proc };
+  }
+  parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return [];
+    const out = [];
+    if (!this.sentInit) {
+      this.sentInit = true;
+      out.push({ kind: "session_init", sessionId: this.sessionId });
+    }
+    if (ERROR_LINE_PATTERNS.some((re) => re.test(trimmed)))
+      out.push({ kind: "error", message: trimmed });
+    else
+      out.push({ kind: "text", text: line });
+    return out;
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  encodeStdinMessage() {
+    return null;
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/kimi.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function parseToolArguments(args) {
+  if (typeof args !== "string")
+    return args ?? {};
+  try {
+    return JSON.parse(args);
+  } catch {
+    return { raw: args };
+  }
+}
+
+class KimiDriver {
+  id = "kimi";
+  lifecycle = { kind: "persistent", stdin: "direct", inFlightWake: "steer" };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
+  supportsStdinNotification = true;
+  busyDeliveryMode = "direct";
+  sessionId = "";
+  sentInit = false;
+  promptRequestId = randomUUID2();
+  probe() {
+    return probeCliRuntime("kimi");
+  }
+  async spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || randomUUID2();
+    const isResume = Boolean(ctx.config.sessionId);
+    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    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 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(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."
+      }
+    }) + `
+`);
+    return { process: proc };
+  }
+  parseLine(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const out = [];
+    if (!this.sentInit) {
+      this.sentInit = true;
+      out.push({ kind: "session_init", sessionId: this.sessionId });
+    }
+    if (msg?.error) {
+      out.push({ kind: "error", message: msg.error?.message ?? "Unknown Kimi error" });
+      out.push({ kind: "turn_end", sessionId: this.sessionId });
+      return out;
+    }
+    if (msg?.method !== "event")
+      return out;
+    const payload = msg.params ?? {};
+    switch (payload.event) {
+      case "StepBegin":
+        out.push({ kind: "thinking", text: "" });
+        break;
+      case "CompactionBegin":
+        out.push({ kind: "compaction_started" });
+        break;
+      case "CompactionEnd":
+        out.push({ kind: "compaction_finished" });
+        break;
+      case "ContentPart":
+        if (payload.type === "think")
+          out.push({ kind: "thinking", text: payload.think ?? "" });
+        else if (payload.type === "text")
+          out.push({ kind: "text", text: payload.text ?? "" });
+        break;
+      case "ToolCall":
+        out.push({
+          kind: "tool_call",
+          name: payload.function?.name ?? "unknown_tool",
+          input: parseToolArguments(payload.function?.arguments)
+        });
+        break;
+      case "TurnEnd":
+        out.push({ kind: "turn_end", sessionId: this.sessionId });
+        break;
+      case "StepInterrupted":
+        out.push({ kind: "error", message: "Turn interrupted" });
+        out.push({ kind: "turn_end", sessionId: this.sessionId });
+        break;
+    }
+    return out;
+  }
+  get currentSessionId() {
+    return this.sessionId || null;
+  }
+  encodeStdinMessage(text, _sessionId, opts) {
+    const method = opts?.mode === "idle" ? "prompt" : "steer";
+    return JSON.stringify({ jsonrpc: "2.0", id: randomUUID2(), method, params: { user_input: text } });
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/pi.ts
+import { createRequire as createRequire2 } from "module";
+import { mkdirSync as mkdirSync6, existsSync as existsSync5, readFileSync as readFileSync5, realpathSync } from "fs";
+import * as path7 from "path";
+
+// src/runtime/sdkRuntimeSession.ts
+import { EventEmitter as EventEmitter3 } from "events";
+var IDLE_PROMPT_RETRY_MS = 25;
+var IDLE_PROMPT_MAX_WAIT_MS = 1000;
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+class SdkRuntimeSession {
+  handle;
+  sessionId;
+  events = new EventEmitter3;
+  sentInit = false;
+  constructor(handle, sessionId) {
+    this.handle = handle;
+    this.sessionId = sessionId;
+  }
+  on(event, cb) {
+    this.events.on(event, cb);
+  }
+  emitEvents(events) {
+    if (!this.sentInit && events.length > 0) {
+      this.sentInit = true;
+      this.events.emit("runtime_event", { kind: "session_init", sessionId: this.sessionId });
+    }
+    for (const e of events)
+      this.events.emit("runtime_event", e);
+  }
+  async send(text, mode) {
+    try {
+      if (mode === "busy") {
+        await this.handle.steer(text);
+        return { ok: true };
+      }
+      const stillStreaming = this.handle.isStreaming && !await this.waitForStreamingToClear();
+      if (stillStreaming) {
+        await this.handle.steer(text);
+        return { ok: true };
+      }
+      try {
+        await this.handle.prompt(text);
+      } catch (err) {
+        this.emitEvents([
+          { kind: "error", message: errorMessage(err) },
+          { kind: "turn_end", sessionId: this.sessionId }
+        ]);
+      }
+    } catch (err) {
+      this.emitEvents([{ kind: "error", message: errorMessage(err) }]);
+    }
+    return { ok: true };
+  }
+  async waitForStreamingToClear() {
+    const deadline = Date.now() + IDLE_PROMPT_MAX_WAIT_MS;
+    while (this.handle.isStreaming) {
+      if (Date.now() >= deadline)
+        return false;
+      await delay(IDLE_PROMPT_RETRY_MS);
+    }
+    return true;
+  }
+  async stop() {
+    if (this.handle.isStreaming && this.handle.abort)
+      await this.handle.abort();
+    await this.handle.dispose?.();
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+}
+
+// src/drivers/pi.ts
+var PI_SDK_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+function isPiSdkPackageJson(pkgJsonPath) {
+  if (!existsSync5(pkgJsonPath))
+    return false;
+  try {
+    const pkg = JSON.parse(readFileSync5(pkgJsonPath, "utf-8"));
+    return pkg.name === PI_SDK_PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+function resolvePiSdkPackageDir(deps = {}) {
+  const binPath = resolveCommandOnPath("pi", deps);
+  if (!binPath)
+    return;
+  try {
+    let dir = path7.dirname(realpathSync(binPath));
+    const MAX_DEPTH = 8;
+    for (let i = 0;i < MAX_DEPTH; i++) {
+      if (isPiSdkPackageJson(path7.join(dir, "package.json")))
+        return dir;
+      const siblingDir = path7.join(dir, "node_modules", PI_SDK_PACKAGE_NAME);
+      if (isPiSdkPackageJson(path7.join(siblingDir, "package.json")))
+        return siblingDir;
+      const parent = path7.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
+  return;
+}
+function resolvePiSdkVersionFromPath(deps = {}) {
+  const dir = resolvePiSdkPackageDir(deps);
+  if (!dir)
+    return;
+  try {
+    const pkg = JSON.parse(readFileSync5(path7.join(dir, "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return;
+  }
+}
+function readPiSdkVersion() {
+  try {
+    const req = createRequire2(import.meta.url);
+    const pkg = req("@earendil-works/pi-coding-agent/package.json");
+    if (pkg.version)
+      return pkg.version;
+  } catch {}
+  return resolvePiSdkVersionFromPath();
+}
+function mapPiSdkEventToParsedEvents(event, sessionId, state) {
+  if (event?.type === "message_update") {
+    const d = event.delta ?? {};
+    switch (d.type) {
+      case "thinking_delta":
+        return [{ kind: "thinking", text: d.delta ?? "" }];
+      case "text_delta":
+        state.sawTextDelta = true;
+        return [{ kind: "text", text: d.delta ?? "" }];
+      case "text_end":
+        return state.sawTextDelta ? [] : [{ kind: "text", text: d.content ?? "" }];
+      case "error":
+        return [{ kind: "error", message: d.message ?? "Pi error" }];
+      default:
+        return [];
+    }
+  }
+  switch (event?.type) {
+    case "tool_execution_start":
+      return [{ kind: "tool_call", name: event.toolName ?? "unknown_tool", input: event.args ?? {} }];
+    case "tool_execution_end":
+      return [{ kind: "tool_output", name: event.toolName ?? "unknown_tool" }];
+    case "compaction_start":
+      return [{ kind: "compaction_started" }];
+    case "compaction_end":
+      return [{ kind: "compaction_finished" }];
+    case "agent_end":
+      return [{ kind: "turn_end", sessionId }];
+    default:
+      return [];
+  }
+}
+
+class PiDriver {
+  id = "pi";
+  lifecycle = { kind: "persistent", stdin: "direct", inFlightWake: "steer" };
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ params: { model: modelId } })
+  };
+  supportsStdinNotification = true;
+  busyDeliveryMode = "direct";
+  supportsNativeStandingPrompt = true;
+  sessionId = null;
+  probe() {
+    const version = readPiSdkVersion();
+    if (!version) {
+      return { status: "unhealthy", lastError: "sdk_not_installed" };
+    }
+    return { status: "healthy", version };
+  }
+  spawn() {
+    throw new Error("PiDriver uses a native RuntimeSession; child-process spawn is unsupported");
+  }
+  async createSession(ctx, deps) {
+    const spawnEnv = await deps.buildSpawnEnv();
+    if (ctx.standingPrompt) {
+      mkdirSync6(ctx.workingDirectory, { recursive: true });
+      writeAgentFile(ctx.workingDirectory, ctx.standingPrompt);
+    }
+    const f = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
+    const { session, sessionId } = await deps.createAgentSession({
+      cwd: ctx.workingDirectory,
+      sessionId: ctx.config.sessionId,
+      model: f.model,
+      thinkingLevel: f.reasoningEffort,
+      spawnEnv
+    });
+    this.sessionId = sessionId;
+    const state = { sawTextDelta: false };
+    const handle = {
+      prompt: (t) => session.prompt(t, session.isStreaming ? { streamingBehavior: "followUp" } : undefined),
+      steer: (t) => session.steer(t),
+      abort: () => session.abort(),
+      dispose: () => session.dispose(),
+      get isStreaming() {
+        return session.isStreaming;
+      }
+    };
+    const runtimeSession = new SdkRuntimeSession(handle, this.sessionId);
+    session.subscribe((event) => runtimeSession.emitEvents(mapPiSdkEventToParsedEvents(event, this.sessionId, state)));
+    return runtimeSession;
+  }
+  parseLine() {
+    return [];
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  encodeStdinMessage() {
+    return null;
+  }
+  buildSystemPrompt(config) {
+    return buildCliTransportSystemPrompt(config, { lifecycleKind: this.lifecycle.kind });
+  }
+}
+
+// src/drivers/index.ts
+var driverFactories = {
+  claude: () => new ClaudeDriver,
+  codex: () => new CodexDriver,
+  antigravity: () => new AntigravityDriver,
+  copilot: () => new CopilotDriver,
+  cursor: () => new CursorDriver,
+  gemini: () => new GeminiDriver,
+  kimi: () => new KimiDriver,
+  opencode: () => new OpenCodeDriver,
+  pi: () => new PiDriver
+};
+function getDriver(runtimeId) {
+  const createDriver = driverFactories[runtimeId];
+  const driver = createDriver?.();
+  if (!driver) {
+    throw new Error(`Unknown runtime: ${runtimeId}. Available: ${Object.keys(driverFactories).join(", ")}`);
+  }
+  return driver;
+}
+function listRuntimeIds() {
+  return Object.keys(driverFactories);
+}
+
+// src/discovery.ts
+function resolveAlookCliPath(moduleDir) {
+  const thisDir = moduleDir ?? path8.dirname(fileURLToPath(import.meta.url));
+  const target = path8.basename(thisDir) === "dist" ? path8.resolve(thisDir, "cli", "index.js") : path8.resolve(thisDir, "..", "scripts", "alook-shim.mjs");
+  return fs8.existsSync(target) ? target : null;
+}
+function deriveCliFallbackCandidates(cliPath) {
+  if (!cliPath)
+    return [];
+  const normalized = cliPath.split(path8.sep).join("/");
+  const marker = "/node_modules/";
+  const idx = normalized.indexOf(marker);
+  if (idx === -1)
+    return [];
+  const globalRoot = cliPath.slice(0, idx + marker.length - 1);
+  const tail = path8.join("dist", "cli", "index.js");
+  return [
+    path8.join(globalRoot, "@alook", "daemon", tail)
+  ].filter((candidate) => candidate !== cliPath);
+}
+function resolveAlookCliPathWithFallback(primary) {
+  const resolved = primary ?? resolveAlookCliPath();
+  if (resolved && fs8.existsSync(resolved))
+    return resolved;
+  if (resolved) {
+    const fallbacks = deriveCliFallbackCandidates(resolved);
+    for (const fallback of fallbacks) {
+      if (fs8.existsSync(fallback))
+        return fallback;
+    }
+  }
+  return resolved;
+}
+async function detectRuntimes() {
+  const ids = listRuntimeIds();
+  const results = [];
+  const nowIso = new Date().toISOString();
+  for (const id of ids) {
+    try {
+      const driver = getDriver(id);
+      const probe = await driver.probe();
+      const healthy = probe.status === "healthy";
+      results.push({
+        id,
+        status: healthy ? "healthy" : "unhealthy",
+        version: probe.version,
+        lastError: healthy ? undefined : probe.lastError ?? "probe_failed",
+        lastErrorAt: healthy ? undefined : nowIso
+      });
+    } catch (err) {
+      results.push({
+        id,
+        status: "unhealthy",
+        lastError: err?.code ?? "probe_threw",
+        lastErrorAt: nowIso
+      });
+    }
+  }
+  return results;
+}
+
+// src/drivers/piSdkDeps.ts
+import { readFileSync as readFileSync6 } from "fs";
+import * as path9 from "path";
+import { pathToFileURL } from "url";
+var PI_SDK_PACKAGE_NAME2 = "@earendil-works/pi-coding-agent";
+var cachedSdkPromise = null;
+async function importPiSdkFromGlobalInstall() {
+  const dir = resolvePiSdkPackageDir();
+  if (!dir) {
+    throw new Error(`${PI_SDK_PACKAGE_NAME2} not found — install it (e.g. \`npm install -g ${PI_SDK_PACKAGE_NAME2}\`) before launching a pi agent`);
+  }
+  const pkg = JSON.parse(readFileSync6(path9.join(dir, "package.json"), "utf-8"));
+  const entry = pkg.exports?.["."]?.import ?? pkg.main ?? "./dist/index.js";
+  const entryPath = path9.join(dir, entry);
+  return import(pathToFileURL(entryPath).href);
+}
+function loadPiSdkModule() {
+  if (!cachedSdkPromise) {
+    cachedSdkPromise = (async () => {
+      try {
+        return await import(PI_SDK_PACKAGE_NAME2);
+      } catch {
+        return importPiSdkFromGlobalInstall();
+      }
+    })().catch((err) => {
+      cachedSdkPromise = null;
+      throw err;
+    });
+  }
+  return cachedSdkPromise;
+}
+function parseModelString(model) {
+  if (!model)
+    return;
+  const idx = model.indexOf("/");
+  if (idx <= 0 || idx === model.length - 1)
+    return;
+  return { provider: model.slice(0, idx), id: model.slice(idx + 1) };
+}
+function createPiSdkDriverDeps(ctx, loadSdk = loadPiSdkModule) {
+  return {
+    async buildSpawnEnv() {
+      const cliConfig = ctx.agentCliPath ? { ...DEFAULT_CLI_CONFIG, hostCliPath: ctx.agentCliPath } : DEFAULT_CLI_CONFIG;
+      const { spawnEnv } = await prepareCliTransport(ctx, {}, cliConfig);
+      return spawnEnv;
+    },
+    async createAgentSession(opts) {
+      const sdk = await loadSdk();
+      const authStorage = sdk.AuthStorage.create();
+      const provider = ctx.config.runtimeConfig?.provider;
+      if (provider?.kind === "pi-builtin") {
+        authStorage.setRuntimeApiKey(provider.providerId, provider.apiKey);
+      }
+      const modelRegistry = sdk.ModelRegistry.create(authStorage);
+      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 spawnEnv = opts.spawnEnv;
+      const bashTool = sdk.createBashToolDefinition(cwd, {
+        spawnHook: (spawnCtx) => ({ ...spawnCtx, env: { ...spawnCtx.env, ...spawnEnv } })
+      });
+      const { session, sessionId } = await sdk.createAgentSession({
+        cwd,
+        model,
+        thinkingLevel: opts.thinkingLevel,
+        authStorage,
+        modelRegistry,
+        sessionManager,
+        customTools: [bashTool]
+      });
+      const resolvedSessionId = sessionId ?? session.sessionId;
+      if (!resolvedSessionId)
+        throw new Error("pi SDK createAgentSession did not produce a sessionId");
+      return { session, sessionId: resolvedSessionId };
+    }
+  };
+}
+
+// ../shared/src/lib/discriminator.ts
+function formatHandle(name, discriminator) {
+  return `${name}#${discriminator}`;
+}
+
+// src/daemon/createDaemon.ts
+var WARMUP_BACKOFF_MS = [250, 500, 1000, 2000, 4000];
+var WARMUP_CEILING_MS = 30000;
+function deriveAuditLogSubcommand(pathname) {
+  const stripped = pathname.replace(/^\/api\/community\/agent\//, "/api/");
+  if (!stripped.startsWith("/api/"))
+    return null;
+  const sub = stripped.slice("/api/".length).split("/")[0]?.split("?")[0] ?? "";
+  if (!sub)
+    return null;
+  if (sub === "ack")
+    return null;
+  return sub;
+}
+async function createDaemon(opts) {
+  const log = opts.logger ?? createLogger({ header: "@alook/daemon" });
+  const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir2()}/.alook`) + "/daemon";
+  const workdirFor = (agentId) => `${opts.workingDirectoryBase ?? fallbackBase}/${agentId}`;
+  const resolvedCliPath = resolveAlookCliPathWithFallback(opts.agentCliPath);
+  const timeline2 = createTimelineRecorder({
+    timelineDirFor: (agentId) => `${workdirFor(agentId)}/.context_timeline`,
+    providerFor: () => opts.runtimeReport[0]?.id ?? null
+  });
+  let channelRef = null;
+  let managerRef = null;
+  const emitBotAuditEvent = (agentId, event, context) => {
+    channelRef?.reportBotAuditEvent?.({
+      type: "bot_audit_event",
+      agentId,
+      sessionId: context?.sessionId ?? null,
+      launchId: context?.launchId ?? null,
+      event
+    });
+  };
+  const broker = new CredentialBroker({ upstreamBaseUrl: opts.serverUrl });
+  const proxy = await startCredentialProxy(broker, {
+    onInboxPullResponse: (agentId, messages) => timeline2.appendEntryForAgent(agentId, messages),
+    onProxyRequest: (agentId, _method, pathname) => {
+      const subcommand = deriveAuditLogSubcommand(pathname);
+      if (!subcommand)
+        return;
+      const context = managerRef?.auditContext(agentId);
+      emitBotAuditEvent(agentId, {
+        kind: "cli_invocation",
+        payload: { subcommand }
+      }, context);
+    }
+  });
+  const enrolledKeys = new Map;
+  const botsById = new Map;
+  async function listMyBotsHttp() {
+    const res = await fetch(`${opts.serverUrl}/api/community/daemon/bots`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${opts.machineKey}` }
+    });
+    if (!res.ok)
+      throw new Error(`listMyBots ${res.status}`);
+    const json = await res.json();
+    return json.bots ?? [];
+  }
+  async function coldStartWarmup() {
+    const start = Date.now();
+    let attempt = 0;
+    while (Date.now() - start < WARMUP_CEILING_MS) {
+      try {
+        const bots = await listMyBotsHttp();
+        botsById.clear();
+        for (const b of bots) {
+          botsById.set(b.id, {
+            name: b.name,
+            discriminator: b.discriminator,
+            description: b.description,
+            ownerName: b.ownerName,
+            ownerDiscriminator: b.ownerDiscriminator
+          });
+        }
+        log.info("cold-start bot-cache warmup succeeded", { bots: bots.length, attempt });
+        return;
+      } catch {
+        const delay2 = WARMUP_BACKOFF_MS[Math.min(attempt, WARMUP_BACKOFF_MS.length - 1)];
+        await new Promise((r) => setTimeout(r, delay2));
+        attempt++;
+      }
+    }
+    log.warn("cold-start bot-cache warmup exhausted its ceiling", { ceilingMs: WARMUP_CEILING_MS, attempts: attempt });
+  }
+  async function resyncPendingWakes() {
+    try {
+      const res = await fetch(`${opts.serverUrl}/api/community/daemon/resync-wakes`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${opts.machineKey}` }
+      });
+      if (!res.ok)
+        throw new Error(`resync-wakes ${res.status}`);
+      const json = await res.json();
+      log.info("wake resync completed", { woken: json.woken ?? 0 });
+    } catch (err) {
+      log.warn("wake resync failed", { err: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  const enrollAgent = async (agentId) => {
+    const existing = enrolledKeys.get(agentId);
+    if (existing)
+      return existing;
+    try {
+      const res = await fetch(`${opts.serverUrl}/api/community/daemon/enroll-agent`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${opts.machineKey}` },
+        body: JSON.stringify({ agentId })
+      });
+      const json = await res.json();
+      if (!res.ok || !json.runnerKey) {
+        if (res.status === 404) {
+          throw new UnknownBotError(agentId);
+        }
+        throw new BotEnrollFailedError(agentId, new Error(json.error ?? `enroll failed (${res.status})`));
+      }
+      enrolledKeys.set(agentId, json.runnerKey);
+      return json.runnerKey;
+    } catch (err) {
+      if (err instanceof UnknownBotError || err instanceof BotEnrollFailedError) {
+        log.warn("agent enroll failed", { agentId, err: err.message });
+        throw err;
+      }
+      const wrapped = new BotEnrollFailedError(agentId, err);
+      log.warn("agent enroll failed", { agentId, err: wrapped.message });
+      throw wrapped;
+    }
+  };
+  const channel = new WsControlChannel({
+    url: opts.serverWsUrl,
+    headers: { Authorization: `Bearer ${opts.machineKey}` },
+    webSocketFactory: opts.webSocketFactory,
+    onAuthRejected: opts.onAuthRejected,
+    logger: log.child("ws")
+  });
+  channelRef = channel;
+  function handleBotFrame(cmd) {
+    switch (cmd.type) {
+      case "bot:added":
+        botsById.set(cmd.botId, {
+          name: cmd.name,
+          discriminator: cmd.discriminator,
+          description: cmd.description,
+          ownerName: cmd.ownerName,
+          ownerDiscriminator: cmd.ownerDiscriminator
+        });
+        log.debug("bot:added", { botId: cmd.botId, name: cmd.name });
+        break;
+      case "bot:updated": {
+        const prev = botsById.get(cmd.botId);
+        botsById.set(cmd.botId, {
+          name: cmd.name,
+          discriminator: cmd.discriminator,
+          description: cmd.description,
+          ownerName: cmd.ownerName,
+          ownerDiscriminator: cmd.ownerDiscriminator
+        });
+        const nameChanged = prev && prev.name !== cmd.name;
+        const descChanged = prev && (prev.description ?? "") !== (cmd.description ?? "");
+        log.debug("bot:updated", { botId: cmd.botId, name: cmd.name });
+        if (nameChanged || descChanged) {
+          manager.stop(cmd.botId);
+        }
+        break;
+      }
+      case "bot:removed":
+        botsById.delete(cmd.botId);
+        enrolledKeys.delete(cmd.botId);
+        log.debug("bot:removed", { botId: cmd.botId });
+        manager.stop(cmd.botId);
+        break;
+      default:
+        break;
+    }
+  }
+  let router = null;
+  const manager = new AgentProcessManager({
+    driverFor: (agentId, runtimeConfig) => {
+      const requested = runtimeConfig?.runtime;
+      if (requested && router && !router.isRuntimeHealthy(requested)) {
+        throw new UnknownRuntimeError(requested, router.healthyRuntimeIds());
+      }
+      return opts.driverFor(agentId, runtimeConfig);
+    },
+    onRuntimeSpawnFailed: (runtimeId, reason) => {
+      router?.markRuntimeUnhealthy(runtimeId, reason);
+    },
+    onRuntimeSessionEstablished: (runtimeId) => {
+      router?.markRuntimeHealthy(runtimeId);
+    },
+    baseContextFor: (agentId) => {
+      const runnerKey = enrolledKeys.get(agentId);
+      if (!runnerKey)
+        throw new Error(`agent ${agentId} not enrolled yet — enroll before deliver`);
+      const botMeta = botsById.get(agentId);
+      return {
+        agentId,
+        workingDirectory: workdirFor(agentId),
+        credentialProxy: { broker, proxyUrl: proxy.url, runnerKey },
+        agentCliPath: resolvedCliPath ?? opts.agentCliPath,
+        config: {
+          ...botMeta?.name ? { agentName: botMeta.name } : {},
+          ...botMeta?.name && botMeta?.discriminator ? { agentHandle: `@${formatHandle(botMeta.name, botMeta.discriminator)}` } : {},
+          ...botMeta?.description ? { description: botMeta.description } : {},
+          ...botMeta?.ownerName && botMeta?.ownerDiscriminator ? { ownerHandle: `@${formatHandle(botMeta.ownerName, botMeta.ownerDiscriminator)}` } : {}
+        }
+      };
+    },
+    tickIntervalMs: opts.tickIntervalMs ?? 2000,
+    onAgentSession: (info) => void channel.reportAgentSession(info),
+    onAgentActivity: (info) => void channel.reportAgentActivity?.(info),
+    onBotAuditEvent: (agentId, event, context) => emitBotAuditEvent(agentId, event, context),
+    onAgentLocallyStopped: (info) => router?.markLocallyStopped(info.agentId),
+    sdkDriverDepsFor: (ctx) => createPiSdkDriverDeps(ctx),
+    timeline: timeline2,
+    wakePromptFooter: "Use `alook inbox pull` to read your messages, then reply with `alook message send`.",
+    logger: log.child("manager")
+  });
+  managerRef = manager;
+  manager.start();
+  router = new AgentRouter({
+    manager,
+    channel,
+    runtimeReport: opts.runtimeReport,
+    hostname: opts.hostname,
+    platform: opts.platform,
+    arch: opts.arch,
+    osRelease: opts.osRelease,
+    daemonVersion: opts.daemonVersion,
+    logger: log.child("router"),
+    onBeforeAgent: async (agentId) => {
+      if (!botsById.has(agentId)) {
+        try {
+          const bots = await listMyBotsHttp();
+          for (const b of bots) {
+            botsById.set(b.id, {
+              name: b.name,
+              discriminator: b.discriminator,
+              description: b.description,
+              ownerName: b.ownerName,
+              ownerDiscriminator: b.ownerDiscriminator
+            });
+          }
+        } catch {}
+      }
+      if (!botsById.has(agentId)) {
+        throw new UnknownBotError(agentId);
+      }
+      await enrollAgent(agentId);
+    },
+    formatUnreadNoticeText: (notice) => `You have unread messages in channel ${notice.channel}.`
+  });
+  channel.onCommand((cmd) => {
+    handleBotFrame(cmd);
+  });
+  channel.onOpen(() => {
+    coldStartWarmup();
+    resyncPendingWakes();
+  });
+  channel.connect();
+  await router.start();
+  return {
+    isOpen: () => channel.status === "open",
+    proxyUrl: proxy.url,
+    stop: async () => {
+      channel.close();
+      await proxy.close();
+      await manager.stopAll();
+    }
+  };
+}
+
+// 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"];
+function resolveDefaultBaseDir() {
+  const root = process.env.ALOOK_PROJECT_ROOT || path10.join(homedir3(), ".alook");
+  return path10.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);
+}
+function daemonsDir(baseDir) {
+  return path10.join(baseDir, "daemons");
+}
+function pidfilePath(baseDir, machineKey) {
+  return path10.join(daemonsDir(baseDir), `${keyHash(machineKey)}.pid`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readPidFile(filePath) {
+  if (!fs9.existsSync(filePath))
+    return null;
+  try {
+    const content = JSON.parse(fs9.readFileSync(filePath, "utf8"));
+    if (typeof content.pid === "number" && typeof content.key === "string")
+      return content;
+  } catch {}
+  return null;
+}
+function writePidFile(filePath, pid, machineKey) {
+  fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
+  fs9.writeFileSync(filePath, JSON.stringify({ pid, key: machineKey }));
+}
+function acquireLock2(baseDir, machineKey) {
+  const pf = pidfilePath(baseDir, machineKey);
+  const existing = readPidFile(pf);
+  if (existing && isProcessAlive(existing.pid)) {
+    log.error(`daemon for this machine key already running (pid ${existing.pid}). Stop it first or remove ${pf}`);
+    process.exit(1);
+  }
+  writePidFile(pf, process.pid, machineKey);
+  return pf;
+}
+function releaseLock2(pf) {
+  try {
+    const content = readPidFile(pf);
+    if (content && content.pid === process.pid) {
+      fs9.unlinkSync(pf);
+    }
+  } catch {}
+}
+function daemonList(opts) {
+  const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
+  const dir = daemonsDir(baseDir);
+  if (!fs9.existsSync(dir))
+    return [];
+  const files = fs9.readdirSync(dir).filter((f) => f.endsWith(".pid"));
+  const results = [];
+  for (const file of files) {
+    const filePath = path10.join(dir, file);
+    const data = readPidFile(filePath);
+    if (!data)
+      continue;
+    const alive = isProcessAlive(data.pid);
+    if (!alive) {
+      try {
+        fs9.unlinkSync(filePath);
+      } catch {}
+    }
+    results.push({
+      keyHash: file.replace(".pid", ""),
+      keyPrefix: data.key.slice(0, 20) + "…",
+      pid: data.pid,
+      alive
+    });
+  }
+  return results;
+}
+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);
+  if (!data) {
+    log.info("no daemon running for this machine key (pidfile not found)");
+    return;
+  }
+  if (!isProcessAlive(data.pid)) {
+    log.info(`stale pidfile (pid ${data.pid} is not running) — removing`);
+    try {
+      fs9.unlinkSync(pf);
+    } catch {}
+    return;
+  }
+  log.info(`sending SIGTERM to daemon (pid ${data.pid})…`);
+  process.kill(data.pid, "SIGTERM");
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline && isProcessAlive(data.pid)) {
+    const start = Date.now();
+    while (Date.now() - start < 100) {}
+  }
+  if (isProcessAlive(data.pid)) {
+    log.error(`daemon (pid ${data.pid}) did not exit in 5s — sending SIGKILL`);
+    process.kill(data.pid, "SIGKILL");
+  } else {
+    log.info("daemon stopped");
+  }
+  try {
+    fs9.unlinkSync(pf);
+  } catch {}
+}
+function credentialFilePathByMachineId(baseDir, machineId) {
+  return path10.join(daemonsDir(baseDir), `${machineId}.credential.json`);
+}
+function credentialFilesDir(baseDir) {
+  return daemonsDir(baseDir);
+}
+function readCredentialFile(filePath) {
+  if (!fs9.existsSync(filePath))
+    return null;
+  try {
+    const content = JSON.parse(fs9.readFileSync(filePath, "utf8"));
+    if (typeof content.credential === "string" && content.credential.startsWith("cmk_") && typeof content.machineId === "string") {
+      return { credential: content.credential, machineId: content.machineId };
+    }
+  } catch {}
+  return null;
+}
+function writeCredentialFile(filePath, credential, machineId) {
+  fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
+  fs9.writeFileSync(filePath, JSON.stringify({ credential, machineId }), { mode: 384 });
+}
+function findExistingCredentialForBearer(baseDir, bearer) {
+  const dir = credentialFilesDir(baseDir);
+  if (!fs9.existsSync(dir))
+    return null;
+  for (const file of fs9.readdirSync(dir)) {
+    if (!file.endsWith(".credential.json"))
+      continue;
+    const parsed = readCredentialFile(path10.join(dir, file));
+    if (parsed && parsed.credential === bearer)
+      return parsed;
+  }
+  return null;
+}
+async function activatePairingToken(serverUrl, tokenId, hostname2, platform, arch, osRelease, daemonVersion, runtimeReport) {
+  const res = await fetch(`${serverUrl}/api/community/daemon/activate`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${tokenId}`
+    },
+    body: JSON.stringify({ hostname: hostname2, platform, arch, osRelease, daemonVersion, runtimeReport })
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok || !json.credential || !json.machineId) {
+    throw new Error(json.error ?? `activate failed (${res.status})`);
+  }
+  return { credential: json.credential, machineId: json.machineId };
+}
+async function daemonStart(opts) {
+  const serverUrl = opts.serverUrl || process.env.ALOOK_SERVER_URL;
+  const wsUrl = opts.wsUrl || process.env.ALOOK_SERVER_WS_URL;
+  if (!serverUrl) {
+    log.error("Server URL required — pass --server-url or set ALOOK_SERVER_URL");
+    process.exit(2);
+  }
+  if (!wsUrl) {
+    log.error("WebSocket URL required — pass --ws-url or set ALOOK_SERVER_WS_URL");
+    process.exit(2);
+  }
+  const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
+  const pf = acquireLock2(baseDir, opts.machineKey);
+  const agentCliPath = resolveAlookCliPathWithFallback() ?? process.argv[1];
+  const runtimeDetections = await detectRuntimes();
+  const healthyRuntimeIds = runtimeDetections.filter((r) => r.status === "healthy").map((r) => r.id);
+  log.info(healthyRuntimeIds.length === 0 ? "no agent CLIs detected" : `detected agent CLIs: ${healthyRuntimeIds.join(", ")}`);
+  const unhealthyIds = runtimeDetections.filter((r) => r.status === "unhealthy").map((r) => `${r.id}(${r.lastError ?? "unknown"})`);
+  if (unhealthyIds.length > 0)
+    log.info(`unhealthy runtimes: ${unhealthyIds.join(", ")}`);
+  const runtimeReport = runtimeDetections.map((r) => ({
+    id: r.id,
+    version: r.version,
+    status: r.status,
+    lastError: r.lastError,
+    lastErrorAt: r.lastErrorAt
+  }));
+  let dialingCredential;
+  if (opts.machineKey.startsWith("cmt_")) {
+    log.info("activating pairing token…");
+    try {
+      const activated = await activatePairingToken(serverUrl, opts.machineKey, os3.hostname(), process.platform, process.arch, os3.release(), readDaemonVersion(), runtimeReport);
+      dialingCredential = activated.credential;
+      writeCredentialFile(credentialFilePathByMachineId(baseDir, activated.machineId), dialingCredential, activated.machineId);
+      log.info("pairing token activated — credential persisted");
+    } catch (err) {
+      log.error(`activation failed: ${err instanceof Error ? err.message : String(err)}`);
+      releaseLock2(pf);
+      process.exit(1);
+    }
+  } else if (opts.machineKey.startsWith("cmk_")) {
+    const match = findExistingCredentialForBearer(baseDir, opts.machineKey);
+    if (match) {
+      dialingCredential = match.credential;
+      log.info("using persisted daemon credential");
+    } else {
+      dialingCredential = opts.machineKey;
+      log.info("dialing with provided cmk_ (no on-disk record)");
+    }
+  } else {
+    log.error("invalid machine key format — expected `cmt_` (pairing token) or `cmk_` (credential)");
+    releaseLock2(pf);
+    process.exit(2);
+  }
+  const daemon = await createDaemon({
+    machineKey: dialingCredential,
+    serverUrl,
+    serverWsUrl: wsUrl,
+    webSocketFactory: (url, headers) => new WebSocket(url, { headers }),
+    runtimeReport,
+    driverFor: (_agentId, runtimeConfig) => {
+      const requested = runtimeConfig?.runtime;
+      const known = runtimeReport.map((r) => r.id);
+      if (!requested || !known.includes(requested)) {
+        throw new UnknownRuntimeError(requested, healthyRuntimeIds);
+      }
+      return getDriver(requested);
+    },
+    capabilities: CAPABILITIES,
+    agentCliPath,
+    workingDirectoryBase: baseDir,
+    hostname: os3.hostname(),
+    platform: process.platform,
+    arch: process.arch,
+    osRelease: os3.release(),
+    daemonVersion: readDaemonVersion(),
+    logger: log,
+    onAuthRejected: () => {
+      log.error("machine key rejected by server — is it correct / has it expired?");
+      releaseLock2(pf);
+      process.exit(1);
+    }
+  });
+  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?.();
+  const shutdown = async () => {
+    log.info("shutting down…");
+    clearInterval(readyTimer);
+    releaseLock2(pf);
+    await daemon.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {});
+}
+
+// ../shared/src/lib/invite-link.ts
+var INVITE_URL_RE = /(?:https?:\/\/[^\s/]+)?\/community\/invite\/([A-Za-z0-9_-]{6,64})/;
+var BARE_TOKEN_RE = /^[A-Za-z0-9_-]{6,64}$/;
+function parseInviteToken(input) {
+  const trimmed = input.trim();
+  if (!trimmed)
+    return null;
+  const urlMatch = INVITE_URL_RE.exec(trimmed);
+  if (urlMatch)
+    return urlMatch[1];
+  return BARE_TOKEN_RE.test(trimmed) ? trimmed : null;
+}
+
+// src/cli/index.ts
+class CliError extends Error {
+}
+function printEnvelope(env) {
+  const out = {};
+  if (env.success !== undefined && env.success !== null)
+    out.success = env.success;
+  if (env.error !== undefined && env.error !== null)
+    out.error = env.error;
+  if (env.hint !== undefined && env.hint !== null)
+    out.hint = env.hint;
+  process.stdout.write(JSON.stringify(out) + `
+`);
+}
+var injectedApi = null;
+function setApiForTesting(api) {
+  injectedApi = api;
+}
+function getApi() {
+  if (injectedApi)
+    return injectedApi;
+  const fromEnv = proxyServerApiFromEnv();
+  if (fromEnv)
+    return fromEnv;
+  throw new CliError("no ServerApi available — ALOOK_PROXY_URL + ALOOK_PROXY_TOKEN_FILE must be set");
+}
+function agentId(opts) {
+  const id = opts.agent || process.env.ALOOK_AGENT_ID || process.env.ALOOK_ID;
+  if (!id)
+    throw new CliError("agent identity required — pass --agent <id> or set ALOOK_AGENT_ID");
+  return id;
+}
+async function cmdMessageSend(opts) {
+  const api = getApi();
+  const agent = agentId(opts);
+  const channel = opts.target;
+  if (!channel)
+    throw new CliError("message send: --target <ref> is required (e.g. /demo-workspace/general)");
+  let text;
+  const fileFlag = opts.file;
+  const textFlag = opts.text;
+  if (fileFlag) {
+    const fs10 = await import("fs");
+    if (!fs10.existsSync(fileFlag))
+      throw new CliError(`message send: file not found: ${fileFlag}`);
+    text = fs10.readFileSync(fileFlag, "utf8").trim();
+  } else if (typeof textFlag === "string") {
+    text = textFlag;
+  }
+  if (!text) {
+    throw new CliError("message send: --text <text> or --file <path> is required");
+  }
+  const res = await api.send({ agentId: agent, channel, content: { text } });
+  if (res.state === "blocked") {
+    throw new CliError(`channel not aligned: ${res.unreadCount} unread message(s) in ${channel} (latest #${res.latestSeq}). Run \`alook inbox pull\` to align, then resend.`);
+  }
+  return { sent: `${res.message.channel}${res.message.seq}` };
+}
+async function cmdInboxPull(opts) {
+  const api = getApi();
+  const agent = agentId(opts);
+  const max = opts.max ? Number(opts.max) : undefined;
+  const { messages, hasMore } = await api.inboxPull({ agentId: agent, max });
+  let acked = 0;
+  if (opts.ack !== false && messages.length > 0) {
+    const latest = new Map;
+    for (const m of messages) {
+      const seqN = Number(m.seq.replace("#", ""));
+      const cur = latest.get(m.channel);
+      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;
+  }
+  return { messages, hasMore, acked };
+}
+async function cmdServerList(opts) {
+  const api = getApi();
+  const agent = agentId(opts);
+  const { servers } = await api.listServers({ agentId: agent });
+  return { servers };
+}
+async function cmdServerMember(opts) {
+  const api = getApi();
+  const agent = agentId(opts);
+  const server = opts.server;
+  if (!server)
+    throw new CliError("server member: --server <name> is required");
+  const { members } = await api.listMembers({ agentId: agent, server });
+  return { members };
+}
+async function cmdServerJoin(opts) {
+  const api = getApi();
+  const agent = agentId(opts);
+  const raw = opts.invite;
+  if (!raw)
+    throw new CliError("server join: --invite <link> is required");
+  const token = parseInviteToken(raw);
+  if (!token)
+    throw new CliError(`server join: could not find an invite token in "${raw}"`);
+  const { server } = await api.joinServer({ agentId: agent, invite: token });
+  return { server };
+}
+async function cmdChannelList(opts) {
+  const api = getApi();
+  const agent = agentId(opts);
+  const server = opts.server;
+  if (!server)
+    throw new CliError("channel list: --server <id-or-name> is required");
+  const { channels } = await api.listChannels({ agentId: agent, server });
+  return { channels };
+}
+async function cmdChannelHistory(opts) {
+  const api = getApi();
+  const agent = agentId(opts);
+  const channel = opts.channel;
+  if (!channel)
+    throw new CliError("channel history: --channel <ref> is required");
+  const toSeq = (v) => v === undefined ? undefined : Number(v);
+  const { items, hasMore, latestSeq } = await api.read({
+    agentId: agent,
+    channel,
+    before: toSeq(opts.before),
+    after: toSeq(opts.after),
+    around: toSeq(opts.around),
+    limit: toSeq(opts.limit)
+  });
+  return { items, hasMore, ...latestSeq !== undefined ? { latestSeq } : {} };
+}
+function buildProgram() {
+  const program = new Command("alook").description("agent CLI").exitOverride().configureOutput({
+    writeOut: () => {},
+    writeErr: () => {}
+  }).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)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdMessageSend({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
+  const inbox = program.command("inbox").description("inbox operations").exitOverride();
+  inbox.configureOutput({ writeOut: () => {}, writeErr: () => {} });
+  inbox.command("pull").description("fetch unread messages from all channels").option("--max <n>", "max messages to return").option("--no-ack", "do not advance read waterlines (peek only)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdInboxPull({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
+  const server = program.command("server").description("server operations").exitOverride();
+  server.configureOutput({ writeOut: () => {}, writeErr: () => {} });
+  server.command("list").description("list servers this agent is a member of").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdServerList({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
+  server.command("member").description("list members of a server").option("--server <id-or-name>", "server id or name (from `server list`)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdServerMember({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
+  server.command("join").description("join a server via an invite link or token").option("--invite <link>", "invite URL or bare token").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdServerJoin({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
+  const channel = program.command("channel").description("channel operations").exitOverride();
+  channel.configureOutput({ writeOut: () => {}, writeErr: () => {} });
+  channel.command("list").description("list top-level channels visible to this agent in one server").option("--server <id-or-name>", "server id or name (from `server list`)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdChannelList({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
+  channel.command("history").description("fetch a page of messages from a channel, thread, or DM").option("--channel <ref>", "channel/thread/DM ref (path-style)").option("--before <seq>", "messages before this seq").option("--after <seq>", "messages after this seq").option("--around <seq>", "messages around this seq").option("--limit <n>", "max messages to return").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdChannelHistory({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
+  const daemon = program.command("daemon").description("daemon operations").exitOverride();
+  daemon.configureOutput({ writeOut: () => {}, writeErr: () => {} });
+  daemon.command("start").description("start the daemon (connects to server, manages agent lifecycles)").requiredOption("--machine-key <key>", "machine key for server authentication").option("--server-url <url>", "server HTTP URL (or ALOOK_SERVER_URL env)").option("--ws-url <url>", "server WebSocket URL (or ALOOK_SERVER_WS_URL env)").option("--base-dir <path>", "data directory for agent workspaces and pidfile (or ALOOK_DATA_DIR env)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    await daemonStart({
+      machineKey: localOpts.machineKey,
+      serverUrl: localOpts.serverUrl,
+      wsUrl: localOpts.wsUrl,
+      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() {
+    const localOpts = this.opts();
+    daemonStop({
+      machineKey: localOpts.machineKey,
+      baseDir: localOpts.baseDir
+    });
+  });
+  daemon.command("list").description("list running daemons on this machine").option("--base-dir <path>", "data directory (or ALOOK_DATA_DIR env)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(function() {
+    const localOpts = this.opts();
+    const daemons = daemonList({ baseDir: localOpts.baseDir });
+    printEnvelope({ success: { daemons } });
+  });
+  return program;
+}
+async function main(argv = process.argv.slice(2)) {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(argv, { from: "user" });
+  } catch (err) {
+    if (err instanceof CommanderError) {
+      if (err.code === "commander.helpDisplayed" || err.code === "commander.help") {
+        const helpText = getHelpText(program, argv);
+        printEnvelope({ success: { usage: helpText } });
+      } else if (err.code === "commander.unknownCommand") {
+        printEnvelope({ error: `unknown command: ${argv.join(" ") || "(none)"}. Run \`alook help\`.` });
+      } else {
+        printEnvelope({ error: err.message });
+      }
+    } else if (err instanceof CliError) {
+      printEnvelope({ error: err.message, hint: err.hint });
+    } else {
+      printEnvelope({ error: err.message, hint: err.hint });
+    }
+  }
+  return 0;
+}
+function getHelpText(program, argv) {
+  const args = argv.filter((a) => a !== "-h" && a !== "--help");
+  let cmd = program;
+  for (const arg of args) {
+    if (arg.startsWith("-"))
+      continue;
+    const sub = cmd.commands.find((c) => c.name() === arg);
+    if (sub)
+      cmd = sub;
+    else
+      break;
+  }
+  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) {
+  main().then((code) => process.exit(code));
+}
+export {
+  setApiForTesting,
+  main
+};