@alook/daemon 0.1.12 → 0.1.13

package/dist/index.js

@@ -4819,382 +4819,6 @@ ${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 + `
-
-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, {
@@ -21717,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}`);
@@ -21728,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;
@@ -21984,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);
@@ -22080,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/")) {
@@ -22118,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);
@@ -22131,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({
@@ -22149,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);
@@ -22485,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;
@@ -22499,6 +22797,7 @@ class WsControlChannel {
   opts;
   statusValue = "idle";
   commandCbs = [];
+  wakeDesiredCbs = [];
   resyncHooks = [];
   ws = null;
   attempt = 0;
@@ -22508,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" });
@@ -22530,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;
   }
@@ -22546,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) {
@@ -22558,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) {
@@ -22629,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) : "" });
@@ -22684,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");
@@ -23263,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;
@@ -23751,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);
@@ -23852,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)
@@ -24082,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;
@@ -24103,6 +24509,7 @@ async function createDaemon(opts) {
   channel2.onOpen(() => {
     coldStartWarmup();
     resyncPendingWakes();
+    resyncPendingDiagnostics();
   });
   channel2.connect();
   await router.start();