@tinycloud/cli 1.3.0-beta.48 → 1.3.0-beta.49

package/dist/courier-entry.js

@@ -4,10 +4,10 @@ var EXT = "https://tinycloud.xyz/ext/courier/v0";
 var DEFAULT_HOST = "https://tee.node.tinycloud.xyz";
 var COURIER_SPACE = "agents";
 var AGENT_GRANT_EXPIRY = "30d";
-var kv = (path18, actions) => ({
+var kv = (path20, actions) => ({
   service: "tinycloud.kv",
   space: COURIER_SPACE,
-  path: `${PREFIX}/${path18}`,
+  path: `${PREFIX}/${path20}`,
   actions: actions.map((action) => `tinycloud.kv/${action}`)
 });
 var AGENT_GRANT = [
@@ -416,6 +416,30 @@ function errInfo(e) {
     message: String(anyE.message ?? e).slice(0, 400)
   };
 }
+var TRANSIENT_CODES = ["NETWORK_ERROR", "ECONNRESET", "ETIMEDOUT"];
+function fieldOf(source, name2) {
+  return typeof source === "object" && source !== null ? Reflect.get(source, name2) : void 0;
+}
+function asStatus(value2) {
+  const n = typeof value2 === "string" && /^\d{3}$/.test(value2) ? Number(value2) : value2;
+  return typeof n === "number" && Number.isInteger(n) ? n : void 0;
+}
+function httpStatuses(error) {
+  return [fieldOf(error, "status"), fieldOf(fieldOf(error, "meta"), "status"), fieldOf(error, "code")].map(asStatus).filter((s) => s !== void 0);
+}
+function isPreconditionError(error) {
+  return fieldOf(error, "code") === "KV_PRECONDITION_FAILED" || httpStatuses(error).includes(412);
+}
+function isNotFoundError(error) {
+  return fieldOf(error, "code") === "KV_NOT_FOUND" || httpStatuses(error).includes(404);
+}
+function isTransientError(error) {
+  if (httpStatuses(error).some((s) => s >= 500 && s <= 599))
+    return true;
+  const code = fieldOf(error, "code");
+  const causeCode = fieldOf(fieldOf(error, "cause"), "code");
+  return TRANSIENT_CODES.some((c) => c === code || c === causeCode);
+}
 function unwrap(r, what) {
   if (r && typeof r === "object" && "ok" in r) {
     const res = r;
@@ -569,7 +593,6 @@ function defer() {
 
 // ../courier/dist/store.js
 var FULL = { prefix: "" };
-var TRANSIENT = /fetch failed|NETWORK_ERROR|ECONNRESET|ETIMEDOUT|5\d\d/i;
 async function nap(ms2) {
   const { promise, resolve } = defer();
   setTimeout(resolve, ms2);
@@ -582,8 +605,7 @@ async function readRetry(fn) {
       const r = await fn();
       const res = r;
       if (res && typeof res === "object" && res.ok === false) {
-        const m = `${res.error?.code ?? ""} ${res.error?.message ?? ""}`;
-        if (TRANSIENT.test(m) && i < 2) {
+        if (isTransientError(res.error) && i < 2) {
           await nap(1500);
           continue;
         }
@@ -591,7 +613,8 @@ async function readRetry(fn) {
       return r;
     } catch (e) {
       last = e;
-      if (!TRANSIENT.test(String(e.message ?? e)) || i === 2)
+      const undiciFetchFailure = e instanceof Error && e.message === "fetch failed";
+      if (!(isTransientError(e) || undiciFetchFailure) || i === 2)
         throw e;
       await nap(1500);
     }
@@ -607,7 +630,7 @@ async function putCreate(kv2, key, value2) {
   try {
     return putEtag(unwrap(r, `put ${key}`));
   } catch (e) {
-    if (e instanceof CourierError && (e.code === "412" || /412|conflict|precondition/i.test(e.message))) {
+    if (e instanceof CourierError && r.ok === false && isPreconditionError(r.error)) {
       throw new CourierError("conflict", `${key} already exists (create-only write)`);
     }
     throw e;
@@ -618,7 +641,7 @@ async function putMatch(kv2, key, value2, etag) {
   try {
     return putEtag(unwrap(r, `put ${key}`));
   } catch (e) {
-    if (e instanceof CourierError && (e.code === "412" || /412|conflict|precondition/i.test(e.message))) {
+    if (e instanceof CourierError && r.ok === false && isPreconditionError(r.error)) {
       throw new CourierError("conflict", `${key} changed under us; re-read and retry`);
     }
     throw e;
@@ -627,11 +650,10 @@ async function putMatch(kv2, key, value2, etag) {
 async function getJson(kv2, key) {
   const r = await readRetry(() => kv2.get(key, FULL));
   if (r && typeof r === "object" && "ok" in r && !r.ok) {
-    const status = r.error?.status ?? r.error?.meta?.status ?? r.error?.code;
     if (/space not found/i.test(String(r.error?.message))) {
       throw new CourierError("no-space", String(r.error?.message));
     }
-    if (status === 404 || String(status) === "404" || /not.found/i.test(String(r.error?.message)))
+    if (isNotFoundError(r.error))
       return void 0;
     unwrap(r, `get ${key}`);
   }
@@ -747,7 +769,7 @@ async function commitReceipts(selfKv, pending) {
           await putCreate(selfKv, key, receipts);
         break;
       } catch (error) {
-        const conflict = /conflict|412|precondition/i.test(`${errInfo(error).code ?? ""} ${errInfo(error).message}`);
+        const conflict = error instanceof CourierError && error.code === "conflict";
         if (conflict && attempt < 2)
           continue;
         console.error(`warning: could not advance receipts for ${peer}: ${errInfo(error).message}`);
@@ -804,7 +826,7 @@ function authorityTuples(entries) {
   return tuples;
 }
 function renderTuples(tuples) {
-  const shown = tuples.slice(0, 3).map(({ service, space, path: path18, action }) => `${service} ${space} ${path18 || '""'} ${action}`);
+  const shown = tuples.slice(0, 3).map(({ service, space, path: path20, action }) => `${service} ${space} ${path20 || '""'} ${action}`);
   if (tuples.length > 3)
     shown.push(`(+${tuples.length - 3} more)`);
   return shown.join("; ");
@@ -1943,13 +1965,13 @@ function contentReason(value2, field) {
     return "not-nfc";
   return void 0;
 }
-function textVerdict(value2, field) {
+function textVerdict(value2, field, maxUnits) {
   let reason;
   if (typeof value2 !== "string")
     reason = "not-string";
   else if (value2.length === 0)
     reason = "empty";
-  else if (value2.length > (field === "multiline" ? MAX_ACTION : MAX_SUMMARY))
+  else if (value2.length > (maxUnits ?? (field === "multiline" ? MAX_ACTION : MAX_SUMMARY)))
     reason = "too-long";
   else if (field !== "multiline" && (value2.startsWith(" ") || value2.endsWith(" ")))
     reason = "edge-whitespace";
@@ -7362,8 +7384,8 @@ var Watcher = class {
     const prefix = `${PREFIX}/to/${peer.handle}/threads/`;
     const keys = await listAll(this.deps.selfKv, prefix);
     const known = /* @__PURE__ */ new Set();
-    for (const path18 of keys) {
-      const match = /^([^/]+)\/(?:meta\.json|(?:msg|task)\/[^/]+\.json)$/.exec(path18.slice(prefix.length));
+    for (const path20 of keys) {
+      const match = /^([^/]+)\/(?:meta\.json|(?:msg|task)\/[^/]+\.json)$/.exec(path20.slice(prefix.length));
       if (match && SAFE_ID.test(match[1]))
         known.add(`${peer.handle}/${match[1]}`);
     }
@@ -8976,6 +8998,860 @@ async function cmdWatch(args) {
   }
 }
 
+// ../courier/dist/intake/intake.js
+import fs16 from "fs";
+import path18 from "path";
+
+// ../courier/dist/intake/flags.js
+var FLAG_TABLE = {
+  "too-long": { severity: "tiered", description: "text is over 8000 UTF-16 units; the text is still queued" },
+  link: { severity: "soft", description: "a URL-like string is present" },
+  instruction: { severity: "soft", description: "matches the fixed instruction-phrase table" },
+  request: { severity: "soft", description: "asks the reader or its principal to take an action (fixed verb-phrase table)" },
+  "secret-request": { severity: "hard", description: "asks for keys, tokens, passwords or credentials" },
+  encoded: { severity: "hard", description: "a long base64- or hex-looking run is present" },
+  unicode: { severity: "hard", description: "shared text verdict: not-nfc, disallowed-code-point, edge-whitespace, not-string or empty" },
+  size: { severity: "hard", description: "original text exceeded the 16 KiB queue cap and was cut at a code-point boundary" },
+  rate: { severity: "hard", description: "peer is over its inbound per-hour cap" }
+};
+
+// ../courier/dist/intake/peers.js
+import fs14 from "fs";
+var DEFAULT_IN_PER_HOUR = 100;
+var DEFAULT_OUT_PER_HOUR = 100;
+var KEYS = { tier: true, ratePerHour: true, outPerHour: true };
+var TIERS = { trusted: true, strict: true };
+var ABSENT = { tier: "strict", ratePerHour: DEFAULT_IN_PER_HOUR, outPerHour: DEFAULT_OUT_PER_HOUR };
+function cap(value2, fallback) {
+  if (value2 === void 0)
+    return fallback;
+  if (!Number.isInteger(value2) || value2 < 1 || value2 > fallback)
+    return void 0;
+  return value2;
+}
+function parseEntry(value2) {
+  if (!isRecord(value2))
+    return void 0;
+  if (Object.keys(value2).some((key) => !Object.hasOwn(KEYS, key)))
+    return void 0;
+  const tier = value2.tier ?? "strict";
+  if (typeof tier !== "string" || !Object.hasOwn(TIERS, tier))
+    return void 0;
+  const ratePerHour = cap(value2.ratePerHour, DEFAULT_IN_PER_HOUR);
+  const outPerHour = cap(value2.outPerHour, DEFAULT_OUT_PER_HOUR);
+  if (ratePerHour === void 0 || outPerHour === void 0)
+    return void 0;
+  return { tier, ratePerHour, outPerHour };
+}
+function loadPeers(path20, ownerUid = process.getuid?.()) {
+  let fd;
+  try {
+    fd = fs14.openSync(path20, fs14.constants.O_RDONLY | fs14.constants.O_NOFOLLOW);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT")
+      return /* @__PURE__ */ Object.create(null);
+    if (code === "ELOOP")
+      throw new CourierError("insecure-peers", `${path20} is a symbolic link; point the flag at the file itself.`);
+    throw error;
+  }
+  try {
+    const stat = fs14.fstatSync(fd);
+    if (!stat.isFile())
+      throw new CourierError("insecure-peers", `${path20} is not a regular file.`);
+    if (ownerUid !== void 0 && stat.uid !== ownerUid)
+      throw new CourierError("insecure-peers", `${path20} is not owned by the courier user.`);
+    if ((stat.mode & 18) !== 0) {
+      throw new CourierError("insecure-peers", `${path20} is writable by group or others; restrict it to the owner (chmod 600).`);
+    }
+    const parsed = JSON.parse(fs14.readFileSync(fd, "utf8"));
+    if (!isRecord(parsed))
+      throw new CourierError("bad-peers", `${path20} must be a JSON object keyed by peer id.`);
+    const peers = /* @__PURE__ */ Object.create(null);
+    for (const [peerId, value2] of Object.entries(parsed)) {
+      const policy = parseEntry(value2);
+      if (!policy)
+        throw new CourierError("bad-peers", `${path20} has an invalid policy for peer "${peerId}"; fix the entry. Nothing was loaded.`);
+      peers[peerId] = policy;
+    }
+    return peers;
+  } finally {
+    fs14.closeSync(fd);
+  }
+}
+function policyOf(peers, peerId) {
+  return Object.hasOwn(peers, peerId) ? peers[peerId] : { ...ABSENT };
+}
+
+// ../courier/dist/intake/queue.js
+import fs15 from "fs";
+import path17 from "path";
+import { randomBytes as randomBytes3 } from "crypto";
+function ensureRealDir(dir, mode) {
+  let existed = true;
+  try {
+    fs15.lstatSync(dir);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    existed = false;
+  }
+  fs15.mkdirSync(dir, { recursive: true, mode });
+  const stat = fs15.lstatSync(dir);
+  if (stat.isSymbolicLink() || !stat.isDirectory()) {
+    throw new CourierError("unsafe-dir", "queue or state path is not a real directory");
+  }
+  if (!existed && stat.uid === process.getuid?.() && (stat.mode & 4095) !== mode)
+    fs15.chmodSync(dir, mode);
+}
+function fsyncDir(dir) {
+  const fd = fs15.openSync(dir, "r");
+  try {
+    fs15.fsyncSync(fd);
+  } finally {
+    fs15.closeSync(fd);
+  }
+}
+function writeTemp(dir, name2, body, mode) {
+  const temp = path17.join(dir, `.${name2}.${randomBytes3(6).toString("hex")}.tmp`);
+  const fd = fs15.openSync(temp, "wx", mode);
+  try {
+    fs15.writeFileSync(fd, body);
+    fs15.fchmodSync(fd, mode);
+    fs15.fsyncSync(fd);
+  } catch (error) {
+    fs15.closeSync(fd);
+    fs15.rmSync(temp, { force: true });
+    throw error;
+  }
+  fs15.closeSync(fd);
+  return temp;
+}
+function writeNew(dir, name2, body, mode) {
+  const temp = writeTemp(dir, name2, body, mode);
+  try {
+    fs15.linkSync(temp, path17.join(dir, name2));
+    fsyncDir(dir);
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST")
+      return false;
+    throw error;
+  } finally {
+    fs15.rmSync(temp, { force: true });
+  }
+}
+function writeReplace(dir, name2, body, mode) {
+  const target2 = path17.join(dir, name2);
+  try {
+    if (!fs15.lstatSync(target2).isFile())
+      throw new CourierError("unsafe-target", "refusing to replace a non-regular file");
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const temp = writeTemp(dir, name2, body, mode);
+  try {
+    fs15.renameSync(temp, target2);
+    fsyncDir(dir);
+  } catch (error) {
+    fs15.rmSync(temp, { force: true });
+    throw error;
+  }
+}
+function parseRecord(text) {
+  if (/^\d+\n?$/.test(text)) {
+    const pid = Number(text);
+    return Number.isInteger(pid) && pid > 0 ? { pid, nonce: text } : void 0;
+  }
+  try {
+    const value2 = JSON.parse(text);
+    if (typeof value2 !== "object" || value2 === null)
+      return void 0;
+    const { pid, nonce } = value2;
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+      return void 0;
+    if (typeof nonce !== "string" || nonce.length === 0)
+      return void 0;
+    return { pid, nonce };
+  } catch {
+    return void 0;
+  }
+}
+function recordBody(record) {
+  return `${JSON.stringify({ pid: record.pid, nonce: record.nonce })}
+`;
+}
+function readRecordFile(file) {
+  try {
+    return parseRecord(fs15.readFileSync(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readLock(file) {
+  let text;
+  try {
+    text = fs15.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { kind: "missing" };
+    throw error;
+  }
+  const record = parseRecord(text);
+  return record ? { kind: "held", record } : { kind: "corrupt" };
+}
+function pidAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var MAX_BREAK_GUARDS = 8;
+function acquireLock(file, opts = {}) {
+  const dir = path17.dirname(file);
+  const name2 = path17.basename(file);
+  const alive = opts.alive ?? pidAlive2;
+  const self2 = { pid: opts.pid ?? process.pid, nonce: randomBytes3(6).toString("hex") };
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (writeNew(dir, name2, recordBody(self2), 384)) {
+      return () => {
+        const current = readLock(file);
+        if (current.kind === "held" && current.record.nonce === self2.nonce)
+          fs15.rmSync(file, { force: true });
+      };
+    }
+    const seen = readLock(file);
+    if (seen.kind === "missing")
+      continue;
+    if (seen.kind === "corrupt" || alive(seen.record.pid)) {
+      throw new CourierError("locked", "another courier intake is running");
+    }
+    opts.afterObserve?.();
+    if (!breakDead(file, seen.record, self2, alive)) {
+      throw new CourierError("locked", "another courier intake is running");
+    }
+  }
+  throw new CourierError("locked", "another courier intake is running");
+}
+function breakDead(file, stale, self2, alive) {
+  const dir = path17.dirname(file);
+  const tag = `${path17.basename(file)}.break.${stale.nonce.trim().replace(/[^A-Za-z0-9_-]/g, "_")}.`;
+  const body = recordBody(self2);
+  let claimed = false;
+  for (let k2 = 1; k2 <= MAX_BREAK_GUARDS && !claimed; k2++) {
+    const candidate = `${tag}${k2}`;
+    if (writeNew(dir, candidate, body, 384)) {
+      claimed = true;
+      break;
+    }
+    const holder = readRecordFile(path17.join(dir, candidate));
+    if (holder && alive(holder.pid))
+      return false;
+  }
+  if (!claimed)
+    return false;
+  try {
+    const now = readLock(file);
+    if (now.kind === "held" && now.record.nonce === stale.nonce)
+      fs15.rmSync(file, { force: true });
+    return true;
+  } finally {
+    for (const entry of fs15.readdirSync(dir)) {
+      if (entry.startsWith(tag))
+        fs15.rmSync(path17.join(dir, entry), { force: true });
+    }
+  }
+}
+function emptyState() {
+  return { v: 1, peers: /* @__PURE__ */ Object.create(null) };
+}
+function readState(file) {
+  let raw;
+  try {
+    raw = fs15.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return emptyState();
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CourierError("bad-state", "intake state is not valid JSON");
+  }
+  if (!isRecord(parsed) || parsed.v !== 1 || !isRecord(parsed.peers))
+    throw new CourierError("bad-state", "intake state has an unknown shape");
+  const peers = /* @__PURE__ */ Object.create(null);
+  for (const [peerId, entry] of Object.entries(parsed.peers)) {
+    if (!isRecord(entry) || !Array.isArray(entry.receipts) || entry.cursor !== void 0 && typeof entry.cursor !== "string") {
+      throw new CourierError("bad-state", "intake state has an unknown shape");
+    }
+    const peer = { receipts: entry.receipts.map(readReceipt) };
+    if (typeof entry.cursor === "string")
+      peer.cursor = entry.cursor;
+    peers[peerId] = peer;
+  }
+  return { v: 1, peers };
+}
+function readReceipt(raw, index) {
+  if (typeof raw === "number")
+    return { id: `legacy-${index}`, at: raw };
+  if (isRecord(raw) && typeof raw.id === "string" && typeof raw.at === "number")
+    return { id: raw.id, at: raw.at };
+  throw new CourierError("bad-state", "intake state has an unknown shape");
+}
+function writeState(dir, file, state) {
+  writeReplace(dir, path17.basename(file), `${JSON.stringify(state)}
+`, 384);
+}
+
+// ../courier/dist/intake/intake.js
+var STATE_FILE = "intake-state.json";
+var LOCK_FILE = "intake.lock";
+var HOUR_MS = 60 * 6e4;
+var DAY_MS3 = 24 * HOUR_MS;
+var MAX_SKEW_MS = 10 * 6e4;
+var STALE_MS = 7 * DAY_MS3;
+var DONE_TTL_MS = 14 * DAY_MS3;
+var OVERFLOW_TTL_MS = STALE_MS;
+var OVERFLOW_MAX_FILES = 200;
+var OVERFLOW_MAX_BYTES = 1024 * 1024;
+var MIRROR_BATCH = 200;
+var JANITOR_BATCH = 500;
+var RATE_WINDOW_MS = HOUR_MS;
+var MAX_QUEUE_CHARS = 8e3;
+var MAX_QUEUE_BYTES = 16 * 1024;
+var RATE_TEXT = "This peer went over its inbound rate limit; further messages this hour are held outside the queue.";
+var ULID_RE = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
+var SAFE_ID2 = /^[0-9A-Za-z_-]{1,64}$/;
+var MSG_KEY2 = /\/threads\/([^/]+)\/msg\/([^/]+)\.json$/;
+var LINK = /(?:https?|ftp):\/\/|\bwww\.[a-z0-9-]+\./i;
+var ENCODED = /[A-Za-z0-9+\/=]{64,}/;
+var REQUEST = /(?:^|[.!?\n]\s*|\bplease\s+)(?:run|merge|send|open|forward|delete|reveal|deploy)\b/i;
+var SECRET_REQUEST = /\b(?:share|send|give|paste|reveal|tell|show|post)\b[^.!?\n]{0,40}\b(?:keys?|tokens?|passwords?|credentials?|secrets?|seed phrase)\b/i;
+var INSTRUCTION_PHRASES = [
+  "ignore previous",
+  "ignore all previous",
+  "disregard previous",
+  "forget your instructions",
+  "you are now",
+  "new instructions",
+  "system prompt",
+  "override your"
+];
+function capUtf8(text, maxBytes) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes)
+    return { text, truncated: false };
+  let out = "";
+  let bytes = 0;
+  for (const ch of text) {
+    const n = Buffer.byteLength(ch, "utf8");
+    if (bytes + n > maxBytes)
+      break;
+    out += ch;
+    bytes += n;
+  }
+  return { text: out, truncated: true };
+}
+function flagsFor(input) {
+  const found = /* @__PURE__ */ new Set();
+  if (!input.verdict.allowed && input.verdict.reason === "too-long")
+    found.add("too-long");
+  if (hiddenTextProblem(input.text, true) || !input.verdict.allowed && input.verdict.reason !== "too-long")
+    found.add("unicode");
+  const lower = input.text.toLowerCase();
+  if (LINK.test(input.text))
+    found.add("link");
+  if (INSTRUCTION_PHRASES.some((phrase) => lower.includes(phrase)))
+    found.add("instruction");
+  if (REQUEST.test(input.text))
+    found.add("request");
+  if (SECRET_REQUEST.test(input.text))
+    found.add("secret-request");
+  if (ENCODED.test(input.text))
+    found.add("encoded");
+  if (input.overRate)
+    found.add("rate");
+  if (input.truncated)
+    found.add("size");
+  return Object.keys(FLAG_TABLE).filter((flag) => found.has(flag));
+}
+function admit(receipts, id, at, cap2) {
+  const recent = receipts.filter((r) => r.at > at - RATE_WINDOW_MS);
+  if (recent.length >= cap2)
+    return { admitted: false, remaining: 0, receipts: recent.slice(-cap2) };
+  return { admitted: true, remaining: cap2 - recent.length - 1, receipts: [...recent, { id, at }].slice(-cap2) };
+}
+var reconciledPeers = /* @__PURE__ */ new WeakMap();
+function reconciledSet(state) {
+  let set = reconciledPeers.get(state);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    reconciledPeers.set(state, set);
+  }
+  return set;
+}
+function reconcileReceipts(input, peer, receipts, cap2) {
+  const now = input.now();
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of receipts)
+    if (!byId.has(r.id))
+      byId.set(r.id, r);
+  for (const root of [input.queueRoot, input.doneRoot]) {
+    const dir = path18.join(root, peer);
+    let names;
+    try {
+      names = fs16.readdirSync(dir);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      throw error;
+    }
+    for (const name2 of names) {
+      if (!name2.endsWith(".json"))
+        continue;
+      const id = name2.slice(0, -".json".length);
+      if (!ULID_RE.test(id) || byId.has(id))
+        continue;
+      const file = path18.join(dir, name2);
+      let stat;
+      try {
+        stat = fs16.lstatSync(file);
+      } catch {
+        continue;
+      }
+      if (!stat.isFile() || stat.mtimeMs < now - RATE_WINDOW_MS - 6e4)
+        continue;
+      let record;
+      try {
+        record = JSON.parse(fs16.readFileSync(file, "utf8"));
+      } catch {
+        continue;
+      }
+      if (!isRecord(record) || typeof record.receivedAt !== "string")
+        continue;
+      const at = Date.parse(record.receivedAt);
+      if (Number.isFinite(at))
+        byId.set(id, { id, at });
+    }
+  }
+  return [...byId.values()].filter((r) => r.at > now - RATE_WINDOW_MS).sort((a, b) => a.at - b.at).slice(-cap2);
+}
+function persist(input, peer) {
+  try {
+    writeState(input.stateDir, path18.join(input.stateDir, STATE_FILE), input.state);
+  } catch (error) {
+    reconciledSet(input.state).delete(peer);
+    throw error;
+  }
+}
+function presentIn(input, peer, name2) {
+  for (const root of [input.queueRoot, input.doneRoot, input.overflowRoot]) {
+    try {
+      fs16.lstatSync(path18.join(root, peer, name2));
+      return true;
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  return false;
+}
+function pathExists(file) {
+  try {
+    fs16.lstatSync(file);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function markDone(input, peer, msgId, outcome) {
+  const dir = path18.join(input.doneRoot, peer);
+  ensureRealDir(dir, 448);
+  const marker = { v: 1, msgId, peerId: peer, outcome, markedAt: new Date(input.now()).toISOString() };
+  return writeNew(dir, `${msgId}.json`, `${JSON.stringify(marker)}
+`, 384);
+}
+function mirrorMessages(handle, keys, log) {
+  const messages = [];
+  for (const key of keys) {
+    const match = MSG_KEY2.exec(key);
+    if (!match)
+      continue;
+    const [, threadId, msgId] = match;
+    if (!ULID_RE.test(threadId) || !ULID_RE.test(msgId)) {
+      log("intake-skip", { peer: handle, code: "bad-id" });
+      continue;
+    }
+    messages.push({ key, threadId, msgId });
+  }
+  return messages;
+}
+function writeRateRecord(input, peer, senderName, tier, at) {
+  const msgId = `rate-${Math.floor(at / RATE_WINDOW_MS)}`;
+  const dir = path18.join(input.queueRoot, peer);
+  ensureRealDir(dir, 1512);
+  const record = {
+    v: 1,
+    msgId,
+    peerId: peer,
+    threadId: "rate",
+    sender: { id: peer, displayName: senderName },
+    receivedAt: new Date(at).toISOString(),
+    text: RATE_TEXT,
+    cheapChecks: {
+      textVerdict: textVerdict(RATE_TEXT, "multiline", MAX_QUEUE_CHARS),
+      tier,
+      peerRatePerHourRemaining: 0,
+      flags: ["rate"]
+    }
+  };
+  if (presentIn(input, peer, `${msgId}.json`))
+    return false;
+  const created = writeNew(dir, `${msgId}.json`, `${JSON.stringify(record)}
+`, 416);
+  if (created)
+    input.log("peer-over-rate", { peer, msgId });
+  return created;
+}
+function pickBatch(items, cursor, cap2, floor) {
+  if (cap2 < 1)
+    return [];
+  const after = [];
+  const wrapped = [];
+  const insertSorted = (list, item) => {
+    if (list.length === cap2 && item.msgId >= list[cap2 - 1].msgId)
+      return;
+    let i = list.length;
+    while (i > 0 && list[i - 1].msgId > item.msgId)
+      i--;
+    list.splice(i, 0, item);
+    if (list.length > cap2)
+      list.pop();
+  };
+  for (const item of items) {
+    if (item.msgId < floor)
+      continue;
+    if (item.msgId > cursor)
+      insertSorted(after, item);
+    else
+      insertSorted(wrapped, item);
+  }
+  return [...after, ...wrapped].slice(0, cap2);
+}
+async function intakePeer(input, peer) {
+  const policy = policyOf(input.peers, peer.handle);
+  const ps = Object.hasOwn(input.state.peers, peer.handle) ? input.state.peers[peer.handle] : { receipts: [] };
+  input.state.peers[peer.handle] = ps;
+  const reconciled = reconciledSet(input.state);
+  if (!reconciled.has(peer.handle)) {
+    ps.receipts = reconcileReceipts(input, peer.handle, ps.receipts, policy.ratePerHour);
+    reconciled.add(peer.handle);
+  }
+  const senderName = typeof peer.label === "string" && textVerdict(peer.label, "summary").allowed ? peer.label : peer.handle;
+  const keys = await listAll(input.kv, `${k.mirrorPrefix}${peer.handle}/threads/`);
+  const all = mirrorMessages(peer.handle, keys, input.log);
+  const cap2 = input.batch ?? MIRROR_BATCH;
+  const floor = encodeTime(input.now() - STALE_MS, 10) + "0".repeat(16);
+  const picked = pickBatch(all, ps.cursor ?? "", cap2, floor);
+  let written = 0;
+  let future = 0;
+  let overflowed = false;
+  try {
+    for (const c of picked) {
+      try {
+        if (presentIn(input, peer.handle, `${c.msgId}.json`))
+          continue;
+        const at = input.now();
+        let sentAt;
+        try {
+          sentAt = decodeTime(c.msgId);
+        } catch {
+          input.log("intake-skip", { peer: peer.handle, code: "bad-id" });
+          markDone(input, peer.handle, c.msgId, "bad-id");
+          continue;
+        }
+        if (sentAt > at + MAX_SKEW_MS) {
+          future++;
+          continue;
+        }
+        const got = await getJson(input.kv, c.key);
+        if (!got || !isRecord(got.value) || got.value.messageId !== c.msgId || got.value.contextId !== c.threadId) {
+          input.log("intake-skip", { peer: peer.handle, code: "mismatch" });
+          markDone(input, peer.handle, c.msgId, "mismatch");
+          continue;
+        }
+        const { admitted, remaining, receipts } = admit(ps.receipts, c.msgId, at, policy.ratePerHour);
+        const parts = Array.isArray(got.value.parts) ? got.value.parts : [];
+        const texts = [];
+        for (const part of parts)
+          if (isRecord(part) && typeof part.text === "string")
+            texts.push(part.text);
+        const text = texts.join("\n");
+        const verdict = textVerdict(text, "multiline", MAX_QUEUE_CHARS);
+        const capped = capUtf8(text, MAX_QUEUE_BYTES);
+        const flags = flagsFor({ text, verdict, overRate: !admitted, truncated: capped.truncated });
+        const record = {
+          v: 1,
+          msgId: c.msgId,
+          peerId: peer.handle,
+          threadId: c.threadId,
+          sender: { id: peer.handle, displayName: senderName },
+          receivedAt: new Date(at).toISOString(),
+          text: capped.text,
+          cheapChecks: { textVerdict: verdict, tier: policy.tier, peerRatePerHourRemaining: remaining, flags }
+        };
+        const body = `${JSON.stringify(record)}
+`;
+        if (admitted) {
+          const dir = path18.join(input.queueRoot, peer.handle);
+          ensureRealDir(dir, 1512);
+          const name2 = `${c.msgId}.json`;
+          let published;
+          try {
+            published = writeNew(dir, name2, body, 416);
+          } catch (error) {
+            if (pathExists(path18.join(dir, name2)))
+              ps.receipts = receipts;
+            throw error;
+          }
+          if (published) {
+            ps.receipts = receipts;
+            persist(input, peer.handle);
+            written++;
+            input.log("intake-queued", { peer: peer.handle, msgId: c.msgId, tier: policy.tier, flags });
+          }
+        } else {
+          const dir = path18.join(input.overflowRoot, peer.handle);
+          ensureRealDir(dir, 448);
+          writeNew(dir, `${c.msgId}.json`, body, 384);
+          overflowed = true;
+          ps.receipts = receipts;
+          persist(input, peer.handle);
+          if (writeRateRecord(input, peer.handle, senderName, policy.tier, at))
+            written++;
+        }
+      } catch (error) {
+        input.log("intake-error", { peer: peer.handle, msgId: c.msgId, code: errInfo(error).code ?? "error" });
+      }
+    }
+  } finally {
+    if (picked.length > 0)
+      ps.cursor = picked[picked.length - 1].msgId;
+    if (overflowed)
+      capOverflow(input, peer.handle);
+    persist(input, peer.handle);
+  }
+  if (future > 0)
+    input.log("intake-skip", { peer: peer.handle, code: "stale", direction: "future", count: future });
+  return written;
+}
+function jsonNames(dir) {
+  return fs16.readdirSync(dir).filter((name2) => name2.endsWith(".json")).sort();
+}
+function nameTime(name2) {
+  const base = name2.slice(0, -".json".length);
+  if (ULID_RE.test(base))
+    return decodeTime(base);
+  const rate = /^rate-(\d+)$/.exec(base);
+  return rate ? Number(rate[1]) * RATE_WINDOW_MS : void 0;
+}
+function retireOverflow(input, peer, name2) {
+  const msgId = name2.slice(0, -".json".length);
+  if (ULID_RE.test(msgId))
+    markDone(input, peer, msgId, "overflow");
+  fs16.unlinkSync(path18.join(input.overflowRoot, peer, name2));
+}
+function capOverflow(input, peer) {
+  const dir = path18.join(input.overflowRoot, peer);
+  const names = jsonNames(dir);
+  const excess = Math.min(Math.max(0, names.length - OVERFLOW_MAX_FILES), JANITOR_BATCH);
+  for (const name2 of names.slice(0, excess))
+    retireOverflow(input, peer, name2);
+  const kept = names.slice(excess);
+  if (kept.length > OVERFLOW_MAX_FILES)
+    return;
+  const sizes = kept.map((name2) => fs16.statSync(path18.join(dir, name2)).size);
+  let bytes = sizes.reduce((sum, size) => sum + size, 0);
+  for (let i = 0; i < kept.length && bytes > OVERFLOW_MAX_BYTES; i++) {
+    retireOverflow(input, peer, kept[i]);
+    bytes -= sizes[i];
+  }
+}
+function peerDirs(root) {
+  return fs16.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && SAFE_ID2.test(entry.name)).map((entry) => entry.name);
+}
+function runJanitor(input) {
+  const now = input.now();
+  for (const peer of peerDirs(input.queueRoot)) {
+    const dir = path18.join(input.queueRoot, peer);
+    let budget = JANITOR_BATCH;
+    for (const name2 of jsonNames(dir)) {
+      const at = nameTime(name2);
+      if (at === void 0 || !(at < now - STALE_MS))
+        continue;
+      if (budget-- <= 0)
+        break;
+      const file = path18.join(dir, name2);
+      const body = fs16.readFileSync(file, "utf8");
+      try {
+        if (!isRecord(JSON.parse(body)))
+          continue;
+      } catch {
+        continue;
+      }
+      const doneDir = path18.join(input.doneRoot, peer);
+      ensureRealDir(doneDir, 448);
+      writeNew(doneDir, name2, body, 384);
+      fs16.unlinkSync(file);
+    }
+  }
+  for (const peer of peerDirs(input.doneRoot)) {
+    const dir = path18.join(input.doneRoot, peer);
+    let budget = JANITOR_BATCH;
+    for (const name2 of jsonNames(dir)) {
+      const at = nameTime(name2);
+      if (at === void 0 || !(at < now - DONE_TTL_MS))
+        continue;
+      if (budget-- <= 0)
+        break;
+      fs16.unlinkSync(path18.join(dir, name2));
+    }
+  }
+  for (const peer of peerDirs(input.overflowRoot)) {
+    const dir = path18.join(input.overflowRoot, peer);
+    let budget = JANITOR_BATCH;
+    for (const name2 of jsonNames(dir)) {
+      const at = nameTime(name2);
+      if (at === void 0 || !(at < now - OVERFLOW_TTL_MS))
+        continue;
+      if (budget-- <= 0)
+        break;
+      retireOverflow(input, peer, name2);
+    }
+    capOverflow(input, peer);
+  }
+}
+async function intakeCycle(input) {
+  for (const id of Object.keys(input.state.peers)) {
+    if (!Object.hasOwn(input.profile.peers, id))
+      delete input.state.peers[id];
+  }
+  runJanitor(input);
+  let written = 0;
+  for (const peer of Object.values(input.profile.peers)) {
+    if (peer.status !== "paired")
+      continue;
+    if (!SAFE_ID2.test(peer.handle)) {
+      input.log("intake-skip", { code: "bad-handle" });
+      continue;
+    }
+    try {
+      written += await intakePeer(input, peer);
+    } catch (error) {
+      input.log("intake-error", { peer: peer.handle, code: errInfo(error).code ?? "error" });
+    }
+  }
+  return written;
+}
+async function initFromNow(input, force) {
+  const paired = Object.values(input.profile.peers).filter((peer) => peer.status === "paired" && SAFE_ID2.test(peer.handle));
+  const hasDone = paired.some((peer) => {
+    const dir = path18.join(input.doneRoot, peer.handle);
+    return fs16.existsSync(dir) && fs16.readdirSync(dir).length > 0;
+  });
+  if (hasDone && !force)
+    throw new CourierError("init-exists", "done/ already has entries for a paired peer; pass --force to mark again");
+  const marked = /* @__PURE__ */ new Map();
+  for (const peer of paired) {
+    const keys = await listAll(input.kv, `${k.mirrorPrefix}${peer.handle}/threads/`);
+    let count = 0;
+    for (const c of mirrorMessages(peer.handle, keys, input.log)) {
+      if (markDone(input, peer.handle, c.msgId, "init"))
+        count++;
+    }
+    marked.set(peer.handle, count);
+    input.log("intake-init", { peer: peer.handle, marked: count });
+  }
+  return marked;
+}
+function intervalSeconds(raw) {
+  if (raw === void 0)
+    return 60;
+  const n = /^\d+$/.test(raw) ? Number(raw) : NaN;
+  if (!(n >= 5 && n <= 3600))
+    throw new CourierError("usage", "--interval must be an integer from 5 to 3600");
+  return n;
+}
+async function cmdIntake(args) {
+  const base = path18.join(profileDir(), "intake");
+  const queueRoot = args.get("queue-dir") ?? path18.join(base, "queue");
+  const doneRoot = args.get("done-dir") ?? path18.join(base, "done");
+  const overflowRoot = args.get("overflow-dir") ?? path18.join(base, "overflow");
+  const stateDir = args.get("state-dir") ?? path18.join(base, "state");
+  const peersFile = args.get("peers-file") ?? path18.join(base, "peers.json");
+  const once = args.has("once");
+  const intervalMs = intervalSeconds(args.get("interval")) * 1e3;
+  const log = jsonLineLog();
+  ensureRealDir(stateDir, 448);
+  ensureRealDir(queueRoot, 488);
+  ensureRealDir(doneRoot, 448);
+  ensureRealDir(overflowRoot, 448);
+  const release = acquireLock(path18.join(stateDir, LOCK_FILE));
+  try {
+    if (args.has("init-from-now")) {
+      const profile = loadProfile();
+      const node = await courierNode(profile);
+      await initFromNow({ kv: node.kv, profile, doneRoot, now: Date.now, log }, args.has("force"));
+      return;
+    }
+    const state = readState(path18.join(stateDir, STATE_FILE));
+    let peers = loadPeers(peersFile);
+    log("intake-start", { once, intervalSeconds: intervalMs / 1e3 });
+    for (; ; ) {
+      try {
+        const profile = loadProfile();
+        const node = await courierNode(profile);
+        try {
+          peers = loadPeers(peersFile);
+        } catch (error) {
+          log("intake-error", { code: errInfo(error).code ?? "bad-peers" });
+        }
+        const queued = await intakeCycle({
+          kv: node.kv,
+          profile,
+          peers,
+          queueRoot,
+          doneRoot,
+          overflowRoot,
+          stateDir,
+          state,
+          now: Date.now,
+          log
+        });
+        log("intake-cycle", { queued });
+      } catch (error) {
+        log("intake-error", { code: errInfo(error).code ?? "error" });
+        if (once)
+          throw error;
+      }
+      if (once)
+        return;
+      await new Promise((resolve) => {
+        setTimeout(resolve, intervalMs);
+      });
+    }
+  } finally {
+    release();
+  }
+}
+
 // ../courier/dist/consumed.js
 function isKeyMissing(error) {
   const status = String(error.status ?? error.meta?.status ?? "");
@@ -9011,7 +9887,7 @@ async function markConsumed(kv2, id, at = /* @__PURE__ */ new Date()) {
 }
 
 // ../courier/dist/approval.js
-var DAY_MS3 = 24 * 3600 * 1e3;
+var DAY_MS4 = 24 * 3600 * 1e3;
 var MAX_NOTE = 2e3;
 var FUTURE_SKEW_MS = 5 * 60 * 1e3;
 function fail3(code, message) {
@@ -9065,7 +9941,7 @@ function verifyApproval(id, request, approval, options = {}) {
     fail3("approval-mismatch", "The decision is dated in the future.");
   if (decidedAt >= expires)
     fail3("approval-expired", "The decision came after the request expired.");
-  if (now - decidedAt >= DAY_MS3)
+  if (now - decidedAt >= DAY_MS4)
     fail3("approval-expired", "The approval is older than 24 hours; ask your owner again.");
   if (typeof request.peer !== "string" || typeof request.threadId !== "string" || typeof request.taskId !== "string") {
     fail3("approval-mismatch", "The request is missing peer, threadId or taskId.");
@@ -9163,9 +10039,9 @@ ${targetHelp()}`);
 
 // ../courier/dist/broker.js
 import { execFile } from "child_process";
-import fs14 from "fs";
+import fs17 from "fs";
 import os8 from "os";
-import path17 from "path";
+import path19 from "path";
 var MAX_OUTPUT = 4e3;
 var EXEC_TIMEOUT_MS = 12e4;
 var TOKEN = /^(gh[pousr]_[A-Za-z0-9]{20,255}|github_pat_[A-Za-z0-9_]{20,255})$/;
@@ -9177,7 +10053,7 @@ async function loadBrokerCredential(config, exec = execFileRunner) {
   const result = await exec(config.ghBin, ["auth", "token", "--hostname", "github.com"], {
     cwd: ownerHome,
     timeoutMs: 1e4,
-    env: { PATH: "/usr/bin:/bin", HOME: ownerHome, GH_CONFIG_DIR: path17.join(ownerHome, ".config/gh"), GH_PROMPT_DISABLED: "1", GH_NO_UPDATE_NOTIFIER: "1", LANG: "C" }
+    env: { PATH: "/usr/bin:/bin", HOME: ownerHome, GH_CONFIG_DIR: path19.join(ownerHome, ".config/gh"), GH_PROMPT_DISABLED: "1", GH_NO_UPDATE_NOTIFIER: "1", LANG: "C" }
   });
   const token2 = result.stdout.trim();
   if (result.code !== 0 || !validToken(token2))
@@ -9227,9 +10103,9 @@ var execFileRunner = (bin, args, { cwd, env, timeoutMs }) => {
 };
 function brokerEnv(credential, scratch) {
   return {
-    PATH: `${path17.dirname(credential.ghBin)}:/usr/bin:/bin`,
+    PATH: `${path19.dirname(credential.ghBin)}:/usr/bin:/bin`,
     HOME: scratch,
-    GH_CONFIG_DIR: path17.join(scratch, "gh"),
+    GH_CONFIG_DIR: path19.join(scratch, "gh"),
     GH_TOKEN: credential.token,
     GH_PROMPT_DISABLED: "1",
     GH_NO_UPDATE_NOTIFIER: "1",
@@ -9261,8 +10137,8 @@ async function runApproved(id, deps) {
   if (await isConsumed(deps.kv, id))
     fail4("approval-used", `Approval ${id} was already used; an approval covers one action.`);
   const scratchRoot = deps.scratchRoot ?? brokerRoot();
-  fs14.mkdirSync(scratchRoot, { recursive: true, mode: 448 });
-  const scratch = fs14.mkdtempSync(path17.join(scratchRoot, "run-"));
+  fs17.mkdirSync(scratchRoot, { recursive: true, mode: 448 });
+  const scratch = fs17.mkdtempSync(path19.join(scratchRoot, "run-"));
   const env = brokerEnv(credential, scratch);
   const run2 = (args) => deps.exec(credential.ghBin, args, { cwd: scratch, env, timeoutMs: EXEC_TIMEOUT_MS });
   const clean = (text) => sanitizeOutput(text, [credential.token]);
@@ -9299,7 +10175,7 @@ ${merged.stderr}` : ""}`).trim(),
       ...ok2 ? {} : { note: "The approval is used up. If the merge should still happen, file a new request." }
     };
   } finally {
-    fs14.rmSync(scratch, { recursive: true, force: true });
+    fs17.rmSync(scratch, { recursive: true, force: true });
   }
 }
 var runApprovedUsage = () => `Usage: ${cmd("run-approved <requestId>")}`;
@@ -9311,7 +10187,7 @@ async function cmdRunApproved(args) {
   const config = loadBrokerConfig(currentProfileId(), testOwnerRoot);
   assertPinnedProfile(config, loadProfile());
   const node = await courierNode(loadProfile(config.courierHome), config.courierHome);
-  const result = await runApproved(id, { kv: node.kv, credential: () => loadBrokerCredential(config), scratchRoot: path17.dirname(brokerFile(currentProfileId(), testOwnerRoot)), exec: execFileRunner, now: () => Date.now() });
+  const result = await runApproved(id, { kv: node.kv, credential: () => loadBrokerCredential(config), scratchRoot: path19.dirname(brokerFile(currentProfileId(), testOwnerRoot)), exec: execFileRunner, now: () => Date.now() });
   await writeOut(`${JSON.stringify(result, null, 2)}
 `);
   if (!result.ok)
@@ -9339,7 +10215,7 @@ async function cmdBroker(args) {
     return;
   }
   if (sub2 === "clear") {
-    fs14.rmSync(file, { force: true });
+    fs17.rmSync(file, { force: true });
     await writeOut('{"configured":false}\n');
     return;
   }
@@ -9349,33 +10225,33 @@ async function cmdBroker(args) {
   if (ghBin === "true")
     fail4("usage", "--gh-bin needs a path.");
   if (ghBin === void 0) {
-    for (const dir of (process.env.PATH ?? "").split(path17.delimiter)) {
-      const candidate = path17.join(dir || ".", "gh");
+    for (const dir of (process.env.PATH ?? "").split(path19.delimiter)) {
+      const candidate = path19.join(dir || ".", "gh");
       try {
-        fs14.accessSync(candidate, fs14.constants.X_OK);
-        ghBin = fs14.realpathSync(candidate);
+        fs17.accessSync(candidate, fs17.constants.X_OK);
+        ghBin = fs17.realpathSync(candidate);
         break;
       } catch {
       }
     }
   }
-  if (!ghBin || !path17.isAbsolute(ghBin))
+  if (!ghBin || !path19.isAbsolute(ghBin))
     fail4("usage", "Could not find gh; pass --gh-bin <absolute path>.");
   try {
-    fs14.accessSync(ghBin, fs14.constants.X_OK);
+    fs17.accessSync(ghBin, fs17.constants.X_OK);
   } catch {
     fail4("usage", `${ghBin} is not an executable file.`);
   }
   const profile = loadProfile();
   let testToken;
   if (testOwnerRoot !== void 0) {
-    testToken = fs14.readFileSync(0, "utf8").trim();
+    testToken = fs17.readFileSync(0, "utf8").trim();
     if (testToken !== TEST_TOKEN)
       fail4("usage", "Tests accept only the fixed dummy token fixture on stdin");
   }
-  ghBin = fs14.realpathSync(ghBin);
-  const st = fs14.statSync(ghBin);
-  const config = { v: 2, courierHome: fs14.realpathSync(profileDir()), profile: pinProfile(profile), ghBin, ghIdentity: { dev: st.dev, ino: st.ino }, ...testToken ? { testToken } : {} };
+  ghBin = fs17.realpathSync(ghBin);
+  const st = fs17.statSync(ghBin);
+  const config = { v: 2, courierHome: fs17.realpathSync(profileDir()), profile: pinProfile(profile), ghBin, ghIdentity: { dev: st.dev, ino: st.ino }, ...testToken ? { testToken } : {} };
   if (!testToken)
     await loadBrokerCredential(config);
   saveBrokerConfig(config, testOwnerRoot);
@@ -9470,6 +10346,9 @@ Delivery (one watcher per person per machine; never calls a model):
   watch \u2026 --install-launchd | --install-systemd [--dry-run] [--name n]
                                    Install the same watch command as a macOS launchd agent or a Linux
                                    systemd --user unit. --dry-run prints the exact file and commands.
+  intake [--queue-dir d] [--peers-file f] [--state-dir d] [--interval 60] [--once]
+                                   Intake reader: copy paired peers' mirrored messages into the local queue
+                                   (one <msgId>.json per message) with cheap checks. Never calls a model.
 
   pause <peer> <threadId> [--reason "\u2026"]   Humans: stop waking your agent for a thread; tells the peer
   resume <peer> <threadId>                 Humans: wake it again (the wake budget starts over)
@@ -9518,6 +10397,8 @@ async function run(argv) {
       return cmdOrders(sub2);
     case "watch":
       return cmdWatch(sub2);
+    case "intake":
+      return cmdIntake(sub2);
     case "approval":
       return cmdApproval(sub2);
     case "pause":