@alook/daemon 0.1.6 → 0.1.8

package/dist/cli/index.js

@@ -98,7 +98,7 @@ var init_nanoid = () => {};
 // src/cli/index.ts
 import { Command, CommanderError } from "commander";
 import { realpathSync as realpathSync2 } from "node:fs";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -16762,6 +16762,17 @@ function parseThreadTail(segment) {
     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))
@@ -16808,6 +16819,9 @@ var HostCommandSchema = exports_external.discriminatedUnion("type", [
       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),
@@ -18616,6 +18630,32 @@ function parseInviteToken(input) {
     return urlMatch[1];
   return BARE_TOKEN_RE.test(trimmed) ? trimmed : null;
 }
+// ../shared/src/semver.ts
+var RELEASE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+function parseReleaseVersion(value) {
+  const match = RELEASE_VERSION_PATTERN.exec(value);
+  if (!match)
+    return null;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  if (![major, minor, patch].every(Number.isSafeInteger))
+    return null;
+  return [major, minor, patch];
+}
+function releaseVersionGte(a, b) {
+  const parsedA = parseReleaseVersion(a);
+  const parsedB = parseReleaseVersion(b);
+  if (!parsedA || !parsedB)
+    return false;
+  for (let i = 0;i < parsedA.length; i++) {
+    if (parsedA[i] > parsedB[i])
+      return true;
+    if (parsedA[i] < parsedB[i])
+      return false;
+  }
+  return true;
+}
 // src/cli/proxyServerApi.ts
 function proxyServerApiFromEnv(prefix = "ALOOK", env = process.env) {
   const proxyUrl = env[`${prefix}_PROXY_URL`];
@@ -18985,9 +19025,9 @@ function createProxyServerApi(config2) {
 }
 
 // src/cli/daemonStart.ts
-import * as fs11 from "fs";
-import * as path12 from "path";
-import * as crypto4 from "crypto";
+import * as fs12 from "fs";
+import * as path13 from "path";
+import * as crypto5 from "crypto";
 import * as os3 from "os";
 import { homedir as homedir4 } from "os";
 
@@ -19033,7 +19073,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).`,
+    `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\`.`,
     `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\`).`,
@@ -19182,7 +19222,13 @@ function utilsSection() {
     "",
     "### Join a new server",
     "",
-    `If a message contains a \`/c/invite/...\` link, just run \`${CLI} server join --invite <link>\`. ` + "The server enforces owner-only: it accepts only invites your owner created and rejects the " + "rest with a reason. Safe to attempt without reasoning about who sent it."
+    `If a message contains a \`/c/invite/...\` link, just run \`${CLI} server join --invite <link>\`. ` + "The server enforces owner-only: it accepts only invites your owner created and rejects the " + "rest with a reason. Safe to attempt without reasoning about who sent it.",
+    "",
+    "### Follow up when a conversation goes quiet",
+    "",
+    `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\`.`
   ].join(`
 `);
 }
@@ -20253,13 +20299,18 @@ function resolveCodexHomeRootFromEnv(env = process.env, opts = {}) {
 // src/version.ts
 import { createRequire as createRequire2 } from "module";
 var requireFromHere = createRequire2(import.meta.url);
+var PACKAGE_JSON_CANDIDATES = ["../package.json", "../../package.json"];
 function readDaemonVersion() {
-  try {
-    const pkg = requireFromHere("../package.json");
-    return pkg.version ?? "";
-  } catch {
-    return "";
+  for (const candidate of PACKAGE_JSON_CANDIDATES) {
+    try {
+      const pkg = requireFromHere(candidate);
+      if (typeof pkg.version === "string" && pkg.version.length > 0)
+        return pkg.version;
+    } catch {
+      continue;
+    }
   }
+  return "";
 }
 function getDaemonClientInfo() {
   return { name: "alook-daemon", version: readDaemonVersion() };
@@ -21362,8 +21413,8 @@ function createLogger2(options = {}) {
 }
 
 // src/cli/daemonRunner.ts
-import * as fs10 from "node:fs";
-import * as path11 from "node:path";
+import * as fs11 from "node:fs";
+import * as path12 from "node:path";
 import { WebSocket } from "ws";
 
 // src/daemon/createDaemon.ts
@@ -21862,6 +21913,10 @@ import * as https from "https";
 import * as os2 from "os";
 import * as path9 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;
+var LOCAL_MESSAGE_REMINDER_MAX_MS = 24 * 60 * 60000;
 var DEFAULT_HEADER_NAMES = {
   agentId: "X-Agent-Id",
   client: "X-Client",
@@ -21977,6 +22032,99 @@ var DEFAULT_CAPABILITY_RESOLVER = (method, pathname) => {
   return;
 };
 var DEFAULT_UPSTREAM_TIMEOUT_MS = 20000;
+function writeJson(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function isCanonicalChannelScope(channel2) {
+  try {
+    const parsed = parseRef(channel2);
+    if (!parsed.channel || parsed.seq !== undefined)
+      return false;
+    if (parsed.threadRootSeq !== undefined && (!Number.isSafeInteger(parsed.threadRootSeq) || parsed.threadRootSeq < 1)) {
+      return false;
+    }
+    const handle = parseNameAndTag(parsed.server === ".dm" ? parsed.channel : parsed.server);
+    if (!handle || `${handle.name}#${handle.discriminator}` !== (parsed.server === ".dm" ? parsed.channel : parsed.server)) {
+      return false;
+    }
+    return formatRef(parsed) === channel2;
+  } catch {
+    return false;
+  }
+}
+function parseLocalMessageReminderBody(body, agentId) {
+  let value;
+  try {
+    value = JSON.parse(body.toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record2 = value;
+  if (Object.keys(record2).sort().join(",") !== "channel,remindAfterMs,sentSeq")
+    return null;
+  if (typeof record2.channel !== "string" || !isCanonicalChannelScope(record2.channel))
+    return null;
+  if (!Number.isSafeInteger(record2.sentSeq) || record2.sentSeq < 1)
+    return null;
+  if (!Number.isSafeInteger(record2.remindAfterMs) || record2.remindAfterMs < LOCAL_MESSAGE_REMINDER_MIN_MS || record2.remindAfterMs > LOCAL_MESSAGE_REMINDER_MAX_MS)
+    return null;
+  return {
+    agentId,
+    channel: record2.channel,
+    sentSeq: record2.sentSeq,
+    remindAfterMs: record2.remindAfterMs
+  };
+}
+async function handleLocalMessageReminder(req, res, agentId, onArm) {
+  const contentType = req.headers["content-type"] ?? "";
+  if (!contentType.toLowerCase().startsWith("application/json")) {
+    writeJson(res, 415, { error: "content-type must be application/json", code: "unsupported_media_type" });
+    req.resume();
+    return;
+  }
+  const declaredLength = Number(req.headers["content-length"] ?? 0);
+  if (!Number.isFinite(declaredLength) || declaredLength > LOCAL_MESSAGE_REMINDER_BODY_MAX_BYTES) {
+    writeJson(res, 413, { error: "request body too large", code: "body_too_large" });
+    req.resume();
+    return;
+  }
+  const chunks = [];
+  let bytes = 0;
+  let tooLarge = false;
+  await new Promise((resolve4) => {
+    req.on("data", (chunk2) => {
+      bytes += chunk2.byteLength;
+      if (bytes > LOCAL_MESSAGE_REMINDER_BODY_MAX_BYTES) {
+        tooLarge = true;
+      } else {
+        chunks.push(chunk2);
+      }
+    });
+    req.on("end", resolve4);
+    req.on("error", resolve4);
+  });
+  if (tooLarge) {
+    writeJson(res, 413, { error: "request body too large", code: "body_too_large" });
+    return;
+  }
+  const input = parseLocalMessageReminderBody(Buffer.concat(chunks), agentId);
+  if (!input) {
+    writeJson(res, 400, { error: "invalid local message reminder request", code: "invalid_request" });
+    return;
+  }
+  if (!onArm) {
+    writeJson(res, 503, { error: "local message reminder unavailable", code: "reminder_unavailable" });
+    return;
+  }
+  try {
+    writeJson(res, 200, await onArm(input));
+  } catch {
+    writeJson(res, 500, { error: "local message reminder failed", code: "reminder_failed" });
+  }
+}
 async function startCredentialProxy(broker, options = {}) {
   const host = options.host ?? "127.0.0.1";
   const resolveCap = options.capabilityResolver ?? DEFAULT_CAPABILITY_RESOLVER;
@@ -21986,6 +22134,26 @@ async function startCredentialProxy(broker, options = {}) {
   const onProxyRequest = options.onProxyRequest;
   const server = http.createServer((req, res) => {
     const pathname = new URL2(req.url ?? "/", "http://placeholder").pathname;
+    if (pathname.startsWith("/__alook/local/")) {
+      if (req.url !== LOCAL_MESSAGE_REMINDER_PATH) {
+        writeJson(res, 404, { error: "unknown local route", code: "not_found" });
+        req.resume();
+        return;
+      }
+      if (req.method !== "PUT") {
+        writeJson(res, 405, { error: "method not allowed", code: "method_not_allowed" });
+        req.resume();
+        return;
+      }
+      const localVerdict = broker.check(req.headers["authorization"], "send");
+      if (!localVerdict.ok) {
+        writeJson(res, localVerdict.status, { error: localVerdict.error, code: localVerdict.code });
+        req.resume();
+        return;
+      }
+      handleLocalMessageReminder(req, res, localVerdict.reg.agentId, options.onMessageReminderArm);
+      return;
+    }
     const requiredCap = resolveCap(req.method ?? "GET", pathname);
     const verdict = broker.check(req.headers["authorization"], requiredCap);
     if (!verdict.ok) {
@@ -24818,6 +24986,108 @@ function createDiagnosticsCommandListener(options) {
   };
 }
 
+// src/daemon/selfUpdateCommand.ts
+function createSelfUpdateCommandListener(handleSelfUpdate) {
+  return (command) => {
+    if (command.type !== "machine:update")
+      return;
+    if (handleSelfUpdate) {
+      try {
+        Promise.resolve(handleSelfUpdate()).catch(() => {});
+      } catch {}
+    }
+    return WS_CONTROL_COMMAND_CONSUMED;
+  };
+}
+
+// src/daemon/messageReminderScheduler.ts
+function reminderKey(agentId, channel2) {
+  return `${agentId}\x00${channel2}`;
+}
+function reminderPrompt(channel2, sentRef, startedAt) {
+  return `Reminder: At ${localISOString(new Date(startedAt))}, after sending ${sentRef} in ${channel2}, you asked to be reminded if no newer message arrived. No newer message has arrived in that conversation.`;
+}
+
+class MessageReminderScheduler {
+  options;
+  reminders = new Map;
+  latestObservedSeq = new Map;
+  now;
+  setTimer;
+  clearTimer;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.setTimer = options.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+    this.clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
+  }
+  arm(input) {
+    const key = reminderKey(input.agentId, input.channel);
+    const latest = this.latestObservedSeq.get(key);
+    if (latest !== undefined && latest > input.sentSeq) {
+      return { armed: false, reason: "newer_message_observed" };
+    }
+    this.clearReminder(key);
+    const startedAt = this.now();
+    const dueAt = startedAt + input.remindAfterMs;
+    const sentRef = `${input.channel}#${input.sentSeq}`;
+    const record2 = {
+      ...input,
+      sentRef,
+      startedAt,
+      dueAt,
+      timer: undefined
+    };
+    record2.timer = this.setTimer(() => {
+      if (this.reminders.get(key) !== record2)
+        return;
+      this.reminders.delete(key);
+      try {
+        const delivery = this.options.deliver(input.agentId, {
+          text: reminderPrompt(input.channel, sentRef, startedAt)
+        });
+        Promise.resolve(delivery).catch(() => {});
+      } catch {}
+    }, input.remindAfterMs);
+    record2.timer.unref?.();
+    this.reminders.set(key, record2);
+    return { armed: true, dueAt };
+  }
+  observe(agentId, channel2, latestSeq) {
+    const key = reminderKey(agentId, channel2);
+    const previous = this.latestObservedSeq.get(key);
+    if (previous === undefined || latestSeq > previous) {
+      this.latestObservedSeq.set(key, latestSeq);
+    }
+    const reminder = this.reminders.get(key);
+    if (reminder && latestSeq > reminder.sentSeq)
+      this.clearReminder(key);
+  }
+  clearAgent(agentId) {
+    const prefix = `${agentId}\x00`;
+    for (const key of [...this.reminders.keys()]) {
+      if (key.startsWith(prefix))
+        this.clearReminder(key);
+    }
+    for (const key of [...this.latestObservedSeq.keys()]) {
+      if (key.startsWith(prefix))
+        this.latestObservedSeq.delete(key);
+    }
+  }
+  clearAll() {
+    for (const key of [...this.reminders.keys()])
+      this.clearReminder(key);
+    this.latestObservedSeq.clear();
+  }
+  clearReminder(key) {
+    const reminder = this.reminders.get(key);
+    if (!reminder)
+      return;
+    this.reminders.delete(key);
+    this.clearTimer(reminder.timer);
+  }
+}
+
 // src/daemon/createDaemon.ts
 var WARMUP_BACKOFF_MS = [250, 500, 1000, 2000, 4000];
 var WARMUP_CEILING_MS = 30000;
@@ -24948,6 +25218,7 @@ async function createDaemon(opts) {
   });
   let channelRef = null;
   let managerRef = null;
+  let reminderSchedulerRef = null;
   const emitBotAuditEvent = (agentId, event, context) => {
     channelRef?.reportBotAuditEvent?.({
       type: "bot_audit_event",
@@ -24961,6 +25232,7 @@ async function createDaemon(opts) {
   const broker = new CredentialBroker({ upstreamBaseUrl: opts.serverUrl });
   const proxy = await startCredentialProxy(broker, {
     onInboxPullResponse: (agentId, messages) => timeline2.appendEntryForAgent(agentId, messages),
+    onMessageReminderArm: (input) => reminderSchedulerRef?.arm(input) ?? { armed: false, reason: "reminder_scheduler_unavailable" },
     onProxyRequest: (agentId, method, pathname) => {
       const subcommand = deriveAuditLogSubcommand(pathname, method);
       if (!subcommand)
@@ -25233,6 +25505,10 @@ async function createDaemon(opts) {
   });
   managerRef = manager;
   manager.start();
+  reminderSchedulerRef = new MessageReminderScheduler({
+    deliver: (agentId, message2) => manager.deliver(agentId, message2),
+    ...opts.messageReminderClock
+  });
   let statusTimer = null;
   if (opts.statusFilePath) {
     const statusPath = opts.statusFilePath;
@@ -25278,10 +25554,26 @@ async function createDaemon(opts) {
     },
     formatUnreadNoticeText: (notice) => `You have unread messages in channel ${notice.channel}.`
   });
+  channel2.onCommand(createSelfUpdateCommandListener(opts.handleSelfUpdate));
   channel2.onCommand(createDiagnosticsCommandListener({
     handleDiagnosticCommand: opts.handleDiagnosticCommand,
     reportDiagnosticFailure: opts.reportDiagnosticFailure
   }));
+  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;
+      case "bot:removed":
+        reminderSchedulerRef?.clearAgent(cmd.botId);
+        break;
+      default:
+        break;
+    }
+  });
   channel2.onCommand((cmd) => {
     handleBotFrame(cmd);
   });
@@ -25300,6 +25592,7 @@ async function createDaemon(opts) {
     },
     proxyUrl: proxy.url,
     stop: async () => {
+      reminderSchedulerRef?.clearAll();
       for (const agentId of [...typingHeartbeats.keys()]) {
         emitTypingStopsAndClear(agentId);
       }
@@ -26476,6 +26769,318 @@ function createDiagnosticHttpTransport(args) {
     }
   };
 }
+// src/cli/daemonUpdate.ts
+import * as crypto4 from "node:crypto";
+import * as fs10 from "node:fs";
+import * as path11 from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+var UPDATE_INTENT_SCHEMA_VERSION = 1;
+var UPDATE_LOG_MAX_BYTES = 512 * 1024;
+var UPDATE_LOG_KEEP_BYTES = 256 * 1024;
+var REQUEST_ID_PATTERN = /^[A-Za-z0-9_-]{16,128}$/;
+function intentPath(baseDir, machineId) {
+  return path11.join(daemonDirById(baseDir, machineId), "update-intent.json");
+}
+function updateLogPath(baseDir, machineId) {
+  return path11.join(daemonDirById(baseDir, machineId), "update.log");
+}
+function updatePackageMapPath(baseDir, machineId) {
+  return path11.join(daemonDirById(baseDir, machineId), "update-package-map.json");
+}
+function ensurePrivateDir(dir) {
+  fs10.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs10.chmodSync(dir, 448);
+}
+function writePrivateJsonAtomic(filePath, value) {
+  const dir = path11.dirname(filePath);
+  ensurePrivateDir(dir);
+  const tempPath = path11.join(dir, `.${path11.basename(filePath)}.${process.pid}.${crypto4.randomBytes(8).toString("hex")}.tmp`);
+  let fd = fs10.openSync(tempPath, "wx", 384);
+  try {
+    fs10.writeFileSync(fd, JSON.stringify(value));
+    fs10.fsyncSync(fd);
+    fs10.closeSync(fd);
+    fd = null;
+    fs10.chmodSync(tempPath, 384);
+    fs10.renameSync(tempPath, filePath);
+  } finally {
+    if (fd !== null) {
+      try {
+        fs10.closeSync(fd);
+      } catch {}
+    }
+    try {
+      fs10.unlinkSync(tempPath);
+    } catch {}
+  }
+}
+function scrub(value) {
+  return (value instanceof Error ? value.message : String(value)).replace(/\b(?:cmk|cmt)_[A-Za-z0-9_-]+\b/g, "[redacted-token]").replace(/[\r\n]+/g, " ").slice(0, 1024);
+}
+function appendUpdateLog(baseDir, machineId, event, fields = {}) {
+  const filePath = updateLogPath(baseDir, machineId);
+  ensurePrivateDir(path11.dirname(filePath));
+  try {
+    if (fs10.existsSync(filePath) && fs10.statSync(filePath).size > UPDATE_LOG_MAX_BYTES) {
+      const data = fs10.readFileSync(filePath);
+      fs10.writeFileSync(filePath, data.subarray(Math.max(0, data.length - UPDATE_LOG_KEEP_BYTES)), { mode: 384 });
+    }
+    const safeFields = Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, scrub(value)]));
+    fs10.appendFileSync(filePath, `${JSON.stringify({ time: new Date().toISOString(), event, ...safeFields })}
+`, { mode: 384 });
+    fs10.chmodSync(filePath, 384);
+  } catch {}
+}
+function pidTuple(value) {
+  if (!value || typeof value.machineId !== "string" || typeof value.startedAt !== "string" || typeof value.ownerToken !== "string")
+    return null;
+  return {
+    pid: value.pid,
+    machineId: value.machineId,
+    startedAt: value.startedAt,
+    ownerToken: value.ownerToken
+  };
+}
+function tuplesEqual(value, expected) {
+  return value?.pid === expected.pid && value.machineId === expected.machineId && value.startedAt === expected.startedAt && value.ownerToken === expected.ownerToken;
+}
+function readIntent(baseDir, machineId) {
+  const filePath = intentPath(baseDir, machineId);
+  const stat = fs10.lstatSync(filePath);
+  if (!stat.isFile())
+    throw new Error("unsafe daemon update intent type");
+  fs10.chmodSync(filePath, 384);
+  const value = JSON.parse(fs10.readFileSync(filePath, "utf8"));
+  if (value.schemaVersion !== UPDATE_INTENT_SCHEMA_VERSION || typeof value.requestId !== "string" || !REQUEST_ID_PATTERN.test(value.requestId) || !Number.isInteger(value.pid) || (value.pid ?? 0) <= 0 || typeof value.machineId !== "string" || typeof value.startedAt !== "string" || typeof value.ownerToken !== "string")
+    throw new Error("invalid daemon update intent");
+  return value;
+}
+function removeIntentIfMatches(baseDir, machineId, requestId) {
+  try {
+    const current = readIntent(baseDir, machineId);
+    if (current.requestId === requestId)
+      fs10.unlinkSync(intentPath(baseDir, machineId));
+  } catch {}
+}
+function npmExecPath(explicit) {
+  const value = explicit ?? process.env.npm_execpath;
+  if (!value || !path11.isAbsolute(value) || !fs10.existsSync(value)) {
+    throw new Error("npm launch context unavailable; daemon remains online");
+  }
+  return value;
+}
+function readTestPackageMap(baseDir, machineId) {
+  if (true)
+    return null;
+  const filePath = updatePackageMapPath(baseDir, machineId);
+  if (!fs10.existsSync(filePath))
+    return null;
+  const stat = fs10.lstatSync(filePath);
+  if (!stat.isFile())
+    throw new Error("unsafe daemon update package map type");
+  if (process.platform !== "win32" && (stat.mode & 63) !== 0) {
+    throw new Error("daemon update package map must be mode 0600");
+  }
+  const parsed = JSON.parse(fs10.readFileSync(filePath, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error("invalid daemon update package map");
+  const result = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (key !== "latest" && !parseReleaseVersion(key))
+      throw new Error("invalid daemon update package map key");
+    if (typeof value !== "string" || !path11.isAbsolute(value))
+      throw new Error("invalid daemon update package map value");
+    result[key] = value;
+  }
+  return result;
+}
+function packageSpec(baseDir, machineId, version3) {
+  const mapped = readTestPackageMap(baseDir, machineId)?.[version3];
+  if (mapped)
+    return mapped;
+  return `@alook/daemon@${version3}`;
+}
+function fixedNpmArgs(args) {
+  return [
+    args.npmPath,
+    "exec",
+    "--yes",
+    `--package=${args.packageSpec}`,
+    "--",
+    "alook-daemon",
+    "daemon",
+    args.command,
+    "--id",
+    args.machineId,
+    "--base-dir",
+    args.baseDir,
+    "--request-id",
+    args.requestId
+  ];
+}
+function openUpdateLog(baseDir, machineId) {
+  appendUpdateLog(baseDir, machineId, "helper_spawn_requested");
+  const filePath = updateLogPath(baseDir, machineId);
+  const fd = fs10.openSync(filePath, "a", 384);
+  fs10.chmodSync(filePath, 384);
+  return fd;
+}
+function createDaemonSelfUpdateHandler(context, deps = {}) {
+  let updateInFlight = null;
+  return () => {
+    if (updateInFlight && updateInFlight.exitCode === null && updateInFlight.signalCode === null)
+      return;
+    let requestId = "";
+    try {
+      const current = pidTuple(readPidFile(pidfilePathById(context.baseDir, context.machineId)));
+      if (!current || current.pid !== context.pid || current.machineId !== context.machineId || current.startedAt !== context.startedAt || current.ownerToken !== context.ownerToken)
+        throw new Error("daemon ownership changed before update launch");
+      const npmPath = npmExecPath(deps.npmExecPath);
+      requestId = crypto4.randomUUID();
+      const intent = {
+        schemaVersion: UPDATE_INTENT_SCHEMA_VERSION,
+        requestId,
+        ...current
+      };
+      writePrivateJsonAtomic(intentPath(context.baseDir, context.machineId), intent);
+      const logFd = openUpdateLog(context.baseDir, context.machineId);
+      try {
+        const child = (deps.spawnProcess ?? spawn2)(process.execPath, fixedNpmArgs({
+          npmPath,
+          packageSpec: packageSpec(context.baseDir, context.machineId, "latest"),
+          command: "replace",
+          machineId: context.machineId,
+          baseDir: context.baseDir,
+          requestId
+        }), {
+          detached: true,
+          shell: false,
+          stdio: ["ignore", logFd, logFd]
+        });
+        updateInFlight = child;
+        const clear = (event, fields) => {
+          appendUpdateLog(context.baseDir, context.machineId, event, fields);
+          if (updateInFlight === child)
+            updateInFlight = null;
+          removeIntentIfMatches(context.baseDir, context.machineId, requestId);
+        };
+        child.once("exit", (code, signal) => clear("helper_exited", { code, signal }));
+        child.once("error", (error51) => clear("helper_process_error", { error: error51 }));
+        child.unref();
+        deps.logger?.info("daemon self-update helper launched", { machineId: context.machineId });
+      } finally {
+        fs10.closeSync(logFd);
+      }
+    } catch (error51) {
+      if (requestId)
+        removeIntentIfMatches(context.baseDir, context.machineId, requestId);
+      appendUpdateLog(context.baseDir, context.machineId, "helper_spawn_failed", { error: error51 });
+      deps.logger?.warn("daemon self-update helper launch failed", { machineId: context.machineId, error: scrub(error51) });
+    }
+  };
+}
+function currentPidTuple(baseDir, machineId) {
+  return pidTuple(readPidFile(pidfilePathById(baseDir, machineId)));
+}
+function removeOldPidfileIfMatches(baseDir, intent) {
+  const filePath = pidfilePathById(baseDir, intent.machineId);
+  if (!tuplesEqual(currentPidTuple(baseDir, intent.machineId), intent))
+    return;
+  try {
+    fs10.unlinkSync(filePath);
+  } catch {}
+}
+async function runPinnedResume(args) {
+  const fd = openUpdateLog(args.baseDir, args.machineId);
+  try {
+    const child = spawn2(process.execPath, fixedNpmArgs({
+      npmPath: args.npmPath,
+      packageSpec: packageSpec(args.baseDir, args.machineId, args.version),
+      command: "resume",
+      machineId: args.machineId,
+      baseDir: args.baseDir,
+      requestId: args.requestId
+    }), {
+      shell: false,
+      stdio: ["ignore", fd, fd]
+    });
+    await new Promise((resolve4, reject) => {
+      child.once("error", reject);
+      child.once("exit", (code, signal) => {
+        if (code === 0)
+          resolve4();
+        else
+          reject(new Error(`rollback resume exited ${signal ?? code}`));
+      });
+    });
+  } finally {
+    fs10.closeSync(fd);
+  }
+}
+async function daemonReplace(opts) {
+  if (!REQUEST_ID_PATTERN.test(opts.requestId))
+    throw new Error("invalid replacement request id");
+  const baseDir = opts.baseDir ?? process.env.ALOOK_DATA_DIR;
+  if (!baseDir)
+    throw new Error("daemon replace requires --base-dir");
+  const intent = readIntent(baseDir, opts.id);
+  if (intent.machineId !== opts.id || intent.requestId !== opts.requestId) {
+    throw new Error("daemon update intent mismatch");
+  }
+  const launch = readDaemonLaunchRecord(baseDir, opts.id);
+  const currentVersion = readDaemonVersion();
+  if (!parseReleaseVersion(currentVersion) || !parseReleaseVersion(launch.daemonVersion)) {
+    throw new Error("daemon replacement version is invalid");
+  }
+  if (currentVersion === launch.daemonVersion || !releaseVersionGte(currentVersion, launch.daemonVersion)) {
+    appendUpdateLog(baseDir, opts.id, "replacement_not_newer", {
+      currentVersion,
+      priorVersion: launch.daemonVersion
+    });
+    removeIntentIfMatches(baseDir, opts.id, opts.requestId);
+    return;
+  }
+  if (!tuplesEqual(currentPidTuple(baseDir, opts.id), intent)) {
+    removeIntentIfMatches(baseDir, opts.id, opts.requestId);
+    throw new Error("daemon ownership changed before replacement");
+  }
+  const npmPath = npmExecPath();
+  const acquired = acquireDaemonReplacementLock({ baseDir, machineId: opts.id, requestId: opts.requestId });
+  let oldStopped = false;
+  try {
+    if (!tuplesEqual(currentPidTuple(baseDir, opts.id), intent)) {
+      throw new Error("daemon ownership changed after replacement lock");
+    }
+    appendUpdateLog(baseDir, opts.id, "replacement_started", {
+      priorVersion: launch.daemonVersion,
+      nextVersion: currentVersion
+    });
+    await stopExactDaemonPid(intent.pid);
+    oldStopped = true;
+    removeOldPidfileIfMatches(baseDir, intent);
+    try {
+      await daemonResume({ id: opts.id, baseDir, requestId: opts.requestId });
+      appendUpdateLog(baseDir, opts.id, "replacement_ready", { version: currentVersion });
+    } catch (error51) {
+      appendUpdateLog(baseDir, opts.id, "replacement_start_failed", { error: error51 });
+      await runPinnedResume({
+        npmPath,
+        version: launch.daemonVersion,
+        machineId: opts.id,
+        baseDir,
+        requestId: opts.requestId
+      });
+      appendUpdateLog(baseDir, opts.id, "rollback_ready", { version: launch.daemonVersion });
+    }
+  } catch (error51) {
+    appendUpdateLog(baseDir, opts.id, oldStopped ? "replacement_terminal_failure" : "replacement_aborted", { error: error51 });
+    throw error51;
+  } finally {
+    removeIntentIfMatches(baseDir, opts.id, opts.requestId);
+    removeReplacementLockIfMatches(acquired.path, acquired.lock);
+  }
+}
+
 // src/cli/daemonRunner.ts
 var CAPABILITIES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge", "attach", "friend"];
 var DAEMON_LOG_MAX_BYTES = 8 * 1024 * 1024;
@@ -26580,9 +27185,9 @@ async function buildRunnerDiagnosticBundle(args) {
   });
 }
 function createDaemonProcessLogger(daemonDir, foreground) {
-  fs10.mkdirSync(daemonDir, { recursive: true, mode: 448 });
-  fs10.chmodSync(daemonDir, 448);
-  const logPath = path11.join(daemonDir, "daemon.log");
+  fs11.mkdirSync(daemonDir, { recursive: true, mode: 448 });
+  fs11.chmodSync(daemonDir, 448);
+  const logPath = path12.join(daemonDir, "daemon.log");
   let warnedOversize = false;
   const sink = createRotatingFileSink(logPath, DAEMON_LOG_MAX_BYTES, {
     mode: 384,
@@ -26656,7 +27261,7 @@ async function runPreparedDaemon(prepared, opts) {
       return;
     const marker = process.env.ALOOK_DAEMON_TEST_SHUTDOWN_MARKER;
     if (marker)
-      fs10.writeFileSync(marker, String(process.pid), { mode: 384 });
+      fs11.writeFileSync(marker, String(process.pid), { mode: 384 });
     await new Promise((resolve4) => setTimeout(resolve4, delayMs));
   };
   const stopDaemon = async () => {
@@ -26704,6 +27309,13 @@ async function runPreparedDaemon(prepared, opts) {
   });
   try {
     logDaemonStartup(log2, prepared);
+    const handleSelfUpdate = createDaemonSelfUpdateHandler({
+      machineId: prepared.machineId,
+      baseDir: prepared.baseDir,
+      pid: process.pid,
+      startedAt: prepared.startedAt,
+      ownerToken: prepared.ownerToken
+    }, { logger: log2 });
     daemon = await createDaemon({
       machineKey: prepared.machineKey,
       serverUrl: prepared.serverUrl,
@@ -26729,6 +27341,7 @@ async function runPreparedDaemon(prepared, opts) {
       osRelease: prepared.osRelease,
       daemonVersion: prepared.daemonVersion,
       logger: log2,
+      handleSelfUpdate,
       handleDiagnosticCommand,
       reportDiagnosticFailure,
       onDiagnosticSources: ({ fsmTraceSource, statusFilePath }) => {
@@ -26793,7 +27406,7 @@ async function runPreparedDaemon(prepared, opts) {
 }
 
 // src/cli/daemonStart.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 var STOP_GRACE_MS = 5000;
 var STOP_KILL_GRACE_MS = 2000;
 var POLL_MS2 = 100;
@@ -26803,16 +27416,16 @@ var RUNNER_KILL_GRACE_MS = 2000;
 var MACHINE_ID_PATTERN = /^cm_[A-Za-z0-9_-]{8,64}$/;
 var LEGACY_DAEMON_ID_PATTERN = /^[a-f0-9]{12}$/;
 function resolveDefaultBaseDir() {
-  const root = process.env.ALOOK_PROJECT_ROOT || path12.join(homedir4(), ".alook");
-  return path12.join(root, "daemon");
+  const root = process.env.ALOOK_PROJECT_ROOT || path13.join(homedir4(), ".alook");
+  return path13.join(root, "daemon");
 }
 var DEFAULT_BASE_DIR = resolveDefaultBaseDir();
 var log2 = createLogger2({ header: "@alook/daemon" });
 function daemonsDir(baseDir) {
-  return path12.join(baseDir, "daemons");
+  return path13.join(baseDir, "daemons");
 }
 function daemonDirById(baseDir, id) {
-  return path12.join(daemonsDir(baseDir), validateDaemonId(id));
+  return path13.join(daemonsDir(baseDir), validateDaemonId(id));
 }
 function validateMachineId(machineId) {
   if (!MACHINE_ID_PATTERN.test(machineId))
@@ -26828,10 +27441,10 @@ function validateDaemonId(id) {
   return id;
 }
 function pidfilePathById(baseDir, id) {
-  return path12.join(daemonDirById(baseDir, id), "daemon.pid");
+  return path13.join(daemonDirById(baseDir, id), "daemon.pid");
 }
 function statusFilePathById(baseDir, id) {
-  return path12.join(daemonDirById(baseDir, id), "status.json");
+  return path13.join(daemonDirById(baseDir, id), "status.json");
 }
 function isProcessAlive(pid) {
   try {
@@ -26869,64 +27482,88 @@ function parsePidFileContent(raw) {
   return null;
 }
 function readPidFile(filePath) {
-  if (!fs11.existsSync(filePath))
+  if (!fs12.existsSync(filePath))
     return null;
   try {
-    return parsePidFileContent(fs11.readFileSync(filePath, "utf8"));
+    return parsePidFileContent(fs12.readFileSync(filePath, "utf8"));
   } catch {}
   return null;
 }
-function ensurePrivateDir(dir) {
-  fs11.mkdirSync(dir, { recursive: true, mode: 448 });
-  fs11.chmodSync(dir, 448);
+function ensurePrivateDir2(dir) {
+  fs12.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs12.chmodSync(dir, 448);
 }
 function syncDirectory(dir) {
   if (process.platform === "win32")
     return;
-  const fd = fs11.openSync(dir, "r");
+  const fd = fs12.openSync(dir, "r");
   try {
-    fs11.fsyncSync(fd);
+    fs12.fsyncSync(fd);
   } finally {
-    fs11.closeSync(fd);
+    fs12.closeSync(fd);
   }
 }
 function writeExclusive(filePath, value) {
-  const dir = path12.dirname(filePath);
-  ensurePrivateDir(dir);
-  const tempPath = path12.join(dir, `.${path12.basename(filePath)}.${process.pid}.${crypto4.randomBytes(12).toString("hex")}.tmp`);
-  let fd = fs11.openSync(tempPath, "wx", 384);
+  const dir = path13.dirname(filePath);
+  ensurePrivateDir2(dir);
+  const tempPath = path13.join(dir, `.${path13.basename(filePath)}.${process.pid}.${crypto5.randomBytes(12).toString("hex")}.tmp`);
+  let fd = fs12.openSync(tempPath, "wx", 384);
   try {
-    fs11.writeFileSync(fd, JSON.stringify(value));
-    fs11.fsyncSync(fd);
-    fs11.closeSync(fd);
+    fs12.writeFileSync(fd, JSON.stringify(value));
+    fs12.fsyncSync(fd);
+    fs12.closeSync(fd);
     fd = null;
-    fs11.chmodSync(tempPath, 384);
-    fs11.linkSync(tempPath, filePath);
+    fs12.chmodSync(tempPath, 384);
+    fs12.linkSync(tempPath, filePath);
     syncDirectory(dir);
   } finally {
     if (fd !== null) {
       try {
-        fs11.closeSync(fd);
+        fs12.closeSync(fd);
       } catch {}
     }
     try {
-      fs11.unlinkSync(tempPath);
+      fs12.unlinkSync(tempPath);
+    } catch {}
+  }
+}
+function writePrivateJsonAtomic2(filePath, value) {
+  const dir = path13.dirname(filePath);
+  ensurePrivateDir2(dir);
+  const tempPath = path13.join(dir, `.${path13.basename(filePath)}.${process.pid}.${crypto5.randomBytes(12).toString("hex")}.tmp`);
+  let fd = fs12.openSync(tempPath, "wx", 384);
+  try {
+    fs12.writeFileSync(fd, JSON.stringify(value));
+    fs12.fsyncSync(fd);
+    fs12.closeSync(fd);
+    fd = null;
+    fs12.chmodSync(tempPath, 384);
+    fs12.renameSync(tempPath, filePath);
+    syncDirectory(dir);
+  } finally {
+    if (fd !== null) {
+      try {
+        fs12.closeSync(fd);
+      } catch {}
+    }
+    try {
+      fs12.unlinkSync(tempPath);
     } catch {}
   }
 }
 function secureExistingFile(filePath) {
-  if (!fs11.existsSync(filePath))
+  if (!fs12.existsSync(filePath))
     return;
-  const stat = fs11.lstatSync(filePath);
+  const stat = fs12.lstatSync(filePath);
   if (!stat.isFile())
     throw new Error("unsafe daemon ownership file type");
-  fs11.chmodSync(filePath, 384);
+  fs12.chmodSync(filePath, 384);
 }
 function removeOwnedFile(filePath, pid, ownerToken) {
   try {
     const content = readPidFile(filePath);
     if (content?.pid === pid && content.ownerToken === ownerToken) {
-      fs11.unlinkSync(filePath);
+      fs12.unlinkSync(filePath);
     }
   } catch {}
 }
@@ -26938,7 +27575,7 @@ function removePidFileIfMatches(filePath, expected) {
   try {
     const current = readPidFile(filePath);
     if (current?.pid === expected.pid && current.key === expected.key)
-      fs11.unlinkSync(filePath);
+      fs12.unlinkSync(filePath);
   } catch {}
 }
 function malformedPidHint(raw) {
@@ -26949,7 +27586,7 @@ function malformedPidHint(raw) {
   return Number.isInteger(pid) && pid > 0 ? pid : null;
 }
 function clearStaleOwnership(filePath, liveError) {
-  if (!fs11.existsSync(filePath))
+  if (!fs12.existsSync(filePath))
     return;
   const valid = readPidFile(filePath);
   if (valid) {
@@ -26961,9 +27598,9 @@ function clearStaleOwnership(filePath, liveError) {
   let raw;
   let before;
   try {
-    before = fs11.statSync(filePath);
-    raw = fs11.readFileSync(filePath, "utf8");
-    const afterRead = fs11.statSync(filePath);
+    before = fs12.statSync(filePath);
+    raw = fs12.readFileSync(filePath, "utf8");
+    const afterRead = fs12.statSync(filePath);
     if (afterRead.dev !== before.dev || afterRead.ino !== before.ino || afterRead.size !== before.size || afterRead.mtimeMs !== before.mtimeMs)
       return;
   } catch {
@@ -26973,28 +27610,112 @@ function clearStaleOwnership(filePath, liveError) {
   if (pid && isProcessAlive(pid))
     throw liveError(pid);
   try {
-    const current = fs11.statSync(filePath);
+    const current = fs12.statSync(filePath);
     if (current.dev !== before.dev || current.ino !== before.ino || current.size !== before.size || current.mtimeMs !== before.mtimeMs)
       return;
-    fs11.unlinkSync(filePath);
+    fs12.unlinkSync(filePath);
+  } catch {}
+}
+function replacementLockPathById(baseDir, machineId) {
+  return path13.join(daemonDirById(baseDir, machineId), "daemon.replace.lock");
+}
+function readReplacementLock(filePath) {
+  if (!fs12.existsSync(filePath))
+    return null;
+  try {
+    const stat = fs12.lstatSync(filePath);
+    if (!stat.isFile())
+      throw new Error("unsafe daemon replacement lock type");
+    fs12.chmodSync(filePath, 384);
+    const content = JSON.parse(fs12.readFileSync(filePath, "utf8"));
+    if (!Number.isInteger(content.pid) || (content.pid ?? 0) <= 0 || typeof content.machineId !== "string" || typeof content.startedAt !== "string" || typeof content.ownerToken !== "string" || typeof content.requestId !== "string")
+      return null;
+    return content;
+  } catch (error51) {
+    if (error51 instanceof SyntaxError)
+      return null;
+    throw error51;
+  }
+}
+function replacementLocksEqual(a, b) {
+  return a.pid === b.pid && a.machineId === b.machineId && a.startedAt === b.startedAt && a.ownerToken === b.ownerToken && a.requestId === b.requestId;
+}
+function removeReplacementLockIfMatches(filePath, expected) {
+  try {
+    const current = readReplacementLock(filePath);
+    if (current && replacementLocksEqual(current, expected))
+      fs12.unlinkSync(filePath);
   } catch {}
 }
+function checkReplacementLock(baseDir, machineId, resumeRequestId) {
+  const lockPath = replacementLockPathById(baseDir, machineId);
+  if (!fs12.existsSync(lockPath))
+    return;
+  const lock = readReplacementLock(lockPath);
+  if (!lock) {
+    let before;
+    let raw;
+    try {
+      before = fs12.statSync(lockPath);
+      raw = fs12.readFileSync(lockPath, "utf8");
+      const afterRead = fs12.statSync(lockPath);
+      if (afterRead.dev !== before.dev || afterRead.ino !== before.ino || afterRead.size !== before.size || afterRead.mtimeMs !== before.mtimeMs)
+        throw new Error(`daemon '${machineId}' replacement lock changed during recovery`);
+    } catch (error51) {
+      if (error51?.code === "ENOENT")
+        return;
+      throw error51;
+    }
+    const pid = malformedPidHint(raw);
+    if (pid && isProcessAlive(pid)) {
+      throw new Error(`daemon '${machineId}' replacement lock is malformed but owned by live pid ${pid}`);
+    }
+    try {
+      const current = fs12.statSync(lockPath);
+      if (current.dev === before.dev && current.ino === before.ino && current.size === before.size && current.mtimeMs === before.mtimeMs)
+        fs12.unlinkSync(lockPath);
+    } catch {}
+    return;
+  }
+  if (!isProcessAlive(lock.pid)) {
+    removeReplacementLockIfMatches(lockPath, lock);
+    return;
+  }
+  if (resumeRequestId && lock.requestId === resumeRequestId)
+    return;
+  throw new Error(`daemon '${machineId}' replacement already in progress (pid ${lock.pid})`);
+}
+function acquireDaemonReplacementLock(args) {
+  const lockPath = replacementLockPathById(args.baseDir, args.machineId);
+  ensurePrivateDir2(path13.dirname(lockPath));
+  checkReplacementLock(args.baseDir, args.machineId);
+  const lock = {
+    pid: process.pid,
+    machineId: args.machineId,
+    startedAt: new Date().toISOString(),
+    ownerToken: crypto5.randomBytes(24).toString("base64url"),
+    requestId: args.requestId
+  };
+  writeExclusive(lockPath, lock);
+  return { path: lockPath, lock };
+}
 function coarseStartLockPath(baseDir) {
-  return path12.join(daemonsDir(baseDir), ".start.lock");
+  return path13.join(daemonsDir(baseDir), ".start.lock");
 }
 function acquireCoarseLock(baseDir, ownerToken) {
   const lf = coarseStartLockPath(baseDir);
-  ensurePrivateDir(path12.dirname(lf));
+  ensurePrivateDir2(path13.dirname(lf));
   secureExistingFile(lf);
   clearStaleOwnership(lf, (pid) => new Error(`another daemon start is in progress on this machine (pid ${pid})`));
   writeExclusive(lf, { pid: process.pid, machineId: "coarse", startedAt: new Date().toISOString(), ownerToken });
   return lf;
 }
-function acquireLaunchLock(baseDir, machineId, ownerToken) {
+function acquireLaunchLock(baseDir, machineId, ownerToken, resumeRequestId) {
   const daemonDir = daemonDirById(baseDir, machineId);
-  ensurePrivateDir(daemonDir);
-  const lockPath = path12.join(daemonDir, "daemon.launch.lock");
+  ensurePrivateDir2(daemonDir);
+  const lockPath = path13.join(daemonDir, "daemon.launch.lock");
   const finalPath = pidfilePathById(baseDir, machineId);
+  checkReplacementLock(baseDir, machineId, resumeRequestId);
   secureExistingFile(lockPath);
   secureExistingFile(finalPath);
   clearStaleOwnership(finalPath, (pid) => new Error(`daemon '${machineId}' already running (pid ${pid})`));
@@ -27009,14 +27730,14 @@ function commitFinalPidfile(baseDir, machineId, pid, startedAt, ownerToken) {
 }
 function legacyPidfileCandidates(baseDir) {
   const dir = daemonsDir(baseDir);
-  if (!fs11.existsSync(dir))
+  if (!fs12.existsSync(dir))
     return [];
   const candidates = [];
-  for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      candidates.push(path12.join(dir, entry.name, "daemon.pid"));
+      candidates.push(path13.join(dir, entry.name, "daemon.pid"));
     } else if (entry.isFile() && entry.name.endsWith(".pid")) {
-      candidates.push(path12.join(dir, entry.name));
+      candidates.push(path13.join(dir, entry.name));
     }
   }
   return candidates;
@@ -27039,7 +27760,7 @@ function reconcileLegacyMachineKeyOwnership(baseDir, machineKey) {
 function daemonList(opts) {
   const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
   const dir = daemonsDir(baseDir);
-  if (!fs11.existsSync(dir))
+  if (!fs12.existsSync(dir))
     return [];
   const results = [];
   const now = Date.now();
@@ -27064,10 +27785,10 @@ function daemonList(opts) {
     }
     results.push({ id, pid: data.pid, alive, agents, running, lastActiveMs });
   };
-  for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory() && isDaemonId(entry.name)) {
       const id = entry.name;
-      pushRow(id, path12.join(dir, id, "daemon.pid"), path12.join(dir, id, "status.json"));
+      pushRow(id, path13.join(dir, id, "daemon.pid"), path13.join(dir, id, "status.json"));
     }
   }
   return results;
@@ -27075,10 +27796,10 @@ function daemonList(opts) {
 var STATUS_STALE_MS = 20000;
 var MISSING_STATUS = { found: false, ageMs: null, freshness: "missing", writtenAt: null, agents: [] };
 function daemonStatusFromFile(statusPath, nowMs) {
-  if (!fs11.existsSync(statusPath))
+  if (!fs12.existsSync(statusPath))
     return MISSING_STATUS;
   try {
-    const snap = JSON.parse(fs11.readFileSync(statusPath, "utf8"));
+    const snap = JSON.parse(fs12.readFileSync(statusPath, "utf8"));
     const ageMs = nowMs - snap.writtenAt;
     return {
       found: true,
@@ -27093,11 +27814,11 @@ function daemonStatusFromFile(statusPath, nowMs) {
 }
 function daemonIdsWithStatus(baseDir) {
   const dir = daemonsDir(baseDir);
-  if (!fs11.existsSync(dir))
+  if (!fs12.existsSync(dir))
     return [];
   const ids = [];
-  for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
-    if (entry.isDirectory() && isDaemonId(entry.name) && fs11.existsSync(path12.join(dir, entry.name, "status.json"))) {
+  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory() && isDaemonId(entry.name) && fs12.existsSync(path13.join(dir, entry.name, "status.json"))) {
       ids.push(entry.name);
     }
   }
@@ -27118,6 +27839,30 @@ function daemonStatus(opts) {
   }
   return MISSING_STATUS;
 }
+async function stopExactPid(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (error51) {
+    if (isProcessAlive(pid))
+      throw error51;
+  }
+  if (!await waitForPidExit(pid, STOP_GRACE_MS)) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch (error51) {
+      if (isProcessAlive(pid))
+        throw error51;
+    }
+    if (!await waitForPidExit(pid, STOP_KILL_GRACE_MS)) {
+      throw new Error(`daemon (pid ${pid}) is still running after SIGKILL`);
+    }
+  }
+}
+async function stopExactDaemonPid(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    throw new Error("invalid daemon pid");
+  await stopExactPid(pid);
+}
 async function stopByPidfile(pf, notFoundHint) {
   const data = readPidFile(pf);
   if (!data) {
@@ -27130,81 +27875,63 @@ async function stopByPidfile(pf, notFoundHint) {
     return;
   }
   log2.info(`sending SIGTERM to daemon (pid ${data.pid})…`);
-  try {
-    process.kill(data.pid, "SIGTERM");
-  } catch (error51) {
-    if (isProcessAlive(data.pid))
-      throw error51;
-  }
-  if (!await waitForPidExit(data.pid, STOP_GRACE_MS)) {
-    log2.error(`daemon (pid ${data.pid}) did not exit in ${STOP_GRACE_MS / 1000}s — sending SIGKILL`);
-    try {
-      process.kill(data.pid, "SIGKILL");
-    } catch (error51) {
-      if (isProcessAlive(data.pid))
-        throw error51;
-    }
-    if (!await waitForPidExit(data.pid, STOP_KILL_GRACE_MS)) {
-      throw new Error(`daemon (pid ${data.pid}) is still running after SIGKILL`);
-    }
-  }
+  await stopExactPid(data.pid);
   log2.info("daemon stopped");
   removePidFileIfMatches(pf, data);
 }
 async function daemonStop(opts) {
   const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
-  await stopByPidfile(path12.join(daemonDirById(baseDir, opts.id), "daemon.pid"), `no daemon with id '${opts.id}' (pidfile not found — check \`alook daemon list\`)`);
+  await stopByPidfile(path13.join(daemonDirById(baseDir, opts.id), "daemon.pid"), `no daemon with id '${opts.id}' (pidfile not found — check \`alook daemon list\`)`);
 }
 function credentialFilePathByMachineId(baseDir, machineId) {
-  return path12.join(daemonsDir(baseDir), `${validateMachineId(machineId)}.credential.json`);
+  return path13.join(daemonsDir(baseDir), `${validateMachineId(machineId)}.credential.json`);
 }
 function readCredentialFile(filePath) {
-  if (!fs11.existsSync(filePath))
+  if (!fs12.existsSync(filePath))
     return null;
-  const stat = fs11.lstatSync(filePath);
+  const stat = fs12.lstatSync(filePath);
   if (!stat.isFile())
     throw new Error("unsafe daemon credential file type");
-  fs11.chmodSync(filePath, 384);
+  fs12.chmodSync(filePath, 384);
   try {
-    const content = JSON.parse(fs11.readFileSync(filePath, "utf8"));
+    const content = JSON.parse(fs12.readFileSync(filePath, "utf8"));
     if (typeof content.credential === "string" && content.credential.startsWith("cmk_") && typeof content.machineId === "string") {
+      if (content.schemaVersion === 1 && typeof content.serverUrl === "string" && typeof content.wsUrl === "string" && typeof content.daemonVersion === "string") {
+        return {
+          schemaVersion: 1,
+          credential: content.credential,
+          machineId: content.machineId,
+          serverUrl: content.serverUrl,
+          wsUrl: content.wsUrl,
+          daemonVersion: content.daemonVersion
+        };
+      }
       return { credential: content.credential, machineId: content.machineId };
     }
   } catch {}
   return null;
 }
-function writeCredentialFile(filePath, credential, machineId) {
-  const dir = path12.dirname(filePath);
-  ensurePrivateDir(dir);
-  const tempPath = path12.join(dir, `.${path12.basename(filePath)}.${process.pid}.${crypto4.randomBytes(12).toString("hex")}.tmp`);
-  let fd = fs11.openSync(tempPath, "wx", 384);
-  try {
-    fs11.writeFileSync(fd, JSON.stringify({ credential, machineId }));
-    fs11.fsyncSync(fd);
-    fs11.closeSync(fd);
-    fd = null;
-    fs11.chmodSync(tempPath, 384);
-    fs11.renameSync(tempPath, filePath);
-    syncDirectory(dir);
-  } finally {
-    if (fd !== null) {
-      try {
-        fs11.closeSync(fd);
-      } catch {}
-    }
-    try {
-      fs11.unlinkSync(tempPath);
-    } catch {}
+function writeCredentialFile(filePath, record2) {
+  writePrivateJsonAtomic2(filePath, record2);
+}
+function readDaemonLaunchRecord(baseDir, machineId) {
+  const record2 = readCredentialFile(credentialFilePathByMachineId(baseDir, machineId));
+  if (!record2 || !("schemaVersion" in record2) || record2.schemaVersion !== 1 || !parseReleaseVersion(record2.daemonVersion)) {
+    throw new Error("daemon launch record is missing or requires a manual start upgrade");
   }
+  validateMachineId(record2.machineId);
+  if (record2.machineId !== machineId)
+    throw new Error("daemon launch record machine mismatch");
+  return record2;
 }
 function findExistingCredentialForBearer(baseDir, bearer) {
   const dir = daemonsDir(baseDir);
-  if (!fs11.existsSync(dir))
+  if (!fs12.existsSync(dir))
     return null;
-  for (const file2 of fs11.readdirSync(dir)) {
+  for (const file2 of fs12.readdirSync(dir)) {
     if (!file2.endsWith(".credential.json"))
       continue;
-    const parsed = readCredentialFile(path12.join(dir, file2));
+    const parsed = readCredentialFile(path13.join(dir, file2));
     if (parsed && parsed.credential === bearer)
       return parsed;
   }
@@ -27246,7 +27973,10 @@ async function prepareDaemonStart(opts) {
     throw new Error("invalid machine key format — expected `cmt_` or `cmk_`");
   }
   const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
-  const ownerToken = crypto4.randomBytes(24).toString("base64url");
+  const daemonVersion = readDaemonVersion();
+  if (!parseReleaseVersion(daemonVersion))
+    throw new Error("daemon package version is not a strict release version");
+  const ownerToken = crypto5.randomBytes(24).toString("base64url");
   const persisted = opts.machineKey.startsWith("cmk_") ? findExistingCredentialForBearer(baseDir, opts.machineKey) : null;
   let coarseLockPath = null;
   let launchLockPath = null;
@@ -27254,7 +27984,7 @@ async function prepareDaemonStart(opts) {
     let machineKey = persisted?.credential;
     let machineId = persisted ? validateMachineId(persisted.machineId) : undefined;
     if (machineKey && machineId) {
-      launchLockPath = acquireLaunchLock(baseDir, machineId, ownerToken);
+      launchLockPath = acquireLaunchLock(baseDir, machineId, ownerToken, opts.resumeRequestId);
     } else {
       coarseLockPath = acquireCoarseLock(baseDir, ownerToken);
       if (opts.machineKey.startsWith("cmk_")) {
@@ -27264,15 +27994,22 @@ async function prepareDaemonStart(opts) {
     const runtimeReport = await detectRuntimes();
     const healthyRuntimeIds = runtimeReport.filter((runtime) => runtime.status === "healthy").map((runtime) => runtime.id);
     if (opts.machineKey.startsWith("cmt_")) {
-      const activated = await activatePairingToken(serverUrl, opts.machineKey, os3.hostname(), process.platform, process.arch, os3.release(), readDaemonVersion(), runtimeReport);
+      const activated = await activatePairingToken(serverUrl, opts.machineKey, os3.hostname(), process.platform, process.arch, os3.release(), daemonVersion, runtimeReport);
       machineKey = activated.credential;
       machineId = validateMachineId(activated.machineId);
     } else {
       machineKey ??= opts.machineKey;
       machineId ??= validateMachineId(await resolveMachineIdentity(serverUrl, opts.machineKey));
     }
-    writeCredentialFile(credentialFilePathByMachineId(baseDir, machineId), machineKey, machineId);
-    launchLockPath ??= acquireLaunchLock(baseDir, machineId, ownerToken);
+    launchLockPath ??= acquireLaunchLock(baseDir, machineId, ownerToken, opts.resumeRequestId);
+    writeCredentialFile(credentialFilePathByMachineId(baseDir, machineId), {
+      schemaVersion: 1,
+      credential: machineKey,
+      machineId,
+      serverUrl,
+      wsUrl,
+      daemonVersion
+    });
     if (coarseLockPath)
       removeOwnedFile(coarseLockPath, process.pid, ownerToken);
     const startedAt = new Date().toISOString();
@@ -27293,7 +28030,7 @@ async function prepareDaemonStart(opts) {
         platform: process.platform,
         arch: process.arch,
         osRelease: os3.release(),
-        daemonVersion: readDaemonVersion(),
+        daemonVersion,
         ownerToken,
         startedAt
       }
@@ -27306,12 +28043,37 @@ async function prepareDaemonStart(opts) {
     throw error51;
   }
 }
+async function daemonResume(opts) {
+  if (!/^[A-Za-z0-9_-]{16,128}$/.test(opts.requestId))
+    throw new Error("invalid replacement request id");
+  const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
+  const record2 = readDaemonLaunchRecord(baseDir, opts.id);
+  if (false) {}
+  await daemonStart({
+    machineKey: record2.credential,
+    serverUrl: record2.serverUrl,
+    wsUrl: record2.wsUrl,
+    baseDir,
+    resumeRequestId: opts.requestId
+  });
+}
+async function daemonStartById(opts) {
+  const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
+  const record2 = readDaemonLaunchRecord(baseDir, opts.id);
+  await daemonStart({
+    machineKey: record2.credential,
+    serverUrl: record2.serverUrl,
+    wsUrl: record2.wsUrl,
+    baseDir,
+    foreground: opts.foreground
+  });
+}
 function runnerArguments() {
   const command = process.env.ALOOK_DAEMON_PACKAGE_WRAPPER === "1" ? ["run"] : ["daemon", "run"];
   return [...process.execArgv, process.argv[1], ...command];
 }
 function spawnBlockedRunner() {
-  return spawn2(process.execPath, runnerArguments(), {
+  return spawn3(process.execPath, runnerArguments(), {
     detached: true,
     stdio: ["ignore", "ignore", "ignore", "ipc"]
   });
@@ -27322,9 +28084,9 @@ function testCheckpoint(name, childPid) {
   const checkpointFile = process.env.ALOOK_DAEMON_TEST_CHECKPOINT_FILE;
   if (!checkpointFile)
     return;
-  fs11.writeFileSync(checkpointFile, JSON.stringify({ name, parentPid: process.pid, childPid }), { mode: 384 });
+  fs12.writeFileSync(checkpointFile, JSON.stringify({ name, parentPid: process.pid, childPid }), { mode: 384 });
   const view = new Int32Array(new SharedArrayBuffer(4));
-  while (!fs11.existsSync(`${checkpointFile}.continue`))
+  while (!fs12.existsSync(`${checkpointFile}.continue`))
     Atomics.wait(view, 0, 0, 25);
 }
 function sendPrepared(child, prepared) {
@@ -27350,7 +28112,7 @@ function waitForReceipt(child, prepared) {
     };
     const configuredTestTimeout = NaN;
     const receiptTimeoutMs = Number.isFinite(configuredTestTimeout) && configuredTestTimeout > 0 ? configuredTestTimeout : START_RECEIPT_TIMEOUT_MS;
-    const timeout = setTimeout(() => settle(new Error(`daemon start timed out; inspect ${path12.join(prepared.daemonDir, "daemon.log")}`)), receiptTimeoutMs);
+    const timeout = setTimeout(() => settle(new Error(`daemon start timed out; inspect ${path13.join(prepared.daemonDir, "daemon.log")}`)), receiptTimeoutMs);
     child.on("message", (message2) => {
       const accepted = message2;
       if (accepted.type === "daemon:accepted") {
@@ -27369,7 +28131,7 @@ function waitForReceipt(child, prepared) {
       settle(undefined, receipt);
     });
     child.once("exit", (code, signal) => {
-      settle(new Error(`daemon child exited before ready (${signal ?? code}); inspect ${path12.join(prepared.daemonDir, "daemon.log")}`));
+      settle(new Error(`daemon child exited before ready (${signal ?? code}); inspect ${path13.join(prepared.daemonDir, "daemon.log")}`));
     });
     child.once("error", (error51) => settle(error51));
   });
@@ -27502,6 +28264,70 @@ function sendIpcBestEffort(ipc, message2, disconnectAfter = false) {
   }
 }
 
+// src/cli/messageReminderClient.ts
+import { readFileSync as readFileSync9 } from "node:fs";
+var LOCAL_MESSAGE_REMINDER_PATH2 = "/__alook/local/message-reminder";
+var MIN_REMINDER_MS = 60000;
+var MAX_REMINDER_MS = 24 * 60 * 60000;
+function parseRemindAfter(value) {
+  const match = /^(\d+)(m|h)$/.exec(value);
+  if (!match) {
+    throw new Error("message send: --remind-after must be a positive integer followed by m or h (1m..24h)");
+  }
+  const amount = Number(match[1]);
+  const milliseconds = amount * (match[2] === "h" ? 60 * 60000 : 60000);
+  if (!Number.isSafeInteger(milliseconds) || milliseconds < MIN_REMINDER_MS || milliseconds > MAX_REMINDER_MS) {
+    throw new Error("message send: --remind-after must be between 1m and 24h");
+  }
+  return milliseconds;
+}
+async function armMessageReminderFromEnv(input, env = process.env, fetchImpl = fetch) {
+  const proxyUrl = env.ALOOK_PROXY_URL;
+  const tokenFile = env.ALOOK_PROXY_TOKEN_FILE;
+  if (!proxyUrl || !tokenFile) {
+    return { armed: false, reason: "local reminder proxy unavailable" };
+  }
+  let voucher;
+  try {
+    voucher = readFileSync9(tokenFile, "utf8").trim();
+  } catch {
+    return { armed: false, reason: "local reminder voucher unavailable" };
+  }
+  if (!voucher)
+    return { armed: false, reason: "local reminder voucher unavailable" };
+  let response;
+  try {
+    response = await fetchImpl(`${proxyUrl.replace(/\/+$/, "")}${LOCAL_MESSAGE_REMINDER_PATH2}`, {
+      method: "PUT",
+      headers: {
+        authorization: `Bearer ${voucher}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(input),
+      signal: AbortSignal.timeout(2000)
+    });
+  } catch {
+    return { armed: false, reason: "local reminder request failed" };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { armed: false, reason: "local reminder returned an invalid response" };
+  }
+  if (!response.ok) {
+    const code = typeof body === "object" && body !== null && typeof body.code === "string" ? body.code : `http_${response.status}`;
+    return { armed: false, reason: `local reminder rejected (${code})` };
+  }
+  if (typeof body === "object" && body !== null && body.armed === true && Number.isSafeInteger(body.dueAt)) {
+    return { armed: true, dueAt: body.dueAt };
+  }
+  if (typeof body === "object" && body !== null && body.armed === false && typeof body.reason === "string") {
+    return { armed: false, reason: body.reason };
+  }
+  return { armed: false, reason: "local reminder returned an invalid response" };
+}
+
 // src/cli/index.ts
 function messagesInLocalTime(messages) {
   return messages.map((m) => ({ ...m, time: toLocalISO(m.time) }));
@@ -27635,6 +28461,8 @@ async function sendWithRetry(api2, req) {
   return withTransientMutationRetry(() => api2.send(req));
 }
 async function cmdMessageSend(opts) {
+  const remindAfterFlag = opts.remindAfter;
+  const remindAfterMs = remindAfterFlag === undefined ? undefined : parseRemindAfter(remindAfterFlag);
   const api2 = getApi();
   const agent2 = agentId(opts);
   const channel2 = opts.target;
@@ -27644,10 +28472,10 @@ async function cmdMessageSend(opts) {
   const fileFlag = opts.file;
   const textFlag = opts.text;
   if (fileFlag) {
-    const fs12 = await import("fs");
-    if (!fs12.existsSync(fileFlag))
+    const fs13 = await import("fs");
+    if (!fs13.existsSync(fileFlag))
       throw new CliError(`message send: file not found: ${fileFlag}`);
-    text2 = fs12.readFileSync(fileFlag, "utf8").trim();
+    text2 = fs13.readFileSync(fileFlag, "utf8").trim();
   } else if (typeof textFlag === "string") {
     text2 = decodeTextEscapes(textFlag);
   }
@@ -27667,7 +28495,7 @@ async function cmdMessageSend(opts) {
     }
     replyToSeq = n;
   }
-  const nonce = randomUUID5();
+  const nonce = randomUUID6();
   const res = await sendWithRetry(api2, {
     agentId: agent2,
     channel: channel2,
@@ -27677,9 +28505,26 @@ async function cmdMessageSend(opts) {
     nonce
   });
   if (res.state === "blocked") {
-    throw new CliError(`channel not aligned: ${res.unreadCount} unread message(s) in ${channel2} (latest #${res.latestSeq}). Run \`alook inbox pull\` to align, then resend.`);
+    throw new CliError(`channel not aligned: ${res.unreadCount} unread message(s) in ${channel2} (latest #${res.latestSeq}). Run \`alook inbox pull\` and READ the new messages before deciding whether to resend, adjust, or skip your message.`);
+  }
+  const sent = `${res.message.channel}${res.message.seq}`;
+  if (remindAfterMs === undefined)
+    return { sent };
+  const seqText = res.message.seq.replace(/^#/, "");
+  const sentSeq = Number(seqText);
+  if (!/^\d+$/.test(seqText) || !Number.isSafeInteger(sentSeq) || sentSeq < 1) {
+    return { sent, reminder: { armed: false, reason: "server returned an invalid canonical message seq" } };
+  }
+  try {
+    const reminder = await armMessageReminderFromEnv({
+      channel: res.message.channel,
+      sentSeq,
+      remindAfterMs
+    });
+    return { sent, reminder };
+  } catch {
+    return { sent, reminder: { armed: false, reason: "local reminder request failed" } };
   }
-  return { sent: `${res.message.channel}${res.message.seq}` };
 }
 async function createPostWithRetry(api2, req) {
   return withTransientMutationRetry(() => api2.createPost(req));
@@ -27697,10 +28542,10 @@ async function cmdMessagePost(opts) {
   const fileFlag = opts.file;
   const textFlag = opts.text;
   if (fileFlag) {
-    const fs12 = await import("fs");
-    if (!fs12.existsSync(fileFlag))
+    const fs13 = await import("fs");
+    if (!fs13.existsSync(fileFlag))
       throw new CliError(`message post: file not found: ${fileFlag}`);
-    text2 = fs12.readFileSync(fileFlag, "utf8").trim();
+    text2 = fs13.readFileSync(fileFlag, "utf8").trim();
   } else if (typeof textFlag === "string") {
     text2 = decodeTextEscapes(textFlag);
   }
@@ -27709,7 +28554,7 @@ async function cmdMessagePost(opts) {
   if (!hasText && attachmentIds.length === 0) {
     throw new CliError("message post: --text <text>, --file <path>, or --attachment <id> is required");
   }
-  const nonce = randomUUID5();
+  const nonce = randomUUID6();
   const res = await createPostWithRetry(api2, {
     agentId: agent2,
     forum,
@@ -27784,10 +28629,10 @@ async function cmdAttachmentUpload(opts) {
     throw new CliError("message attachment upload: --target <ref> is required");
   if (!filePath)
     throw new CliError("message attachment upload: --file <path> is required");
-  const fs12 = await import("fs/promises");
+  const fs13 = await import("fs/promises");
   let bytes;
   try {
-    bytes = await fs12.readFile(filePath);
+    bytes = await fs13.readFile(filePath);
   } catch (err) {
     throw new CliError(`message attachment upload: cannot read file: ${err.message}`);
   }
@@ -27841,13 +28686,13 @@ async function cmdAttachmentDownload(opts) {
   const destPath = outFlag ?? pathMod.join(os4.tmpdir(), "alook-attachments", agent2, id, "file");
   const result = await api2.attachmentDownload({ agentId: agent2, id, destPath });
   if (!outFlag) {
-    const fs12 = await import("fs/promises");
+    const fs13 = await import("fs/promises");
     const destDir = pathMod.dirname(destPath);
     const safeName = pathMod.basename(result.filename) || "file";
     const renamed = pathMod.join(destDir, safeName);
     if (renamed !== destPath) {
       try {
-        await fs12.rename(destPath, renamed);
+        await fs13.rename(destPath, renamed);
         return { ...result, path: renamed };
       } catch {
         return { ...result, path: destPath };
@@ -27982,10 +28827,10 @@ async function cmdNap(opts) {
   const textFlag = opts.text;
   let handoff;
   if (fileFlag) {
-    const fs12 = await import("fs");
-    if (!fs12.existsSync(fileFlag))
+    const fs13 = await import("fs");
+    if (!fs13.existsSync(fileFlag))
       throw new CliError(`nap: handoff file not found: ${fileFlag}`);
-    handoff = fs12.readFileSync(fileFlag, "utf8").trim();
+    handoff = fs13.readFileSync(fileFlag, "utf8").trim();
   } else if (typeof textFlag === "string") {
     handoff = decodeTextEscapes(textFlag).trim();
   }
@@ -28001,7 +28846,7 @@ function buildProgram() {
   }).option("--agent <id>", "agent identity (or ALOOK_AGENT_ID env)");
   const message2 = program.command("message").description("message operations").exitOverride();
   message2.configureOutput({ writeOut: () => {}, writeErr: () => {} });
-  message2.command("send").description("send a message to a channel, DM, or thread").option("--target <ref>", "destination (path-style ref, e.g. /demo-workspace#1234/general)").option("--text <text>", "inline message body (short messages)").option("--file <path>", "read message body from a file (long messages)").option("-a, --attachment <id>", "attach an uploaded file by id (repeatable — order = message order)", (v, prev = []) => [...prev, v], []).option("--reply <seq>", 'reply to a message by its seq in --target (e.g. "#37" or 37)').exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+  message2.command("send").description("send a message to a channel, DM, or thread").option("--target <ref>", "destination (path-style ref, e.g. /demo-workspace#1234/general)").option("--text <text>", "inline message body (short messages)").option("--file <path>", "read message body from a file (long messages)").option("-a, --attachment <id>", "attach an uploaded file by id (repeatable — order = message order)", (v, prev = []) => [...prev, v], []).option("--reply <seq>", 'reply to a message by its seq in --target (e.g. "#37" or 37)').option("--remind-after <duration>", "optionally arm one local follow-up wake after 1m..24h; a newer same-scope message or daemon restart cancels it").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
     const localOpts = this.opts();
     const globalOpts = program.opts();
     const result = await cmdMessageSend({ ...globalOpts, ...localOpts });
@@ -28117,10 +28962,23 @@ function buildProgram() {
   });
   const daemon = program.command("daemon").description("daemon operations").exitOverride();
   daemon.configureOutput({ writeOut: () => {}, writeErr: () => {} });
-  daemon.command("start").description("start the daemon (connects to server, manages agent lifecycles)").requiredOption("--machine-key <key>", "machine key for server authentication").option("--server-url <url>", "server HTTP URL (or ALOOK_SERVER_URL env)").option("--ws-url <url>", "server WebSocket URL (or ALOOK_SERVER_WS_URL env)").option("--base-dir <path>", "data directory for agent workspaces and pidfile (or ALOOK_DATA_DIR env)").option("--foreground", "run in the current process and tee daemon logs to the terminal").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+  daemon.command("start").description("start the daemon (connects to server, manages agent lifecycles)").option("--machine-key <key>", "machine key for first-time pairing").option("--id <machineId>", "restart a previously paired machine by id").option("--server-url <url>", "server HTTP URL (or ALOOK_SERVER_URL env)").option("--ws-url <url>", "server WebSocket URL (or ALOOK_SERVER_WS_URL env)").option("--base-dir <path>", "data directory for agent workspaces and pidfile (or ALOOK_DATA_DIR env)").option("--foreground", "run in the current process and tee daemon logs to the terminal").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
     const localOpts = this.opts();
+    const machineKey = localOpts.machineKey;
+    const id = localOpts.id;
+    if (!machineKey && !id || machineKey && id) {
+      throw new CliError("daemon start requires exactly one of --machine-key <key> or --id <machineId>");
+    }
+    if (id) {
+      await daemonStartById({
+        id,
+        baseDir: localOpts.baseDir,
+        foreground: localOpts.foreground === true
+      });
+      return;
+    }
     await daemonStart({
-      machineKey: localOpts.machineKey,
+      machineKey,
       serverUrl: localOpts.serverUrl,
       wsUrl: localOpts.wsUrl,
       baseDir: localOpts.baseDir,
@@ -28130,6 +28988,22 @@ function buildProgram() {
   daemon.command("run", { hidden: true }).exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async () => {
     await daemonRunFromIpc();
   });
+  daemon.command("resume", { hidden: true }).requiredOption("--id <machineId>").requiredOption("--base-dir <path>").requiredOption("--request-id <id>").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    await daemonResume({
+      id: localOpts.id,
+      baseDir: localOpts.baseDir,
+      requestId: localOpts.requestId
+    });
+  });
+  daemon.command("replace", { hidden: true }).requiredOption("--id <machineId>").requiredOption("--base-dir <path>").requiredOption("--request-id <id>").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    await daemonReplace({
+      id: localOpts.id,
+      baseDir: localOpts.baseDir,
+      requestId: localOpts.requestId
+    });
+  });
   daemon.command("stop").argument("<id>", "daemon id from `alook daemon list` (the ID column)").description("stop a daemon by its id (from `alook daemon list`)").option("--base-dir <path>", "data directory (or ALOOK_DATA_DIR env)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function(id) {
     const localOpts = this.opts();
     await daemonStop({
@@ -28137,9 +29011,13 @@ function buildProgram() {
       baseDir: localOpts.baseDir
     });
   });
-  daemon.command("list").description("list running daemons on this machine").option("--base-dir <path>", "data directory (or ALOOK_DATA_DIR env)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(function() {
+  daemon.command("list").description("list running daemons on this machine").option("--base-dir <path>", "data directory (or ALOOK_DATA_DIR env)").option("--json", "print a machine-readable JSON envelope").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(function() {
     const localOpts = this.opts();
     const daemons = daemonList({ baseDir: localOpts.baseDir });
+    if (localOpts.json === true) {
+      printEnvelope({ success: { daemons } });
+      return;
+    }
     process.stdout.write(renderDaemonList(daemons) + `
 `);
   });
@@ -28159,6 +29037,7 @@ function buildProgram() {
 }
 async function main(argv = process.argv.slice(2)) {
   const program = buildProgram();
+  let internalExitCode = 0;
   try {
     await program.parseAsync(argv, { from: "user" });
   } catch (err) {
@@ -28180,8 +29059,11 @@ async function main(argv = process.argv.slice(2)) {
         hint: err.hint
       });
     }
+    if (argv[0] === "daemon" && (argv[1] === "resume" || argv[1] === "replace")) {
+      internalExitCode = 1;
+    }
   }
-  return 0;
+  return internalExitCode;
 }
 function getHelpText(program, argv) {
   const args = argv.filter((a) => a !== "-h" && a !== "--help");