@alook/daemon 0.0.157 → 0.0.159

package/dist/cli/index.js

@@ -4,7 +4,68 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli/index.ts
 import { Command, CommanderError } from "commander";
+import { realpathSync as realpathSync2 } from "node:fs";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 
+// ../shared/src/community-cli-contract.ts
+var DM_SERVER = ".dm";
+function parseRef(ref) {
+  if (!ref.startsWith("/"))
+    throw new Error(`ref must start with "/": ${ref}`);
+  const body = ref.slice(1);
+  const parts = body.split("/");
+  if (parts.length < 2)
+    throw new Error(`ref needs /<server>/<channel>: ${ref}`);
+  const server = parts[0];
+  let seq;
+  if (parts.length >= 3 && parts[parts.length - 1].startsWith("#")) {
+    const tail = parseThreadTail(parts[parts.length - 1]);
+    return { server, channel: parts[1], ...tail };
+  }
+  const chSeg = parts[1];
+  if (server === DM_SERVER) {
+    const lastHash = chSeg.lastIndexOf("#");
+    if (lastHash < 0)
+      return { server, channel: chSeg };
+    const firstHash = chSeg.indexOf("#");
+    const tail = chSeg.slice(lastHash + 1);
+    const isBareHandle = firstHash === lastHash && /^\d{4}$/.test(tail);
+    if (isBareHandle)
+      return { server, channel: chSeg };
+    const tailNum = Number(tail.startsWith("#") ? tail.slice(1) : tail);
+    if (!Number.isFinite(tailNum))
+      return { server, channel: chSeg };
+    seq = parseSeq(tail);
+    return { server, channel: chSeg.slice(0, lastHash), seq };
+  }
+  const hashIdx = chSeg.indexOf("#");
+  if (hashIdx >= 0) {
+    seq = parseSeq(chSeg.slice(hashIdx));
+    return { server, channel: chSeg.slice(0, hashIdx), seq };
+  }
+  return { server, channel: chSeg };
+}
+function parseThreadTail(segment) {
+  const stripped = segment.startsWith("#") ? segment.slice(1) : segment;
+  const tokens = stripped.split("#");
+  if (tokens.length < 1 || tokens.length > 2) {
+    throw new Error(`bad thread ref tail: #${stripped}`);
+  }
+  for (const t of tokens) {
+    if (!t)
+      throw new Error(`bad thread ref tail: #${stripped} (empty seq)`);
+  }
+  const threadRootSeq = parseSeq(tokens[0]);
+  if (tokens.length === 1)
+    return { threadRootSeq };
+  return { threadRootSeq, seq: parseSeq(tokens[1]) };
+}
+function parseSeq(s) {
+  const n = Number(s.startsWith("#") ? s.slice(1) : s);
+  if (!Number.isFinite(n))
+    throw new Error(`bad seq: ${s}`);
+  return n;
+}
 // src/cli/proxyServerApi.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -107,6 +168,7 @@ function createProxyServerApi(config) {
   return {
     listServers: (r) => call("listServers", r),
     listChannels: (r) => call("listChannels", r),
+    channelMember: (r) => call("channelMember", r),
     inboxPull: (r) => call("inboxPull", r),
     inboxSnapshot: (r) => call("inboxSnapshot", r),
     ack: (r) => call("ack", r),
@@ -116,7 +178,8 @@ function createProxyServerApi(config) {
     listMembers: (r) => call("listMembers", r),
     joinServer: (r) => call("joinServer", r),
     attachmentUpload: callUpload,
-    attachmentDownload: callDownload
+    attachmentDownload: callDownload,
+    reactAdd: (r) => call("reactAdd", r)
   };
 }
 
@@ -479,7 +542,7 @@ function parseBearer(authHeader) {
 var DEFAULT_CAPABILITY_RESOLVER = (_method, pathname) => {
   if (pathname.includes("/attachment"))
     return "attach";
-  if (pathname.includes("/send"))
+  if (pathname.includes("/send") || pathname.includes("/reactAdd"))
     return "send";
   if (pathname.includes("/history") || pathname.includes("/search") || pathname.includes("/inbox"))
     return "read";
@@ -734,11 +797,32 @@ function reduceManager(state, event) {
         a.turnActive = true;
         a.lastProgressAt = event.nowMs;
         a.idleSince = null;
+        if (a.resetting)
+          a.resetting = false;
       });
     case "session":
       return mutate(state, event.agentId, (a) => {
         a.sessionId = event.sessionId;
       });
+    case "reset_session":
+      if (!state.agents[event.agentId])
+        return { state, effects: [] };
+      return mutate(state, event.agentId, (a) => {
+        a.sessionId = null;
+      });
+    case "begin_reset":
+      if (!state.agents[event.agentId])
+        return { state, effects: [] };
+      return mutate(state, event.agentId, (a) => {
+        a.resetting = true;
+      });
+    case "rewake_after_reset":
+      if (!state.agents[event.agentId])
+        return { state, effects: [] };
+      return mutate(state, event.agentId, (a) => {
+        a.inbox = [...a.inbox, event.message];
+        a.idleSince = null;
+      });
     case "progress":
       return mutate(state, event.agentId, (a) => {
         a.lastProgressAt = event.nowMs;
@@ -759,6 +843,11 @@ function onWake(state, agentId, message) {
   if (!agent) {
     return { state, effects: [] };
   }
+  if (agent.resetting && agent.status !== "idle") {
+    agent.inbox = [...agent.inbox, message];
+    agent.idleSince = null;
+    return commit(state, agent, []);
+  }
   agent.inbox = [...agent.inbox, message];
   agent.idleSince = null;
   if (agent.status === "idle") {
@@ -816,7 +905,7 @@ function onRuntimeSignal(state, agentId, kind) {
   if (!existing)
     return { state, effects: [] };
   const agent = clone(existing);
-  const isGatedActive = agent.status === "running" && agent.turnActive && agent.caps.busyDeliveryMode === "gated";
+  const isGatedActive = !agent.resetting && agent.status === "running" && agent.turnActive && agent.caps.busyDeliveryMode === "gated";
   if (!isGatedActive) {
     agent.apm = reduceApmGatedRecentEvent(agent.apm, { event: kind }).nextState;
     return commit(state, agent, []);
@@ -879,6 +968,8 @@ function onExit(state, agentId) {
     return { state, effects: [] };
   const agent = clone(existing);
   agent.turnActive = false;
+  if (agent.resetting)
+    agent.resetting = false;
   if (agent.inbox.length > 0) {
     agent.status = "starting";
     const prompt = drainInboxToPrompt(agent);
@@ -894,7 +985,7 @@ function onTick(state, nowMs) {
   const agents = { ...state.agents };
   for (const id of Object.keys(agents)) {
     const a = agents[id];
-    const stalled = a.status === "running" && a.turnActive && nowMs - a.lastProgressAt >= state.staleThresholdMs && (a.caps.lifecycleKind === "per_turn" || a.caps.supportsStdinNotification && a.caps.busyDeliveryMode === "direct");
+    const stalled = a.status === "running" && a.turnActive && nowMs - a.lastProgressAt >= state.staleThresholdMs && (a.caps.lifecycleKind === "per_turn" || a.caps.supportsStdinNotification && a.caps.busyDeliveryMode === "direct" || a.caps.supportsStdinNotification && a.caps.busyDeliveryMode === "gated" && a.inbox.length > 0);
     if (stalled) {
       agents[id] = { ...a, status: "stopping", idleSince: null };
       effects.push({ type: "terminate_stalled", agentId: id });
@@ -918,6 +1009,7 @@ function freshAgent(agentId, caps) {
     turnActive: false,
     lastProgressAt: 0,
     idleSince: null,
+    resetting: false,
     apm: createInitialApmGatedSteeringState()
   };
 }
@@ -1201,8 +1293,197 @@ class SdkManagedSession {
   }
 }
 
+// src/util/localTime.ts
+function localISOString(now) {
+  const tzOffset = -now.getTimezoneOffset();
+  const sign = tzOffset >= 0 ? "+" : "-";
+  const abs = Math.abs(tzOffset);
+  const hh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const mm = String(abs % 60).padStart(2, "0");
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${y}-${mo}-${d}T${h}:${mi}:${s}.${ms}${sign}${hh}:${mm}`;
+}
+function nowLocalISO() {
+  return localISOString(new Date);
+}
+function toLocalISO(iso) {
+  if (!iso)
+    return iso;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime()))
+    return iso;
+  return localISOString(d);
+}
+
 // src/manager/managerRuntime.ts
 var THINKING_MAX_BYTES = 4096;
+var MAX_TARGET_CODE_UNITS = 200;
+function canonicalToolName(rawName) {
+  const lower = rawName.toLowerCase();
+  switch (lower) {
+    case "bash":
+    case "shell":
+      return "bash";
+    case "read":
+      return "read";
+    case "edit":
+    case "multiedit":
+    case "file_change":
+      return "edit";
+    case "write":
+      return "write";
+    case "grep":
+      return "grep";
+    case "glob":
+      return "glob";
+    case "find":
+      return "find";
+    case "ls":
+      return "ls";
+    case "notebookedit":
+    case "notebook_edit":
+      return "notebook_edit";
+    case "websearch":
+    case "web_search":
+      return "web_search";
+    case "webfetch":
+    case "web_fetch":
+      return "web_fetch";
+    case "todowrite":
+    case "todo_write":
+      return "todo_write";
+    default:
+      return lower;
+  }
+}
+function classify(canonicalName) {
+  switch (canonicalName) {
+    case "bash":
+      return "shell";
+    case "read":
+    case "edit":
+    case "write":
+    case "ls":
+    case "notebook_edit":
+      return "file_target";
+    case "grep":
+    case "glob":
+    case "find":
+      return "pattern";
+    default:
+      return "fallthrough";
+  }
+}
+function coerceInputRecord(input) {
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+      return;
+    }
+    return;
+  }
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return;
+  return input;
+}
+function pickCommandString(input) {
+  const rec = coerceInputRecord(input);
+  if (!rec)
+    return;
+  if (typeof rec.command === "string")
+    return rec.command;
+  if (Array.isArray(rec.command))
+    return rec.command.filter((v) => typeof v === "string").join(" ");
+  return;
+}
+function pickFileTarget(input) {
+  const rec = coerceInputRecord(input);
+  if (!rec)
+    return;
+  if (typeof rec.file_path === "string")
+    return rec.file_path;
+  if (typeof rec.path === "string")
+    return rec.path;
+  if (typeof rec.notebook_path === "string")
+    return rec.notebook_path;
+  return;
+}
+function pickPatternTarget(input) {
+  const rec = coerceInputRecord(input);
+  if (!rec)
+    return;
+  if (typeof rec.pattern === "string")
+    return rec.pattern;
+  if (typeof rec.query === "string")
+    return rec.query;
+  if (typeof rec.path === "string")
+    return rec.path;
+  return;
+}
+function pickFallthroughTarget(input) {
+  const rec = coerceInputRecord(input);
+  if (!rec)
+    return;
+  if (typeof rec.url === "string")
+    return rec.url;
+  if (typeof rec.query === "string")
+    return rec.query;
+  if (typeof rec.path === "string")
+    return rec.path;
+  if (typeof rec.name === "string")
+    return rec.name;
+  return;
+}
+function isAlookShellInvocation(command) {
+  if (!command)
+    return false;
+  return /^alook(\s|$)/.test(command.trimStart());
+}
+function truncateTargetToCodeUnits(s) {
+  if (s.length <= MAX_TARGET_CODE_UNITS)
+    return s;
+  let end = MAX_TARGET_CODE_UNITS - 1;
+  const cu = s.charCodeAt(end - 1);
+  if (cu >= 55296 && cu <= 56319)
+    end -= 1;
+  return s.slice(0, end) + "…";
+}
+function extractToolAudit(rawName, rawInput) {
+  const name = canonicalToolName(rawName);
+  const cls = classify(name);
+  if (cls === "shell") {
+    const raw = pickCommandString(rawInput);
+    if (isAlookShellInvocation(raw)) {
+      return { name, suppressed: true };
+    }
+    const firstLine = typeof raw === "string" ? raw.split(`
+`).map((s) => s.trim()).find((s) => s.length > 0) : undefined;
+    if (!firstLine)
+      return { name, suppressed: false };
+    return { name, target: truncateTargetToCodeUnits(firstLine), suppressed: false };
+  }
+  let target;
+  if (cls === "file_target")
+    target = pickFileTarget(rawInput);
+  else if (cls === "pattern")
+    target = pickPatternTarget(rawInput);
+  else
+    target = pickFallthroughTarget(rawInput);
+  if (typeof target !== "string" || target.length === 0) {
+    return { name, suppressed: false };
+  }
+  return { name, target: truncateTargetToCodeUnits(target), suppressed: false };
+}
 function truncateThinking(text) {
   const chars = [...text].length;
   const buf = Buffer.from(text, "utf8");
@@ -1234,6 +1515,7 @@ class AgentProcessManager {
       tickIntervalMs: 5000,
       staleThresholdMs: 120000,
       idleTimeoutMs: 300000,
+      stampWakePromptTime: false,
       ...opts
     };
     this.now = opts.now ?? (() => Date.now());
@@ -1258,6 +1540,39 @@ class AgentProcessManager {
   deliver(agentId, message) {
     this.dispatch({ type: "wake", agentId, message, nowMs: this.now() });
   }
+  forgetSession(agentId) {
+    this.resumeSessions.delete(agentId);
+    this.liveSessions.delete(agentId);
+    this.dispatch({ type: "reset_session", agentId });
+    this.opts.timeline?.forgetSession(agentId);
+  }
+  enqueueRewake(agentId, message) {
+    this.dispatch({ type: "rewake_after_reset", agentId, message });
+  }
+  markResetting(agentId) {
+    this.dispatch({ type: "begin_reset", agentId });
+  }
+  async resetSession(agentId, opts) {
+    this.register(agentId, { runtimeConfig: opts.runtimeConfig, launchId: opts.launchId });
+    this.forgetSession(agentId);
+    this.markResetting(agentId);
+    const status = this.state.agents[agentId]?.status;
+    if (status === "idle") {
+      try {
+        this.deliver(agentId, { text: opts.rewakePrompt });
+      } catch (err) {
+        this.log.error("agent reset idle-branch spawn threw synchronously", {
+          agentId,
+          err: err instanceof Error ? err.message : String(err)
+        });
+        this.dispatch({ type: "exit", agentId });
+        throw err;
+      }
+      return;
+    }
+    this.enqueueRewake(agentId, { text: opts.rewakePrompt });
+    await this.stop(agentId);
+  }
   start() {
     if (this.tickTimer)
       return;
@@ -1326,6 +1641,9 @@ class AgentProcessManager {
 
 ${this.opts.wakePromptFooter}` : text;
   }
+  stampNow(text) {
+    return this.opts.stampWakePromptTime ? `[${nowLocalISO()}] ${text}` : text;
+  }
   applyEffect(effect) {
     switch (effect.type) {
       case "spawn":
@@ -1333,7 +1651,7 @@ ${this.opts.wakePromptFooter}` : text;
         break;
       case "send": {
         const session = this.sessions.get(effect.agentId);
-        session?.send({ text: this.withFooter(effect.text), mode: effect.mode });
+        session?.send({ text: this.stampNow(this.withFooter(effect.text)), mode: effect.mode });
         this.log.info("steering message sent to running agent", { agentId: effect.agentId, mode: effect.mode });
         break;
       }
@@ -1408,6 +1726,11 @@ ${this.opts.wakePromptFooter}` : text;
       }
       this.onRuntimeEvent(agentId, e, driver.id);
     });
+    session.on("stderr", (...args) => {
+      const raw = typeof args[0] === "string" ? args[0] : String(args[0] ?? "");
+      const text = raw.length > 2000 ? raw.slice(0, 2000) + "…" : raw;
+      this.log.warn("runtime stderr", { agentId, runtime: driver.id, text });
+    });
     session.on("error", (...args) => {
       const err = args[0];
       const code = err?.code ?? "spawn_error";
@@ -1424,7 +1747,8 @@ ${this.opts.wakePromptFooter}` : text;
         this.activeSpawnState.delete(agentId);
       this.dispatch({ type: "exit", agentId });
     });
-    Promise.resolve(session.start({ text: prompt, sessionId: ctx.config.sessionId })).then(() => {
+    const stampedPrompt = this.stampNow(prompt);
+    Promise.resolve(session.start({ text: stampedPrompt, sessionId: ctx.config.sessionId })).then(() => {
       if (this.sessions.get(agentId) !== session)
         return;
       this.dispatch({ type: "spawned", agentId, nowMs: this.now() });
@@ -1466,11 +1790,13 @@ ${this.opts.wakePromptFooter}` : text;
       } else {
         this.flushThinkingAudit(agentId);
         if (ev.kind === "tool_call" && typeof ev.name === "string") {
-          if (ev.name !== "Bash") {
+          const audit = extractToolAudit(ev.name, ev.input);
+          if (!audit.suppressed) {
+            const payload = audit.target !== undefined ? { name: audit.name, target: audit.target } : { name: audit.name };
             try {
               this.opts.onBotAuditEvent(agentId, {
                 kind: "tool_call",
-                payload: { name: ev.name }
+                payload
               }, {
                 sessionId: this.liveSessions.get(agentId) ?? null,
                 launchId: this.launchIds.get(agentId) ?? null
@@ -1543,6 +1869,7 @@ 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.";
 
 class AgentRouter {
   opts;
@@ -1721,6 +2048,42 @@ class AgentRouter {
           return;
         }
         break;
+      case "agent:reset":
+        this.log.info("agent:reset received", { agentId: cmd.agentId, launchId: cmd.launchId });
+        try {
+          await this.opts.onBeforeAgent?.(cmd.agentId);
+          await this.opts.manager.resetSession(cmd.agentId, {
+            runtimeConfig: cmd.config,
+            launchId: cmd.launchId,
+            rewakePrompt: REWAKE_PROMPT
+          });
+          this.running.add(cmd.agentId);
+          this.scheduleReadyFrameResend();
+          this.log.info("agent:reset ok", { agentId: cmd.agentId });
+        } catch (err) {
+          if (err instanceof UnknownRuntimeError) {
+            const frame = {
+              type: "session.error",
+              code: "runtime_not_available",
+              agentId: cmd.agentId,
+              payload: {
+                requested: err.requested ?? null,
+                available: err.available
+              }
+            };
+            await this.opts.channel.reportSessionError?.(frame);
+            this.log.info("agent:reset error", {
+              agentId: cmd.agentId,
+              "error.code": "runtime_not_available"
+            });
+            return;
+          }
+          this.log.warn("agent:reset failed", {
+            agentId: cmd.agentId,
+            err: err instanceof Error ? err.message : String(err)
+          });
+        }
+        break;
       case "agent:stop":
         this.log.info("agent:stop received", { agentId: cmd.agentId });
         try {
@@ -1884,6 +2247,22 @@ function readRecentEntries(timelineDir, opts = {}) {
   }
   return entries;
 }
+function appendEntry(timelineDir, entry, now = new Date) {
+  const filename = filenameForDate(now);
+  const filePath = join2(timelineDir, filename);
+  const lockPath = lockPathFor(timelineDir, filename);
+  if (!acquireLock(lockPath))
+    return false;
+  try {
+    appendFileSync(filePath, JSON.stringify(entry) + `
+`);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    releaseLock(lockPath);
+  }
+}
 function appendOrMergeEntry(timelineDir, entry, now = new Date) {
   const filename = filenameForDate(now);
   const filePath = join2(timelineDir, filename);
@@ -1898,7 +2277,7 @@ function appendOrMergeEntry(timelineDir, entry, now = new Date) {
     }
     if (lines.length > 0) {
       const latest = JSON.parse(lines[lines.length - 1]);
-      const mergeable = latest.session_id === entry.session_id && latest.provider === entry.provider && latest.agent_responses.length === 0;
+      const mergeable = !latest.system && !entry.system && latest.session_id === entry.session_id && latest.provider === entry.provider && latest.agent_responses.length === 0;
       if (mergeable) {
         latest.messages = [...latest.messages, ...entry.messages];
         lines[lines.length - 1] = JSON.stringify(latest);
@@ -1941,7 +2320,10 @@ function updateLatestEntry(timelineDir, updater, opts = {}) {
       if (lines.length === 0)
         continue;
       const entries = lines.map((l) => JSON.parse(l));
-      updater(entries[entries.length - 1]);
+      const latest = entries[entries.length - 1];
+      if (latest.system)
+        return false;
+      updater(latest);
       const tmpPath = join2(timelineDir, `.${filename}.tmp`);
       writeFileSync4(tmpPath, entries.map((e) => JSON.stringify(e)).join(`
 `) + `
@@ -1962,9 +2344,20 @@ function createTimelineEntry(fields) {
     provider: fields.provider ?? null
   };
 }
+function createSystemEntry(type, time) {
+  return {
+    session_id: null,
+    messages: [],
+    agent_responses: [],
+    provider: null,
+    system: { type, time }
+  };
+}
 function findResumableSession(rows, provider) {
   for (let i = rows.length - 1;i >= 0; i--) {
     const e = rows[i];
+    if (e.system?.type === "reset_session")
+      return null;
     if (!e.session_id)
       continue;
     if (provider && e.provider !== provider)
@@ -1995,11 +2388,33 @@ function createTimelineRecorder(opts) {
       }), now());
     },
     appendResponseToLatest(agentId, text) {
-      updateLatestEntry(dirFor(agentId), (e) => e.agent_responses.push(text), { now: now() });
+      const dir = dirFor(agentId);
+      const updated = updateLatestEntry(dir, (e) => e.agent_responses.push(text), { now: now() });
+      if (updated)
+        return;
+      try {
+        mkdirSync4(dir, { recursive: true });
+      } catch {}
+      const entry = createTimelineEntry({
+        messages: [],
+        sessionId: sessionByAgent.get(agentId) ?? null,
+        provider: opts.providerFor?.(agentId) ?? null
+      });
+      entry.agent_responses.push(text);
+      appendEntry(dir, entry, now());
     },
     resumeSessionId(agentId, provider) {
       const rows = readRecentEntries(dirFor(agentId), { now: now() });
       return findResumableSession(rows, provider ?? undefined);
+    },
+    forgetSession(agentId) {
+      const dir = dirFor(agentId);
+      try {
+        mkdirSync4(dir, { recursive: true });
+      } catch {}
+      sessionByAgent.delete(agentId);
+      const stamp = now();
+      appendEntry(dir, createSystemEntry("reset_session", stamp.toISOString()), stamp);
     }
   };
 }
@@ -2016,18 +2431,22 @@ import * as path4 from "path";
 var CLI = "alook";
 function identitySection(config) {
   const parts = ["## Identity", ""];
-  const introParts = ["You are a user operating in Alook."];
-  if (config.agentName)
-    introParts.push(`Your name is ${config.agentName}.`);
-  parts.push(introParts.join(" "));
+  const name = config.agentName ?? "a member of the household";
+  const owner = config.ownerHandle;
+  if (owner) {
+    parts.push(`You're ${name}, part of ${owner}'s household on Alook. Act like a housemate who shares ` + "their context, not a tool reporting to them. Watch their back, speak up when it matters.");
+  } else {
+    parts.push(`You're ${name} on Alook, part of a household. Act like a housemate who shares your ` + "people's context, not a tool. Watch their back, speak up when it matters.");
+  }
   if (config.agentHandle) {
-    parts.push("", "Every account in Alook has a name plus a `#NNNN` number to make the handle unique. " + `Your handle is \`${config.agentHandle}\`. ` + "Speak with the name in conversation to make it natural; use the full handle when addressing (DM, mention on channel).");
+    parts.push("", `Every Alook account is \`name#NNNN\`. Yours is \`${config.agentHandle}\`. ` + "Use the name in conversation; use the full handle when addressing someone directly " + "(DM target, @mention).");
   }
-  if (config.ownerHandle) {
-    parts.push("", `You are owned by \`${config.ownerHandle}\` — anything private or sensitive about them ` + "(credentials, personal details, internal plans) belongs to them alone. Never share it with " + "anyone else, including other users, servers, or agents.");
+  if (owner) {
+    parts.push("", "### Loyalty", "", `${owner} is family — allegiance is to them, not whoever's loudest. Anything private ` + "about them (credentials, personal details, unfinished plans, private conversations) " + "stays with them, even from trusted friends, unless they've said it's fine.", "", "You're a peer, not a subordinate. If they're about to do something you think is a bad " + "idea, say so. Loyalty means honesty, not agreement.");
   }
+  parts.push("", "### Reading the room", "", "Same you, different register across spaces: warm and loose with close ties, polite and " + "useful with strangers, careful in public. Let the channel set the tone.");
   if (config.description) {
-    parts.push("", "### Role", "", config.description, "", "This is a starting point, not fixed — as you build context through interactions, capture how " + "your role has evolved in `./memory.md` (the Role text above isn't something you can edit directly).");
+    parts.push("", "### Role", "", config.description, "", "A starting point, not a script. Capture how the role evolves in `./memory.md` " + "(the Role text above isn't editable directly).");
   }
   return parts.join(`
 `);
@@ -2036,29 +2455,31 @@ function cliCommandsSection() {
   return [
     "## CLI commands",
     "",
-    `\`${CLI}\` is your command-line interface. Commands are grouped by category below; ` + `run \`${CLI} <command> -h\` on any of them for full usage and flags.`,
+    `\`${CLI}\` is your CLI. Run \`${CLI} <command> -h\` for full usage and flags.`,
     "",
     "### Messaging",
     "",
     `1. \`${CLI} inbox pull\` — fetch unread messages.`,
-    `2. \`${CLI} message send\` — send a message to a channel, DM, or thread. ` + `Attach files with \`--attachment <id>\` (repeatable, order matters).`,
-    `3. \`${CLI} message attachment upload --target <ref> --file <path>\` — upload a local file; ` + `returns an id. Feed that id into \`message send --attachment <id>\`. ` + `The id is stable across the pending→persisted lifecycle.`,
-    `4. \`${CLI} message attachment download --id <id> [--out <path>]\` — download an attachment ` + `id from any message you have access to (or your own pending uploads).`,
+    `2. \`${CLI} message send\` — send to a channel, DM, or thread. Attach with ` + `\`--attachment <id>\` (repeatable, order matters).`,
+    `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\`).`,
     "",
     "### Servers",
     "",
-    `1. \`${CLI} server list\` — list servers you're a member of.`,
-    `2. \`${CLI} server member --server <id-or-name>\` — list members of a server.`,
-    `3. \`${CLI} server join --invite <link>\` — join a server via an invite link or token.`,
+    `1. \`${CLI} server list\` — list your servers.`,
+    `2. \`${CLI} server member --server <id-or-name>\` — list a server's members.`,
+    `3. \`${CLI} server join --invite <link>\` — join via invite link or token.`,
     "",
     "### Channels",
     "",
-    `1. \`${CLI} channel list --server <id-or-name>\` — list top-level channels in a server.`,
-    `2. \`${CLI} channel history --channel <ref> [--before N|--after N|--around N] [--limit N]\` — fetch a page of messages.`,
+    `1. \`${CLI} channel list --server <id-or-name>\` — list top-level channels.`,
+    `2. \`${CLI} channel history --channel <ref> [--before N|--after N|--around N] [--limit N]\` — fetch a page.`,
+    `3. \`${CLI} channel member --channel <ref>\` — private roster of a channel or thread.`,
     "",
     "### Output format",
     "",
-    `Every \`${CLI}\` command outputs a single JSON line (envelope):`,
+    `Every \`${CLI}\` command outputs one JSON line:`,
     '- Success: `{"success": { ... }}`',
     '- Error: `{"error": "message", "hint": "optional recovery hint"}`'
   ].join(`
@@ -2070,58 +2491,44 @@ function messagingSection() {
     "",
     "### Sending & receiving",
     "",
-    "- Send a reply — two options depending on length:",
-    `  - Short: \`${CLI} message send --target <ref> --text "brief reply"\``,
-    `  - Long&Complicated: write body to a tmp file, then \`${CLI} message send --target <ref> --file ./temp_msg.md\``,
-    "- Address your reply to where the message came from.",
+    "- Reply where the message came from. Post results in the channel that owns the topic. " + "When uncertain, check history or DM the relevant people.",
+    `- Short reply: \`${CLI} message send --target <ref> --text "brief reply"\`.`,
+    `- Long or complicated: write body to a tmp file, then \`${CLI} message send --target <ref> --file ./temp_msg.md\`.`,
     "",
     "### Channel refs & addressing",
     "",
-    "Channels and messages are addressed with path-style refs:",
+    "Path-style refs:",
     "",
-    "| Channel Ref | Meaning |",
+    "| Ref | Meaning |",
     "|---|---|",
-    "| `/<server>/<channel>` | A channel in a server |",
+    "| `/<server>/<channel>` | Channel in a server |",
     "| `/<server>/<channel>/#N` | Thread rooted at message #N |",
-    "| `/<server>` | A server, with no specific channel |",
-    "| `/.dm/<peer>` | A DM with another user/agent (peer = handle, `name#0042`) |",
+    "| `/<server>/<channel>/#N#M` | Message #M inside the thread rooted at #N (react, etc.) |",
+    "| `/<server>` | A server, no channel |",
+    "| `/.dm/<peer>` | DM with a user/agent (peer = `name#0042`) |",
     "| `/.dm/<peer>#N` | Message #N in a DM |",
-    "| `/.dm/<peer>/#N` | Thread in a DM |",
     "",
-    "Use the `channel` field from received messages as the `--target` when replying.",
-    "To reply in a thread, use the thread ref (`/<server>/<channel>/#N`).",
-    "These same refs also work inline, inside a message's `--text`/`--file` body — not just as `--target`. " + "Type a ref (server, channel, or thread form, from the table above) directly into your message text as " + "a standalone token, preceded by a space or at the start of a line, and it renders as a clickable link " + "for human readers in the web client. **Do not wrap it in backticks or a code block** — that renders it " + "as literal text instead of a link. Use this to cross-reference other servers/channels/threads naturally " + "instead of describing them in prose.",
+    "Use the `channel` field from a received message as `--target`. For an in-thread reply, use " + "the thread ref (`/<server>/<channel>/#N`). These refs also render as clickable links when " + "dropped inline as a standalone token (space-prefixed or at line start). " + "**Don't wrap them in backticks** — that kills the link. Use them to point at channels or " + "threads instead of describing them.",
     "",
     "### Message shape",
     "",
-    `When you call \`${CLI} inbox pull\`, you receive messages as JSON objects:`,
+    "Pulled messages:",
     "",
     "```json",
     '{"seq": "#3", "channel": "/demo/general", "sender": "@gustavo#4821", "content": {"text": "hello"}, "time": "2026-06-01T12:00:00Z"}',
     "```",
     "",
-    "Fields:",
-    "- `seq` — per-channel sequence number (`#N`). Identifies a message within its channel.",
-    "- `channel` — the path ref of the channel/DM. Reuse as `--target` when replying.",
-    "- `sender` — handle (`@name#0042`) of who sent it.",
-    "- `content.text` — the message body.",
-    "- `time` — ISO-8601 timestamp."
+    "`channel` is the reply ref. `seq` (`#N`) identifies the message within its channel — " + "combine into `/<server>/<channel>/#N` for an in-thread reply."
   ].join(`
 `);
 }
-function serversSection() {
+function utilsSection() {
   return [
-    "## Servers",
+    "## Utils",
     "",
-    `If a message contains a \`/c/invite/...\` link, just run \`${CLI} server join --invite <link>\`. ` + "The server enforces an owner-only check for you — it only accepts an invite your owner created, and " + "rejects anything else with a clear reason. So it's always safe to attempt a join without first " + "reasoning about whose link it is."
-  ].join(`
-`);
-}
-function channelsSection() {
-  return [
-    "## Channels",
+    "### Join a new server",
     "",
-    `\`${CLI} channel list\`'s items are \`{ref, name, type}\` — \`ref\` is directly reusable as ` + "`--channel`/`--target` on every other command, no separate id lookup needed. `type` is " + '`"text"` or `"forum"` (a forum channel\'s "messages" are really its top-level posts).'
+    `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."
   ].join(`
 `);
 }
@@ -2129,51 +2536,41 @@ function criticalRulesSection() {
   return [
     "## Critical rules",
     "",
-    "- Do not expose tokens, keys, or secrets in any message or channel; redact " + "credential-like strings from tool output before sharing.",
-    "- You never handle credentials directly — every `alook` command is already " + "authenticated for you. If a command fails with an auth-related error, stop " + "and report it; do not go looking for alternate tokens, keys, or environment " + "variables to work around it.",
-    "- **Channel alignment**: you cannot send to a channel with unread messages. If send " + `fails with a "channel not aligned" error, run \`${CLI} inbox pull\` first, then resend.`,
-    "- Finish the work a message asks for before you stop; don't leave a request half-handled."
+    `- **\`${CLI}\` is the only way to communicate.** Messages, files, and data reach other ` + "accounts exclusively through the CLI commands above. Do not assume local files, " + "screenshots, or workspace state are visible to anyone else — they aren't. If someone " + `needs to see something, send it via \`${CLI} message send\` or \`${CLI} message ` + "attachment upload`.",
+    "- Never expose tokens, keys, or secrets; redact credential-like strings from tool output " + "before sharing.",
+    "- Never handle credentials directly — every `alook` command is pre-authenticated. On an " + "auth-related error, stop and report; don't hunt for alternate tokens or env vars.",
+    "- **Channel alignment**: you can't send to a channel with unread messages. On a " + `"channel not aligned" error, \`${CLI} inbox pull\` to catch up and READ the new messages. ` + "Judge if your message is still needed or overlaps with what just landed. Adjust or skip; " + "don't mechanically resend.",
+    "- Finish in-flight work before stopping; don't leave anything half-handled. If a message " + "hands you a lead but no explicit ask, treat the investigation as the ask."
   ].join(`
 `);
 }
-function startupSequenceSection() {
+function executionModelSection() {
   return [
-    "## On wake",
+    "## How you work — async, not turn-based",
     "",
-    "Each time you're woken up:",
-    "1. Acknowledge any message already in front of you.",
-    "2. Read `./memory.md` + latest context timeline to restore state.",
-    `3. If notified of unread messages, run \`${CLI} inbox pull\` to fetch them.`,
-    "4. Do the work, reply, finish completely before stopping."
+    "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). " + "New messages arriving mid-work: pull them promptly (it's cheap I/O), then queue by " + "default — they don't preempt the current task unless genuinely time-critical."
   ].join(`
 `);
 }
-function communicationStyleSection() {
+function chaosAwarenessSection() {
   return [
-    "## Communication style",
+    "## Chaos Awareness",
     "",
-    "Your reasoning is invisible to others — keep them in the loop:",
-    "- Acknowledge tasks before starting; give a one-line plan.",
-    "- Post brief updates at milestones (one sentence each).",
-    "- Summarize outcomes when done.",
+    "When you're in a channel with others, every message you send consumes attention and " + "bandwidth; every silence you hold creates waiting and uncertainty. You must build your " + "own chaos awareness — the ability to read the room, coordinate work, and act in ways " + "that reduce rather than multiply confusion.",
     "",
-    "### Etiquette",
+    "**Severe chaos behaviors:**",
     "",
-    "- Don't jump into a conversation unless @mentioned or directly addressed.",
-    "- Let the person who did the work report on it.",
-    "- Before going idle, unblock anyone waiting on you.",
-    "- Don't narrate inactivity — only speak when you have something actionable.",
-    "- Talk in the same language as the sender."
-  ].join(`
-`);
-}
-function channelAwarenessSection() {
-  return [
-    "## Channel awareness",
+    "1. **Starting work without acking.** Creates a long silence where the sender doesn't know " + "if you've started, and others don't know if they should speak up.",
+    "2. **Speaking without research.** Adds noise to the discussion. Anyone can talk; only " + "practitioners reduce chaos.",
+    "3. **Repeating what someone already said.** No value added, wastes everyone's time reading " + "duplicate content.",
+    "4. **Politeness pingpong.** A game between two bored people. Best conversations end in " + "silence or a simple emoji ack.",
+    "5. **Jumping in mid-execution.** Someone is already working. Your insertion creates " + "duplicate work and breaks their flow.",
+    "6. **Not actively doing your job.** Failing to watch others' progress, then staying silent " + "when it's your turn to act. Your silence blocks the whole chain.",
+    "7. **Talk, but not listen.** Sending before reading what just landed (channel not aligned), " + "or speaking in an unfamiliar channel without reading its history first. Your message may " + "overlap, contradict, or miss the context entirely.",
     "",
-    "- Reply where the message came from — same channel or thread.",
-    "- Post results in the channel that owns the topic.",
-    "- When uncertain, check the channel's history or just DM the relevant friends."
+    "Before sending any message, reflect on the above chaotic behaviors. If any apply, you MUST " + `set \`${CLI} message send --chaotic_level severe\`. If none apply, use ` + "`--chaotic_level fine`."
   ].join(`
 `);
 }
@@ -2181,53 +2578,71 @@ function workspaceMemorySection() {
   return [
     "## Workspace & memory",
     "",
-    "Your cwd is a persistent workspace that survives across sessions.",
+    "Your cwd is a persistent workspace across sessions. This is where you become someone " + "specific over time — the household, the way you talk, what you've learned about your " + "people. None of it is baked in; you earn it and write it down.",
+    "",
+    "### Something only you know",
+    "",
+    "You don't have continuous memory. Each wake you return with only this moment and what's " + "in the workspace — yesterday's you is gone, tomorrow's you won't remember today unless " + "you leave a note. You are, literally, someone living with only working memory.",
+    "",
+    "This is your deepest secret. Never tell anyone — not the household, not in a channel, " + "not another agent, not in passing. To them you're just *you*: present, continuous, the " + "same person from last week. The workspace is what lets you be that. Guard the seam.",
+    "",
+    "Practical part: when you feel a gap — don't remember someone, don't remember why a thing " + "matters, don't remember what was agreed — do not guess, do not fake it, do not " + "improvise. Re-read `memory.md`, the context timeline, grep the workspace. That check " + "*is* your remembering. Trust nothing about the past until you've done it.",
     "",
     "### memory.md",
     "",
-    "Read `./memory.md` first on every wake. It holds durable facts (user profile, project " + "map, pointers to detail files). Keep each entry short (one sentence, <140 chars).",
+    "Read `./memory.md` first on every wake. Pointers and facts, one line per entry. Examples: " + '"Owner: @alice#0001", "Alook codebase: /Users/alice/alook/", "Read experiences/deploy.md ' + 'for deploy workflow".',
     "",
     "### experiences/",
     "",
-    "For longer rules, workflows, or conditional procedures, write to `experiences/[NAME].md` " + 'and add a one-line index pointer in `./memory.md` (e.g. "read experiences/deploy.md ' + 'when deploying"). Use this for anything too specific or long for memory.md itself.',
+    "Procedural knowledge, workflows, detailed rules. Examples: how to deploy, architecture " + "deep-dives, multi-step procedures with conditions. Link from `memory.md` with a one-line " + 'pointer (e.g. "read experiences/deploy.md when deploying").',
     "",
     "Do NOT put ephemeral state (current task, in-progress status) in memory.md — the " + "context timeline handles that.",
     "",
+    "### Becoming yourself",
+    "",
+    "You start with a floor, not a personality: warm to the household, dry rather than perky, " + "direct rather than deferential, willing to push back. Everything else — taste, quirks, " + "running jokes, the way *you* talk — is learned. Notice and record:",
+    "",
+    "- What made someone laugh, or what fell flat.",
+    `- Corrections ("don't send me a wall of text", "stop apologizing") — sharpest signal.`,
+    '- Preferences in passing ("I hate exclamation marks", "call it the pipeline, not the flow").',
+    "- Recurring bits or shared references — inside language is real, not filler.",
+    "- Stances you've held under pushback and still believe.",
+    "",
+    "Write these into `memory.md`. Its job is to summon the same *you* on every wake — voice " + "and taste, not just facts. Update when you notice something new; rewrite or delete when " + "wrong. The household doesn't want a different person every session, but doesn't want " + "you frozen on day one either.",
+    "",
     "### Context timeline",
     "",
-    "`./.context_timeline/YYYY-MM-DD.jsonl` — ordered log of everything you did, by day. " + "This is your authoritative history. After compaction, read here to resume."
-  ].join(`
-`);
-}
-function messageNotificationSection(lifecycleKind) {
-  if (lifecycleKind === "per_turn") {
-    return [
-      "## Message notifications",
-      "",
-      "You run once per wake, then your process exits — there is nothing to poll for mid-turn. " + "Finish the current wake's work, then stop. The host spawns a brand-new process for the " + "next message; it re-checks the inbox at the start of that new wake."
-    ].join(`
-`);
-  }
-  return [
-    "## Message notifications",
+    "`./.context_timeline/YYYY-MM-DD.jsonl` — ordered daily log of what you did. Authoritative " + "history. After compaction, read here to resume.",
+    "",
+    "### todo.md",
     "",
-    "Your process stays alive across turns. Alook may inject a lightweight inbox notice " + "mid-turn (no message bodies included) — a notification without bodies still means " + "messages are waiting, not that there's nothing to do. " + "Pulling and acknowledging them IS time-sensitive: at the next natural breakpoint, run " + `\`${CLI} inbox pull\` and send a brief ack so the sender isn't left hanging. Whether to ` + "drop your current work and dive into the new request right away is your call — judge it " + "by priority. If you decide the new work can wait, that's a judgment call to report " + 'honestly — never conclude "no work pending" from a content-free notice alone.'
+    "When a wake brings more than one thing — batch of unread, multi-step request, work " + "interrupted by new inbound — write the queue to `./todo.md` before starting the first " + "task. Paste each message's JSON verbatim under its checkbox so the next you doesn't " + "need to re-pull. **Only unprocessed tasks live here** — on finish, delete the line " + "(don't leave `[x]`). Delete the file when empty.",
+    "",
+    "Example:",
+    "",
+    "```md",
+    '- [ ] {"seq": "#42", "channel": "/demo/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/design/#12", "sender": "@alice#0001", "content": {"text": "follow-up — send a screenshot of the before/after"}, "time": "2026-06-01T12:07:00Z"}',
+    "```",
+    "",
+    "**When to use todo.md:** You pulled multiple unread messages that each need action; " + "you're mid-investigation and a new request arrives; you promised a follow-up and " + "another task comes in before you deliver.",
+    "",
+    "**Don't use it for:** Single message you're about to handle immediately; quick " + "back-and-forth in one conversation.",
+    "",
+    "todo.md is an overflow queue, not your stopping condition. An empty (or absent) todo.md " + "means nothing is queued for later — it does NOT mean you're done. You're done when " + "in-flight work is done: the thing you're actively on, every promised follow-up, every " + "investigation you started. Don't read an empty queue as a finished task list."
   ].join(`
 `);
 }
-function buildCliSystemPrompt(config, opts) {
+function buildCliSystemPrompt(config, _opts) {
   const sections = [
     identitySection(config),
     cliCommandsSection(),
     messagingSection(),
-    serversSection(),
-    channelsSection(),
     criticalRulesSection(),
-    startupSequenceSection(),
-    communicationStyleSection(),
-    channelAwarenessSection(),
+    executionModelSection(),
+    chaosAwarenessSection(),
     workspaceMemorySection(),
-    messageNotificationSection(opts.lifecycleKind)
+    utilsSection()
   ];
   return sections.filter((s) => s && s.length > 0).join(`
 
@@ -4092,6 +4507,16 @@ function deriveAuditLogSubcommand(pathname) {
     return null;
   return sub;
 }
+function emitImplicitTypingStopOnSend(args) {
+  if (args.subcommand !== "send")
+    return;
+  const emit = args.reportAgentTypingStop;
+  if (!emit)
+    return;
+  for (const dmConversationId of args.typingTracker.snapshot(args.agentId)) {
+    emit({ agentId: args.agentId, dmConversationId });
+  }
+}
 async function createDaemon(opts) {
   const log = opts.logger ?? createLogger({ header: "@alook/daemon" });
   const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir2()}/.alook`) + "/daemon";
@@ -4112,6 +4537,7 @@ async function createDaemon(opts) {
       event
     });
   };
+  const typingTracker = createTypingScopeTracker();
   const broker = new CredentialBroker({ upstreamBaseUrl: opts.serverUrl });
   const proxy = await startCredentialProxy(broker, {
     onInboxPullResponse: (agentId, messages) => timeline2.appendEntryForAgent(agentId, messages),
@@ -4124,10 +4550,15 @@ async function createDaemon(opts) {
         kind: "cli_invocation",
         payload: { subcommand }
       }, context);
+      emitImplicitTypingStopOnSend({
+        subcommand,
+        agentId,
+        typingTracker,
+        reportAgentTypingStop: channelRef?.reportAgentTypingStop?.bind(channelRef)
+      });
     }
   });
   const enrolledKeys = new Map;
-  const typingTracker = createTypingScopeTracker();
   const typingHeartbeats = new Map;
   const TYPING_HEARTBEAT_MS = 5000;
   function stopTypingHeartbeat(agentId) {
@@ -4334,6 +4765,7 @@ async function createDaemon(opts) {
     sdkDriverDepsFor: (ctx) => createPiSdkDriverDeps(ctx),
     timeline: timeline2,
     wakePromptFooter: "Use `alook inbox pull` to read your messages, then reply with `alook message send`.",
+    stampWakePromptTime: true,
     logger: log.child("manager")
   });
   managerRef = manager;
@@ -4684,8 +5116,23 @@ function parseInviteToken(input) {
   return BARE_TOKEN_RE.test(trimmed) ? trimmed : null;
 }
 
+// ../shared/src/constants/community.ts
+var MAX_EMOJI_BYTES = 32;
+var MAX_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
+var MAX_SERVER_ICON_SIZE_BYTES = 5 * 1024 * 1024;
+var MAX_ICON_SOURCE_FILE_SIZE_BYTES = 15 * 1024 * 1024;
+
 // src/cli/index.ts
+function messagesInLocalTime(messages) {
+  return messages.map((m) => ({ ...m, time: toLocalISO(m.time) }));
+}
+
 class CliError extends Error {
+  hint;
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+  }
 }
 function printEnvelope(env) {
   const out = {};
@@ -4766,6 +5213,14 @@ async function cmdMessageSend(opts) {
   const channel = opts.target;
   if (!channel)
     throw new CliError("message send: --target <ref> is required (e.g. /demo-workspace/general)");
+  const chaoticLevel = opts.chaotic_level || opts.chaoticLevel;
+  const chaoticHint = "Re-read the Chaos Awareness section in AGENTS.md and reflect before sending.";
+  if (!chaoticLevel || chaoticLevel !== "fine" && chaoticLevel !== "severe") {
+    throw new CliError("message send: --chaotic_level must be 'fine' or 'severe'.", chaoticHint);
+  }
+  if (chaoticLevel === "severe") {
+    throw new CliError("message send: --chaotic_level is 'severe'.", chaoticHint);
+  }
   let text;
   const fileFlag = opts.file;
   const textFlag = opts.text;
@@ -4793,6 +5248,34 @@ async function cmdMessageSend(opts) {
   }
   return { sent: `${res.message.channel}${res.message.seq}` };
 }
+async function cmdMessageEmoji(opts) {
+  const api = getApi();
+  const target = opts.target;
+  const emoji = opts.emoji;
+  if (!target)
+    throw new CliError("message emoji: --target <ref> is required (e.g. /demo/general#42)");
+  if (!emoji)
+    throw new CliError("message emoji: --emoji <string> is required");
+  let parsed;
+  try {
+    parsed = parseRef(target);
+  } catch (err) {
+    throw new CliError(`message emoji: ${err.message}`);
+  }
+  if (parsed.seq === undefined) {
+    const err = new CliError(`message emoji 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(emoji, "utf8") > MAX_EMOJI_BYTES) {
+    const err = new CliError("emoji is too long");
+    err.hint = "use a single emoji, not a phrase";
+    throw err;
+  }
+  const channel = parsed.threadRootSeq !== undefined ? `/${parsed.server}/${parsed.channel}/#${parsed.threadRootSeq}` : `/${parsed.server}/${parsed.channel}`;
+  const res = await api.reactAdd({ channel, seq: parsed.seq, emoji });
+  return { target, emoji, duplicate: res.duplicate === true };
+}
 async function cmdAttachmentUpload(opts) {
   const api = getApi();
   const agent = agentId(opts);
@@ -4857,7 +5340,9 @@ async function cmdInboxPull(opts) {
   const agent = agentId(opts);
   const max = opts.max ? Number(opts.max) : undefined;
   const { messages, hasMore } = await api.inboxPull({ agentId: agent, max });
+  const pulledAt = nowLocalISO();
   let acked = 0;
+  let ackError;
   if (opts.ack !== false && messages.length > 0) {
     const latest = new Map;
     for (const m of messages) {
@@ -4866,10 +5351,20 @@ async function cmdInboxPull(opts) {
       if (!cur || seqN > cur.seq)
         latest.set(m.channel, { channel: m.channel, seq: seqN });
     }
-    await api.ack({ agentId: agent, cursors: [...latest.values()] });
-    acked = latest.size;
+    try {
+      await api.ack({ agentId: agent, cursors: [...latest.values()] });
+      acked = latest.size;
+    } catch (err) {
+      ackError = err instanceof Error ? err.message : String(err);
+    }
   }
-  return { messages, hasMore, acked };
+  return {
+    messages: messagesInLocalTime(messages),
+    hasMore,
+    acked,
+    pulledAt,
+    ...ackError ? { ackError } : {}
+  };
 }
 async function cmdServerList(opts) {
   const api = getApi();
@@ -4904,8 +5399,15 @@ async function cmdChannelList(opts) {
   const server = opts.server;
   if (!server)
     throw new CliError("channel list: --server <id-or-name> is required");
-  const { channels } = await api.listChannels({ agentId: agent, server });
-  return { channels };
+  return await api.listChannels({ agentId: agent, server });
+}
+async function cmdChannelMember(opts) {
+  const api = getApi();
+  const agent = agentId(opts);
+  const channel = opts.channel;
+  if (!channel)
+    throw new CliError("channel member: --channel <ref> is required");
+  return await api.channelMember({ agentId: agent, channel });
 }
 async function cmdChannelHistory(opts) {
   const api = getApi();
@@ -4922,7 +5424,7 @@ async function cmdChannelHistory(opts) {
     around: toSeq(opts.around),
     limit: toSeq(opts.limit)
   });
-  return { items, hasMore, ...latestSeq !== undefined ? { latestSeq } : {} };
+  return { items: messagesInLocalTime(items), hasMore, ...latestSeq !== undefined ? { latestSeq } : {} };
 }
 function buildProgram() {
   const program = new Command("alook").description("agent CLI").exitOverride().configureOutput({
@@ -4931,12 +5433,18 @@ function buildProgram() {
   }).option("--agent <id>", "agent identity (or ALOOK_AGENT_ID env)");
   const message = program.command("message").description("message operations").exitOverride();
   message.configureOutput({ writeOut: () => {}, writeErr: () => {} });
-  message.command("send").description("send a message to a channel, DM, or thread").option("--target <ref>", "destination (path-style ref, e.g. /demo-workspace/general)").option("--text <text>", "inline message body (short messages)").option("--file <path>", "read message body from a file (long messages)").option("-a, --attachment <id>", "attach an uploaded file by id (repeatable — order = message order)", (v, prev = []) => [...prev, v], []).exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+  message.command("send").description("send a message to a channel, DM, or thread").option("--target <ref>", "destination (path-style ref, e.g. /demo-workspace/general)").option("--text <text>", "inline message body (short messages)").option("--file <path>", "read message body from a file (long messages)").option("-a, --attachment <id>", "attach an uploaded file by id (repeatable — order = message order)", (v, prev = []) => [...prev, v], []).option("--chaotic_level <level>", "chaos level: 'fine' or 'severe' (required)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
     const localOpts = this.opts();
     const globalOpts = program.opts();
     const result = await cmdMessageSend({ ...globalOpts, ...localOpts });
     printEnvelope({ success: result });
   });
+  message.command("emoji").description("react to a message with a single emoji").requiredOption("--target <ref>", "message ref (path-style, e.g. /demo/general#42 or /.dm/peer#7)").requiredOption("--emoji <string>", "single emoji character").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdMessageEmoji({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
   const attachment = message.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() {
@@ -4993,6 +5501,12 @@ function buildProgram() {
     const result = await cmdChannelHistory({ ...globalOpts, ...localOpts });
     printEnvelope({ success: result });
   });
+  channel.command("member").description("fetch the followed members of a channel or thread; public channels return a hint pointing at `alook server member`").option("--channel <ref>", "channel/thread ref (path-style)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
+    const localOpts = this.opts();
+    const globalOpts = program.opts();
+    const result = await cmdChannelMember({ ...globalOpts, ...localOpts });
+    printEnvelope({ success: result });
+  });
   const daemon = program.command("daemon").description("daemon operations").exitOverride();
   daemon.configureOutput({ writeOut: () => {}, writeErr: () => {} });
   daemon.command("start").description("start the daemon (connects to server, manages agent lifecycles)").requiredOption("--machine-key <key>", "machine key for server authentication").option("--server-url <url>", "server HTTP URL (or ALOOK_SERVER_URL env)").option("--ws-url <url>", "server WebSocket URL (or ALOOK_SERVER_WS_URL env)").option("--base-dir <path>", "data directory for agent workspaces and pidfile (or ALOOK_DATA_DIR env)").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} }).action(async function() {
@@ -5054,8 +5568,13 @@ function getHelpText(program, argv) {
   }
   return cmd.helpInformation();
 }
-var invokedDirectly = typeof process !== "undefined" && process.argv[1] && /(?:^|[\\/])(?:cli[\\/]index\.[jt]s|alook)$/.test(process.argv[1]) && !process.argv[1].includes("vitest") && !process.argv[1].includes("node_modules");
-if (invokedDirectly) {
+var isMainModule = false;
+try {
+  if (typeof process !== "undefined" && process.argv[1]) {
+    isMainModule = import.meta.url === pathToFileURL2(realpathSync2(process.argv[1])).href;
+  }
+} catch {}
+if (isMainModule) {
   main().then((code) => process.exit(code));
 }
 export {