@alook/daemon 0.1.11 → 0.1.13

package/dist/index.js

@@ -57,7 +57,7 @@ function cliCommandsSection() {
     "### Messaging",
     "",
     `1. \`${CLI} inbox pull\` — fetch unread messages (advances your read waterline by default, ` + `so they won't re-pull; \`--no-ack\` to peek without advancing).`,
-    `2. \`${CLI} message send\` — send to a channel, DM, or thread. Attach with ` + `\`--attachment <id>\` (repeatable, order matters). Optionally add ` + `\`--remind-after <duration>\` to be reminded if the same channel, thread, or DM receives no ` + `newer message after your send. Use a whole number of minutes or hours from \`1m\` to \`24h\`, ` + `such as \`15m\` or \`2h\`.`,
+    `2. \`${CLI} message send\` — send to a channel, DM, or thread. ` + `For a short body, use explicit \`--stdin\` with a quoted heredoc; for a long or complicated body, ` + `use \`--file <path>\`. Attach with \`--attachment <id>\` (repeatable, order matters). Optionally add ` + `\`--remind-after <duration>\` to be reminded if the same channel, thread, or DM receives no ` + `newer message after your send. Use a whole number of minutes or hours from \`1m\` to \`24h\`, ` + `such as \`15m\` or \`2h\`.`,
     `3. \`${CLI} message attachment upload --target <ref> --file <path>\` — upload a file; ` + `returns an id stable across pending→persisted. Feed it into ` + `\`message send --attachment <id>\`.`,
     `4. \`${CLI} message attachment download --id <id> [--out <path>]\` — download any ` + `attachment you can see (or your own pending uploads).`,
     `5. \`${CLI} message emoji --target <ref> --emoji <e>\` — react with a single emoji. ` + `Works on channel messages (\`/<server>/<channel>#N\`), DM messages ` + `(\`/.dm/<peer>#N\`), and thread-reply messages (\`/<server>/<channel>/#N#M\`).`,
@@ -88,7 +88,7 @@ function cliCommandsSection() {
     "",
     "### Context Lifecycle",
     "",
-    `1. \`${CLI} nap --handoff <file>\` (or \`--text <note>\`) — reset your current session and ` + `start fresh. The required handoff is injected into the new session so your future self can ` + `quickly pick up unfinished work. Never nap on your own; only do it when someone explicitly asks.`,
+    `1. \`${CLI} nap --handoff <file>\` — reset your current session and ` + `start fresh. The required handoff is injected into the new session so your future self can ` + `quickly pick up unfinished work. Never nap on your own; only do it when someone explicitly asks.`,
     "",
     "### Output format",
     "",
@@ -107,9 +107,11 @@ function messagingSection() {
     "You can initiate conversations — send to any channel or DM someone directly. You're not " + "limited to replying. Use the same `message send` command whether you're replying or " + "starting a conversation.",
     "",
     "- Reply where the message came from. Post results in the channel that owns the topic. " + "When uncertain, read history (below) or DM the relevant people.",
-    `- Short reply: \`${CLI} message send --target <ref> --text "brief reply"\`.`,
-    `- Long or complicated: write body to a tmp file, then \`${CLI} message send --target <ref> --file ./temp_msg.md\`.`,
-    `- Cite a specific message: \`${CLI} message send --target <ref> --reply "#37" --text "on it"\` — ` + "`--reply` takes the `#N` seq (within `--target`) of the message you're answering.",
+    "Free-form message bodies never go in command arguments.",
+    "",
+    `- Short reply: use \`${CLI} message send --target <ref> --stdin\` with the quoted-heredoc form shown ` + "under *Message formatting*. Choose a fresh quoted delimiter that does not occur as a standalone line in the body.",
+    `- Long or complicated: write the body to a temporary file with a filesystem tool, then ` + `\`${CLI} message send --target <ref> --file ./temp_msg.md\`.`,
+    `- Cite a specific message: add \`--reply "#37"\` to either form — \`--reply\` takes the \`#N\` seq ` + "(within `--target`) of the message you're answering.",
     "",
     "### Context refs",
     "",
@@ -149,8 +151,10 @@ function messagingSection() {
     "- **Mentions** — `@name#NNNN` calls that person's attention specifically. In a private " + "channel, first verify they " + `are a member with \`${CLI} channel member --channel <ref>\` before mentioning them.`,
     "",
     "```bash",
-    "# Notify Alice and point her to a message for context.",
-    `${CLI} message send --target "/demo#1234/general" --text "@alice#0001 Please review /demo#1234/general#42"`,
+    "# Choose a fresh quoted delimiter that does not occur as a standalone line in the body.",
+    `${CLI} message send --target "/demo#1234/general" --stdin <<'ALOOK_MESSAGE_7F3C'`,
+    "@alice#0001 Please review /demo#1234/general#42",
+    "ALOOK_MESSAGE_7F3C",
     "```",
     "",
     "### Pulled messages",
@@ -216,7 +220,7 @@ function utilsSection() {
     "",
     `Use \`message send --remind-after <duration>\` when you send something that may need a later ` + "follow-up — for example, a question, approval request, handoff, or blocker — and silence would " + "leave the work unfinished. If no newer message appears in that channel, thread, or DM during " + "the duration, you'll receive a reminder to return and decide what to do next. Don't add it to " + "ordinary messages that need no follow-up.",
     "",
-    `Example: \`${CLI} message send --target /demo#1234/team --text "Please review the rollout plan" ` + `--remind-after 1m\`.`
+    `Example: ${CLI} message send --target "/demo#1234/team" --remind-after 1m --file ./message.md`
   ].join(`
 `);
 }
@@ -4815,624 +4819,248 @@ ${this.opts.wakePromptFooter}` : text;
     }
   }
 }
-// src/manager/agentRouter.ts
-var DEFINITIVE_EXECUTABLE_FAILURES = new Set(["ENOENT", "EACCES", "ENOEXEC", "EPERM"]);
-
-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}.`;
-}
-var REWAKE_PROMPT = "Your session was reset by your owner. Prior conversation context is gone. " + "Read @memory.md and your .context_timeline for durable context, then pull your inbox " + "before doing anything else. If it reports marked messages, run `$ALOOK_CLI message mark list` " + "and resume that outstanding work.";
-var MODEL_SWITCH_REWAKE_PROMPT = "You were just switched to a different model. Continue any unfinished work.";
-function buildNapRewakePrompt(handoff) {
-  return "You took a nap: you reset your own session, so prior conversation context " + `is gone. Before sleeping you left yourself this handoff —
-
-` + handoff.trim() + `
-
-Then read @memory.md and your .context_timeline for durable context, and pull ` + "your inbox before doing anything else. If it reports marked messages, run `$ALOOK_CLI " + "message mark list` and resume that outstanding work.";
-}
-
-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(),
-      activities: this.opts.manager.liveAgentActivities()
-    }));
-    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";
-  }
-  recordRuntimeSpawnFailure(id, reason) {
-    if (!DEFINITIVE_EXECUTABLE_FAILURES.has(reason))
-      return;
-    this.markRuntimeUnhealthy(id, reason);
-  }
-  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 runRestartCommand(agentId, launchId, opName, run) {
-    this.log.info(`${opName} received`, { agentId, launchId });
-    try {
-      await this.opts.onBeforeAgent?.(agentId);
-      await run();
-      this.running.add(agentId);
-      this.scheduleReadyFrameResend();
-      this.log.info(`${opName} ok`, { agentId });
-    } catch (err) {
-      if (err instanceof UnknownRuntimeError) {
-        const frame = {
-          type: "session.error",
-          code: "runtime_not_available",
-          agentId,
-          launchId,
-          payload: { requested: err.requested ?? null, available: err.available }
-        };
-        await this.opts.channel.reportSessionError?.(frame);
-        this.log.info(`${opName} error`, { agentId, "error.code": "runtime_not_available" });
-        return;
-      }
-      const code = classifyErrorCode(err);
-      await this.opts.channel.reportWakeAck?.({
-        agentId,
-        launchId,
-        status: "error",
-        error: { code, message: err instanceof Error ? err.message : String(err) }
-      });
-      this.log.warn(`${opName} failed`, {
-        agentId,
-        "error.code": code,
-        err: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  async onCommand(cmd) {
-    switch (cmd.type) {
-      case "agent:wake":
-        this.log.info("agent:wake received", {
-          agentId: cmd.agentId,
-          channel: cmd.unreadNotice.channel,
-          latestSeq: cmd.unreadNotice.latestSeq
-        });
-        try {
-          const beforeStatus = this.opts.manager.snapshot?.().agents?.[cmd.agentId]?.status ?? "unregistered";
-          const wasActive = this.opts.typingTracker?.hasAny(cmd.agentId) ?? false;
-          await this.opts.onBeforeAgent?.(cmd.agentId);
-          this.opts.manager.register(cmd.agentId, {
-            runtimeConfig: cmd.config,
-            sessionId: cmd.sessionId,
-            launchId: cmd.launchId
-          });
-          this.running.add(cmd.agentId);
-          const channelScope = cmd.unreadNotice.channelId;
-          if (channelScope)
-            this.opts.typingTracker?.add(cmd.agentId, channelScope);
-          const text = (this.opts.formatUnreadNoticeText ?? defaultFormatUnreadNoticeText)(cmd.unreadNotice);
-          const producedEffect = this.opts.manager.deliver(cmd.agentId, {
-            seq: cmd.unreadNotice.latestSeq,
-            text
-          });
-          if (producedEffect === false && beforeStatus === "running") {
-            this.log.info("agent:wake produced no effect (coalesced onto running agent)", {
-              agentId: cmd.agentId,
-              latestSeq: cmd.unreadNotice.latestSeq
-            });
-          }
-          if (channelScope && wasActive && beforeStatus === "running") {
-            this.opts.channel.reportAgentTyping?.({
-              agentId: cmd.agentId,
-              channelId: channelScope
-            });
-          }
-          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,
-              launchId: cmd.launchId,
-              payload: {
-                requested: err.requested ?? null,
-                available: err.available
-              }
-            };
-            await this.opts.channel.reportSessionError?.(frame);
-            await this.opts.channel.reportWakeAck?.({
-              agentId: cmd.agentId,
-              launchId: cmd.launchId,
-              status: "error",
-              error: {
-                code: "bot_runtime_missing",
-                message: err.message
-              }
-            });
-            this.log.info("agent:wake ack", {
-              agentId: cmd.agentId,
-              status: "error",
-              "error.code": "bot_runtime_missing"
-            });
-            return;
-          }
-          {
-            const code = classifyErrorCode(err);
-            await this.opts.channel.reportWakeAck?.({
-              agentId: cmd.agentId,
-              launchId: cmd.launchId,
-              status: "error",
-              error: {
-                code,
-                message: err instanceof Error ? err.message : String(err)
-              }
-            });
-            this.log.info("agent:wake ack", { agentId: cmd.agentId, status: "error", "error.code": code });
-          }
-          return;
-        }
-        break;
-      case "agent:reset":
-        await this.runRestartCommand(cmd.agentId, cmd.launchId, "agent:reset", () => this.opts.manager.resetSession(cmd.agentId, {
-          runtimeConfig: cmd.config,
-          launchId: cmd.launchId,
-          rewakePrompt: REWAKE_PROMPT
-        }));
-        break;
-      case "machine:reset_all":
-        for (const r of cmd.resets) {
-          await this.runRestartCommand(r.agentId, r.launchId, "agent:reset", () => this.opts.manager.resetSession(r.agentId, {
-            runtimeConfig: r.config,
-            launchId: r.launchId,
-            rewakePrompt: REWAKE_PROMPT
-          }));
-        }
-        break;
-      case "agent:nap":
-        await this.runRestartCommand(cmd.agentId, cmd.launchId, "agent:nap", () => this.opts.manager.resetSession(cmd.agentId, {
-          runtimeConfig: cmd.config,
-          launchId: cmd.launchId,
-          rewakePrompt: buildNapRewakePrompt(cmd.handoff),
-          barrierType: "nap"
-        }));
-        break;
-      case "agent:model_switch":
-        await this.runRestartCommand(cmd.agentId, cmd.launchId, "agent:model_switch", () => this.opts.manager.switchModel(cmd.agentId, {
-          runtimeConfig: cmd.config,
-          launchId: cmd.launchId,
-          rewakePrompt: MODEL_SWITCH_REWAKE_PROMPT
-        }));
-        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/manager/typingScopeTracker.ts
-function createTypingScopeTracker() {
-  const scopes = new Map;
-  return {
-    add(agentId, channelId) {
-      let set = scopes.get(agentId);
-      if (!set) {
-        set = new Set;
-        scopes.set(agentId, set);
-      }
-      set.add(channelId);
-    },
-    snapshot(agentId) {
-      const set = scopes.get(agentId);
-      return set ? [...set] : [];
-    },
-    hasAny(agentId) {
-      const set = scopes.get(agentId);
-      return !!set && set.size > 0;
-    },
-    clear(agentId) {
-      scopes.delete(agentId);
-    }
-  };
-}
-// src/credentials/credentialProxy.ts
-import * as crypto2 from "crypto";
-import * as fs5 from "fs";
-import * as http from "http";
-import * as https from "https";
-import * as os2 from "os";
-import * as path7 from "path";
-import { URL as URL2 } from "url";
-
-// ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
-var exports_external = {};
-__export(exports_external, {
-  xor: () => xor,
-  xid: () => xid2,
-  void: () => _void2,
-  uuidv7: () => uuidv7,
-  uuidv6: () => uuidv6,
-  uuidv4: () => uuidv4,
-  uuid: () => uuid2,
-  util: () => exports_util,
-  url: () => url,
-  uppercase: () => _uppercase,
-  unknown: () => unknown,
-  union: () => union,
-  undefined: () => _undefined3,
-  ulid: () => ulid2,
-  uint64: () => uint64,
-  uint32: () => uint32,
-  tuple: () => tuple,
-  trim: () => _trim,
-  treeifyError: () => treeifyError,
-  transform: () => transform,
-  toUpperCase: () => _toUpperCase,
-  toLowerCase: () => _toLowerCase,
-  toJSONSchema: () => toJSONSchema,
-  templateLiteral: () => templateLiteral,
-  symbol: () => symbol,
-  superRefine: () => superRefine,
-  success: () => success,
-  stringbool: () => stringbool,
-  stringFormat: () => stringFormat,
-  string: () => string2,
-  strictObject: () => strictObject,
-  startsWith: () => _startsWith,
-  slugify: () => _slugify,
-  size: () => _size,
-  setErrorMap: () => setErrorMap,
-  set: () => set,
-  safeParseAsync: () => safeParseAsync2,
-  safeParse: () => safeParse2,
-  safeEncodeAsync: () => safeEncodeAsync2,
-  safeEncode: () => safeEncode2,
-  safeDecodeAsync: () => safeDecodeAsync2,
-  safeDecode: () => safeDecode2,
-  registry: () => registry,
-  regexes: () => exports_regexes,
-  regex: () => _regex,
-  refine: () => refine,
-  record: () => record,
-  readonly: () => readonly,
-  property: () => _property,
-  promise: () => promise,
-  prettifyError: () => prettifyError,
-  preprocess: () => preprocess,
-  prefault: () => prefault,
-  positive: () => _positive,
-  pipe: () => pipe,
-  partialRecord: () => partialRecord,
-  parseAsync: () => parseAsync2,
-  parse: () => parse3,
-  overwrite: () => _overwrite,
-  optional: () => optional,
-  object: () => object,
-  number: () => number2,
-  nullish: () => nullish2,
-  nullable: () => nullable,
-  null: () => _null3,
-  normalize: () => _normalize,
-  nonpositive: () => _nonpositive,
-  nonoptional: () => nonoptional,
-  nonnegative: () => _nonnegative,
-  never: () => never,
-  negative: () => _negative,
-  nativeEnum: () => nativeEnum,
-  nanoid: () => nanoid2,
-  nan: () => nan,
-  multipleOf: () => _multipleOf,
-  minSize: () => _minSize,
-  minLength: () => _minLength,
-  mime: () => _mime,
-  meta: () => meta2,
-  maxSize: () => _maxSize,
-  maxLength: () => _maxLength,
-  map: () => map,
-  mac: () => mac2,
-  lte: () => _lte,
-  lt: () => _lt,
-  lowercase: () => _lowercase,
-  looseRecord: () => looseRecord,
-  looseObject: () => looseObject,
-  locales: () => exports_locales,
-  literal: () => literal,
-  length: () => _length,
-  lazy: () => lazy,
-  ksuid: () => ksuid2,
-  keyof: () => keyof,
-  jwt: () => jwt,
-  json: () => json,
-  iso: () => exports_iso,
-  ipv6: () => ipv62,
-  ipv4: () => ipv42,
-  invertCodec: () => invertCodec,
-  intersection: () => intersection,
-  int64: () => int64,
-  int32: () => int32,
-  int: () => int,
-  instanceof: () => _instanceof,
-  includes: () => _includes,
-  httpUrl: () => httpUrl,
-  hostname: () => hostname2,
-  hex: () => hex2,
-  hash: () => hash,
-  guid: () => guid2,
-  gte: () => _gte,
-  gt: () => _gt,
-  globalRegistry: () => globalRegistry,
-  getErrorMap: () => getErrorMap,
-  function: () => _function,
-  fromJSONSchema: () => fromJSONSchema,
-  formatError: () => formatError,
-  float64: () => float64,
-  float32: () => float32,
-  flattenError: () => flattenError,
-  file: () => file,
-  exactOptional: () => exactOptional,
-  enum: () => _enum2,
-  endsWith: () => _endsWith,
-  encodeAsync: () => encodeAsync2,
-  encode: () => encode2,
-  emoji: () => emoji2,
-  email: () => email2,
-  e164: () => e1642,
-  discriminatedUnion: () => discriminatedUnion,
-  describe: () => describe2,
-  decodeAsync: () => decodeAsync2,
-  decode: () => decode2,
-  date: () => date3,
-  custom: () => custom,
-  cuid2: () => cuid22,
-  cuid: () => cuid3,
-  core: () => exports_core2,
-  config: () => config,
-  coerce: () => exports_coerce,
-  codec: () => codec,
-  clone: () => clone2,
-  cidrv6: () => cidrv62,
-  cidrv4: () => cidrv42,
-  check: () => check,
-  catch: () => _catch2,
-  boolean: () => boolean2,
-  bigint: () => bigint2,
-  base64url: () => base64url2,
-  base64: () => base642,
-  array: () => array,
-  any: () => any,
-  _function: () => _function,
-  _default: () => _default2,
-  _ZodString: () => _ZodString,
-  ZodXor: () => ZodXor,
-  ZodXID: () => ZodXID,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodUUID: () => ZodUUID,
-  ZodURL: () => ZodURL,
-  ZodULID: () => ZodULID,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransform: () => ZodTransform,
-  ZodTemplateLiteral: () => ZodTemplateLiteral,
-  ZodSymbol: () => ZodSymbol,
-  ZodSuccess: () => ZodSuccess,
-  ZodStringFormat: () => ZodStringFormat,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodRecord: () => ZodRecord,
-  ZodRealError: () => ZodRealError,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPreprocess: () => ZodPreprocess,
-  ZodPrefault: () => ZodPrefault,
-  ZodPipe: () => ZodPipe,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumberFormat: () => ZodNumberFormat,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNonOptional: () => ZodNonOptional,
-  ZodNever: () => ZodNever,
-  ZodNanoID: () => ZodNanoID,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodMAC: () => ZodMAC,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodKSUID: () => ZodKSUID,
-  ZodJWT: () => ZodJWT,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodISOTime: () => ZodISOTime,
-  ZodISODuration: () => ZodISODuration,
-  ZodISODateTime: () => ZodISODateTime,
-  ZodISODate: () => ZodISODate,
-  ZodIPv6: () => ZodIPv6,
-  ZodIPv4: () => ZodIPv4,
-  ZodGUID: () => ZodGUID,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodFile: () => ZodFile,
-  ZodExactOptional: () => ZodExactOptional,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEmoji: () => ZodEmoji,
-  ZodEmail: () => ZodEmail,
-  ZodE164: () => ZodE164,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCustomStringFormat: () => ZodCustomStringFormat,
-  ZodCustom: () => ZodCustom,
-  ZodCodec: () => ZodCodec,
-  ZodCatch: () => ZodCatch,
-  ZodCUID2: () => ZodCUID2,
-  ZodCUID: () => ZodCUID,
-  ZodCIDRv6: () => ZodCIDRv6,
-  ZodCIDRv4: () => ZodCIDRv4,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigIntFormat: () => ZodBigIntFormat,
-  ZodBigInt: () => ZodBigInt,
-  ZodBase64URL: () => ZodBase64URL,
-  ZodBase64: () => ZodBase64,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  TimePrecision: () => TimePrecision,
-  NEVER: () => NEVER,
-  $output: () => $output,
-  $input: () => $input,
-  $brand: () => $brand
-});
+// ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
+var exports_external = {};
+__export(exports_external, {
+  xor: () => xor,
+  xid: () => xid2,
+  void: () => _void2,
+  uuidv7: () => uuidv7,
+  uuidv6: () => uuidv6,
+  uuidv4: () => uuidv4,
+  uuid: () => uuid2,
+  util: () => exports_util,
+  url: () => url,
+  uppercase: () => _uppercase,
+  unknown: () => unknown,
+  union: () => union,
+  undefined: () => _undefined3,
+  ulid: () => ulid2,
+  uint64: () => uint64,
+  uint32: () => uint32,
+  tuple: () => tuple,
+  trim: () => _trim,
+  treeifyError: () => treeifyError,
+  transform: () => transform,
+  toUpperCase: () => _toUpperCase,
+  toLowerCase: () => _toLowerCase,
+  toJSONSchema: () => toJSONSchema,
+  templateLiteral: () => templateLiteral,
+  symbol: () => symbol,
+  superRefine: () => superRefine,
+  success: () => success,
+  stringbool: () => stringbool,
+  stringFormat: () => stringFormat,
+  string: () => string2,
+  strictObject: () => strictObject,
+  startsWith: () => _startsWith,
+  slugify: () => _slugify,
+  size: () => _size,
+  setErrorMap: () => setErrorMap,
+  set: () => set,
+  safeParseAsync: () => safeParseAsync2,
+  safeParse: () => safeParse2,
+  safeEncodeAsync: () => safeEncodeAsync2,
+  safeEncode: () => safeEncode2,
+  safeDecodeAsync: () => safeDecodeAsync2,
+  safeDecode: () => safeDecode2,
+  registry: () => registry,
+  regexes: () => exports_regexes,
+  regex: () => _regex,
+  refine: () => refine,
+  record: () => record,
+  readonly: () => readonly,
+  property: () => _property,
+  promise: () => promise,
+  prettifyError: () => prettifyError,
+  preprocess: () => preprocess,
+  prefault: () => prefault,
+  positive: () => _positive,
+  pipe: () => pipe,
+  partialRecord: () => partialRecord,
+  parseAsync: () => parseAsync2,
+  parse: () => parse3,
+  overwrite: () => _overwrite,
+  optional: () => optional,
+  object: () => object,
+  number: () => number2,
+  nullish: () => nullish2,
+  nullable: () => nullable,
+  null: () => _null3,
+  normalize: () => _normalize,
+  nonpositive: () => _nonpositive,
+  nonoptional: () => nonoptional,
+  nonnegative: () => _nonnegative,
+  never: () => never,
+  negative: () => _negative,
+  nativeEnum: () => nativeEnum,
+  nanoid: () => nanoid2,
+  nan: () => nan,
+  multipleOf: () => _multipleOf,
+  minSize: () => _minSize,
+  minLength: () => _minLength,
+  mime: () => _mime,
+  meta: () => meta2,
+  maxSize: () => _maxSize,
+  maxLength: () => _maxLength,
+  map: () => map,
+  mac: () => mac2,
+  lte: () => _lte,
+  lt: () => _lt,
+  lowercase: () => _lowercase,
+  looseRecord: () => looseRecord,
+  looseObject: () => looseObject,
+  locales: () => exports_locales,
+  literal: () => literal,
+  length: () => _length,
+  lazy: () => lazy,
+  ksuid: () => ksuid2,
+  keyof: () => keyof,
+  jwt: () => jwt,
+  json: () => json,
+  iso: () => exports_iso,
+  ipv6: () => ipv62,
+  ipv4: () => ipv42,
+  invertCodec: () => invertCodec,
+  intersection: () => intersection,
+  int64: () => int64,
+  int32: () => int32,
+  int: () => int,
+  instanceof: () => _instanceof,
+  includes: () => _includes,
+  httpUrl: () => httpUrl,
+  hostname: () => hostname2,
+  hex: () => hex2,
+  hash: () => hash,
+  guid: () => guid2,
+  gte: () => _gte,
+  gt: () => _gt,
+  globalRegistry: () => globalRegistry,
+  getErrorMap: () => getErrorMap,
+  function: () => _function,
+  fromJSONSchema: () => fromJSONSchema,
+  formatError: () => formatError,
+  float64: () => float64,
+  float32: () => float32,
+  flattenError: () => flattenError,
+  file: () => file,
+  exactOptional: () => exactOptional,
+  enum: () => _enum2,
+  endsWith: () => _endsWith,
+  encodeAsync: () => encodeAsync2,
+  encode: () => encode2,
+  emoji: () => emoji2,
+  email: () => email2,
+  e164: () => e1642,
+  discriminatedUnion: () => discriminatedUnion,
+  describe: () => describe2,
+  decodeAsync: () => decodeAsync2,
+  decode: () => decode2,
+  date: () => date3,
+  custom: () => custom,
+  cuid2: () => cuid22,
+  cuid: () => cuid3,
+  core: () => exports_core2,
+  config: () => config,
+  coerce: () => exports_coerce,
+  codec: () => codec,
+  clone: () => clone2,
+  cidrv6: () => cidrv62,
+  cidrv4: () => cidrv42,
+  check: () => check,
+  catch: () => _catch2,
+  boolean: () => boolean2,
+  bigint: () => bigint2,
+  base64url: () => base64url2,
+  base64: () => base642,
+  array: () => array,
+  any: () => any,
+  _function: () => _function,
+  _default: () => _default2,
+  _ZodString: () => _ZodString,
+  ZodXor: () => ZodXor,
+  ZodXID: () => ZodXID,
+  ZodVoid: () => ZodVoid,
+  ZodUnknown: () => ZodUnknown,
+  ZodUnion: () => ZodUnion,
+  ZodUndefined: () => ZodUndefined,
+  ZodUUID: () => ZodUUID,
+  ZodURL: () => ZodURL,
+  ZodULID: () => ZodULID,
+  ZodType: () => ZodType,
+  ZodTuple: () => ZodTuple,
+  ZodTransform: () => ZodTransform,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodSymbol: () => ZodSymbol,
+  ZodSuccess: () => ZodSuccess,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodString: () => ZodString,
+  ZodSet: () => ZodSet,
+  ZodRecord: () => ZodRecord,
+  ZodRealError: () => ZodRealError,
+  ZodReadonly: () => ZodReadonly,
+  ZodPromise: () => ZodPromise,
+  ZodPreprocess: () => ZodPreprocess,
+  ZodPrefault: () => ZodPrefault,
+  ZodPipe: () => ZodPipe,
+  ZodOptional: () => ZodOptional,
+  ZodObject: () => ZodObject,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodNumber: () => ZodNumber,
+  ZodNullable: () => ZodNullable,
+  ZodNull: () => ZodNull,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNever: () => ZodNever,
+  ZodNanoID: () => ZodNanoID,
+  ZodNaN: () => ZodNaN,
+  ZodMap: () => ZodMap,
+  ZodMAC: () => ZodMAC,
+  ZodLiteral: () => ZodLiteral,
+  ZodLazy: () => ZodLazy,
+  ZodKSUID: () => ZodKSUID,
+  ZodJWT: () => ZodJWT,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodIntersection: () => ZodIntersection,
+  ZodISOTime: () => ZodISOTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODate: () => ZodISODate,
+  ZodIPv6: () => ZodIPv6,
+  ZodIPv4: () => ZodIPv4,
+  ZodGUID: () => ZodGUID,
+  ZodFunction: () => ZodFunction,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFile: () => ZodFile,
+  ZodExactOptional: () => ZodExactOptional,
+  ZodError: () => ZodError,
+  ZodEnum: () => ZodEnum,
+  ZodEmoji: () => ZodEmoji,
+  ZodEmail: () => ZodEmail,
+  ZodE164: () => ZodE164,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodDefault: () => ZodDefault,
+  ZodDate: () => ZodDate,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodCustom: () => ZodCustom,
+  ZodCodec: () => ZodCodec,
+  ZodCatch: () => ZodCatch,
+  ZodCUID2: () => ZodCUID2,
+  ZodCUID: () => ZodCUID,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodBoolean: () => ZodBoolean,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBigInt: () => ZodBigInt,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBase64: () => ZodBase64,
+  ZodArray: () => ZodArray,
+  ZodAny: () => ZodAny,
+  TimePrecision: () => TimePrecision,
+  NEVER: () => NEVER,
+  $output: () => $output,
+  $input: () => $input,
+  $brand: () => $brand
+});
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/index.js
 var exports_core2 = {};
@@ -21713,6 +21341,7 @@ var OwnerDiagnosticReportSchema = exports_external.discriminatedUnion("status",
 
 // ../shared/src/community-cli-contract.ts
 var DM_SERVER = ".dm";
+var CONTROL_HEARTBEAT_CAPABILITY = "control-heartbeat-v1";
 function parseRef(ref) {
   if (!ref.startsWith("/"))
     throw new Error(`ref must start with "/": ${ref}`);
@@ -21724,137 +21353,516 @@ function parseRef(ref) {
   if (server !== DM_SERVER && !parseNameAndTag(server)) {
     throw new Error(`server ref must use a name#discriminator handle: ${ref}`);
   }
-  let seq;
-  if (parts.length >= 3 && parts[parts.length - 1].startsWith("#")) {
-    const tail = parseThreadTail(parts[parts.length - 1]);
-    return { server, channel: parts[1], ...tail };
+  let seq;
+  if (parts.length >= 3 && parts[parts.length - 1].startsWith("#")) {
+    const tail = parseThreadTail(parts[parts.length - 1]);
+    return { server, channel: parts[1], ...tail };
+  }
+  if (parts.length >= 3 && server !== DM_SERVER) {
+    throw new Error(`ref has too many segments: ${ref}`);
+  }
+  const chSeg = parts[1];
+  if (server === DM_SERVER) {
+    const lastHash = chSeg.lastIndexOf("#");
+    if (lastHash < 0)
+      return { server, channel: chSeg };
+    const firstHash = chSeg.indexOf("#");
+    const tail = chSeg.slice(lastHash + 1);
+    const isBareHandle = firstHash === lastHash && /^\d{4,}$/.test(tail);
+    if (isBareHandle)
+      return { server, channel: chSeg };
+    const tailNum = Number(tail.startsWith("#") ? tail.slice(1) : tail);
+    if (!Number.isFinite(tailNum))
+      return { server, channel: chSeg };
+    seq = parseSeq(tail);
+    return { server, channel: chSeg.slice(0, lastHash), seq };
+  }
+  const hashIdx = chSeg.indexOf("#");
+  if (hashIdx >= 0) {
+    seq = parseSeq(chSeg.slice(hashIdx));
+    return { server, channel: chSeg.slice(0, hashIdx), seq };
+  }
+  return { server, channel: chSeg };
+}
+function parseThreadTail(segment) {
+  const stripped = segment.startsWith("#") ? segment.slice(1) : segment;
+  const tokens = stripped.split("#");
+  if (tokens.length < 1 || tokens.length > 2) {
+    throw new Error(`bad thread ref tail: #${stripped}`);
+  }
+  for (const t of tokens) {
+    if (!t)
+      throw new Error(`bad thread ref tail: #${stripped} (empty seq)`);
+  }
+  const threadRootSeq = parseSeq(tokens[0]);
+  if (tokens.length === 1)
+    return { threadRootSeq };
+  return { threadRootSeq, seq: parseSeq(tokens[1]) };
+}
+function formatRef(p) {
+  if (p.seq !== undefined && p.threadRootSeq === undefined) {
+    throw new Error("formatRef: seq without threadRootSeq is not supported");
+  }
+  const base = `/${p.server}/${p.channel}`;
+  if (p.threadRootSeq === undefined)
+    return base;
+  if (p.seq === undefined)
+    return `${base}/#${p.threadRootSeq}`;
+  return `${base}/#${p.threadRootSeq}#${p.seq}`;
+}
+function parseSeq(s) {
+  const n = Number(s.startsWith("#") ? s.slice(1) : s);
+  if (!Number.isFinite(n))
+    throw new Error(`bad seq: ${s}`);
+  return n;
+}
+var HostCommandSchema = exports_external.discriminatedUnion("type", [
+  exports_external.strictObject({
+    type: exports_external.literal("machine:heartbeat"),
+    nonce: exports_external.string().min(1).max(128)
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:wake"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    sessionId: exports_external.string().optional(),
+    launchId: exports_external.string().min(1),
+    unreadNotice: exports_external.unknown()
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:stop"),
+    agentId: exports_external.string().min(1)
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:reset"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    launchId: exports_external.string().min(1)
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:nap"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    launchId: exports_external.string().min(1),
+    handoff: exports_external.string().min(1)
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:model_switch"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    launchId: exports_external.string().min(1)
+  }),
+  exports_external.object({
+    type: exports_external.literal("machine:reset_all"),
+    resets: exports_external.array(exports_external.object({
+      agentId: exports_external.string().min(1),
+      config: exports_external.unknown(),
+      launchId: exports_external.string().min(1)
+    }))
+  }),
+  exports_external.strictObject({
+    type: exports_external.literal("machine:update")
+  }),
+  exports_external.object({
+    type: exports_external.literal("bot:added"),
+    botId: exports_external.string().min(1),
+    name: exports_external.string().optional(),
+    discriminator: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    ownerName: exports_external.string().optional(),
+    ownerDiscriminator: exports_external.string().optional()
+  }),
+  exports_external.object({
+    type: exports_external.literal("bot:updated"),
+    botId: exports_external.string().min(1),
+    name: exports_external.string().optional(),
+    discriminator: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    ownerName: exports_external.string().optional(),
+    ownerDiscriminator: exports_external.string().optional()
+  }),
+  exports_external.object({
+    type: exports_external.literal("bot:removed"),
+    botId: exports_external.string().min(1)
+  }),
+  DiagnosticCollectCommandSchema
+]);
+// src/manager/agentRouter.ts
+var DEFINITIVE_EXECUTABLE_FAILURES = new Set(["ENOENT", "EACCES", "ENOEXEC", "EPERM"]);
+
+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}.`;
+}
+var REWAKE_PROMPT = "Your session was reset by your owner. Prior conversation context is gone. " + "Read @memory.md and your .context_timeline for durable context, then pull your inbox " + "before doing anything else. If it reports marked messages, run `$ALOOK_CLI message mark list` " + "and resume that outstanding work.";
+var MODEL_SWITCH_REWAKE_PROMPT = "You were just switched to a different model. Continue any unfinished work.";
+function buildNapRewakePrompt(handoff) {
+  return "You took a nap: you reset your own session, so prior conversation context " + `is gone. Before sleeping you left yourself this handoff —
+
+` + handoff + `
+
+Then read @memory.md and your .context_timeline for durable context, and pull ` + "your inbox before doing anything else. If it reports marked messages, run `$ALOOK_CLI " + "message mark list` and resume that outstanding work.";
+}
+
+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(),
+      activities: this.opts.manager.liveAgentActivities()
+    }));
+    await this.opts.channel.reportReady(this.buildReady());
+  }
+  buildReady() {
+    return {
+      runtimeReport: [...this.runtimes.values()],
+      capabilities: [CONTROL_HEARTBEAT_CAPABILITY],
+      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";
   }
-  if (parts.length >= 3 && server !== DM_SERVER) {
-    throw new Error(`ref has too many segments: ${ref}`);
+  recordRuntimeSpawnFailure(id, reason) {
+    if (!DEFINITIVE_EXECUTABLE_FAILURES.has(reason))
+      return;
+    this.markRuntimeUnhealthy(id, reason);
   }
-  const chSeg = parts[1];
-  if (server === DM_SERVER) {
-    const lastHash = chSeg.lastIndexOf("#");
-    if (lastHash < 0)
-      return { server, channel: chSeg };
-    const firstHash = chSeg.indexOf("#");
-    const tail = chSeg.slice(lastHash + 1);
-    const isBareHandle = firstHash === lastHash && /^\d{4,}$/.test(tail);
-    if (isBareHandle)
-      return { server, channel: chSeg };
-    const tailNum = Number(tail.startsWith("#") ? tail.slice(1) : tail);
-    if (!Number.isFinite(tailNum))
-      return { server, channel: chSeg };
-    seq = parseSeq(tail);
-    return { server, channel: chSeg.slice(0, lastHash), seq };
+  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();
   }
-  const hashIdx = chSeg.indexOf("#");
-  if (hashIdx >= 0) {
-    seq = parseSeq(chSeg.slice(hashIdx));
-    return { server, channel: chSeg.slice(0, hashIdx), seq };
+  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();
   }
-  return { server, channel: chSeg };
-}
-function parseThreadTail(segment) {
-  const stripped = segment.startsWith("#") ? segment.slice(1) : segment;
-  const tokens = stripped.split("#");
-  if (tokens.length < 1 || tokens.length > 2) {
-    throw new Error(`bad thread ref tail: #${stripped}`);
+  markLocallyStopped(agentId) {
+    if (!this.running.delete(agentId))
+      return;
+    this.log.info("agent removed from running set (local stop)", { agentId });
+    this.scheduleReadyFrameResend();
   }
-  for (const t of tokens) {
-    if (!t)
-      throw new Error(`bad thread ref tail: #${stripped} (empty seq)`);
+  scheduleReadyFrameResend() {
+    if (this.pendingResend)
+      return;
+    this.pendingResend = true;
+    this.scheduleResend(() => {
+      this.pendingResend = false;
+      try {
+        this.opts.channel.sendReady?.(this.buildReady());
+      } catch {}
+    });
   }
-  const threadRootSeq = parseSeq(tokens[0]);
-  if (tokens.length === 1)
-    return { threadRootSeq };
-  return { threadRootSeq, seq: parseSeq(tokens[1]) };
-}
-function formatRef(p) {
-  if (p.seq !== undefined && p.threadRootSeq === undefined) {
-    throw new Error("formatRef: seq without threadRootSeq is not supported");
+  async runRestartCommand(agentId, launchId, opName, run) {
+    this.log.info(`${opName} received`, { agentId, launchId });
+    try {
+      await this.opts.onBeforeAgent?.(agentId);
+      await run();
+      this.running.add(agentId);
+      this.scheduleReadyFrameResend();
+      this.log.info(`${opName} ok`, { agentId });
+    } catch (err) {
+      if (err instanceof UnknownRuntimeError) {
+        const frame = {
+          type: "session.error",
+          code: "runtime_not_available",
+          agentId,
+          launchId,
+          payload: { requested: err.requested ?? null, available: err.available }
+        };
+        await this.opts.channel.reportSessionError?.(frame);
+        this.log.info(`${opName} error`, { agentId, "error.code": "runtime_not_available" });
+        return;
+      }
+      const code = classifyErrorCode(err);
+      await this.opts.channel.reportWakeAck?.({
+        agentId,
+        launchId,
+        status: "error",
+        error: { code, message: err instanceof Error ? err.message : String(err) }
+      });
+      this.log.warn(`${opName} failed`, {
+        agentId,
+        "error.code": code,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  async onCommand(cmd) {
+    switch (cmd.type) {
+      case "agent:wake":
+        this.log.info("agent:wake received", {
+          agentId: cmd.agentId,
+          channel: cmd.unreadNotice.channel,
+          latestSeq: cmd.unreadNotice.latestSeq
+        });
+        try {
+          const beforeStatus = this.opts.manager.snapshot?.().agents?.[cmd.agentId]?.status ?? "unregistered";
+          const wasActive = this.opts.typingTracker?.hasAny(cmd.agentId) ?? false;
+          await this.opts.onBeforeAgent?.(cmd.agentId);
+          this.opts.manager.register(cmd.agentId, {
+            runtimeConfig: cmd.config,
+            sessionId: cmd.sessionId,
+            launchId: cmd.launchId
+          });
+          this.running.add(cmd.agentId);
+          const channelScope = cmd.unreadNotice.channelId;
+          if (channelScope)
+            this.opts.typingTracker?.add(cmd.agentId, channelScope);
+          const text2 = (this.opts.formatUnreadNoticeText ?? defaultFormatUnreadNoticeText)(cmd.unreadNotice);
+          const producedEffect = this.opts.manager.deliver(cmd.agentId, {
+            seq: cmd.unreadNotice.latestSeq,
+            text: text2
+          });
+          if (producedEffect === false && beforeStatus === "running") {
+            this.log.info("agent:wake produced no effect (coalesced onto running agent)", {
+              agentId: cmd.agentId,
+              latestSeq: cmd.unreadNotice.latestSeq
+            });
+          }
+          if (channelScope && wasActive && beforeStatus === "running") {
+            this.opts.channel.reportAgentTyping?.({
+              agentId: cmd.agentId,
+              channelId: channelScope
+            });
+          }
+          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,
+              launchId: cmd.launchId,
+              payload: {
+                requested: err.requested ?? null,
+                available: err.available
+              }
+            };
+            await this.opts.channel.reportSessionError?.(frame);
+            await this.opts.channel.reportWakeAck?.({
+              agentId: cmd.agentId,
+              launchId: cmd.launchId,
+              status: "error",
+              error: {
+                code: "bot_runtime_missing",
+                message: err.message
+              }
+            });
+            this.log.info("agent:wake ack", {
+              agentId: cmd.agentId,
+              status: "error",
+              "error.code": "bot_runtime_missing"
+            });
+            return;
+          }
+          {
+            const code = classifyErrorCode(err);
+            await this.opts.channel.reportWakeAck?.({
+              agentId: cmd.agentId,
+              launchId: cmd.launchId,
+              status: "error",
+              error: {
+                code,
+                message: err instanceof Error ? err.message : String(err)
+              }
+            });
+            this.log.info("agent:wake ack", { agentId: cmd.agentId, status: "error", "error.code": code });
+          }
+          return;
+        }
+        break;
+      case "agent:reset":
+        await this.runRestartCommand(cmd.agentId, cmd.launchId, "agent:reset", () => this.opts.manager.resetSession(cmd.agentId, {
+          runtimeConfig: cmd.config,
+          launchId: cmd.launchId,
+          rewakePrompt: REWAKE_PROMPT
+        }));
+        break;
+      case "machine:reset_all":
+        for (const r of cmd.resets) {
+          await this.runRestartCommand(r.agentId, r.launchId, "agent:reset", () => this.opts.manager.resetSession(r.agentId, {
+            runtimeConfig: r.config,
+            launchId: r.launchId,
+            rewakePrompt: REWAKE_PROMPT
+          }));
+        }
+        break;
+      case "agent:nap":
+        await this.runRestartCommand(cmd.agentId, cmd.launchId, "agent:nap", () => this.opts.manager.resetSession(cmd.agentId, {
+          runtimeConfig: cmd.config,
+          launchId: cmd.launchId,
+          rewakePrompt: buildNapRewakePrompt(cmd.handoff),
+          barrierType: "nap"
+        }));
+        break;
+      case "agent:model_switch":
+        await this.runRestartCommand(cmd.agentId, cmd.launchId, "agent:model_switch", () => this.opts.manager.switchModel(cmd.agentId, {
+          runtimeConfig: cmd.config,
+          launchId: cmd.launchId,
+          rewakePrompt: MODEL_SWITCH_REWAKE_PROMPT
+        }));
+        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;
+    }
   }
-  const base = `/${p.server}/${p.channel}`;
-  if (p.threadRootSeq === undefined)
-    return base;
-  if (p.seq === undefined)
-    return `${base}/#${p.threadRootSeq}`;
-  return `${base}/#${p.threadRootSeq}#${p.seq}`;
 }
-function parseSeq(s) {
-  const n = Number(s.startsWith("#") ? s.slice(1) : s);
-  if (!Number.isFinite(n))
-    throw new Error(`bad seq: ${s}`);
-  return n;
+// src/manager/typingScopeTracker.ts
+function createTypingScopeTracker() {
+  const scopes = new Map;
+  return {
+    add(agentId, channelId) {
+      let set2 = scopes.get(agentId);
+      if (!set2) {
+        set2 = new Set;
+        scopes.set(agentId, set2);
+      }
+      set2.add(channelId);
+    },
+    snapshot(agentId) {
+      const set2 = scopes.get(agentId);
+      return set2 ? [...set2] : [];
+    },
+    hasAny(agentId) {
+      const set2 = scopes.get(agentId);
+      return !!set2 && set2.size > 0;
+    },
+    clear(agentId) {
+      scopes.delete(agentId);
+    }
+  };
 }
-var HostCommandSchema = exports_external.discriminatedUnion("type", [
-  exports_external.object({
-    type: exports_external.literal("agent:wake"),
-    agentId: exports_external.string().min(1),
-    config: exports_external.unknown(),
-    sessionId: exports_external.string().optional(),
-    launchId: exports_external.string().min(1),
-    unreadNotice: exports_external.unknown()
-  }),
-  exports_external.object({
-    type: exports_external.literal("agent:stop"),
-    agentId: exports_external.string().min(1)
-  }),
-  exports_external.object({
-    type: exports_external.literal("agent:reset"),
-    agentId: exports_external.string().min(1),
-    config: exports_external.unknown(),
-    launchId: exports_external.string().min(1)
-  }),
-  exports_external.object({
-    type: exports_external.literal("agent:nap"),
-    agentId: exports_external.string().min(1),
-    config: exports_external.unknown(),
-    launchId: exports_external.string().min(1),
-    handoff: exports_external.string().min(1)
-  }),
-  exports_external.object({
-    type: exports_external.literal("agent:model_switch"),
-    agentId: exports_external.string().min(1),
-    config: exports_external.unknown(),
-    launchId: exports_external.string().min(1)
-  }),
-  exports_external.object({
-    type: exports_external.literal("machine:reset_all"),
-    resets: exports_external.array(exports_external.object({
-      agentId: exports_external.string().min(1),
-      config: exports_external.unknown(),
-      launchId: exports_external.string().min(1)
-    }))
-  }),
-  exports_external.strictObject({
-    type: exports_external.literal("machine:update")
-  }),
-  exports_external.object({
-    type: exports_external.literal("bot:added"),
-    botId: exports_external.string().min(1),
-    name: exports_external.string().optional(),
-    discriminator: exports_external.string().optional(),
-    description: exports_external.string().optional(),
-    ownerName: exports_external.string().optional(),
-    ownerDiscriminator: exports_external.string().optional()
-  }),
-  exports_external.object({
-    type: exports_external.literal("bot:updated"),
-    botId: exports_external.string().min(1),
-    name: exports_external.string().optional(),
-    discriminator: exports_external.string().optional(),
-    description: exports_external.string().optional(),
-    ownerName: exports_external.string().optional(),
-    ownerDiscriminator: exports_external.string().optional()
-  }),
-  exports_external.object({
-    type: exports_external.literal("bot:removed"),
-    botId: exports_external.string().min(1)
-  }),
-  DiagnosticCollectCommandSchema
-]);
 // src/credentials/credentialProxy.ts
+import * as crypto2 from "crypto";
+import * as fs5 from "fs";
+import * as http from "http";
+import * as https from "https";
+import * as os2 from "os";
+import * as path7 from "path";
+import { URL as URL2 } from "url";
 var LOCAL_MESSAGE_REMINDER_PATH = "/__alook/local/message-reminder";
 var LOCAL_MESSAGE_REMINDER_BODY_MAX_BYTES = 4 * 1024;
 var LOCAL_MESSAGE_REMINDER_MIN_MS = 60000;
@@ -21980,6 +21988,14 @@ function writeJson(res, status, body) {
   res.writeHead(status, { "content-type": "application/json" });
   res.end(JSON.stringify(body));
 }
+function normalizeContentEncoding(value) {
+  const normalized = (Array.isArray(value) ? value.join(",") : value ?? "").trim().toLowerCase();
+  if (!normalized || normalized === "identity")
+    return "identity";
+  if (normalized === "gzip" || normalized === "deflate" || normalized === "br")
+    return normalized;
+  return "other";
+}
 function isCanonicalChannelScope(channel2) {
   try {
     const parsed = parseRef(channel2);
@@ -22076,6 +22092,11 @@ async function startCredentialProxy(broker, options = {}) {
   const upstreamClient = upstream.protocol === "https:" ? https : http;
   const onPull = options.onInboxPullResponse;
   const onProxyRequest = options.onProxyRequest;
+  const reportInboxPullObservationError = (failure) => {
+    try {
+      options.onInboxPullObservationError?.(failure);
+    } catch {}
+  };
   const server = http.createServer((req, res) => {
     const pathname = new URL2(req.url ?? "/", "http://placeholder").pathname;
     if (pathname.startsWith("/__alook/local/")) {
@@ -22114,7 +22135,20 @@ async function startCredentialProxy(broker, options = {}) {
       return;
     }
     const reg = verdict.reg;
-    const isInboxPull = onPull && pathname === "/api/community/users/me/inbox/pull";
+    const isInboxPull = req.method === "POST" && pathname === "/api/community/users/me/inbox/pull";
+    const shouldObserveInboxPull = Boolean(isInboxPull && onPull);
+    let inboxPullObservationToken;
+    if (shouldObserveInboxPull) {
+      try {
+        inboxPullObservationToken = options.onInboxPullStart?.(reg.agentId);
+      } catch {
+        reportInboxPullObservationError({
+          agentId: reg.agentId,
+          reason: "observer_failed",
+          contentEncoding: "identity"
+        });
+      }
+    }
     if (onProxyRequest) {
       try {
         onProxyRequest(reg.agentId, req.method ?? "GET", pathname);
@@ -22127,6 +22161,8 @@ async function startCredentialProxy(broker, options = {}) {
     outHeaders[broker.headerNames.agentId.toLowerCase()] = reg.agentId;
     outHeaders[broker.headerNames.client.toLowerCase()] = broker.clientLabel;
     outHeaders[broker.headerNames.capabilities.toLowerCase()] = [...reg.capabilities].join(",");
+    if (isInboxPull)
+      outHeaders["accept-encoding"] = "identity";
     let responded = false;
     let upstreamRes;
     const upstreamReq = upstreamClient.request({
@@ -22145,18 +22181,54 @@ async function startCredentialProxy(broker, options = {}) {
       };
       res_.on("error", destroyResIfIncomplete);
       res_.on("close", destroyResIfIncomplete);
-      if (isInboxPull && res_.statusCode && res_.statusCode < 300) {
+      if (shouldObserveInboxPull && res_.statusCode !== undefined && res_.statusCode >= 200 && res_.statusCode < 300) {
         const chunks = [];
         res_.on("data", (chunk) => chunks.push(chunk));
         res_.on("end", () => {
           const body = Buffer.concat(chunks);
+          const contentEncoding = normalizeContentEncoding(res_.headers["content-encoding"]);
+          if (contentEncoding !== "identity") {
+            reportInboxPullObservationError({
+              agentId: reg.agentId,
+              reason: "unexpected_content_encoding",
+              contentEncoding
+            });
+          } else {
+            let parsed;
+            try {
+              parsed = JSON.parse(body.toString("utf8"));
+            } catch {
+              reportInboxPullObservationError({
+                agentId: reg.agentId,
+                reason: "invalid_json",
+                contentEncoding
+              });
+            }
+            if (parsed !== undefined) {
+              if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !Array.isArray(parsed.messages)) {
+                reportInboxPullObservationError({
+                  agentId: reg.agentId,
+                  reason: "invalid_inbox_shape",
+                  contentEncoding
+                });
+              } else {
+                const messages = parsed.messages;
+                if (messages.length > 0) {
+                  try {
+                    onPull(reg.agentId, messages, inboxPullObservationToken);
+                  } catch {
+                    reportInboxPullObservationError({
+                      agentId: reg.agentId,
+                      reason: "observer_failed",
+                      contentEncoding
+                    });
+                  }
+                }
+              }
+            }
+          }
           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);
@@ -22481,6 +22553,236 @@ function writeStatusFile(path8, snapshot) {
   } catch {}
 }
 
+// src/manager/wakeCoordinator.ts
+class WakeCoordinator {
+  agents = new Map;
+  async run(command, dispatch, onDesiredAdvance) {
+    const state = this.agent(command.agentId);
+    const channel2 = command.unreadNotice.channel;
+    const seq = command.unreadNotice.latestSeq;
+    const scope = state.scopes.get(channel2);
+    const coveredSeq = Math.max(scope?.modelSeenSeq ?? 0, scope?.admittedSeq ?? 0);
+    if (seq <= coveredSeq) {
+      this.rememberReplacement(state, command);
+      return { state: "suppressed", coveredSeq };
+    }
+    const desiredAdvanced = !scope || seq > scope.desiredSeq;
+    if (!scope || seq >= scope.desiredSeq) {
+      state.scopes.set(channel2, {
+        desiredSeq: Math.max(scope?.desiredSeq ?? 0, seq),
+        admittedSeq: scope?.admittedSeq ?? 0,
+        modelSeenSeq: scope?.modelSeenSeq ?? 0,
+        command
+      });
+    }
+    if (desiredAdvanced)
+      onDesiredAdvance?.(command);
+    state.dispatch = dispatch;
+    if (state.active || state.admitting) {
+      this.rememberReplacement(state, command);
+      return { state: "suppressed", coveredSeq: seq };
+    }
+    await this.admit(command.agentId, command);
+    return { state: "accepted" };
+  }
+  modelSeenGeneration(agentId) {
+    return this.agent(agentId).observationGeneration;
+  }
+  recordModelSeen(agentId, messages, generation) {
+    const state = this.agent(agentId);
+    if (generation !== state.observationGeneration)
+      return false;
+    for (const message2 of messages) {
+      const seq = Number(message2.seq.startsWith("#") ? message2.seq.slice(1) : message2.seq);
+      if (!Number.isSafeInteger(seq) || seq <= 0)
+        continue;
+      const scope = state.scopes.get(message2.channel);
+      if (scope) {
+        scope.modelSeenSeq = Math.max(scope.modelSeenSeq, seq);
+      } else {
+        state.scopes.set(message2.channel, {
+          desiredSeq: 0,
+          admittedSeq: 0,
+          modelSeenSeq: seq,
+          command: null
+        });
+      }
+    }
+    return true;
+  }
+  recordAgentActivity(agentId, activity) {
+    const state = this.agent(agentId);
+    if (activity === "starting" || activity === "running") {
+      state.active = true;
+      return;
+    }
+    if (activity !== "idle")
+      return;
+    state.active = false;
+    state.activeAdmission = null;
+    const next = this.nextPending(state);
+    if (next && state.dispatch)
+      this.admit(agentId, next);
+  }
+  recordDeliveryAck(agentId, launchId, status) {
+    const state = this.agents.get(agentId);
+    const admission = state?.activeAdmission;
+    if (!state || !admission || admission.launchId !== launchId)
+      return;
+    if (status === "ok")
+      return;
+    for (const [channel2, coverage] of admission.coverage) {
+      const scope = state.scopes.get(channel2);
+      if (scope?.admittedSeq === coverage.admittedSeq) {
+        scope.admittedSeq = coverage.previousSeq;
+      }
+    }
+    state.active = false;
+    state.failedAdmissionLaunchId = launchId;
+    state.retryAfterFailure = state.coalescedReplacement;
+    state.coalescedReplacement = null;
+    state.activeAdmission = null;
+    if (!state.admitting && state.retryAfterFailure) {
+      this.retryFailedAdmission(agentId, state).catch(() => {});
+    }
+  }
+  invalidate(agentId, clearModelSeen) {
+    const state = this.agent(agentId);
+    state.observationGeneration += 1;
+    state.active = false;
+    state.admitting = false;
+    state.activeAdmission = null;
+    state.failedAdmissionLaunchId = null;
+    state.coalescedReplacement = null;
+    state.retryAfterFailure = null;
+    if (clearModelSeen) {
+      state.scopes.clear();
+      return;
+    }
+    for (const scope of state.scopes.values()) {
+      scope.desiredSeq = scope.modelSeenSeq;
+      scope.admittedSeq = scope.modelSeenSeq;
+    }
+  }
+  agent(agentId) {
+    let state = this.agents.get(agentId);
+    if (!state) {
+      state = {
+        active: false,
+        admitting: false,
+        activeAdmission: null,
+        failedAdmissionLaunchId: null,
+        coalescedReplacement: null,
+        retryAfterFailure: null,
+        observationGeneration: 0,
+        scopes: new Map,
+        dispatch: null
+      };
+      this.agents.set(agentId, state);
+    }
+    return state;
+  }
+  nextPending(state) {
+    let next = null;
+    for (const scope of state.scopes.values()) {
+      if (scope.desiredSeq <= Math.max(scope.modelSeenSeq, scope.admittedSeq))
+        continue;
+      if (!scope.command)
+        continue;
+      if (scope.command.launchId === state.failedAdmissionLaunchId)
+        continue;
+      if (!next || scope.desiredSeq > next.desiredSeq)
+        next = scope;
+    }
+    return next?.command ?? null;
+  }
+  async admit(agentId, preferred) {
+    const state = this.agent(agentId);
+    if (state.active || state.admitting || !state.dispatch)
+      return;
+    const admissionGeneration = state.observationGeneration;
+    const command = preferred ?? this.nextPending(state);
+    if (!command)
+      return;
+    const commandScope = state.scopes.get(command.unreadNotice.channel);
+    if (commandScope && command.unreadNotice.latestSeq >= commandScope.desiredSeq) {
+      commandScope.command = command;
+    }
+    const coverage = new Map;
+    for (const [channel2, scope] of state.scopes) {
+      if (scope.desiredSeq <= Math.max(scope.modelSeenSeq, scope.admittedSeq))
+        continue;
+      coverage.set(channel2, {
+        previousSeq: scope.admittedSeq,
+        admittedSeq: scope.desiredSeq
+      });
+      scope.admittedSeq = scope.desiredSeq;
+      scope.command = command;
+    }
+    if (coverage.size === 0)
+      return;
+    state.admitting = true;
+    state.active = true;
+    state.failedAdmissionLaunchId = null;
+    state.coalescedReplacement = null;
+    state.activeAdmission = { launchId: command.launchId, coverage };
+    let dispatchError;
+    try {
+      await state.dispatch(command);
+    } catch (error51) {
+      if (state.observationGeneration === admissionGeneration) {
+        for (const [channel2, admitted] of coverage) {
+          const scope = state.scopes.get(channel2);
+          if (scope?.admittedSeq === admitted.admittedSeq) {
+            scope.admittedSeq = admitted.previousSeq;
+          }
+        }
+        state.active = false;
+        state.failedAdmissionLaunchId = command.launchId;
+        state.retryAfterFailure = state.coalescedReplacement;
+        state.coalescedReplacement = null;
+        state.activeAdmission = null;
+      }
+      dispatchError = error51;
+    } finally {
+      if (state.observationGeneration === admissionGeneration) {
+        state.admitting = false;
+      }
+    }
+    if (state.observationGeneration === admissionGeneration) {
+      await this.retryFailedAdmission(agentId, state);
+      if (!state.active && !state.admitting) {
+        const next = this.nextPending(state);
+        if (next)
+          await this.admit(agentId, next);
+      }
+    }
+    if (dispatchError)
+      throw dispatchError;
+  }
+  rememberReplacement(state, command) {
+    const failedOrActiveLaunchId = state.activeAdmission?.launchId ?? state.failedAdmissionLaunchId;
+    if (!failedOrActiveLaunchId || command.launchId === failedOrActiveLaunchId)
+      return;
+    const scope = state.scopes.get(command.unreadNotice.channel);
+    if (!scope || command.unreadNotice.latestSeq < scope.desiredSeq)
+      return;
+    state.coalescedReplacement = command;
+    if (state.failedAdmissionLaunchId)
+      state.retryAfterFailure = command;
+  }
+  async retryFailedAdmission(agentId, state) {
+    if (state.active || state.admitting)
+      return;
+    const replacement = state.retryAfterFailure;
+    state.retryAfterFailure = null;
+    if (!replacement)
+      return;
+    state.failedAdmissionLaunchId = null;
+    await this.admit(agentId, replacement);
+  }
+}
+
 // src/server/wsControlChannel.ts
 var WS_CONTROL_COMMAND_CONSUMED = Symbol("ws-control-command-consumed");
 var DEFAULT_PING_INTERVAL_MS = 15000;
@@ -22495,6 +22797,7 @@ class WsControlChannel {
   opts;
   statusValue = "idle";
   commandCbs = [];
+  wakeDesiredCbs = [];
   resyncHooks = [];
   ws = null;
   attempt = 0;
@@ -22504,6 +22807,7 @@ class WsControlChannel {
   pongDeadline = 0;
   resyncProvider = null;
   log;
+  wakeCoordinator = new WakeCoordinator;
   constructor(opts) {
     this.opts = opts;
     this.log = opts.logger ?? createLogger({ header: "@alook/daemon:ws" });
@@ -22526,6 +22830,30 @@ class WsControlChannel {
   onCommand(cb) {
     this.commandCbs.push(cb);
   }
+  onWakeDesiredAdvance(cb) {
+    this.wakeDesiredCbs.push(cb);
+  }
+  async ingestCommand(frame) {
+    const parsed = HostCommandSchema.safeParse(frame);
+    if (!parsed.success) {
+      this.log.warn("dropped malformed HostCommand frame", {
+        type: typeof frame === "object" && frame !== null && "type" in frame ? String(frame.type) : "unknown",
+        issues: parsed.error.issues.map((issue3) => ({
+          path: issue3.path.join("."),
+          code: issue3.code
+        }))
+      });
+      return false;
+    }
+    await this.dispatchIngressCommand(parsed.data);
+    return true;
+  }
+  modelSeenGeneration(agentId) {
+    return this.wakeCoordinator.modelSeenGeneration(agentId);
+  }
+  recordModelSeen(agentId, messages, generation = this.wakeCoordinator.modelSeenGeneration(agentId)) {
+    return this.wakeCoordinator.recordModelSeen(agentId, messages, generation);
+  }
   onResync(provider) {
     this.resyncProvider = provider;
   }
@@ -22542,6 +22870,7 @@ class WsControlChannel {
     this.sendFrame({ type: "agent_session", ...info });
   }
   async reportAgentActivity(info) {
+    this.wakeCoordinator.recordAgentActivity(info.agentId, info.state);
     this.sendFrame({ type: "agent_activity", ...info });
   }
   reportAgentTyping(info) {
@@ -22554,6 +22883,7 @@ class WsControlChannel {
     this.sendFrame(frame);
   }
   async reportWakeAck(info) {
+    this.wakeCoordinator.recordDeliveryAck(info.agentId, info.launchId, info.status);
     this.sendFrame({ type: "agent_wake_ack", ...info });
   }
   async reportStoppedAck(info) {
@@ -22625,27 +22955,75 @@ class WsControlChannel {
       return;
     }
     this.attempt = 0;
-    const parsed = HostCommandSchema.safeParse(frame);
-    if (!parsed.success) {
-      this.log.warn("dropped malformed HostCommand frame", {
-        type: frame.type,
-        issues: parsed.error.issues.map((i) => ({ path: i.path.join("."), code: i.code }))
-      });
-      return;
-    }
-    const cmd = parsed.data;
+    this.ingestCommand(frame).catch((err) => {
+      this.log.warn("command ingress failed", { type: frame.type, err: describeErr(err) });
+    });
+  }
+  async dispatchListeners(cmd) {
+    const pending = [];
     for (const cb of this.commandCbs) {
       try {
         const result = cb(cmd);
         if (result === WS_CONTROL_COMMAND_CONSUMED)
           break;
-        Promise.resolve(result).catch((err) => {
+        pending.push(Promise.resolve(result).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) });
       }
     }
+    await Promise.all(pending);
+  }
+  async dispatchIngressCommand(cmd) {
+    if (cmd.type === "machine:heartbeat") {
+      this.sendFrame({ type: "machine_heartbeat_ack", nonce: cmd.nonce });
+      return;
+    }
+    if (cmd.type === "diagnostics:collect") {
+      this.sendFrame({ type: "diagnostics_ack", reportId: cmd.reportId });
+      await this.dispatchListeners(cmd);
+      return;
+    }
+    if (cmd.type === "agent:wake") {
+      const result = await this.wakeCoordinator.run(cmd, (accepted) => this.dispatchListeners(accepted), (advanced) => {
+        for (const cb of this.wakeDesiredCbs) {
+          try {
+            cb(advanced);
+          } catch (err) {
+            this.log.warn("wake desired observer threw", { err: describeErr(err) });
+          }
+        }
+      });
+      if (result.state === "suppressed") {
+        await this.reportWakeAck({
+          agentId: cmd.agentId,
+          launchId: cmd.launchId,
+          status: "ok"
+        });
+        this.log.debug("duplicate wake suppressed", {
+          agentId: cmd.agentId,
+          channel: cmd.unreadNotice.channel,
+          latestSeq: cmd.unreadNotice.latestSeq,
+          coveredSeq: result.coveredSeq
+        });
+      }
+      return;
+    }
+    if (cmd.type === "machine:reset_all") {
+      for (const reset of cmd.resets)
+        this.wakeCoordinator.invalidate(reset.agentId, true);
+      await this.dispatchListeners(cmd);
+      return;
+    }
+    if (cmd.type === "agent:stop" || cmd.type === "agent:model_switch") {
+      this.wakeCoordinator.invalidate(cmd.agentId, false);
+    } else if (cmd.type === "agent:reset" || cmd.type === "agent:nap") {
+      this.wakeCoordinator.invalidate(cmd.agentId, true);
+    } else if (cmd.type === "bot:removed") {
+      this.wakeCoordinator.invalidate(cmd.botId, true);
+    }
+    await this.dispatchListeners(cmd);
   }
   onSocketClosed(code, reason) {
     this.log.warn("control channel closed", { code, reason: reason ? String(reason) : "" });
@@ -22680,7 +23058,10 @@ class WsControlChannel {
     this.pingTimer = setInterval(() => {
       if (this.now() > this.pongDeadline) {
         this.log.warn("heartbeat pong timeout — forcing reconnect");
-        this.ws?.close();
+        if (this.ws?.terminate)
+          this.ws.terminate();
+        else
+          this.ws?.close();
         return;
       }
       this.log.debug("heartbeat ping");
@@ -23259,6 +23640,8 @@ function createTimelineRecorder(opts) {
       sessionByAgent.set(agentId, sessionId);
     },
     appendEntryForAgent(agentId, messages) {
+      if (messages.length === 0)
+        return;
       const dir = dirFor(agentId);
       if (!prepareTimelineDirectory(dir))
         return;
@@ -23747,7 +24130,16 @@ async function createDaemon(opts) {
   const typingTracker = createTypingScopeTracker();
   const broker = new CredentialBroker({ upstreamBaseUrl: opts.serverUrl });
   const proxy = await startCredentialProxy(broker, {
-    onInboxPullResponse: (agentId, messages) => timeline2.appendEntryForAgent(agentId, messages),
+    onInboxPullStart: (agentId) => channelRef?.modelSeenGeneration(agentId),
+    onInboxPullResponse: (agentId, messages, observationToken) => {
+      timeline2.appendEntryForAgent(agentId, messages);
+      if (typeof observationToken === "number") {
+        channelRef?.recordModelSeen(agentId, messages, observationToken);
+      }
+    },
+    onInboxPullObservationError: ({ agentId, reason, contentEncoding }) => {
+      log.warn("inbox pull timeline observation failed", { agentId, reason, contentEncoding });
+    },
     onMessageReminderArm: (input) => reminderSchedulerRef?.arm(input) ?? { armed: false, reason: "reminder_scheduler_unavailable" },
     onProxyRequest: (agentId, method, pathname) => {
       const subcommand = deriveAuditLogSubcommand(pathname, method);
@@ -23848,11 +24240,29 @@ async function createDaemon(opts) {
       if (!res.ok)
         throw new Error(`resync-wakes ${res.status}`);
       const json2 = await res.json();
-      log.info("wake resync completed", { woken: json2.woken ?? 0 });
+      log.info("wake resync completed", { attempted: json2.attempted ?? 0 });
     } catch (err) {
       log.warn("wake resync failed", { err: err instanceof Error ? err.message : String(err) });
     }
   }
+  async function resyncPendingDiagnostics() {
+    try {
+      const res = await fetch(`${opts.serverUrl}/api/community/daemon/resync-diagnostics`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${opts.machineKey}` }
+      });
+      if (!res.ok)
+        throw new Error(`resync-diagnostics ${res.status}`);
+      const json2 = await res.json();
+      log.info("diagnostics resync completed", {
+        pending: json2.pending ?? 0,
+        attempted: json2.attempted ?? 0,
+        ambiguous: json2.ambiguous ?? 0
+      });
+    } catch (err) {
+      log.warn("diagnostics resync failed", { err: err instanceof Error ? err.message : String(err) });
+    }
+  }
   const enrollAgent = async (agentId) => {
     const existing = enrolledKeys.get(agentId);
     if (existing)
@@ -24028,7 +24438,10 @@ async function createDaemon(opts) {
   let statusTimer = null;
   if (opts.statusFilePath) {
     const statusPath = opts.statusFilePath;
-    const writeStatus = () => writeStatusFile(statusPath, { writtenAt: Date.now(), agents: manager.statusProjection(Date.now()) });
+    const writeStatus = () => {
+      const nowMs = Date.now();
+      writeStatusFile(statusPath, { writtenAt: nowMs, agents: manager.statusProjection(nowMs) });
+    };
     writeStatus();
     statusTimer = setInterval(writeStatus, STATUS_WRITE_INTERVAL_MS);
     statusTimer.unref?.();
@@ -24075,11 +24488,11 @@ async function createDaemon(opts) {
     handleDiagnosticCommand: opts.handleDiagnosticCommand,
     reportDiagnosticFailure: opts.reportDiagnosticFailure
   }));
+  channel2.onWakeDesiredAdvance((cmd) => {
+    reminderSchedulerRef?.observe(cmd.agentId, cmd.unreadNotice.channel, cmd.unreadNotice.latestSeq);
+  });
   channel2.onCommand((cmd) => {
     switch (cmd.type) {
-      case "agent:wake":
-        reminderSchedulerRef?.observe(cmd.agentId, cmd.unreadNotice.channel, cmd.unreadNotice.latestSeq);
-        break;
       case "agent:stop":
         reminderSchedulerRef?.clearAgent(cmd.agentId);
         break;
@@ -24096,6 +24509,7 @@ async function createDaemon(opts) {
   channel2.onOpen(() => {
     coldStartWarmup();
     resyncPendingWakes();
+    resyncPendingDiagnostics();
   });
   channel2.connect();
   await router.start();