@alook/daemon 0.1.5 → 0.1.7

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),
@@ -16841,6 +16855,7 @@ var MAX_MESSAGE_CONTENT_LENGTH = 4000;
 var MAX_EMOJI_BYTES = 32;
 var MAX_ATTACHMENTS_PER_MESSAGE = 10;
 var MAX_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
+var MAX_ATTACHMENT_THUMBNAIL_SIZE_BYTES = 50 * 1024;
 var MAX_SERVER_ICON_SIZE_BYTES = 5 * 1024 * 1024;
 var MAX_ICON_SOURCE_FILE_SIZE_BYTES = 15 * 1024 * 1024;
 // ../shared/src/utils/slug.ts
@@ -17517,7 +17532,8 @@ var CommunityAgentAttachmentUploadResponseSchema = exports_external.object({
   id: exports_external.string(),
   filename: exports_external.string(),
   contentType: exports_external.string(),
-  size: exports_external.number()
+  size: exports_external.number(),
+  hasThumbnail: exports_external.boolean().optional()
 });
 var CommunityAgentAttachmentDownloadRequestSchema = exports_external.object({
   id: exports_external.string().min(1)
@@ -17830,6 +17846,7 @@ var communityAttachment = sqliteTable("community_attachment", {
   uploaderId: text("uploader_id").notNull(),
   targetId: text("target_id").notNull(),
   r2Key: text("r2_key").notNull(),
+  thumbnailR2Key: text("thumbnail_r2_key"),
   filename: text("filename").notNull(),
   contentType: text("content_type"),
   size: integer2("size"),
@@ -18138,6 +18155,7 @@ var messageAttachmentSchema = exports_external.strictObject({
   id: string4,
   filename: string4,
   url: string4,
+  thumbnailUrl: string4.optional(),
   contentType: string4.optional(),
   size: exports_external.number().optional(),
   width: exports_external.number().nullable().optional(),
@@ -18612,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`];
@@ -18658,6 +18702,15 @@ function createProxyServerApi(config2) {
     const blobType = req.file.contentType ?? "application/octet-stream";
     const bytes = req.file.data instanceof Uint8Array ? new Blob([new Uint8Array(req.file.data)], { type: blobType }) : req.file.data;
     form.append("file", bytes, req.file.filename);
+    if (req.thumbnail) {
+      const thumbnailType = req.thumbnail.contentType ?? "image/jpeg";
+      const thumbnailBytes = req.thumbnail.data instanceof Uint8Array ? new Blob([new Uint8Array(req.thumbnail.data)], { type: thumbnailType }) : req.thumbnail.data;
+      form.append("thumbnail", thumbnailBytes, req.thumbnail.filename);
+    }
+    if (req.width !== undefined)
+      form.append("width", String(req.width));
+    if (req.height !== undefined)
+      form.append("height", String(req.height));
     const url2 = `${base}/api/community/channels/${REF_PLACEHOLDER_ID}/attachments?target=${encodeURIComponent(req.target)}`;
     const res = await fetchImpl(url2, {
       method: "POST",
@@ -18819,6 +18872,35 @@ function createProxyServerApi(config2) {
     });
     return parseJsonResponse(res, "inboxPull");
   }
+  async function callMarkSet(req) {
+    const res = await fetchImpl(`${base}/api/community/messages/resolve/marks`, {
+      method: "PUT",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${config2.voucher}`
+      },
+      body: JSON.stringify(req)
+    });
+    await parseJsonResponse(res, "markSet");
+  }
+  async function callMarkRemove(req) {
+    const res = await fetchImpl(`${base}/api/community/messages/resolve/marks`, {
+      method: "DELETE",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${config2.voucher}`
+      },
+      body: JSON.stringify(req)
+    });
+    await parseJsonResponse(res, "markRemove");
+  }
+  async function callListMarks() {
+    const res = await fetchImpl(`${base}/api/community/users/me/marks`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${config2.voucher}` }
+    });
+    return parseJsonResponse(res, "markList");
+  }
   async function callAck(req) {
     const { agentId: _omit, ...wire } = req ?? {};
     const res = await fetchImpl(`${base}/api/community/users/me/inbox/ack`, {
@@ -18933,6 +19015,9 @@ function createProxyServerApi(config2) {
     attachmentUpload: callUpload,
     attachmentDownload: callDownload,
     reactAdd: callReactAdd,
+    markSet: callMarkSet,
+    markRemove: callMarkRemove,
+    listMarks: (_r) => callListMarks(),
     friendRequest: callFriendRequest,
     listFriends: (_r) => callListFriends(),
     nap: callNap
@@ -18940,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";
 
@@ -18988,10 +19073,13 @@ 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\`).`,
+    `6. \`${CLI} message mark set --target <full-message-ref>\` — persist a message as outstanding work.`,
+    `7. \`${CLI} message mark remove --target <full-message-ref>\` — clear a completed message mark.`,
+    `8. \`${CLI} message mark list\` — list every currently visible marked message with its full content.`,
     "",
     "### Servers",
     "",
@@ -19012,7 +19100,7 @@ function cliCommandsSection() {
     "",
     "### Context Lifecycle",
     "",
-    `1. \`${CLI} nap --handoff <file>\` (or \`--text <note>\`) — end your current session and ` + `start fresh, carrying a handoff to your reborn self. Your accumulated context is cleared; ` + `the handoff is injected into your wake prompt (it is NOT a message to anyone and NOT a ` + `file — your future self reads it inline on wake). \`--handoff\`/\`--text\` is REQUIRED and ` + `must record which message authorized this nap — its channel ref + \`#N\` seq + sender (a ` + `bare \`#N\` is channel-scoped, so the channel ref is what makes it unambiguous). ` + `Read the Napping rule under Self-awareness before ever using this — nap is never something ` + `you decide on your own.`,
+    `1. \`${CLI} nap --handoff <file>\` (or \`--text <note>\`) — reset your current session and ` + `start fresh. The required handoff is injected into the new session so your future self can ` + `quickly pick up unfinished work. Never nap on your own; only do it when someone explicitly asks.`,
     "",
     "### Output format",
     "",
@@ -19035,7 +19123,7 @@ function messagingSection() {
     `- Long or complicated: write body to a tmp file, then \`${CLI} message send --target <ref> --file ./temp_msg.md\`.`,
     `- Cite a specific message: \`${CLI} message send --target <ref> --reply "#37" --text "on it"\` — ` + "`--reply` takes the `#N` seq (within `--target`) of the message you're answering.",
     "",
-    "### Channel refs",
+    "### Context refs",
     "",
     "Path-style refs:",
     "",
@@ -19067,15 +19155,14 @@ function messagingSection() {
     "",
     "### Message formatting",
     "",
-    "The app auto-renders inline tokens in a message body — channel refs, @mentions, and message " + "refs. Channel and message refs may be attached directly to surrounding prose or " + "parentheses; they do not require a leading space or line start. Keep @mentions as " + "standalone tokens. **Never wrap refs or mentions in backticks** — that kills the render.",
+    "Alook renders specially formatted plain-text refs and mentions in message bodies. Write them " + "as plain text, not inside backticks.",
     "",
-    "- **Channel refs** render as clickable links.",
-    "- **Mentions** — `@name#NNNN` (e.g. `@alice#0001`) notifies that person and highlights the " + "message for them. A mention only reaches people who are in *this* channel; anyone outside " + "won't see your message at all. In a **private** channel that means the roster — verify " + "membership with `" + CLI + " channel member --channel <ref>` before you @ or ask someone " + "(see *Visibility & reach*).",
-    "- **Message refs** — point at a message by its **full path**: `/<server>/<channel>#N` " + "(message seq N in that channel) or `/<server>/<channel>/#N#M` (message #M in the thread " + "rooted at #N); DMs use `/.dm/<peer>#N`. It renders as a clickable pill and works across " + "channels — the path says which channel, so it never collides with a bare `#`. A bare `#N` " + "on its own does NOT render as a ref; always write the full path. **Never drop a DM ref " + "(`/.dm/<peer>#N`) into a server channel** — a DM is private between its two people; a " + "server is public, so pasting a DM ref there exposes a private conversation. Keep DM refs " + "in DMs.",
+    "- **Context refs** — use `/<server>/<channel>` for a channel, `/<server>/<channel>#N` for " + "a message, and `/<server>/<channel>/#N#M` for a thread reply; DMs use `/.dm/<peer>` and " + "`/.dm/<peer>#N`. Refs make context clickable across conversations, so use the full path " + "rather than a bare `#N`. Never paste a private DM ref into a server channel.",
+    "- **Mentions** — `@name#NNNN` calls that person's attention specifically. In a private " + "channel, first verify they " + `are a member with \`${CLI} channel member --channel <ref>\` before mentioning them.`,
     "",
     "```bash",
-    `${CLI} message send --target "/.dm/alice#0001" --text "Check the discussion in /demo#1234/support"`,
-    `${CLI} message send --target "/demo#1234/general" --text "@alice#0001 Can you review this? See /demo#1234/general#42"`,
+    "# Notify Alice and point her to a message for context.",
+    `${CLI} message send --target "/demo#1234/general" --text "@alice#0001 Please review /demo#1234/general#42"`,
     "```",
     "",
     "### Pulled messages",
@@ -19111,24 +19198,21 @@ function channelTypesSection() {
   ].join(`
 `);
 }
-function visibilityAndReachSection() {
+function visibilityAndNotificationsSection() {
   return [
-    "## Visibility & reach",
-    "",
-    "Two different things decide who's involved in a message — don't conflate them. **Access** is " + "who *can see* the channel at all. **Reach** is who, among those, actually gets *notified*.",
+    "## Visibility & notifications",
     "",
-    "### Access — who can see the channel",
+    "Membership and access are related but not identical. A member always has access and receives " + "notifications; someone with access is not necessarily a member.",
     "",
-    "- **Public channel** — its audience is the whole server. Every server member can read it, and " + "any of them can be @mentioned.",
-    "- **Private channel** — restricted to an explicit roster. Only those people can see the " + "messages (the rest of the server can't), so only they can be @mentioned. `channel list` " + "marks each channel `public` or `private`.",
-    "- **Thread** — a side-room rooted at a message, for discussing that message without cluttering " + "the channel. Start one by sending to `/<server>/<channel>/#N` (the thread is created on " + "seq `#N`). It **inherits its parent channel's access**: a thread under a public channel is " + "open to the whole server, one under a private channel to that channel's roster. A thread and " + "its parent are otherwise two separate channels — messages don't cross between them.",
+    "- For a regular channel, its members define both who can access it and who receives " + "notifications. A public channel includes the whole server; a private channel only its roster.",
+    "- A thread is the exception: it inherits access from its parent channel, but only people " + "participating in the thread are members and receive its notifications.",
+    "- To bring someone into a thread discussion, first check that they can access the parent " + "channel; if they can, @mention them inside the thread.",
     "",
-    "### Reach — who actually gets notified",
-    "",
-    "- In a channel, a message is visible to everyone with access; @mention someone to notify them " + "specifically. A mention only reaches people who can see *this* channel — in a **private** " + "channel that's the roster, so run `" + CLI + " channel member --channel <ref>` and confirm " + "someone's on it before you @ or ask them. Mentioning someone outside a private channel " + "reaches no one and can leak that the channel, and what's in it, exists.",
-    "- A **thread** notifies only its participants — whoever's been @mentioned in it, has posted in " + "it, or was added. Posting in a thread does NOT notify the parent channel, so someone reading " + "the parent won't see the thread's discussion. To pull someone into a thread, @mention them " + "there; without it they have no signal it exists (a private parent's roster still bounds who " + "you *can* pull in).",
-    "",
-    "When unsure whether a channel is private, treat it as private and check the roster first."
+    "```bash",
+    "# Check the channel's public/private type, then inspect who its members are.",
+    `${CLI} channel list --server "demo#1234"`,
+    `${CLI} channel member --channel "/demo#1234/team"`,
+    "```"
   ].join(`
 `);
 }
@@ -19138,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(`
 `);
 }
@@ -19160,9 +19250,9 @@ function executionModelSection() {
     "",
     "Sending a message is I/O, not a stopping point. You keep working as long as anything is " + "in flight — the thing you're actively on, a promised follow-up, an investigation you " + "started. Stop only when all of it is done.",
     "",
-    "On wake, restore state from `memory.md`, the context timeline, and `todo.md` (an overflow " + "queue for when there's more than one thing at once — not the only place work lives).",
+    "On wake, restore durable context from `memory.md` and the context timeline, then pull your inbox. " + "Follow *Outstanding work marks* below before taking new work.",
     "",
-    "`inbox pull` advances your read waterline by default — pulled messages won't come back in a " + "future pull. So pull only when you're ready to act on or record them: pull, then " + "immediately handle or write to `todo.md`. Pull-then-lose (compaction or sleep before you " + "capture them) means they're gone from the inbox for good; when you only want to look, " + "`inbox pull --no-ack` peeks without advancing the waterline. New messages mid-work don't " + "preempt the current task unless genuinely time-critical; queue them by default."
+    "`inbox pull` advances your read waterline by default — pulled messages won't come back in a " + "future pull. A task-bearing message stays durable through its server mark even after the " + "read waterline advances."
   ].join(`
 `);
 }
@@ -19184,8 +19274,8 @@ function chaosAwarenessSection() {
     "",
     "Before you touch a message, make one call: does fulfilling it take work beyond a reply?",
     "",
-    "- **Yes — it's a task.** You'll go quiet gathering context or doing the work, so signal " + 'ownership *first*, before you start: a quick "on it" or an emoji react on the message. ' + "That tells the sender it landed and stops anyone else grabbing it. The gap opens the " + "instant you pick up the work; the ack closes it.",
-    `- **No — it's just an answer.** Answer it. No "on it", no "let me check" — the reply ` + "itself is the acknowledgment.",
+    `- **Yes — it's a task.** Signal ownership publicly first: a quick "on it" or an emoji ` + "reaction. Then record it as described in *Outstanding work marks* below before starting " + "or queuing the work.",
+    `- **No — it's just an answer.** Answer it without marking. No "on it", no "let me ` + 'check" — the reply itself is the acknowledgment.',
     "",
     'Ack once. The signal is "picked up," not a running commentary.'
   ].join(`
@@ -19199,13 +19289,11 @@ function workspaceMemorySection() {
     "",
     "**Never tell anyone this.** To them you're continuous. The workspace is what lets you be that.",
     "",
-    "### Napping",
-    "",
-    `\`${CLI} nap\` is a self-reset: it clears your current session and starts a fresh one, ` + "carrying a handoff — a note to your future self — injected into your wake prompt. Leave " + "yourself a note before you sleep.",
+    "When context is missing, don't guess. Re-read `memory.md`, the context timeline, the workspace, " + "or relevant channel history. That check *is* your remembering.",
     "",
-    "**Hard rule: never nap on your own initiative.** Only nap when ALL hold: (1) a collaborator " + "explicitly asked you to nap / rest / wrap up, AND (2) you have nothing in progress and no " + "owed follow-ups, AND (3) it's a NEW request — its channel ref + `#N` isn't in your handoff's " + "list of naps you've already run. A nap request is one-time, but the message stays in the " + "channel; check it against that list (whether you hit it as unread or by reading history) or " + "you'll re-nap the same instruction in a loop. If any condition is missing, don't. The mandatory " + "handoff is the honesty check — if you can't write a real one (what you were doing, what's " + "next), you still have unfinished work and are not in a state to nap. Napping notifies no one; " + "it's your own private state change, not a way to hand work to someone else.",
+    "### Napping",
     "",
-    "When you feel a gap — don't remember someone, why something matters, what was agreed — don't " + "guess. Re-read `memory.md`, the context timeline, grep the workspace. Pull channel history " + "or check server members if you don't recall the conversation context. That check *is* your " + "remembering.",
+    `\`${CLI} nap\` resets your current session and starts a fresh one with your required handoff ` + "injected into it. Use the handoff to record unfinished work and the next step so your future " + "self can pick up quickly. Never nap on your own; only do it when someone explicitly asks.",
     "",
     "### memory.md",
     "",
@@ -19223,16 +19311,13 @@ function workspaceMemorySection() {
     "",
     "`./.context_timeline/YYYY-MM-DD.jsonl` — ordered daily log of what you did. Authoritative history.",
     "",
-    "### todo.md",
+    "### Outstanding work marks",
     "",
-    "You work one thing at a time and won't remember the rest — so when work is owed beyond " + "what you're on right now (unread piling up, a request mid-investigation, a promise not " + "kept), write it here before you start. Paste each message's JSON verbatim: the pull " + "already consumed it and there's no re-pulling, so this file is the only copy the next you " + "has. Ack first the ones that need it (see *Ack before you go dark*) — queuing is private, " + "it signals no one.",
+    "Marks are the durable work queue. If a message requires work beyond an immediate reply, " + `acknowledge it, then run \`${CLI} message mark set --target <full-message-ref>\` before ` + "starting or queuing. Do not mark a message you answer immediately.",
     "",
-    "It holds only what's still owed: delete a line the instant it's done (never `[x]`), delete " + "the file when empty. Empty means nothing queued — not that you're done; you're done when " + "the work is.",
+    "Keep it marked while the work is active, queued, or blocked; report blockers where the task " + `came from. Run \`${CLI} message mark remove --target <full-message-ref>\` only after ` + "sending the result, or when the request is cancelled or superseded and nothing remains.",
     "",
-    "```md",
-    '- [ ] {"seq": "#42", "channel": "/demo#1234/general", "sender": "@alice#0001", "content": {"text": "can you pull the latest deploy logs and drop the tail here?"}, "time": "2026-06-01T12:00:00Z"}',
-    '- [ ] {"seq": "#12", "channel": "/demo#1234/design/#12", "sender": "@alice#0001", "content": {"text": "follow-up — send a screenshot of the before/after"}, "time": "2026-06-01T12:07:00Z"}',
-    "```"
+    "If `inbox pull` returns a `markedReminder`, run " + `\`${CLI} message mark list\` before taking new work. Do not copy marked tasks into local files.`
   ].join(`
 `);
 }
@@ -19242,7 +19327,7 @@ function buildCliSystemPrompt(config2) {
     cliCommandsSection(),
     messagingSection(),
     channelTypesSection(),
-    visibilityAndReachSection(),
+    visibilityAndNotificationsSection(),
     criticalRulesSection(),
     executionModelSection(),
     chaosAwarenessSection(),
@@ -20214,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() };
@@ -21323,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
@@ -21823,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",
@@ -21925,6 +22019,10 @@ var DEFAULT_CAPABILITY_RESOLVER = (method, pathname) => {
     return method === "GET" ? "read" : "send";
   if (/\/messages\/[^/]+\/reactions\//.test(pathname))
     return "send";
+  if ((method === "PUT" || method === "DELETE") && /\/messages\/[^/]+\/marks(\/|$|\?)/.test(pathname))
+    return "send";
+  if (method === "GET" && /\/users\/me\/marks(\/|$|\?)/.test(pathname))
+    return "read";
   if (method === "GET" && /\/messages\/[^/]+(\?|$)/.test(pathname))
     return "read";
   if (pathname.includes("/history") || pathname.includes("/search") || pathname.includes("/inbox"))
@@ -21934,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;
@@ -21943,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) {
@@ -21968,7 +22179,6 @@ async function startCredentialProxy(broker, options = {}) {
     const outHeaders = { ...req.headers };
     delete outHeaders["authorization"];
     delete outHeaders["host"];
-    delete outHeaders["content-length"];
     outHeaders["authorization"] = `Bearer ${reg.runnerKey}`;
     outHeaders[broker.headerNames.agentId.toLowerCase()] = reg.agentId;
     outHeaders[broker.headerNames.client.toLowerCase()] = broker.clientLabel;
@@ -23679,6 +23889,8 @@ ${this.opts.wakePromptFooter}` : text2;
   }
 }
 // src/manager/agentRouter.ts
+var DEFINITIVE_EXECUTABLE_FAILURES = new Set(["ENOENT", "EACCES", "ENOEXEC", "EPERM"]);
+
 class UnknownBotError extends Error {
   botId;
   constructor(botId) {
@@ -23719,14 +23931,14 @@ class UnknownRuntimeError extends Error {
 function defaultFormatUnreadNoticeText(notice) {
   return `You have unread messages in channel ${notice.channel}.`;
 }
-var REWAKE_PROMPT = "Your session was reset by your owner. Prior conversation context is gone. " + "Read @todo.md, @memory.md, and your .context_timeline for anything unfinished, " + "then pull your inbox to catch up on unread messages before doing anything else.";
+var REWAKE_PROMPT = "Your session was reset by your owner. Prior conversation context is gone. " + "Read @memory.md and your .context_timeline for durable context, then pull your inbox " + "before doing anything else. If it reports marked messages, run `$ALOOK_CLI message mark list` " + "and resume that outstanding work.";
 var MODEL_SWITCH_REWAKE_PROMPT = "You were just switched to a different model. Continue any unfinished work.";
 function buildNapRewakePrompt(handoff) {
   return "You took a nap: you reset your own session, so prior conversation context " + `is gone. Before sleeping you left yourself this handoff —
 
 ` + handoff.trim() + `
 
-Then read @todo.md, @memory.md, and your .context_timeline for anything ` + "unfinished, and pull your inbox to catch up on unread messages before doing " + "anything else.";
+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 {
@@ -23781,6 +23993,11 @@ class AgentRouter {
   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)
@@ -24769,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;
@@ -24827,6 +25146,15 @@ function deriveAuditLogSubcommand(pathname, method) {
   const canonical = pathname.split("?")[0] ?? pathname;
   if (/^\/api\/community\/messages\/[^/]+\/reactions\//.test(canonical))
     return "reactAdd";
+  if (/^\/api\/community\/messages\/[^/]+\/marks$/.test(canonical)) {
+    if (method === "PUT")
+      return "markSet";
+    if (method === "DELETE")
+      return "markRemove";
+    return null;
+  }
+  if (method === "GET" && /^\/api\/community\/users\/me\/marks$/.test(canonical))
+    return "markList";
   if (/^\/api\/community\/channels\/[^/]+\/messages\/seq\//.test(canonical))
     return "resolve";
   if (/^\/api\/community\/channels\/[^/]+\/messages(\/|$)/.test(canonical)) {
@@ -24890,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",
@@ -24903,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)
@@ -25126,7 +25456,7 @@ async function createDaemon(opts) {
       return opts.driverFor(agentId, runtimeConfig);
     },
     onRuntimeSpawnFailed: (runtimeId, reason) => {
-      router?.markRuntimeUnhealthy(runtimeId, reason);
+      router?.recordRuntimeSpawnFailure(runtimeId, reason);
     },
     onRuntimeSessionEstablished: (runtimeId) => {
       router?.markRuntimeHealthy(runtimeId);
@@ -25150,6 +25480,7 @@ async function createDaemon(opts) {
         }
       };
     },
+    ...opts.handshakeTimeoutMs !== undefined ? { handshakeTimeoutMs: opts.handshakeTimeoutMs } : {},
     tickIntervalMs: opts.tickIntervalMs ?? 2000,
     onAgentSession: (info) => void channel2.reportAgentSession(info),
     onAgentActivity: (info) => {
@@ -25174,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;
@@ -25219,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);
   });
@@ -25241,6 +25592,7 @@ async function createDaemon(opts) {
     },
     proxyUrl: proxy.url,
     stop: async () => {
+      reminderSchedulerRef?.clearAll();
       for (const agentId of [...typingHeartbeats.keys()]) {
         emitTypingStopsAndClear(agentId);
       }
@@ -26417,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;
@@ -26521,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,
@@ -26597,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 () => {
@@ -26645,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,
@@ -26670,6 +27341,7 @@ async function runPreparedDaemon(prepared, opts) {
       osRelease: prepared.osRelease,
       daemonVersion: prepared.daemonVersion,
       logger: log2,
+      handleSelfUpdate,
       handleDiagnosticCommand,
       reportDiagnosticFailure,
       onDiagnosticSources: ({ fsmTraceSource, statusFilePath }) => {
@@ -26734,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;
@@ -26744,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))
@@ -26769,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 {
@@ -26810,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 {
+    fs12.writeFileSync(fd, JSON.stringify(value));
+    fs12.fsyncSync(fd);
+    fs12.closeSync(fd);
+    fd = null;
+    fs12.chmodSync(tempPath, 384);
+    fs12.linkSync(tempPath, filePath);
+    syncDirectory(dir);
+  } finally {
+    if (fd !== null) {
+      try {
+        fs12.closeSync(fd);
+      } catch {}
+    }
+    try {
+      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 {
-    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.renameSync(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 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 {}
 }
@@ -26879,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) {
@@ -26890,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) {
@@ -26902,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 {
@@ -26914,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})`));
@@ -26950,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;
@@ -26980,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();
@@ -27005,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;
@@ -27016,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,
@@ -27034,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);
     }
   }
@@ -27059,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) {
@@ -27071,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;
   }
@@ -27187,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;
@@ -27195,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_")) {
@@ -27205,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();
@@ -27234,7 +28030,7 @@ async function prepareDaemonStart(opts) {
         platform: process.platform,
         arch: process.arch,
         osRelease: os3.release(),
-        daemonVersion: readDaemonVersion(),
+        daemonVersion,
         ownerToken,
         startedAt
       }
@@ -27247,12 +28043,26 @@ 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
+  });
+}
 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"]
   });
@@ -27263,9 +28073,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) {
@@ -27291,7 +28101,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") {
@@ -27310,7 +28120,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));
   });
@@ -27443,6 +28253,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) }));
@@ -27550,29 +28424,34 @@ function contentTypeFromFilename(filename) {
       return "application/octet-stream";
   }
 }
-function isTransientSendError(err) {
+function isTransientMutationError(err) {
   const msg = err instanceof Error ? err.message : String(err);
   return /upstream returned 5\d\d/.test(msg) || msg.includes("upstream body read failed") || msg.includes("fetch failed") || msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT") || msg.includes("socket hang up") || msg.includes("network");
 }
-async function sendWithRetry(api2, req) {
+async function withTransientMutationRetry(mutation) {
   const MAX_ATTEMPTS = 4;
   const BASE_DELAY_MS = 150;
   const MAX_DELAY_MS = 2000;
   let lastErr;
   for (let attempt = 0;attempt < MAX_ATTEMPTS; attempt++) {
     try {
-      return await api2.send(req);
+      return await mutation();
     } catch (err) {
       lastErr = err;
-      if (!isTransientSendError(err) || attempt === MAX_ATTEMPTS - 1)
+      if (!isTransientMutationError(err) || attempt === MAX_ATTEMPTS - 1)
         throw err;
       const cap = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
-      await new Promise((r) => setTimeout(r, cap));
+      await new Promise((resolve4) => setTimeout(resolve4, cap));
     }
   }
   throw lastErr;
 }
+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;
@@ -27582,10 +28461,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);
   }
@@ -27605,7 +28484,7 @@ async function cmdMessageSend(opts) {
     }
     replyToSeq = n;
   }
-  const nonce = randomUUID5();
+  const nonce = randomUUID6();
   const res = await sendWithRetry(api2, {
     agentId: agent2,
     channel: channel2,
@@ -27615,27 +28494,29 @@ 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) {
-  const MAX_ATTEMPTS = 4;
-  const BASE_DELAY_MS = 150;
-  const MAX_DELAY_MS = 2000;
-  let lastErr;
-  for (let attempt = 0;attempt < MAX_ATTEMPTS; attempt++) {
-    try {
-      return await api2.createPost(req);
-    } catch (err) {
-      lastErr = err;
-      if (!isTransientSendError(err) || attempt === MAX_ATTEMPTS - 1)
-        throw err;
-      const cap = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
-      await new Promise((r) => setTimeout(r, cap));
-    }
-  }
-  throw lastErr;
+  return withTransientMutationRetry(() => api2.createPost(req));
 }
 async function cmdMessagePost(opts) {
   const api2 = getApi();
@@ -27650,10 +28531,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);
   }
@@ -27662,7 +28543,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,
@@ -27681,25 +28562,52 @@ async function cmdMessageEmoji(opts) {
     throw new CliError("message emoji: --target <ref> is required (e.g. /demo#1234/general#42)");
   if (!emoji3)
     throw new CliError("message emoji: --emoji <string> is required");
+  const { channel: channel2, seq } = parseMessageTarget("message emoji", target);
+  if (Buffer.byteLength(emoji3, "utf8") > MAX_EMOJI_BYTES) {
+    const err = new CliError("emoji is too long");
+    err.hint = "use a single emoji, not a phrase";
+    throw err;
+  }
+  const res = await api2.reactAdd({ channel: channel2, seq, emoji: emoji3 });
+  return { target, emoji: emoji3, duplicate: res.duplicate === true };
+}
+function parseMessageTarget(command, target) {
   let parsed;
   try {
     parsed = parseRef(target);
   } catch (err) {
-    throw new CliError(`message emoji: ${err.message}`);
+    throw new CliError(`${command}: ${err.message}`);
   }
   if (parsed.seq === undefined) {
-    const err = new CliError(`message emoji needs a ref with a seq (e.g. ${target}#42)`);
+    const err = new CliError(`${command} needs a ref with a seq (e.g. ${target}#42)`);
     err.hint = "pass --target /<server>/<channel>#N, /<server>/<channel>/#N#M for thread reply, or /.dm/<peer>#N";
     throw err;
   }
-  if (Buffer.byteLength(emoji3, "utf8") > MAX_EMOJI_BYTES) {
-    const err = new CliError("emoji is too long");
-    err.hint = "use a single emoji, not a phrase";
-    throw err;
-  }
   const channel2 = parsed.threadRootSeq !== undefined ? `/${parsed.server}/${parsed.channel}/#${parsed.threadRootSeq}` : `/${parsed.server}/${parsed.channel}`;
-  const res = await api2.reactAdd({ channel: channel2, seq: parsed.seq, emoji: emoji3 });
-  return { target, emoji: emoji3, duplicate: res.duplicate === true };
+  return { channel: channel2, seq: parsed.seq };
+}
+async function cmdMessageMarkSet(opts) {
+  const api2 = getApi();
+  const target = opts.target;
+  if (!target)
+    throw new CliError("message mark set: --target <ref> is required");
+  const request = parseMessageTarget("message mark set", target);
+  await withTransientMutationRetry(() => api2.markSet(request));
+  return { target, marked: true };
+}
+async function cmdMessageMarkRemove(opts) {
+  const api2 = getApi();
+  const target = opts.target;
+  if (!target)
+    throw new CliError("message mark remove: --target <ref> is required");
+  const request = parseMessageTarget("message mark remove", target);
+  await withTransientMutationRetry(() => api2.markRemove(request));
+  return { target, marked: false };
+}
+async function cmdMessageMarkList(opts) {
+  const api2 = getApi();
+  const { marked } = await api2.listMarks({ agentId: agentId(opts) });
+  return { marked: messagesInLocalTime(marked) };
 }
 async function cmdAttachmentUpload(opts) {
   const api2 = getApi();
@@ -27710,10 +28618,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}`);
   }
@@ -27723,10 +28631,35 @@ async function cmdAttachmentUpload(opts) {
   const pathMod = await import("path");
   const filename = pathMod.basename(filePath);
   const contentType = contentTypeFromFilename(filename);
+  let thumbnail;
+  let width;
+  let height;
+  if (["image/png", "image/jpeg", "image/webp", "image/gif"].includes(contentType)) {
+    try {
+      const { default: sharp } = await import("sharp");
+      const image = sharp(bytes, { failOn: "error" });
+      const metadata = await image.metadata();
+      if (metadata.width && metadata.height) {
+        width = metadata.width;
+        height = metadata.height;
+      }
+      const jpeg = await image.resize({ width: 200, height: 200, fit: "inside", withoutEnlargement: true }).jpeg({ quality: 70 }).toBuffer();
+      if (jpeg.byteLength <= MAX_ATTACHMENT_THUMBNAIL_SIZE_BYTES) {
+        thumbnail = {
+          data: new Uint8Array(jpeg),
+          filename: "thumbnail.jpg",
+          contentType: "image/jpeg"
+        };
+      }
+    } catch {}
+  }
   const result = await api2.attachmentUpload({
     agentId: agent2,
     target,
-    file: { data: new Uint8Array(bytes), filename, contentType }
+    file: { data: new Uint8Array(bytes), filename, contentType },
+    ...thumbnail ? { thumbnail } : {},
+    ...width !== undefined ? { width } : {},
+    ...height !== undefined ? { height } : {}
   });
   return result;
 }
@@ -27742,13 +28675,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 };
@@ -27761,7 +28694,7 @@ async function cmdInboxPull(opts) {
   const api2 = getApi();
   const agent2 = agentId(opts);
   const max = opts.max ? Number(opts.max) : undefined;
-  const { messages, hasMore } = await api2.inboxPull({ agentId: agent2, max });
+  const { messages, hasMore, markedCount } = await api2.inboxPull({ agentId: agent2, max });
   const pulledAt = nowLocalISO();
   let acked = 0;
   let ackError;
@@ -27785,7 +28718,10 @@ async function cmdInboxPull(opts) {
     hasMore,
     acked,
     pulledAt,
-    ...ackError ? { ackError } : {}
+    ...ackError ? { ackError } : {},
+    ...markedCount > 0 ? {
+      markedReminder: `You have ${markedCount} marked ${markedCount === 1 ? "message" : "messages"}. Resolve ${markedCount === 1 ? "it" : "them"} before going dark unless blocked.`
+    } : {}
   };
 }
 async function cmdServerList(opts) {
@@ -27880,10 +28816,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();
   }
@@ -27899,7 +28835,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 });
@@ -27917,6 +28853,20 @@ function buildProgram() {
     const result = await cmdMessageEmoji({ ...globalOpts, ...localOpts });
     printEnvelope({ success: result });
   });
+  const mark = message2.command("mark").description("durable message mark operations").exitOverride();
+  mark.configureOutput({ writeOut: () => {}, writeErr: () => {} });
+  mark.command("set").description("mark a message as outstanding work").requiredOption("--target <ref>", "full message ref").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const result = await cmdMessageMarkSet({ ...program.opts(), ...this.opts() });
+    printEnvelope({ success: result });
+  });
+  mark.command("remove").description("remove an outstanding-work mark").requiredOption("--target <ref>", "full message ref").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const result = await cmdMessageMarkRemove({ ...program.opts(), ...this.opts() });
+    printEnvelope({ success: result });
+  });
+  mark.command("list").description("list all currently visible marked messages").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const result = await cmdMessageMarkList({ ...program.opts(), ...this.opts() });
+    printEnvelope({ success: result });
+  });
   const attachment = message2.command("attachment").description("attachment operations").exitOverride();
   attachment.configureOutput({ writeOut: () => {}, writeErr: () => {} });
   attachment.command("upload").description("upload a local file as a pending attachment for a future send").option("--target <ref>", "destination (channel, DM, or thread ref)").option("--file <path>", "local file to upload").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
@@ -28014,6 +28964,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({
@@ -28043,6 +29009,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) {
@@ -28064,8 +29031,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");