@centralu/host-linux-arm64 0.1.0-beta.43 → 0.1.0-beta.44

package/host/main.mjs

@@ -43054,7 +43054,7 @@ import { dirname as dirname26, join as join58 } from "node:path";
 import { mkdirSync as mkdirSync20, writeSync as writeSync3 } from "node:fs";
 
 // packages/protocol/src/version.generated.ts
-var APP_VERSION = "0.1.0-beta.43";
+var APP_VERSION = "0.1.0-beta.44";
 
 // packages/protocol/src/brand.ts
 var APP_NAME = "Centralu";
@@ -59081,7 +59081,31 @@ var UsageSnapshot = external_exports.object({
   plan: external_exports.string().nullable().default(null),
   windows: external_exports.array(UsageWindow).default([]),
   /** Daily tokens. A tool that cannot report this leaves it empty — the UI collapses that row on its own */
-  daily: external_exports.array(external_exports.object({ date: external_exports.string(), tokens: external_exports.number() })).default([])
+  daily: external_exports.array(external_exports.object({ date: external_exports.string(), tokens: external_exports.number() })).default([]),
+  /**
+   * What the tool counted locally, as a total and not a limit (#1623): a tool with no limits to read (`agents.usage`
+   * answers it `notReported`) may still say how much was used on this computer. Absent when it says nothing, and from a
+   * host that predates it.
+   */
+  totals: external_exports.object({
+    /** What the totals cover, in the words the person reads under their title ("all time") */
+    scope: external_exports.string(),
+    /**
+     * When the host read them, in ms since the epoch. A large database is read slowly, so the host keeps the last totals and
+     * the screen says how old they are. Absent from a host that predates it
+     */
+    asOf: external_exports.number().optional(),
+    rows: external_exports.array(
+      external_exports.object({
+        id: external_exports.string(),
+        label: external_exports.string(),
+        /** Null: the tool printed it in a form the host could not read. The screen shows it as unread, never as a number */
+        value: external_exports.number().nullable(),
+        /** How the screen writes the value: a count, a number of tokens, or dollars */
+        unit: external_exports.enum(["count", "tokens", "usd"])
+      })
+    )
+  }).optional()
 });
 
 // packages/protocol/src/entities/errors.ts
@@ -59865,6 +59889,8 @@ var NormalizedEvent = external_exports.discriminatedUnion("type", [
     data: external_exports.string(),
     /** If the image exists on disk, its source path (Codex imageView) */
     path: external_exports.string().optional(),
+    /** The file the agent viewed, as its path: `path` of a stored row is the host's own copy of it (#1464) */
+    name: external_exports.string().optional(),
     note: external_exports.string().optional()
   }),
   /**
@@ -61685,8 +61711,14 @@ var hostParams = {
    * command can start), so a turn cannot slip in between the check and the stop. Otherwise `{ ok: false, busy, calls }`
    * and nothing changes. A host older than `ifIdle` ignores it and stops; the hand-over sends it only to a host that says
    * its logon, which came with it
+   *
+   * `forUpdate` (#1618, additive): a linked hub stops this host to update it, roll it back or put a version back, and starts
+   * one again in this folder. As it lets its sessions go, this host writes those in a turn to a list of its own in the
+   * folder, each with the last row of its conversation (docs/agent-host.md §4.8), so the host that starts next continues
+   * each of those turns once, while its conversation still ends there. A host
+   * older than it ignores it and stops, and its turns end as a stop's always did
    */
-  "host.stop": external_exports.object({ ifIdle: external_exports.boolean().optional() }),
+  "host.stop": external_exports.object({ ifIdle: external_exports.boolean().optional(), forUpdate: external_exports.boolean().optional() }),
   /**
    * What a `serve` in the person's Windows sign-in says about taking over from this host (#1224): this host keeps it,
    * says it in its hellos and sends `host_handover`, so a hub's row can say it. `handover: null` clears it. Additive
@@ -62771,6 +62803,12 @@ var sessionsParams = {
      * reading of limits nobody will look at. Absent: read them.
      */
     limits: external_exports.boolean().optional(),
+    /**
+     * `true`: when a read of the tool's own command is in flight (an answer marked `provisional`), wait for it instead of
+     * answering at once (#1623). The screen asks once more with this when the first answer was provisional, so it
+     * receives the result when the command finishes and does not poll. Absent: answer at once.
+     */
+    settle: external_exports.boolean().optional(),
     ...machineParam
   }),
   /**
@@ -62980,6 +63018,20 @@ var sessionsResults = {
     supported: external_exports.boolean(),
     reason: external_exports.string().optional(),
     usage: UsageSnapshot.nullable(),
+    /**
+     * With `supported: false`: the tool has no way to report limits at all (its adapter has none), as against a read
+     * that failed, which also answers `supported: false` (not logged in, a timeout). The screen draws only this one as
+     * a plain dimmed ring (#1616); a host that predates it sends neither, and its failed and never answers look alike,
+     * so both stay the unknown they were. Absent otherwise.
+     */
+    notReported: external_exports.boolean().optional(),
+    /**
+     * The answer stands in for one the host is still reading (#1623): a tool with no limits whose own command was
+     * slower than the host waits (`usage` holds nothing yet), or whose last answer is old and is being read again (`usage`
+     * is that answer, with its `totals.asOf`). Asking again with `settle` returns what the command read. Absent
+     * otherwise, and from a host that predates it.
+     */
+    provisional: external_exports.boolean().optional(),
     /**
      * Set on the hub's answer for a linked machine when `usage` is this computer's own because both are logged in to
      * the same account (#726); the meter says so. Absent otherwise, and from a host that predates it.
@@ -63508,7 +63560,15 @@ var HelloServer = external_exports.object({
    */
   logon: HostLogon.optional().catch(void 0),
   /** A sign-in's `serve` waiting to take over from this host, or one that gave up (#1224, `HostHandover`). Additive */
-  handover: HostHandover.optional().catch(void 0)
+  handover: HostHandover.optional().catch(void 0),
+  /**
+   * The turns this host continues because an update of this machine cut them (#1618, `host.stop { forUpdate }`), with when
+   * its start took each up, on this host's clock: what tells a linked hub's caller of such a session that its turn goes on
+   * rather than that the link dropped. Named from the start on, before any hello is answered, whether or not the Continue
+   * is in yet; one that turns out lost is no longer named. An empty list says the host continues the turns an update cuts;
+   * absent, it predates that (or the field could not be read). Additive
+   */
+  updateContinued: external_exports.array(external_exports.object({ sessionId: external_exports.string(), at: external_exports.number() })).optional().catch(void 0)
 });
 var RpcRequest = external_exports.object({
   kind: external_exports.literal("rpc"),
@@ -63968,6 +64028,12 @@ function activityCounts(s) {
   }
   return c;
 }
+function turnCut(s) {
+  return inTurn(s.state);
+}
+function cutTurns(s) {
+  return s.sessions.flatMap((x) => x.id !== void 0 && turnCut(x) ? [x.id] : []);
+}
 function sessionIdle(s, process4) {
   if (s.pendingApproval) return { idle: false, reason: "approval" };
   if (s.pendingQuestions.length > 0) return { idle: false, reason: "question" };
@@ -66441,7 +66507,8 @@ var HostServer = class _HostServer {
       ...this.opts.build ? { build: this.opts.build } : {},
       ...elevatedField(this.opts.elevated?.()),
       ...this.opts.logon?.() ? { logon: this.opts.logon() } : {},
-      ...this.opts.handover?.() ? { handover: this.opts.handover() } : {}
+      ...this.opts.handover?.() ? { handover: this.opts.handover() } : {},
+      ...this.opts.updateContinued ? { updateContinued: this.opts.updateContinued() } : {}
     });
   }
   /**
@@ -105573,6 +105640,12 @@ var RestartPolicy = class {
    * app-server), even though the screen said "starting next turn".
    */
   restartAfterTurn = /* @__PURE__ */ new Set();
+  /**
+   * Sessions whose turn a linked hub's update cut, being woken to continue it (#1618, `continueCutTurns`): their new process
+   * keeps the turn's state as it comes up, as a re-attached one does, rather than settling idle, so a hub reading the machine
+   * between the wake and the note's turn does not read the cut turn as ended
+   */
+  continuingTurns = /* @__PURE__ */ new Set();
   /** Input arriving after a note completes waits for its deferred process replacement, including disposal. */
   deferredRestarts = /* @__PURE__ */ new Map();
   /** A new host served a different Centralu tool prefix; replace the old agent at its safe boundary. */
@@ -107404,6 +107477,7 @@ function interruptionWords(i) {
       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.";
 
 // packages/agent-host/src/sessions/error-kind.ts
 var USAGE_LIMIT = /usage limit|rate.?limit|\b429\b|quota|limit reached|hit your limit/i;
@@ -110484,6 +110558,9 @@ Now:
 ${machineLine(machine)}` };
 }
 
+// packages/agent-host/src/usage-clock.ts
+var isFromTheFuture = (at2, now) => at2 > now;
+
 // packages/agent-host/src/dev-services/store/usage-history.ts
 var HOUR_MS = 60 * 6e4;
 var BUCKET_COLUMNS = `hour, session_id AS sessionId, project_id AS projectId, tool, model, machine, requests, input,
@@ -110518,6 +110595,27 @@ var UsageRecords = class {
     })();
     return written;
   }
+  /**
+   * Keeps the totals a tool that reports no limits last read (`usage_local_totals`, v64), replacing the ones before: a restart
+   * then shows them at once with `totals.asOf`, while a fresh read goes on. An older read than the one kept is not stored.
+   */
+  saveLocalTotals(tool, totals, now = Date.now()) {
+    if (totals.asOf === void 0) return;
+    const kept = this.db.prepare(`SELECT at FROM usage_local_totals WHERE tool = ?`).get(tool);
+    if (kept && kept.at > totals.asOf && !isFromTheFuture(kept.at, now)) return;
+    this.db.prepare(`INSERT INTO usage_local_totals (tool, at, totals) VALUES (?, ?, ?) ON CONFLICT(tool) DO UPDATE SET at = excluded.at, totals = excluded.totals`).run(tool, totals.asOf, JSON.stringify(totals));
+  }
+  /** The totals `saveLocalTotals` kept for a tool, or null: none, or not in the form this build reads (never a guess) */
+  localTotals(tool) {
+    const row = this.db.prepare(`SELECT at, totals FROM usage_local_totals WHERE tool = ?`).get(tool);
+    if (!row) return null;
+    try {
+      const parsed = UsageSnapshot.shape.totals.safeParse(JSON.parse(row.totals));
+      return parsed.success && parsed.data && parsed.data.asOf === row.at ? parsed.data : null;
+    } catch {
+      return null;
+    }
+  }
   /**
    * The readings with `from <= at < to`, oldest first, and for each series the last one before `from`: a reading is
    * stored only when it changes, so the value in force when the range began is that older row. One tool's when `tool` is given.
@@ -113082,6 +113180,10 @@ var RemoteAgents = class {
    * turned Auto reconnect off, or disconnected it, while it was down
    */
   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`) */
@@ -113913,7 +114015,10 @@ var RemoteAgents = class {
    */
   linkChanged(machine) {
     const m = machine;
-    if (!m || typeof m.id !== "string" || m.status === "connected") return;
+    if (!m || typeof m.id !== "string") return;
+    if (updating(m.operation)) this.updateHolds.add(m.id);
+    else if (m.status !== "connecting" && m.status !== "starting") this.updateHolds.delete(m.id);
+    if (m.status === "connected") return;
     const alone = this.host.linkedReader?.machineWaitsForPerson(m.id) === true;
     const mayRecover = m.autoReconnect === false && !alone && m.status !== "versions_differ" && m.status !== "updating";
     const name = typeof m.name === "string" && m.name ? m.name : m.id;
@@ -113932,6 +114037,7 @@ var RemoteAgents = class {
       const told = this.toldDown.get(rec.sessionId);
       if (!report || report.orchestratorId !== rec.callerId || report.paused || told !== void 0 && (told || !alone)) continue;
       if (mayRecover) continue;
+      if (this.updateHolds.has(m.id) && this.host.linkedReader?.continuesCutTurns?.(m.id) === true) continue;
       this.toldDown.set(rec.sessionId, alone);
       const why = !alone ? "It cannot be followed until the link is back: " : m.status === "disconnected" ? "The person disconnected the machine, so nothing here reconnects it: ask the person to connect it. It cannot be followed until then: " : "The machine's Auto reconnect is off, so nothing here reconnects it: ask the person to connect it. It cannot be followed until then: ";
       const rest = why + "its report comes then, once its turn has ended, if that turn is still yours. agent_session status reads its state once the machine can be reached.";
@@ -113970,10 +114076,35 @@ var RemoteAgents = class {
       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;
-      else this.host.settleLinkedTurn(rec.sessionId);
+      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
@@ -114080,6 +114211,9 @@ var RemoteAgents = class {
     return { error: `${machine.name} has no checkout of ${key}, so nothing was started there.${listed2 ? ` Its projects: ${listed2}.` : " It has no projects."} The person can clone it there first.` };
   }
 };
+function updating(op) {
+  return op?.kind === "update" || op?.kind === "rollback";
+}
 
 // packages/agent-host/src/sessions/delegation-flow.ts
 var DelegationFlow = class {
@@ -114162,8 +114296,9 @@ var DelegationFlow = class {
     if (!joinedTurn) this.host.children.ownTurn(sessionId, callerId, false);
     void d2.outcome.then((r) => {
       if (this.host.agentRuns.get(sessionId) === wait) this.host.agentRuns.delete(sessionId);
-      if (!joinedTurn && !this.host.handingOver) this.host.children.releaseTurn(sessionId, d2.callerId);
-      if (!agent && r.ok && !joinedTurn && !this.host.handingOver && this.host.meta.has(d2.callerId) && !this.host.children.pausedReports.has(sessionId)) {
+      if (this.host.closing) return;
+      if (!joinedTurn) this.host.children.releaseTurn(sessionId, d2.callerId);
+      if (!agent && r.ok && !joinedTurn && this.host.meta.has(d2.callerId) && !this.host.children.pausedReports.has(sessionId)) {
         const left = this.host.ownTasksRunning(sessionId);
         if (left.length) {
           this.host.children.markReport(sessionId, d2.callerId);
@@ -114269,6 +114404,7 @@ var NOT_READ = "(not read: the session's last turn was the person's; read_sessio
 function outcomeWord(work, stop, 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";
@@ -114319,6 +114455,9 @@ 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");
@@ -114515,6 +114654,19 @@ var ChildReports = class {
     const { name, project: project2 } = this.reportedAs(m);
     await this.deliverReport(asker, sessionId, name, project2, previewOf(this.host.store.messages, sessionId, 600), { type: stop.reason === "network" ? "error" : "state_change" }, void 0, this.answerSeq(sessionId));
   }
+  /**
+   * 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)}`);
+    await this.deliverReport(requester, sessionId, name, project2, previewOf(this.host.store.messages, sessionId, 600), { type: "state_change" }, { resumed: true, owed }, this.answerSeq(sessionId));
+  }
   /**
    * A report a host swap held back (#646, #1186): its session ended a turn while the old host let go, and the mark the
    * store kept is dropped at start (`restoreReports`), so a later turn is never reported as the work. The caller is
@@ -114567,7 +114719,7 @@ ${read} shows what the person and the session did since.`;
   async deliverReport(orchestratorId, sessionId, name, project2, preview, ending, work, answerSeq, part) {
     const stop = this.host.meta.get(sessionId)?.interruption;
     const cutShort = stop?.reason === "network" || stop?.reason === "interrupted" || stop?.reason === "quit";
-    const outcomeOf2 = (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) : stop?.reason === "network" ? `[Centralu] The assigned work stopped before finishing: a network error ended its turn.
+    const outcomeOf2 = (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) : stop?.reason === "network" ? `[Centralu] The assigned work stopped before finishing: a network error ended its turn.
 ` : stop?.reason === "interrupted" ? `[Centralu] The assigned work stopped before finishing: its tool interrupted the turn.
 ` : stop?.reason === "quit" ? `[Centralu] The assigned work stopped before finishing: Centralu quit or restarted during its turn.
 ` : ending.type === "error" ? `[Centralu] The assigned work failed.
@@ -114601,6 +114753,7 @@ ${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, stop, ending),
       body: forModel(true),
@@ -114608,7 +114761,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 ? "running" : "review"
+      then: holding || handedOn || goesOn ? "running" : "review"
     });
     if (reported === "mailed" || reported === "closed") return;
     await this.tellSession(
@@ -119744,7 +119897,7 @@ function unfitError(reason) {
 }
 
 // packages/agent-host/src/sessions/session-start.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 
 // packages/agent-host/src/sessions/opened-settings.ts
 function adoptOpenedSettings(handle, record2, launched, imported) {
@@ -119774,10 +119927,112 @@ function remember(map2, key, value, cap = FOLDER_CACHE_KEYS) {
   }
 }
 
+// packages/agent-host/src/adapters/input-receipts.ts
+import { randomUUID as randomUUID19 } from "node:crypto";
+var UUID_FORMAT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(s) {
+  return UUID_FORMAT.test(s);
+}
+var CENTRALU_INPUT_MARK = "ce47a1ce47a1";
+function centraluInputId() {
+  const id3 = randomUUID19();
+  return `${id3.slice(0, 8)}-${id3.slice(9, 13)}-${id3.slice(14, 18)}-${id3.slice(19, 23)}-${CENTRALU_INPUT_MARK}`;
+}
+function isCentraluInputId(id3) {
+  return typeof id3 === "string" && id3.length === 36 && id3.toLowerCase().endsWith(`-${CENTRALU_INPUT_MARK}`);
+}
+var UPDATE_CONTINUE_TEXT = "[Centralu] Centralu on this machine was updated while your turn was running, which stopped the turn before it finished. Continue where you stopped. Check what already happened before repeating a step.";
+function isUpdateContinueNote(text2) {
+  return text2.trim() === UPDATE_CONTINUE_TEXT;
+}
+var InputReceipts = class {
+  pending = /* @__PURE__ */ new Map();
+  ended = /* @__PURE__ */ new Set();
+  /** `named`: the id the caller gave the input, which the tool then names back; none, one is made (with Centralu's mark) */
+  create(observer, named) {
+    const id3 = named ?? centraluInputId();
+    let resolve21;
+    let reject;
+    const done2 = new Promise((yes, no2) => {
+      resolve21 = yes;
+      reject = no2;
+    });
+    done2.catch(() => {
+    });
+    const receipt = { id: id3, done: done2, cancelled: false, completed: false };
+    this.pending.set(id3, { receipt, resolve: resolve21, reject, observer });
+    return receipt;
+  }
+  get size() {
+    return this.pending.size;
+  }
+  get ids() {
+    return [...this.pending.keys()];
+  }
+  /** The tool took the input (once): the observer is told before the turn is recorded */
+  accept(id3) {
+    const p = this.pending.get(id3);
+    if (!p || p.accepted) return;
+    p.accepted = true;
+    p.observer?.accepted?.();
+  }
+  /** Codex's turn/start response can arrive after that turn's completion notification. */
+  bind(receipt, turn) {
+    const p = this.pending.get(receipt.id);
+    if (!p) return;
+    this.accept(receipt.id);
+    p.turn = turn;
+    if (this.ended.has(turn)) this.finish(receipt.id);
+  }
+  endTurn(turn) {
+    if (this.pending.size) this.ended.add(turn);
+    for (const [id3, p] of this.pending) if (p.turn === turn) this.finish(id3);
+  }
+  /** Retries can reorder inputs; only UUIDs actually reported as consumed have completed. */
+  complete(ids) {
+    for (const id3 of ids) this.finish(id3);
+  }
+  /** These inputs did not finish (a stopped turn, a process gone): each one's observer is told, the others go on waiting */
+  fail(ids, error51) {
+    for (const id3 of ids) {
+      const p = this.pending.get(id3);
+      if (!p) continue;
+      this.pending.delete(id3);
+      if (!this.pending.size) this.ended.clear();
+      p.receipt.cancelled = true;
+      p.observer?.fail(error51);
+      p.reject(error51);
+    }
+  }
+  failAll(error51) {
+    const turns = [...new Set([...this.pending.values()].flatMap((p) => p.turn ? [p.turn] : []))];
+    const pending = [...this.pending.values()];
+    this.pending.clear();
+    this.ended.clear();
+    for (const p of pending) {
+      p.receipt.cancelled = true;
+      p.observer?.fail(error51);
+      p.reject(error51);
+    }
+    return turns;
+  }
+  finish(id3) {
+    const p = this.pending.get(id3);
+    if (!p) return;
+    this.pending.delete(id3);
+    if (!this.pending.size) this.ended.clear();
+    if (!p.accepted) p.observer?.accepted?.();
+    p.receipt.completed = true;
+    p.observer?.complete();
+    p.resolve();
+  }
+};
+
 // packages/agent-host/src/sessions/external-conversations.ts
 var HISTORY_LIMIT = 200;
 var SYNC_LIMIT = 600;
 var externalSyncedKey = (sessionId) => `external_synced:${sessionId}`;
+var ownNote = (h) => h.role === "user" && isUpdateContinueNote(h.text);
 function historyRow(sessionId, seq, h, fallbackTs) {
   const ts = h.ts ?? fallbackTs;
   if (h.role === "system") {
@@ -119914,39 +120169,32 @@ var ExternalConversations = class {
       return parts.length > 0 ? parts.join("") : void 0;
     };
     const lastText = lastMessageText()?.trim();
+    const said = lastText ? history.findLastIndex((h) => h.role !== "system" && h.text.trim() === lastText) : -1;
+    const wrote = history.findLastIndex((h) => h.role === "user" && h.sent === true);
     let start2 = -1;
-    if (lastText) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        const h = history[i];
-        if (h.role !== "system" && h.text.trim() === lastText) {
-          start2 = i + 1;
-          break;
-        }
-      }
-    } else if (ours.length === 0) {
-      start2 = 0;
-    }
+    if (ours.length === 0) start2 = 0;
+    else if (said >= 0 || !lastText && wrote >= 0) start2 = Math.max(said, wrote) + 1;
     if (start2 < 0 || start2 >= history.length) {
       mark();
       return 0;
     }
     const known = /* @__PURE__ */ new Map();
-    for (let i = ours.length - 1; i >= 0 && ours[i].kind !== "text"; i--) {
+    let trailing = true;
+    for (let i = ours.length - 1; i >= 0; i--) {
+      if (ours[i].kind === "text") trailing = false;
       const key2 = eventKey(ours[i]);
-      if (key2) known.set(key2, (known.get(key2) ?? 0) + 1);
+      if (key2 && (key2 !== "compaction" || trailing)) known.set(key2, (known.get(key2) ?? 0) + 1);
     }
     let end = start2;
     while (history[end]?.role === "system") end++;
-    const fresh = [
-      ...history.slice(start2, end).filter((h) => {
-        const key2 = eventKey(historyRow(info.id, 0, h, 0));
-        const left = key2 ? known.get(key2) ?? 0 : 0;
-        if (!key2 || left === 0) return true;
-        known.set(key2, left - 1);
-        return false;
-      }),
-      ...history.slice(end)
-    ];
+    const fresh = history.slice(start2).filter((h, i) => {
+      if (ownNote(h)) return false;
+      const key2 = eventKey(historyRow(info.id, 0, h, 0));
+      const left = key2 && (key2 !== "compaction" || start2 + i < end) ? known.get(key2) ?? 0 : 0;
+      if (!key2 || left === 0) return true;
+      known.set(key2, left - 1);
+      return false;
+    });
     if (fresh.length === 0) {
       mark();
       return 0;
@@ -119983,6 +120231,7 @@ var ExternalConversations = class {
       });
       return;
     }
+    history = history.filter((h) => !ownNote(h));
     if (history.length === 0) return;
     const base2 = this.host.store.messages.nextSeq(info.id);
     const rows3 = history.map((h, i) => historyRow(info.id, base2 + i, h, info.createdAt));
@@ -120099,7 +120348,7 @@ var SessionStarts = class {
         throw rpcError(`This conversation is already open in the "${holder.name}" session \u2014 continue there`);
       }
     }
-    const id3 = randomUUID19();
+    const id3 = randomUUID20();
     const permissionPreset = presetFromHub(params, this.host.uiPreferences());
     let worktree = null;
     let setupProblems = [];
@@ -120541,6 +120790,9 @@ var SessionStarts = class {
         this.host.emit({ type: "state_change", sessionId, state: m.state, reason: "reattached" });
         if (kept === null) this.host.restartPolicy.backgroundUnknown.set(sessionId, Date.now());
         else if (kept.length > 0) this.host.onEvent({ type: "background_tasks", sessionId, live: kept });
+      } else if (this.host.restartPolicy.continuingTurns.has(sessionId)) {
+        this.host.store.sessions.upsertSession(m);
+        this.host.emit({ type: "state_change", sessionId, state: m.state, reason: "continued" });
       } else {
         this.host.settleState(m, { type: "state_change", sessionId, state: "idle", reason: "resumed" });
       }
@@ -120591,7 +120843,6 @@ function startFit(adapter, opts, sink) {
 }
 
 // packages/agent-host/src/sessions/session-events.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
 import { relative as relative5, resolve as resolve13, sep as sep5 } from "node:path";
 
 // packages/agent-host/src/dev-services/git-attrib.ts
@@ -121603,7 +121854,7 @@ ${attachments.map((a) => `@${a.path}`).join("\n")}` : text2;
 ${adapterText}` : adapterText;
     const joins = inTurn(m.state) && this.host.joinsRunningTurn(sessionId);
     const hubInput = from?.sessionId === HUB_SENDER;
-    const inputId = joins || hubInput ? randomUUID20() : void 0;
+    const inputId = joins || hubInput ? centraluInputId() : void 0;
     this.host.children.noteMessage(sessionId, !from && !fromApp2 && !fromScript ? "person" : "work", inTurn(m.state), this.host.joinsRunningTurn(sessionId), intent === "task", inputId, relayed ? "report" : fromApp2 ? "app" : "caller");
     if (inputId && from && hubInput) this.host.children.noteInputOrigin(sessionId, inputId, { seq, from });
     this.host.cardRests.turnAsked(sessionId);
@@ -121644,7 +121895,8 @@ ${adapterText}` : adapterText;
       this.host.cardRests.turnAsked(sessionId);
       await takeInput(handle, input.text, late);
     }
-    this.onEvent({ type: "notice", sessionId, level: "info", from: "Centralu", label: "mail", text: input.line });
+    if (input.skipLine?.()) return;
+    this.onEvent({ type: "notice", sessionId, level: "info", from: "Centralu", label: input.label ?? "mail", text: input.line });
   }
   /**
    * Centralu's own compact command (#1451): the tool's `/compact` as a turn of its own, in no one's name and with no user row,
@@ -122272,97 +122524,8 @@ function spawnLocalAgent(spec, os2) {
   return LocalAgentProcess.spawn(spec, os2);
 }
 
-// packages/agent-host/src/adapters/input-receipts.ts
-import { randomUUID as randomUUID21 } from "node:crypto";
-var UUID_FORMAT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function isUuid(s) {
-  return UUID_FORMAT.test(s);
-}
-var InputReceipts = class {
-  pending = /* @__PURE__ */ new Map();
-  ended = /* @__PURE__ */ new Set();
-  /** `named`: the id the caller gave the input, which the tool then names back; none, one is made */
-  create(observer, named) {
-    const id3 = named ?? randomUUID21();
-    let resolve21;
-    let reject;
-    const done2 = new Promise((yes, no2) => {
-      resolve21 = yes;
-      reject = no2;
-    });
-    done2.catch(() => {
-    });
-    const receipt = { id: id3, done: done2, cancelled: false, completed: false };
-    this.pending.set(id3, { receipt, resolve: resolve21, reject, observer });
-    return receipt;
-  }
-  get size() {
-    return this.pending.size;
-  }
-  get ids() {
-    return [...this.pending.keys()];
-  }
-  /** The tool took the input (once): the observer is told before the turn is recorded */
-  accept(id3) {
-    const p = this.pending.get(id3);
-    if (!p || p.accepted) return;
-    p.accepted = true;
-    p.observer?.accepted?.();
-  }
-  /** Codex's turn/start response can arrive after that turn's completion notification. */
-  bind(receipt, turn) {
-    const p = this.pending.get(receipt.id);
-    if (!p) return;
-    this.accept(receipt.id);
-    p.turn = turn;
-    if (this.ended.has(turn)) this.finish(receipt.id);
-  }
-  endTurn(turn) {
-    if (this.pending.size) this.ended.add(turn);
-    for (const [id3, p] of this.pending) if (p.turn === turn) this.finish(id3);
-  }
-  /** Retries can reorder inputs; only UUIDs actually reported as consumed have completed. */
-  complete(ids) {
-    for (const id3 of ids) this.finish(id3);
-  }
-  /** These inputs did not finish (a stopped turn, a process gone): each one's observer is told, the others go on waiting */
-  fail(ids, error51) {
-    for (const id3 of ids) {
-      const p = this.pending.get(id3);
-      if (!p) continue;
-      this.pending.delete(id3);
-      if (!this.pending.size) this.ended.clear();
-      p.receipt.cancelled = true;
-      p.observer?.fail(error51);
-      p.reject(error51);
-    }
-  }
-  failAll(error51) {
-    const turns = [...new Set([...this.pending.values()].flatMap((p) => p.turn ? [p.turn] : []))];
-    const pending = [...this.pending.values()];
-    this.pending.clear();
-    this.ended.clear();
-    for (const p of pending) {
-      p.receipt.cancelled = true;
-      p.observer?.fail(error51);
-      p.reject(error51);
-    }
-    return turns;
-  }
-  finish(id3) {
-    const p = this.pending.get(id3);
-    if (!p) return;
-    this.pending.delete(id3);
-    if (!this.pending.size) this.ended.clear();
-    if (!p.accepted) p.observer?.accepted?.();
-    p.receipt.completed = true;
-    p.observer?.complete();
-    p.resolve();
-  }
-};
-
 // packages/agent-host/src/adapters/session-kit.ts
-import { randomUUID as randomUUID22 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 var notices = 0;
 function adapterNotice(sessionId, text2) {
   return { type: "message_delta", sessionId, role: "assistant", messageId: `centralu-notice-${++notices}`, text: text2 };
@@ -122410,7 +122573,7 @@ function stopNotConfirmed(sessionId, text2) {
 }
 var CardIds = class {
   counter = 0;
-  tag = randomUUID22().slice(0, 8);
+  tag = randomUUID21().slice(0, 8);
   next(prefix) {
     return `${prefix}-${this.tag}-${++this.counter}`;
   }
@@ -124305,10 +124468,14 @@ var AcpAdapter = class {
     this.profile = profile;
     this.spawn = spawn6;
     this.stopConfirmMs = stopConfirmMs;
+    const localUsage = profile.localUsage?.bind(profile);
+    if (localUsage) this.localUsage = localUsage;
   }
   profile;
   spawn;
   stopConfirmMs;
+  /** What the tool's own command says about its usage (the profile's `localUsage`), when it has one */
+  localUsage;
   get descriptor() {
     return this.profile.descriptor;
   }
@@ -125395,7 +125562,7 @@ var AntigravityAdapter = class extends AcpAdapter {
 import { tmpdir as tmpdir3 } from "node:os";
 import { mkdtemp as mkdtemp3, readdir as readdir10, rm as rm8, stat as stat8 } from "node:fs/promises";
 import { join as join43 } from "node:path";
-import { randomUUID as randomUUID25 } from "node:crypto";
+import { randomUUID as randomUUID23 } from "node:crypto";
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
 
@@ -126058,20 +126225,58 @@ function contentBlocks(m) {
 
 // packages/agent-host/src/adapters/images.ts
 import { readFile as readFile6, stat as stat6 } from "node:fs/promises";
-var IMAGE_MIMES2 = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  webp: "image/webp",
-  bmp: "image/bmp"
-};
+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) {
+  const n = buf.length;
+  const at2 = (i8) => buf[i8] ?? 0;
+  const table = (flags) => flags & 128 ? 3 * 2 ** ((flags & 7) + 1) : 0;
+  const skipSubBlocks = (from) => {
+    let i8 = from;
+    while (i8 < n && at2(i8) !== 0) i8 += at2(i8) + 1;
+    return i8 + 1;
+  };
+  let i = 13 + table(at2(10));
+  while (i < n) {
+    const b2 = at2(i);
+    if (b2 === 59) return true;
+    if (b2 === 33) i = skipSubBlocks(i + 2);
+    else if (b2 === 44) i = skipSubBlocks(i + 11 + table(at2(i + 9)));
+    else return true;
+  }
+  return false;
+}
+function sniffImage(buf) {
+  const n = buf.length;
+  if (startsWith(buf, [137, 80, 78, 71, 13, 10, 26, 10])) {
+    return { mime: "image/png", complete: buf.lastIndexOf("IEND", n, "latin1") >= 8 };
+  }
+  if (startsWith(buf, [255, 216, 255])) return { mime: "image/jpeg", complete: buf.lastIndexOf(Buffer.from([255, 217])) > 2 };
+  const head = buf.subarray(0, 6).toString("latin1");
+  if (head === "GIF87a" || head === "GIF89a") return { mime: "image/gif", complete: gifReachesTrailer(buf) };
+  if (head.startsWith("RIFF") && buf.subarray(8, 12).toString("latin1") === "WEBP") {
+    return { mime: "image/webp", complete: buf.readUInt32LE(4) + 8 <= n };
+  }
+  if (startsWith(buf, [66, 77]) && n >= 26 && buf.readUInt32LE(6) === 0 && [12, 40, 52, 56, 64, 108, 124].includes(buf.readUInt32LE(14))) return { mime: "image/bmp", complete: buf.readUInt32LE(2) <= n };
+  return null;
+}
+var SIGNATURES = [[137, 80, 78, 71, 13, 10, 26, 10], [255, 216, 255], [...Buffer.from("GIF89a")], [...Buffer.from("RIFF")], [66, 77]];
+function judgeImage(buf) {
+  const seen = sniffImage(buf);
+  if (seen?.complete) return { mime: seen.mime };
+  if (seen || buf.length < 8 && SIGNATURES.some((sig) => buf.every((b2, i) => i >= sig.length || b2 === sig[i]))) {
+    return { note: `the file is cut short (${buf.length} bytes): it may still be being written` };
+  }
+  return null;
+}
 var IMAGE_MAX_BYTES = 8 * 1048576;
-var tooLarge = (bytes2) => `Image is too large (${Math.round(bytes2 / 1048576)}MB)`;
+var tooLarge = (bytes2) => `too large (${Math.round(bytes2 / 1048576)}MB)`;
 function inlineImageEvent(sessionId, mime, data) {
   const bytes2 = Math.floor(data.length * 3 / 4);
   if (bytes2 > IMAGE_MAX_BYTES) return { type: "message_image", sessionId, mime, data: "", note: tooLarge(bytes2) };
-  return { type: "message_image", sessionId, mime: mime || "image/png", data };
+  const judged = judgeImage(Buffer.from(data, "base64"));
+  if (judged && "note" in judged) return undrawnImageEvent(sessionId, judged.note);
+  return { type: "message_image", sessionId, mime: judged?.mime ?? (mime || "image/png"), data };
 }
 function undrawnImageEvent(sessionId, note) {
   return { type: "message_image", sessionId, mime: "", data: "", note };
@@ -126084,22 +126289,31 @@ function mcpImageEvents(sessionId, content) {
     if (part.type !== "image") continue;
     const data = typeof part.data === "string" ? part.data : "";
     const mime = typeof part.mimeType === "string" ? part.mimeType : "";
-    out.push(data ? inlineImageEvent(sessionId, mime, data) : undrawnImageEvent(sessionId, "The tool sent an image with no data"));
+    out.push(data ? inlineImageEvent(sessionId, mime, data) : undrawnImageEvent(sessionId, "the tool sent it with no data"));
   }
   return out;
 }
+function readFailure2(err) {
+  const code2 = asObj(err).code;
+  if (code2 === "ENOENT") return "the file is gone";
+  if (code2 === "EACCES" || code2 === "EPERM") return "no permission to read it";
+  if (code2 === "EISDIR") return "it is a folder";
+  return typeof code2 === "string" ? `the system refused the read (${code2})` : "the read failed";
+}
 async function imageEventFromDisk(sessionId, path2, maxBytes = IMAGE_MAX_BYTES) {
   const fail4 = (note) => ({ ...undrawnImageEvent(sessionId, note), path: path2 });
-  const ext2 = path2.slice(path2.lastIndexOf(".") + 1).toLowerCase();
-  const mime = IMAGE_MIMES2[ext2];
-  if (!mime) return fail4(`Cannot display this format (.${ext2})`);
+  const file2 = path2.split(/[\\/]/).pop() ?? path2;
+  const ext2 = file2.includes(".") ? file2.slice(file2.lastIndexOf(".") + 1).toLowerCase() : "";
   try {
     const s = await stat6(path2);
     if (s.size > maxBytes) return fail4(tooLarge(s.size));
     const buf = await readFile6(path2);
-    return { type: "message_image", sessionId, mime, data: buf.toString("base64"), path: 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);
+    return { type: "message_image", sessionId, mime: seen.mime, data: buf.toString("base64"), path: path2 };
   } catch (err) {
-    return fail4(`Failed to read image: ${err.message}`);
+    return fail4(readFailure2(err));
   }
 }
 
@@ -126327,7 +126541,7 @@ async function readClaudeHistory(externalId, cwd, limit) {
     try {
       const message = readableMessage(r?.message);
       if (r?.type === "assistant") out.push(...assistantLines(message, agents));
-      else if (r?.type === "user") out.push(...userLines(message, agents));
+      else if (r?.type === "user") out.push(...userLines(message, agents, isCentraluInputId(r.uuid)));
     } catch (err) {
       console.error(`[claude] a transcript row was skipped on read-back: ${err.message}`);
     }
@@ -126355,11 +126569,14 @@ function agentResult(e, agents) {
   if (!agents.has(e.callId) && !FOR_THE_MODEL.test(e.output ?? e.summary)) return e;
   return toolResultEvent(HISTORY_SESSION, e.callId, e.ok, "", AGENT_REPORT_NOT_RECORDED);
 }
-function userLines(message, agents) {
+var INTERRUPT_LINE = /^\[Request interrupted by user( for tool use)?\]$/;
+function userLines(message, agents, sent) {
   const raw = userText(message);
   if (COMPACT_SUMMARY.test(raw)) return [{ role: "system", event: { type: "compaction", sessionId: HISTORY_SESSION, failed: false } }];
-  const text2 = stripInjectedBlocks(raw);
-  const out = text2 ? [{ role: "user", text: text2 }] : [];
+  const text2 = INTERRUPT_LINE.test(raw) ? "" : stripInjectedBlocks(raw);
+  const note = isUpdateContinueNote(text2);
+  if (note && !sent) console.error("[claude] Centralu's Continue note is in the transcript without the input id Centralu gave it: this CLI does not keep it. The catch-up recognises the note by its text");
+  const out = text2 ? [{ role: "user", text: text2, ...sent || note ? { sent: true } : {} }] : [];
   const events2 = userEvents({ message }, HISTORY_SESSION);
   out.push(...historyEvents(events2.map((e) => e.type === "tool_result" ? agentResult(e, agents) : e)));
   return out;
@@ -126467,7 +126684,6 @@ async function readClaudeModels(q2) {
 
 // packages/agent-host/src/adapters/claude/session.ts
 init_sdk();
-import { randomUUID as randomUUID24 } from "node:crypto";
 
 // packages/agent-host/src/adapters/subagent-steps.ts
 function subagentSteps(sessionId, parentCallId, events2) {
@@ -128901,8 +129117,9 @@ var ClaudeSession = class {
     this.closed = true;
     this.notify?.();
   }
+  /** Every input goes out under an id with Centralu's mark, so its line in the transcript reads back as Centralu's (`centraluInputId`) */
   send(text2, opts) {
-    this.sendInput(text2, opts?.id !== void 0 && isUuid(opts.id) ? opts.id : randomUUID24(), void 0, opts?.origin, opts?.quiet);
+    this.sendInput(text2, opts?.id !== void 0 && isUuid(opts.id) ? opts.id : centraluInputId(), void 0, opts?.origin, opts?.quiet);
   }
   /** A note read with the next message or at the running turn's next tool round, starting nothing (#1492): quiet input, stamped as Centralu's */
   nudge(text2) {
@@ -128920,7 +129137,7 @@ var ClaudeSession = class {
   turnInputs() {
     return this.resultInputs;
   }
-  sendInput(text2, uuid3 = randomUUID24(), note, origin, quiet) {
+  sendInput(text2, uuid3 = centraluInputId(), note, origin, quiet) {
     const goal = isGoalCommand(text2);
     if (!this.sendGate && !(goal && this.goalCommand === void 0)) {
       this.deliver(text2, uuid3, !!note, origin, quiet);
@@ -129397,7 +129614,7 @@ var ClaudeAdapter = class _ClaudeAdapter {
       await sweepProbeDirs();
     }
     const dir = await mkdtemp3(join43(tmpdir3(), PROBE_DIR_PREFIX));
-    const sessionId = `usage-probe-${randomUUID25()}`;
+    const sessionId = `usage-probe-${randomUUID23()}`;
     _ClaudeAdapter.probeIds.add(sessionId);
     let probe = null;
     try {
@@ -130479,7 +130696,7 @@ function itemToMessages(item, ts) {
   }
   if (it2.type === "userMessage") {
     const text2 = stripInjectedBlocks(userInputText(it2.content));
-    return text2 ? [{ role: "user", text: text2, ts }] : [];
+    return text2 ? [{ role: "user", text: text2, ts, ...isUpdateContinueNote(text2) ? { sent: true } : {} }] : [];
   }
   const live2 = (method) => normalizeNotification(HISTORY_SESSION, { method, params: { item: it2 } });
   return historyEvents([...live2("item/started"), ...live2("item/completed")], ts);
@@ -130870,6 +131087,29 @@ var CODEX_KNOWN_NOTIFICATIONS = /* @__PURE__ */ new Set([
   "thread/realtime/closed"
 ]);
 
+// packages/agent-host/src/adapters/codex/reasoning-parts.ts
+var ReasoningParts = class {
+  item = null;
+  /** Something ended the open row (a tool call, the end of the turn, an image): the next chunk starts a row, not a part */
+  reset() {
+    this.item = null;
+  }
+  /** The events one notification maps to, with the blank line in front of a new item's first chunk */
+  join(n, events2) {
+    if (n.method !== "item/reasoning/summaryTextDelta") return events2;
+    const p = asObj(n.params);
+    const item = str(p.itemId);
+    if (!item) return events2;
+    if (!events2.some((e) => e.type === "reasoning_delta" && e.text)) return events2;
+    const apart = this.item !== null && this.item !== item;
+    this.item = item;
+    if (!apart || typeof p.summaryIndex === "number" && p.summaryIndex > 0) return events2;
+    return events2.map((e) => e.type === "reasoning_delta" && e.text ? { ...e, text: `
+
+${e.text}` } : e);
+  }
+};
+
 // packages/agent-host/src/adapters/codex/thread-settings.ts
 function threadSettingsOf(res) {
   if (!res) return null;
@@ -131819,7 +132059,10 @@ var CodexSession = class {
     this.sessionId = opts.sessionId;
     this.livePreset = opts.permissionPreset;
     const sink = emit;
-    this.emit = (e) => sink(keepAttachedAppMarks(e, () => (opts.apps?.current() ?? []).map((a) => a.server)));
+    this.emit = (e) => {
+      if (endsStreamRow(e) || streamRowKind(e) === "text") this.reasoningParts.reset();
+      sink(keepAttachedAppMarks(e, () => (opts.apps?.current() ?? []).map((a) => a.server)));
+    };
     this.unmapped = new UnmappedTypes("codex", opts.sessionId, CODEX_KNOWN_NOTIFICATIONS);
     this.retry = new RetryActivity(opts.sessionId);
     this.slashCommands = new CodexSlashCommands({
@@ -131978,6 +132221,8 @@ var CodexSession = class {
   ready;
   /** The preset the session is set to now (#1525), which can differ from the one it launched under only between `normal` and `edits` */
   livePreset;
+  /** Which reasoning item the open reasoning row last grew from, so a second item's summary does not run into the first's (#1464) */
+  reasoningParts = new ReasoningParts();
   setPermissionPreset(preset) {
     this.livePreset = preset;
   }
@@ -132123,7 +132368,7 @@ var CodexSession = class {
   }
   /** A notification of this thread's own, as the events it maps to (`normalizeNotification`), each the way it goes out */
   emitNotification(n) {
-    for (const said of normalizeNotification(this.sessionId, n)) {
+    for (const said of this.reasoningParts.join(n, normalizeNotification(this.sessionId, n))) {
       const sort = said.type === "compaction" ? { ...said, trigger: this.compactTurn ? "manual" : "auto" } : said;
       const compactAt = codexCompactAt(this.opts);
       const e = sort.type === "context_update" && compactAt !== void 0 ? { ...sort, compactAt } : sort;
@@ -133147,6 +133392,111 @@ var CURSOR_SURFACE = {
   baseline: SURFACE_BASELINE3
 };
 
+// packages/agent-host/src/adapters/usage-read.ts
+function softRead(o) {
+  const now = o.now ?? Date.now;
+  const freshFor = (e) => typeof o.freshMs === "function" ? o.freshMs(e.v, e.tookMs) : o.freshMs;
+  let value = null;
+  let failedAt = null;
+  let inflight = null;
+  const standIn = () => value && (o.staleOk?.(value.v) ?? true) ? value.v : o.fallback();
+  const start2 = () => {
+    const began = now();
+    return inflight ??= o.read().then(
+      (v) => {
+        value = { at: now(), v, tookMs: now() - began };
+        failedAt = null;
+        return v;
+      },
+      (e) => {
+        failedAt = now();
+        o.onFail?.(e instanceof Error ? e : new Error(String(e)));
+        return standIn();
+      }
+    ).finally(() => {
+      inflight = null;
+    });
+  };
+  return async (ask = {}) => {
+    const t = now();
+    if (!value && ask.seed) value = { at: ask.seed.at, v: ask.seed.value, tookMs: 0 };
+    if (value && !isFromTheFuture(value.at, t) && t - value.at < freshFor(value)) return { value: value.v, provisional: false };
+    if (failedAt !== null && t - failedAt < o.failMs) return { value: standIn(), provisional: false };
+    const run4 = start2();
+    const held3 = value && (o.staleOk?.(value.v) ?? true) ? { v: value.v } : null;
+    if (held3 && !ask.settle) return { value: held3.v, provisional: true };
+    let timer;
+    const soft = new Promise((resolve21) => {
+      timer = setTimeout(() => resolve21({ value: held3 ? held3.v : o.fallback(), provisional: true }), ask.settle ? o.settleMs ?? 2e4 : o.softMs);
+      timer.unref?.();
+    });
+    try {
+      return await Promise.race([run4.then((v) => ({ value: v, provisional: false })), soft]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+function localUsageReader(o) {
+  const read = softRead(o);
+  return async (ask) => {
+    const at2 = ask?.seed?.totals?.asOf;
+    const { value, provisional } = await read({ settle: ask?.settle, ...ask?.seed && at2 !== void 0 ? { seed: { value: ask.seed, at: at2 } } : {} });
+    return provisional ? { ...value, provisional: true } : value;
+  };
+}
+
+// packages/agent-host/src/adapters/cursor-agent/usage.ts
+var ABOUT = external_exports.object({ subscriptionTier: external_exports.unknown().optional() });
+function parseAbout(stdout) {
+  const about = ABOUT.parse(jsonObjectOf(stdout));
+  if (about.subscriptionTier === null) return { plan: null, loggedOut: true };
+  const tier = typeof about.subscriptionTier === "string" ? about.subscriptionTier.trim() : "";
+  return { plan: tier || null };
+}
+function jsonObjectOf(stdout) {
+  for (let from = stdout.indexOf("{"); from >= 0; from = stdout.indexOf("{", from + 1)) {
+    let depth = 0;
+    let inString = false;
+    for (let i = from; i < stdout.length; i++) {
+      const c = stdout[i];
+      if (inString) {
+        if (c === "\\") i++;
+        else if (c === '"') inString = false;
+      } else if (c === '"') inString = true;
+      else if (c === "{") depth++;
+      else if (c === "}" && --depth === 0) {
+        try {
+          const value = JSON.parse(stdout.slice(from, i + 1));
+          if (typeof value === "object" && value !== null) return value;
+        } catch {
+        }
+        break;
+      }
+    }
+  }
+  throw new Error("`agent about` printed no JSON object");
+}
+var NOTHING = { plan: null };
+var FRESH_MS = 5 * 6e4;
+var LOGGED_OUT_FRESH_MS = 1e4;
+var FAIL_MS = 6e4;
+var SOFT_MS = 3e3;
+var ABOUT_RUN_MS = 15e3;
+function cursorUsageReader(run4, now = Date.now) {
+  return localUsageReader({
+    now,
+    freshMs: (v) => v.loggedOut ? LOGGED_OUT_FRESH_MS : FRESH_MS,
+    // A "not logged in" that is ten seconds old is read again before it is told: a login a moment ago is seen at once
+    staleOk: (v) => !v.loggedOut,
+    failMs: FAIL_MS,
+    softMs: SOFT_MS,
+    fallback: () => NOTHING,
+    onFail: (e) => console.error(`[usage] cursor: could not read the plan: ${e.message}`),
+    read: async () => parseAbout(await run4(ABOUT_RUN_MS))
+  });
+}
+
 // packages/agent-host/src/adapters/cursor-agent/index.ts
 var exec7 = promisify8(execFile9);
 var CAPABILITIES2 = {
@@ -133185,6 +133535,12 @@ function centraluToolOfCall(call2) {
 var STATUS_FOR_MS = 6e4;
 function cursorProfile() {
   let status = null;
+  const localUsage = cursorUsageReader(async (timeout) => {
+    const install = findCursor();
+    if (!install) throw new Error("Cursor CLI not found");
+    const r = await exec7(install.command, [...install.args, "about", "--format", "json"], { timeout, windowsHide: true, env: { ...process.env, ...install.env } });
+    return r.stdout;
+  });
   return {
     descriptor: DESCRIPTOR2,
     capabilities: CAPABILITIES2,
@@ -133197,6 +133553,7 @@ function cursorProfile() {
       return findCursor()?.version ?? null;
     },
     centraluToolOf: centraluToolOfCall,
+    localUsage,
     async detect() {
       if (status && Date.now() - status.at < STATUS_FOR_MS) return status.result;
       const install = findCursor();
@@ -133560,6 +133917,75 @@ var OPENCODE_SURFACE = {
   baseline: SURFACE_BASELINE4
 };
 
+// packages/agent-host/src/adapters/opencode/usage.ts
+var ROWS4 = [
+  { match: "Sessions", id: "sessions", label: "Sessions", unit: "count" },
+  { match: "Messages", id: "messages", label: "Messages", unit: "count" },
+  { match: "Input", id: "input", label: "Input", unit: "tokens" },
+  { match: "Output", id: "output", label: "Output", unit: "tokens" },
+  { match: "Cache Read", id: "cache-read", label: "Cache read", unit: "tokens" },
+  { match: "Cache Write", id: "cache-write", label: "Cache write", unit: "tokens" },
+  { match: "Total Cost", id: "cost", label: "Cost", unit: "usd" }
+];
+function parseAmount(text2) {
+  const m = /^\$?\s*([\d,]*\.?\d+)\s*([KMB])?$/i.exec(text2.trim());
+  const digits = m?.[1];
+  if (!digits) return null;
+  const n = Number(digits.replace(/,/g, ""));
+  if (!Number.isFinite(n)) return null;
+  const k2 = SUFFIX.get((m[2] ?? "").toUpperCase()) ?? 1;
+  return Math.round(n * k2 * 100) / 100;
+}
+var GROUPED = /^\d{1,3}([.,\u00A0\u202F '’])\d{3}(?:\1\d{3})*$/;
+var LAKH = /^\d{1,2}(?:,\d{2})+,\d{3}$/;
+function parseCount(text2) {
+  const t = text2.trim();
+  if (!(/^\d+$/.test(t) || GROUPED.test(t) || LAKH.test(t))) return null;
+  const n = Number(t.replace(/\D/g, ""));
+  return Number.isSafeInteger(n) ? n : null;
+}
+var SUFFIX = /* @__PURE__ */ new Map([
+  ["K", 1e3],
+  ["M", 1e6],
+  ["B", 1e9]
+]);
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function parseStats(stdout) {
+  const found = /* @__PURE__ */ new Map();
+  for (const raw of stdout.replace(ANSI, "").split(/\r?\n/)) {
+    const line = raw.replace(/^[│|]\s*/, "").replace(/\s*[│|]$/, "").trim();
+    const cells = /^(\S.*?)\s{2,}(\S.*)$/.exec(line);
+    const row = ROWS4.find((r) => r.match === cells?.[1]);
+    if (!row || !cells?.[2] || found.has(row.id)) continue;
+    found.set(row.id, row.unit === "count" ? parseCount(cells[2]) : parseAmount(cells[2]));
+  }
+  const rows3 = ROWS4.flatMap((r) => {
+    const value = found.get(r.id);
+    return value === void 0 ? [] : [{ id: r.id, label: r.label, value, unit: r.unit }];
+  });
+  return { plan: null, ...rows3.length > 0 ? { totals: { scope: "all time", rows: rows3 } } : {} };
+}
+var NOTHING2 = { plan: null };
+var MIN_FRESH_MS = 6e4;
+var FRESH_PER_RUN = 10;
+var FAIL_MS2 = 6e4;
+var SOFT_MS2 = 3e3;
+var STATS_RUN_MS = 5 * 6e4;
+function openCodeUsageReader(run4, now = Date.now) {
+  return localUsageReader({
+    freshMs: (_v2, tookMs) => Math.max(MIN_FRESH_MS, tookMs * FRESH_PER_RUN),
+    failMs: FAIL_MS2,
+    softMs: SOFT_MS2,
+    now,
+    fallback: () => NOTHING2,
+    onFail: (e) => console.error(`[usage] opencode: could not read the totals: ${e.message}`),
+    read: async () => {
+      const read = parseStats(await run4(STATS_RUN_MS));
+      return read.totals ? { ...read, totals: { ...read.totals, asOf: now() } } : read;
+    }
+  });
+}
+
 // packages/agent-host/src/adapters/opencode/index.ts
 var exec9 = promisify10(execFile11);
 var CAPABILITIES3 = {
@@ -133592,6 +134018,12 @@ var DESCRIPTOR3 = {
 var VERSION_FOR_MS = 6e4;
 function openCodeProfile() {
   let known = null;
+  const localUsage = openCodeUsageReader(async (timeout) => {
+    const l = findOpenCode();
+    if (!l) throw new Error("OpenCode not found");
+    const r = await exec9(l.command, [...l.args, "stats"], { timeout, windowsHide: true, maxBuffer: 1024 * 1024 });
+    return r.stdout;
+  });
   const version2 = async () => {
     if (known && Date.now() - known.at < VERSION_FOR_MS) return known.version;
     const l = findOpenCode();
@@ -133604,6 +134036,7 @@ function openCodeProfile() {
     capabilities: CAPABILITIES3,
     surface: OPENCODE_SURFACE,
     infersCompaction: true,
+    localUsage,
     async launch(opts) {
       const l = findOpenCode();
       return l ? { command: l.command, args: [...l.args, "acp"], env: presetEnv(opts.permissionPreset, process.env, readOpenCodeConfigs(opts.cwd, process.env)) } : null;
@@ -135577,8 +136010,8 @@ var AppRunRecords = class {
   /**
    * Closes out runs that never saw an end (once, at startup). When the host dies, the app
    * process's input also closes and it ends — a row left at `running` would look like it is
-   * running forever. The same reasoning as fixing session state at startup (`manager.ts`'s
-   * LIVE_ONLY): a "live" state is only true while a process backs it.
+   * running forever. The same reasoning as fixing session state at startup (`manager.ts`, by
+   * `turnCut`): a "live" state is only true while a process backs it.
    */
   settleUnfinishedAppRuns(error51) {
     return this.db.prepare(`UPDATE app_runs SET status = 'error', error = ? WHERE status = 'running'`).run(error51).changes;
@@ -138710,6 +139143,28 @@ var StepsV62 = class extends MigrationRange {
             this.db.exec(`ALTER TABLE usage_buckets ADD COLUMN rebuild_tokens INTEGER NOT NULL DEFAULT 0`);
           }
         }
+      },
+      {
+        to: 64,
+        breaksOlderReaders: false,
+        /**
+         * The last good totals of a tool that reports no limits (#1623), `usage_local_totals`: one row per tool with the JSON of
+         * its `UsageSnapshot.totals` and `at`, when they were read (ms). A tool whose command reads a large database takes a
+         * minute to count, so after a restart the usage panel shows these at once, with the time they were read, while a fresh
+         * read goes on. A row is replaced by each newer read. Counts only, no content; local to this computer.
+         *
+         * **Expand only (#292's rule).** A new table that an older host neither reads nor writes. It goes away when the totals
+         * are not needed any more, in a contract step one release after the code stops using it.
+         */
+        run: () => {
+          this.db.exec(`
+            CREATE TABLE IF NOT EXISTS usage_local_totals (
+              tool   TEXT PRIMARY KEY,
+              at     INTEGER NOT NULL,
+              totals TEXT NOT NULL
+            );
+          `);
+        }
       }
     ];
   }
@@ -139744,6 +140199,116 @@ var Store = class extends MigrationRunner {
 };
 var WAL_SIZE_LIMIT = 64 * 1024 * 1024;
 
+// packages/agent-host/src/lifecycle/update-resume.ts
+var UPDATE_RESUME_PREFIX = "update-resume.";
+var MAX_TURNS = 1e3;
+var ID3 = /^[0-9A-Za-z_.:-]{1,200}$/;
+var READ_TRIES = 5;
+var READ_RETRY_MS = 200;
+function sleepSync(ms3) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms3);
+}
+function readHeld(folder, name, wait) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return folder.read(name);
+    } catch (err) {
+      const busy = err instanceof Error && "code" in err && err.code === "EBUSY";
+      if (!busy || attempt >= READ_TRIES) throw err;
+      console.error(`[agent-host] ${name} is held by another process (${errorMessage(err)}); reading it again (${attempt}/${READ_TRIES})`);
+      wait(READ_RETRY_MS);
+    }
+  }
+}
+function parseUpdateResume(text2) {
+  let o;
+  try {
+    o = JSON.parse(text2);
+  } catch {
+    return "torn";
+  }
+  if (typeof o !== "object" || o === null || !("v" in o) || o.v !== 1 || !("turns" in o) || !Array.isArray(o.turns)) return "other";
+  const turns = [];
+  const listed2 = o.turns;
+  for (const t of listed2) {
+    if (typeof t !== "object" || t === null || !("id" in t) || !("seq" in t)) continue;
+    if (typeof t.id === "string" && ID3.test(t.id) && typeof t.seq === "number" && Number.isSafeInteger(t.seq) && t.seq >= 0) turns.push({ id: t.id, seq: t.seq });
+  }
+  return turns.slice(0, MAX_TURNS);
+}
+function recordUpdateCut(folder, cut2) {
+  const turns = cut2.filter((t) => ID3.test(t.id)).slice(0, MAX_TURNS);
+  if (!turns.length) return;
+  try {
+    folder.add(`${JSON.stringify({ v: 1, turns })}
+`);
+  } catch (err) {
+    console.error(`[agent-host] the turns this update ends could not be listed for the next start (${errorMessage(err)}); they end as a stop's do`);
+  }
+}
+var UpdateResumeLists = class {
+  /**
+   * `wait` sleeps between the tries at a list a scanner holds (`READ_TRIES`); the host's own start is one thread with nothing
+   * yet to serve, so it blocks. Tests pass their own
+   */
+  constructor(folder, wait = sleepSync) {
+    this.folder = folder;
+    let names;
+    try {
+      names = folder.names();
+    } catch (err) {
+      console.error(`[agent-host] the turns an update ended could not be read (${errorMessage(err)}); none is continued`);
+      return;
+    }
+    for (const name of names) {
+      let text2;
+      try {
+        text2 = readHeld(folder, name, wait);
+      } catch (err) {
+        console.error(`[agent-host] ${name} could not be read (${errorMessage(err)}); the list is kept for a later start, and the turns it names end as a quit's do`);
+        continue;
+      }
+      if (text2 === null) continue;
+      const turns = parseUpdateResume(text2);
+      if (turns === "other") continue;
+      if (turns === "torn") this.removeList(name);
+      else this.lists.set(name, turns);
+    }
+  }
+  folder;
+  /** Each list's name and the turns it names, as read at the start */
+  lists = /* @__PURE__ */ new Map();
+  dealt = /* @__PURE__ */ new Set();
+  /** The sessions the lists name */
+  ids() {
+    return new Set([...this.lists.values()].flat().map((t) => t.id));
+  }
+  /** Whether a stop listed this session's turn as the one it cut: its conversation still ends where it ended then */
+  cut(id3, lastSeq) {
+    return [...this.lists.values()].some((turns) => turns.some((t) => t.id === id3 && t.seq === lastSeq));
+  }
+  /**
+   * One listed session dealt with: continued, reported as lost, or not found cut. Each list all of whose sessions are
+   * dealt with goes. One that cannot be removed is said in the log and stays harmless: the turn it names is over, so
+   * its mark no longer matches, and a later start removes it
+   */
+  done(id3) {
+    this.dealt.add(id3);
+    for (const [name, turns] of this.lists) {
+      if (!turns.some((t) => t.id === id3) || !turns.every((t) => this.dealt.has(t.id))) continue;
+      this.lists.delete(name);
+      this.removeList(name);
+    }
+  }
+  removeList(name) {
+    try {
+      this.folder.remove(name);
+    } catch (err) {
+      console.error(`[agent-host] ${name} could not be removed (${errorMessage(err)}); the turns it names are over, and a later start removes it`);
+    }
+  }
+};
+
 // packages/agent-host/src/sessions/card-rest.ts
 var CardRests = class {
   constructor(record2 = null, now = () => Date.now()) {
@@ -140614,7 +141179,7 @@ function pausedWords(tasks, sessionId, there = "") {
 }
 
 // packages/agent-host/src/sessions/handoff-flow.ts
-import { randomUUID as randomUUID26 } from "node:crypto";
+import { randomUUID as randomUUID24 } from "node:crypto";
 var TIMINGS = { callMs: 24e4, noteMs: 10 * 6e4 };
 var HandoffFlow = class {
   constructor(host, timings = TIMINGS) {
@@ -140693,7 +141258,7 @@ var HandoffFlow = class {
     const again = this.refusal(callerId, now, mode);
     if (again) return this.refuse(callerId, now.id, again);
     if (always) this.always.add(callerId);
-    const run4 = { id: `ho-${randomUUID26().slice(0, 8)}`, callerId, targetId: now.id, done: Promise.resolve({ ok: false, error: "" }) };
+    const run4 = { id: `ho-${randomUUID24().slice(0, 8)}`, callerId, targetId: now.id, done: Promise.resolve({ ok: false, error: "" }) };
     this.running.set(now.id, run4);
     this.runs.set(run4.id, run4);
     if (viaAuto && !this.host.autoBoundaryOpen(callerId, `${SESSION_HANDOFF} of ${now.id} (${mode}, to ${tool})`)) {
@@ -140829,7 +141394,7 @@ var HandoffFlow = class {
 
 // packages/agent-host/src/sessions/host-cards.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID as randomUUID27 } from "node:crypto";
+import { randomUUID as randomUUID25 } from "node:crypto";
 var HostCards = class {
   constructor(host) {
     this.host = host;
@@ -140893,7 +141458,7 @@ var HostCards = class {
     if (!card.alwaysAsk && this.host.autoBoundaryOpen(sessionId, card.log ?? `${detail.kind}${note}`)) return Promise.resolve("allow");
     return new Promise((resolve21) => {
       if (signal?.aborted) return resolve21(null);
-      const requestId = card.requestId ?? `${detail.kind === "project_access" ? "xp" : detail.kind === "agent_start" ? "ag" : detail.kind === "centralu_update" || isCentraluApply(detail) ? "up" : "mk"}-${randomUUID27()}`;
+      const requestId = card.requestId ?? `${detail.kind === "project_access" ? "xp" : detail.kind === "agent_start" ? "ag" : detail.kind === "centralu_update" || isCentraluApply(detail) ? "up" : "mk"}-${randomUUID25()}`;
       const ask = { requestId, sessionId, detail, shown: card.shown ?? false, resolve: resolve21 };
       this.hostAsks.set(requestId, ask);
       signal?.addEventListener("abort", () => this.withdrawHostAsk(requestId), { once: true });
@@ -140954,7 +141519,7 @@ var HostCards = class {
       if (signal.aborted) return resolve21(null);
       const app2 = { appId: q2.app.appId, projectId: q2.app.projectId, name: q2.appName };
       if (q2.origin.kind === "session" && this.host.meta.has(q2.origin.sessionId)) {
-        const requestId = `cap-${randomUUID27()}`;
+        const requestId = `cap-${randomUUID25()}`;
         const ask = {
           requestId,
           sessionId: q2.origin.sessionId,
@@ -140968,7 +141533,7 @@ var HostCards = class {
         return;
       }
       const origin = q2.origin.kind === "view" ? q2.origin.app : q2.app;
-      const id3 = `q-${randomUUID27()}`;
+      const id3 = `q-${randomUUID25()}`;
       this.appQuestions.set(id3, {
         question: { id: id3, app: app2, capability: q2.capability, text: q2.text, origin: { appId: origin.appId, projectId: origin.projectId }, askedAt: q2.askedAt, expiresAt: q2.expiresAt },
         resolve: resolve21
@@ -141038,7 +141603,7 @@ import { posix as posix4, sep as sep10, win32 as win328 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 var OPEN_FLAGS = constants8.O_RDONLY | constants8.O_NONBLOCK | (constants8.O_NOFOLLOW ?? 0);
 var MESSAGE_IMAGE_KINDS = "PNG, JPEG, GIF or WebP";
-function sniffImage(b2) {
+function sniffImage2(b2) {
   const at2 = (i, ...bytes2) => bytes2.every((x, k2) => b2[i + k2] === x);
   if (b2.length >= 8 && at2(0, 137, 80, 78, 71, 13, 10, 26, 10)) return "image/png";
   if (b2.length >= 3 && at2(0, 255, 216, 255)) return "image/jpeg";
@@ -141126,7 +141691,7 @@ async function readMessageImage(abs, max = IMAGE_PREVIEW_MAX_BYTES) {
     }
     if (total > max) return refuse6("too_large", `The image is over ${mb3(max)}; a reply shows images up to ${mb3(max)}`, file2);
     const bytes2 = buf.subarray(0, total);
-    const mime = sniffImage(bytes2);
+    const mime = sniffImage2(bytes2);
     if (!mime) return refuse6("not_an_image", `${file2} is not a ${MESSAGE_IMAGE_KINDS} image`, file2);
     return { ok: true, mime, data: bytes2.toString("base64"), file: file2 };
   } finally {
@@ -141249,9 +141814,10 @@ var SessionRecord = class {
         return run4.seq;
       }
       if (run4) this.closeStream(m.id);
-      if (!text2) return null;
+      const first = streamKind === "reasoning" ? text2.replace(/^\s+/, "") : text2;
+      if (!first) return null;
       const seq2 = this.host.store.messages.nextSeq(m.id);
-      const fresh = { seq: seq2, kind: streamKind, payload: { ...e }, text: text2, written: 0, lastWrite: 0 };
+      const fresh = { seq: seq2, kind: streamKind, payload: { ...e }, text: first, written: 0, lastWrite: 0 };
       this.streams.set(m.id, fresh);
       this.flushStream(m.id, fresh);
       m.lastSeq = seq2;
@@ -141372,13 +141938,14 @@ var SessionRecord = class {
   persistImage(e, m) {
     const ts = Date.now();
     const seq = this.host.store.messages.nextSeq(m.id);
+    const name = e.path;
     const row = (path2, note) => ({
       sessionId: m.id,
       seq,
       role: "system",
       kind: "image",
       ts,
-      payload: { type: "message_image", sessionId: m.id, mime: e.mime, data: "", path: path2, note }
+      payload: { type: "message_image", sessionId: m.id, mime: e.mime, data: "", path: path2, note, ...name ? { name } : {} }
     });
     this.host.store.messages.appendMessages([row(e.path, e.note)]);
     m.lastSeq = seq;
@@ -141393,8 +141960,8 @@ var SessionRecord = class {
       stored = (await saveAttachment(m.id, "agent-image", e.mime, e.data)).path;
       void sweepAttachments().catch(() => {
       });
-    } catch (err) {
-      note = `Could not save the image: ${err.message}`;
+    } catch {
+      note = "a copy could not be kept";
     }
     try {
       this.host.store.messages.upsertMessageNoIndex(row(stored ?? e.path, note));
@@ -141443,7 +142010,7 @@ var SessionRecord = class {
             const data = (await readFile9(p.path)).toString("base64");
             return { ...r, payload: { ...p, data } };
           } catch {
-            return { ...r, payload: { ...p, note: "The image was cleared and no longer exists (total-size cap)" } };
+            return { ...r, payload: { ...p, note: "the saved copy was cleared (total-size cap)" } };
           }
         }
         if (r.kind === "text" && r.role === "user") {
@@ -141470,6 +142037,9 @@ var SessionRecord = class {
 // packages/agent-host/src/sessions/tool-queries.ts
 var MODEL_LIST_READ_MS = 6e4;
 var MODEL_LIST_RETRY_MS = 6e4;
+function noLimitsReason(label) {
+  return `${label} does not report usage limits`;
+}
 var ToolQueries = class {
   constructor(host) {
     this.host = host;
@@ -141524,7 +142094,22 @@ var ToolQueries = class {
   async usageFor(tool, opts = {}) {
     const cache2 = this.host.cacheLedger.stats(tool, (id3) => this.host.meta.get(id3)?.name);
     const adapter = this.host.adapters.get(tool);
-    if (!adapter?.listUsage) return { supported: false, reason: `${tool} does not support usage queries`, usage: null, cache: cache2 };
+    const label = adapter?.descriptor.label ?? tool;
+    if (!adapter) return { supported: false, reason: `${tool} does not support usage queries`, usage: null, cache: cache2 };
+    if (!adapter.listUsage) {
+      const none = { supported: false, reason: noLimitsReason(label), notReported: true, usage: null, cache: cache2 };
+      if (!adapter.localUsage || opts.limits === false) return none;
+      try {
+        const local = await adapter.localUsage({ settle: opts.settle, seed: this.localTotalsSeed(tool) });
+        this.keepLocalTotals(tool, local);
+        if (local.loggedOut) return { supported: false, reason: `${label} is not logged in on this computer`, usage: null, cache: cache2 };
+        const usage = { plan: local.plan, windows: [], daily: [], ...local.totals ? { totals: local.totals } : {} };
+        return { ...none, usage, ...local.provisional ? { provisional: true } : {} };
+      } catch (err) {
+        console.error(`[usage] ${tool}: the tool's own usage could not be read: ${errorMessage(err)}`);
+        return none;
+      }
+    }
     if (opts.limits === false) return { supported: true, usage: null, cache: cache2 };
     const hit = this.usageCache.get(tool);
     if (hit && Date.now() - hit.at < 6e4) return { supported: true, usage: hit.snapshot, cache: cache2 };
@@ -141537,6 +142122,38 @@ var ToolQueries = class {
       return { supported: false, reason: err.message, usage: hit?.snapshot ?? null, cache: cache2 };
     }
   }
+  /** Per tool: the read time of the totals last kept, so a stale answer returned again is not written again */
+  keptTotalsAt = /* @__PURE__ */ new Map();
+  /** Tools whose kept totals were already offered to their reader: it keeps its own answer after that */
+  seededTotals = /* @__PURE__ */ new Set();
+  /**
+   * The totals the last process kept for a tool (v64), offered once to its reader, which stands on them as on a stale answer
+   * until its own read ends. After a restart a panel then shows the totals at once, with the time they were read.
+   */
+  localTotalsSeed(tool) {
+    if (this.seededTotals.has(tool)) return void 0;
+    this.seededTotals.add(tool);
+    try {
+      const totals = this.host.store.usage.localTotals(tool);
+      if (!totals) return void 0;
+      if (totals.asOf !== void 0) this.keptTotalsAt.set(tool, totals.asOf);
+      return { plan: null, totals };
+    } catch (err) {
+      console.error(`[usage] ${tool}: the kept totals could not be read: ${errorMessage(err)}`);
+      return void 0;
+    }
+  }
+  /** Keeps totals a read produced (not a stale answer returned again, nor a provisional one), for the next process */
+  keepLocalTotals(tool, local) {
+    const totals = local.totals;
+    if (!totals || totals.asOf === void 0 || local.provisional || this.keptTotalsAt.get(tool) === totals.asOf) return;
+    this.keptTotalsAt.set(tool, totals.asOf);
+    try {
+      this.host.store.usage.saveLocalTotals(tool, totals);
+    } catch (err) {
+      console.error(`[usage] ${tool}: the totals could not be kept: ${errorMessage(err)}`);
+    }
+  }
   /**
    * The models that can be picked, and each model's reasoning effort levels.
    *
@@ -142954,11 +143571,15 @@ var SessionManager = class {
     this.emit = (full) => {
       rawEmit(withoutToolRecord(full));
     };
-    const LIVE_ONLY = ["working", "waiting_approval"];
     const stoppedByQuit = [];
+    const cutByUpdate = [];
+    const lists = keeperOpts.updateResume ? new UpdateResumeLists(keeperOpts.updateResume) : null;
+    this.updateLists = lists;
     for (const s of store2.sessions.listSessions()) {
-      const stale = LIVE_ONLY.includes(s.state) && !keeperOpts.keptSessions?.has(s.id);
-      const fixed = stale ? { ...s, state: "idle", waitingSince: null } : s;
+      const cut2 = turnCut(s) && !keeperOpts.keptSessions?.has(s.id);
+      const goesOn = cut2 && !!lists?.cut(s.id, s.lastSeq);
+      const stale = cut2 && !goesOn;
+      const fixed = stale ? { ...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`);
@@ -142967,27 +143588,39 @@ var SessionManager = class {
         this.children.processGone(s.id);
         stoppedByQuit.push(fixed);
       }
+      if (goesOn) {
+        console.error(`[agent-host] ${s.id.slice(0, 8)}: an update of this machine ended its turn; continuing it`);
+        store2.sessions.upsertSession(fixed);
+        cutByUpdate.push(fixed);
+        this.restartPolicy.continuingTurns.add(s.id);
+        this.continuedAfterUpdate.push({ sessionId: s.id, at: Date.now() });
+      }
     }
+    for (const id3 of lists?.ids() ?? []) if (!cutByUpdate.some((s) => s.id === id3)) this.updateResumeDone(id3);
+    const goingOn = /* @__PURE__ */ new Set([...keeperOpts.keptSessions ?? [], ...cutByUpdate.map((s) => s.id)]);
     this.quitPersonWork = stoppedByQuit.map((s) => s.id);
     const marks = new Map(store2.children.listReportMarks().map((r) => [r.sessionId, r.callerSessionId]));
     const turnGivers = new Map(store2.children.listDelegatedTurns().map((r) => [r.sessionId, r.callerSessionId]));
+    const requesterOf = (s) => [marks.get(s.id), turnGivers.get(s.id), s.askedBy].find((id3) => !!id3 && id3 !== s.id && this.meta.has(id3));
     for (const s of stoppedByQuit) {
-      const requester = [marks.get(s.id), turnGivers.get(s.id), s.askedBy].find((id3) => !!id3 && id3 !== s.id && this.meta.has(id3));
+      const requester = requesterOf(s);
       if (requester) this.quitNotices.push({ sessionId: s.id, requester });
     }
+    this.updateCuts = cutByUpdate.map((s) => ({ sessionId: s.id, requester: requesterOf(s) ?? null }));
     this.cardRests.restore((id3) => !!keeperOpts.keptSessions?.has(id3) && this.meta.get(id3)?.state === "waiting_approval");
-    for (const m of this.children.restoreReports(this.meta, keeperOpts.keptSessions)) this.quitNotices.push({ sessionId: m.sessionId, requester: m.callerSessionId, swapped: true });
+    for (const m of this.children.restoreReports(this.meta, goingOn)) this.quitNotices.push({ sessionId: m.sessionId, requester: m.callerSessionId, swapped: true });
     this.delegationFlow.starts.restoreAgentStarts();
     this.delegationFlow.remote.restore();
-    this.children.restoreTurns(this.meta, keeperOpts.keptSessions);
-    this.keptAtStart = new Set(keeperOpts.keptSessions ?? []);
+    this.children.restoreTurns(this.meta, goingOn);
+    this.keptAtStart = goingOn;
     this.children.restoreQueued(this.meta, (r) => r.via === "ask_project" && !this.queue.pairConsented(r.callerSessionId, this.meta.get(r.sessionId)));
     if (this.children.queued.size) {
       setTimeout(() => {
-        for (const id3 of this.children.queued.keys()) if (!keeperOpts.keptSessions?.has(id3)) this.queue.scheduleDrain(id3);
+        for (const id3 of this.children.queued.keys()) if (!goingOn.has(id3)) this.queue.scheduleDrain(id3);
       }, 0);
     }
-    if (this.quitNotices.length || this.quitPersonWork.length) setTimeout(() => this.tellQuitNotices((id3) => !keeperOpts.keptSessions?.has(id3)), 0);
+    if (this.quitNotices.length || this.quitPersonWork.length) setTimeout(() => this.tellQuitNotices((id3) => !goingOn.has(id3)), 0);
+    if (this.updateCuts.length) setTimeout(() => void this.continueCutTurns(), 0);
     void this.handoffNotes.sweepOrphanHandoffNotes().catch(() => {
     });
     this.recoveryRepair = repairWorktreeRecoveryRemovals((id3) => store2.trash.isTrashed(id3)).catch((e) => console.error(`[archive] recovery folders left by an interrupted purge were not repaired: ${e.message}`));
@@ -143163,6 +143796,18 @@ var SessionManager = class {
   quitNotices = [];
   /** 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 = [];
+  /** Turns a hub's update cut, to continue once the start is done, and who to tell (#1618, `continueCutTurns`) */
+  updateCuts = [];
+  /**
+   * The turns this host continues because an update cut them, and when its start took them up (#1618): said in every hello,
+   * for a hub's callers. Taken at the start, before this host answers any hello, so a hub that connects while a Continue is
+   * still on its way is told of it too (#1626 review); one that turns out lost leaves it (`turnLostInSwap`)
+   */
+  continuedAfterUpdate = [];
+  /** The lists of the turns an update cut that the stops before this start left (#1618), each removed once dealt with */
+  updateLists = null;
+  /** A linked hub stops this host for an update (`host.stop { forUpdate }`): the turns its stop ends are listed (#1618) */
+  stoppingForUpdate = false;
   /** `disposeAll` has begun (#673): a card it withdraws is not the person's answer, and its request stays stored */
   disposing = false;
   /**
@@ -143684,6 +144329,73 @@ var SessionManager = class {
     );
     this.tellQuitNotices(() => true);
   }
+  /**
+   * 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
+   * 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 (`updateResumeDone`), not before, so a host stopped in between leaves it for the next.
+   */
+  async continueCutTurns() {
+    const cuts = this.updateCuts;
+    this.updateCuts = [];
+    const continued = new Set(cuts.map((c) => c.sessionId));
+    await Promise.all(
+      cuts.map(async ({ sessionId, requester }) => {
+        const m = this.meta.get(sessionId);
+        if (this.disposing || this.handingOver) return;
+        if (!m || !inTurn(m.state)) {
+          this.restartPolicy.continuingTurns.delete(sessionId);
+          this.notContinued(sessionId);
+          this.updateResumeDone(sessionId);
+          return;
+        }
+        try {
+          await this.events.deliverMail(
+            sessionId,
+            { text: UPDATE_CONTINUE_TEXT, quiet: false, line: UPDATE_CONTINUE_LINE, label: "update", skipLine: () => this.disposing && this.stoppingForUpdate },
+            { leaving: () => this.handingOver || this.disposing, atRest: () => true }
+          );
+        } catch (e) {
+          if (this.disposing || this.handingOver || this.meta.get(sessionId) !== m) return;
+          this.restartPolicy.continuingTurns.delete(sessionId);
+          console.error(`[agent-host] ${sessionId.slice(0, 8)}: the turn an update ended could not be continued (${errorMessage(e)})`);
+          this.turnLostInSwap(m);
+          this.notContinued(sessionId);
+          this.updateResumeDone(sessionId);
+          return;
+        }
+        if (this.disposing || this.handingOver) return;
+        this.restartPolicy.continuingTurns.delete(sessionId);
+        this.updateResumeDone(sessionId);
+        if (requester && !continued.has(requester)) void this.reports.tellCutByUpdate(sessionId, requester);
+      })
+    );
+    this.tellQuitNotices(() => true);
+  }
+  /** One turn the lists named is dealt with: a list goes once all its turns are (#1618, `UpdateResumeLists.done`) */
+  updateResumeDone(sessionId) {
+    this.updateLists?.done(sessionId);
+  }
+  /** 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);
+  }
+  /**
+   * A linked hub stops this host to update it, roll it back or put a version back (`host.stop { forUpdate }`, #1618): as the
+   * sessions are let go of (`disposeAll`), the ones in a turn are listed for the host that starts next, which continues them
+   */
+  stopForUpdate() {
+    this.stoppingForUpdate = true;
+  }
+  /** The turns this host continues after an update cut them (#1618), for the hello a linked hub reads */
+  updateContinued() {
+    return [...this.continuedAfterUpdate];
+  }
   /** A turn a quit cut in a session whose work the person owns: reported to them. */
   tellPersonOfInterruption(sessionId) {
     if (!this.meta.has(sessionId)) return;
@@ -145100,10 +145812,14 @@ var SessionManager = class {
   async disposeEverything() {
     this.disposing = true;
     this.leaveHost("Centralu is shutting down");
+    const cut2 = this.stoppingForUpdate && this.keeperOpts.updateResume ? cutTurns({ sessions: this.listSessions(), terminals: 0, commandRuns: 0 }) : [];
     for (const [id3, run4] of this.record.streams) this.record.flushStream(id3, run4);
     await Promise.allSettled([...[...this.handles.values()].map((h) => h.dispose()), ...this.merges.mergeChecks]);
     await Promise.allSettled([...this.adapters.values()].map((a) => a.settle?.()));
     for (const id3 of [...this.record.streams.keys()]) this.record.closeStream(id3);
+    if (cut2.length && this.keeperOpts.updateResume) {
+      recordUpdateCut(this.keeperOpts.updateResume, cut2.map((id3) => ({ id: id3, seq: this.store.messages.nextSeq(id3) - 1 })));
+    }
     for (const id3 of this.handles.keys()) this.externals.stampExternalSynced(id3);
     this.handles.clear();
   }
@@ -148499,8 +149215,8 @@ function createRpcHandler(mgr2, adapters2, { settleDeletedProjects, deleteOutloo
     },
     "agents.commands": async (p) => mgr2.listCommands(RpcMethods["agents.commands"].params.parse(p).sessionId),
     "agents.usage": async (p) => {
-      const { tool, limits } = RpcMethods["agents.usage"].params.parse(p);
-      return mgr2.usageFor(tool, { limits });
+      const { tool, limits, settle } = RpcMethods["agents.usage"].params.parse(p);
+      return mgr2.usageFor(tool, { limits, settle });
     },
     "usage.history": async (p) => mgr2.usageHistory(RpcMethods["usage.history"].params.parse(p)),
     "agents.account": async (p) => mgr2.accountFor(RpcMethods["agents.account"].params.parse(p).tool),
@@ -148752,14 +149468,14 @@ function createRpcHandler(mgr2, adapters2, { settleDeletedProjects, deleteOutloo
       if (!stopHost) {
         throw rpcError("This host runs under the Centralu app, which stops it: quit the app instead");
       }
-      const { ifIdle } = RpcMethods["host.stop"].params.parse(p ?? {});
+      const { ifIdle, forUpdate } = RpcMethods["host.stop"].params.parse(p ?? {});
       if (ifIdle) {
         if (!stopGate) throw rpcError("This host cannot tell whether it is idle");
         const running2 = stopGate.busy();
         if (running2) return { ok: false, ...running2 };
         stopGate.refuse();
       }
-      setTimeout(stopHost, 50);
+      setTimeout(() => stopHost({ forUpdate: forUpdate === true }), 50);
       return { ok: true };
     },
     "host.handover": async (p) => {
@@ -148832,7 +149548,7 @@ function onExternalAppListChanged(apps, emit) {
 }
 
 // packages/agent-host/src/update-apply.ts
-import { randomUUID as randomUUID28 } from "node:crypto";
+import { randomUUID as randomUUID26 } from "node:crypto";
 var ANSWER_MS = 5e3;
 var OUTCOME_MS = 2e4;
 var GONE_GRACE_MS = 5e3;
@@ -148866,7 +149582,7 @@ var UpdateApplyBroker = class {
   /** Asks every window whether its "Apply now" could relaunch now; resolves with the first ready one */
   probe() {
     if (this.opts.windows() === 0) return Promise.resolve({ ready: false, error: NO_WINDOW });
-    const requestId = randomUUID28();
+    const requestId = randomUUID26();
     return new Promise((resolve21) => {
       const p = {
         requestId,
@@ -148889,7 +149605,7 @@ var UpdateApplyBroker = class {
     if (!p || p.answered.has(client)) return { ticket: null };
     p.answered.add(client);
     if (a.ready) {
-      const ticket = randomUUID28();
+      const ticket = randomUUID26();
       p.finish({ ready: true, requestId: a.requestId, ticket, client, ...a.version ? { version: a.version } : {} });
       return { ticket };
     }
@@ -150289,7 +151005,7 @@ var SessionSleeper = class {
 };
 
 // packages/agent-host/src/host-requests.ts
-import { randomUUID as randomUUID29 } from "node:crypto";
+import { randomUUID as randomUUID27 } from "node:crypto";
 
 // packages/agent-host/src/host-request-targets.ts
 function asItRuns(method, params) {
@@ -150524,7 +151240,7 @@ var HostRequests = class {
     if (cannot) return Promise.resolve({ decision: null, outcome: cannot });
     const createdAt = this.now();
     const request = {
-      requestId: randomUUID29(),
+      requestId: randomUUID27(),
       method,
       question,
       client: from.client === null ? null : quotedName2(from.client),
@@ -150844,7 +151560,8 @@ function wireEndings(o) {
 }
 
 // packages/agent-host/src/lifecycle/stopped-mark.ts
-import { rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { randomUUID as randomUUID28 } from "node:crypto";
+import { readdirSync as readdirSync15, readFileSync as readFileSync23, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
 import { join as join56 } from "node:path";
 var STOPPED_MARK_FILE = "stopped.json";
 function clearStoppedMark(dataDir) {
@@ -150860,6 +151577,22 @@ function markQuit(dataDir, now = Date.now()) {
   } catch {
   }
 }
+function updateResumeFolder(dataDir) {
+  const NAME3 = /^update-resume\.[0-9a-f-]{36}\.json$/;
+  return {
+    names: () => readdirSync15(dataDir).filter((n) => NAME3.test(n)),
+    read: (name) => {
+      try {
+        return readFileSync23(join56(dataDir, name), "utf8");
+      } catch (err) {
+        if (err instanceof Error && "code" in err && err.code === "ENOENT") return null;
+        throw err;
+      }
+    },
+    add: (text2) => writeFileSync11(join56(dataDir, `${UPDATE_RESUME_PREFIX}${randomUUID28()}.json`), text2, { flag: "wx" }),
+    remove: (name) => rmSync7(join56(dataDir, name), { force: true })
+  };
+}
 
 // packages/agent-host/src/swap-control.ts
 var KEEPS_AGENTS_ACROSS_SWAP = true;
@@ -150996,7 +151729,7 @@ async function runDrain(bound, deps) {
 }
 
 // packages/agent-host/src/links/install.ts
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync27, readFileSync as readFileSync24 } from "node:fs";
 import { hostname as hostname4 } from "node:os";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { gzipSync } from "node:zlib";
@@ -151376,8 +152109,8 @@ function detachCommand(spec, from = null) {
   const name = from === null ? null : hubNameForRemote(from);
   return remoteCommand(spec, name ? `serve --detach --from ${name}` : "serve --detach");
 }
-function stopCommand(spec) {
-  return remoteCommand(spec, "serve --stop", true);
+function stopCommand(spec, o) {
+  return remoteCommand(spec, "serve --stop", o.forUpdate ? "update" : "stop");
 }
 function serveCommand(spec) {
   return remoteCommand(spec, "serve");
@@ -151385,15 +152118,15 @@ function serveCommand(spec) {
 function autostartCommand(spec, action) {
   return remoteCommand(spec, `serve --autostart ${action}`);
 }
-function remoteCommand(spec, args, hubStop = false) {
+function remoteCommand(spec, args, hubStop = null) {
   const custom2 = spec.command?.trim() || null;
   if (spec.shell === "powershell") {
     if (custom2) return powershell(`${custom2} ${args}`);
     return powershell(
-      `${hubStop ? "$env:CENTRALU_STOP_BY = 'hub'; " : ""}${MANAGED_PS}; if (Test-Path $m) { & $m ${args} } elseif (Get-Command centralu.cmd -ErrorAction SilentlyContinue) { & centralu.cmd ${args} } else { $l = Join-Path $d 'bin\\centralu.cmd'; if (Test-Path $l) { & $l ${args} } else { '${NOT_FOUND2}' } }`
+      `${hubStop ? "$env:CENTRALU_STOP_BY = 'hub'; " : ""}${hubStop === "update" ? "$env:CENTRALU_STOP_FOR = 'update'; " : ""}${MANAGED_PS}; if (Test-Path $m) { & $m ${args} } elseif (Get-Command centralu.cmd -ErrorAction SilentlyContinue) { & centralu.cmd ${args} } else { $l = Join-Path $d 'bin\\centralu.cmd'; if (Test-Path $l) { & $l ${args} } else { '${NOT_FOUND2}' } }`
     );
   }
-  const lookup = `${hubStop ? "CENTRALU_STOP_BY=hub; export CENTRALU_STOP_BY; " : ""}${MANAGED_SH}; if [ -x "$m" ]; then exec "$m" ${args}; elif command -v centralu >/dev/null 2>&1; then exec centralu ${args}; elif [ -x "$d/bin/centralu" ]; then exec "$d/bin/centralu" ${args}; else echo ${NOT_FOUND2}; exit 127; fi`;
+  const lookup = `${hubStop ? "CENTRALU_STOP_BY=hub; export CENTRALU_STOP_BY; " : ""}${hubStop === "update" ? "CENTRALU_STOP_FOR=update; export CENTRALU_STOP_FOR; " : ""}${MANAGED_SH}; if [ -x "$m" ]; then exec "$m" ${args}; elif command -v centralu >/dev/null 2>&1; then exec centralu ${args}; elif [ -x "$d/bin/centralu" ]; then exec "$d/bin/centralu" ${args}; else echo ${NOT_FOUND2}; exit 127; fi`;
   if (spec.shell === "posix") return custom2 ? `${custom2} ${args}` : `sh -c '${lookup}'`;
   const distro = distroOf(spec);
   const script = custom2 ? `${custom2} ${args}` : `PATH=$(printf %s "$PATH" | tr : '\\n' | grep -v '^/mnt/' | paste -sd: -); ${lookup}`;
@@ -151681,7 +152414,7 @@ var SSH_STDIN_READY_MS = SSH_CONNECT_ALLOWANCE_MS + SSH_POWERSHELL_START_MS;
 var SSH_STDIN_ACK_MS = 3e4;
 var FORWARD_STDERR_KEEP = 16 * 1024;
 var CLIXML_MARK = /<\/?(?:Objs|Obj|S|MS|PR|TN|TNRef|Props|I32|I64|B|AV)[\s>/]|_x00[0-9A-F]{2}_/;
-var ANSI = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b[@-_]?/g;
+var ANSI2 = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b[@-_]?/g;
 function powershellErrorLine(line) {
   const l = line.trim();
   if (l === "+" || l.startsWith("+ ")) return null;
@@ -151693,7 +152426,7 @@ function powershellErrorLine(line) {
 function clixmlErrorText(xml) {
   return [...xml.matchAll(/<S S="Error">([\s\S]*?)<\/S>/g)].map(
     (m) => m[1].replace(/_x([0-9A-Fa-f]{4})_/g, (_, hex3) => String.fromCharCode(parseInt(hex3, 16))).replace(/&(lt|gt|quot|apos|amp);/g, (_, e) => ({ lt: "<", gt: ">", quot: '"', apos: "'", amp: "&" })[e])
-  ).join("").replace(ANSI, "").split(/\r?\n/).flatMap((l) => {
+  ).join("").replace(ANSI2, "").split(/\r?\n/).flatMap((l) => {
     const kept = powershellErrorLine(l);
     return kept === null ? [] : [kept];
   }).join("\n");
@@ -151721,7 +152454,7 @@ function withoutClixml(s) {
     text2 = end < 0 ? "" : text2.slice(end + "</Objs>".length);
   }
   parts.push(plainPart(text2));
-  return parts.join("").replace(ANSI, "").split(/\r?\n/);
+  return parts.join("").replace(ANSI2, "").split(/\r?\n/);
 }
 function lastLine(s, ansi = ansiText) {
   const lines = withoutClixml(s).map((l) => l.trim()).filter((l) => l && !l.startsWith("**") && !/^Node\.js v\d/.test(l) && !/^at /.test(l));
@@ -152036,7 +152769,7 @@ async function installRemote(o) {
 function bundled(name, source) {
   for (const url2 of [new URL(`./${name}`, import.meta.url), new URL(source, import.meta.url)]) {
     const file2 = fileURLToPath6(url2);
-    if (existsSync27(file2)) return readFileSync23(file2, "utf8");
+    if (existsSync27(file2)) return readFileSync24(file2, "utf8");
   }
   throw new Error(`${name} is missing from this host`);
 }
@@ -152620,7 +153353,7 @@ var RemoteClient = class {
       this.cursorValid = true;
       this.ready = true;
       this.attempt = 0;
-      this.on.hello?.({ resync, newLifetime: !sameLifetime, protocolVersion: frame.protocolVersion, ...frame.build ? { build: frame.build } : {}, ...typeof frame.elevated === "boolean" ? { elevated: frame.elevated } : {}, ...frame.logon ? { logon: frame.logon } : {}, ...frame.handover ? { handover: frame.handover } : {} });
+      this.on.hello?.({ resync, newLifetime: !sameLifetime, protocolVersion: frame.protocolVersion, ...frame.build ? { build: frame.build } : {}, ...typeof frame.elevated === "boolean" ? { elevated: frame.elevated } : {}, ...frame.logon ? { logon: frame.logon } : {}, ...frame.handover ? { handover: frame.handover } : {}, ...frame.updateContinued ? { updateContinued: frame.updateContinued } : {} });
       return;
     }
     if (frame.kind === "res") {
@@ -152916,6 +153649,11 @@ var LinkedMachineConnection = class {
   logon = null;
   /** A sign-in's serve waiting to take over from the remote host, as its hello or `host_handover` last said (#1224) */
   handover = null;
+  /**
+   * The turns the remote host said in its last hello it continues after an update cut them, with when its start took each
+   * up, on its clock (#1618); null: a host from before that, which continues none
+   */
+  updateContinued = null;
   /** The floor could not be read from this host once already; said once in the log */
   floorUnreadable = false;
   /**
@@ -153060,6 +153798,14 @@ var LinkedMachineConnection = class {
   /** The link has just connected, its hello and lists read; `LinkedMachine` looks at the versions then (#1508) */
   connectedNow() {
   }
+  /** Whether the remote host continues the turns an update's stop cuts (#1618): its last hello said which it continues */
+  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,
@@ -153565,6 +154311,7 @@ var LinkedMachineConnection = class {
     }
     this.logon = logon2;
     this.handover = h.handover ?? null;
+    this.updateContinued = h.updateContinued ? new Map(h.updateContinued.map((c) => [c.sessionId, c.at])) : null;
     this.switched = null;
     this.switchTried = false;
     this.switchFailure = null;
@@ -153686,8 +154433,8 @@ function parseStopLine(stdout) {
   }
   return null;
 }
-async function stopRemoteHost(c) {
-  const r = await c.exec(stopCommand(c.spec));
+async function stopRemoteHost(c, o) {
+  const r = await c.exec(stopCommand(c.spec, o));
   if (r.stdout.includes(NOT_FOUND2)) return { wasRunning: false };
   const answer = parseStopLine(r.stdout);
   if (!answer) {
@@ -153739,7 +154486,7 @@ var restoredNote = (version2, target) => `The store on ${target} was put back as
 async function startOrRestore(c, to, from) {
   const why = await startAndCheck(c, to.version);
   if (!why || !isLocalBuildVersion(from?.version) || isLocalBuildVersion(to.version)) return { why };
-  await stopRemoteHost(c).catch(() => void 0);
+  await stopRemoteHost(c, { forUpdate: true }).catch(() => void 0);
   let restored = false;
   try {
     restored = await restoreStore(c, to);
@@ -153757,7 +154504,7 @@ async function putBack(c, to, why, was, restore = false) {
   const log = tail ? ` The end of its host.log: ${tail}` : "";
   const back = was.current ? `Centralu ${was.current.version}` : "the Centralu that was there";
   try {
-    await stopRemoteHost(c).catch(() => void 0);
+    await stopRemoteHost(c, { forUpdate: true }).catch(() => void 0);
     await setPointers(c, to, was.current, was.previous);
     if (restore && was.current) await restoreStore(c, was.current);
     if (was.running) await c.start();
@@ -153778,7 +154525,7 @@ async function switchRemote(c, next, was, keep, o = {}) {
   const stoppedTurns = await c.beforeStop?.() ?? null;
   await c.hold();
   c.step("stop");
-  const { wasRunning } = await stopRemoteHost(c);
+  const { wasRunning } = await stopRemoteHost(c, { forUpdate: true });
   const saveStore = o.saveStore === true && was.current !== null;
   if (saveStore && was.current) {
     c.step("backup");
@@ -153801,7 +154548,7 @@ async function switchRemote(c, next, was, keep, o = {}) {
 async function rollbackRemote(c, there) {
   await c.hold();
   c.step("stop");
-  const { wasRunning } = await stopRemoteHost(c);
+  const { wasRunning } = await stopRemoteHost(c, { forUpdate: true });
   c.step("switch");
   await setPointers(c, there.previous, there.previous, null);
   const { why, note } = await startOrRestore(c, there.previous, there.current);
@@ -153827,7 +154574,7 @@ function uninstallCommand(spec) {
 async function uninstallRemote(c) {
   await c.hold();
   c.step("stop");
-  const { wasRunning } = await stopRemoteHost(c);
+  const { wasRunning } = await stopRemoteHost(c, { forUpdate: false });
   c.step("autostart");
   await removeAutostart(c);
   c.step("remove");
@@ -153840,7 +154587,6 @@ var linkError2 = (message) => rpcError(message);
 var ACTIVITY_POLL_MS2 = 15e3;
 var ACTIVITY_SETTLE_MS = 3e3;
 var ACTIVITY_UNREAD_RETRIES = 2;
-var OPEN_WORK_WAIT_MS = 30 * 6e4;
 var FOLLOW_RETRY_MS = 10 * 6e4;
 var FOLLOW_TRIES = 2;
 var reasonOf = (signal) => signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason));
@@ -153895,9 +154641,10 @@ var LinkedMachine = class extends LinkedMachineConnection {
   }
   /**
    * `machines.update` (update.ts, plan §10.5): install beside, wait until no turn runs there (`when: 'idle'`, the default, #1399),
-   * stop, switch, start, check, or put back. `when: 'now'`: no wait, the turns running are stopped and the answer says so.
-   * `unasked`: an update nobody approved, which automatic updates cover (#1508): the hub's own catch-up (`followHub`), or an agent's
-   * call that went without a card (`followsHub`). It stops nothing it cannot see and gives up when automatic updates go off
+   * stop, switch, start, check, or put back. `when: 'now'`: no wait, the turns running are stopped, the answer says so, and the
+   * next host continues each of them once (#1618, `stopAtOnce`). `unasked`: an update nobody approved, which automatic updates
+   * cover (#1508): the hub's own catch-up (`followHub`), or an agent's call that went without a card (`followsHub`). It goes at
+   * once too (owner, 2026-10-26, #1618: a machine always busy never updated), and stops no host it cannot ask what runs
    */
   update(opts = {}) {
     return opts.unasked === true ? this.unaskedRun(() => this.updateNow(opts)) : this.updateNow(opts);
@@ -153929,7 +154676,6 @@ var LinkedMachine = class extends LinkedMachineConnection {
   cancelUpdate() {
     const wait = this.idleWait;
     if (!wait) return false;
-    if (this.followRun && this.follow === this.followRun) Object.assign(this.follow, { tries: FOLLOW_TRIES, cancelled: true });
     wait.abort(new Error(`The update of ${this.name} was cancelled while it waited for the sessions there to finish; nothing was switched`));
     return true;
   }
@@ -153947,35 +154693,18 @@ var LinkedMachine = class extends LinkedMachineConnection {
    * every answer failed is read again twice, then not waited for either: waiting on what was never seen would never end. Once an
    * answer has come, though, the wait goes on through failed readings (the row says `wait_unread`) and the host is stopped only on
    * a successful reading of none in a turn, since a busy or dropped remote reads as failed too; Cancel or Update now are the ways
-   * out. `now`: stops at once, and the answer says how many turns that ended.
-   *
-   * `unasked` (#1508): an update nobody approved stops nothing it cannot see, so a machine that cannot be told what runs there is
-   * not updated by it (the person's Update still can), and it gives up once automatic updates go off or the hub hands over
-   * to another build (`LinkDeps.autoUpdate`). Either way it ends before the host is held, so nothing was switched
+   * out. `now`, and every update nobody approved (`unasked`, #1508; at once since #1618): `stopAtOnce`.
    */
   async beforeStop(c, when, unasked = false) {
-    if (when === "now") {
-      const running2 = turnsRunning(await this.activity());
-      if (running2 === 0) return null;
-      const note = `Updating stopped Centralu on ${this.name} with ${running2} ${running2 === 1 ? "session" : "sessions"} in a turn; they resume on the new version, and a turn in progress was lost`;
-      this.deps.log?.(`[links] ${this.name}: ${note}`);
-      return note;
-    }
+    if (when === "now" || unasked) return this.stopAtOnce(unasked);
     const wait = new AbortController();
     this.idleWait = wait;
     const poll = this.deps.activityPollMs ?? ACTIVITY_POLL_MS2;
     const settle = Math.min(poll, ACTIVITY_SETTLE_MS);
-    const stillOn = () => {
-      if (unasked && this.deps.autoUpdate?.() !== true) {
-        throw new Error(`Automatic updates went off, or this computer began switching to another build, while the update of ${this.name} waited; nothing was switched`);
-      }
-    };
     const read = async () => {
       wait.signal.throwIfAborted();
-      stillOn();
       const r = await this.readActivity();
       wait.signal.throwIfAborted();
-      stillOn();
       return r;
     };
     try {
@@ -153992,32 +154721,17 @@ var LinkedMachine = class extends LinkedMachineConnection {
       const unread = () => show("wait_unread", "what runs there cannot be read now; the update keeps waiting, since the sessions there may be in a turn (Cancel ends it)");
       const busy = (a) => {
         const turns = turnsRunning(a);
-        const n = open6(a);
-        if (turns > 0) show("wait_idle", `the update waits for ${turns} ${turns === 1 ? "session" : "sessions"} in a turn`, turns);
-        else show("wait_open", `the update waits for ${n} open ${n === 1 ? "terminal or project command" : "terminals and project commands"}, which an update this computer starts by itself closes none of`, n);
+        show("wait_idle", `the update waits for ${turns} ${turns === 1 ? "session" : "sessions"} in a turn`, turns);
       };
-      const open6 = (a) => unasked ? a.terminals + a.commandRuns : 0;
-      const holding = (a) => turnsRunning(a) + open6(a);
-      let openSince = null;
-      const now = this.deps.now ?? Date.now;
-      const openLimit = this.deps.openWorkWaitMs ?? OPEN_WORK_WAIT_MS;
       for (; ; ) {
         const r = await read();
         if (r.activity) {
           seen = true;
           blind = 0;
-          if (open6(r.activity) > 0) {
-            openSince ??= now();
-            if (now() - openSince >= openLimit) {
-              throw new Error(
-                `Terminals or project commands stayed open on ${this.name}, and an update this computer starts by itself closes none of them; nothing was switched`
-              );
-            }
-          } else openSince = null;
-          if (holding(r.activity) === 0) {
+          if (turnsRunning(r.activity) === 0) {
             await pause(settle, wait.signal);
             const again = await read();
-            if (again.activity && holding(again.activity) === 0) {
+            if (again.activity && turnsRunning(again.activity) === 0) {
               if (shown3) c.step("stop");
               return null;
             }
@@ -154027,7 +154741,6 @@ var LinkedMachine = class extends LinkedMachineConnection {
         } else if (seen) {
           unread();
         } else if (r.cannot || ++blind > ACTIVITY_UNREAD_RETRIES) {
-          if (unasked) throw new Error(this.blindSentence());
           this.deps.log?.(`[links] ${this.name}: it cannot be told what runs there, so the update does not wait for it`);
           return null;
         }
@@ -154038,14 +154751,38 @@ var LinkedMachine = class extends LinkedMachineConnection {
     }
   }
   /**
-   * Before an update nobody approved installs anything (#1508 review): what runs there must be readable. A failed reading is
-   * tried again twice, a poll apart, as the wait does (`ACTIVITY_UNREAD_RETRIES`); a host that cannot be asked at all is not
+   * An update that does not wait (#1618): the person's `when: 'now'`, and every update nobody approved (owner, 2026-10-26: the
+   * hub's own catch-up used to wait for the turns there, and for its terminals and project commands, and a machine always busy
+   * never updated). It reads what runs there once, for the answer's sentence, and the host is stopped: the turns running end,
+   * and terminals and project commands close. Which turns that stop ends the stopping host lists itself, as it stops
+   * (`host.stop { forUpdate }`, update.ts `stopRemoteHost`), and the host the update starts continues each of them once.
+   *
+   * An update nobody approved stops no host it cannot ask what runs (#1508): a reading that fails is tried again as
+   * `probeActivity` does, then the update fails before the hold, nothing switched. The person's `now` goes on unread
+   */
+  async stopAtOnce(unasked) {
+    const a = unasked ? await this.probeActivity() : await this.activity();
+    const running2 = turnsRunning(a);
+    const open6 = a ? a.terminals + a.commandRuns : 0;
+    const goesOn = this.continuesCutTurns();
+    const after = goesOn ? "Centralu continues each of those turns on the new version" : "they resume on the new version, and a turn in progress was lost";
+    if (unasked) this.deps.log?.(`[links] ${this.name}: updating it now, since automatic updates are on${running2 ? `; ${running2} ${running2 === 1 ? "session" : "sessions"} in a turn there: ${after}` : ""}`);
+    if (running2 === 0) return null;
+    const closed = open6 ? `, and ${open6} open ${open6 === 1 ? "terminal or project command" : "terminals and project commands"} there closed` : "";
+    const note = `Updating stopped Centralu on ${this.name} with ${running2} ${running2 === 1 ? "session" : "sessions"} in a turn; ${after}${closed}`;
+    this.deps.log?.(`[links] ${this.name}: ${note}`);
+    return note;
+  }
+  /**
+   * Before an update nobody approved installs anything (#1508 review), and again right before it stops the host (#1618): what
+   * runs there must be readable. A failed reading is tried again twice, a poll apart, as the wait does
+   * (`ACTIVITY_UNREAD_RETRIES`); a host that cannot be asked at all is not
    */
   async probeActivity() {
     const poll = this.deps.activityPollMs ?? ACTIVITY_POLL_MS2;
     for (let i = 0; ; i++) {
       const r = await this.readActivity();
-      if (r.activity) return;
+      if (r.activity) return r.activity;
       if (r.cannot || i >= ACTIVITY_UNREAD_RETRIES) throw linkError2(this.blindSentence());
       await pause(poll, new AbortController().signal);
     }
@@ -154060,8 +154797,6 @@ var LinkedMachine = class extends LinkedMachineConnection {
    * failed, and the retry's timer. `due`: the retry's time has come, and it runs at the next chance (connected, not busy)
    */
   follow = null;
-  /** The hub's own update that runs now, if one does */
-  followRun = null;
   /**
    * Whether an idle update of this machine is the hub's catch-up that needs no one's approval (#1508): the hub's automatic
    * updates are on (`LinkDeps.autoUpdate`), this hub can update it (`operationRefusal`), the person did not remove what the
@@ -154076,7 +154811,7 @@ var LinkedMachine = class extends LinkedMachineConnection {
     const hub = this.deps.hub.version;
     if (!v || v.hub.version !== hub || isLocalBuildVersion(hub) || isLocalBuildVersion(v.remote.version)) return false;
     const f = this.follow;
-    if (f?.version === hub && (f.cancelled === true || f.tries >= FOLLOW_TRIES)) return false;
+    if (f?.version === hub && f.tries >= FOLLOW_TRIES) return false;
     return v.older === "remote";
   }
   /** At every connect: a machine found on an older release follows the hub (#1508) */
@@ -154084,9 +154819,10 @@ var LinkedMachine = class extends LinkedMachineConnection {
     this.followHub();
   }
   /**
-   * Starts the hub's own idle update of this machine (#1508) when it follows the hub (`followsHub`), the link is up and
-   * nothing else runs there: once per version of the hub's, and once more `FOLLOW_RETRY_MS` after a failure. Sessions in a
-   * turn there are waited for (`machines.update { when: 'idle' }`, #1399); the steps show on the row as the person's do
+   * Starts the hub's own update of this machine (#1508) when it follows the hub (`followsHub`), the link is up and nothing
+   * else runs there: once per version of the hub's, and once more `FOLLOW_RETRY_MS` after a failure. It does not wait for
+   * what runs there (#1618, `stopAtOnce`): the turns it ends continue on the new version, and terminals and project
+   * commands close. The steps show on the row as the person's do
    */
   followHub() {
     if (this.stopped || this.busy || this.status !== "connected" || !this.followsHub()) return;
@@ -154097,13 +154833,13 @@ var LinkedMachine = class extends LinkedMachineConnection {
       this.follow = { version: version2, tries: 0, failed: null, retryAt: null, due: false };
     }
     this.deps.log?.(
-      `[links] ${this.name}: runs Centralu ${this.versions?.remote.version ?? "an older version"}, older than this computer's ${version2}; updating it once no session there is in a turn, since automatic updates are on`
+      `[links] ${this.name}: runs Centralu ${this.versions?.remote.version ?? "an older version"}, older than this computer's ${version2}; updating it, since automatic updates are on`
     );
-    void this.update({ when: "idle", unasked: true }).catch(() => void 0);
+    void this.update({ when: "now", unasked: true }).catch(() => void 0);
   }
   /**
    * Runs an update nobody approved as one try for this hub's version (#1508 review): the hub's own catch-up and an agent's
-   * card-less `machines.update` or `install_machine` alike, so a cancel or two failures spend the version for both
+   * card-less `machines.update` or `install_machine` alike, so two failures spend the version for both
    * (`followsHub`). A failure shows on the row and, with a try left, is tried once more `FOLLOW_RETRY_MS` later. A call refused
    * because something else runs there spends nothing
    */
@@ -154120,7 +154856,6 @@ var LinkedMachine = class extends LinkedMachineConnection {
     f.tries += 1;
     f.due = false;
     f.retryAt = null;
-    this.followRun = f;
     try {
       const r = await run4();
       if (this.follow === f) {
@@ -154130,8 +154865,8 @@ var LinkedMachine = class extends LinkedMachineConnection {
       return r;
     } catch (err) {
       if (this.follow === f && !this.stopped) {
-        f.failed = f.cancelled ? null : errorMessage(err);
-        if (!f.cancelled && f.tries < FOLLOW_TRIES) {
+        f.failed = errorMessage(err);
+        if (f.tries < FOLLOW_TRIES) {
           const ms3 = this.deps.followRetryMs ?? FOLLOW_RETRY_MS;
           f.retryAt = Date.now() + ms3;
           f.timer = setTimeout(() => {
@@ -154144,8 +154879,6 @@ var LinkedMachine = class extends LinkedMachineConnection {
         this.deps.broadcast({ type: "machine_status", machine: this.info() });
       }
       throw err;
-    } finally {
-      if (this.followRun === f) this.followRun = null;
     }
   }
   info() {
@@ -154479,7 +155212,7 @@ function probeTarget(target, opts = {}) {
 }
 
 // packages/agent-host/src/links/ssh-config.ts
-import { readdirSync as readdirSync15, readFileSync as readFileSync24, statSync as statSync15 } from "node:fs";
+import { readdirSync as readdirSync16, readFileSync as readFileSync25, statSync as statSync15 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
 import { isAbsolute as isAbsolute11, join as join57, normalize, parse as parse5, sep as sep11 } from "node:path";
 var MAX_DEPTH = 16;
@@ -154552,7 +155285,7 @@ function expandGlob(path2) {
       }
       let names;
       try {
-        names = readdirSync15(base2);
+        names = readdirSync16(base2);
       } catch {
         continue;
       }
@@ -154589,7 +155322,7 @@ function readSshConfig(opts) {
     }
     let text2;
     try {
-      text2 = readFileSync24(file2, "utf8");
+      text2 = readFileSync25(file2, "utf8");
     } catch (err) {
       if (depth > 0 && err.code !== "ENOENT") notes.push(`${tildePath(file2, opts.home)} could not be read`);
       return;
@@ -155294,6 +156027,13 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     machineWaitsForPerson(machineId) {
       return machineById(machineId)?.waitsForPerson === true;
     },
+    continuesCutTurns(machineId) {
+      return machineById(machineId)?.continuesCutTurns?.() === true;
+    },
+    continuedAfterUpdate(sessionId) {
+      const at2 = splitQualified(sessionId);
+      return (at2 && machineById(at2.machine)?.continuedAfterUpdate?.(at2.id)) ?? null;
+    },
     async backgroundTasks(machineId) {
       const m = machineById(machineId);
       if (!m || !m.reachable) return null;
@@ -156665,7 +157405,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 ? "137a245" : "dev";
+var BUILD = true ? "6e6bc62" : "dev";
 var { values } = parseArgs({
   options: {
     port: { type: "string", default: "5175" },
@@ -156744,6 +157484,7 @@ if (!lock.ok) {
 var ownership = lock;
 process.on("exit", ownership.release);
 if (dbPath !== ":memory:") clearStoppedMark(dirname26(dbPath));
+var updateResume = dbPath === ":memory:" ? void 0 : updateResumeFolder(dirname26(dbPath));
 start.at("hold signals");
 var signals = holdSignals(process, (line) => console.error(line));
 start.at("store");
@@ -156778,7 +157519,7 @@ 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
   join58(dirname26(dbPath), "worktrees"),
-  held2 ? { processes: held2.processes, keptSessions: held2.kept.sessionIds } : {}
+  { ...held2 ? { processes: held2.processes, keptSessions: held2.kept.sessionIds } : {}, ...updateResume ? { updateResume } : {} }
 );
 mgr.useProjectsHome(() => projectsHome());
 mgr.useMemoryGate(new MemoryGate());
@@ -157005,8 +157746,9 @@ if (launch.underKeeper) {
 }
 var stopNow = null;
 var stopAsked = false;
-var stopFromRequest = () => {
-  console.error("[agent-host] asked to stop (centralu serve --stop)");
+var stopFromRequest = (o) => {
+  console.error(`[agent-host] asked to stop (centralu serve --stop${o.forUpdate ? ", for an update" : ""})`);
+  if (o.forUpdate) mgr.stopForUpdate();
   if (stopNow) stopNow();
   else stopAsked = true;
 };
@@ -157081,7 +157823,7 @@ var router = new Router({
     inlineViews,
     heldPids: held2?.heldPids,
     machines: links,
-    stopHost: launch.startedByServe && !launch.underKeeper ? () => stopFromRequest() : void 0,
+    stopHost: launch.startedByServe && !launch.underKeeper ? (o) => stopFromRequest(o) : void 0,
     // `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
@@ -157139,6 +157881,8 @@ var server = new HostServer({
   // Which Windows logon it runs in, for a hub linked to it (#1224); asked with the elevation
   logon: () => logon,
   handover: () => handover,
+  // The turns this host continued after an update cut them, for a linked hub's callers (#1618)
+  updateContinued: () => mgr.updateContinued(),
   // A planned swap waits for running RPCs, within a bound (#280 step 3, drain.ts)
   drain: hostDrain
 });