@centralu/host-linux-x64 0.1.0-beta.47 → 0.1.0-beta.48

package/host/main.mjs

@@ -43050,7 +43050,7 @@ import { dirname as dirname26, join as join59 } from "node:path";
 import { mkdirSync as mkdirSync21, readFileSync as readFileSync27, writeSync as writeSync4 } from "node:fs";
 
 // packages/protocol/src/version.generated.ts
-var APP_VERSION = "0.1.0-beta.47";
+var APP_VERSION = "0.1.0-beta.48";
 
 // packages/protocol/src/brand.ts
 var APP_NAME = "Centralu";
@@ -57761,7 +57761,8 @@ var SessionState = external_exports.enum([
   "error"
 ]);
 var SessionActivity = external_exports.enum(["compacting", "reviewing", "retrying"]);
-var InterruptionReason = external_exports.enum(["network", "quit", "interrupted", "reconnecting"]).catch("interrupted");
+var InterruptionReason = external_exports.enum(["network", "quit", "shutdown", "interrupted", "reconnecting"]).catch("interrupted");
+var SHUTDOWN_WORDS = "the computer shut down, restarted or signed out";
 var Interruption = external_exports.object({
   reason: InterruptionReason,
   /** When it happened (ms); for `reconnecting`, when the reconnecting began */
@@ -59671,6 +59672,8 @@ var TurnWho = external_exports.object({
   by: external_exports.enum(["person", "work"]),
   wrote: external_exports.literal(true).optional(),
   added: external_exports.literal(true).optional(),
+  /** An update of Centralu cut this turn and Centralu continued it (#1966): the report of its end says so */
+  cut: external_exports.literal(true).optional(),
   compaction: external_exports.literal(true).optional(),
   since: external_exports.number().int().optional()
 });
@@ -61807,6 +61810,12 @@ var hostParams = {
    * says it in its hellos and sends `host_handover`, so a hub's row can say it. `handover: null` clears it. Additive
    */
   "host.handover": external_exports.object({ handover: HostHandover.nullable() }),
+  /**
+   * The system is ending (a shutdown, restart or sign-out), told by the window on a machine where the host has no window of its
+   * own to hear it: Windows, whose desktop window runs `centralu serve --window` and cannot write to a host it did not start
+   * (#1970, #1397). `cancelled`: the end announced before was called off. Additive
+   */
+  "host.systemEnding": external_exports.object({ cancelled: external_exports.boolean().optional() }),
   /**
    * A hub linked to this host says who it is and whether this host's sessions may ask its projects (#550, the reverse
    * direction, docs/plans/remote-hub.md §12.7). Sent by the hub at every connect and when its switch for this machine
@@ -61878,6 +61887,7 @@ var hostResults = {
     external_exports.object({ ok: external_exports.literal(false), busy: HostActivity, calls: external_exports.number().int() })
   ]),
   "host.handover": external_exports.object({ ok: external_exports.literal(true) }),
+  "host.systemEnding": external_exports.object({ ok: external_exports.literal(true) }),
   "host.hubOffer": external_exports.object({ ok: external_exports.literal(true) })
 };
 
@@ -63454,6 +63464,12 @@ var settingsParams = {
    * like any other file and gets a fresh id if the name is taken.
    */
   "themes.import": external_exports.object({ path: external_exports.string() }),
+  /**
+   * Takes a theme file out of the folder, without losing it: the file moves to the folder's `.removed/`, where the
+   * theme list does not look (an OS trash is the shell's, `themes.resolve`; this is the host's own, for a caller with no shell, the orchestrator).
+   * A side that showed it falls back to its preset (the caller's to set, as Settings does).
+   */
+  "themes.remove": external_exports.object({ id: ThemeId }),
   /**
    * The absolute path of a theme file, for the shell to trash or reveal (the same two-step as
    * `fs.resolve`: the host knows the folder, the shell knows the OS).
@@ -63474,6 +63490,7 @@ var settingsResults = {
   "themes.list": external_exports.array(ThemeFileEntry),
   "themes.save": ThemeFileEntry,
   "themes.import": ThemeFileEntry,
+  "themes.remove": external_exports.object({ removed: external_exports.boolean(), keptAt: external_exports.string().nullable() }),
   "themes.resolve": external_exports.object({ path: external_exports.string() }),
   "approvals.rules": external_exports.array(
     external_exports.object({
@@ -65587,6 +65604,13 @@ function logonFromGroups(stdout) {
   if (sids.has("S-1-5-6")) return "service";
   return null;
 }
+function systemStoppingQueries(platform = HOST_PLATFORM) {
+  if (platform !== "linux") return null;
+  return [
+    ["systemctl", "is-system-running"],
+    ["systemctl", "--user", "is-system-running"]
+  ];
+}
 
 // packages/agent-host/src/dev-services/path-guard.ts
 import { lstatSync as lstatSync2, realpathSync, statSync } from "node:fs";
@@ -66409,6 +66433,8 @@ var METHOD_RIGHTS = {
    * launcher says it with the limited credential and no full one crosses a port for it; `host.stop` does far more
    */
   "host.handover": "everyday",
+  /** The window telling the serve host the system is ending (#1970): said with the window's full credential. An everyday one could plant a false end that relabels a real crash as the system's (#1397) */
+  "host.systemEnding": "window",
   "host.hubOffer": "link",
   // The window's own state, preferences, themes and approval rules
   "workspace.save": "window",
@@ -66421,6 +66447,7 @@ var METHOD_RIGHTS = {
   "themes.list": "everyday",
   "themes.save": "everyday",
   "themes.import": "everyday",
+  "themes.remove": "everyday",
   "themes.resolve": "everyday",
   "approvals.rules": "everyday"
 };
@@ -67544,7 +67571,7 @@ var HostServer = class _HostServer {
           return;
         }
         if (refusal2 !== null) {
-          console.error(`[agent-host] refused ${JSON.stringify(method)} to a connection holding the limited credential (${refusal2.rights})`);
+          console.error(`[agent-host] refused ${JSON.stringify(method)} to a connection holding the limited credential (${refusal2.rights})${method === "host.systemEnding" ? ": a launcher older than this host sends the system-ending notice with it, so that end is not noted until the launcher is updated (#1970)" : ""}`);
           return this.sendError(ws2, id3, { code: "internal", message: refusal2.message, retryable: false, data: { refused: "rights", rights: refusal2.rights } });
         }
       }
@@ -106570,6 +106597,8 @@ function matchProjects(asked, projects, o = {}) {
   return [];
 }
 var NO_WORDS = "(its turn ended without saying anything: read_session shows what it did)";
+var MACHINE_UNREACHABLE = "(not read: its machine could not be reached)";
+var IN_PAUSE_REPORT = "(in the paused report before this one)";
 function clipAnswer(answer, sessionName, at2) {
   if (answer.length <= ANSWER_MAX_CHARS) return answer;
   const cut3 = answer.length - ANSWER_HEAD_CHARS - ANSWER_TAIL_CHARS;
@@ -106825,9 +106854,9 @@ async function gitStatusFiles(cwd, trust = {}) {
     if (entry.startsWith("1 ") || entry.startsWith("2 ")) {
       const parts = entry.split(" ");
       const xy = parts[1] ?? "..";
-      const rename7 = entry.startsWith("2 ");
-      const path2 = parts.slice(rename7 ? 9 : 8).join(" ");
-      if (rename7) i++;
+      const rename8 = entry.startsWith("2 ");
+      const path2 = parts.slice(rename8 ? 9 : 8).join(" ");
+      if (rename8) i++;
       if (!path2) continue;
       const [x, y] = [xy[0] ?? ".", xy[1] ?? "."];
       if (x !== ".") out.push({ path: path2, staged: true, status: mapStatus(x) });
@@ -108238,6 +108267,264 @@ function givenAgentName(name) {
   return flat ? oneLineText(flat, 40) : void 0;
 }
 
+// packages/agent-host/src/sessions/handoff-heirs.ts
+function liveHeirOf(store2, sessionId, isLive) {
+  const seen = /* @__PURE__ */ new Set([sessionId]);
+  let generation = [sessionId];
+  while (generation.length) {
+    const heirs = generation.flatMap((at2) => store2.handoffs.handoffHeirs(at2)).filter((h) => !seen.has(h.sessionId));
+    for (const h of heirs) seen.add(h.sessionId);
+    const live2 = heirs.find((h) => !h.trashed && isLive(h.sessionId));
+    if (live2) return live2.sessionId;
+    generation = heirs.map((h) => h.sessionId);
+  }
+  return null;
+}
+
+// packages/agent-host/src/sessions/interruptions.ts
+var NETWORK_WORDS = [
+  /\b(ECONNREFUSED|ENOTFOUND|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|ENETDOWN)\b/,
+  /API Error: (No response from API|Can't reach the API server|Connection (refused|lost|reset|error|dropped)|Request timed out|No internet route|fetch failed|Unable to connect to API(?!: SSL))/i,
+  /computer (went to sleep|was asleep)/i,
+  /stream disconnected before completion/i,
+  /failed to lookup address information/i,
+  /Connection failed: error sending request/i,
+  /waiting for network/i
+];
+function failureSentence(message) {
+  return message.split(/(?:^|[.\s])stderr:/)[0].trim();
+}
+function isNetworkFailure(message) {
+  const sentence = failureSentence(message);
+  return NETWORK_WORDS.some((w) => w.test(sentence));
+}
+function interruptionAfter(e, now, endedTurn) {
+  switch (e.type) {
+    case "error":
+      if (!e.sessionId || !endedTurn || e.error.code === "adapter_crashed") return void 0;
+      return isNetworkFailure(e.error.message) ? { reason: "network", at: now, detail: failureSentence(e.error.message).slice(0, 600) } : null;
+    case "turn_complete":
+      return null;
+    case "state_change":
+      if (e.state === "working") return null;
+      if (e.state === "waiting_input" && e.reason === INTERRUPTED_BY_TOOL) return { reason: "interrupted", at: now };
+      if (e.state === "waiting_input" && e.reason === "interrupted") return null;
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+var RECONNECTING_FLAG_MS = 5 * 6e4;
+function interruptionWords(i) {
+  switch (i.reason) {
+    case "network":
+      return "stopped: network error";
+    case "quit":
+      return "stopped: Centralu quit during its turn";
+    case "shutdown":
+      return `stopped: ${SHUTDOWN_WORDS} during its turn`;
+    case "interrupted":
+      return "stopped: its tool interrupted the turn";
+    case "reconnecting":
+      return `reconnecting to its API for ${Math.max(1, Math.round((Date.now() - i.at) / 6e4))} min`;
+  }
+}
+var wentWithItsProcess = (i) => i?.reason === "quit" || i?.reason === "shutdown";
+var UPDATE_CONTINUE_LINE = "Centralu was updated during this turn, which stopped it; Centralu continued it on the new version.";
+var UPDATE_TASKS_LINE = "Centralu was updated, which stopped background work of this session; Centralu told the agent so it can start again what it needs.";
+
+// packages/agent-host/src/sessions/tool-answers.ts
+function trustedJsonText(value) {
+  return JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function plainQuoted(value, max = 60) {
+  const cut3 = value.length > max ? `${value.slice(0, max)}\u2026` : value;
+  return JSON.stringify(cut3).replace(/[\p{Cc}\p{Cf}\u2028\u2029]/gu, (c) => {
+    const code2 = c.codePointAt(0);
+    return code2 > 65535 ? `\\u{${code2.toString(16)}}` : `\\u${code2.toString(16).padStart(4, "0")}`;
+  });
+}
+var READER_LIST_CAP = 40;
+async function listSessionsText(tools, caller, project2) {
+  const all = await tools.listSessions(project2 ? { project: project2 } : void 0);
+  if (all.length === 0) {
+    if (project2) return { text: `No session in a project called ${frameField(project2)}. Leave project out to list every one.` };
+    return { text: caller.profile === "reader" ? "There are no other sessions." : "There are no sessions under management." };
+  }
+  const list2 = caller.profile === "reader" ? all.slice(0, READER_LIST_CAP) : all;
+  const more = all.length - list2.length;
+  return {
+    text: list2.map(
+      (s) => (
+        // A linked machine's session says where it runs (#82 phase 4), and why the row is only what was last known
+        // Names on one line (#838): a session's name is set by rename or an auto-name, and a line break in it made a row of its own
+        `- ${frameField(s.name)} [${s.sessionId}] \xB7 project ${frameField(s.project)}${s.machine ? ` on ${frameField(s.machine)}` : ""} \xB7 ${s.tool} \xB7 ${s.waitingOn === "question" ? "waiting on a question" : s.state}` + (s.away ? ` \xB7 ${s.away}` : "") + // A turn cut short by the network or a quit looks like any session at rest (#698)
+        (s.interruption ? ` \xB7 ${interruptionWords(s.interruption)}` : "") + // If merge status is not shown, the manager keeps assigning work to a finished branch (#69, dogfooding)
+        (s.merged ? " \xB7 merged" : "") + // PR status (#76 stage 3) — assigning new work to a branch awaiting review pollutes the PR
+        (s.pr ? ` \xB7 PR #${s.pr.number}(${s.pr.state})` : "") + (s.lastActive ? ` \xB7 last ${s.lastActive}` : "") + (s.preview ? `
+    recent (JSON): ${trustedJsonText(s.preview)}` : "")
+      )
+    ).join("\n") + (more > 0 ? `
+${more} more; pass project to narrow.` : "")
+  };
+}
+function cardsText(cards) {
+  return cards.map(
+    (c) => c.kind === "question" ? `card ${c.card} (question), as JSON: ${trustedJsonText(JSON.stringify(c.questions.map((q2) => ({ question: q2.question, header: q2.header, options: q2.options.map((o) => o.label), ...q2.options.some((o) => o.description) ? { descriptions: q2.options.map((o) => o.description) } : {}, multiSelect: q2.multiSelect }))))}` : `card ${c.card} (approval${c.answerable ? ", yours to allow or deny" : ", only the person can answer it"}), as JSON: ${trustedJsonText(JSON.stringify(c.detail))}`
+  ).join("\n");
+}
+function progressText(p) {
+  if (!p) return "";
+  return ` It last recorded something ${p.quietFor} ago${p.lastStep ? `; its last step, as JSON: ${JSON.stringify(p.lastStep)}` : ""}.`;
+}
+function busyText(b2, call2) {
+  const what = {
+    note: "add it to the running turn as a note; that turn's answer stays its owner's, and you read the reply to your note",
+    queue: "hold it and deliver it as a new turn when the running one ends; you are told when that turn ends",
+    fork: "start a sub-session from a copy of its conversation now, linked to you, in a worktree of its own (fork_read: read-only work in its folder)"
+  };
+  const lines = b2.choices.map((c) => `- ${c.choice}: ${c.available ? `${what[c.choice]}. ${call2(c.choice === "fork" ? "fork" : c.choice)}` : `not available: ${c.why}`}`);
+  const ahead = b2.ahead ? ` ${b2.ahead} request${b2.ahead === 1 ? " is" : "s are"} queued there already.` : "";
+  return `"${b2.sessionName}" [${b2.sessionId}] is busy (${b2.sessionState}) with a turn that is not yours, so nothing was sent.${progressText(b2.progress)}${ahead} Choose:
+${lines.join("\n")}`;
+}
+function queuedText(q2) {
+  const instead = q2.lowMemory ? `Not forked: memory is low (${q2.lowMemory}), so it was queued instead, which starts no new process. ` : "";
+  return `${instead}Queued for "${q2.sessionName}" [${q2.sessionId}] as ${q2.queueId}, number ${q2.position} in its queue: it goes in as a new turn when the running one ends, and you are told when that turn ends.`;
+}
+var ANSWER_FORM = 'Answer a question with its option label, or your own words; one line per question; several choices of one question separated by ";". The person may answer first; the first answer counts.';
+function askProjectText(r) {
+  if (!r.ok) return { text: r.error, isError: true };
+  const where2 = `the session "${r.sessionName}" [${r.sessionId}] in ${r.project}`;
+  if (r.state === "busy") return { text: busyText(r, (c) => `ask_project with the same task and ifBusy "${c}".`) };
+  if (r.state === "queued") return { text: `${queuedText(r)} Call ask_project with project "${r.project}", session "${r.sessionId}" and no task to see where it stands.` };
+  if (r.state === "asking") {
+    return {
+      text: `${where2} is waiting on you in the task you gave it:
+${cardsText(r.cards)}
+Answer with agent_session(sessionId="${r.sessionId}", action="answer", card=\u2026, text=\u2026). ${ANSWER_FORM} Then call ask_project with project "${r.project}", session "${r.sessionId}" and no task to wait for the answer.`
+    };
+  }
+  if (r.state === "working") {
+    return {
+      text: `${r.project} is still working on it in ${where2}${r.notice ? ` \u2014 ${r.notice}` : ""}.${progressText(r.progress)} To keep waiting, call ask_project again with project "${r.project}", session "${r.sessionId}" and no task; the work goes on meanwhile.`
+    };
+  }
+  const lines = [
+    r.paused ? `${r.project} has not finished (from ${where2}): ${r.paused} What it said so far, as JSON:` : `${r.project} answered (from ${where2}), as JSON:`,
+    trustedJsonText(r.answer || "(no final text)")
+  ];
+  if (r.readable.length) lines.push(`You can read these now: ${r.readable.join(", ")}`);
+  if (r.outside.length) lines.push(`Named outside ${r.project}'s folder (not opened for you): ${r.outside.join(", ")}`);
+  return { text: lines.join("\n") };
+}
+var NO_POLLING = "Do not check on it with status meanwhile. With nothing else to do, wait is the one call that blocks until the end:";
+var NEW_ROLE_NEW_AGENT = "For another kind of work (say, editing files after read-only research), start a new agent instead, with the task written in full: it starts without this one's context, and this one's name and role came from its first task.";
+function cleanUpLine(sessionId, call2 = `agent_session(sessionId="${sessionId}", action="delete")`) {
+  return `Archive it once its answer is used: ${call2}. Keep it only if more work on the same thing is coming soon, and archive it when that is done. Work not on the trunk is kept in the session archive.`;
+}
+function agentListText(r) {
+  if (!r.ok) return { text: r.error, isError: true };
+  const rows3 = r.agents;
+  if (rows3.length === 0) return { text: "No session start_agent started from here is left." };
+  const finished = rows3.filter((r5) => r5.state === "finished").length;
+  const lines = rows3.map(
+    (r5) => `- ${frameField(r5.name)} [${r5.sessionId}] \xB7 ${r5.tool} \xB7 ${r5.state}${r5.asleep ? " (asleep)" : ""}` + (r5.machine ? ` \xB7 on ${frameField(r5.machine)}` : "") + (r5.worktree ? ` \xB7 worktree branch ${frameField(r5.worktree.branch)}${r5.worktree.unmerged ? ", not merged: a delete keeps its work in the session archive" : ", merged"}` : "") + (r5.lastActive ? ` \xB7 last ${r5.lastActive}` : "")
+  );
+  return {
+    text: `Sessions you started (${rows3.length}, ${finished} finished):
+${lines.join("\n")}
+` + (finished ? 'Delete each finished one whose answer you have used: agent_session(sessionId=\u2026, action="delete").' : "None is finished yet.")
+  };
+}
+function agentRunText(r) {
+  if (!r.ok) return { text: r.error, isError: true };
+  if (r.state === "pending" && r.lowMemory) {
+    return {
+      text: `queued: low memory. No session yet: starting ${r.tool} is allowed and waits for memory (${r.lowMemory.available} free, ${r.lowMemory.floor} needed; request ${r.sessionId}). It starts when memory frees up, and you will be told when its turn ends; if memory stays low for ${r.lowMemory.maxWaitMinutes} minutes it gives up and you will be told. Carry on with other work, and do not do this with your own subagents instead. ${NO_POLLING} agent_session(sessionId="${r.sessionId}", action="wait") waits, action="stop" withdraws it.`
+    };
+  }
+  if (r.state === "pending") {
+    return {
+      text: `No session yet: starting ${r.tool} is waiting for the person's answer on the card in your session (request ${r.sessionId}). Carry on with other work, and do not do this with your own subagents instead. If they allow it, the session starts and you will be told when its turn ends; if they refuse or it is withdrawn, you will be told. ${NO_POLLING} agent_session(sessionId="${r.sessionId}", action="wait") waits for the answer, action="stop" withdraws the request.`
+    };
+  }
+  const who = `the ${r.tool} session "${r.sessionName}" [${r.sessionId}]` + (r.via === "fork" ? `, a fork of [${r.forkedFrom}]` : "");
+  const out = agentStateText(r, who);
+  return r.via === "note" ? { ...out, text: `Added as a note to the running turn. ${out.text}` } : out;
+}
+function agentStateText(r, who) {
+  switch (r.state) {
+    case "working":
+      return {
+        text: `${who} is working on it${r.notice ? ` \u2014 ${r.notice}` : ""}.${progressText(r.progress)} ` + (r.reported ? `You will be told when it ends. ${NO_POLLING} ` : "") + `agent_session(sessionId="${r.sessionId}", action="wait") waits for its answer, action="stop" stops it.`
+      };
+    case "asking":
+      return {
+        text: `${who} is waiting on you in the turn you gave it:
+${cardsText(r.cards)}
+agent_session(sessionId="${r.sessionId}", action="answer", card=\u2026, text=\u2026) answers it. ${ANSWER_FORM}`
+      };
+    case "busy":
+      return { text: busyText(r, (c) => `agent_session(sessionId="${r.sessionId}", action="send", text=\u2026, ifBusy="${c}").`) };
+    case "queued":
+      return { text: `${queuedText(r)} agent_session(sessionId="${r.sessionId}", action="stop") withdraws it.` };
+    case "answered":
+      return { text: `Answered card ${r.card} in ${who}; it goes on. agent_session(sessionId="${r.sessionId}", action="wait") waits for its answer.` };
+    case "stopped":
+      if (!r.sessionName) return { text: `Withdrew request ${r.sessionId}: its card is gone and no session was started.` };
+      return { text: `Stopped ${who}.${r.notice ? ` ${r.notice}` : ""}` };
+    case "deleted":
+      if (r.branch === void 0) return { text: `Moved ${who} to the session archive. Tell the person in one line.` };
+      if (r.note) return { text: `Moved ${who} to the session archive. ${r.note} Tell the person in one line.` };
+      return {
+        text: (r.warning ? `Moved ${who} to the session archive. Warning: ${r.warning} ` : `Cleaned up ${who}: its worktree and branch "${r.branch}" were removed and the session was archived. `) + (r.setAside.changedFiles || r.setAside.commits ? `${r.setAside.changedFiles} uncommitted files, ${r.setAside.commits} commits not on the trunk, kept in the session archive. ` : "Nothing needed setting aside. ") + "Tell the person in one line."
+      };
+    case "at_rest":
+      return {
+        text: `${who} is not working on anything you gave it (${r.sessionState}${r.interruption ? `, ${interruptionWords(r.interruption)}` : ""}). Its last answer, as JSON:
+${trustedJsonText(r.answer || "(no final text)")}
+` + (r.notice ? `${r.notice}
+` : "") + `agent_session(sessionId="${r.sessionId}", action="send", text=\u2026) gives it more. ${NEW_ROLE_NEW_AGENT}` + (r.cleanUp ? `
+${cleanUpLine(r.sessionId)}` : "")
+      };
+    case "done": {
+      const lines = [`${who} answered, as JSON:`, trustedJsonText(r.answer || "(no final text)")];
+      if (r.notice) lines.push(r.notice);
+      if (r.readable.length) lines.push(`You can read these now: ${r.readable.join(", ")}`);
+      if (r.outside.length) lines.push(`Named outside its folder (not opened for you): ${r.outside.join(", ")}`);
+      lines.push(`agent_session(sessionId="${r.sessionId}", action="send", text=\u2026) continues with it. ${NEW_ROLE_NEW_AGENT}`);
+      if (r.cleanUp) lines.push(cleanUpLine(r.sessionId));
+      return { text: lines.join("\n") };
+    }
+  }
+}
+var plural = (n, one2, many = `${one2}s`) => `${n} ${n === 1 ? one2 : many}`;
+
+// packages/agent-host/src/sessions/stale-session-id.ts
+function staleSessionHint(host, id3, visible, seesAll = false, doing = "act") {
+  if (host.meta.has(id3)) return "";
+  const live2 = [...host.meta.values()].filter((s) => s.kind !== "orchestrator" && visible(s));
+  const found = host.store.trash.trashedSession(id3);
+  const trashed = found && (seesAll || live2.some((s) => s.projectId === found.record.projectId)) ? found : null;
+  const heirId = liveHeirOf(host.store, id3, (h) => {
+    const s = host.meta.get(h);
+    return !!s && s.kind !== "orchestrator" && visible(s);
+  });
+  const heir = heirId ? host.meta.get(heirId) : void 0;
+  if (!trashed && !heir) return "";
+  const named = trashed ? live2.filter((s) => s.name === trashed.session.name && s.projectId === trashed.record.projectId && s !== heir) : [];
+  const label = (s) => `${plainQuoted(s.name, 80)} (id ${s.id})`;
+  const parts = [];
+  if (trashed) parts.push(`That id was the session ${plainQuoted(trashed.session.name, 80)}, deleted since (it is in the archive).`);
+  else parts.push("That id was a session that has been replaced by a handoff.");
+  if (heir) parts.push(`The live session that took over from it: ${label(heir)}.`);
+  if (named.length) parts.push(`Live in the same project with the same name: ${named.map(label).join(", ")}.`);
+  const then2 = doing === "send" ? "Nothing was sent; send to the one you meant, by its id." : doing === "read" ? "Nothing was read; read the one you meant, by its id." : "Nothing was done; retry the same call with the id of the live session you meant.";
+  parts.push(heir || named.length ? then2 : "No live session carries its name; list the sessions to find the one you meant.");
+  return " " + parts.join(" ");
+}
+
 // packages/agent-host/src/mail/script-label.ts
 var LABEL_MAX = 40;
 var NOT_IN_A_LABEL = /[^\p{L}\p{N} ._:@/+-]/gu;
@@ -108533,8 +108820,9 @@ function orchestratorToolsFor(host, orchestratorId, scopeIds, ownProject, hubVie
     const trusted = trustedIds();
     return (id3) => !trusted.has(id3);
   };
-  const readError = (id3) => ownProject && wide() ? `Not a session you can read: ${id3}` : scopeError(id3);
-  const scopeError = (id3) => scopeIds !== void 0 ? `Not a member of this coordinating session: ${id3}` : ownProject ? `Not a session in this project: ${id3}` : hubView ? `Not a session this machine shares: ${id3}` : `Not a session this app manages: ${id3}`;
+  const readError = (id3) => (ownProject && wide() ? `Not a session you can read: ${id3}` : scopeText(id3)) + staleSessionHint(host, id3, readable, central, "read");
+  const scopeError = (id3, doing = "act") => scopeText(id3) + staleSessionHint(host, id3, inScope, central, doing);
+  const scopeText = (id3) => scopeIds !== void 0 ? `Not a member of this coordinating session: ${id3}` : ownProject ? `Not a session in this project: ${id3}` : hubView ? `Not a session this machine shares: ${id3}` : `Not a session this app manages: ${id3}`;
   const sendLinked = async (reader, sessionId, text3, reportBack) => {
     const earlier = host.children.linkedReports.get(sessionId);
     const mine = reportBack ? { orchestratorId, busy: false, instruction: text3 } : void 0;
@@ -108855,7 +109143,7 @@ function orchestratorToolsFor(host, orchestratorId, scopeIds, ownProject, hubVie
         return sendLinked(remote, sessionId, text3, reportBack);
       }
       const target = host.meta.get(sessionId);
-      if (!target || !inScope(target)) return { ok: false, error: scopeError(sessionId) };
+      if (!target || !inScope(target)) return { ok: false, error: scopeError(sessionId, "send") };
       if (reportBack) {
         const refused2 = host.refusesDelegation(orchestratorId, { sessionId, projectId: target.projectId }, { tool: "send_to_session", target: target.name || target.id, text: text3 });
         if (refused2) return { ok: false, error: refused2 };
@@ -109291,55 +109579,6 @@ function withHubMark(settings, info) {
 // packages/agent-host/src/sessions/queued-requests.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
 
-// packages/agent-host/src/sessions/interruptions.ts
-var NETWORK_WORDS = [
-  /\b(ECONNREFUSED|ENOTFOUND|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|ENETDOWN)\b/,
-  /API Error: (No response from API|Can't reach the API server|Connection (refused|lost|reset|error|dropped)|Request timed out|No internet route|fetch failed|Unable to connect to API(?!: SSL))/i,
-  /computer (went to sleep|was asleep)/i,
-  /stream disconnected before completion/i,
-  /failed to lookup address information/i,
-  /Connection failed: error sending request/i,
-  /waiting for network/i
-];
-function failureSentence(message) {
-  return message.split(/(?:^|[.\s])stderr:/)[0].trim();
-}
-function isNetworkFailure(message) {
-  const sentence = failureSentence(message);
-  return NETWORK_WORDS.some((w) => w.test(sentence));
-}
-function interruptionAfter(e, now, endedTurn) {
-  switch (e.type) {
-    case "error":
-      if (!e.sessionId || !endedTurn || e.error.code === "adapter_crashed") return void 0;
-      return isNetworkFailure(e.error.message) ? { reason: "network", at: now, detail: failureSentence(e.error.message).slice(0, 600) } : null;
-    case "turn_complete":
-      return null;
-    case "state_change":
-      if (e.state === "working") return null;
-      if (e.state === "waiting_input" && e.reason === INTERRUPTED_BY_TOOL) return { reason: "interrupted", at: now };
-      if (e.state === "waiting_input" && e.reason === "interrupted") return null;
-      return void 0;
-    default:
-      return void 0;
-  }
-}
-var RECONNECTING_FLAG_MS = 5 * 6e4;
-function interruptionWords(i) {
-  switch (i.reason) {
-    case "network":
-      return "stopped: network error";
-    case "quit":
-      return "stopped: Centralu quit during its turn";
-    case "interrupted":
-      return "stopped: its tool interrupted the turn";
-    case "reconnecting":
-      return `reconnecting to its API for ${Math.max(1, Math.round((Date.now() - i.at) / 6e4))} min`;
-  }
-}
-var UPDATE_CONTINUE_LINE = "Centralu was updated during this turn, which stopped it; Centralu continued it on the new version.";
-var UPDATE_TASKS_LINE = "Centralu was updated, which stopped background work of this session; Centralu told the agent so it can start again what it needs.";
-
 // packages/agent-host/src/sessions/error-kind.ts
 var USAGE_LIMIT = /usage limit|rate.?limit|\b429\b|quota|limit reached|hit your limit/i;
 var OVERLOADED = /overload|\b529\b|\b503\b|capacity|temporarily unavailable/i;
@@ -109610,174 +109849,6 @@ ${reason}`
 // packages/agent-host/src/sessions/delegated-cards.ts
 import { createHash as createHash9 } from "node:crypto";
 
-// packages/agent-host/src/sessions/tool-answers.ts
-function trustedJsonText(value) {
-  return JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function plainQuoted(value, max = 60) {
-  const cut3 = value.length > max ? `${value.slice(0, max)}\u2026` : value;
-  return JSON.stringify(cut3).replace(/[\p{Cc}\p{Cf}\u2028\u2029]/gu, (c) => {
-    const code2 = c.codePointAt(0);
-    return code2 > 65535 ? `\\u{${code2.toString(16)}}` : `\\u${code2.toString(16).padStart(4, "0")}`;
-  });
-}
-var READER_LIST_CAP = 40;
-async function listSessionsText(tools, caller, project2) {
-  const all = await tools.listSessions(project2 ? { project: project2 } : void 0);
-  if (all.length === 0) {
-    if (project2) return { text: `No session in a project called ${frameField(project2)}. Leave project out to list every one.` };
-    return { text: caller.profile === "reader" ? "There are no other sessions." : "There are no sessions under management." };
-  }
-  const list2 = caller.profile === "reader" ? all.slice(0, READER_LIST_CAP) : all;
-  const more = all.length - list2.length;
-  return {
-    text: list2.map(
-      (s) => (
-        // A linked machine's session says where it runs (#82 phase 4), and why the row is only what was last known
-        // Names on one line (#838): a session's name is set by rename or an auto-name, and a line break in it made a row of its own
-        `- ${frameField(s.name)} [${s.sessionId}] \xB7 project ${frameField(s.project)}${s.machine ? ` on ${frameField(s.machine)}` : ""} \xB7 ${s.tool} \xB7 ${s.waitingOn === "question" ? "waiting on a question" : s.state}` + (s.away ? ` \xB7 ${s.away}` : "") + // A turn cut short by the network or a quit looks like any session at rest (#698)
-        (s.interruption ? ` \xB7 ${interruptionWords(s.interruption)}` : "") + // If merge status is not shown, the manager keeps assigning work to a finished branch (#69, dogfooding)
-        (s.merged ? " \xB7 merged" : "") + // PR status (#76 stage 3) — assigning new work to a branch awaiting review pollutes the PR
-        (s.pr ? ` \xB7 PR #${s.pr.number}(${s.pr.state})` : "") + (s.lastActive ? ` \xB7 last ${s.lastActive}` : "") + (s.preview ? `
-    recent (JSON): ${trustedJsonText(s.preview)}` : "")
-      )
-    ).join("\n") + (more > 0 ? `
-${more} more; pass project to narrow.` : "")
-  };
-}
-function cardsText(cards) {
-  return cards.map(
-    (c) => c.kind === "question" ? `card ${c.card} (question), as JSON: ${trustedJsonText(JSON.stringify(c.questions.map((q2) => ({ question: q2.question, header: q2.header, options: q2.options.map((o) => o.label), ...q2.options.some((o) => o.description) ? { descriptions: q2.options.map((o) => o.description) } : {}, multiSelect: q2.multiSelect }))))}` : `card ${c.card} (approval${c.answerable ? ", yours to allow or deny" : ", only the person can answer it"}), as JSON: ${trustedJsonText(JSON.stringify(c.detail))}`
-  ).join("\n");
-}
-function progressText(p) {
-  if (!p) return "";
-  return ` It last recorded something ${p.quietFor} ago${p.lastStep ? `; its last step, as JSON: ${JSON.stringify(p.lastStep)}` : ""}.`;
-}
-function busyText(b2, call2) {
-  const what = {
-    note: "add it to the running turn as a note; that turn's answer stays its owner's, and you read the reply to your note",
-    queue: "hold it and deliver it as a new turn when the running one ends; you are told when that turn ends",
-    fork: "start a sub-session from a copy of its conversation now, linked to you, in a worktree of its own (fork_read: read-only work in its folder)"
-  };
-  const lines = b2.choices.map((c) => `- ${c.choice}: ${c.available ? `${what[c.choice]}. ${call2(c.choice === "fork" ? "fork" : c.choice)}` : `not available: ${c.why}`}`);
-  const ahead = b2.ahead ? ` ${b2.ahead} request${b2.ahead === 1 ? " is" : "s are"} queued there already.` : "";
-  return `"${b2.sessionName}" [${b2.sessionId}] is busy (${b2.sessionState}) with a turn that is not yours, so nothing was sent.${progressText(b2.progress)}${ahead} Choose:
-${lines.join("\n")}`;
-}
-function queuedText(q2) {
-  const instead = q2.lowMemory ? `Not forked: memory is low (${q2.lowMemory}), so it was queued instead, which starts no new process. ` : "";
-  return `${instead}Queued for "${q2.sessionName}" [${q2.sessionId}] as ${q2.queueId}, number ${q2.position} in its queue: it goes in as a new turn when the running one ends, and you are told when that turn ends.`;
-}
-var ANSWER_FORM = 'Answer a question with its option label, or your own words; one line per question; several choices of one question separated by ";". The person may answer first; the first answer counts.';
-function askProjectText(r) {
-  if (!r.ok) return { text: r.error, isError: true };
-  const where2 = `the session "${r.sessionName}" [${r.sessionId}] in ${r.project}`;
-  if (r.state === "busy") return { text: busyText(r, (c) => `ask_project with the same task and ifBusy "${c}".`) };
-  if (r.state === "queued") return { text: `${queuedText(r)} Call ask_project with project "${r.project}", session "${r.sessionId}" and no task to see where it stands.` };
-  if (r.state === "asking") {
-    return {
-      text: `${where2} is waiting on you in the task you gave it:
-${cardsText(r.cards)}
-Answer with agent_session(sessionId="${r.sessionId}", action="answer", card=\u2026, text=\u2026). ${ANSWER_FORM} Then call ask_project with project "${r.project}", session "${r.sessionId}" and no task to wait for the answer.`
-    };
-  }
-  if (r.state === "working") {
-    return {
-      text: `${r.project} is still working on it in ${where2}${r.notice ? ` \u2014 ${r.notice}` : ""}.${progressText(r.progress)} To keep waiting, call ask_project again with project "${r.project}", session "${r.sessionId}" and no task; the work goes on meanwhile.`
-    };
-  }
-  const lines = [
-    r.paused ? `${r.project} has not finished (from ${where2}): ${r.paused} What it said so far, as JSON:` : `${r.project} answered (from ${where2}), as JSON:`,
-    trustedJsonText(r.answer || "(no final text)")
-  ];
-  if (r.readable.length) lines.push(`You can read these now: ${r.readable.join(", ")}`);
-  if (r.outside.length) lines.push(`Named outside ${r.project}'s folder (not opened for you): ${r.outside.join(", ")}`);
-  return { text: lines.join("\n") };
-}
-var NO_POLLING = "Do not check on it with status meanwhile. With nothing else to do, wait is the one call that blocks until the end:";
-var NEW_ROLE_NEW_AGENT = "For another kind of work (say, editing files after read-only research), start a new agent instead, with the task written in full: it starts without this one's context, and this one's name and role came from its first task.";
-function cleanUpLine(sessionId, call2 = `agent_session(sessionId="${sessionId}", action="delete")`) {
-  return `Archive it once its answer is used: ${call2}. Keep it only if more work on the same thing is coming soon, and archive it when that is done. Work not on the trunk is kept in the session archive.`;
-}
-function agentListText(r) {
-  if (!r.ok) return { text: r.error, isError: true };
-  const rows3 = r.agents;
-  if (rows3.length === 0) return { text: "No session start_agent started from here is left." };
-  const finished = rows3.filter((r5) => r5.state === "finished").length;
-  const lines = rows3.map(
-    (r5) => `- ${frameField(r5.name)} [${r5.sessionId}] \xB7 ${r5.tool} \xB7 ${r5.state}${r5.asleep ? " (asleep)" : ""}` + (r5.machine ? ` \xB7 on ${frameField(r5.machine)}` : "") + (r5.worktree ? ` \xB7 worktree branch ${frameField(r5.worktree.branch)}${r5.worktree.unmerged ? ", not merged: a delete keeps its work in the session archive" : ", merged"}` : "") + (r5.lastActive ? ` \xB7 last ${r5.lastActive}` : "")
-  );
-  return {
-    text: `Sessions you started (${rows3.length}, ${finished} finished):
-${lines.join("\n")}
-` + (finished ? 'Delete each finished one whose answer you have used: agent_session(sessionId=\u2026, action="delete").' : "None is finished yet.")
-  };
-}
-function agentRunText(r) {
-  if (!r.ok) return { text: r.error, isError: true };
-  if (r.state === "pending" && r.lowMemory) {
-    return {
-      text: `queued: low memory. No session yet: starting ${r.tool} is allowed and waits for memory (${r.lowMemory.available} free, ${r.lowMemory.floor} needed; request ${r.sessionId}). It starts when memory frees up, and you will be told when its turn ends; if memory stays low for ${r.lowMemory.maxWaitMinutes} minutes it gives up and you will be told. Carry on with other work, and do not do this with your own subagents instead. ${NO_POLLING} agent_session(sessionId="${r.sessionId}", action="wait") waits, action="stop" withdraws it.`
-    };
-  }
-  if (r.state === "pending") {
-    return {
-      text: `No session yet: starting ${r.tool} is waiting for the person's answer on the card in your session (request ${r.sessionId}). Carry on with other work, and do not do this with your own subagents instead. If they allow it, the session starts and you will be told when its turn ends; if they refuse or it is withdrawn, you will be told. ${NO_POLLING} agent_session(sessionId="${r.sessionId}", action="wait") waits for the answer, action="stop" withdraws the request.`
-    };
-  }
-  const who = `the ${r.tool} session "${r.sessionName}" [${r.sessionId}]` + (r.via === "fork" ? `, a fork of [${r.forkedFrom}]` : "");
-  const out = agentStateText(r, who);
-  return r.via === "note" ? { ...out, text: `Added as a note to the running turn. ${out.text}` } : out;
-}
-function agentStateText(r, who) {
-  switch (r.state) {
-    case "working":
-      return {
-        text: `${who} is working on it${r.notice ? ` \u2014 ${r.notice}` : ""}.${progressText(r.progress)} ` + (r.reported ? `You will be told when it ends. ${NO_POLLING} ` : "") + `agent_session(sessionId="${r.sessionId}", action="wait") waits for its answer, action="stop" stops it.`
-      };
-    case "asking":
-      return {
-        text: `${who} is waiting on you in the turn you gave it:
-${cardsText(r.cards)}
-agent_session(sessionId="${r.sessionId}", action="answer", card=\u2026, text=\u2026) answers it. ${ANSWER_FORM}`
-      };
-    case "busy":
-      return { text: busyText(r, (c) => `agent_session(sessionId="${r.sessionId}", action="send", text=\u2026, ifBusy="${c}").`) };
-    case "queued":
-      return { text: `${queuedText(r)} agent_session(sessionId="${r.sessionId}", action="stop") withdraws it.` };
-    case "answered":
-      return { text: `Answered card ${r.card} in ${who}; it goes on. agent_session(sessionId="${r.sessionId}", action="wait") waits for its answer.` };
-    case "stopped":
-      if (!r.sessionName) return { text: `Withdrew request ${r.sessionId}: its card is gone and no session was started.` };
-      return { text: `Stopped ${who}.${r.notice ? ` ${r.notice}` : ""}` };
-    case "deleted":
-      if (r.branch === void 0) return { text: `Moved ${who} to the session archive. Tell the person in one line.` };
-      if (r.note) return { text: `Moved ${who} to the session archive. ${r.note} Tell the person in one line.` };
-      return {
-        text: (r.warning ? `Moved ${who} to the session archive. Warning: ${r.warning} ` : `Cleaned up ${who}: its worktree and branch "${r.branch}" were removed and the session was archived. `) + (r.setAside.changedFiles || r.setAside.commits ? `${r.setAside.changedFiles} uncommitted files, ${r.setAside.commits} commits not on the trunk, kept in the session archive. ` : "Nothing needed setting aside. ") + "Tell the person in one line."
-      };
-    case "at_rest":
-      return {
-        text: `${who} is not working on anything you gave it (${r.sessionState}${r.interruption ? `, ${interruptionWords(r.interruption)}` : ""}). Its last answer, as JSON:
-${trustedJsonText(r.answer || "(no final text)")}
-` + (r.notice ? `${r.notice}
-` : "") + `agent_session(sessionId="${r.sessionId}", action="send", text=\u2026) gives it more. ${NEW_ROLE_NEW_AGENT}` + (r.cleanUp ? `
-${cleanUpLine(r.sessionId)}` : "")
-      };
-    case "done": {
-      const lines = [`${who} answered, as JSON:`, trustedJsonText(r.answer || "(no final text)")];
-      if (r.notice) lines.push(r.notice);
-      if (r.readable.length) lines.push(`You can read these now: ${r.readable.join(", ")}`);
-      if (r.outside.length) lines.push(`Named outside its folder (not opened for you): ${r.outside.join(", ")}`);
-      lines.push(`agent_session(sessionId="${r.sessionId}", action="send", text=\u2026) continues with it. ${NEW_ROLE_NEW_AGENT}`);
-      if (r.cleanUp) lines.push(cleanUpLine(r.sessionId));
-      return { text: lines.join("\n") };
-    }
-  }
-}
-var plural = (n, one2, many = `${one2}s`) => `${n} ${n === 1 ? one2 : many}`;
-
 // packages/agent-host/src/sessions/app-guide.ts
 var APP_GUIDE_TOPICS = ["overview", "sessions", "orchestrator", "apps", "approvals", "settings", "updates"];
 var STATIC = {
@@ -110129,8 +110200,8 @@ var ORCHESTRATOR_TOOLS = [
    */
   {
     name: "get_preferences",
-    description: "Reads the person's settings: theme and the themes to choose from, text size, fonts, line height, the notification switches, idle sleep, automatic updates.",
-    schema: external_exports.object({})
+    description: "Reads the person's settings: theme and the themes to choose from (theme files with their problems), text size, fonts, line height, the notification switches, idle sleep, automatic updates, the models for started agents.",
+    schema: external_exports.object({ themeFile: external_exports.string().optional().describe("A theme file id: shows that file in full (its tokens and problems), to edit it with set_preferences themeFile.") }).strict()
   },
   {
     name: "set_preferences",
@@ -110149,6 +110220,21 @@ var ORCHESTRATOR_TOOLS = [
         fold: external_exports.array(external_exports.string()).max(50).optional().describe("Sessions whose children to fold away in the sidebar."),
         unfold: external_exports.array(external_exports.string()).max(50).optional().describe("Sessions whose children to show again.")
       }).strict().optional().describe("Which sidebar groups of children are folded; the rest stay as they are."),
+      agentModels: external_exports.record(
+        external_exports.string(),
+        external_exports.object({
+          light: external_exports.object({ model: external_exports.string().min(1), effort: external_exports.string().optional() }).nullable().optional(),
+          standard: external_exports.object({ model: external_exports.string().min(1), effort: external_exports.string().optional() }).nullable().optional(),
+          heavy: external_exports.object({ model: external_exports.string().min(1), effort: external_exports.string().optional() }).nullable().optional()
+        }).strict()
+      ).optional().describe("The model (and effort) start_agent runs when a caller names a difficulty, per tool then light, standard or heavy; null clears one. The rest stay."),
+      themeFile: external_exports.object({
+        id: external_exports.string().optional().describe("An existing theme file to replace; leave out to make a new file named after the theme."),
+        name: external_exports.string().describe("The theme name, 1 to 80 characters."),
+        base: external_exports.enum(["dark", "light"]),
+        tokens: external_exports.record(external_exports.string(), external_exports.string()).describe("Token key to CSS value (get_preferences themeFile shows the keys); a token left out keeps its preset value.")
+      }).strict().optional().describe("Writes a theme file as Settings does; pick it afterwards with theme (its id or name)."),
+      deleteThemeFile: external_exports.string().optional().describe("The id of a theme file to remove (kept in the themes folder under .removed); a side that showed it goes back to its preset."),
       notifications: external_exports.object({
         approval: external_exports.boolean().optional().describe("Notify when an agent is blocked on an approval."),
         done: external_exports.boolean().optional().describe("Notify when a session finishes out of sight."),
@@ -111314,6 +111400,310 @@ function movedMessage(m, folded = false) {
   return { handle: m.messageId, name: m.firstLine, state, can, message: true, ...folded ? { folded: true } : {} };
 }
 
+// packages/agent-host/src/mail/rules.ts
+var REFUSALS = [
+  "bad_address",
+  "not_local",
+  "not_found",
+  "not_participant",
+  "thread_done",
+  "kind_not_allowed",
+  "field_not_allowed",
+  "not_allowed",
+  "empty",
+  "too_long",
+  "too_many_blockers",
+  "blockers_stand",
+  "no_blocker",
+  "bad_follows",
+  "no_mailbox",
+  "rate_limited",
+  "bad_value",
+  "policy",
+  // mail without threads (docs/plans/mailbox.md §15, S9)
+  "gone",
+  "ambiguous",
+  "unknown",
+  "elsewhere",
+  "unknown_message",
+  "own_message",
+  "recipients",
+  "not_yours",
+  "pair_rate",
+  "repeat",
+  "ask_rate",
+  "orchestrator_asks",
+  "removed",
+  "untrusted_project"
+];
+function refuse4(reason, message, more = {}) {
+  return rpcError(message, "refused", { retryable: false, data: { reason, ...more } });
+}
+function refusalReason(err) {
+  const reason = asObj(asObj(err).data).reason;
+  return REFUSALS.find((r) => r === reason);
+}
+function bodyLimit(sender) {
+  return sender === "app" ? 4e3 : 16e3;
+}
+function postsPerMinute(sender) {
+  return sender === "session" ? 30 : sender === "app" ? 10 : Infinity;
+}
+var ASKS_PER_HOUR = 5;
+var REPEAT_WINDOW_MS = 10 * 6e4;
+function wakes(sender, m) {
+  if (m.kind === "event") return false;
+  if (sender === "centralu" && m.wake === "no") return false;
+  if (sender !== "app") return true;
+  if (m.wake === "no") return false;
+  if (m.kind === "notice") return m.needsOwner || m.wake === "yes";
+  return true;
+}
+function needsReceiver(m) {
+  return m.sender === PERSON || m.kind === "task" || m.kind === "report" || m.needsReply || m.facts.needsOwner === true;
+}
+var HOLD_QUESTION_MS = 5 * 6e4;
+var HOLD_OTHER_MS = 15 * 6e4;
+var DEBOUNCE_MS = 2e3;
+function dueAt(now, urgent, fromPerson) {
+  return urgent || fromPerson ? now : now + DEBOUNCE_MS;
+}
+var MINUTE_MS = 6e4;
+var HOUR_MS = 60 * MINUTE_MS;
+var READ_ITEMS = 10;
+var READ_CHARS = 2e4;
+var READ_CHAIN = 9;
+var PAIR_NEW_PER_HOUR = 5;
+var MAX_RECIPIENTS = 10;
+var HOLD_UNTRUSTED_OUT = true;
+var MAX_DEPTH = 4;
+var HOST_MAIL_TURNS_PER_HOUR = 120;
+var HOST_SHARE = 10;
+var PAIR_TURNS_PER_HOUR = 20;
+var REMINDER = {
+  /** After a session came to rest, before the first reminder */
+  graceMs: 2 * 6e4,
+  /** After a turn the person started */
+  personQuietMs: 10 * 6e4,
+  /** After the first reminder's turn ended; also the wait after the second before the row is released */
+  againMs: 20 * 6e4,
+  perRow: 2,
+  /** Between two follow-up wakes of one session (reminders and notices to a sender together) */
+  gapMs: 20 * 6e4,
+  perDay: 6,
+  /** A session asleep longer than this since its last turn is not woken for a follow-up (its prompt cache has expired) */
+  warmMs: 50 * 6e4,
+  /** After delivery a needsReply row is released: the one 2-hour constant, which also bounds a cover (D23, D25) */
+  unansweredAfterMs: 2 * HOUR_MS
+};
+var REFUSAL_TEXT = {
+  gone: (address) => `${address} is gone: it is in the session archive or deleted.`,
+  no_mailbox: () => "that session cannot read mail: only an ordinary session in a project, or the orchestrator, has the mail tool",
+  elsewhere: (address) => `${address} is on another computer, and mail does not reach other computers yet; use agent_session there.`,
+  unknown_message: (id3) => `there is no message ${id3} you can read; check the id with mail(action="inbox").`,
+  own_message: (id3) => `${id3} is your own message; say who it is for with to="\u2026".`,
+  recipients: () => `at most ${MAX_RECIPIENTS} recipients.`,
+  not_allowed: () => "that is not a party that takes mail",
+  withheld: (id3) => `${id3} is a request: its words are shown in the turn it starts, and it is marked done there.`,
+  not_yours: (id3) => `you were not sent ${id3} and did not send it.`,
+  pair_rate: (name) => `you started ${PAIR_NEW_PER_HOUR} conversations with ${name} in the last hour; answer one of its messages instead, or wait.`,
+  repeat: (name) => `you sent the same text to ${name} less than ${REPEAT_WINDOW_MS / 6e4} minutes ago.`,
+  ask_rate: () => `your project's sessions asked the orchestrator ${ASKS_PER_HOUR} times in the last hour; wait, or write to the person.`,
+  orchestrator_asks: () => "the orchestrator runs on a tool that cannot ask the person for each step of a request yet, so a session cannot ask it: write to the person instead",
+  untrusted_project: (project2, target) => `your project ${project2} is not trusted, so work you give outside it (to ${target}) waits for the person to trust ${project2}. Nothing was started. Centralu shows the person how, and tells you when ${project2} is trusted; give it again then.`
+};
+var ADOPTED_TASK = "Work given before this version of Centralu wrote it down as mail. The conversation of the session that does it shows what was asked.";
+var TASK_CUT = "\n[Centralu: cut here. The full task is in the session's conversation (read_session).]";
+function cutTask(text3, limit) {
+  const task = text3.trim();
+  return task.length > limit ? task.slice(0, limit - TASK_CUT.length) + TASK_CUT : task;
+}
+function firstLineOf(text3, max = Infinity) {
+  return oneLineText(text3.split(/\r\n|[\n\r]/)[0] ?? "", max);
+}
+function wakesMessage(m) {
+  return m.facts.quiet !== true;
+}
+function quietAnswer(m, target, receiver) {
+  return m.kind === "message" && !m.needsReply && !m.urgent && !receiver.request && target.kind === "message" && !target.needsReply && parseAddress(m.sender)?.kind === "session" && m.sender !== receiver.parent && !receiver.owesTask;
+}
+function depthOf2(cause2, about, recipients) {
+  if (!cause2 || cause2.sender === PERSON) return 0;
+  const followUp = cause2.kind === "notice" && (cause2.facts.reminder !== void 0 || cause2.facts.unanswered !== void 0);
+  if (cause2.kind !== "message" && !followUp) return 0;
+  const base2 = followUp ? Math.max(0, ...about.map((m) => m.depth)) : cause2.depth;
+  const back = !followUp ? [cause2.sender] : cause2.facts.reminder !== void 0 ? about.map((m) => m.sender) : (cause2.facts.unanswered ?? []).map((u) => u.recipient);
+  return recipients.every((r) => back.includes(r)) ? base2 : base2 + 1;
+}
+function pickWork(candidates, now) {
+  const classOf = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const hold = c.needsReply ? HOLD_QUESTION_MS : HOLD_OTHER_MS;
+    const k2 = c.decides || now - c.dueAt > hold ? 1 : c.needsReply ? 2 : 3;
+    const was = classOf.get(c.key);
+    if (was === void 0 || k2 < was) classOf.set(c.key, k2);
+  }
+  let best = null;
+  let bestClass = 4;
+  for (const [key, k2] of classOf) {
+    if (k2 < bestClass) {
+      best = key;
+      bestClass = k2;
+    }
+  }
+  return best;
+}
+function flowsDownTo(f) {
+  if (f.fromPerson) return true;
+  if (!f.fromSession || f.toOrchestrator) return false;
+  return f.kind === "task" || f.kind === "message" && f.fromParent;
+}
+
+// packages/agent-host/src/mail/delegation.ts
+function delegationRecorder(mail, turns) {
+  return (callerId, childId, origin, task) => {
+    const written = mail.task(mail.sessionAddress(callerId), mail.sessionAddress(childId), { text: task, origin: delegationOrigin(origin), delivered: true });
+    turns?.attach(childId, written.id, callerId);
+  };
+}
+function delegationOrigin(origin) {
+  return origin === "start_agent" || origin === "agent_session" || origin === "send_to_session" || origin === "create_session" || origin === "ask_project" ? origin : "send_to_session";
+}
+function personWorkRecorder(mail) {
+  return (sessionId, text3, fromScript) => {
+    mail.task(PERSON, mail.sessionAddress(sessionId), { text: text3, origin: fromScript ? "script" : "create_session", delivered: true });
+  };
+}
+function personOwes(mail, records) {
+  return (sessionId) => records.newestTask(PERSON, mail.sessionAddress(sessionId)) !== void 0;
+}
+function personReportRecorder(mail, records, waitingOn = () => 0) {
+  return (sessionId, draft) => {
+    const task = records.newestTask(PERSON, mail.sessionAddress(sessionId));
+    if (!task) return false;
+    const owed = draft.then === "review" && draft.outcome === "finished" ? waitingOn(sessionId) : 0;
+    try {
+      mail.report(task.id, turnReport(owed > 0 ? { ...draft, outcome: "paused", then: "running" } : draft, owed));
+      return true;
+    } catch (e) {
+      if (refusalReason(e) !== void 0) return false;
+      throw e;
+    }
+  };
+}
+var TURN_ENDED = "[Centralu] The session ended its turn. Its last response says whether the work is done.";
+var ANSWER_KEPT = 600;
+function answerRecorder(mail, records, turns, waitingOn = () => 0) {
+  return (callerId, childId, how) => {
+    const owner = mail.sessionAddress(callerId);
+    const child = mail.sessionAddress(childId);
+    const now = Date.now();
+    const reports = records.unreadFor(owner).filter((p) => p.message.kind === "report" && reportOnTaskTo(records, p.message, owner, child)).map((p) => p.message.id);
+    records.markDelivered(owner, reports, now, null);
+    records.markRead(owner, reports, now);
+    const task = records.newestTask(owner, child);
+    if (!how || !task) return;
+    const read = `read_session(sessionId="${childId}")`;
+    const waiting = how.ok ? waitingOn(callerId, childId) : 0;
+    const startedAt = turns?.latest(childId)?.startedAt;
+    const written = mail.report(task.id, {
+      ...startedAt !== void 0 ? { startedAt } : {},
+      ...waiting > 0 ? { outcome: "waiting", waitingOn: waiting } : { outcome: how.ok ? "finished" : "failed" },
+      body: how.ok ? `${TURN_ENDED}
+id: ${childId}
+
+Its last response is that session's own words, so it is not repeated here: ${read} reads it.` : `[Centralu] The assigned work did not finish.
+id: ${childId}
+
+Its tool's error, by kind: ${how.error}. Its words are its tool's, not Centralu's, so they are not repeated here: ${read} shows them.`,
+      ...how.ok ? { answer: how.text.length > ANSWER_KEPT ? `${how.text.slice(0, ANSWER_KEPT)}\u2026` : how.text } : { error: how.error }
+    });
+    if ("message" in written) {
+      records.markDelivered(owner, [written.message.id], now, null);
+      records.markRead(owner, [written.message.id], now);
+    }
+  };
+}
+function reportOnTaskTo(records, report, owner, child) {
+  const task = report.replyTo === null ? void 0 : records.message(report.replyTo);
+  return task?.kind === "task" && task.sender === owner && records.recipient(task.id, child) !== void 0;
+}
+function turnRecorder(mail, records, turns) {
+  return (sessionId, turn) => {
+    const child = mail.sessionAddress(sessionId);
+    const taskId = turn.ownerId && (turn.by === "work" || turn.added) ? records.newestTask(mail.sessionAddress(turn.ownerId), child)?.id ?? null : null;
+    const personWork = () => turn.ownerId ? null : records.newestTask(PERSON, child)?.id ?? null;
+    const record2 = (by, messageId, owner) => turn.again ? turns.restate(sessionId, by, messageId, owner) : turns.beginOther(sessionId, by, messageId, owner);
+    if (turn.by === "person") record2("person", null);
+    else if (turn.added) record2("person", taskId, turn.ownerId);
+    else if (turn.source === "report") record2("report", null);
+    else if (turn.source === "app") record2("app", null);
+    else {
+      const person = taskId === null ? personWork() : null;
+      record2(turn.cli && person === null ? "cli" : "caller", taskId ?? person, turn.ownerId);
+    }
+  };
+}
+function outcomeOf(draft) {
+  if (draft.then === "dropped") return { outcome: "stopped", reason: "taken_over" };
+  const word = draft.outcome;
+  const outcome = word === "finished" || word === "settled" ? "finished" : word === "failed" || word === "limit_reached" ? "failed" : "stopped";
+  return { outcome, ...word !== outcome ? { reason: word } : {} };
+}
+function turnReport(draft, waitingOn) {
+  const base2 = { body: draft.body, ...draft.answer ? { answer: draft.answer } : {}, ...draft.error ? { error: draft.error } : {}, ...draft.personNote ? { personNote: true } : {} };
+  if (draft.then === "running" && draft.paused) return { ...base2, outcome: "paused", paused: draft.paused };
+  if (draft.then === "running") return { ...base2, outcome: "waiting", waitingOn: Math.max(1, waitingOn) };
+  return { ...base2, ...outcomeOf(draft) };
+}
+function askedReportBody(draft) {
+  return draft.outcome === "finished" ? "[Centralu] The orchestrator ended its turn on your request. What it sent you in reply is its answer; if it sent nothing, it had none to give. Its other words in that turn are not passed on." : `[Centralu] The orchestrator's turn on your request did not finish (${draft.outcome}). What it sent you in reply, if anything, has reached you. Ask again, or ask the person.`;
+}
+function reportedWork(records, turns, owner, child, childId) {
+  const turnWork = turns.latest(childId)?.messageId;
+  const work = turnWork == null ? void 0 : records.message(turnWork);
+  if (work && work.sender === owner && records.recipient(work.id, child)) {
+    if (work.kind === "task") return { work, request: false };
+    if (work.kind === "message") return { work, request: true };
+  }
+  const task = records.newestTask(owner, child);
+  return task && { work: task, request: false };
+}
+function reportRecorder(mail, records, turns, waitingOn = () => 0) {
+  return (ownerId, childId, draft) => {
+    const owner = mail.sessionAddress(ownerId);
+    const child = mail.sessionAddress(childId);
+    const found = reportedWork(records, turns, owner, child, childId);
+    if (!found) return "none";
+    if (draft.archiving) return "closed";
+    const { work, request } = found;
+    let written;
+    try {
+      const { answer: _answer, ...unanswered2 } = draft;
+      const startedAt = turns.latest(childId)?.startedAt;
+      const report = request ? { ...turnReport(unanswered2, 0), body: askedReportBody(draft) } : turnReport(draft, waitingOn(ownerId, childId));
+      written = mail.report(work.id, startedAt === void 0 ? report : { ...report, startedAt });
+    } catch (e) {
+      if (refusalReason(e) !== void 0) return "none";
+      throw e;
+    }
+    const seq = turns.latest(childId)?.seq;
+    if (request && seq !== void 0 && draft.then !== "running") mail.requestTurnEnded(child, owner, seq);
+    if ("settledAlready" in written || written.duplicate) return "closed";
+    if (draft.delivery === "wake") return "mailed";
+    if (!written.first && !draft.ownerInTurn) return "closed";
+    const reportId = written.message.id;
+    return {
+      keep: true,
+      settle: () => {
+        const now = Date.now();
+        records.markDelivered(owner, [reportId], now, null);
+        records.markRead(owner, [reportId], now);
+      }
+    };
+  };
+}
+
 // packages/agent-host/src/sessions/child-ownership.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
 
@@ -111416,6 +111806,8 @@ var ChildOwnership = class {
   starters = /* @__PURE__ */ new Map();
   /** Turns the tool started by itself, no message behind them (`turnStarted`, #1576); memory only, a swap forgets it */
   cliTurns = /* @__PURE__ */ new Set();
+  /** Sessions whose running turn an update cut and Centralu continued (#1966): the turn's end carries it, once. Memory only */
+  continuedCuts = /* @__PURE__ */ new Set();
   lastBy = /* @__PURE__ */ new Map();
   /** The messages given each session's tool that no turn has taken yet (#1639), oldest first; read back from the rows once per host (`held`) */
   entries = /* @__PURE__ */ new Map();
@@ -112004,6 +112396,7 @@ var ChildOwnership = class {
     this.starters.delete(sessionId);
     this.cliTurns.delete(sessionId);
     this.takenOver.delete(sessionId);
+    if (this.continuedCuts.delete(sessionId)) starter.cut = true;
     if (cut3) this.dropInputOrigins(sessionId);
     this.noteTurnEnd(sessionId);
     this.spendCarried(sessionId);
@@ -112047,6 +112440,14 @@ var ChildOwnership = class {
   lastTurnBy(sessionId) {
     return this.lastBy.get(sessionId);
   }
+  /** The turn running was cut by an update and continued (#1966): its report says so in one line */
+  noteContinuedCut(sessionId) {
+    this.continuedCuts.add(sessionId);
+  }
+  /** The Continue did not go in after all: the turn's end is a stopped turn's, not a continued one's */
+  dropContinuedCut(sessionId) {
+    this.continuedCuts.delete(sessionId);
+  }
   /** Whose the running turn is, when one is recorded */
   starterOf(sessionId) {
     return this.starters.get(sessionId);
@@ -112584,7 +112985,7 @@ ${machineLine(machine)}` };
 var isFromTheFuture = (at2, now) => at2 > now;
 
 // packages/agent-host/src/dev-services/store/usage-history.ts
-var HOUR_MS = 60 * 6e4;
+var HOUR_MS2 = 60 * 6e4;
 var BUCKET_COLUMNS = `hour, session_id AS sessionId, project_id AS projectId, tool, model, machine, requests, input,
   cache_read AS cacheRead, cache_write AS cacheWrite, cache_write_5m AS cacheWrite5m, cache_write_1h AS cacheWrite1h,
   output, rebuilds, rebuild_tokens AS rebuildTokens, causes`;
@@ -112723,7 +113124,7 @@ function mergeCauses(a, b2) {
 var OTHERS_KEY = "*";
 var MAX_KEYS = 50;
 var NO_PROJECT_KEY = "none";
-var HOUR_MS2 = 60 * 6e4;
+var HOUR_MS3 = 60 * 6e4;
 function dayStart(ms3) {
   const d2 = new Date(ms3);
   d2.setHours(0, 0, 0, 0);
@@ -112827,7 +113228,7 @@ ${r.scope ?? ""}`;
 }
 function usageHistory(usage, p, names) {
   const firstHour = usage.firstHour(p.tool);
-  const fromHour = Math.floor(p.from / HOUR_MS2) * HOUR_MS2;
+  const fromHour = Math.floor(p.from / HOUR_MS3) * HOUR_MS3;
   return {
     by: p.by,
     readings: readingSeries(usage.readings(p.from, p.to, p.tool)),
@@ -113102,9 +113503,9 @@ Pass a machine's name as machine to create_project or add_project.` };
   remove_app: ({ app: app2, project: project2 }, call2) => appUpkeepCommand({ action: "remove", app: app2, ...trimmed(project2) ? { project: trimmed(project2) } : {} }, call2),
   share_app: ({ app: app2, project: project2, shared }, call2) => trustCommand({ action: "share_app", app: app2, ...trimmed(project2) ? { project: trimmed(project2) } : {}, shared }, call2),
   // The preferences (#1219): the flow writes each answer; set_preferences names what it did not find to change
-  get_preferences: (_args, call2) => preferencesCommand({ action: "get" }, call2),
+  get_preferences: (args, call2) => preferencesCommand({ action: "get", ...trimmed(args.themeFile) ? { themeFile: trimmed(args.themeFile) } : {} }, call2),
   apply_agent_versions: (_args, call2) => preferencesCommand({ action: "apply_agent_versions" }, call2),
-  set_preferences: (changes, call2) => Object.values(changes).some((v) => v !== void 0 && !(typeof v === "object" && Object.values(v).every((x) => x === void 0))) ? preferencesCommand({ action: "set", changes }, call2) : { text: "Nothing to change: give at least one of theme, textSize, bodyFont, codeFont, lineHeight, idleSleepMinutes, autoUpdate, moveIdleSessionsToNewAgentCli, sendWithModifierEnter, foldedGroups, notifications, autoCompact.", isError: true },
+  set_preferences: (changes, call2) => Object.values(changes).some((v) => v !== void 0 && !(typeof v === "object" && Object.values(v).every((x) => x === void 0))) ? preferencesCommand({ action: "set", changes }, call2) : { text: "Nothing to change: give at least one of theme, textSize, bodyFont, codeFont, lineHeight, idleSleepMinutes, autoUpdate, moveIdleSessionsToNewAgentCli, sendWithModifierEnter, foldedGroups, notifications, autoCompact, agentModels, themeFile, deleteThemeFile.", isError: true },
   async handoff_session(args, { tools, caller, signal }) {
     const sessionId = args.sessionId?.trim() ?? "";
     const waitFor = trimmed(args.waitFor);
@@ -114818,7 +115219,7 @@ var AgentSessionActions = class {
     const seat = caller?.projectId ? "project" : caller?.kind === "orchestrator" ? "orchestrator" : null;
     const owns = seat === "orchestrator" ? child?.askedBy === callerId : startedHere || !deletingWithoutWorktree && this.host.autoBoundaryOpen(callerId, "session ownership");
     if (!caller || !seat || !child || !owns || child.projectId !== caller.projectId) {
-      return { ok: false, error: `${opts.sessionId} is not a session this session started. agent_session works only on sessions start_agent started here.` };
+      return { ok: false, error: `${opts.sessionId} is not a session this session started. agent_session works only on sessions start_agent started here.${child ? "" : staleSessionHint(this.host, opts.sessionId, (s) => s.projectId === caller?.projectId && s.id !== callerId && (seat !== "orchestrator" || s.askedBy === callerId))}` };
     }
     if (opts.sessionId === callerId) return this.flow.agentAtRest(child);
     if (opts.action === "answer") return this.host.answerRoutedCard(callerId, child.id, opts.card, opts.text ?? "");
@@ -115093,8 +115494,6 @@ var RemoteAgents = class {
   toldDown = /* @__PURE__ */ new Map();
   /** The machines whose link this hub's own update or rollback holds, until it is back (#1618, `linkChanged`) */
   updateHolds = /* @__PURE__ */ new Set();
-  /** The turns an update of their machine cut whose callers were told it goes on (#1618), by session and when it was taken up: once each */
-  toldCut = /* @__PURE__ */ new Set();
   /** The cards of a caller's turn its caller was told of, once each (`<session>\0<turn>\0<request>`, #676) */
   toldCards = /* @__PURE__ */ new Set();
   /** Whose each child's turn is, as settled in this host (`Whose`); one not here is read from its record (`whoseOf`) */
@@ -115232,7 +115631,7 @@ var RemoteAgents = class {
     if (!reader || this.pending.has(rec.sessionId)) return;
     await this.verify(rec, reader);
     const report = this.host.children.linkedReports.get(rec.sessionId);
-    if (!report || report.orchestratorId !== rec.callerId || report.paused || !this.gateNow(rec).owned) return;
+    if (!report || report.orchestratorId !== rec.callerId || report.paused && !report.busy || !this.gateNow(rec).owned) return;
     const now = await reader.read(rec.sessionId, 1);
     if (!now.ok || this.host.children.linkedReports.get(rec.sessionId) !== report || !this.gateNow(rec).owned) return;
     this.deferred.delete(rec.sessionId);
@@ -116103,39 +116502,15 @@ Reason, by kind: ${errorKind(why2)} (its words are an error's, kept in this noti
       const held3 = this.deferred.delete(rec.sessionId);
       if (this.whoseOf(rec) === "unknown" && !this.pending.has(rec.sessionId)) await this.verify(rec, reader);
       const report = this.host.children.linkedReports.get(rec.sessionId);
-      if (!report || report.orchestratorId !== rec.callerId || report.paused || !this.gateNow(rec).owned) continue;
+      if (!report || report.orchestratorId !== rec.callerId || report.paused && !report.busy || !this.gateNow(rec).owned) continue;
       if (!report.busy && !missed && !held3) continue;
       const now = await reader.read(rec.sessionId, 1);
       if (!now.ok || this.host.children.linkedReports.get(rec.sessionId) !== report || !this.gateNow(rec).owned) continue;
       if (inTurn(now.state ?? "idle")) {
         report.busy = true;
-        this.tellContinued(rec);
       } else this.host.settleLinkedTurn(rec.sessionId);
     }
   }
-  /**
-   * A child whose turn an update of its machine cut, found in a turn again once the link is back: the host that update
-   * started continued it (#1618). Its caller is told so once, and that the report it is owed is that turn's end, so it
-   * neither waits on a link that came back nor continues the child by hand a second time.
-   *
-   * Whatever the order of the Continue and the reconnect (#1626 review): the machine's host names each turn it continues
-   * from its start on, before it answers any hello, not once the Continue is in (`SessionManager.updateContinued`), so a
-   * link back while the Continue is still on its way is told it too
-   */
-  tellContinued(rec) {
-    const at2 = this.host.linkedReader?.continuedAfterUpdate?.(rec.sessionId);
-    if (at2 == null || this.toldCut.has(`${rec.sessionId}@${at2}`)) return;
-    this.toldCut.add(`${rec.sessionId}@${at2}`);
-    const rest = "and Centralu continued it there on the new version. Its report comes when that turn ends; nothing is needed from you now.";
-    void this.host.tellSession(
-      rec.callerId,
-      `[Centralu] An update of Centralu on its machine cut the turn "${rec.name}" [${rec.sessionId}] was running there, ${rest}`,
-      { sessionId: rec.sessionId, name: rec.name },
-      true,
-      // What the model reads (#1186): all of it but the name, which is not Centralu's words (#120)
-      `[Centralu] An update of Centralu on its machine cut the turn the session [${rec.sessionId}] was running there, ${rest}`
-    );
-  }
   /**
    * Whether a message the child took was sent by this hub over this link (#1038 review): the machine records a hub's
    * instruction from `HUB_SENDER`, which reaches the hub qualified with that machine's id. Another machine's prefix is no
@@ -116430,13 +116805,13 @@ var NOT_READ = "(not read: the session's last turn was the person's; read_sessio
 function outcomeWord(work, stop2, ending) {
   if (work && "tookOver" in work) return "took_over";
   if (work && "swapped" in work) return "swapped";
-  if (work && "resumed" in work) return "resumed";
   if (work && ("machineRemoved" in work || "linkLost" in work)) return "stopped";
   if (work && ("paused" in work || "waitingOn" in work)) return "paused";
   if (work && "settled" in work) return "settled";
   if (stop2?.reason === "network") return "network";
   if (stop2?.reason === "interrupted") return "interrupted";
   if (stop2?.reason === "quit") return "quit";
+  if (stop2?.reason === "shutdown") return "shutdown";
   if (ending.type === "error") return "failed";
   if (ending.type === "limit_reached") return "limit_reached";
   if (ending.type === "turn_complete") return "finished";
@@ -116456,6 +116831,8 @@ function personReportLine(outcome, tasks) {
       return "[Centralu] The session you started stopped before finishing: its tool interrupted the turn.";
     case "quit":
       return "[Centralu] The session you started stopped before finishing: Centralu quit or restarted during its turn.";
+    case "shutdown":
+      return `[Centralu] The session you started stopped before finishing: ${SHUTDOWN_WORDS} during its turn.`;
     case "paused":
       return `[Centralu] The session you started paused: its turn ended while its own background work is still running (${tasks} task${tasks === 1 ? "" : "s"}).`;
     default:
@@ -116481,17 +116858,17 @@ function machineRemovedReportLine(machine, paused, name = STORED) {
 function swappedReportLine() {
   return "[Centralu] The assigned work's session ended a turn while Centralu was restarting, so that end was not followed. It is most likely the end of the work you gave it; check its last response before relying on it.\n";
 }
-function resumedReportLine(owed) {
-  return "[Centralu] The assigned work's turn was cut short by an update of Centralu on its machine, and Centralu continued it there on the new version. " + (owed ? "Its report follows when that turn ends; this is not it, and nothing is needed from you now.\n" : "Its end is not reported to you; read the session to follow it.\n");
-}
 function tookOverReportLine(paused, name = STORED) {
   return "[Centralu] The person took this session over; its later turns are theirs, and none of them will be reported to you. " + (paused.length ? `The work you assigned had paused on its own background work (${name.tasks(paused)}), and no final report follows.
 ` : "The work you assigned was still running, and no report of it follows.\n");
 }
 function personPartLine(turn) {
-  if (turn?.added) return "The person added an instruction to this task during this turn.\n";
-  if (turn?.wrote) return "The person wrote in this session during this turn.\n";
-  return "";
+  const cut3 = turn?.cut ? "An update of Centralu cut this turn and Centralu continued it.\n" : "";
+  if (turn?.added) return `${cut3}The person added an instruction to this task during this turn.
+`;
+  if (turn?.wrote) return `${cut3}The person wrote in this session during this turn.
+`;
+  return cut3;
 }
 function settledReportLine(tasks, name = STORED) {
   const clean = tasks.every((t) => t.status === "completed");
@@ -116677,26 +117054,12 @@ var ChildReports = class {
     const asker = requester ?? m?.askedBy ?? void 0;
     if (!m || !asker || asker === sessionId || !stop2 || stop2.reason === "reconnecting" || this.host.handingOver) return;
     const askerInfo = this.host.meta.get(asker);
-    if (!askerInfo || askerInfo.interruption?.reason === "quit") return;
+    if (!askerInfo || wentWithItsProcess(askerInfo.interruption)) return;
     console.error(`[sessions] ${sessionId.slice(0, 8)} stopped (${stop2.reason}) in a turn no report was owed for; telling ${asker.slice(0, 8)}, which started it`);
     const { name, project: project2 } = this.reportedAs(m);
     const { preview, seq } = this.stoppedTurnAnswer(sessionId);
     await this.deliverReport(asker, sessionId, name, project2, preview, { type: stop2.reason === "network" ? "error" : "state_change" }, void 0, seq);
   }
-  /**
-   * A turn of this session that a linked hub's update cut, and this host continued (#1618): its requester hears it once,
-   * so it does not read the session's stop as the end of the work, nor continue it a second time by hand. The report it is
-   * owed, if one is, stays owed: the continued turn's end is it, so it is neither lost nor sent twice
-   */
-  async tellCutByUpdate(sessionId, requester) {
-    const m = this.host.meta.get(sessionId);
-    if (!m || !this.host.meta.has(requester) || this.host.handingOver) return;
-    const { name, project: project2 } = this.reportedAs(m);
-    const owed = this.host.children.awaitingReport.get(sessionId) === requester;
-    console.error(`[sessions] ${sessionId.slice(0, 8)}: an update cut its turn and it was continued; telling ${requester.slice(0, 8)}`);
-    const { preview, seq } = this.stoppedTurnAnswer(sessionId);
-    await this.deliverReport(requester, sessionId, name, project2, preview, { type: "state_change" }, { resumed: true, owed }, seq);
-  }
   /**
    * The words of the turn a stop cut (a quit, the network, an update), as a notice of it quotes them: those said so far, or none, never the turn
    * before's (#1604, #1946). A turn not seen to begin (one an older build ran) reads as the last response does
@@ -116758,13 +117121,14 @@ ${read} shows what the person and the session did since.`;
   /** Reports the end of a turn the orchestrator asked to hear about, as one message in its session (#166) */
   async deliverReport(orchestratorId, sessionId, name, project2, preview, ending, work, answerSeq, part) {
     const stop2 = this.host.meta.get(sessionId)?.interruption;
-    const cutShort = stop2?.reason === "network" || stop2?.reason === "interrupted" || stop2?.reason === "quit";
-    const outcomeOf3 = (name2) => work && "tookOver" in work ? tookOverReportLine(work.paused, name2) : work && "swapped" in work ? swappedReportLine() : work && "resumed" in work ? resumedReportLine(work.owed) : work && "machineRemoved" in work ? machineRemovedReportLine(work.machineRemoved, work.paused, name2) : work && "linkLost" in work ? linkLostReportLine(work.linkLost, work.paused, name2) : work && "paused" in work ? pausedReportLine(work.paused, work.stoppable ? this.agentCall(orchestratorId, { action: "stop" }) : void 0, name2) : work && "settled" in work ? settledReportLine(work.settled, name2) : work && "waitingOn" in work ? waitingReportLine(work.waitingOn) : stop2?.reason === "network" ? `[Centralu] The assigned work stopped before finishing: a network error ended its turn.
+    const cutShort = stop2?.reason === "network" || stop2?.reason === "interrupted" || wentWithItsProcess(stop2);
+    const outcomeOf3 = (name2) => work && "tookOver" in work ? tookOverReportLine(work.paused, name2) : work && "swapped" in work ? swappedReportLine() : work && "machineRemoved" in work ? machineRemovedReportLine(work.machineRemoved, work.paused, name2) : work && "linkLost" in work ? linkLostReportLine(work.linkLost, work.paused, name2) : work && "paused" in work ? pausedReportLine(work.paused, work.stoppable ? this.agentCall(orchestratorId, { action: "stop" }) : void 0, name2) : work && "settled" in work ? settledReportLine(work.settled, name2) : work && "waitingOn" in work ? waitingReportLine(work.waitingOn) : stop2?.reason === "network" ? `[Centralu] The assigned work stopped before finishing: a network error ended its turn.
 ` : stop2?.reason === "interrupted" ? `[Centralu] The assigned work stopped before finishing: its tool interrupted the turn.
 ` : stop2?.reason === "quit" ? `[Centralu] The assigned work stopped before finishing: Centralu quit or restarted during its turn.
+` : stop2?.reason === "shutdown" ? `[Centralu] The assigned work stopped before finishing: ${SHUTDOWN_WORDS} during its turn.
 ` : ending.type === "error" ? `[Centralu] The assigned work failed.
 ` : ending.type === "limit_reached" ? `[Centralu] The assigned work stopped after hitting a usage limit.
-` : ending.type === "turn_complete" ? `[Centralu] The assigned work finished.
+` : ending.type === "turn_complete" ? `${TURN_ENDED}
 ` : `[Centralu] The assigned work stopped before finishing.
 `;
     const outcome = outcomeOf3(STORED) + personPartLine(part);
@@ -116777,23 +117141,24 @@ ${read} shows what the person and the session did since.`;
     const cleanUp = !work && !stop2 && ending.type === "turn_complete" ? this.cleanUpWords(orchestratorId, sessionId) : "";
     const read = `read_session(sessionId="${sessionId}"${answerSeq !== void 0 ? `, around=${answerSeq}` : ""})`;
     const kind = message ? stop2?.reason === "network" ? "network" : errorKind(message) : void 0;
-    const answered = preview !== "" && preview !== NOT_READ;
+    const answered = preview !== "" && preview !== NOT_READ && preview !== MACHINE_UNREACHABLE && preview !== IN_PAUSE_REPORT;
+    const asRead = !!work && ("linkLost" in work || "machineRemoved" in work) && work.asRead === true;
+    const asReadWords = asRead ? ", as it was last read there, before its machine went out of reach" : "";
     const forModel = (inThread) => outcomeOf3(FOR_MODEL) + personPartLine(part) + `id: ${sessionId}
 
 ` + (kind ? `Its tool's error, by kind: ${kind}. Its words are its tool's, not Centralu's, so they are not repeated here: ${read} shows them.
 
-` : "") + resume + (inThread && answered ? `Its last response is that session's own words: it is the message above in this thread, and ${read} reads more.` : `Its last response is that session's own words, so it is not repeated here: ${read} reads it${preview ? "" : " (it had none)"}.`) + cleanUp;
+` : "") + resume + (inThread && answered ? `Its last response${asReadWords} is that session's own words: it is the message above in this thread, and ${read} reads more.` : preview === MACHINE_UNREACHABLE ? `Its last response could not be read: its machine could not be reached. ${read} reads it once that machine is back.` : `Its last response${asReadWords} is that session's own words, so it is not repeated here: ${read} reads it${preview ? "" : " (it had none)"}.`) + cleanUp;
     const stored = outcome + `Session: ${frameField(name)}
 id: ${sessionId}
 Project: ${frameField(project2)}
 
-` + failure3 + resume + `Last response:
+` + failure3 + resume + `Last response${asReadWords}:
 ${preview || "(no content)"}
 
 If you need more, you can read that session's recent conversation with read_session.` + cleanUp;
     const holding = !!work && "paused" in work && !("tookOver" in work) && !("machineRemoved" in work) && !("linkLost" in work);
     const handedOn = !!work && "waitingOn" in work;
-    const goesOn = !!work && "resumed" in work;
     const reported = this.toMailbox(orchestratorId, sessionId, {
       outcome: outcomeWord(work, stop2, ending),
       body: forModel(true),
@@ -116801,7 +117166,7 @@ If you need more, you can read that session's recent conversation with read_sess
       ...kind ? { error: kindWord(kind) } : {},
       ...holding ? { paused: work.paused.length } : {},
       ...part?.wrote || part?.added ? { personNote: true } : {},
-      then: holding || handedOn || goesOn ? "running" : "review"
+      then: holding || handedOn ? "running" : "review"
     });
     if (reported === "mailed" || reported === "closed") return;
     await this.tellSession(
@@ -116828,7 +117193,7 @@ If you need more, you can read that session's recent conversation with read_sess
     const others = ownAgents(this.host, parentId).filter((s) => s.id !== childId && agentState(this.host, s) === "finished").length;
     return `
 ${cleanUpLine(childId, this.agentCall(parentId, { sessionId: childId, action: "delete" }))}` + (others ? `
-${others} other finished session${others === 1 ? "" : "s"} you started remain${others === 1 ? "s" : ""}: ${this.agentCall(parentId, { action: "list" })} shows them.` : "");
+${others} other session${others === 1 ? "" : "s"} you started ${others === 1 ? "has" : "have"} ended ${others === 1 ? "its turn" : "their turns"} and remain${others === 1 ? "s" : ""}: ${this.agentCall(parentId, { action: "list" })} shows them.` : "");
   }
   /**
    * An agent_session call a report names, in the form its receiver calls it (#850): the orchestrator reaches agent_session
@@ -116895,6 +117260,10 @@ sourceSessionId: ${from.sessionId}`;
 var HELD_NOTICES_MAX = 20;
 
 // packages/agent-host/src/sessions/interruption-watch.ts
+var LOST_TURN_LINE = {
+  quit: "Centralu quit or restarted while this turn was running, so the turn stopped before it finished. Send a message to continue.",
+  shutdown: `This turn stopped before it finished: ${SHUTDOWN_WORDS} while it was running. Send a message to continue.`
+};
 var InterruptionWatch = class {
   constructor(host) {
     this.host = host;
@@ -116940,19 +117309,20 @@ var InterruptionWatch = class {
   }
   /**
    * The turn went with its process (#698): a start found the session mid-turn with no process left (a full quit, a
-   * reboot, a crash the keeper did not survive), or a kept process could not be re-attached. The session is reset to
+   * reboot, a crash the keeper did not survive), or a kept process could not be re-attached. `shutdown`: the start found the
+   * last host recorded the system ending (a shutdown, restart or sign-out, #1397), which is said so rather than as a quit. The session is reset to
    * `idle`, which used to leave no mark at all: the conversation simply stopped. A line now says so, and the
    * interruption puts the session in the inbox with a way to continue.
    */
-  markStoppedByQuit(m, announce) {
-    m.interruption = { reason: "quit", at: Date.now() };
+  markTurnLost(m, announce, reason = "quit") {
+    m.interruption = { reason, at: Date.now() };
     const notice = {
       type: "notice",
       sessionId: m.id,
       level: "warning",
       from: "Centralu",
       label: "stopped",
-      text: "Centralu quit or restarted while this turn was running, so the turn stopped before it finished. Send a message to continue."
+      text: LOST_TURN_LINE[reason]
     };
     const seq = this.host.record.persistMessage(notice, m);
     if (!announce) return;
@@ -117247,11 +117617,150 @@ var MergeChecks = class {
   }
 };
 
+// packages/agent-host/src/themes.ts
+import { randomBytes as randomBytes7 } from "node:crypto";
+import { watch as watch3 } from "node:fs";
+import { mkdir as mkdir4, readdir as readdir7, readFile as readFile4, rename as rename4, stat as stat7 } from "node:fs/promises";
+import { basename as basename8, join as join31 } from "node:path";
+var MAX_FILE_BYTES = 256 * 1024;
+var SETTLE_MS = 100;
+function themeSlug(name) {
+  return name.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "theme";
+}
+var REMOVED_DIR = ".removed";
+var ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,59}$/;
+var ThemeFiles = class {
+  constructor(dir, onChange) {
+    this.dir = dir;
+    this.onChange = onChange;
+  }
+  dir;
+  onChange;
+  watcher = null;
+  timer = null;
+  /** Makes the folder, writes the schema next to the themes, and starts watching */
+  async start() {
+    await mkdir4(this.dir, { recursive: true });
+    await this.writeSchema();
+    try {
+      this.watcher = watch3(this.dir, (_event, name) => {
+        if (name && !String(name).endsWith(".json")) return;
+        if (name === THEME_SCHEMA_FILE) return;
+        if (this.timer) clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+          this.timer = null;
+          this.onChange();
+        }, SETTLE_MS);
+      });
+      this.watcher.on("error", () => this.stopWatching());
+    } catch {
+    }
+  }
+  close() {
+    this.stopWatching();
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  stopWatching() {
+    this.watcher?.close();
+    this.watcher = null;
+  }
+  /**
+   * The schema an editor uses for completion, written only when it differs — a build that adds
+   * a token updates it, and an unchanged one does not touch the folder (or wake the watcher).
+   */
+  async writeSchema() {
+    const path2 = join31(this.dir, THEME_SCHEMA_FILE);
+    const text3 = `${JSON.stringify(themeFileJsonSchema(), null, 2)}
+`;
+    const current = await readFile4(path2, "utf8").catch(() => null);
+    if (current !== text3) writeFileWhole(realOs().files, path2, text3);
+  }
+  /** Every `<id>.json` in the folder, read and checked. A file that cannot be read is listed with the reason. */
+  async list() {
+    const names = await readdir7(this.dir).catch(() => []);
+    const entries = [];
+    const ids = names.filter((name) => name.endsWith(".json") && name !== THEME_SCHEMA_FILE).map((name) => name.slice(0, -".json".length)).filter((id3) => ID_PATTERN.test(id3)).sort();
+    for (const id3 of ids) entries.push(await this.read(id3));
+    return entries;
+  }
+  async read(id3) {
+    const path2 = this.pathOf(id3);
+    try {
+      const info = await stat7(path2);
+      if (info.size > MAX_FILE_BYTES) {
+        return { id: id3, path: path2, name: id3, base: "dark", tokens: {}, problems: ["The file is too large to be a theme."], broken: true };
+      }
+      return parseThemeFile(id3, path2, await readFile4(path2, "utf8"));
+    } catch (e) {
+      return { id: id3, path: path2, name: id3, base: "dark", tokens: {}, problems: [`Could not read the file: ${e.message}`], broken: true };
+    }
+  }
+  /** Writes a theme. `id` null makes a new file named after the theme (`My theme` → `my-theme.json`). */
+  async save(id3, content) {
+    const text3 = formatThemeFile(content);
+    if (Buffer.byteLength(text3) > MAX_FILE_BYTES) throw rpcError("The theme is too large to be a theme file.");
+    const target = id3 ?? await this.freeId(content.name);
+    await mkdir4(this.dir, { recursive: true });
+    const names = await readdir7(this.dir).catch(() => []);
+    const clash = names.find((n) => n !== `${target}.json` && n.toLowerCase() === `${target}.json`);
+    if (clash) throw rpcError(`The themes folder has ${clash}, which the list does not show (ids are lowercase); rename or remove it first.`);
+    writeFileWhole(realOs().files, this.pathOf(target), text3);
+    return this.read(target);
+  }
+  /**
+   * Takes a theme file out of the list without destroying it: it moves to `.removed/<id>-<time>-<random>.json`, a place the list
+   * does not look, so a mistaken removal is one move back. The host has no OS trash (Settings' button reaches it through the
+   * shell), so these stay until the person clears the folder. Where it went is returned; null when there was no such file.
+   */
+  async remove(id3) {
+    const from = this.pathOf(id3);
+    if (!await stat7(from).then(() => true, () => false)) return null;
+    const kept = join31(this.dir, REMOVED_DIR);
+    await mkdir4(kept, { recursive: true });
+    const to = join31(kept, `${id3}-${Date.now()}-${randomBytes7(3).toString("hex")}.json`);
+    await rename4(from, to);
+    return to;
+  }
+  /** Copies a file from elsewhere in, under a fresh id if its name is taken. Refuses what does not read as a theme. */
+  async importFrom(source) {
+    const info = await stat7(source);
+    if (!info.isFile()) throw rpcError("That is not a file.");
+    if (info.size > MAX_FILE_BYTES) throw rpcError("The file is too large to be a theme.");
+    const text3 = await readFile4(source, "utf8");
+    const parsed = parseThemeFile("import", source, text3);
+    if (parsed.broken) throw rpcError(parsed.problems[0] ?? "Not a theme file.");
+    const fromName = basename8(source).replace(/\.json$/i, "");
+    const id3 = await this.freeId(parsed.name !== "import" ? parsed.name : fromName);
+    writeFileWhole(realOs().files, this.pathOf(id3), text3);
+    return this.read(id3);
+  }
+  /** The absolute path for an id, for the shell to trash or reveal. Refuses anything that is not an id. */
+  pathOf(id3) {
+    if (!ID_PATTERN.test(id3)) throw rpcError(`Not a theme id: ${id3}`);
+    return join31(this.dir, `${id3}.json`);
+  }
+  async freeId(name) {
+    const base2 = themeSlug(name);
+    for (let n = 1; n < 1e3; n++) {
+      const id3 = n === 1 ? base2 : `${base2}-${n}`;
+      const taken = await stat7(this.pathOf(id3)).then(
+        () => true,
+        () => false
+      );
+      if (!taken) return id3;
+    }
+    return `${base2}-${randomBytes7(4).toString("hex")}`;
+  }
+};
+
 // packages/agent-host/src/sessions/window-rpc.ts
 var WINDOW_METHODS = [
   "prefs.get",
   "prefs.set",
   "themes.list",
+  "themes.save",
+  "themes.remove",
   "agents.sleepPolicy",
   "agents.setSleepPolicy",
   "updates.status",
@@ -117311,6 +117820,7 @@ async function callWindow(rpc, method, params) {
 // packages/agent-host/src/sessions/preferences-flow.ts
 var HIDDEN2 = /[\p{Cc}\p{Cf}\u2028\u2029]/u;
 var UPDATE_CARD = 'Turn on "Automatic updates"? From then on this computer checks for a newer Centralu, installs it by itself as soon as one is published, and the desktop window relaunches into it when nothing is busy, without asking again. You can turn it off in Settings, Updates.';
+var THEME_FILE_MAX_BYTES = 256 * 1024;
 var FOLDED_GROUPS_MAX = 500;
 var SLEEP_CHOICES = 'a whole number of minutes, or "never"';
 function autoCompactText(c) {
@@ -117332,7 +117842,7 @@ var PreferencesFlow = class {
     const rpc = this.rpc;
     if (!rpc) return { ok: false, error: "This host has no window calls to make." };
     try {
-      if (req.action === "get") return await this.get(rpc);
+      if (req.action === "get") return await this.get(rpc, req.themeFile);
       if (req.action === "apply_agent_versions") return await this.applyVersions(rpc);
       return await this.set(rpc, sessionId, req.changes, signal);
     } catch (e) {
@@ -117340,7 +117850,7 @@ var PreferencesFlow = class {
     }
   }
   /** Every setting Settings shows, one line each; a part the host cannot read says so, and the rest still answers */
-  async get(rpc) {
+  async get(rpc, themeFile) {
     const [prefs, themes2, sleep4, updates2, versions] = await Promise.allSettled([
       callWindow(rpc, "prefs.get", {}),
       callWindow(rpc, "themes.list", {}),
@@ -117360,9 +117870,11 @@ var PreferencesFlow = class {
       "Appearance",
       `- Theme mode: ${p.themeMode}; dark theme ${named(p.themeDark)}; light theme ${named(p.themeLight)}`,
       `- Themes to choose from (set_preferences theme): ${choices.map((c) => `${plainQuoted(c.name)} [${c.id}] (${c.base}${c.file ? ", a theme file" : ""})`).join(", ")}`,
+      ...themes2.status === "fulfilled" ? themeFileLines(themes2.value, themeFile) : [],
       `- Text size: ${p.textSize} (${TEXT_SIZES.join(", ")}; 1 is the default)`,
       `- Body font: ${p.bodyFont ? plainQuoted(p.bodyFont, 200) : "the app's own"}; code font: ${p.codeFont ? plainQuoted(p.codeFont, 200) : "the app's own"}`,
       `- Line height: ${p.lineHeight} (compact, normal, relaxed)`,
+      `- Models for the agents a session starts (set_preferences agentModels): ${agentModelsText(p.agentModels)}`,
       "Notifications (set_preferences notifications)",
       `- Approval needed: ${onOff(notify.approval)}; a session finishes out of sight: ${onOff(notify.done)}; even while the app is focused: ${onOff(notify.whenFocused)}; sound: ${onOff(notify.sound)}; turning the approval one off, or the sound while it notifies, asks the person`,
       "Auto compact (set_preferences autoCompact)",
@@ -117383,12 +117895,19 @@ var PreferencesFlow = class {
   async set(rpc, sessionId, changes, signal) {
     const patch = {};
     let theme = null;
+    const done2 = [];
+    const failed3 = [];
+    const modelWarnings = [];
+    const file2 = changes.themeFile;
+    if (file2 !== void 0) {
+      const bad = themeFileRefusal(file2);
+      if (bad) return { ok: false, error: bad };
+    }
     if (changes.theme !== void 0) {
       const found = await this.theme(rpc, changes.theme);
-      if (typeof found === "string") return { ok: false, error: found };
-      theme = found;
-      patch.themeMode = found.base;
-      patch[found.base === "dark" ? "themeDark" : "themeLight"] = found.id;
+      const wanted = changes.theme.trim().toLowerCase();
+      const madeHere = file2 !== void 0 && (file2.name.trim().toLowerCase() === wanted || await this.idOfFile(rpc, file2) === wanted);
+      if (typeof found === "string" && !madeHere) return { ok: false, error: found };
     }
     if (changes.textSize !== void 0) {
       if (!Number.isFinite(changes.textSize)) return { ok: false, error: `textSize is a number: one of ${TEXT_SIZES.join(", ")}.` };
@@ -117400,6 +117919,12 @@ var PreferencesFlow = class {
       if (HIDDEN2.test(value)) return { ok: false, error: `${key} has a control or formatting character in it; give a font family as plain text.` };
       patch[key] = value.trim();
     }
+    if (changes.agentModels !== void 0) {
+      const merged = await this.mergedAgentModels(rpc, changes.agentModels);
+      if (typeof merged === "string") return { ok: false, error: merged };
+      patch.agentModels = merged.models;
+      modelWarnings.push(...merged.warnings);
+    }
     if (changes.lineHeight !== void 0) patch.lineHeight = changes.lineHeight;
     if (changes.sendWithModifierEnter !== void 0) patch.sendWithModifierEnter = changes.sendWithModifierEnter;
     if (changes.foldedGroups !== void 0) {
@@ -117408,13 +117933,35 @@ var PreferencesFlow = class {
       patch.foldedGroups = keys;
     }
     const parsed = UiPreferencesPatch.safeParse(patch);
-    if (!parsed.success) return { ok: false, error: `Nothing changed: ${issuesOf(parsed.error)}.` };
+    if (!parsed.success) return { ok: false, error: `${issuesOf(parsed.error)}.` };
     const sleep4 = changes.idleSleepMinutes;
     if (sleep4 !== void 0 && sleep4 !== "never" && !(Number.isInteger(sleep4) && sleep4 > 0)) {
       return { ok: false, error: `idleSleepMinutes is ${SLEEP_CHOICES}.` };
     }
-    const done2 = [];
-    const failed3 = [];
+    if (file2 !== void 0) {
+      try {
+        const saved = await callWindow(rpc, "themes.save", { id: file2.id?.trim() || null, content: { name: file2.name.trim(), base: file2.base, tokens: file2.tokens } });
+        done2.push(themeFileWritten(saved));
+      } catch (e) {
+        return { ok: false, error: errorMessage(e) };
+      }
+    }
+    let toApply = parsed.data;
+    if (changes.theme !== void 0) {
+      const found = await this.theme(rpc, changes.theme);
+      if (typeof found === "string") failed3.push(`Theme: not picked. ${found}`);
+      else {
+        theme = found;
+        patch.themeMode = found.base;
+        patch[found.base === "dark" ? "themeDark" : "themeLight"] = found.id;
+        const again = UiPreferencesPatch.safeParse(patch);
+        if (again.success) toApply = again.data;
+        else {
+          theme = null;
+          failed3.push(`Theme: not picked. ${issuesOf(again.error)}.`);
+        }
+      }
+    }
     const attempt = async (what, run4) => {
       try {
         done2.push(await run4());
@@ -117424,8 +117971,8 @@ var PreferencesFlow = class {
     };
     if (Object.keys(patch).length) {
       await attempt("Appearance", async () => {
-        const now = await callWindow(rpc, "prefs.set", { patch: parsed.data });
-        return appearanceText(now, patch, theme);
+        const now = await callWindow(rpc, "prefs.set", { patch: toApply });
+        return [appearanceText(now, patch, theme), ...modelWarnings].join(" ");
       });
     }
     const switches = Object.fromEntries(Object.entries(changes.notifications ?? {}).filter(([, v]) => v !== void 0));
@@ -117461,7 +118008,7 @@ var PreferencesFlow = class {
     if (Object.keys(compact).length) {
       await attempt("Auto compact", async () => {
         const checked2 = UiPreferencesPatch.safeParse({ autoCompact: compact });
-        if (!checked2.success) throw new Error(`Nothing changed: ${issuesOf(checked2.error)}.`);
+        if (!checked2.success) throw new Error(`${issuesOf(checked2.error)}.`);
         const now = autoCompactOf(await callWindow(rpc, "prefs.set", { patch: checked2.data }));
         return `Now: ${autoCompactText(now)}. It reaches a running session when its process next starts.`;
       });
@@ -117513,7 +118060,21 @@ var PreferencesFlow = class {
         return `Moving idle sessions to a newly installed agent CLI is ${onOff(now.autoApply)}.`;
       });
     }
-    if (!done2.length) return { ok: false, error: `Nothing changed. ${failed3.join(" ")}` };
+    if (changes.deleteThemeFile !== void 0) {
+      const id3 = changes.deleteThemeFile.trim();
+      await attempt("Theme file", async () => {
+        if (!ThemeId.safeParse(id3).success) throw new Error(`${plainQuoted(id3)} is not a theme file id; get_preferences lists them.`);
+        const { removed, keptAt } = await callWindow(rpc, "themes.remove", { id: id3 });
+        if (!removed) throw new Error(`No theme file [${id3}]; get_preferences lists them.`);
+        const now = await callWindow(rpc, "prefs.get", {});
+        const back = {};
+        if (now.themeDark === id3) back.themeDark = "dark";
+        if (now.themeLight === id3) back.themeLight = "light";
+        if (Object.keys(back).length) await callWindow(rpc, "prefs.set", { patch: back });
+        return `Removed the theme file [${id3}]; it is kept at ${plainQuoted(keptAt ?? "", 300)} (move it back to restore it).${Object.keys(back).length ? " A side that showed it is back on its preset." : ""}`;
+      });
+    }
+    if (!done2.length) return { ok: false, error: failed3.join(" ") };
     return { ok: true, text: [...done2, ...failed3.length ? [`Not changed: ${failed3.join(" ")}`] : []].join("\n") };
   }
   /**
@@ -117536,6 +118097,58 @@ var PreferencesFlow = class {
     const kept = now.filter((key) => !drop.has(key) && !add2.includes(key));
     return [...kept, ...add2].slice(-FOLDED_GROUPS_MAX);
   }
+  /**
+   * The saved models with this call's changes merged in (the patch carries the whole map), or the sentence that says what is
+   * wrong. The map steers every difficulty-based start_agent in every project, so the tool must be an agent CLI on this
+   * computer. A model or effort is free text, as Settings' picker takes with "Other…", also when the tool lists its models
+   * (a newer id may not be in the list yet); one the list lacks is saved as typed and said so in a warning. Clearing a
+   * difficulty that was never set changes nothing and leaves no empty entry.
+   */
+  async mergedAgentModels(rpc, change) {
+    const now = (await callWindow(rpc, "prefs.get", {})).agentModels ?? {};
+    const known = (await callWindow(rpc, "agents.detect", {})).map((s) => s.name);
+    const out = { ...now };
+    const warnings = [];
+    for (const [tool, levels] of Object.entries(change)) {
+      if (!known.includes(tool)) return `agentModels: ${plainQuoted(tool, 80)} is not an agent CLI on this computer; agent_status lists them (${known.join(", ") || "none"}).`;
+      const own = { ...out[tool] };
+      let catalog;
+      for (const [level2, choice] of Object.entries(levels)) {
+        if (choice === null) delete own[level2];
+        else if (choice !== void 0) {
+          const model = choice.model.trim();
+          const effort = choice.effort?.trim();
+          if (!model) return "agentModels: a model is empty; give its id as plain text.";
+          if (HIDDEN2.test(model) || HIDDEN2.test(effort ?? "")) return "agentModels has a control or formatting character in a model or effort; give plain text.";
+          if (catalog === void 0) {
+            const r = await callWindow(rpc, "agents.models", { tool }).catch(() => null);
+            catalog = r?.supported && r.models.length ? r.models : null;
+          }
+          if (catalog) {
+            const m = catalog.find((x) => x.id === model);
+            if (!m) warnings.push(`Note: ${plainQuoted(model, 200)} is not in ${tool}'s current list (agent_models); saved as typed.`);
+            else if (effort && m.efforts.length && !m.efforts.includes(effort)) warnings.push(`Note: ${plainQuoted(effort, 80)} is not in the current efforts of ${plainQuoted(model, 200)} (${m.efforts.map((e) => plainQuoted(e, 40)).join(", ")}); saved as typed.`);
+          }
+          own[level2] = effort ? { model, effort } : { model };
+        }
+      }
+      if (Object.keys(own).length) out[tool] = own;
+      else delete out[tool];
+    }
+    return { models: out, warnings };
+  }
+  /** The id a theme file will be written under: the one named, else the one `themes.save` files its name under among the ids taken now */
+  async idOfFile(rpc, file2) {
+    const named = file2.id?.trim().toLowerCase();
+    if (named) return named;
+    const taken = new Set((await callWindow(rpc, "themes.list", {})).map((f) => f.id));
+    const base2 = themeSlug(file2.name.trim());
+    for (let n = 1; n < 1e3; n++) {
+      const id3 = n === 1 ? base2 : `${base2}-${n}`;
+      if (!taken.has(id3)) return id3;
+    }
+    return base2;
+  }
   /** The session header's action: idle sessions on an older agent CLI restart on the installed one, and the busy ones are named */
   async applyVersions(rpc) {
     const r = await callWindow(rpc, "agents.applyVersions", { keepQuiet: true });
@@ -117570,6 +118183,44 @@ function automatic(s) {
   if (!s.auto && !s.autoApply) return "off";
   return s.auto ? "off (checking is on, installing is off)" : "off (installing is on, checking is off)";
 }
+function themeFileRefusal(file2) {
+  if (file2.id !== void 0 && file2.id.trim() && !ThemeId.safeParse(file2.id.trim()).success) {
+    return `themeFile.id ${plainQuoted(file2.id)} is not a theme id: lowercase letters, digits and dashes, up to 60. Leave it out for a new file.`;
+  }
+  const content = ThemeFileContent.safeParse({ name: file2.name.trim(), base: file2.base, tokens: file2.tokens });
+  if (!content.success) return `themeFile: ${issuesOf(content.error)}.`;
+  if (HIDDEN2.test(file2.name) || Object.entries(file2.tokens).some(([k2, v]) => HIDDEN2.test(k2) || HIDDEN2.test(v))) {
+    return "themeFile has a control or formatting character in its name or tokens; give plain text.";
+  }
+  if (Buffer.byteLength(formatThemeFile(content.data)) > THEME_FILE_MAX_BYTES) return "themeFile is too large to be a theme file; leave out the tokens you do not change.";
+  return null;
+}
+function themeFileWritten(f) {
+  const problems = f.problems.length ? ` Problems the reader found, skipped when applied: ${f.problems.map((x) => plainQuoted(x, 200)).join(" ")}` : "";
+  return `Wrote the theme file ${plainQuoted(f.name)} [${f.id}] (${f.base}, ${Object.keys(f.tokens).length} tokens).${problems}`;
+}
+function themeFileLines(files2, one2) {
+  const state = (f) => f.broken ? ", unreadable" : f.problems.length ? `, ${f.problems.length} problems` : "";
+  const lines = [
+    files2.length ? `- Theme files (set_preferences themeFile writes one, deleteThemeFile removes one): ${files2.map((f) => `${plainQuoted(f.name)} [${f.id}] (${f.base}, ${Object.keys(f.tokens).length} tokens${state(f)})`).join(", ")}` : "- Theme files: none (set_preferences themeFile writes one)"
+  ];
+  if (one2) {
+    const f = files2.find((x) => x.id === one2.trim());
+    if (!f) lines.push(`- Theme file ${plainQuoted(one2)}: no such file`);
+    else {
+      lines.push(`- Theme file ${plainQuoted(f.name)} [${f.id}], ${f.base}${f.problems.length ? `; problems: ${f.problems.map((x) => plainQuoted(x, 200)).join(" ")}` : ""}`);
+      lines.push(...Object.entries(f.tokens).map(([k2, v]) => `  ${k2}: ${plainQuoted(v, 400)}`));
+      lines.push(`  Token keys to set: ${THEME_TOKENS.map((t) => t.key).join(", ")}`);
+    }
+  }
+  return lines;
+}
+function agentModelsText(models) {
+  const parts = Object.entries(models ?? {}).flatMap(
+    ([tool, levels]) => Object.entries(levels).flatMap(([level2, c]) => c ? [`${plainQuoted(tool, 80)} ${level2}: ${plainQuoted(c.model, 200)}${c.effort ? ` (${plainQuoted(c.effort, 80)})` : ""}`] : [])
+  );
+  return parts.length ? parts.join("; ") : "none chosen (each project keeps its last choice)";
+}
 function themeChoices(files2) {
   return [
     ...THEME_PRESETS.map((p) => ({ id: p.id, name: p.name, base: p.base, file: false })),
@@ -117587,6 +118238,7 @@ function appearanceText(now, patch, theme) {
   if ("codeFont" in patch) parts.push(`code font ${now.codeFont ? plainQuoted(now.codeFont, 200) : "the app's own"}`);
   if ("lineHeight" in patch) parts.push(`line height ${now.lineHeight}`);
   if ("sendWithModifierEnter" in patch) parts.push(`send with ${now.sendWithModifierEnter ? "Ctrl+Enter (Enter breaks the line)" : "Enter"}`);
+  if ("agentModels" in patch) parts.push(`models for started agents: ${agentModelsText(now.agentModels)}`);
   if ("foldedGroups" in patch) parts.push(`${now.foldedGroups.length} sidebar ${now.foldedGroups.length === 1 ? "group" : "groups"} folded`);
   return `Now: ${parts.join("; ")}.`;
 }
@@ -118552,7 +119204,7 @@ var HousekeepingFlow = class {
 import { randomUUID as randomUUID18 } from "node:crypto";
 import { existsSync as existsSync15, realpathSync as realpathSync5, rmSync as rmSync4, statSync as statSync13 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename8, isAbsolute as isAbsolute5, join as join31, resolve as resolve11 } from "node:path";
+import { basename as basename9, isAbsolute as isAbsolute5, join as join32, resolve as resolve11 } from "node:path";
 
 // packages/agent-host/src/dev-services/project-folder.ts
 import { lstatSync as lstatSync12, mkdirSync as mkdirSync16, statSync as statSync12 } from "node:fs";
@@ -118565,18 +119217,18 @@ function projectsHome(platform = process.platform, home = homedir6(), env = proc
   if (platform === "win32") return path.win32.join(env.USERPROFILE || home, PROJECTS_DIR);
   return path.posix.join(home, PROJECTS_DIR);
 }
-function refuse4(message) {
+function refuse5(message) {
   throw rpcError(message);
 }
 function projectFolderTarget(spec, home, platform = process.platform) {
   const p = pathFor(platform);
   const name = spec.name.trim();
   const nameError = folderNameError(name, platform === "win32");
-  if (nameError) refuse4(nameError);
+  if (nameError) refuse5(nameError);
   const given = spec.parent?.trim();
-  if (given && !p.isAbsolute(given)) refuse4(`The location has to be a full path (${platform === "win32" ? "C:\\Users\\me\\code" : "/home/me/code"}).`);
+  if (given && !p.isAbsolute(given)) refuse5(`The location has to be a full path (${platform === "win32" ? "C:\\Users\\me\\code" : "/home/me/code"}).`);
   const base2 = given || home;
-  if (!base2) refuse4("There is no default location here \u2014 give a parent folder.");
+  if (!base2) refuse5("There is no default location here \u2014 give a parent folder.");
   const parent = p.resolve(base2);
   const isDefault = !given;
   if (!isDefault) {
@@ -118584,9 +119236,9 @@ function projectFolderTarget(spec, home, platform = process.platform) {
     try {
       dir = statSync12(parent).isDirectory();
     } catch {
-      refuse4(`There is no folder at ${parent}.`);
+      refuse5(`There is no folder at ${parent}.`);
     }
-    if (!dir) refuse4(`${parent} is a file, not a folder.`);
+    if (!dir) refuse5(`${parent} is a file, not a folder.`);
   }
   const target = p.join(parent, name);
   let taken = false;
@@ -118595,7 +119247,7 @@ function projectFolderTarget(spec, home, platform = process.platform) {
     taken = true;
   } catch {
   }
-  if (taken) refuse4(`Something named "${name}" is already in ${parent} \u2014 choose another name.`);
+  if (taken) refuse5(`Something named "${name}" is already in ${parent} \u2014 choose another name.`);
   return { name, parent, path: target, isDefault };
 }
 function makeProjectFolder(target) {
@@ -118604,9 +119256,9 @@ function makeProjectFolder(target) {
     mkdirSync16(target.path);
   } catch (e) {
     const code2 = execFailure(e).code;
-    if (code2 === "EEXIST") refuse4(`Something named "${target.name}" is already in ${target.parent} \u2014 choose another name.`);
-    if (code2 === "ENOENT") refuse4(`There is no folder at ${target.parent}.`);
-    refuse4(`Could not make ${target.path}: ${errorMessage(e)}`);
+    if (code2 === "EEXIST") refuse5(`Something named "${target.name}" is already in ${target.parent} \u2014 choose another name.`);
+    if (code2 === "ENOENT") refuse5(`There is no folder at ${target.parent}.`);
+    refuse5(`Could not make ${target.path}: ${errorMessage(e)}`);
   }
 }
 
@@ -118629,7 +119281,7 @@ var ProjectCreation = class {
     const existing = this.projectAt(spelled2);
     const at2 = existing?.path ?? spelled2;
     const id3 = existing?.id ?? randomUUID18();
-    this.host.store.projects.addProject({ id: id3, path: at2, name: basename8(at2), ...opts.trusted ? { trusted: true } : {} });
+    this.host.store.projects.addProject({ id: id3, path: at2, name: basename9(at2), ...opts.trusted ? { trusted: true } : {} });
     return this.host.projectInfo(id3, at2);
   }
   /**
@@ -118651,7 +119303,7 @@ var ProjectCreation = class {
    */
   async inspectFolder(given) {
     const typed = given.trim();
-    const expanded = /^~(?=$|[\\/])/.test(typed) ? join31(homedir7(), typed.slice(1)) : typed;
+    const expanded = /^~(?=$|[\\/])/.test(typed) ? join32(homedir7(), typed.slice(1)) : typed;
     if (!expanded || !isAbsolute5(expanded)) throw rpcError(`Give the folder's full path: ${JSON.stringify(given)} is not one`);
     const path2 = resolve11(expanded).replace(/^[a-z]:/, (drive) => drive.toUpperCase());
     let found;
@@ -118664,7 +119316,7 @@ var ProjectCreation = class {
     const git2 = folder ? await isRepo(path2).catch(() => false) : false;
     const origin = git2 ? await gitOriginUrl(path2, { trusted: false }) : null;
     const kept = folder ? this.projectAt(path2) : void 0;
-    const project2 = kept ? { id: kept.id, name: this.host.store.projects.listProjects().find((p) => p.id === kept.id)?.name ?? basename8(kept.path) } : null;
+    const project2 = kept ? { id: kept.id, name: this.host.store.projects.listProjects().find((p) => p.id === kept.id)?.name ?? basename9(kept.path) } : null;
     return { path: path2, exists: found !== null, folder, git: git2, origin, project: project2 };
   }
   /**
@@ -120459,27 +121111,27 @@ var SessionTools = class {
 
 // packages/agent-host/src/dev-services/handoff-notes.ts
 import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync8 } from "node:fs";
-import { mkdir as mkdir4, readdir as readdir7, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join32 } from "node:path";
-var root = () => join32(dataRoot(), "handoff");
+import { mkdir as mkdir5, readdir as readdir8, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join33 } from "node:path";
+var root = () => join33(dataRoot(), "handoff");
 function handoffNoteDir(projectId) {
   if (!isProjectId(projectId)) {
     throw rpcError(`Not a project id: ${projectId}`);
   }
-  return join32(root(), projectId);
+  return join33(root(), projectId);
 }
 function handoffNotePath(projectId, sessionId) {
   if (!isSessionId(sessionId)) {
     throw rpcError(`Not a session id: ${sessionId}`);
   }
-  return join32(handoffNoteDir(projectId), `${sessionId}.md`);
+  return join33(handoffNoteDir(projectId), `${sessionId}.md`);
 }
 async function handoffNoteBytes(projectId, sessionId) {
   return dataBytes(handoffNotePath(projectId, sessionId));
 }
 async function writeHandoffNote(projectId, sessionId, text3) {
   const path2 = handoffNotePath(projectId, sessionId);
-  await mkdir4(handoffNoteDir(projectId), { recursive: true });
+  await mkdir5(handoffNoteDir(projectId), { recursive: true });
   await removeData(path2);
   await writeFile4(path2, text3, "utf8");
   return path2;
@@ -120494,7 +121146,7 @@ function writeHandoffNoteSync(projectId, sessionId, text3) {
 async function sweepHandoffNotes(owned, projectId) {
   let dirs;
   try {
-    dirs = projectId ? [projectId] : (await readdir7(root(), { withFileTypes: true })).filter((d2) => d2.isDirectory()).map((d2) => d2.name);
+    dirs = projectId ? [projectId] : (await readdir8(root(), { withFileTypes: true })).filter((d2) => d2.isDirectory()).map((d2) => d2.name);
   } catch {
     return;
   }
@@ -120505,12 +121157,12 @@ async function sweepHandoffNotes(owned, projectId) {
     } catch {
       continue;
     }
-    const entries = await readdir7(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir8(dir, { withFileTypes: true }).catch(() => []);
     for (const e of entries) {
       if (!e.isFile() || !e.name.endsWith(".md")) continue;
       const owner = e.name.slice(0, -".md".length);
       if (owned(owner)) continue;
-      await removeData(join32(dir, e.name)).catch(() => {
+      await removeData(join33(dir, e.name)).catch(() => {
       });
     }
   }
@@ -120808,20 +121460,12 @@ var HandoffNotes = class {
    * first, as its children did; the nearest generation with a live one wins.
    */
   handoffHeir(sessionId) {
-    const seen = /* @__PURE__ */ new Set([sessionId]);
-    let generation = [sessionId];
     try {
-      while (generation.length) {
-        const heirs = generation.flatMap((at2) => this.host.store.handoffs.handoffHeirs(at2)).filter((h) => !seen.has(h.sessionId));
-        for (const h of heirs) seen.add(h.sessionId);
-        const live2 = heirs.find((h) => !h.trashed && this.host.meta.has(h.sessionId) && !this.host.trashing.has(h.sessionId));
-        if (live2) return live2.sessionId;
-        generation = heirs.map((h) => h.sessionId);
-      }
+      return liveHeirOf(this.host.store, sessionId, (id3) => this.host.meta.has(id3) && !this.host.trashing.has(id3));
     } catch (e) {
       console.error(`[agent-host] no handoff heir read for ${sessionId.slice(0, 8)}: ${e.message}`);
+      return null;
     }
-    return null;
   }
   /**
    * The note folder a successor reads from (#142) — only a project session that inherited a handoff
@@ -120960,11 +121604,11 @@ ${note}` : note;
 };
 
 // packages/agent-host/src/mail/ids.ts
-import { randomBytes as randomBytes7 } from "node:crypto";
+import { randomBytes as randomBytes8 } from "node:crypto";
 var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var ID_RE = /^([a-z0-9][a-z0-9-]*)\.(t|m)_([0-9A-HJKMNP-TV-Z]{26})$/;
 var UlidMaker = class {
-  constructor(random = randomBytes7) {
+  constructor(random = randomBytes8) {
     this.random = random;
   }
   random;
@@ -121972,7 +122616,7 @@ function linksOf(raw) {
 function stateOf(word) {
   return THREAD_STATES.find((x) => x === word) ?? "unknown";
 }
-function outcomeOf(word) {
+function outcomeOf2(word) {
   if (word === null) return null;
   return THREAD_OUTCOMES.find((x) => x === word) ?? "unknown";
 }
@@ -121986,7 +122630,7 @@ var toThread = (r) => ({
   parentId: r.parent_id,
   follows: readJsonList(r.follows, external_exports.string()),
   state: stateOf(r.state),
-  outcome: outcomeOf(r.outcome),
+  outcome: outcomeOf2(r.outcome),
   owner: r.owner,
   assignee: r.assignee,
   next: r.next_step,
@@ -123465,165 +124109,6 @@ function attachCommitSessions(commits, records, nameOf3) {
   });
 }
 
-// packages/agent-host/src/mail/rules.ts
-var REFUSALS = [
-  "bad_address",
-  "not_local",
-  "not_found",
-  "not_participant",
-  "thread_done",
-  "kind_not_allowed",
-  "field_not_allowed",
-  "not_allowed",
-  "empty",
-  "too_long",
-  "too_many_blockers",
-  "blockers_stand",
-  "no_blocker",
-  "bad_follows",
-  "no_mailbox",
-  "rate_limited",
-  "bad_value",
-  "policy",
-  // mail without threads (docs/plans/mailbox.md §15, S9)
-  "gone",
-  "ambiguous",
-  "unknown",
-  "elsewhere",
-  "unknown_message",
-  "own_message",
-  "recipients",
-  "not_yours",
-  "pair_rate",
-  "repeat",
-  "ask_rate",
-  "orchestrator_asks",
-  "removed",
-  "untrusted_project"
-];
-function refuse5(reason, message, more = {}) {
-  return rpcError(message, "refused", { retryable: false, data: { reason, ...more } });
-}
-function refusalReason(err) {
-  const reason = asObj(asObj(err).data).reason;
-  return REFUSALS.find((r) => r === reason);
-}
-function bodyLimit(sender) {
-  return sender === "app" ? 4e3 : 16e3;
-}
-function postsPerMinute(sender) {
-  return sender === "session" ? 30 : sender === "app" ? 10 : Infinity;
-}
-var ASKS_PER_HOUR = 5;
-var REPEAT_WINDOW_MS = 10 * 6e4;
-function wakes(sender, m) {
-  if (m.kind === "event") return false;
-  if (sender === "centralu" && m.wake === "no") return false;
-  if (sender !== "app") return true;
-  if (m.wake === "no") return false;
-  if (m.kind === "notice") return m.needsOwner || m.wake === "yes";
-  return true;
-}
-function needsReceiver(m) {
-  return m.sender === PERSON || m.kind === "task" || m.kind === "report" || m.needsReply || m.facts.needsOwner === true;
-}
-var HOLD_QUESTION_MS = 5 * 6e4;
-var HOLD_OTHER_MS = 15 * 6e4;
-var DEBOUNCE_MS = 2e3;
-function dueAt(now, urgent, fromPerson) {
-  return urgent || fromPerson ? now : now + DEBOUNCE_MS;
-}
-var MINUTE_MS = 6e4;
-var HOUR_MS3 = 60 * MINUTE_MS;
-var READ_ITEMS = 10;
-var READ_CHARS = 2e4;
-var READ_CHAIN = 9;
-var PAIR_NEW_PER_HOUR = 5;
-var MAX_RECIPIENTS = 10;
-var HOLD_UNTRUSTED_OUT = true;
-var MAX_DEPTH = 4;
-var HOST_MAIL_TURNS_PER_HOUR = 120;
-var HOST_SHARE = 10;
-var PAIR_TURNS_PER_HOUR = 20;
-var REMINDER = {
-  /** After a session came to rest, before the first reminder */
-  graceMs: 2 * 6e4,
-  /** After a turn the person started */
-  personQuietMs: 10 * 6e4,
-  /** After the first reminder's turn ended; also the wait after the second before the row is released */
-  againMs: 20 * 6e4,
-  perRow: 2,
-  /** Between two follow-up wakes of one session (reminders and notices to a sender together) */
-  gapMs: 20 * 6e4,
-  perDay: 6,
-  /** A session asleep longer than this since its last turn is not woken for a follow-up (its prompt cache has expired) */
-  warmMs: 50 * 6e4,
-  /** After delivery a needsReply row is released: the one 2-hour constant, which also bounds a cover (D23, D25) */
-  unansweredAfterMs: 2 * HOUR_MS3
-};
-var REFUSAL_TEXT = {
-  gone: (address) => `${address} is gone: it is in the session archive or deleted.`,
-  no_mailbox: () => "that session cannot read mail: only an ordinary session in a project, or the orchestrator, has the mail tool",
-  elsewhere: (address) => `${address} is on another computer, and mail does not reach other computers yet; use agent_session there.`,
-  unknown_message: (id3) => `there is no message ${id3} you can read; check the id with mail(action="inbox").`,
-  own_message: (id3) => `${id3} is your own message; say who it is for with to="\u2026".`,
-  recipients: () => `at most ${MAX_RECIPIENTS} recipients.`,
-  not_allowed: () => "that is not a party that takes mail",
-  withheld: (id3) => `${id3} is a request: its words are shown in the turn it starts, and it is marked done there.`,
-  not_yours: (id3) => `you were not sent ${id3} and did not send it.`,
-  pair_rate: (name) => `you started ${PAIR_NEW_PER_HOUR} conversations with ${name} in the last hour; answer one of its messages instead, or wait.`,
-  repeat: (name) => `you sent the same text to ${name} less than ${REPEAT_WINDOW_MS / 6e4} minutes ago.`,
-  ask_rate: () => `your project's sessions asked the orchestrator ${ASKS_PER_HOUR} times in the last hour; wait, or write to the person.`,
-  orchestrator_asks: () => "the orchestrator runs on a tool that cannot ask the person for each step of a request yet, so a session cannot ask it: write to the person instead",
-  untrusted_project: (project2, target) => `your project ${project2} is not trusted, so work you give outside it (to ${target}) waits for the person to trust ${project2}. Nothing was started. Centralu shows the person how, and tells you when ${project2} is trusted; give it again then.`
-};
-var ADOPTED_TASK = "Work given before this version of Centralu wrote it down as mail. The conversation of the session that does it shows what was asked.";
-var TASK_CUT = "\n[Centralu: cut here. The full task is in the session's conversation (read_session).]";
-function cutTask(text3, limit) {
-  const task = text3.trim();
-  return task.length > limit ? task.slice(0, limit - TASK_CUT.length) + TASK_CUT : task;
-}
-function firstLineOf(text3, max = Infinity) {
-  return oneLineText(text3.split(/\r\n|[\n\r]/)[0] ?? "", max);
-}
-function wakesMessage(m) {
-  return m.facts.quiet !== true;
-}
-function quietAnswer(m, target, receiver) {
-  return m.kind === "message" && !m.needsReply && !m.urgent && !receiver.request && target.kind === "message" && !target.needsReply && parseAddress(m.sender)?.kind === "session" && m.sender !== receiver.parent && !receiver.owesTask;
-}
-function depthOf2(cause2, about, recipients) {
-  if (!cause2 || cause2.sender === PERSON) return 0;
-  const followUp = cause2.kind === "notice" && (cause2.facts.reminder !== void 0 || cause2.facts.unanswered !== void 0);
-  if (cause2.kind !== "message" && !followUp) return 0;
-  const base2 = followUp ? Math.max(0, ...about.map((m) => m.depth)) : cause2.depth;
-  const back = !followUp ? [cause2.sender] : cause2.facts.reminder !== void 0 ? about.map((m) => m.sender) : (cause2.facts.unanswered ?? []).map((u) => u.recipient);
-  return recipients.every((r) => back.includes(r)) ? base2 : base2 + 1;
-}
-function pickWork(candidates, now) {
-  const classOf = /* @__PURE__ */ new Map();
-  for (const c of candidates) {
-    const hold = c.needsReply ? HOLD_QUESTION_MS : HOLD_OTHER_MS;
-    const k2 = c.decides || now - c.dueAt > hold ? 1 : c.needsReply ? 2 : 3;
-    const was = classOf.get(c.key);
-    if (was === void 0 || k2 < was) classOf.set(c.key, k2);
-  }
-  let best = null;
-  let bestClass = 4;
-  for (const [key, k2] of classOf) {
-    if (k2 < bestClass) {
-      best = key;
-      bestClass = k2;
-    }
-  }
-  return best;
-}
-function flowsDownTo(f) {
-  if (f.fromPerson) return true;
-  if (!f.fromSession || f.toOrchestrator) return false;
-  return f.kind === "task" || f.kind === "message" && f.fromParent;
-}
-
 // packages/agent-host/src/mail/delivery.ts
 var MailNotAtRest = class extends Error {
   constructor() {
@@ -124012,7 +124497,7 @@ var MailDelivery = class {
    */
   overHostCap(recipient, sessionId, drained, now) {
     if (!this.turns) return 0;
-    const since = now - HOUR_MS3;
+    const since = now - HOUR_MS;
     if (this.turns.mailStartedSince(since) < this.o.hostCap || this.turns.mailStartedSince(since, sessionId) < this.o.hostShare) return 0;
     if (drained.messageIds.some((id3) => {
       const m = this.records.message(id3);
@@ -124021,9 +124506,9 @@ var MailDelivery = class {
     this.service.notice(PERSON, {
       body: `Mail between sessions started ${this.o.hostCap} turns in the last hour; more wait until the hour has room.`,
       facts: { hostCap: true },
-      dedupeKey: `hostcap:${PERSON}:${Math.floor(now / HOUR_MS3) * HOUR_MS3}`
+      dedupeKey: `hostcap:${PERSON}:${Math.floor(now / HOUR_MS) * HOUR_MS}`
     });
-    const until = (this.records.oldestMailStartedSince(since, sessionId) ?? now) + HOUR_MS3;
+    const until = (this.records.oldestMailStartedSince(since, sessionId) ?? now) + HOUR_MS;
     if (this.capUntil.get(recipient) !== until) console.error(`[mail] ${recipient}: the host has had ${this.o.hostCap} mail-started turns this hour; its mail waits`);
     this.capUntil.set(recipient, until);
     return Math.max(1e3, until - now);
@@ -125253,16 +125738,16 @@ var CardIds = class {
 
 // packages/agent-host/src/adapters/frames/recorder.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync18 } from "node:fs";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 var processes = /* @__PURE__ */ new Map();
 function frameRecorder(sessionId, env = process.env) {
   const dir = env.CC_RECORD_FRAMES;
   if (!dir) return void 0;
   mkdirSync18(dir, { recursive: true });
   let n = (processes.get(sessionId) ?? 0) + 1;
-  while (existsSync16(join33(dir, `${sessionId}.${n}.jsonl`))) n++;
+  while (existsSync16(join34(dir, `${sessionId}.${n}.jsonl`))) n++;
   processes.set(sessionId, n);
-  const file2 = join33(dir, `${sessionId}.${n}.jsonl`);
+  const file2 = join34(dir, `${sessionId}.${n}.jsonl`);
   const start3 = Date.now();
   const write = (entry) => {
     try {
@@ -125711,7 +126196,7 @@ var CoreSession = class {
 };
 
 // packages/agent-host/src/adapters/acp/session.ts
-import { isAbsolute as isAbsolute6, join as join34 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join35 } from "node:path";
 
 // packages/agent-host/src/adapters/always-allow.ts
 var AlwaysAllowRules = class {
@@ -125853,7 +126338,7 @@ var UnmappedTypes = class {
 };
 
 // packages/agent-host/src/adapters/acp/connection.ts
-import { randomBytes as randomBytes8 } from "node:crypto";
+import { randomBytes as randomBytes9 } from "node:crypto";
 var RpcError = class extends Error {
   constructor(code2, message, data) {
     super(message);
@@ -125898,7 +126383,7 @@ var AcpConnection = class {
    * String ids with a per-connection prefix: a host that adopts a process the previous host was talking to can
    * receive answers to that host's requests (§4.4), and plain counters on both would have collided.
    */
-  idPrefix = `c${randomBytes8(3).toString("hex")}-`;
+  idPrefix = `c${randomBytes9(3).toString("hex")}-`;
   nextId = 1;
   pending = new PendingRequests();
   closed = false;
@@ -127108,7 +127593,7 @@ var AcpWire = class {
       ownTool: Boolean(this.deps.centraluToolOf?.(call2)),
       auto: this.preset === "auto",
       alwaysAllowKey: alwaysAllowKey(detail),
-      edit: edit ? { folder: this.opts.cwd, paths: editPaths(call2).map((p) => isAbsolute6(p) ? p : join34(this.opts.cwd, p)) } : null
+      edit: edit ? { folder: this.opts.cwd, paths: editPaths(call2).map((p) => isAbsolute6(p) ? p : join35(this.opts.cwd, p)) } : null
     };
   }
   respondApproval(requestId, decision, matcher2) {
@@ -127265,10 +127750,10 @@ var ACP_CAPABILITIES = {
 // packages/agent-host/src/adapters/antigravity/agent-files.ts
 import { spawn as spawnChild } from "node:child_process";
 import { createHash as createHash11 } from "node:crypto";
-import { closeSync as closeSync5, createReadStream as createReadStream3, createWriteStream, existsSync as existsSync18, fstatSync as fstatSync4, openSync as openSync5, readdirSync as readdirSync11, readFileSync as readFileSync12, readSync as readSync4, watch as watch3 } from "node:fs";
-import { chmod as chmod3, mkdir as mkdir5, mkdtemp as mkdtemp3, readdir as readdir8, readFile as readFile4, rename as rename4, rm as rm6, statfs, writeFile as writeFile5 } from "node:fs/promises";
+import { closeSync as closeSync5, createReadStream as createReadStream3, createWriteStream, existsSync as existsSync18, fstatSync as fstatSync4, openSync as openSync5, readdirSync as readdirSync11, readFileSync as readFileSync12, readSync as readSync4, watch as watch4 } from "node:fs";
+import { chmod as chmod3, mkdir as mkdir6, mkdtemp as mkdtemp3, readdir as readdir9, readFile as readFile5, rename as rename5, rm as rm6, statfs, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createInflateRaw } from "node:zlib";
@@ -127276,7 +127761,7 @@ import { createInflateRaw } from "node:zlib";
 // packages/agent-host/src/dev-services/instance-lock.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync11, unlinkSync as unlinkSync3, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname16, join as join35 } from "node:path";
+import { dirname as dirname16, join as join36 } from "node:path";
 import Database2 from "better-sqlite3";
 var OWNERSHIP_FILE = "host-ownership.sqlite";
 var held = /* @__PURE__ */ new Set();
@@ -127317,7 +127802,7 @@ function parseHolder(raw) {
 function acquireInstanceLock(dbPath2, startOf = processStartTime, describe4 = {}, now = Date.now) {
   if (dbPath2 === ":memory:") return { ok: true, release: () => {
   } };
-  const lockPath = join35(dirname16(dbPath2), "host.lock");
+  const lockPath = join36(dirname16(dbPath2), "host.lock");
   const readHolder = () => {
     try {
       return parseHolder(readFileSync11(lockPath, "utf8"));
@@ -127325,7 +127810,7 @@ function acquireInstanceLock(dbPath2, startOf = processStartTime, describe4 = {}
       return null;
     }
   };
-  const owner = takeOwnership(join35(dirname16(dbPath2), OWNERSHIP_FILE));
+  const owner = takeOwnership(join36(dirname16(dbPath2), OWNERSHIP_FILE));
   if (!owner) {
     const holder = readHolder();
     const pid = holder && Number.isInteger(holder.pid) && holder.pid > 0 ? holder.pid : null;
@@ -127450,26 +127935,26 @@ function agyPlatformKey(platform = HOST_PLATFORM, arch = process.arch) {
   return null;
 }
 function agyHome(dataDir, version2) {
-  const root3 = join36(dataDir, "tools", "antigravity");
-  return { root: root3, versionDir: join36(root3, version2), geminiHome: join36(root3, "gemini-home") };
+  const root3 = join37(dataDir, "tools", "antigravity");
+  return { root: root3, versionDir: join37(root3, version2), geminiHome: join37(root3, "gemini-home") };
 }
 function agyProgram(home, archive) {
-  return join36(home.versionDir, archive.command);
+  return join37(home.versionDir, archive.command);
 }
 var INSTALL_MARKER = "install.json";
 function isInstalled(home, archive) {
   try {
-    const marker = asObj(JSON.parse(readFileSync12(join36(home.versionDir, INSTALL_MARKER), "utf8")));
+    const marker = asObj(JSON.parse(readFileSync12(join37(home.versionDir, INSTALL_MARKER), "utf8")));
     if (marker.sha256 !== archive.sha256) return false;
-    return archive.files.every((f) => existsSync18(join36(home.versionDir, f)));
+    return archive.files.every((f) => existsSync18(join37(home.versionDir, f)));
   } catch {
     return false;
   }
 }
 function hasSignIn(home) {
-  const dir = join36(home.geminiHome, "antigravity-acp");
+  const dir = join37(home.geminiHome, "antigravity-acp");
   try {
-    const settings = asObj(JSON.parse(readFileSync12(join36(dir, "settings.json"), "utf8")));
+    const settings = asObj(JSON.parse(readFileSync12(join37(dir, "settings.json"), "utf8")));
     const auth = asObj(settings.auth);
     return typeof auth.type === "string" && auth.type.length > 0;
   } catch {
@@ -127529,22 +128014,22 @@ async function installAgy(home, archive, version2, opts) {
   const io2 = opts.io ?? realInstallIo;
   const { signal } = opts;
   if (isInstalled(home, archive)) return;
-  await mkdir5(home.root, { recursive: true });
+  await mkdir6(home.root, { recursive: true });
   await removeStale(home.root, ".install-");
   const free = await io2.freeBytes(home.root);
   if (free !== null && free < AGY_INSTALL_SPACE_BYTES) {
     throw new InstallFailure("disk_space", `Antigravity needs about ${mb(AGY_INSTALL_SPACE_BYTES)} MB free to install; ${mb(free)} MB are free`);
   }
-  const work = await mkdtemp3(join36(home.root, `.install-${ownerTag()}-`));
+  const work = await mkdtemp3(join37(home.root, `.install-${ownerTag()}-`));
   try {
-    const zip = join36(work, "archive.zip");
+    const zip = join37(work, "archive.zip");
     const sha = await download(io2, archive.url, zip, signal, opts.onProgress);
     if (sha !== archive.sha256) throw new InstallFailure("checksum", `The downloaded archive does not match the version Centralu pins (sha256 ${sha.slice(0, 12)}\u2026)`);
     cancelled(signal);
-    const pkg = join36(work, "pkg");
+    const pkg = join37(work, "pkg");
     await unpack(zip, archive, pkg, signal, opts.platform ?? HOST_PLATFORM);
     await rm6(zip, { force: true });
-    await writeFile5(join36(pkg, INSTALL_MARKER), `${JSON.stringify({ version: version2, sha256: archive.sha256, url: archive.url })}
+    await writeFile5(join37(pkg, INSTALL_MARKER), `${JSON.stringify({ version: version2, sha256: archive.sha256, url: archive.url })}
 `);
     cancelled(signal);
     if (isInstalled(home, archive)) return;
@@ -127607,12 +128092,12 @@ async function unpack(zip, archive, dir, signal, platform) {
   if (names.length !== want.length || names.some((n, i) => n !== want[i])) {
     throw new InstallFailure("unpack", `The archive holds ${names.join(", ") || "nothing"}, not the files the release names (${want.join(", ")})`);
   }
-  await mkdir5(dir, { recursive: true });
+  await mkdir6(dir, { recursive: true });
   for (const e of entries) {
     if (e.kind !== "file" || !/^[\w.-]+$/.test(e.name)) throw new InstallFailure("unpack", `The archive's entry ${e.name} is not a plain file`);
     if (e.method !== 0 && e.method !== 8) throw new InstallFailure("unpack", `The archive's entry ${e.name} uses compression method ${e.method}`);
     cancelled(signal);
-    const path2 = join36(dir, e.name);
+    const path2 = join37(dir, e.name);
     await unpackEntry(zip, e, starts.get(e) ?? 0, path2, signal);
     if (platform !== "win32") await chmod3(path2, 493);
   }
@@ -127662,9 +128147,9 @@ async function removeLeftovers(home) {
   await removeStale(home.root, ".sign-in-");
 }
 async function removeStale(root3, prefix) {
-  const names = await readdir8(root3).catch(() => []);
+  const names = await readdir9(root3).catch(() => []);
   const stale = names.filter((n) => n.startsWith(prefix) && ownerGone(n.slice(prefix.length)));
-  await Promise.all(stale.map((n) => rm6(join36(root3, n), { recursive: true, force: true }).catch(() => {
+  await Promise.all(stale.map((n) => rm6(join37(root3, n), { recursive: true, force: true }).catch(() => {
   })));
 }
 var ownStart;
@@ -127695,10 +128180,10 @@ function processAlive(pid) {
   }
 }
 async function removeOtherVersions(home) {
-  const names = await readdir8(home.root).catch(() => []);
+  const names = await readdir9(home.root).catch(() => []);
   for (const n of names) {
     if (!/^\d+\.\d+\.\d+/.test(n)) continue;
-    const dir = join36(home.root, n);
+    const dir = join37(home.root, n);
     if (dir === home.versionDir) continue;
     await rm6(dir, { recursive: true, force: true }).catch(() => {
     });
@@ -127707,7 +128192,7 @@ async function removeOtherVersions(home) {
 async function renameHeld(from, to) {
   for (let attempt = 1; ; attempt++) {
     try {
-      await rename4(from, to);
+      await rename5(from, to);
       return;
     } catch (err) {
       const code2 = err instanceof Error ? Reflect.get(err, "code") : void 0;
@@ -127718,21 +128203,21 @@ async function renameHeld(from, to) {
 }
 var mb = (bytes2) => Math.round(bytes2 / (1024 * 1024));
 async function browserFolder(home, platform = HOST_PLATFORM, node = process.execPath) {
-  await mkdir5(home.root, { recursive: true });
+  await mkdir6(home.root, { recursive: true });
   await removeStale(home.root, ".sign-in-");
-  const dir = await mkdtemp3(join36(home.root, `.sign-in-${ownerTag()}-`));
+  const dir = await mkdtemp3(join37(home.root, `.sign-in-${ownerTag()}-`));
   await chmod3(dir, 448).catch(() => {
   });
   let browser;
   if (platform === "win32") {
-    const script = join36(dir, "open-url.mjs");
+    const script = join37(dir, "open-url.mjs");
     await writeFile5(script, WINDOWS_HELPER);
     browser = windowsBrowserCommand(node, script);
   } else {
-    const helper = join36(dir, "open-url");
-    const part = `${shQuote(join36(dir, "part-"))}"$$"`;
+    const helper = join37(dir, "open-url");
+    const part = `${shQuote(join37(dir, "part-"))}"$$"`;
     await writeFile5(helper, `#!/bin/sh
-printf '%s\\n' "$1" > ${part} && mv ${part} ${shQuote(join36(dir, "url-"))}"$$"
+printf '%s\\n' "$1" > ${part} && mv ${part} ${shQuote(join37(dir, "url-"))}"$$"
 exit 0
 `, { mode: 448 });
     await chmod3(helper, 448);
@@ -127752,8 +128237,8 @@ exit 0
         }
         for (const name of names) {
           taken.add(name);
-          const path2 = join36(dir, name);
-          void readFile4(path2, "utf8").then(
+          const path2 = join37(dir, name);
+          void readFile5(path2, "utf8").then(
             async (text3) => {
               await rm6(path2, { force: true }).catch(() => {
               });
@@ -127765,7 +128250,7 @@ exit 0
         }
       };
       try {
-        watcher = watch3(dir, () => look());
+        watcher = watch4(dir, () => look());
         watcher.on("error", () => {
         });
       } catch {
@@ -128295,10 +128780,10 @@ var AntigravityAdapter = class extends AcpAdapter {
 
 // packages/agent-host/src/adapters/claude/index.ts
 import { tmpdir as tmpdir4 } from "node:os";
-import { mkdtemp as mkdtemp4, readdir as readdir11, rm as rm9, stat as stat10 } from "node:fs/promises";
-import { join as join44 } from "node:path";
+import { mkdtemp as mkdtemp4, readdir as readdir12, rm as rm9, stat as stat11 } from "node:fs/promises";
+import { join as join45 } from "node:path";
 import { randomUUID as randomUUID23 } from "node:crypto";
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 
 // packages/agent-host/src/cli-version.ts
@@ -128651,13 +129136,28 @@ function claudeQueryOptions({ sessionId, opts, executablePath, servers, permissi
 }
 
 // packages/agent-host/src/adapters/claude/exe-link.ts
-import { randomBytes as randomBytes9 } from "node:crypto";
+import { execFile as execFile5 } from "node:child_process";
+import { randomBytes as randomBytes10 } from "node:crypto";
 import { closeSync as closeSync7, copyFileSync as copyFileSync4, linkSync as linkSync2, mkdirSync as mkdirSync20, openSync as openSync7, readdirSync as readdirSync13, readFileSync as readFileSync15, readSync as readSync6, renameSync as renameSync11, rmSync as rmSync6, statSync as statSync15 } from "node:fs";
-import { basename as basename11, dirname as dirname20, join as join41 } from "node:path";
+import { createRequire } from "node:module";
+import { basename as basename12, dirname as dirname20, join as join42 } from "node:path";
 var PLACEHOLDER_MAX_BYTES = 1e6;
+var INSTALLER_TIMEOUT_MS = 3e4;
+var VERSION_TIMEOUT_MS = 1e4;
 var ClaudePlaceholderError = class extends Error {
   name = "ClaudePlaceholderError";
 };
+function runNode(file2, args, cwd, timeoutMs) {
+  return new Promise((resolve20) => {
+    const child = execFile5(file2, args, { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 1 << 20, encoding: "utf8" }, (err, stdout, stderr) => {
+      const output = `${stdout}${stderr}`.trim();
+      if (!err) return resolve20({ status: 0, output });
+      if (err.killed) return resolve20({ status: null, output: `it did not finish within ${Math.round(timeoutMs / 1e3)} seconds` });
+      resolve20(typeof err.code === "number" ? { status: err.code, output } : { status: null, output: err.message });
+    });
+    child.stdin?.end();
+  });
+}
 var realExeFs = {
   stat: (p) => statSync15(p),
   head: (p, n) => {
@@ -128677,9 +129177,33 @@ var realExeFs = {
   list: (d2) => readdirSync13(d2),
   mkdir: (d2) => void mkdirSync20(d2, { recursive: true }),
   removeDir: (d2) => rmSync6(d2, { recursive: true, force: true }),
-  removeFile: (p) => rmSync6(p, { force: true })
+  removeFile: (p) => rmSync6(p, { force: true }),
+  runInstaller: (installer, timeoutMs) => runNode(process.execPath, [installer], dirname20(installer), timeoutMs),
+  /*
+   * Where `install.cjs` takes the program from: the platform package its `package.json` lists, resolved
+   * from the package's own folder. Only Windows repairs, so the platform is win32 and the file claude.exe.
+   */
+  nativeSize: (installer) => {
+    try {
+      const pkg = createRequire(installer).resolve(`@anthropic-ai/claude-code-win32-${process.arch}/package.json`);
+      return statSync15(join42(dirname20(pkg), "claude.exe")).size;
+    } catch {
+      return null;
+    }
+  },
+  runProgram: async (path2, args, timeoutMs) => ({ status: (await runNode(path2, args, void 0, timeoutMs)).status })
 };
-function placeholderProblem(exe, size2, fs3 = realExeFs) {
+function installerFor(exe, fs3 = realExeFs) {
+  if (basename12(dirname20(exe)).toLowerCase() !== "bin") return null;
+  const installer = join42(dirname20(dirname20(exe)), "install.cjs");
+  try {
+    fs3.stat(installer);
+    return installer;
+  } catch {
+    return null;
+  }
+}
+function placeholderProblem(exe, size2, fs3 = realExeFs, tried = null) {
   if (size2 >= PLACEHOLDER_MAX_BYTES) return null;
   let head;
   try {
@@ -128688,26 +129212,23 @@ function placeholderProblem(exe, size2, fs3 = realExeFs) {
     return null;
   }
   if (head.toString("latin1") === "MZ") return null;
-  const pkg = dirname20(dirname20(exe));
-  const installer = basename11(dirname20(exe)).toLowerCase() === "bin" ? join41(pkg, "install.cjs") : null;
-  let canRerun = false;
-  if (installer) {
-    try {
-      fs3.stat(installer);
-      canRerun = true;
-    } catch {
-    }
-  }
   return [
     `Claude Code is not installed completely: ${exe} is a ${size2}-byte placeholder, not the Claude program (about 250 MB).`,
     "Claude Code's setup step puts the real program there after npm installs the package; it did not finish, usually because a running Claude Code held the file during an install or update.",
-    canRerun ? `To fix it, close every Claude Code (Centralu's Claude sessions, terminals, editors) and run \`node "${installer}"\`, or reinstall with \`npm i -g @anthropic-ai/claude-code\` while no Claude Code is running.` : "To fix it, close every Claude Code (Centralu's Claude sessions, terminals, editors) and reinstall it with `npm i -g @anthropic-ai/claude-code`."
+    ...tried ? [tried] : [],
+    fixAdvice(installerFor(exe, fs3))
   ].join(" ");
 }
+function fixAdvice(installer) {
+  return installer ? `To fix it, close every Claude Code (Centralu's Claude sessions, terminals, editors) and run \`node "${installer}"\`, or reinstall with \`npm i -g @anthropic-ai/claude-code\` while no Claude Code is running.` : "To fix it, close every Claude Code (Centralu's Claude sessions, terminals, editors) and reinstall it with `npm i -g @anthropic-ai/claude-code`.";
+}
+function unprovenProblem(exe, size2, why2, tried, installer) {
+  return [`Claude Code is not installed completely: ${exe} is ${size2} bytes and ${why2}.`, tried, fixAdvice(installer)].join(" ");
+}
 function claudeKey(exe, stat12, fs3 = realExeFs) {
   let version2 = null;
   try {
-    const pkg = JSON.parse(fs3.read(join41(dirname20(dirname20(exe)), "package.json")));
+    const pkg = JSON.parse(fs3.read(join42(dirname20(dirname20(exe)), "package.json")));
     if (pkg.name === "@anthropic-ai/claude-code" && typeof pkg.version === "string" && pkg.version) version2 = pkg.version;
   } catch {
   }
@@ -128727,19 +129248,31 @@ var ClaudeLinks = class {
   fs;
   log;
   uses = /* @__PURE__ */ new Map();
+  /** The setup step of each package this host has started, running or done: once per host start, never in a loop */
+  repairs = /* @__PURE__ */ new Map();
+  /** What the setup step did, once it ended: what the message adds about it, and the program it left that is not proven */
+  outcomes = /* @__PURE__ */ new Map();
   /** The key new sessions start from: the last one prepared */
   current = null;
   get enabled() {
     return windowsStart(this.opts.platform);
   }
   base() {
-    return join41(this.opts.root(), "tools", "claude");
+    return join42(this.opts.root(), "tools", "claude");
+  }
+  /**
+   * `prepare`, after repairing npm's placeholder if that is what `exe` is. Every start path awaits this,
+   * so the setup step runs beside the host's loop, never in it.
+   */
+  async ensure(exe) {
+    await this.repair(exe);
+    return this.prepare(exe);
   }
   /**
    * What to start for the `claude.exe` found at `exe`. Off Windows, or for anything but an `.exe`
    * (a `cli.js` through Node), `exe` itself.
    *
-   * @throws ClaudePlaceholderError when the file is npm's placeholder
+   * @throws ClaudePlaceholderError when the file is npm's placeholder, or a setup step left a file that is not proven to be the program
    */
   prepare(exe) {
     const direct = { path: exe, key: null };
@@ -128750,11 +129283,15 @@ var ClaudeLinks = class {
     } catch {
       return direct;
     }
-    const problem3 = placeholderProblem(exe, stat12.size, this.fs);
+    const installer = installerFor(exe, this.fs);
+    const outcome = installer ? this.outcomes.get(installer) : void 0;
+    let problem3 = placeholderProblem(exe, stat12.size, this.fs, outcome?.note ?? null);
+    const bad = outcome?.unproven;
+    if (!problem3 && installer && outcome && bad && bad.size === stat12.size && bad.mtimeMs === stat12.mtimeMs) problem3 = unprovenProblem(exe, stat12.size, bad.why, outcome.note, installer);
     if (problem3) throw new ClaudePlaceholderError(problem3);
     const key = claudeKey(exe, stat12, this.fs);
-    const dir = join41(this.base(), key);
-    const target = join41(dir, "claude.exe");
+    const dir = join42(this.base(), key);
+    const target = join42(dir, "claude.exe");
     const ready = () => {
       try {
         return this.fs.stat(target).size === stat12.size;
@@ -128763,7 +129300,7 @@ var ClaudeLinks = class {
       }
     };
     if (ready()) return this.use(key, target);
-    const tmp = join41(dir, `claude-${randomBytes9(4).toString("hex")}.tmp`);
+    const tmp = join42(dir, `claude-${randomBytes10(4).toString("hex")}.tmp`);
     try {
       this.fs.mkdir(dir);
       try {
@@ -128788,6 +129325,74 @@ var ClaudeLinks = class {
       return direct;
     }
   }
+  /**
+   * Runs the package's own setup step, once per package per host start, when `exe` is npm's placeholder
+   * and `install.cjs` is beside it (the step that was meant to put the program there; nothing else runs
+   * and nothing is fetched). Starts that arrive meanwhile wait for the same run. Never stops a process:
+   * a file a running Claude Code holds stays a placeholder and the message says so. Never rejects.
+   */
+  repair(exe) {
+    if (!this.enabled || !/\.exe$/i.test(exe)) return Promise.resolve();
+    let size2;
+    try {
+      size2 = this.fs.stat(exe).size;
+    } catch {
+      return Promise.resolve();
+    }
+    if (placeholderProblem(exe, size2, this.fs) === null) return Promise.resolve();
+    const installer = installerFor(exe, this.fs);
+    if (!installer) return Promise.resolve();
+    let run4 = this.repairs.get(installer);
+    if (!run4) {
+      run4 = this.runSetupStep(exe, installer).catch((err) => {
+        this.log(`[claude] the setup step could not be run: ${code(err)}`);
+        this.outcomes.set(installer, { note: `Centralu tried to run that setup step (\`node "${installer}"\`) and could not: ${code(err)}.`, unproven: null });
+      });
+      this.repairs.set(installer, run4);
+    }
+    return run4;
+  }
+  async runSetupStep(exe, installer) {
+    this.log(`[claude] ${exe} is npm's placeholder; running Claude Code's own setup step, ${installer}`);
+    const run4 = await this.fs.runInstaller(installer, this.opts.installerTimeoutMs ?? INSTALLER_TIMEOUT_MS);
+    const step = `Centralu ran that setup step itself (\`node "${installer}"\`)`;
+    const verdict = await this.proven(exe, installer);
+    if (verdict.ok) {
+      this.log(`[claude] repaired ${exe}`);
+      this.outcomes.set(installer, { note: `Centralu already ran that setup step once since it started (\`node "${installer}"\`) and does not run it again.`, unproven: null });
+      return;
+    }
+    const ran = run4.status === null ? run4.output : run4.status === 0 ? "" : `exit code ${run4.status}: ${firstLine3(run4.output)}`;
+    if (verdict.stat) {
+      this.log(`[claude] the setup step left ${verdict.stat.size} bytes at ${exe} that are not proven to be the program (${verdict.why})${ran ? `; ${ran}` : ""}`);
+      this.outcomes.set(installer, { note: `${step} and it did not finish the copy${ran ? `: ${ran}` : ""}.`, unproven: { ...verdict.stat, why: verdict.why } });
+    } else if (/\b(EBUSY|EPERM|EACCES)\b/.test(run4.output)) {
+      this.log(`[claude] the setup step could not replace ${exe}; a running program holds it: ${firstLine3(run4.output)}`);
+      this.outcomes.set(installer, { note: `${step} and the file is still a placeholder: it could not be replaced, usually because a running Claude Code held it.`, unproven: null });
+    } else {
+      const why2 = ran || firstLine3(run4.output) || "it left the placeholder in place";
+      this.log(`[claude] the setup step did not repair ${exe}: ${why2}`);
+      this.outcomes.set(installer, { note: `${step} and it did not repair the file: ${why2}.`, unproven: null });
+    }
+  }
+  /**
+   * Whether the file at `exe` is the program. Not "large enough": a copy cut by the time limit is large.
+   * It must be the size of the platform package's program it was made from; where that cannot be found,
+   * it must run `--version` and exit 0.
+   */
+  async proven(exe, installer) {
+    let stat12;
+    try {
+      stat12 = this.fs.stat(exe);
+    } catch {
+      return { ok: false, why: "the file is gone" };
+    }
+    if (placeholderProblem(exe, stat12.size, this.fs) !== null) return { ok: false, why: "it is still the placeholder" };
+    const native = this.fs.nativeSize(installer);
+    if (native !== null) return stat12.size === native ? { ok: true } : { ok: false, stat: stat12, why: `not the ${native} bytes of the Claude program it was copied from` };
+    const version2 = await this.fs.runProgram(exe, ["--version"], VERSION_TIMEOUT_MS);
+    return version2.status === 0 ? { ok: true } : { ok: false, stat: stat12, why: "it does not run (`--version` failed)" };
+  }
   use(key, path2) {
     if (key !== this.current) {
       this.current = key;
@@ -128823,7 +129428,7 @@ var ClaudeLinks = class {
     for (const name of names) {
       if (name === this.current || this.uses.has(name)) continue;
       try {
-        this.fs.removeDir(join41(this.base(), name));
+        this.fs.removeDir(join42(this.base(), name));
       } catch {
       }
     }
@@ -128837,6 +129442,10 @@ var ClaudeLinks = class {
     }
   }
 };
+function firstLine3(text3) {
+  const line = text3.split(/\r?\n/).find((l) => l.trim())?.trim() ?? "";
+  return line.length > 240 ? `${line.slice(0, 240)}...` : line;
+}
 function code(err) {
   return err?.code ?? err?.message ?? String(err);
 }
@@ -128960,7 +129569,7 @@ function contentBlocks(m) {
 }
 
 // packages/agent-host/src/adapters/images.ts
-import { readFile as readFile6, stat as stat8 } from "node:fs/promises";
+import { readFile as readFile7, stat as stat9 } from "node:fs/promises";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp"]);
 var startsWith = (buf, bytes2, at2 = 0) => bytes2.every((b2, i) => buf[at2 + i] === b2);
 function gifReachesTrailer(buf) {
@@ -129041,9 +129650,9 @@ async function imageEventFromDisk(sessionId, path2, maxBytes = IMAGE_MAX_BYTES)
   const file2 = path2.split(/[\\/]/).pop() ?? path2;
   const ext2 = file2.includes(".") ? file2.slice(file2.lastIndexOf(".") + 1).toLowerCase() : "";
   try {
-    const s = await stat8(path2);
+    const s = await stat9(path2);
     if (s.size > maxBytes) return fail4(tooLarge(s.size));
-    const buf = await readFile6(path2);
+    const buf = await readFile7(path2);
     const seen = judgeImage(buf);
     if (!seen) return fail4(!ext2 ? "the file is not a picture" : IMAGE_EXTENSIONS.has(ext2) ? `the file is not a valid .${ext2} image` : `the .${ext2} format cannot be shown`);
     if ("note" in seen) return fail4(seen.note);
@@ -129060,12 +129669,13 @@ function commandRunOf(name, input) {
   const run4 = centraluRunCommand(input);
   return run4 ? { name: name.slice(0, -"centralu_run".length) + run4.command, input: run4.args } : null;
 }
+var SHELL_TOOLS = /* @__PURE__ */ new Set(["Bash", "PowerShell"]);
 function toolSummary(name, input) {
   const run4 = commandRunOf(name, input);
   if (run4) return toolSummary(run4.name, run4.input);
   const paths = [];
   let title = name;
-  if (name === "Bash") title = str(input.command, name);
+  if (SHELL_TOOLS.has(name)) title = str(input.command, name);
   else if (FILE_EDIT_TOOLS.has(name) || name === "Read") {
     const p = str(input.file_path ?? input.notebook_path);
     if (p) paths.push(p);
@@ -129120,7 +129730,7 @@ ${content.replace(/\n$/, "")}` : "" };
 ${diff}` : diff };
 }
 function approvalDetail(name, input, cwd, isNew) {
-  if (name === "Bash") return { kind: "command", command: str(input.command), cwd, ...input.dangerouslyDisableSandbox === true ? { unsandboxed: true } : {} };
+  if (SHELL_TOOLS.has(name)) return { kind: "command", command: str(input.command), cwd, ...input.dangerouslyDisableSandbox === true ? { unsandboxed: true } : {} };
   if (FILE_EDIT_TOOLS.has(name)) {
     const change = claudeFileChange(name, input, isNew);
     return fileEditDetail([change.diff ? change : { ...change, diff: JSON.stringify(input) }]);
@@ -130452,16 +131062,16 @@ var ClaudeStreamNormalizer = class {
 
 // packages/agent-host/src/adapters/claude/lsp-plugins.ts
 init_sdk();
-import { access as access3, readFile as readFile7 } from "node:fs/promises";
+import { access as access3, readFile as readFile8 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 var KNOWN_LSP_PLUGINS = ["typescript-lsp@claude-plugins-official"];
 function claudeConfigDir(env = process.env, home = homedir10()) {
-  return env.CLAUDE_CONFIG_DIR || join42(home, ".claude");
+  return env.CLAUDE_CONFIG_DIR || join43(home, ".claude");
 }
 async function readJson2(path2) {
   try {
-    return JSON.parse(await readFile7(path2, "utf8"));
+    return JSON.parse(await readFile8(path2, "utf8"));
   } catch {
     return void 0;
   }
@@ -130472,22 +131082,22 @@ async function declaresLspServers(id3, configDir) {
   if (at2 <= 0) return false;
   const name = id3.slice(0, at2);
   const marketplace = id3.slice(at2 + 1);
-  const installed = await readJson2(join42(configDir, "plugins", "installed_plugins.json"));
+  const installed = await readJson2(join43(configDir, "plugins", "installed_plugins.json"));
   const entries = isObj(installed) && isObj(installed.plugins) ? installed.plugins[id3] : void 0;
   for (const entry of Array.isArray(entries) ? entries : []) {
     const path2 = isObj(entry) && typeof entry.installPath === "string" ? entry.installPath : null;
     if (!path2) continue;
-    if (declares(await readJson2(join42(path2, ".claude-plugin", "plugin.json")))) return true;
+    if (declares(await readJson2(join43(path2, ".claude-plugin", "plugin.json")))) return true;
     try {
-      await access3(join42(path2, ".lsp.json"));
+      await access3(join43(path2, ".lsp.json"));
       return true;
     } catch {
     }
   }
-  const known = await readJson2(join42(configDir, "plugins", "known_marketplaces.json"));
+  const known = await readJson2(join43(configDir, "plugins", "known_marketplaces.json"));
   const place = isObj(known) && isObj(known[marketplace]) ? known[marketplace].installLocation : void 0;
   if (typeof place !== "string") return false;
-  const listing = await readJson2(join42(place, ".claude-plugin", "marketplace.json"));
+  const listing = await readJson2(join43(place, ".claude-plugin", "marketplace.json"));
   const plugins = isObj(listing) && Array.isArray(listing.plugins) ? listing.plugins : [];
   return plugins.some((p) => isObj(p) && p.name === name && declares(p));
 }
@@ -130850,8 +131460,8 @@ var MidTurnLedger = class {
 import { resolve as resolve17 } from "node:path";
 
 // packages/agent-host/src/adapters/claude/new-file.ts
-import { stat as stat9 } from "node:fs/promises";
-async function newFile(path2, statOf = stat9) {
+import { stat as stat10 } from "node:fs/promises";
+async function newFile(path2, statOf = stat10) {
   const found = statOf(path2).then(
     () => false,
     (err) => err.code === "ENOENT" ? true : void 0
@@ -131378,7 +131988,7 @@ function tracksInputs(m) {
 
 // packages/agent-host/src/adapters/claude/surface.ts
 import { readFileSync as readFileSync16 } from "node:fs";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 
 // packages/agent-host/src/adapters/surface-drift.ts
 function compareSurface(surface, limitations, baseline) {
@@ -131871,8 +132481,8 @@ var CLAUDE_SURFACE = {
   async gather(env) {
     const sdk = await env.packageDir(SDK);
     return {
-      "package.json": readFileSync16(join43(sdk, "package.json"), "utf8"),
-      "sdk.d.ts": readFileSync16(join43(sdk, "sdk.d.ts"), "utf8"),
+      "package.json": readFileSync16(join44(sdk, "package.json"), "utf8"),
+      "sdk.d.ts": readFileSync16(join44(sdk, "sdk.d.ts"), "utf8"),
       "claude --version": await env.run("claude", ["--version"]),
       "claude --help": await env.run("claude", ["--help"])
     };
@@ -132075,7 +132685,7 @@ var ClaudeSession = class {
     const preset = this.opts.permissionPreset;
     this.cards.editAskRule = preset === "edits" || preset === "normal" ? await editAskRuleExists(this.opts) : true;
     const exe = this.launch.executable();
-    const run4 = exe ? this.launch.links.prepare(exe) : null;
+    const run4 = exe ? await this.launch.links.ensure(exe) : null;
     this.servers.load();
     const servers = this.servers.mcpServers();
     const permissionOptions = await permissionOptionsFor(this.opts);
@@ -132092,7 +132702,7 @@ var ClaudeSession = class {
         servers,
         permissionOptions,
         codeIntelligence,
-        spawn: (o) => this.opts.processSource ? this.spawnProcess(o) : this.proc = spawnLocalAgent(o),
+        spawn: (o) => this.opts.processSource ? this.spawnProcess(o) : this.proc = tapSessionProcess(spawnLocalAgent(o), this.sessionId),
         canUseTool: (toolName, toolInput, options) => this.cards.canUseTool(preset, toolName, toolInput, options),
         hooks: requestTurnHooks(this.opts, () => this.servers.orchestratorServer !== null)
       })
@@ -132271,7 +132881,7 @@ var ClaudeSession = class {
     const src = this.opts.processSource;
     const adopt = src.adopt && !this.adopted ? src.adopt.process : null;
     this.adopted = true;
-    this.proc = adopt ?? src.spawn({ command: o.command, args: o.args, cwd: o.cwd, env: o.env });
+    this.proc = tapSessionProcess(adopt ?? src.spawn({ command: o.command, args: o.args, cwd: o.cwd, env: o.env }), this.sessionId);
     return this.proc;
   }
   /**
@@ -132569,7 +133179,7 @@ var ClaudeSession = class {
 };
 
 // packages/agent-host/src/adapters/claude/index.ts
-var exec4 = promisify4(execFile5);
+var exec4 = promisify4(execFile6);
 var PROBE_USAGE_MS = 2e4;
 var PROBE_USAGE_RETRY_MS = 500;
 var ACCOUNT_CACHE_MS = 6e4;
@@ -132597,10 +133207,10 @@ async function claudeLoggedIn(bin) {
 async function sweepProbeDirs(now = Date.now()) {
   try {
     const root3 = tmpdir4();
-    for (const name of await readdir11(root3)) {
+    for (const name of await readdir12(root3)) {
       if (!name.startsWith(PROBE_DIR_PREFIX)) continue;
-      const path2 = join44(root3, name);
-      const old = await stat10(path2).then((s) => now - s.mtimeMs > PROBE_DIR_STALE_MS, () => false);
+      const path2 = join45(root3, name);
+      const old = await stat11(path2).then((s) => now - s.mtimeMs > PROBE_DIR_STALE_MS, () => false);
       if (old) await rm9(path2, { recursive: true, force: true }).catch(() => {
       });
     }
@@ -132708,7 +133318,7 @@ var ClaudeAdapter = class _ClaudeAdapter {
     try {
       let launch2;
       try {
-        launch2 = this.statusLaunch();
+        launch2 = await this.statusLaunch();
       } catch (err) {
         if (!(err instanceof ClaudePlaceholderError)) throw err;
         return { tool: "claude", installed: false, loggedIn: false, detail: err.message };
@@ -132791,7 +133401,7 @@ var ClaudeAdapter = class _ClaudeAdapter {
       this.swept = true;
       await sweepProbeDirs();
     }
-    const dir = await mkdtemp4(join44(tmpdir4(), PROBE_DIR_PREFIX));
+    const dir = await mkdtemp4(join45(tmpdir4(), PROBE_DIR_PREFIX));
     const sessionId = `usage-probe-${randomUUID23()}`;
     _ClaudeAdapter.probeIds.add(sessionId);
     let probe = null;
@@ -132829,7 +133439,7 @@ var ClaudeAdapter = class _ClaudeAdapter {
     if (this.accountCache && Date.now() - this.accountCache.at < ACCOUNT_CACHE_MS) return this.accountCache.value;
     let value;
     try {
-      const status = await claudeAuthStatus(this.statusLaunch());
+      const status = await claudeAuthStatus(await this.statusLaunch());
       const flag = status?.loggedIn;
       value = { loggedIn: typeof flag === "boolean" ? flag : null, fingerprint: accountFingerprint(status) };
     } catch {
@@ -132840,9 +133450,9 @@ var ClaudeAdapter = class _ClaudeAdapter {
   }
   accountCache = null;
   /** The program the sign-in is asked of: what sessions start (on Windows the link), else the one on PATH */
-  statusLaunch() {
+  async statusLaunch() {
     const exe = this.launch.windows ? this.launch.executable() : null;
-    if (exe && /\.exe$/i.test(exe)) return { command: this.launch.links.prepare(exe).path, args: [] };
+    if (exe && /\.exe$/i.test(exe)) return { command: (await this.launch.links.ensure(exe)).path, args: [] };
     return launchFor2(toolCommand("claude"));
   }
   async listModels() {
@@ -132875,13 +133485,13 @@ var ClaudeAdapter = class _ClaudeAdapter {
 };
 
 // packages/agent-host/src/adapters/codex/index.ts
-import { execFile as execFile6 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join48 } from "node:path";
+import { join as join49 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // packages/agent-host/src/adapters/codex/client.ts
-import { randomBytes as randomBytes10 } from "node:crypto";
+import { randomBytes as randomBytes11 } from "node:crypto";
 
 // packages/agent-host/src/adapters/codex/native.ts
 import { existsSync as existsSync20, readFileSync as readFileSync17, realpathSync as realpathSync8 } from "node:fs";
@@ -133010,7 +133620,7 @@ var CodexClient = class {
    * with plain counters both hosts would have sent `1`, `2`, … and an old answer would resolve a new
    * request. codex echoes string ids back as given.
    */
-  idPrefix = `${randomBytes10(3).toString("hex")}-`;
+  idPrefix = `${randomBytes11(3).toString("hex")}-`;
   pending = new PendingRequests();
   closed = false;
   /** A flag to call onExit only once (both 'error' and 'exit' can fire) */
@@ -133107,24 +133717,24 @@ async function withCodexClient(opts, fn2) {
 
 // packages/agent-host/src/adapters/codex/home.ts
 import { homedir as homedir11 } from "node:os";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 function codexHome(env = process.env, home = homedir11()) {
   const custom2 = env.CODEX_HOME?.trim();
-  return custom2 ? custom2 : join45(home, ".codex");
+  return custom2 ? custom2 : join46(home, ".codex");
 }
 
 // packages/agent-host/src/adapters/codex/rollout.ts
 import { createReadStream as createReadStream5 } from "node:fs";
-import { readdir as readdir12 } from "node:fs/promises";
-import { join as join46 } from "node:path";
+import { readdir as readdir13 } from "node:fs/promises";
+import { join as join47 } from "node:path";
 var MIN_SUMMARY_CHARS = 200;
-async function findRolloutPath(threadId, sessionsDir = join46(codexHome(), "sessions")) {
+async function findRolloutPath(threadId, sessionsDir = join47(codexHome(), "sessions")) {
   try {
     const suffix = `-${threadId}.jsonl`;
-    const names = await readdir12(sessionsDir, { recursive: true });
+    const names = await readdir13(sessionsDir, { recursive: true });
     const hits = names.filter((n) => String(n).endsWith(suffix)).sort();
     const hit = hits[hits.length - 1];
-    return hit ? join46(sessionsDir, String(hit)) : null;
+    return hit ? join47(sessionsDir, String(hit)) : null;
   } catch {
     return null;
   }
@@ -133602,7 +134212,7 @@ function normalizeNotification(sessionId, n) {
      * exactly the lie we are trying to fix. The same rule the Claude adapter uses for `result`.
      *
      * An interrupted turn is not a finished one either (#698). It went out as `turn_complete`, so a turn Codex cut
-     * short told the orchestrator that gave it "The assigned work finished". It ends as the person's Stop ends a turn,
+     * short told the orchestrator that gave it that the work was done ("finished", as the report then read). It ends as the person's Stop ends a turn,
      * `waiting_input` with `interrupted`; the adapter tells a Stop of ours from an interrupt it did not ask for
      * (`INTERRUPTED_BY_TOOL`).
      */
@@ -135627,7 +136237,7 @@ var CodexSession = class {
 
 // packages/agent-host/src/adapters/codex/surface.ts
 import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 
 // packages/agent-host/src/adapters/codex/surface-baseline.ts
 var SURFACE_BASELINE2 = {
@@ -135945,7 +136555,7 @@ var CODEX_SURFACE = {
       "codex --version": await env.run("codex", ["--version"]),
       "codex --help": await env.run("codex", ["--help"])
     };
-    for (const f of FILES) inputs[f] = readFileSync18(join47(out, f), "utf8");
+    for (const f of FILES) inputs[f] = readFileSync18(join48(out, f), "utf8");
     return inputs;
   },
   read: readCodexSurface,
@@ -135954,7 +136564,7 @@ var CODEX_SURFACE = {
 };
 
 // packages/agent-host/src/adapters/codex/index.ts
-var exec5 = promisify5(execFile6);
+var exec5 = promisify5(execFile7);
 var CODEX_VERBOSITIES = ["low", "medium", "high"];
 var CodexAdapter = class {
   tool = "codex";
@@ -136013,7 +136623,7 @@ var CodexAdapter = class {
       const launch2 = launchFor2(path2 ?? toolCommand("codex"));
       const { stdout } = await exec5(launch2.command, [...launch2.args, "--version"], { timeout: 5e3, windowsHide: true });
       const version2 = `${stdout.trim()} \xB7 ${path2 ?? "PATH"}`;
-      const loggedIn = existsSync21(join48(codexHome(), "auth.json"));
+      const loggedIn = existsSync21(join49(codexHome(), "auth.json"));
       return {
         tool: "codex",
         installed: true,
@@ -136116,12 +136726,12 @@ var CodexAdapter = class {
 };
 
 // packages/agent-host/src/adapters/cursor-agent/index.ts
-import { execFile as execFile8 } from "node:child_process";
+import { execFile as execFile9 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
 
 // packages/agent-host/src/adapters/cursor-agent/install.ts
 import { existsSync as existsSync22, readdirSync as readdirSync14, realpathSync as realpathSync10 } from "node:fs";
-import { dirname as dirname22, join as join49, win32 as win327 } from "node:path";
+import { dirname as dirname22, join as join50, win32 as win327 } from "node:path";
 var realFs = {
   exists: existsSync22,
   list: (dir) => {
@@ -136173,15 +136783,15 @@ function findCursor(env = process.env, platform, fs3 = realFs) {
     const real3 = fs3.real(found);
     const dir = dirname22(real3);
     const version2 = dir.split(/[\\/]/).pop() ?? "";
-    if (VERSION.test(version2) && fs3.exists(join49(dir, "index.js"))) return { version: version2, command: real3, args: [], env: {} };
+    if (VERSION.test(version2) && fs3.exists(join50(dir, "index.js"))) return { version: version2, command: real3, args: [], env: {} };
   }
   return null;
 }
 
 // packages/agent-host/src/adapters/cursor-agent/surface.ts
-import { execFile as execFile7 } from "node:child_process";
+import { execFile as execFile8 } from "node:child_process";
 import { readdirSync as readdirSync15, readFileSync as readFileSync19 } from "node:fs";
-import { dirname as dirname23, join as join50 } from "node:path";
+import { dirname as dirname23, join as join51 } from "node:path";
 import { promisify as promisify6 } from "node:util";
 
 // packages/agent-host/src/adapters/cursor-agent/surface-baseline.ts
@@ -136241,7 +136851,7 @@ var SURFACE_BASELINE3 = {
 };
 
 // packages/agent-host/src/adapters/cursor-agent/surface.ts
-var exec6 = promisify6(execFile7);
+var exec6 = promisify6(execFile8);
 async function gather2() {
   const install = findCursor();
   if (!install) throw new Error("Cursor CLI is not installed on this machine (https://cursor.com/install)");
@@ -136251,7 +136861,7 @@ async function gather2() {
   const dir = dirname23(install.args[0] ?? install.command);
   const names = /* @__PURE__ */ new Set();
   for (const f of readdirSync15(dir).filter((n) => n.endsWith(".js"))) {
-    const text3 = readFileSync19(join50(dir, f), "utf8");
+    const text3 = readFileSync19(join51(dir, f), "utf8");
     if (!text3.includes("session/request_permission") && !text3.includes("cursor_login")) continue;
     for (const m of text3.matchAll(/sessionUpdate:"([a-z_]+)"|"(cursor\/[a-z_]+)"/g)) {
       const name = m[1] ?? m[2];
@@ -136435,7 +137045,7 @@ function cursorUsageReader(run4, now = Date.now) {
 }
 
 // packages/agent-host/src/adapters/cursor-agent/index.ts
-var exec7 = promisify7(execFile8);
+var exec7 = promisify7(execFile9);
 var CAPABILITIES2 = {
   ...ACP_CAPABILITIES,
   contextUsage: "none",
@@ -136499,24 +137109,24 @@ var CursorAgentAdapter = class extends AcpAdapter {
 };
 
 // packages/agent-host/src/adapters/opencode/index.ts
-import { execFile as execFile10 } from "node:child_process";
+import { execFile as execFile11 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
 
 // packages/agent-host/src/adapters/opencode/config-files.ts
 import { existsSync as existsSync23, readdirSync as readdirSync16, readFileSync as readFileSync20 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import { dirname as dirname24, extname as extname3, join as join51, relative as relative6 } from "node:path";
+import { dirname as dirname24, extname as extname3, join as join52, relative as relative6 } from "node:path";
 function readOpenCodeConfigs(cwd, env, home = homedir15()) {
-  const global2 = join51(env.XDG_CONFIG_HOME || join51(home, ".config"), "opencode");
+  const global2 = join52(env.XDG_CONFIG_HOME || join52(home, ".config"), "opencode");
   const project2 = !env.OPENCODE_DISABLE_PROJECT_CONFIG;
   const upward = project2 ? foldersUp(cwd) : [];
-  const dotFolders = [...upward.map((d2) => join51(d2, ".opencode")), join51(home, ".opencode"), ...env.OPENCODE_CONFIG_DIR ? [env.OPENCODE_CONFIG_DIR] : []];
+  const dotFolders = [...upward.map((d2) => join52(d2, ".opencode")), join52(home, ".opencode"), ...env.OPENCODE_CONFIG_DIR ? [env.OPENCODE_CONFIG_DIR] : []];
   const files2 = [
-    ...["config.json", "opencode.json", "opencode.jsonc"].map((f) => join51(global2, f)),
+    ...["config.json", "opencode.json", "opencode.jsonc"].map((f) => join52(global2, f)),
     ...env.OPENCODE_CONFIG ? [env.OPENCODE_CONFIG] : [],
-    ...upward.flatMap((d2) => CONFIG_NAMES.map((f) => join51(d2, f))),
-    ...dotFolders.flatMap((d2) => CONFIG_NAMES.map((f) => join51(d2, f))),
-    ...CONFIG_NAMES.map((f) => join51(managedFolder(env), f))
+    ...upward.flatMap((d2) => CONFIG_NAMES.map((f) => join52(d2, f))),
+    ...dotFolders.flatMap((d2) => CONFIG_NAMES.map((f) => join52(d2, f))),
+    ...CONFIG_NAMES.map((f) => join52(managedFolder(env), f))
   ];
   return {
     layers: files2.map(readConfig).filter((c) => c !== null),
@@ -136528,7 +137138,7 @@ function foldersUp(cwd) {
   const out = [];
   for (let d2 = cwd; ; d2 = dirname24(d2)) {
     out.push(d2);
-    if (existsSync23(join51(d2, ".git")) || dirname24(d2) === d2) return out;
+    if (existsSync23(join52(d2, ".git")) || dirname24(d2) === d2) return out;
   }
 }
 function managedFolder(env) {
@@ -136570,13 +137180,13 @@ function stringEnd(text3, start3) {
   return text3.length;
 }
 function agentNames(folder) {
-  const named = (sub, deep) => markdown(join51(folder, sub), deep).map((f) => relative6(join51(folder, sub), f).replaceAll("\\", "/").slice(0, -extname3(f).length));
+  const named = (sub, deep) => markdown(join52(folder, sub), deep).map((f) => relative6(join52(folder, sub), f).replaceAll("\\", "/").slice(0, -extname3(f).length));
   return [...named("agent", true), ...named("agents", true), ...named("mode", false), ...named("modes", false)];
 }
 function markdown(folder, deep) {
   try {
     return readdirSync16(folder, { withFileTypes: true }).flatMap((e) => {
-      const path2 = join51(folder, e.name);
+      const path2 = join52(folder, e.name);
       if (e.isDirectory()) return deep ? markdown(path2, deep) : [];
       return e.name.endsWith(".md") ? [path2] : [];
     });
@@ -136705,7 +137315,7 @@ function openCodeRefusal(line, conversation) {
 }
 
 // packages/agent-host/src/adapters/opencode/surface.ts
-import { execFile as execFile9 } from "node:child_process";
+import { execFile as execFile10 } from "node:child_process";
 import { readFileSync as readFileSync21 } from "node:fs";
 import { promisify as promisify8 } from "node:util";
 
@@ -136762,7 +137372,7 @@ var SURFACE_BASELINE4 = {
 };
 
 // packages/agent-host/src/adapters/opencode/surface.ts
-var exec8 = promisify8(execFile9);
+var exec8 = promisify8(execFile10);
 async function gather3() {
   const install = findOpenCode();
   if (!install) throw new Error("OpenCode is not installed on this machine (npm i -g opencode-ai)");
@@ -136905,7 +137515,7 @@ function openCodeUsageReader(run4, now = Date.now) {
 }
 
 // packages/agent-host/src/adapters/opencode/index.ts
-var exec9 = promisify9(execFile10);
+var exec9 = promisify9(execFile11);
 var CAPABILITIES3 = {
   ...ACP_CAPABILITIES
 };
@@ -137078,7 +137688,7 @@ var ApprovalRules = class {
 };
 
 // packages/agent-host/src/sessions/project-registry.ts
-import { basename as basename12 } from "node:path";
+import { basename as basename13 } from "node:path";
 var ProjectRegistry = class {
   constructor(host) {
     this.host = host;
@@ -137132,7 +137742,7 @@ var ProjectRegistry = class {
     return {
       id: id3,
       path: path2,
-      name: basename12(path2),
+      name: basename13(path2),
       defaultTool: this.host.firstTool(stored),
       // Trust (M4, decision 3) — reads the same column as the app runtime. The trust toggle on screen shows
       // this value
@@ -137401,11 +138011,11 @@ var SessionLayout = class {
 // packages/agent-host/src/sessions/linked-reports.ts
 var ADD_NEXT_MS = 15e3;
 function partOf(turn) {
-  return turn.wrote || turn.added ? { ...turn.wrote ? { wrote: true } : {}, ...turn.added ? { added: true } : {} } : void 0;
+  return turn.wrote || turn.added || turn.cut ? { ...turn.wrote ? { wrote: true } : {}, ...turn.added ? { added: true } : {}, ...turn.cut ? { cut: true } : {} } : void 0;
 }
 function saidTurn(raw) {
   if (typeof raw !== "object" || raw === null || !("by" in raw) || raw.by !== "person" && raw.by !== "work") return void 0;
-  return { by: raw.by, ..."wrote" in raw && raw.wrote === true ? { wrote: true } : {}, ..."added" in raw && raw.added === true ? { added: true } : {} };
+  return { by: raw.by, ..."wrote" in raw && raw.wrote === true ? { wrote: true } : {}, ..."added" in raw && raw.added === true ? { added: true } : {}, ..."cut" in raw && raw.cut === true ? { cut: true } : {} };
 }
 function fromHub(from) {
   const id3 = from?.sessionId;
@@ -137493,7 +138103,7 @@ var LinkedReports = class {
       wait.paused = [...held3, ...running2.filter((t) => !held3.some((h) => h.id === t.id))];
       wait.busy = false;
       this.host.children.setLinkedReport(sessionId, wait);
-      if (!told) void this.report(sessionId, wait.orchestratorId, e, { paused: running2, stoppable: false }, void 0, partOf(turn));
+      if (!told) void this.report(sessionId, wait.orchestratorId, e, { paused: running2, stoppable: false }, void 0, partOf(turn), false, wait);
       return;
     }
     this.drop(sessionId);
@@ -137688,7 +138298,7 @@ var LinkedReports = class {
         continue;
       }
       this.drop(sessionId);
-      void this.report(sessionId, wait.orchestratorId, { type: "turn_complete" }, { linkLost: name, paused: wait.paused });
+      void this.report(sessionId, wait.orchestratorId, { type: "turn_complete" }, { linkLost: name, paused: wait.paused }, void 0, void 0, false, wait);
     }
     for (const sessionId of [...this.tasks.keys()]) if (sessionId.startsWith(prefix)) this.forget(sessionId);
   }
@@ -137724,23 +138334,25 @@ var LinkedReports = class {
       if (!sessionId.startsWith(prefix)) continue;
       const about = this.about.get(sessionId);
       this.drop(sessionId);
-      void this.report(sessionId, wait.orchestratorId, { type: "turn_complete" }, { machineRemoved: name, ...wait.paused ? { paused: wait.paused } : {} }, about);
+      void this.report(sessionId, wait.orchestratorId, { type: "turn_complete" }, { machineRemoved: name, ...wait.paused ? { paused: wait.paused } : {} }, about, void 0, false, wait);
     }
     for (const sessionId of [...this.tasks.keys()]) if (sessionId.startsWith(prefix)) this.forget(sessionId);
     this.machineNames.delete(machineId);
   }
-  async report(sessionId, orchestratorId, ending, work, known, part, theirs = false) {
+  async report(sessionId, orchestratorId, ending, work, known, part, theirs = false, wait) {
     const reader = this.host.linkedReader;
     if (!reader || !this.host.hasSession(orchestratorId)) return;
     const about = reader.describe(sessionId) ?? known ?? this.about.get(sessionId) ?? { name: sessionId, project: "(unknown)" };
     const unreachable = work && ("linkLost" in work || "machineRemoved" in work);
+    const kept = unreachable && work && "paused" in work && work.paused ? wait?.read : void 0;
     if (!unreachable && this.gate(sessionId) !== "deliver") return;
     const tookOver = !!work && "tookOver" in work || theirs;
     const since = turnSince(ending);
     const words = unreachable || tookOver ? null : await reader.lastWords(sessionId, 600, { turn: true, ...since !== void 0 ? { since } : {} }).catch((e) => ({ ok: false, error: e.message }));
-    const preview = theirs && !(work && "tookOver" in work) ? "(not read: the last turn there was the person's; read_session shows it)" : tookOver ? "(not read: the conversation there is the person's now; read_session shows it)" : !words ? work && "paused" in work && work.paused ? "(in the paused report before this one)" : "(not read: its machine could not be reached)" : words.ok ? words.text === "" ? NO_WORDS : words.text : `(its last response could not be read there: ${words.error})`;
-    const seq = words?.ok && words.seq !== null ? words.seq : void 0;
-    await this.host.deliverReport(orchestratorId, sessionId, about.name, about.project, preview, ending, work, seq, part);
+    const preview = theirs && !(work && "tookOver" in work) ? "(not read: the last turn there was the person's; read_session shows it)" : tookOver ? "(not read: the conversation there is the person's now; read_session shows it)" : !words ? kept ? clipPreview(kept.preview, 600) : work && "paused" in work && work.paused ? IN_PAUSE_REPORT : MACHINE_UNREACHABLE : words.ok ? words.text === "" ? NO_WORDS : words.text : `(its last response could not be read there: ${words.error})`;
+    if (wait && words?.ok && words.text !== "" && work && "paused" in work && "stoppable" in work) wait.read = { preview: words.text, seq: words.seq ?? void 0 };
+    const seq = words?.ok ? words.seq ?? void 0 : kept?.seq;
+    await this.host.deliverReport(orchestratorId, sessionId, about.name, about.project, preview, ending, kept && unreachable ? { ...work, asRead: true } : work, seq, part);
   }
 };
 
@@ -138627,7 +139239,7 @@ var UsageRecorder = class {
   }
   /** Counts one request in its hour's bucket, in memory until the next flush */
   request(src, r, counted, at2 = this.now()) {
-    const hour = Math.floor(at2 / HOUR_MS) * HOUR_MS;
+    const hour = Math.floor(at2 / HOUR_MS2) * HOUR_MS2;
     const projectId = src.projectId ?? "";
     const model = r.model || src.model || "";
     const id3 = [hour, src.sessionId, projectId, src.tool, model].join("\n");
@@ -138697,10 +139309,10 @@ var UsageRecorder = class {
   /** Drops what is older than the keeping time. Once a day at most unless `force` */
   prune(force = false) {
     const now = this.now();
-    if (!force && now - this.lastPrune < 24 * HOUR_MS) return;
+    if (!force && now - this.lastPrune < 24 * HOUR_MS2) return;
     this.lastPrune = now;
     try {
-      this.usage.prune(now - KEEP_DAYS * 24 * HOUR_MS);
+      this.usage.prune(now - KEEP_DAYS * 24 * HOUR_MS2);
     } catch (err) {
       console.error(`[usage] could not prune: ${errorMessage(err)}`);
     }
@@ -138747,7 +139359,7 @@ var UsageRecorder = class {
 
 // packages/agent-host/src/sessions/manager.ts
 import { homedir as homedir17 } from "node:os";
-import { join as join54 } from "node:path";
+import { join as join55 } from "node:path";
 
 // packages/agent-host/src/dev-services/store.ts
 import Database4 from "better-sqlite3";
@@ -143445,6 +144057,105 @@ var Store = class extends MigrationRunner {
 };
 var WAL_SIZE_LIMIT = 64 * 1024 * 1024;
 
+// packages/agent-host/src/lifecycle/system-end.ts
+var SYSTEM_END_FILE = "system-end.json";
+var SystemEndNotice = class {
+  constructor(o) {
+    this.o = o;
+  }
+  o;
+  at = null;
+  /** Which notice an expiry belongs to: a later one is not called off by an earlier one's timer */
+  notices = 0;
+  closed = false;
+  /** The system said it is ending, at `at` */
+  notice(at2 = (this.o.now ?? Date.now)()) {
+    if (this.at !== null) return;
+    this.at = at2;
+    const n = ++this.notices;
+    this.flush();
+    const setTimer = this.o.setTimer ?? ((f, ms3) => void setTimeout(f, ms3).unref());
+    setTimer(() => {
+      if (this.notices !== n || this.at === null) return;
+      this.o.outlived?.();
+      this.cancel();
+    }, SYSTEM_END_TAIL_MS);
+  }
+  /** The end was called off (Windows: another app refused it) */
+  cancel() {
+    if (this.at === null) return;
+    this.at = null;
+    this.flush();
+  }
+  close() {
+    this.closed = true;
+  }
+  flush() {
+    if (!this.closed) this.o.write(this.at === null ? null : { at: this.at });
+  }
+};
+function parseSystemEnd(text3) {
+  let r;
+  try {
+    r = JSON.parse(text3);
+  } catch {
+    return null;
+  }
+  if (typeof r !== "object" || r === null || !("v" in r) || r.v !== 1 || !("at" in r) || typeof r.at !== "number") return null;
+  return { at: r.at };
+}
+var systemEndText = (end) => `${JSON.stringify({ v: 1, at: end.at })}
+`;
+var SYSTEM_END_LEAD_MS = 3e4;
+var SYSTEM_END_TAIL_MS = 2 * 6e4;
+var inSystemEnd = (end, ts) => !!end && ts >= end.at - SYSTEM_END_LEAD_MS && ts <= end.at + SYSTEM_END_TAIL_MS;
+var cutBySystemEnd = (end, lastTs) => !!end && (lastTs === void 0 || lastTs <= end.at + SYSTEM_END_TAIL_MS);
+function errorCodeOf(payload) {
+  if (typeof payload !== "object" || payload === null || !("type" in payload) || payload.type !== "error") return void 0;
+  const error51 = "error" in payload ? payload.error : void 0;
+  return typeof error51 === "object" && error51 !== null && "code" in error51 && typeof error51.code === "string" ? error51.code : "";
+}
+function crashedInSystemEnd(s, rows3, end) {
+  if (s.state !== "error" || !end) return false;
+  const last = rows3.findLast((r) => {
+    const code2 = errorCodeOf(r.payload);
+    return code2 !== void 0 && code2 !== "internal";
+  });
+  return !!last && errorCodeOf(last.payload) === "adapter_crashed" && inSystemEnd(end, last.ts);
+}
+function askSystemStopping(o = {}) {
+  const queries = (o.queries === void 0 ? systemStoppingQueries() : o.queries) ?? [];
+  const children = /* @__PURE__ */ new Set();
+  const end = () => {
+    for (const child of children) child.kill("SIGKILL");
+    children.clear();
+  };
+  if (queries.length === 0) return { stopping: null, end };
+  const timeoutMs = o.timeoutMs ?? 1e3;
+  const run4 = o.run ?? ((command, args, options) => realOs().processes.run(command, args, options));
+  const stopping = new Promise((resolve20) => {
+    let left = queries.length;
+    const answered = (yes) => {
+      if (yes) resolve20(true);
+      else if (--left === 0) resolve20(false);
+    };
+    for (const [command, ...args] of queries) {
+      if (command === void 0) {
+        answered(false);
+        continue;
+      }
+      run4(command, args, { timeoutMs, onChild: (child) => void children.add(child) }).then(
+        (r) => answered(String(r.stdout).trim() === "stopping"),
+        () => answered(false)
+      );
+    }
+    setTimeout(() => resolve20(false), timeoutMs).unref();
+  });
+  stopping.finally(end).catch(() => {
+  });
+  return { stopping, end };
+}
+
 // packages/agent-host/src/lifecycle/update-ended.ts
 var ENDED_MAX_AGE_MS = 10 * 6e4;
 var MAX_ENTRIES2 = 100;
@@ -143841,8 +144552,8 @@ async function gitBranchPr(projectCwd, branch, signal, timeoutMs = OK2.timeout)
 }
 
 // packages/agent-host/src/dev-services/file-search.ts
-import { readdir as readdir13 } from "node:fs/promises";
-import { join as join52 } from "node:path";
+import { readdir as readdir14 } from "node:fs/promises";
+import { join as join53 } from "node:path";
 var MAX_FILES2 = 2e4;
 var TTL_MS2 = 15e3;
 var WALK_DEPTH = 6;
@@ -143872,7 +144583,7 @@ async function walk(root3) {
     const { dir, rel, depth } = next;
     let entries;
     try {
-      entries = await readdir13(dir, { withFileTypes: true });
+      entries = await readdir14(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -143880,7 +144591,7 @@ async function walk(root3) {
       if (e.name.startsWith(".") && e.name !== ".env") continue;
       if (e.isDirectory()) {
         if (SKIP.has(e.name) || depth >= WALK_DEPTH) continue;
-        queue.push({ dir: join52(dir, e.name), rel: wireJoin(rel, e.name), depth: depth + 1 });
+        queue.push({ dir: join53(dir, e.name), rel: wireJoin(rel, e.name), depth: depth + 1 });
       } else {
         out.push(wireJoin(rel, e.name).normalize("NFC"));
         if (out.length >= MAX_FILES2) break;
@@ -145065,14 +145776,14 @@ async function readMessageImage(abs, max = IMAGE_PREVIEW_MAX_BYTES) {
 }
 
 // packages/agent-host/src/dev-services/attachments.ts
-import { lstat as lstat11, mkdir as mkdir8, readdir as readdir14, rm as rm10, writeFile as writeFile6 } from "node:fs/promises";
-import { extname as extname4, join as join53 } from "node:path";
-var root2 = () => join53(dataRoot(), "attachments");
+import { lstat as lstat11, mkdir as mkdir9, readdir as readdir15, rm as rm10, writeFile as writeFile6 } from "node:fs/promises";
+import { extname as extname4, join as join54 } from "node:path";
+var root2 = () => join54(dataRoot(), "attachments");
 function sessionDir(sessionId) {
   if (!isSessionId(sessionId)) {
     throw rpcError(`Not a session id: ${sessionId}`);
   }
-  return join53(root2(), sessionId);
+  return join54(root2(), sessionId);
 }
 var EXT = {
   "image/png": ".png",
@@ -145082,9 +145793,9 @@ var EXT = {
 };
 async function saveAttachment(sessionId, name, mime, dataBase64) {
   const dir = sessionDir(sessionId);
-  await mkdir8(dir, { recursive: true });
+  await mkdir9(dir, { recursive: true });
   const ext2 = extname4(name) || EXT[mime] || "";
-  const file2 = join53(dir, `${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext2}`);
+  const file2 = join54(dir, `${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext2}`);
   const buf = Buffer.from(dataBase64, "base64");
   await writeFile6(file2, buf);
   return { kind: mime.startsWith("image/") ? "image" : "file", path: file2, name, mime, bytes: buf.length };
@@ -145100,15 +145811,15 @@ async function sweepAttachments(maxBytes = ATTACHMENTS_MAX_BYTES) {
   const files2 = [];
   let dirs;
   try {
-    dirs = await readdir14(root2());
+    dirs = await readdir15(root2());
   } catch {
     return 0;
   }
   for (const d2 of dirs) {
-    const dir = join53(root2(), d2);
-    const names = await readdir14(dir).catch(() => []);
+    const dir = join54(root2(), d2);
+    const names = await readdir15(dir).catch(() => []);
     for (const name of names) {
-      const p = join53(dir, name);
+      const p = join54(dir, name);
       const s = await lstat11(p).catch(() => null);
       if (s?.isFile()) files2.push({ path: p, size: s.size, mtime: s.mtimeMs });
     }
@@ -146061,7 +146772,7 @@ async function gitStatusForApp(summary, files2) {
 }
 
 // packages/agent-host/src/sessions/session-trash.ts
-import { basename as basename13 } from "node:path";
+import { basename as basename14 } from "node:path";
 import { rm as rm11 } from "node:fs/promises";
 import { existsSync as existsSync26, statSync as statSync16 } from "node:fs";
 var SessionTrash = class {
@@ -146438,7 +147149,7 @@ var SessionTrash = class {
           this.host.store.projects.addProject({
             id: record2.projectId,
             path: record2.projectPath,
-            name: record2.projectName ?? basename13(record2.projectPath)
+            name: record2.projectName ?? basename14(record2.projectPath)
           });
           projectId = record2.projectId;
           registered = await this.host.projectInfo(projectId, record2.projectPath);
@@ -146811,7 +147522,7 @@ function stands(o, proto) {
   return Object.getPrototypeOf(o) === proto;
 }
 var SessionManager = class {
-  constructor(store2, adapters2, emit, endpoint, worktreeRoot = join54(homedir17(), DATA_DIR, "worktrees"), keeperOpts = {}) {
+  constructor(store2, adapters2, emit, endpoint, worktreeRoot = join55(homedir17(), DATA_DIR, "worktrees"), keeperOpts = {}) {
     this.store = store2;
     this.adapters = adapters2;
     this.emit = emit;
@@ -146943,16 +147654,21 @@ var SessionManager = class {
       const cut3 = turnCut(s) && !keeperOpts.keptSessions?.has(s.id);
       const goesOn = cut3 && !!lists?.cut(s.id, s.lastSeq);
       const stale = cut3 && !goesOn;
-      const fixed = stale ? { ...s, state: "idle", waitingSince: null } : goesOn ? { ...s, state: "working", waitingSince: null } : s;
+      const end = keeperOpts.systemEnd;
+      const recent = end && (stale || s.state === "error") ? store2.messages.loadMessages(s.id, 20) : [];
+      const crashedAtEnd = !cut3 && crashedInSystemEnd(s, recent, end);
+      const lost = stale || crashedAtEnd;
+      const bySystem = crashedAtEnd || stale && cutBySystemEnd(end, recent.at(-1)?.ts);
+      const fixed = lost ? { ...s, state: "idle", waitingSince: null } : goesOn ? { ...s, state: "working", waitingSince: null } : s;
       this.meta.set(s.id, withHubMark(store2.settings, fixed));
-      if (stale) {
-        console.error(`[agent-host] stale state reset: ${s.id.slice(0, 8)} ${s.state} -> idle`);
-        this.interruptions.markStoppedByQuit(fixed, false);
+      if (lost) {
+        console.error(`[agent-host] stale state reset: ${s.id.slice(0, 8)} ${s.state} -> idle${bySystem ? " (the system was ending)" : ""}`);
+        this.interruptions.markTurnLost(fixed, false, bySystem ? "shutdown" : "quit");
         store2.sessions.upsertSession(fixed);
         cutTurns2.set(s.id, this.children.processGone(s.id));
         stoppedByQuit.push(fixed);
       }
-      const stopped = stale ? null : lists?.stoppedOf(s.id, s.lastSeq) ?? null;
+      const stopped = lost ? null : lists?.stoppedOf(s.id, s.lastSeq) ?? null;
       if (stopped) stoppedBy.set(s.id, stopped);
       if (goesOn) {
         console.error(`[agent-host] ${s.id.slice(0, 8)}: an update of this machine ended its turn; continuing it`);
@@ -146974,8 +147690,8 @@ var SessionManager = class {
     }
     const cutIds = new Set(cutByUpdate.map((s) => s.id));
     this.updateCuts = [
-      ...cutByUpdate.map((s) => ({ sessionId: s.id, requester: requesterOf(s) ?? null, turn: true, stopped: stoppedBy.get(s.id) ?? null })),
-      ...[...stoppedBy].filter(([id3]) => !cutIds.has(id3)).map(([id3, stopped]) => ({ sessionId: id3, requester: null, turn: false, stopped }))
+      ...cutByUpdate.map((s) => ({ sessionId: s.id, turn: true, stopped: stoppedBy.get(s.id) ?? null })),
+      ...[...stoppedBy].filter(([id3]) => !cutIds.has(id3)).map(([id3, stopped]) => ({ sessionId: id3, turn: false, stopped }))
     ];
     this.cardRests.restore((id3) => !!keeperOpts.keptSessions?.has(id3) && this.meta.get(id3)?.state === "waiting_approval");
     for (const m of this.children.restoreReports(this.meta, goingOn)) this.quitNotices.push({ sessionId: m.sessionId, requester: m.callerSessionId, swapped: true });
@@ -147167,8 +147883,8 @@ var SessionManager = class {
   /** Sessions this start found mid-turn with no process: the person is told of the ones whose work is theirs (§8.1), once the mailbox is wired */
   quitPersonWork = [];
   /**
-   * Sessions an update's stop left, to tell once the start is done (#1618, `continueCutTurns`): a turn it cut is continued (`turn`) and
-   * its requester told; a session at rest whose tasks it stopped is woken for the note alone (#1902). `stopped`: what else it ended there
+   * Sessions an update's stop left, to tell once the start is done (#1618, `continueCutTurns`): a turn it cut is continued (`turn`; its end
+   * says so, #1966); a session at rest whose tasks it stopped is woken for the note alone (#1902). `stopped`: what else it ended there
    */
   updateCuts = [];
   /**
@@ -147584,7 +148300,7 @@ var SessionManager = class {
   turnLostInSwap(m) {
     const change = { type: "state_change", sessionId: m.id, state: "idle", reason: "reattach_failed" };
     this.events.applyStateHint(change, m);
-    this.interruptions.markStoppedByQuit(m, true);
+    this.interruptions.markTurnLost(m, true);
     this.store.sessions.upsertSession(m);
     this.emit(change);
     const turnBy = this.children.turnEnded(m.id, null, true);
@@ -147612,14 +148328,16 @@ var SessionManager = class {
         }
         m.agentVersion = k2.version ?? null;
         const r = await this.resumeSession(k2.sessionId, k2.process).catch((err) => ({ resumed: false, reason: err.message }));
-        if (!r.resumed && !this.lettingGo()) k2.process.kill("SIGTERM");
+        let gone = Promise.resolve();
+        if (!r.resumed && !this.lettingGo()) gone = this.endKept(k2.process);
         const adopted = r.resumed ? this.handles.get(k2.sessionId) : void 0;
-        if (adopted?.takesOverTurn === false && inTurn(m.state)) this.turnLostInSwap(m);
+        if (adopted?.takesOverTurn === false && inTurn(m.state)) await this.continueLostTurn(m);
         if (this.children.queued.has(k2.sessionId)) this.queue.scheduleDrain(k2.sessionId);
         if (!r.resumed) {
           console.error(`[agent-host] could not re-attach ${k2.sessionId.slice(0, 8)}: ${r.reason ?? "unknown"}`);
           if (inTurn(m.state)) {
-            this.turnLostInSwap(m);
+            await gone;
+            await this.continueLostTurn(m);
           } else if (this.children.pausedReports.has(m.id)) {
             void this.reports.reportBackIfAwaited(m.id, { type: "state_change", sessionId: m.id, state: "idle" });
           }
@@ -147634,9 +148352,8 @@ var SessionManager = class {
    * Continues each turn a linked hub's update cut (#1618, owner 2026-10-26): the update no longer waits for the turns on a
    * machine, so the host it starts takes them up again, once. The session was left `working` by the start; it is woken
    * and given Centralu's note through Centralu's own channel (`deliverMail`: no message of the person's, so the turn stays
-   * whose it was and its report, if one is owed, is still that turn's end). Its requester here is told that the turn was
-   * cut and goes on, unless it is one of the turns continued, whose own note covers its children, as a quit's rule has it
-   * (`tellAskerOfInterruption`). A session that cannot be continued (its tool cannot resume it, it is gone there) ends
+   * whose it was and its report, if one is owed, is still that turn's end). Its requester is told nothing of the cut: the
+   * report of the continued turn's end says so (#1966). A session that cannot be continued (its tool cannot resume it, it is gone there) ends
    * as a kept process that could not be re-attached does (`turnLostInSwap`): idle, marked stopped, its report or its
    * requester told. Each is taken once: the list is emptied first, and its id leaves the file once its Continue was sent
    * or its loss reported (`UpdateResumeLists.done`), not before, so a host stopped in between leaves it for the next.
@@ -147649,9 +148366,8 @@ var SessionManager = class {
   async continueCutTurns() {
     const cuts = this.updateCuts;
     this.updateCuts = [];
-    const continued = new Set(cuts.filter((c) => c.turn).map((c) => c.sessionId));
     await Promise.all(
-      cuts.map(async ({ sessionId, requester, turn, stopped }) => {
+      cuts.map(async ({ sessionId, turn, stopped }) => {
         const m = this.meta.get(sessionId);
         if (this.disposing || this.handingOver) return;
         if (!m || turn && !inTurn(m.state)) {
@@ -147660,13 +148376,11 @@ var SessionManager = class {
           this.updateLists?.done(sessionId);
           return;
         }
+        if (turn) this.children.noteContinuedCut(sessionId);
         try {
-          await this.events.deliverMail(
-            sessionId,
-            { text: updateNote(turn, stopped), quiet: false, line: turn ? UPDATE_CONTINUE_LINE : UPDATE_TASKS_LINE, label: "update", skipLine: () => this.disposing && this.stoppingForUpdate },
-            { leaving: () => this.handingOver || this.disposing, atRest: () => true }
-          );
+          await this.sendUpdateNote(sessionId, turn, stopped);
         } catch (e) {
+          this.children.dropContinuedCut(sessionId);
           if (this.disposing || this.handingOver || this.meta.get(sessionId) !== m) return;
           this.restartPolicy.continuingTurns.delete(sessionId);
           if (!turn) {
@@ -147683,11 +148397,50 @@ var SessionManager = class {
         if (this.disposing || this.handingOver) return;
         this.restartPolicy.continuingTurns.delete(sessionId);
         this.updateLists?.done(sessionId);
-        if (requester && !continued.has(requester)) void this.reports.tellCutByUpdate(sessionId, requester);
       })
     );
     this.tellQuitNotices(() => true);
   }
+  /**
+   * Centralu's note to the agent after an update or a swap stopped it (#1618, #1966): the Continue of a cut turn, or the tasks the stop ended
+   * for a session at rest. The one door of the update's continue and of the swap's (`adoptKept`). Not sent once this host is leaving (a second
+   * update's stop while the session wakes): the host after it sends the one
+   */
+  sendUpdateNote(sessionId, turn, stopped) {
+    return this.events.deliverMail(
+      sessionId,
+      { text: updateNote(turn, stopped), quiet: false, line: turn ? UPDATE_CONTINUE_LINE : UPDATE_TASKS_LINE, label: "update", skipLine: () => this.disposing && this.stoppingForUpdate },
+      { leaving: () => this.handingOver || this.disposing, atRest: () => true }
+    );
+  }
+  /**
+   * A turn a host swap cut that its tool cannot take up again (ACP reopens the conversation in a new process; a process that could not be
+   * re-attached): continued like one an update cut, with the same Continue (#1966). Only a turn Centralu itself cut. One that cannot be
+   * continued ends as it did: stopped, its report or its requester told (`turnLostInSwap`)
+   */
+  async continueLostTurn(m) {
+    this.restartPolicy.continuingTurns.add(m.id);
+    this.children.noteContinuedCut(m.id);
+    try {
+      await this.sendUpdateNote(m.id, true, null);
+    } catch (e) {
+      this.children.dropContinuedCut(m.id);
+      if (this.disposing || this.handingOver || this.meta.get(m.id) !== m) return;
+      console.error(`[agent-host] ${m.id.slice(0, 8)}: the turn a swap ended could not be continued (${errorMessage(e)})`);
+      this.turnLostInSwap(m);
+    } finally {
+      this.restartPolicy.continuingTurns.delete(m.id);
+    }
+  }
+  /** Stops a kept process nobody can address; resolves when it has exited, or after a bound (then it is killed) */
+  endKept(p) {
+    if (p.exitCode !== null || p.signalCode) return Promise.resolve();
+    const exited = new Promise((r) => p.once("exit", () => r(true)));
+    p.kill("SIGTERM");
+    return raceTimeout(exited, this.keeperOpts.exitWaitMs ?? 5e3, false).then((done2) => {
+      if (!done2) p.kill("SIGKILL");
+    });
+  }
   /** A turn the start took up that is not continued after all: the hello stops naming it (#1618) */
   notContinued(sessionId) {
     this.continuedAfterUpdate = this.continuedAfterUpdate.filter((c) => c.sessionId !== sessionId);
@@ -148910,7 +149663,7 @@ var MailPerson = class {
   /** A chain with its messages, which the person reads: what is returned is read for them. An old thread's id names the chain moved from it */
   thread(threadId, opts = {}) {
     const root3 = this.rootsOf(threadId)[0];
-    if (root3 === void 0) throw refuse5("unknown_message", `There is no mail ${threadId} kept.`);
+    if (root3 === void 0) throw refuse4("unknown_message", `There is no mail ${threadId} kept.`);
     const all = this.shown(root3);
     let page;
     if (opts.after !== void 0) page = all.filter((s) => s.seq > (opts.after ?? 0)).slice(0, opts.all ? void 0 : THREAD_PAGE);
@@ -148952,7 +149705,7 @@ var MailPerson = class {
     const theirs = open6 ?? toPerson.at(-1);
     const mine = chain.findLast((m) => m.sender === PERSON && this.records.recipients(m.id).some((r) => this.here(r.recipient)));
     const target = theirs ?? mine;
-    if (!target) throw refuse5("unknown_message", `There is no message in ${threadId} to answer.`);
+    if (!target) throw refuse4("unknown_message", `There is no message in ${threadId} to answer.`);
     const to = target === theirs ? [target.sender] : this.records.recipients(target.id).flatMap((r) => this.here(r.recipient) ? [r.recipient] : []);
     const sent = this.service.send(PERSON, { to, text: text3, replyTo: target.id, needsReply: kind === "question" });
     const at2 = this.shown(target.rootId).find((s) => s.m.id === sent.message.id)?.seq ?? 1;
@@ -148972,7 +149725,7 @@ var MailPerson = class {
   close(threadId, outcome = "finished") {
     const roots = this.rootsOf(threadId);
     const root3 = roots[0];
-    if (root3 === void 0) throw refuse5("unknown_message", `There is no mail ${threadId} kept.`);
+    if (root3 === void 0) throw refuse4("unknown_message", `There is no mail ${threadId} kept.`);
     const now = Date.now();
     for (const r of roots) {
       const chain = this.chainOf(r);
@@ -149010,7 +149763,7 @@ var MailPerson = class {
     if (action === "dismiss") return { changed: this.service.dismissHeld(recipient, messageIds, PERSON_HOLDS) };
     const projects = new Set(messageIds.flatMap((id3) => this.records.recipient(id3, recipient)?.held === "policy" ? this.records.message(id3)?.senderProject ?? [] : []));
     const still = [...projects].find((p) => this.host.untrusted(p));
-    if (still !== void 0) throw refuse5("untrusted_project", `${this.host.projectLabel(still)} is not trusted: what its sessions send out of it waits until you trust the project, and then goes in order.`);
+    if (still !== void 0) throw refuse4("untrusted_project", `${this.host.projectLabel(still)} is not trusted: what its sessions send out of it waits until you trust the project, and then goes in order.`);
     const policy = messageIds.filter((id3) => this.records.recipient(id3, recipient)?.held === "policy");
     for (const p of projects) this.trusted(p);
     const letGo = policy.filter((id3) => this.records.recipient(id3, recipient)?.held !== "policy").length;
@@ -149244,151 +149997,6 @@ function askedBy(host, turns, orchestratorId) {
   return { messageId: turn.messageId, sessionId: asker.sessionId, turn: turn.turnSeq, ...askerFacts(host, asker.sessionId), cites: host.cites(turn.messageId) };
 }
 
-// packages/agent-host/src/mail/delegation.ts
-function delegationRecorder(mail, turns) {
-  return (callerId, childId, origin, task) => {
-    const written = mail.task(mail.sessionAddress(callerId), mail.sessionAddress(childId), { text: task, origin: delegationOrigin(origin), delivered: true });
-    turns?.attach(childId, written.id, callerId);
-  };
-}
-function delegationOrigin(origin) {
-  return origin === "start_agent" || origin === "agent_session" || origin === "send_to_session" || origin === "create_session" || origin === "ask_project" ? origin : "send_to_session";
-}
-function personWorkRecorder(mail) {
-  return (sessionId, text3, fromScript) => {
-    mail.task(PERSON, mail.sessionAddress(sessionId), { text: text3, origin: fromScript ? "script" : "create_session", delivered: true });
-  };
-}
-function personOwes(mail, records) {
-  return (sessionId) => records.newestTask(PERSON, mail.sessionAddress(sessionId)) !== void 0;
-}
-function personReportRecorder(mail, records, waitingOn = () => 0) {
-  return (sessionId, draft) => {
-    const task = records.newestTask(PERSON, mail.sessionAddress(sessionId));
-    if (!task) return false;
-    const owed = draft.then === "review" && draft.outcome === "finished" ? waitingOn(sessionId) : 0;
-    try {
-      mail.report(task.id, turnReport(owed > 0 ? { ...draft, outcome: "paused", then: "running" } : draft, owed));
-      return true;
-    } catch (e) {
-      if (refusalReason(e) !== void 0) return false;
-      throw e;
-    }
-  };
-}
-var ANSWER_KEPT = 600;
-function answerRecorder(mail, records, turns, waitingOn = () => 0) {
-  return (callerId, childId, how) => {
-    const owner = mail.sessionAddress(callerId);
-    const child = mail.sessionAddress(childId);
-    const now = Date.now();
-    const reports = records.unreadFor(owner).filter((p) => p.message.kind === "report" && reportOnTaskTo(records, p.message, owner, child)).map((p) => p.message.id);
-    records.markDelivered(owner, reports, now, null);
-    records.markRead(owner, reports, now);
-    const task = records.newestTask(owner, child);
-    if (!how || !task) return;
-    const read = `read_session(sessionId="${childId}")`;
-    const waiting = how.ok ? waitingOn(callerId, childId) : 0;
-    const startedAt = turns?.latest(childId)?.startedAt;
-    const written = mail.report(task.id, {
-      ...startedAt !== void 0 ? { startedAt } : {},
-      ...waiting > 0 ? { outcome: "waiting", waitingOn: waiting } : { outcome: how.ok ? "finished" : "failed" },
-      body: how.ok ? `[Centralu] The assigned work finished.
-id: ${childId}
-
-Its last response is that session's own words, so it is not repeated here: ${read} reads it.` : `[Centralu] The assigned work did not finish.
-id: ${childId}
-
-Its tool's error, by kind: ${how.error}. Its words are its tool's, not Centralu's, so they are not repeated here: ${read} shows them.`,
-      ...how.ok ? { answer: how.text.length > ANSWER_KEPT ? `${how.text.slice(0, ANSWER_KEPT)}\u2026` : how.text } : { error: how.error }
-    });
-    if ("message" in written) {
-      records.markDelivered(owner, [written.message.id], now, null);
-      records.markRead(owner, [written.message.id], now);
-    }
-  };
-}
-function reportOnTaskTo(records, report, owner, child) {
-  const task = report.replyTo === null ? void 0 : records.message(report.replyTo);
-  return task?.kind === "task" && task.sender === owner && records.recipient(task.id, child) !== void 0;
-}
-function turnRecorder(mail, records, turns) {
-  return (sessionId, turn) => {
-    const child = mail.sessionAddress(sessionId);
-    const taskId = turn.ownerId && (turn.by === "work" || turn.added) ? records.newestTask(mail.sessionAddress(turn.ownerId), child)?.id ?? null : null;
-    const personWork = () => turn.ownerId ? null : records.newestTask(PERSON, child)?.id ?? null;
-    const record2 = (by, messageId, owner) => turn.again ? turns.restate(sessionId, by, messageId, owner) : turns.beginOther(sessionId, by, messageId, owner);
-    if (turn.by === "person") record2("person", null);
-    else if (turn.added) record2("person", taskId, turn.ownerId);
-    else if (turn.source === "report") record2("report", null);
-    else if (turn.source === "app") record2("app", null);
-    else {
-      const person = taskId === null ? personWork() : null;
-      record2(turn.cli && person === null ? "cli" : "caller", taskId ?? person, turn.ownerId);
-    }
-  };
-}
-function outcomeOf2(draft) {
-  if (draft.then === "dropped") return { outcome: "stopped", reason: "taken_over" };
-  const word = draft.outcome;
-  const outcome = word === "finished" || word === "settled" ? "finished" : word === "failed" || word === "limit_reached" ? "failed" : "stopped";
-  return { outcome, ...word !== outcome ? { reason: word } : {} };
-}
-function turnReport(draft, waitingOn) {
-  const base2 = { body: draft.body, ...draft.answer ? { answer: draft.answer } : {}, ...draft.error ? { error: draft.error } : {}, ...draft.personNote ? { personNote: true } : {} };
-  if (draft.then === "running" && draft.paused) return { ...base2, outcome: "paused", paused: draft.paused };
-  if (draft.then === "running") return { ...base2, outcome: "waiting", waitingOn: Math.max(1, waitingOn) };
-  return { ...base2, ...outcomeOf2(draft) };
-}
-function askedReportBody(draft) {
-  return draft.outcome === "finished" ? "[Centralu] The orchestrator ended its turn on your request. What it sent you in reply is its answer; if it sent nothing, it had none to give. Its other words in that turn are not passed on." : `[Centralu] The orchestrator's turn on your request did not finish (${draft.outcome}). What it sent you in reply, if anything, has reached you. Ask again, or ask the person.`;
-}
-function reportedWork(records, turns, owner, child, childId) {
-  const turnWork = turns.latest(childId)?.messageId;
-  const work = turnWork == null ? void 0 : records.message(turnWork);
-  if (work && work.sender === owner && records.recipient(work.id, child)) {
-    if (work.kind === "task") return { work, request: false };
-    if (work.kind === "message") return { work, request: true };
-  }
-  const task = records.newestTask(owner, child);
-  return task && { work: task, request: false };
-}
-function reportRecorder(mail, records, turns, waitingOn = () => 0) {
-  return (ownerId, childId, draft) => {
-    const owner = mail.sessionAddress(ownerId);
-    const child = mail.sessionAddress(childId);
-    const found = reportedWork(records, turns, owner, child, childId);
-    if (!found) return "none";
-    if (draft.archiving) return "closed";
-    if (draft.outcome === "resumed") return "none";
-    const { work, request } = found;
-    let written;
-    try {
-      const { answer: _answer, ...unanswered2 } = draft;
-      const startedAt = turns.latest(childId)?.startedAt;
-      const report = request ? { ...turnReport(unanswered2, 0), body: askedReportBody(draft) } : turnReport(draft, waitingOn(ownerId, childId));
-      written = mail.report(work.id, startedAt === void 0 ? report : { ...report, startedAt });
-    } catch (e) {
-      if (refusalReason(e) !== void 0) return "none";
-      throw e;
-    }
-    const seq = turns.latest(childId)?.seq;
-    if (request && seq !== void 0 && draft.then !== "running") mail.requestTurnEnded(child, owner, seq);
-    if ("settledAlready" in written || written.duplicate) return "closed";
-    if (draft.delivery === "wake") return "mailed";
-    if (!written.first && !draft.ownerInTurn) return "closed";
-    const reportId = written.message.id;
-    return {
-      keep: true,
-      settle: () => {
-        const now = Date.now();
-        records.markDelivered(owner, [reportId], now, null);
-        records.markRead(owner, [reportId], now);
-      }
-    };
-  };
-}
-
 // packages/agent-host/src/mail/messages.ts
 import { createHash as createHash13 } from "node:crypto";
 var CITE_MS = 30 * 6e4;
@@ -149446,18 +150054,18 @@ var MessageService = class {
    */
   send(sender, input) {
     const from = parseAddress(sender);
-    if (!from || from.kind === "centralu") throw refuse5("not_allowed", "Centralu sends with notice and report");
+    if (!from || from.kind === "centralu") throw refuse4("not_allowed", "Centralu sends with notice and report");
     const cls = from.kind;
     const text3 = this.checkText(cls, input.text);
-    if (input.urgent === true && cls !== "session" && cls !== "person") throw refuse5("field_not_allowed", "only a session or the person marks mail urgent");
+    if (input.urgent === true && cls !== "session" && cls !== "person") throw refuse4("field_not_allowed", "only a session or the person marks mail urgent");
     const target = input.replyTo === void 0 ? void 0 : this.readable(sender, input.replyTo);
     let to = [...new Set(input.to)];
     if (to.length === 0) {
-      if (!target) throw refuse5("bad_value", "a message needs at least one recipient");
-      if (target.sender === sender) throw refuse5("own_message", REFUSAL_TEXT.own_message(target.id));
+      if (!target) throw refuse4("bad_value", "a message needs at least one recipient");
+      if (target.sender === sender) throw refuse4("own_message", REFUSAL_TEXT.own_message(target.id));
       to = [target.sender];
     }
-    if (to.length > MAX_RECIPIENTS) throw refuse5("recipients", REFUSAL_TEXT.recipients());
+    if (to.length > MAX_RECIPIENTS) throw refuse4("recipients", REFUSAL_TEXT.recipients());
     const causeId = this.causeOf(sender);
     const cause2 = causeId === null ? null : this.records.message(causeId) ?? null;
     const clarifies = cls === "session" && cause2?.kind === "task" && to.length === 1 && to[0] === cause2.sender ? cause2.id : void 0;
@@ -149466,10 +150074,10 @@ var MessageService = class {
     const requests2 = to.map((r) => this.isRequest({ sender, kind: "message", replyTo: target?.id ?? null, facts: { clarifies } }, r));
     for (const [i, r] of to.entries()) {
       const party = parseAddress(r);
-      if (!party) throw refuse5("bad_address", `Not a mail address: ${JSON.stringify(r)}`);
-      if (r === sender) throw refuse5("bad_value", "a message is for someone else");
+      if (!party) throw refuse4("bad_address", `Not a mail address: ${JSON.stringify(r)}`);
+      if (r === sender) throw refuse4("bad_value", "a message is for someone else");
       const why2 = this.reach.mayWrite(sender, r, requests2[i]);
-      if (why2 !== null) throw refuse5(why2, this.refusalText(why2, r));
+      if (why2 !== null) throw refuse4(why2, this.refusalText(why2, r));
     }
     return this.run(() => {
       const now = this.now();
@@ -149514,9 +150122,9 @@ var MessageService = class {
   /** Work a delegation tool gave: a task from `sender` to `recipient`, whose turn Centralu reports (D2, D7). Written delivered when the old path delivered its words */
   task(sender, recipient, input) {
     const from = parseAddress(sender);
-    if (!from || from.kind === "centralu") throw refuse5("not_allowed", "Centralu sends with notice and report");
+    if (!from || from.kind === "centralu") throw refuse4("not_allowed", "Centralu sends with notice and report");
     const text3 = cutTask(input.text, bodyLimit(from.kind));
-    if (text3 === "") throw refuse5("empty", "a task says something");
+    if (text3 === "") throw refuse4("empty", "a task says something");
     return this.run(() => {
       const now = this.now();
       return this.put(
@@ -149529,12 +150137,12 @@ var MessageService = class {
   refused(callerId, input) {
     const to = this.sessionAddress(callerId);
     const now = this.now();
-    const firstLine3 = oneLineText(input.firstLine, 120);
+    const firstLine4 = oneLineText(input.firstLine, 120);
     this.run(
       () => this.centralu(to, {
         kind: "notice",
         body: REFUSAL_TEXT.untrusted_project(this.reach.projectLabel(input.projectId), input.target),
-        facts: { refused: { ...input, firstLine: firstLine3 } },
+        facts: { refused: { ...input, firstLine: firstLine4 } },
         dedupeKey: `refused:${to}:${hash16([input.tool, input.target, input.firstLine])}:${Math.floor(now / MINUTE_MS)}`,
         delivered: true
       })
@@ -149549,7 +150157,7 @@ var MessageService = class {
     return this.run(() => {
       const task = this.records.message(taskId);
       const row = task && (task.kind === "task" || task.kind === "message") ? this.records.recipients(taskId).find((r) => task.kind === "task" || this.isRequest(task, r.recipient)) : void 0;
-      if (!task || !row) throw refuse5("unknown_message", REFUSAL_TEXT.unknown_message(taskId));
+      if (!task || !row) throw refuse4("unknown_message", REFUSAL_TEXT.unknown_message(taskId));
       if (row.settled !== null && task.kind === "task") return { settledAlready: true };
       const now = this.now();
       const pause = input.outcome === "paused" || input.outcome === "waiting";
@@ -149603,11 +150211,11 @@ var MessageService = class {
   done(by, id3) {
     return this.run(() => {
       const m = this.records.message(id3);
-      if (!m) throw refuse5("unknown_message", REFUSAL_TEXT.unknown_message(id3));
+      if (!m) throw refuse4("unknown_message", REFUSAL_TEXT.unknown_message(id3));
       const mine = m.sender === by;
       const row = mine ? void 0 : this.records.recipient(id3, by);
-      if (!mine && !row) throw refuse5("not_yours", REFUSAL_TEXT.not_yours(id3));
-      if (!mine && this.isRequest(m, by) && m.sender !== this.opts.turn?.(by)?.asker) throw refuse5("not_allowed", REFUSAL_TEXT.withheld(id3));
+      if (!mine && !row) throw refuse4("not_yours", REFUSAL_TEXT.not_yours(id3));
+      if (!mine && this.isRequest(m, by) && m.sender !== this.opts.turn?.(by)?.asker) throw refuse4("not_allowed", REFUSAL_TEXT.withheld(id3));
       if (!m.needsReply && (m.kind !== "task" || !mine)) return { settled: 0, how: "unwatched" };
       if (mine) {
         const n = this.records.settle(id3, "all", "withdrawn", this.now());
@@ -149642,7 +150250,7 @@ var MessageService = class {
       }
       const id3 = opts.id ?? opts.before ?? "";
       const base2 = opts.id === void 0 ? this.records.message(id3) : this.readable(reader, id3);
-      if (!base2) throw refuse5("unknown_message", REFUSAL_TEXT.unknown_message(id3));
+      if (!base2) throw refuse4("unknown_message", REFUSAL_TEXT.unknown_message(id3));
       const chain = this.records.chain(id3, READ_CHAIN);
       const oldest = chain.at(-1) ?? base2;
       const missing = oldest.replyTo !== null && chain.length < READ_CHAIN && this.records.message(oldest.replyTo) === void 0;
@@ -150008,7 +150616,7 @@ var MessageService = class {
         rows3
       );
     } catch (e) {
-      if (e instanceof MailTargetMissing) throw refuse5("unknown_message", REFUSAL_TEXT.unknown_message(e.replyTo));
+      if (e instanceof MailTargetMissing) throw refuse4("unknown_message", REFUSAL_TEXT.unknown_message(e.replyTo));
       throw e;
     }
     if (!stored.duplicate) this.changed(stored, rows3.map((r) => r.recipient));
@@ -150029,9 +150637,9 @@ var MessageService = class {
     );
   }
   checkText(cls, text3) {
-    if (typeof text3 !== "string") throw refuse5("bad_value", "a body is text");
-    if (text3.trim() === "") throw refuse5("empty", "a post says something");
-    if (text3.length > bodyLimit(cls)) throw refuse5("too_long", `a body from ${cls === "app" ? "an app" : "this sender"} is at most ${bodyLimit(cls)} characters`);
+    if (typeof text3 !== "string") throw refuse4("bad_value", "a body is text");
+    if (text3.trim() === "") throw refuse4("empty", "a post says something");
+    if (text3.length > bodyLimit(cls)) throw refuse4("too_long", `a body from ${cls === "app" ? "an app" : "this sender"} is at most ${bodyLimit(cls)} characters`);
     return text3;
   }
   refusalText(why2, to) {
@@ -150048,7 +150656,7 @@ var MessageService = class {
   readable(reader, id3) {
     const m = this.records.message(id3);
     const row = m && m.sender !== reader ? this.records.recipient(id3, reader) : void 0;
-    if (!m || m.sender !== reader && (!row || isHidden(row))) throw refuse5("unknown_message", REFUSAL_TEXT.unknown_message(id3));
+    if (!m || m.sender !== reader && (!row || isHidden(row))) throw refuse4("unknown_message", REFUSAL_TEXT.unknown_message(id3));
     return m;
   }
   /** Whether `target` is a clarification of a task `owner` gave, and the answer goes to the one who asked (§9.7) */
@@ -150074,18 +150682,18 @@ var MessageService = class {
   /** The guards of a send, over the store so a restart does not reset them (§7.5) */
   guards(sender, cls, to, text3, target, requests2, now) {
     for (const r of to) {
-      if ((cls === "session" || cls === "app") && this.records.sameBody(sender, r, text3, now - REPEAT_WINDOW_MS)) throw refuse5("repeat", REFUSAL_TEXT.repeat(this.reach.labelOf(r)));
+      if ((cls === "session" || cls === "app") && this.records.sameBody(sender, r, text3, now - REPEAT_WINDOW_MS)) throw refuse4("repeat", REFUSAL_TEXT.repeat(this.reach.labelOf(r)));
     }
     const limit = postsPerMinute(cls);
     if (limit !== Infinity && this.records.postsSince(sender, now - MINUTE_MS) >= limit) {
-      throw refuse5("rate_limited", `at most ${limit} posts a minute from ${cls === "app" ? "an app" : "a session"}: wait a minute`);
+      throw refuse4("rate_limited", `at most ${limit} posts a minute from ${cls === "app" ? "an app" : "a session"}: wait a minute`);
     }
     for (const [i, r] of to.entries()) {
-      if (target === void 0 && cls === "session" && parseAddress(r)?.kind === "session" && this.records.newSince(sender, r, now - HOUR_MS3) >= PAIR_NEW_PER_HOUR) {
-        throw refuse5("pair_rate", REFUSAL_TEXT.pair_rate(this.reach.labelOf(r)));
+      if (target === void 0 && cls === "session" && parseAddress(r)?.kind === "session" && this.records.newSince(sender, r, now - HOUR_MS) >= PAIR_NEW_PER_HOUR) {
+        throw refuse4("pair_rate", REFUSAL_TEXT.pair_rate(this.reach.labelOf(r)));
       }
       if (requests2[i]) {
-        if (this.records.requestsSince(this.reach.askGroupMembers(sender), r, now - HOUR_MS3) >= ASKS_PER_HOUR) throw refuse5("ask_rate", REFUSAL_TEXT.ask_rate());
+        if (this.records.requestsSince(this.reach.askGroupMembers(sender), r, now - HOUR_MS) >= ASKS_PER_HOUR) throw refuse4("ask_rate", REFUSAL_TEXT.ask_rate());
       }
     }
   }
@@ -150197,7 +150805,8 @@ var MessageService = class {
       ...answered?.sender === recipient ? { answers: answered.id } : {},
       ...typeof m.facts.clarifies === "string" ? { clarifies: m.facts.clarifies } : {},
       ...typeof about === "string" && parseAddress(about) ? { about } : {},
-      ...m.facts.outcome ? { outcome: m.facts.outcome } : {},
+      // The stored word `finished` is the host's knowledge that a turn ended, not that the work is done (#1902): the model reads it as that
+      ...m.facts.outcome ? { outcome: m.facts.outcome === "finished" ? "turn_ended" : m.facts.outcome } : {},
       ...m.facts.error ? { error: m.facts.error } : {},
       ...m.facts.reason ? { reason: m.facts.reason } : {},
       ...m.facts.paused !== void 0 ? { paused: m.facts.paused } : {},
@@ -150319,7 +150928,7 @@ var MailTool = class {
   run(sessionId, args) {
     try {
       const me2 = this.host.caller(sessionId);
-      if (!me2) throw refuse5("gone", "this session is not here");
+      if (!me2) throw refuse4("gone", "this session is not here");
       return { text: this.dispatch(sessionId, me2, args, mailCalls(this.host.mailArgs(sessionId), this.host.form(sessionId))) };
     } catch (e) {
       const reason = refusalReason(e);
@@ -150346,7 +150955,7 @@ var MailTool = class {
       }
       case "update":
       case "close":
-        throw refuse5(
+        throw refuse4(
           "removed",
           `Centralu's mail has no threads any more, so "${a.action}" is gone. Answer a message with ${calls.answer("<message id>")}, and mark one that needs nothing with ${calls.done("<message id>")}.`
         );
@@ -150361,7 +150970,7 @@ var MailTool = class {
     const id3 = thread.trim();
     if (parseMailId(id3)?.kind !== "thread") return id3;
     const newest = this.records.newestLegacyTo(id3, me2);
-    if (!newest) throw refuse5("unknown_message", `there is no message of thread ${id3} you were sent; check the id with mail(action="inbox").`);
+    if (!newest) throw refuse4("unknown_message", `there is no message of thread ${id3} you were sent; check the id with mail(action="inbox").`);
     return newest.id;
   }
   /**
@@ -150373,14 +150982,14 @@ var MailTool = class {
     if (t === PERSON) return { address: PERSON };
     if (t.toLowerCase() === "orchestrator") {
       const id3 = this.host.orchestratorId();
-      if (!id3) throw refuse5("no_mailbox", "there is no orchestrator to ask yet: write to the person instead");
+      if (!id3) throw refuse4("no_mailbox", "there is no orchestrator to ask yet: write to the person instead");
       return { address: this.service.sessionAddress(id3), via: "orchestrator" };
     }
     if (t.toLowerCase() === "parent") {
-      if (!me2.askedBy) throw refuse5("unknown", 'this session was not started by another session; write to "orchestrator" or "person".');
+      if (!me2.askedBy) throw refuse4("unknown", 'this session was not started by another session; write to "orchestrator" or "person".');
       return { address: this.service.sessionAddress(me2.askedBy) };
     }
-    if (t === sessionId) throw refuse5("bad_value", "a message is for someone else");
+    if (t === sessionId) throw refuse4("bad_value", "a message is for someone else");
     return { address: t.includes(":") ? t : this.service.sessionAddress(t) };
   }
   /** `send`'s and `reply`'s answer (S4's lines, in this tool's calls) */
@@ -150639,7 +151248,7 @@ var MailTurns = class {
     else if (outcome === "acted") this.empty.delete(sessionId);
   }
   recent(sessionId) {
-    const since = this.now() - HOUR_MS3;
+    const since = this.now() - HOUR_MS;
     return (this.tokens.get(sessionId) ?? []).filter((t) => t.at > since);
   }
   /** Tokens the session's mail-started turns read in the last hour, the open one included */
@@ -150664,7 +151273,7 @@ var MailTurns = class {
    * counted since the latest of an hour ago, the person's last word to either (a turn of theirs or a message), and the pair's Resume (§7.5)
    */
   pairLoopSpent(a, b2) {
-    const since = Math.max(this.now() - HOUR_MS3, this.lastPersonWord(a), this.lastPersonWord(b2), this.pairFrom.get(pairKey(a, b2)) ?? 0);
+    const since = Math.max(this.now() - HOUR_MS, this.lastPersonWord(a), this.lastPersonWord(b2), this.pairFrom.get(pairKey(a, b2)) ?? 0);
     return this.records.pairTurnsSince(a, b2, since) > this.o.turnsPerHour;
   }
   /** The person pressed Resume on a pair that was paused: its turns are counted from now */
@@ -150867,8 +151476,8 @@ function refusesDelegation(service, reach, callerId, target, call2) {
 }
 
 // packages/agent-host/src/sessions/memory-gate.ts
-import { execFile as execFile11 } from "node:child_process";
-import { readFile as readFile8 } from "node:fs/promises";
+import { execFile as execFile12 } from "node:child_process";
+import { readFile as readFile9 } from "node:fs/promises";
 import { freemem } from "node:os";
 import { promisify as promisify10 } from "node:util";
 var MEMORY_FLOOR_BYTES = 2 * 1024 ** 3;
@@ -150890,14 +151499,14 @@ function parseMemInfo(text3) {
   const m = /^MemAvailable:\s+(\d+)\s*kB\s*$/m.exec(text3);
   return m ? Number(m[1]) * 1024 : null;
 }
-var run = promisify10(execFile11);
+var run = promisify10(execFile12);
 async function readAvailableMemory(deps = {}) {
   const source = deps.source ?? availableMemorySource();
   const free = deps.free ?? freemem;
   if (source.kind === "freemem") return free();
   const what = source.kind === "command" ? source.file : source.path;
   try {
-    const value = source.kind === "command" ? parseVmStat((await (deps.exec ?? ((f, a) => run(f, a, { timeout: 5e3, windowsHide: true })))(source.file, source.args)).stdout) : parseMemInfo(await (deps.readText ?? ((p) => readFile8(p, "utf8")))(source.path));
+    const value = source.kind === "command" ? parseVmStat((await (deps.exec ?? ((f, a) => run(f, a, { timeout: 5e3, windowsHide: true })))(source.file, source.args)).stdout) : parseMemInfo(await (deps.readText ?? ((p) => readFile9(p, "utf8")))(source.path));
     if (value !== null) return value;
     console.error(`[memory-gate] could not parse ${what}; letting agent starts through`);
   } catch (e) {
@@ -150991,126 +151600,12 @@ var MemoryGate = class {
 // packages/agent-host/src/rpc.ts
 import { relative as relative8 } from "node:path";
 
-// packages/agent-host/src/themes.ts
-import { randomBytes as randomBytes11 } from "node:crypto";
-import { watch as watch4 } from "node:fs";
-import { mkdir as mkdir9, readdir as readdir15, readFile as readFile9, stat as stat11 } from "node:fs/promises";
-import { basename as basename14, join as join55 } from "node:path";
-var MAX_FILE_BYTES = 256 * 1024;
-var SETTLE_MS = 100;
-var ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,59}$/;
-var ThemeFiles = class {
-  constructor(dir, onChange) {
-    this.dir = dir;
-    this.onChange = onChange;
-  }
-  dir;
-  onChange;
-  watcher = null;
-  timer = null;
-  /** Makes the folder, writes the schema next to the themes, and starts watching */
-  async start() {
-    await mkdir9(this.dir, { recursive: true });
-    await this.writeSchema();
-    try {
-      this.watcher = watch4(this.dir, (_event, name) => {
-        if (name && !String(name).endsWith(".json")) return;
-        if (name === THEME_SCHEMA_FILE) return;
-        if (this.timer) clearTimeout(this.timer);
-        this.timer = setTimeout(() => {
-          this.timer = null;
-          this.onChange();
-        }, SETTLE_MS);
-      });
-      this.watcher.on("error", () => this.stopWatching());
-    } catch {
-    }
-  }
-  close() {
-    this.stopWatching();
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = null;
-  }
-  stopWatching() {
-    this.watcher?.close();
-    this.watcher = null;
-  }
-  /**
-   * The schema an editor uses for completion, written only when it differs — a build that adds
-   * a token updates it, and an unchanged one does not touch the folder (or wake the watcher).
-   */
-  async writeSchema() {
-    const path2 = join55(this.dir, THEME_SCHEMA_FILE);
-    const text3 = `${JSON.stringify(themeFileJsonSchema(), null, 2)}
-`;
-    const current = await readFile9(path2, "utf8").catch(() => null);
-    if (current !== text3) writeFileWhole(realOs().files, path2, text3);
-  }
-  /** Every `<id>.json` in the folder, read and checked. A file that cannot be read is listed with the reason. */
-  async list() {
-    const names = await readdir15(this.dir).catch(() => []);
-    const entries = [];
-    const ids = names.filter((name) => name.endsWith(".json") && name !== THEME_SCHEMA_FILE).map((name) => name.slice(0, -".json".length)).filter((id3) => ID_PATTERN.test(id3)).sort();
-    for (const id3 of ids) entries.push(await this.read(id3));
-    return entries;
-  }
-  async read(id3) {
-    const path2 = this.pathOf(id3);
-    try {
-      const info = await stat11(path2);
-      if (info.size > MAX_FILE_BYTES) {
-        return { id: id3, path: path2, name: id3, base: "dark", tokens: {}, problems: ["The file is too large to be a theme."], broken: true };
-      }
-      return parseThemeFile(id3, path2, await readFile9(path2, "utf8"));
-    } catch (e) {
-      return { id: id3, path: path2, name: id3, base: "dark", tokens: {}, problems: [`Could not read the file: ${e.message}`], broken: true };
-    }
-  }
-  /** Writes a theme. `id` null makes a new file named after the theme (`My theme` → `my-theme.json`). */
-  async save(id3, content) {
-    const target = id3 ?? await this.freeId(content.name);
-    await mkdir9(this.dir, { recursive: true });
-    writeFileWhole(realOs().files, this.pathOf(target), formatThemeFile(content));
-    return this.read(target);
-  }
-  /** Copies a file from elsewhere in, under a fresh id if its name is taken. Refuses what does not read as a theme. */
-  async importFrom(source) {
-    const info = await stat11(source);
-    if (!info.isFile()) throw rpcError("That is not a file.");
-    if (info.size > MAX_FILE_BYTES) throw rpcError("The file is too large to be a theme.");
-    const text3 = await readFile9(source, "utf8");
-    const parsed = parseThemeFile("import", source, text3);
-    if (parsed.broken) throw rpcError(parsed.problems[0] ?? "Not a theme file.");
-    const fromName = basename14(source).replace(/\.json$/i, "");
-    const id3 = await this.freeId(parsed.name !== "import" ? parsed.name : fromName);
-    writeFileWhole(realOs().files, this.pathOf(id3), text3);
-    return this.read(id3);
-  }
-  /** The absolute path for an id, for the shell to trash or reveal. Refuses anything that is not an id. */
-  pathOf(id3) {
-    if (!ID_PATTERN.test(id3)) throw rpcError(`Not a theme id: ${id3}`);
-    return join55(this.dir, `${id3}.json`);
-  }
-  async freeId(name) {
-    const base2 = name.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "theme";
-    for (let n = 1; n < 1e3; n++) {
-      const id3 = n === 1 ? base2 : `${base2}-${n}`;
-      const taken = await stat11(this.pathOf(id3)).then(
-        () => true,
-        () => false
-      );
-      if (!taken) return id3;
-    }
-    return `${base2}-${randomBytes11(4).toString("hex")}`;
-  }
-};
-
 // packages/agent-host/src/dev-services/strays.ts
-import { execFile as execFile12 } from "node:child_process";
+import { execFile as execFile13 } from "node:child_process";
 import { realpathSync as realpathSync11 } from "node:fs";
 import { promisify as promisify11 } from "node:util";
 import { userInfo as userInfo2 } from "node:os";
-var exec10 = promisify11(execFile12);
+var exec10 = promisify11(execFile13);
 function parsePsRows(out) {
   const rows3 = [];
   for (const line of out.split("\n")) {
@@ -151382,7 +151877,7 @@ var toInfo = (h) => ({
   history: h.history(),
   alive: h.alive
 });
-function createRpcHandler(mgr2, adapters2, { settleDeletedProjects, deleteOutlook, terminals: terminals2, updates: updates2, commands, externalApps: externalApps2, views: views2, inlineViews: inlineViews2, heldPids, themes: themes2, agentVersions: agentVersions2, sleeper: sleeper2, machines, stopHost, stopGate, handover: handover2, activity: activity2, updateApply: updateApply2, hubs: hubs2, mail, requests: requests2, serveCredentials } = {}) {
+function createRpcHandler(mgr2, adapters2, { settleDeletedProjects, deleteOutlook, terminals: terminals2, updates: updates2, commands, externalApps: externalApps2, views: views2, inlineViews: inlineViews2, heldPids, themes: themes2, agentVersions: agentVersions2, sleeper: sleeper2, machines, stopHost, stopGate, handover: handover2, systemEnding: systemEnding2, activity: activity2, updateApply: updateApply2, hubs: hubs2, mail, requests: requests2, serveCredentials } = {}) {
   const reportUiCrash = createUiCrashLog((line) => console.error(line));
   const requireThemes = () => {
     if (!themes2) throw rpcError("Theme files are unavailable");
@@ -151470,6 +151965,10 @@ function createRpcHandler(mgr2, adapters2, { settleDeletedProjects, deleteOutloo
       requireTerminals().close(RpcMethods["terminal.close"].params.parse(p).terminalId);
       return { ok: true };
     },
+    "themes.remove": async (p) => {
+      const keptAt = await requireThemes().remove(RpcMethods["themes.remove"].params.parse(p).id);
+      return { removed: keptAt !== null, keptAt };
+    },
     "themes.import": async (p) => requireThemes().importFrom(RpcMethods["themes.import"].params.parse(p).path),
     "themes.resolve": async (p) => ({ path: requireThemes().pathOf(RpcMethods["themes.resolve"].params.parse(p).id) }),
     "machines.add": async (p) => {
@@ -152072,7 +152571,8 @@ function createRpcHandler(mgr2, adapters2, { settleDeletedProjects, deleteOutloo
       if (updateApply2 && ctx) updateApply2.report(ctx.client, r);
       return {};
     },
-    "host.handover": async ({ handover: h }) => ack(handover2?.(h))
+    "host.handover": async ({ handover: h }) => ack(handover2?.(h)),
+    "host.systemEnding": async ({ cancelled: cancelled2 }) => ack(systemEnding2?.(cancelled2 === true))
   };
   const routes = { ...raw, ...handlers };
   return async (method, params, ctx) => {
@@ -152327,7 +152827,7 @@ function broadcastAppRuns(send, windowMs = APP_CHANGE_WINDOW_MS) {
 var sameCause = (a, b2) => a !== null && b2 !== null && JSON.stringify(a) === JSON.stringify(b2);
 
 // packages/agent-host/src/dev-services/terminal.ts
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { existsSync as existsSync27 } from "node:fs";
 
 // packages/agent-host/src/dev-services/pty-slot.ts
@@ -152482,7 +152982,7 @@ function warnInternals(what) {
 }
 
 // packages/agent-host/src/dev-services/terminal.ts
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 var TerminalService = class {
   constructor(emit, ptys) {
     this.emit = emit;
@@ -152675,8 +153175,8 @@ function shellPath() {
 }
 
 // packages/agent-host/src/dev-services/commands.ts
-import { createRequire as createRequire2 } from "node:module";
-var require3 = createRequire2(import.meta.url);
+import { createRequire as createRequire3 } from "node:module";
+var require3 = createRequire3(import.meta.url);
 var CommandRunner = class {
   constructor(emit, ptys) {
     this.emit = emit;
@@ -152824,7 +153324,7 @@ var CommandRunner = class {
 };
 
 // packages/agent-host/src/updates.ts
-import { execFile as execFile13, execFileSync as execFileSync4 } from "node:child_process";
+import { execFile as execFile14, execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync28, readFileSync as readFileSync23 } from "node:fs";
 import { dirname as dirname25, join as join56 } from "node:path";
 var REGISTRY_URL = `https://registry.npmjs.org/${APP_SLUG}/latest`;
@@ -152847,7 +153347,7 @@ function hubUpdatesMachines(f) {
 async function npmGlobalPackage() {
   const cmd = commandFor("npm", ["root", "-g"]);
   const out = await new Promise((done2) => {
-    execFile13(cmd.file, cmd.args, { timeout: 6e4, windowsHide: true }, (err, stdout) => done2(err ? "" : String(stdout)));
+    execFile14(cmd.file, cmd.args, { timeout: 6e4, windowsHide: true }, (err, stdout) => done2(err ? "" : String(stdout)));
   });
   const root3 = out.trim().split(/\r?\n/).at(-1)?.trim();
   if (!root3) return null;
@@ -152922,7 +153422,7 @@ function failureLine(e) {
 function runCommand(file2, args, resolve20) {
   const cmd = commandFor(file2, args, resolve20);
   return new Promise((done2, reject) => {
-    execFile13(cmd.file, cmd.args, { timeout: INSTALL_TIMEOUT_MS, windowsHide: true }, (err, _stdout, stderr) => {
+    execFile14(cmd.file, cmd.args, { timeout: INSTALL_TIMEOUT_MS, windowsHide: true }, (err, _stdout, stderr) => {
       if (!err) return done2();
       if (err.code === "ENOENT") {
         return reject(new Error(`${file2} was not found on PATH (${err.message})`));
@@ -154369,7 +154869,14 @@ var Shutdown = class {
     if (this.ending) return this.ending;
     if (this.stopping) return this.stopping.catch(() => {
     });
-    const stopped = this.stopServices(mode, handOver2);
+    this.mode = mode;
+    let before;
+    try {
+      before = this.o.beforeLeave?.()?.catch(() => {
+      });
+    } catch {
+    }
+    const stopped = before ? before.then(() => this.stopServices(mode, handOver2)) : this.stopServices(mode, handOver2);
     const setTimer = this.o.setTimer ?? ((f, ms3) => void setTimeout(f, ms3).unref());
     setTimer(() => this.force(`did not finish within ${this.o.boundMs ?? SHUTDOWN_BOUND_MS}ms`), this.o.boundMs ?? SHUTDOWN_BOUND_MS);
     this.ending = stopped.catch((err) => {
@@ -154496,6 +155003,29 @@ function markQuit(dataDir, now = Date.now()) {
   } catch {
   }
 }
+function writeSystemEnd(dataDir) {
+  return (end) => {
+    try {
+      if (end) writeFileSync10(join57(dataDir, SYSTEM_END_FILE), systemEndText(end));
+      else rmSync8(join57(dataDir, SYSTEM_END_FILE), { force: true });
+    } catch {
+    }
+  };
+}
+function takeSystemEnd(dataDir) {
+  const path2 = join57(dataDir, SYSTEM_END_FILE);
+  let text3;
+  try {
+    text3 = readFileSync24(path2, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    rmSync8(path2, { force: true });
+  } catch {
+  }
+  return parseSystemEnd(text3);
+}
 function updateResumeFolder(dataDir) {
   const NAME3 = /^update-resume\.[0-9a-f-]{36}\.json$/;
   return {
@@ -157283,10 +157813,6 @@ var LinkedMachineConnection = class {
   continuesCutTurns() {
     return this.updateContinued !== null;
   }
-  /** When the remote host took up this session's turn (its own id) after an update cut it (#1618); null when it did not */
-  continuedAfterUpdate(sessionId) {
-    return this.updateContinued?.get(sessionId) ?? null;
-  }
   info() {
     return {
       id: this.record.id,
@@ -159278,10 +159804,6 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     continuesCutTurns(machineId) {
       return machineById(machineId)?.continuesCutTurns?.() === true;
     },
-    continuedAfterUpdate(sessionId) {
-      const at2 = qualifiedMachine(machines(), sessionId);
-      return at2?.machine.continuedAfterUpdate?.(at2.id) ?? null;
-    },
     async backgroundTasks(machineId) {
       const m = machineById(machineId);
       if (!m || !m.reachable) return null;
@@ -159712,6 +160234,7 @@ var ROUTES = {
   "themes.list": HUB,
   "themes.save": HUB,
   "themes.import": HUB,
+  "themes.remove": HUB,
   "themes.resolve": HUB,
   "updates.status": HUB,
   "updates.setAuto": HUB,
@@ -159736,6 +160259,8 @@ var ROUTES = {
   "host.stop": HUB,
   // A sign-in's serve on this machine telling its own host about the hand-over (#1224); never through a link
   "host.handover": HUB,
+  // The window of this machine telling its own host the system is ending (#1970); never through a link
+  "host.systemEnding": HUB,
   "machines.acceptVersions": HUB,
   "machines.install": HUB,
   "machines.update": HUB,
@@ -160313,7 +160838,7 @@ function reverseCalls(o) {
 }
 
 // packages/agent-host/src/lifecycle/work-job.ts
-import { execFile as execFile14 } from "node:child_process";
+import { execFile as execFile15 } from "node:child_process";
 import { promisify as promisify12 } from "node:util";
 var WORK_JOB_LIMITS = 8192;
 var JOIN_SCRIPT = (pid, limits) => `
@@ -160354,7 +160879,7 @@ public static class CentraluWorkJob {
 '@
 [CentraluWorkJob]::Join(${pid}, ${limits})
 `;
-var run3 = promisify12(execFile14);
+var run3 = promisify12(execFile15);
 var REAL_OS2 = {
   needed: endsWorkWithJob(),
   powershell: async (script) => {
@@ -160387,7 +160912,7 @@ function workJobLine(job) {
 // packages/agent-host/src/dev-services/broker-pty.ts
 import { spawn as startProcess } from "node:child_process";
 import { existsSync as existsSync30 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire4 } from "node:module";
 import { createInterface as createInterface2 } from "node:readline";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function parseBrokerEvent(line) {
@@ -160563,7 +161088,7 @@ function openInHost(url2) {
   } catch {
   }
 }
-var require4 = createRequire3(import.meta.url);
+var require4 = createRequire4(import.meta.url);
 function loadNodePty() {
   const loaded = require4("node-pty");
   if (!isPtyModule(loaded)) throw new Error("node-pty did not load as a terminal module");
@@ -160589,7 +161114,7 @@ function brokerPtyModule(broker, fallback = loadNodePty) {
 }
 
 // packages/agent-host/src/elevation.ts
-import { execFile as execFile15 } from "node:child_process";
+import { execFile as execFile16 } from "node:child_process";
 function detectToken(o = {}) {
   const source = elevationSource(o.platform ?? HOST_PLATFORM, o.env ?? process.env);
   if (source.kind === "uid") {
@@ -160597,7 +161122,7 @@ function detectToken(o = {}) {
     return Promise.resolve({ elevated: getuid ? getuid() === 0 : null, logon: null });
   }
   const run4 = o.run ?? ((file2, args) => new Promise(
-    (resolve20, reject) => execFile15(file2, args, { windowsHide: true, timeout: 1e4, encoding: "utf8" }, (err, stdout) => err ? reject(err) : resolve20(stdout))
+    (resolve20, reject) => execFile16(file2, args, { windowsHide: true, timeout: 1e4, encoding: "utf8" }, (err, stdout) => err ? reject(err) : resolve20(stdout))
   ));
   return run4(source.file, source.args).then(
     (out) => ({ elevated: elevatedFromGroups(out), logon: logonFromGroups(out) }),
@@ -160622,7 +161147,7 @@ var handedToken = launch.tokenOnStdin ? await readHandedToken(process.stdin).cat
   console.error(`[agent-host] the launcher did not hand over the token: ${e.message}`);
   process.exit(1);
 }) : launch.token;
-var BUILD = true ? "7a978ec" : "dev";
+var BUILD = true ? "eafd282" : "dev";
 var { values } = parseArgs({
   options: {
     port: { type: "string", default: "5175" },
@@ -160694,6 +161219,30 @@ if (!lock.ok) {
 }
 var ownership = lock;
 process.on("exit", ownership.release);
+var systemEnd = dbPath === ":memory:" ? null : takeSystemEnd(dirname26(dbPath));
+if (systemEnd) console.error(`[agent-host] the last host was told the system was ending, at ${new Date(systemEnd.at).toISOString()}`);
+var systemEnding = new SystemEndNotice({
+  write: dbPath === ":memory:" ? () => {
+  } : writeSystemEnd(dirname26(dbPath)),
+  outlived: () => console.error("[agent-host] still running well after the system said it was ending: it did not end")
+});
+var systemQuestion = null;
+var endSystemQuestion = () => {
+};
+process.on("exit", () => endSystemQuestion());
+var askSystem = () => {
+  if (systemQuestion) return systemQuestion;
+  const at2 = Date.now();
+  const q2 = askSystemStopping();
+  if (!q2.stopping) return void 0;
+  endSystemQuestion = q2.end;
+  systemQuestion = q2.stopping.then((stopping) => {
+    if (!stopping) return;
+    console.error("[agent-host] leaving as the system is stopping");
+    systemEnding.notice(at2);
+  });
+  return systemQuestion;
+};
 if (dbPath !== ":memory:") clearStoppedMark(dirname26(dbPath));
 var updateResume = dbPath === ":memory:" ? void 0 : updateResumeFolder(dirname26(dbPath));
 start2.at("hold signals");
@@ -160730,7 +161279,12 @@ var mgr = new SessionManager(
   (sessionId) => bridgeAddress(launch.frontDoor, port, token, sessionId),
   // Worktrees are created next to the data folder — dev and the packaged app never touch each other's worktrees
   join59(dirname26(dbPath), "worktrees"),
-  { ...held2 ? { processes: held2.processes, keptSessions: held2.kept.sessionIds } : {}, ...updateResume ? { updateResume } : {} }
+  {
+    ...held2 ? { processes: held2.processes, keptSessions: held2.kept.sessionIds } : {},
+    ...updateResume ? { updateResume } : {},
+    // The last host recorded that the system was ending (#1397)
+    ...systemEnd ? { systemEnd } : {}
+  }
 );
 mgr.useProjectsHome(() => projectsHome());
 mgr.useMemoryGate(new MemoryGate());
@@ -160895,6 +161449,16 @@ var stopFromRequest = (o, by = "centralu serve --stop") => {
   else stopAsked = true;
 };
 if (control && launch.startedBy === "app") control.on("stop", (m) => stopFromRequest({ forUpdate: m.forUpdate === true }, "the window"));
+var systemEndingTold = (cancelled2) => {
+  if (cancelled2) {
+    console.error("[agent-host] the system is no longer ending");
+    systemEnding.cancel();
+  } else {
+    console.error("[agent-host] the system is ending");
+    systemEnding.notice();
+  }
+};
+control?.on("system-ending", (m) => systemEndingTold(m.cancelled === true));
 var hubName = () => hostname5().replace(/\.local$/i, "") || "a linked computer";
 var links = new Links(linkDepsFor(store, {
   hub: { version: APP_VERSION, protocolVersion: PROTOCOL_VERSION, dev: BUILD === "dev" },
@@ -160980,6 +161544,7 @@ var router = new Router({
     // `host.stop {ifIdle}`: the check and the refusal of new calls in one step (#1224, lifecycle/stop-gate.ts)
     stopGate: launch.startedByServe && !launch.underKeeper ? createStopGate({ drain: hostDrain, activity: () => activityCounts(activity()) }) : void 0,
     // A sign-in's serve says it waits to take over, or gave up (#1224): kept for every hello, and told to who is connected
+    systemEnding: systemEndingTold,
     handover: (h) => {
       handover = h;
       server.broadcast({ type: "host_handover", handover: h });
@@ -161100,7 +161665,9 @@ var shutdown = new Shutdown({
   log: (line) => console.error(line),
   stopLog,
   exit: (code2) => process.exit(code2),
-  pid: process.pid
+  pid: process.pid,
+  // Whether the system is ending, asked as the leave begins, whichever way it began (#1397). Nothing where it cannot say (`undefined`)
+  beforeLeave: () => askSystem()
 });
 start2.at("listen");
 await raceTimeout(elevation, 3e3, void 0);
@@ -161181,7 +161748,11 @@ if (control && launch.underKeeper) {
       return shutdown.stopServices(mode, true);
     },
     keepsAgents: KEEPS_AGENTS_ACROSS_SWAP && held2 !== null,
-    release: ownership.release,
+    // The data folder is the next host's from here: nothing this one learns later is written in it
+    release: () => {
+      systemEnding.close();
+      ownership.release();
+    },
     write: (line) => void writeSync4(1, `${line}
 `),
     log: (line) => console.error(line),