@centralu/host-linux-x64 0.1.0-beta.50 → 0.1.0-beta.51

package/host/bundle-info.json

@@ -1,11 +1,11 @@
 {
-  "commit": "3bbc42b",
+  "commit": "5f99652",
   "protocolVersion": 1,
   "hostProof": 1,
   "tokenOnStdin": 1,
   "verifiers": 1,
   "keyPairing": 1,
-  "builtAt": "2026-11-06T23:11:15.183Z",
+  "builtAt": "2026-11-07T05:42:39.476Z",
   "runtime": "system-node",
   "platform": "linux",
   "arch": "x64"

package/host/centralu-package.json

@@ -1,6 +1,6 @@
 {
   "name": "centralu",
-  "version": "0.1.0-beta.50",
+  "version": "0.1.0-beta.51",
   "description": "Run, watch and steer several Claude Code and Codex CLI sessions from one window",
   "license": "MIT",
   "author": "ijun17",
@@ -38,9 +38,9 @@
     "win32"
   ],
   "optionalDependencies": {
-    "@centralu/darwin-arm64": "0.1.0-beta.50",
-    "@centralu/linux-arm64": "0.1.0-beta.50",
-    "@centralu/linux-x64": "0.1.0-beta.50",
-    "@centralu/win32-x64": "0.1.0-beta.50"
+    "@centralu/darwin-arm64": "0.1.0-beta.51",
+    "@centralu/linux-arm64": "0.1.0-beta.51",
+    "@centralu/linux-x64": "0.1.0-beta.51",
+    "@centralu/win32-x64": "0.1.0-beta.51"
   }
 }

package/host/main.mjs

@@ -43050,7 +43050,7 @@ import { dirname as dirname27, join as join59 } from "node:path";
 import { mkdirSync as mkdirSync21, readFileSync as readFileSync27, writeSync as writeSync4 } from "node:fs";
 
 // packages/protocol/src/version.generated.ts
-var APP_VERSION = "0.1.0-beta.50";
+var APP_VERSION = "0.1.0-beta.51";
 
 // packages/protocol/src/brand.ts
 var APP_NAME = "Centralu";
@@ -108241,6 +108241,9 @@ function lowestPreset(...presets) {
 function presetWithin(child, parent) {
   return PRESET_RANK[child] <= PRESET_RANK[parent];
 }
+function aboveCallerError(name, child, caller) {
+  return presetWithin(child, caller) ? null : `"${name}" now has more permissions (${child}) than this session (${caller}), so this session cannot give it work. Tell the person.`;
+}
 var PARENT_MAIL = 'To write to it before you finish, call mail with `to: "parent"`. ';
 function canMailParent(child, senderId) {
   return child.askedBy === senderId && !!child.projectId;
@@ -114345,6 +114348,7 @@ var START_AGENT_MODEL_CHECK_MS = 3e3;
 var START_AGENT_SETUP_MS = 2e5;
 var START_AGENT_CALL_MS = 27e4;
 var ASK_THE_PERSON = "Do not do this with your own subagents instead: tell the person what stopped it and let them decide.";
+var UNTRUSTED_START = `This session's project is not trusted, so it cannot start agents \u2014 the person can trust it from the project menu. ${ASK_THE_PERSON}`;
 function agentStartPending(req, lowMemory) {
   return { ok: true, state: "pending", sessionId: req.requestId, sessionName: "", tool: req.detail.tool, ...lowMemory ? { lowMemory } : {} };
 }
@@ -114385,21 +114389,6 @@ var AgentStartGates = class {
    * many. Counted by `agentCeilingError` with the running children, so starts at once cannot pass the ceiling together.
    */
   agentStartReserved = /* @__PURE__ */ new Map();
-  /**
-   * What a child's start rests on in its caller, read once the person allowed it and again once its session exists,
-   * right before its delegation is registered: the caller is still here, its project still registered and trusted
-   * (or the caller is `auto`), and it is still above the agent depth (#867), which `auto` does not open.
-   */
-  agentStartGateError(callerId, projectId) {
-    const caller = this.host.meta.get(callerId);
-    if (!caller) return "The session that asked is no longer here.";
-    if (projectId === ORCHESTRATOR_PLACE && caller.kind === "orchestrator") return agentDepthRefusal(this.host, callerId, "start agents");
-    const now = this.host.store.projects.listProjects().find((p) => p.id === projectId);
-    if (!now) return "This session's project is no longer registered.";
-    const auto = caller.permissionPreset === "auto";
-    if (now.trusted !== true && !auto) return `This session's project is no longer trusted, so it cannot start agents. ${ASK_THE_PERSON}`;
-    return agentDepthRefusal(this.host, callerId, "start agents");
-  }
   /**
    * A place under the per-project ceiling, checked and taken in one synchronous step (`agentStartReserved`), for a start
    * (`createAgentChild`) or a fork (`forkFor`) that waits on something before its delegation counts the child.
@@ -114439,6 +114428,16 @@ var AgentStartGates = class {
     return `${running2} agents ${whose} are already working, the most at once. Wait for one (${wait}) or stop one, then try again.`;
   }
 };
+function agentStartGateError(host, callerId, projectId) {
+  const caller = host.meta.get(callerId);
+  if (!caller) return "The session that asked is no longer here.";
+  if (projectId === ORCHESTRATOR_PLACE && caller.kind === "orchestrator") return agentDepthRefusal(host, callerId, "start agents");
+  const now = host.store.projects.listProjects().find((p) => p.id === projectId);
+  if (!now) return "This session's project is no longer registered.";
+  const auto = caller.permissionPreset === "auto";
+  if (now.trusted !== true && !auto) return `This session's project is no longer trusted, so it cannot start agents. ${ASK_THE_PERSON}`;
+  return agentDepthRefusal(host, callerId, "start agents");
+}
 
 // packages/agent-host/src/sessions/agent-consents.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
@@ -114866,7 +114865,7 @@ var AgentStartFlow = class {
       return done2({ ok: false, error: "A session the orchestrator starts works outside any project, so it has no worktree. Start it without one, or hand the work to a project's session with send_to_session." });
     }
     if (project2.trusted !== true && !this.host.autoBoundaryOpen(callerId, "start in an untrusted project")) {
-      return done2({ ok: false, error: `This session's project is not trusted, so it cannot start agents \u2014 the person can trust it from the project menu. ${ASK_THE_PERSON}` });
+      return done2({ ok: false, error: UNTRUSTED_START });
     }
     const waiting = [...this.host.children.agentStarts.values()].find(
       (r5) => !r5.ended && r5.req.callerId === callerId && r5.req.task === opts.task && (!opts.tool || r5.req.tool === opts.tool)
@@ -114978,7 +114977,7 @@ var AgentStartFlow = class {
    */
   async createAgentChild(callerId, project2, choice, progress, approvedPreset, requestId) {
     const done2 = (r) => ({ done: r });
-    const refused2 = this.agentStartGateError(callerId, project2.id);
+    const refused2 = agentStartGateError(this.host, callerId, project2.id);
     if (refused2) return done2({ ok: false, error: refused2 });
     const caller = this.host.meta.get(callerId);
     if (approvedPreset && !presetWithin(caller.permissionPreset, approvedPreset)) {
@@ -115007,10 +115006,6 @@ var AgentStartFlow = class {
       release();
     }
   }
-  /** `AgentStartGates.agentStartGateError` (agent-start-gates.ts), kept on the flow for its callers */
-  agentStartGateError(...a) {
-    return this.gates.agentStartGateError(...a);
-  }
   /** `AgentStartGates.reservePlace` (agent-start-gates.ts), kept on the flow for its callers */
   reservePlace(...a) {
     return this.gates.reservePlace(...a);
@@ -115082,7 +115077,7 @@ var AgentStartFlow = class {
     recordAgentDepth(this.host, child.id, callerId);
     const callerNow = this.host.meta.get(callerId);
     const withdrawn = requestId ? this.host.children.agentStarts.get(requestId)?.ended : void 0;
-    const late = (withdrawn && "error" in withdrawn ? `The request was withdrawn while its session was being made. ${withdrawn.error}` : null) ?? this.agentStartGateError(callerId, project2.id) ?? (callerNow && !presetWithin(child.permissionPreset, callerNow.permissionPreset) ? `This session's permissions were lowered to ${callerNow.permissionPreset} while the session was being made.` : null);
+    const late = (withdrawn && "error" in withdrawn ? `The request was withdrawn while its session was being made. ${withdrawn.error}` : null) ?? agentStartGateError(this.host, callerId, project2.id) ?? (callerNow && !presetWithin(child.permissionPreset, callerNow.permissionPreset) ? `This session's permissions were lowered to ${callerNow.permissionPreset} while the session was being made.` : null);
     const name = choice.name ?? (worktree ? void 0 : agentName(choice.task));
     if (late) return done2(await this.abandonChild(child, late, name));
     progress.stage = "created";
@@ -115757,7 +115752,7 @@ var AgentSessionActions = class {
     const seat = caller?.projectId ? "project" : caller?.kind === "orchestrator" ? "orchestrator" : null;
     const owns = seat === "orchestrator" ? child?.askedBy === callerId : startedHere || !deletingWithoutWorktree && this.host.autoBoundaryOpen(callerId, "session ownership");
     if (!caller || !seat || !child || !owns || child.projectId !== caller.projectId) {
-      return { ok: false, error: `${opts.sessionId} is not a session this session started. agent_session works only on sessions start_agent started here.${child ? "" : staleSessionHint(this.host, opts.sessionId, (s) => s.projectId === caller?.projectId && s.id !== callerId && (seat !== "orchestrator" || s.askedBy === callerId))}` };
+      return { ok: false, error: `${opts.sessionId} is not a session this session started. agent_session works only on sessions start_agent started from here.${child ? "" : staleSessionHint(this.host, opts.sessionId, (s) => s.projectId === caller?.projectId && s.id !== callerId && (seat !== "orchestrator" || s.askedBy === callerId))}` };
     }
     if (opts.sessionId === callerId) return this.flow.agentAtRest(child);
     if (opts.action === "answer") return this.host.answerRoutedCard(callerId, child.id, opts.card, opts.text ?? "");
@@ -115829,12 +115824,8 @@ var AgentSessionActions = class {
           return { ok: true, state: "deleted", sessionId: child.id, sessionName: child.name, tool: child.tool, branch: r.branch, setAside: r.setAside, ...r.warning ? { warning: r.warning } : {}, ...note2 ? { note: note2 } : {} };
         }
         case "send": {
-          if (!presetWithin(child.permissionPreset, caller.permissionPreset)) {
-            return {
-              ok: false,
-              error: `"${child.name}" now has more permissions (${child.permissionPreset}) than this session (${caller.permissionPreset}), so this session cannot give it work. Tell the person.`
-            };
-          }
+          const above = aboveCallerError(child.name, child.permissionPreset, caller.permissionPreset);
+          if (above) return { ok: false, error: above };
           const refused2 = this.host.refusesDelegation(callerId, { sessionId: child.id, projectId: child.projectId }, { tool: "agent_session", target: child.name || child.id, text: opts.text ?? "" });
           if (refused2) return { ok: false, error: refused2 };
           const from = { sessionId: callerId, name: labelOf(this.host.store.messages, caller) };
@@ -116182,9 +116173,11 @@ var RemoteAgents = class {
     if (!caller?.projectId) {
       return { ok: false, error: caller?.kind === "orchestrator" ? "The orchestrator starts a session on a linked machine with create_session; start_agent with a machine is for a project's session." : "This session belongs to no project, so it cannot start agents." };
     }
+    const project2 = this.host.store.projects.listProjects().find((p) => p.id === caller.projectId);
+    if (!project2) return { ok: false, error: "This session's project is no longer registered." };
+    if (project2.trusted !== true && !this.host.autoBoundaryOpen(callerId, "start in an untrusted project")) return { ok: false, error: UNTRUSTED_START };
     const refused2 = this.gateError(callerId);
     if (refused2) return { ok: false, error: refused2 };
-    const project2 = this.host.store.projects.listProjects().find((p) => p.id === caller.projectId);
     const full = this.places.agentCeilingError(callerId, project2.id);
     if (full) return { ok: false, error: full };
     const reader = this.host.linkedReader;
@@ -116377,11 +116370,8 @@ var RemoteAgents = class {
       case "send": {
         const text3 = opts.text?.trim();
         if (!text3) return { ok: false, error: "Give the text to send." };
-        const childPreset = rec.preset ?? "normal";
-        const own = this.callerPreset(callerId);
-        if (!presetWithin(childPreset, own)) {
-          return { ok: false, error: `"${rec.name}" now has more permissions (${childPreset}) than this session (${own}), so this session cannot give it work. Tell the person.` };
-        }
+        const above = aboveCallerError(rec.name, rec.preset ?? "normal", this.callerPreset(callerId));
+        if (above) return { ok: false, error: above };
         const now = await stateOf();
         if (!now.ok) return now;
         if (now.running) {
@@ -116413,16 +116403,8 @@ var RemoteAgents = class {
         return this.sendAtRest(rec, callerId, text3, label, reader);
       }
       case "stop": {
-        const owed = this.host.children.linkedReports.get(rec.sessionId);
-        if (owed?.orchestratorId === callerId) this.host.children.dropLinkedReport(rec.sessionId);
-        const held3 = rec.queued;
-        this.setQueued(rec.sessionId, []);
-        const r = await reader.interrupt(rec.sessionId);
-        if (!r.ok) {
-          if (held3) this.setQueued(rec.sessionId, held3);
-          if (owed?.orchestratorId === callerId && !this.host.children.linkedReports.has(rec.sessionId)) this.host.children.setLinkedReport(rec.sessionId, owed);
-          return { ok: false, error: `Could not stop "${rec.name}" on ${rec.machine}: ${bare(r.error)}.` };
-        }
+        const r = await this.interruptFor(rec, callerId, reader);
+        if (!r.ok) return { ok: false, error: `Could not stop "${rec.name}" on ${rec.machine}: ${bare(r.error)}.` };
         return { ok: true, state: "stopped", sessionId: rec.sessionId, sessionName: rec.name, tool: rec.tool };
       }
       case "delete": {
@@ -116441,14 +116423,9 @@ var RemoteAgents = class {
         const now = await stateOf();
         if (!now.ok) return now;
         if (now.running) {
-          const owed = this.host.children.linkedReports.get(rec.sessionId);
-          if (owed?.orchestratorId === callerId) this.host.children.dropLinkedReport(rec.sessionId);
-          const stopped = await reader.interrupt(rec.sessionId);
-          if (!stopped.ok) {
-            if (owed?.orchestratorId === callerId && !this.host.children.linkedReports.has(rec.sessionId)) this.host.children.setLinkedReport(rec.sessionId, owed);
-            return { ok: false, error: `Could not stop "${rec.name}" on ${rec.machine} before deleting it: ${bare(stopped.error)}.` };
-          }
-        }
+          const stopped = await this.interruptFor(rec, callerId, reader);
+          if (!stopped.ok) return { ok: false, error: `Could not stop "${rec.name}" on ${rec.machine} before deleting it: ${bare(stopped.error)}.` };
+        } else this.setQueued(rec.sessionId, []);
         const canClean = typeof reader.deleteAgentChild === "function";
         const withWorktree = rec.worktree && canClean ? await reader.deleteAgentChild(rec.sessionId, rec.worktree).catch((e) => ({ ok: false, error: e instanceof Error ? e.message : String(e) })) : void 0;
         if (withWorktree && !withWorktree.ok) return { ok: false, error: `Could not delete "${rec.name}" on ${rec.machine}: ${bare(withWorktree.error)}.` };
@@ -116713,6 +116690,22 @@ var RemoteAgents = class {
     this.scheduleDrain(rec.sessionId);
     return { ok: true, tool: rec.tool, state: "queued", sessionId: rec.sessionId, sessionName: rec.name, queueId: entry.id, position: (same ? held3.indexOf(same) : held3.length) + 1 };
   }
+  /**
+   * Stops the child's turn there for a stop or a deletion by the one it would report to: nothing more is owed, and its
+   * end must not send what was held for it. Both are taken down first, as the stopped turn's end can reach the hub before
+   * the machine's answer does, and put back if the stop does not go
+   */
+  async interruptFor(rec, callerId, reader) {
+    const owed = this.host.children.linkedReports.get(rec.sessionId);
+    if (owed?.orchestratorId === callerId) this.host.children.dropLinkedReport(rec.sessionId);
+    const held3 = this.of(rec.sessionId)?.queued;
+    this.setQueued(rec.sessionId, []);
+    const r = await reader.interrupt(rec.sessionId);
+    if (r.ok) return r;
+    if (held3) this.setQueued(rec.sessionId, held3);
+    if (owed?.orchestratorId === callerId && !this.host.children.linkedReports.has(rec.sessionId)) this.host.children.setLinkedReport(rec.sessionId, owed);
+    return r;
+  }
   setQueued(sessionId, queued) {
     if (!queued.length && !this.of(sessionId)?.queued) return;
     this.save(this.records().map((r) => r.sessionId === sessionId ? { ...r, queued: queued.length ? queued : void 0 } : r));
@@ -117100,16 +117093,9 @@ Reason, by kind: ${errorKind(why2)} (its words are an error's, kept in this noti
     for (const key of [...this.toldCards]) if (key.startsWith(`${sessionId}\0`)) this.toldCards.delete(key);
     if (this.host.children.linkedReports.has(sessionId)) this.host.children.dropLinkedReport(sessionId);
   }
-  /** What start_agent and a send rest on in the caller, read again after a card: here, in a trusted project, above the depth */
+  /** What start_agent and a send rest on in the caller, read again after a card and before each send: a local start's (`agentStartGateError`) */
   gateError(callerId) {
-    const caller = this.host.meta.get(callerId);
-    if (!caller) return "The session that asked is no longer here.";
-    const project2 = this.host.store.projects.listProjects().find((p) => p.id === caller.projectId);
-    if (!project2) return "This session's project is no longer registered.";
-    if (project2.trusted !== true && !this.host.autoBoundaryOpen(callerId, "start in an untrusted project")) {
-      return `This session's project is not trusted, so it cannot start agents \u2014 the person can trust it from the project menu. ${ASK_THE_PERSON}`;
-    }
-    return agentDepthRefusal(this.host, callerId, "start agents");
+    return agentStartGateError(this.host, callerId, this.host.meta.get(callerId)?.projectId || null);
   }
   /** The caller's preset as it is now; `safe` for one gone, so nothing is decided on a preset no one has */
   callerPreset(callerId) {
@@ -122730,10 +122716,6 @@ var MailboxRecords = class {
   markDelivered(recipient, ids, at2, turnSeq) {
     this.update("delivered_at = ?, last_error = NULL, turn_seq = ?", [at2, turnSeq], recipient, ids);
   }
-  /** These delivered rows were delivered in the turn `turnSeq` (the delivery began it after it delivered them) */
-  markTurn(recipient, ids, turnSeq) {
-    this.update("turn_seq = ?", [turnSeq], recipient, ids, "delivered_at IS NOT NULL");
-  }
   /** Sets why mail waits for the person (`policy`, `loop`, `budget`, `failed`, `uncertain`), or clears it with null */
   hold(recipient, ids, why2) {
     this.update("held = ?", [why2], recipient, ids);
@@ -125182,11 +125164,6 @@ var MessageService = class {
     });
     return { needReply, unread: unread2, waiting, held: held3 };
   }
-  /** The messages to or from `address`, newest first, as the address reads them (the person's Inbox feed, M6's `mail.inbox`, §12.2). Marks nothing */
-  feed(address, opts) {
-    const found = this.records.feedOf(address, { ...opts.before === void 0 ? {} : { before: opts.before }, limit: opts.limit + 1 });
-    return { items: found.slice(0, opts.limit).map((m) => this.item(m, address, null)), older: found.length > opts.limit };
-  }
   /**
    * Whether mail that wakes `recipient` waits for it, due or not yet (the debounce makes a message wait a moment before it is due): a turn of its own is
    * coming, which a note of the host's should follow. Reads only; mail that is held out or settled is not waiting
@@ -125270,10 +125247,6 @@ var MessageService = class {
       asker: turnStarts && toOrchestrator ? picked : null
     };
   }
-  /** The delivery began a turn for `recipient` (it called `MailTurns.begin`): the rows it delivered were delivered in that turn */
-  turnStarted(recipient, messageIds, turnSeq) {
-    this.run(() => this.records.markTurn(recipient, messageIds, turnSeq));
-  }
   /**
    * What a host that died left half done (§7.6.5 of the old plan): a delivery whose attempt was written and whose acceptance was not. It is not sent
    * again on its own, since an inline task the tool took just before the host died would start the same work twice: it is held `uncertain`, for the
@@ -125435,29 +125408,6 @@ var MessageService = class {
       return rows3.length;
     });
   }
-  /** One line for the person's guidance per project with mail held for its trust or delegations refused (§7.4) */
-  heldByProject() {
-    const byProject = /* @__PURE__ */ new Map();
-    const entry = (projectId) => {
-      const kept = byProject.get(projectId) ?? { count: 0, refused: 0, recipients: /* @__PURE__ */ new Set() };
-      byProject.set(projectId, kept);
-      return kept;
-    };
-    for (const { row, senderProject } of this.records.heldPolicy()) {
-      if (senderProject === null) continue;
-      const e = entry(senderProject);
-      e.count++;
-      e.recipients.add(row.recipient);
-    }
-    for (const { message } of this.records.refusedRecords()) {
-      const e = message.facts.refused ? entry(message.facts.refused.projectId) : void 0;
-      if (e) {
-        e.refused++;
-        e.recipients.add(message.facts.refused?.target ?? "");
-      }
-    }
-    return [...byProject].map(([projectId, e]) => ({ projectId, count: e.count, refused: e.refused, recipients: [...e.recipients] })).sort((a, b2) => a.projectId.localeCompare(b2.projectId));
-  }
   // ── Parties that go, parties that take over (§7.7) ──
   /** A session went to the trash or was deleted: its watched rows are `gone`, its own watched messages `withdrawn`, and each sender whose needsReply message it leaves is told once (D25) */
   partyGone(address) {
@@ -125477,6 +125427,8 @@ var MessageService = class {
    * `needsReply` message, the person's too) is released with the cause, and each sender is told once, in one notice. The rows stay open, so a reply that
    * comes after the person continues the session still answers them. A question delivered in an earlier turn is not this stop's: it was read, and the
    * session may have answered it in conversation. A task is not released here: the old report path tells its owner until requests decide reports.
+   * A request to the orchestrator is (owner: its sender always learns it will not be answered, #1186): the turn's report tells the asker it was owed to,
+   * which the caller passes as `held`, and every other asker, or one that report misses (an asker the same quit cut), gets the stop notice.
    * `turnSeq` is the cut turn (none: nothing is released, as for a turn the mailbox never recorded)
    *
    * Who is woken (Q1): a sender that is at rest and waits on the stopped session, by a task it gave it that is still open or by a wait (`waitsOn`).
@@ -125499,10 +125451,7 @@ var MessageService = class {
           if (turnSeq === null) continue;
           const rows3 = this.records.watchedTo(address);
           const gave = new Set(rows3.filter((r) => this.records.message(r.messageId)?.kind === "task").flatMap((r) => this.records.message(r.messageId)?.sender ?? []));
-          for (const row of rows3) {
-            if (row.releasedAt !== null || row.deliveredAt === null || row.answerId !== null || row.turnSeq !== turnSeq) continue;
-            const m = this.records.message(row.messageId);
-            if (!m || m.kind === "task" || !m.needsReply || m.sender === address || this.isRequest(m, address)) continue;
+          for (const { row, message: m } of this.cutQuestions(address, turnSeq)) {
             if (!this.records.markReleased(row.messageId, address, now, why2)) continue;
             released++;
             if (gave.has(m.sender) || this.opts.waitsOn?.(m.sender, address)) waiting.add(m.sender);
@@ -125580,14 +125529,22 @@ var MessageService = class {
   turnsLost(close) {
     this.releaseAndTell((now, senders) => {
       for (const { address, turnSeq } of close()) {
-        for (const row of this.records.unansweredTo(address)) {
-          if (row.turnSeq !== turnSeq || row.settled !== null) continue;
-          const m = this.records.message(row.messageId);
-          if (m && m.kind !== "task" && this.records.markReleased(row.messageId, address, now, "lost")) senders.add(m.sender);
-        }
+        for (const { row, message } of this.cutQuestions(address, turnSeq)) if (this.records.markReleased(row.messageId, address, now, "lost")) senders.add(message.sender);
       }
     });
   }
+  /**
+   * The questions `address` left unanswered in its turn `turnSeq`, the rows a stop (`sessionsStopped`) or a lost turn (`turnsLost`) releases: each
+   * `needsReply` message delivered into that turn and not answered, settled or released, a request to the orchestrator included. Not a task (the old
+   * report path tells its owner, #698), nor a message the session sent itself (a handoff to the very session that asked leaves such a row)
+   */
+  cutQuestions(address, turnSeq) {
+    return this.records.unansweredTo(address).flatMap((row) => {
+      if (row.turnSeq !== turnSeq || row.settled !== null || row.releasedAt !== null) return [];
+      const message = this.records.message(row.messageId);
+      return message && message.kind !== "task" && message.sender !== address ? [{ row, message }] : [];
+    });
+  }
   /** One write: `release` releases rows and adds each released question's sender to `senders`; then each sender is told once, in one notice (D25) */
   releaseAndTell(release, quiet = () => false) {
     this.run(() => {
@@ -156054,7 +156011,6 @@ function updateNodeSentence(o) {
 import { execFileSync as execFileSync5, spawn as spawn6 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
 import { createConnection as createConnection2, createServer as createServer3 } from "node:net";
-import { win32 as win329 } from "node:path";
 import { hostname as hostname3 } from "node:os";
 
 // packages/agent-host/src/links/ssh-run.ts
@@ -156468,7 +156424,7 @@ var SshTunnel = class {
     const r = await this.run([...this.config(), "-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", "--", this.opts.target, detachCommand(remote, this.opts.hubName ?? hostname3())], void 0, this.opts.detachTimeoutMs ?? SSH_DETACH_TIMEOUT_MS);
     this.ifClosed();
     if (r.code === 255) throw new Error(`ssh could not reach ${this.opts.target}: ${lastLine(r.stderr) || "no answer"}`);
-    if (r.stdout.includes(NOT_FOUND2) || r.code === 127 && !remote.command) throw notInstalled(this.where, remote);
+    if (r.stdout.includes(NOT_FOUND2)) throw notInstalled(this.where, remote);
     let answer;
     try {
       answer = parseDetachLine(r.stdout);
@@ -156597,7 +156553,7 @@ var SshTunnel = class {
       return this.connectionLine();
     }
     if (r.code === 255) throw new Error(`ssh could not reach ${this.opts.target}: ${lastLine(r.stderr) || "no answer"}`);
-    if (r.stdout.includes(NOT_FOUND2) || r.code === 127 && !remote.command) throw notInstalled(this.where, remote);
+    if (r.stdout.includes(NOT_FOUND2)) throw notInstalled(this.where, remote);
     try {
       const line = parseConnectionLine(r.stdout, remote);
       return pair && this.pairs && line.credential ? { ...line, pairedAs: oneLineText(pair, 80) } : line;
@@ -156746,8 +156702,7 @@ function ansiText(bytes2) {
     ansiDecoder = null;
     if (process.platform !== "win32") return null;
     try {
-      const root3 = process.env.SystemRoot && win329.isAbsolute(process.env.SystemRoot) ? process.env.SystemRoot : "C:\\Windows";
-      const out = execFileSync5(win329.join(root3, "System32", "reg.exe"), ["query", "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Nls\\CodePage", "/v", "ACP"], { encoding: "utf8", timeout: 5e3, windowsHide: true });
+      const out = execFileSync5(systemTool2(["reg.exe"]), ["query", "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Nls\\CodePage", "/v", "ACP"], { encoding: "utf8", timeout: 5e3, windowsHide: true });
       const page = /\bACP\s+REG_SZ\s+(\d+)/.exec(out)?.[1];
       if (page) ansiDecoder = new TextDecoder(CODE_PAGE_NAMES[page] ?? `windows-${page}`, { fatal: true });
     } catch {
@@ -157401,6 +157356,17 @@ async function removeAutostart(c) {
   }
 }
 
+// packages/agent-host/src/links/hub-auto.ts
+async function askHubAuto(call2, allowed) {
+  try {
+    const r = asObj(await (allowed === void 0 ? call2("host.hubAuto", {}) : call2("host.setHubAuto", { allowed })));
+    return r.allowed === true ? "on" : "off";
+  } catch (err) {
+    if (/^Unknown method/.test(errorMessage(err))) return "older";
+    throw err;
+  }
+}
+
 // packages/agent-host/src/links/linked-machine-connection.ts
 import { randomBytes as randomBytes13 } from "node:crypto";
 
@@ -157722,6 +157688,11 @@ var RemoteClient = class {
   attempt = 0;
   reconnectTimer;
   handshakeTimer;
+  stableTimer;
+  /** The hello of this socket is younger than `stableMs`: a drop now makes it short-lived */
+  settling = false;
+  /** The hellos in a row that dropped within `stableMs` */
+  shortLived = 0;
   /** The refusal that came before the close, if one did: it names why the host closes */
   refusal;
   WS;
@@ -157819,6 +157790,7 @@ var RemoteClient = class {
       this.lastSeq = 0;
     }
     this.attempt = 0;
+    this.shortLived = 0;
     if (this.ws) {
       const old = this.ws;
       this.ws = null;
@@ -157887,6 +157859,14 @@ var RemoteClient = class {
       this.cursorValid = true;
       this.ready = true;
       this.attempt = 0;
+      if (this.opts.stableMs !== void 0) {
+        this.settling = true;
+        this.stableTimer = setTimeout(() => {
+          this.settling = false;
+          this.shortLived = 0;
+        }, this.opts.stableMs);
+        this.stableTimer.unref?.();
+      }
       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;
     }
@@ -157958,11 +157938,13 @@ var RemoteClient = class {
     this.ws = null;
     const wasReady = this.ready;
     this.ready = false;
+    if (wasReady && this.settling) this.shortLived++;
+    this.settling = false;
     this.clearTimers();
     this.failAll("The link dropped");
     if (this.closed) return;
     if (wasReady) this.on.down?.(reason, detail);
-    if (this.opts.redials !== void 0 && this.attempt >= this.opts.redials) {
+    if (this.opts.redials !== void 0 && (this.attempt >= this.opts.redials || this.shortLived >= this.opts.redials)) {
       this.on.gaveUp?.(reason);
       return;
     }
@@ -157983,6 +157965,7 @@ var RemoteClient = class {
   clearTimers() {
     clearTimeout(this.reconnectTimer);
     clearTimeout(this.handshakeTimer);
+    clearTimeout(this.stableTimer);
     this.reconnectTimer = void 0;
     this.handshakeTimer = void 0;
   }
@@ -158123,7 +158106,7 @@ async function follow(c, id3) {
       const machine = c.machine ?? c.target;
       throw new Error(`The update of ${machine} could not be followed to its end from this computer; how it ended is shown once ${machine} is reached again`);
     }
-    await new Promise((r) => setTimeout(r, wait));
+    await sleep(wait);
   }
 }
 var restoredNote = (version2, machine) => `The store on ${machine} was put back as it was before the dev build first opened it, since Centralu ${version2} could not read it as the dev build left it; what was done on the dev build since is not in it`;
@@ -158321,9 +158304,8 @@ var LinkedMachineConnection = class {
   client = null;
   /** The client when it stopped redialling (`gaveUp`, #1143) and is waiting, idle, for the next opening */
   gaveUp = null;
-  /** Sessions of the remote the hub shows / hides, by the remote's id. Events of any other session are not passed on */
+  /** Sessions of the remote the hub shows, by the remote's id. Events of any other session are not passed on */
   shown = /* @__PURE__ */ new Set();
-  hidden = /* @__PURE__ */ new Set();
   /** The remote's coordinators as it last gave them: not shown, but read by a reader (#1941, `unshown`) */
   coordinators = /* @__PURE__ */ new Map();
   retryTimer;
@@ -158650,23 +158632,23 @@ var LinkedMachineConnection = class {
     return !!line.credential && c.id === line.credential && this.isPairedHere(c);
   }
   /**
-   * The credentials used on the machine under this hub's own label that this hub did not pair (#1405 review), and that
-   * `listed` does not name already, as used and gone. The machine's host leaves out a credential whose label's next one
-   * was paired the same way, taking it for its pairer again; under a hub's label only the hub can tell. Counted from the
-   * first use there of one this hub paired in its present run, so the credentials of its own earlier runs, which it does
-   * not remember, are not taken for another's
-   */
-  /**
-   * Marks, in a list the host answered with `nonce`, the entries whose `check` is of the secret this hub holds under
-   * their id (`own`). An entry without a check (a host from before it) or a credential this hub holds no secret of is not
-   * marked, and is compared by id alone
-   */
+    * Marks, in a list the host answered with `nonce`, the entries whose `check` is of the secret this hub holds under
+    * their id (`own`). An entry without a check (a host from before it) or a credential this hub holds no secret of is not
+    * marked, and is compared by id alone
+    */
   ownOf(list2, nonce) {
     return list2?.map((c) => {
       const verifier = this.pairedHere.get(c.id);
       return c.check === void 0 || !verifier ? c : { ...c, own: c.check === credentialCheck(verifier, nonce) };
     }) ?? null;
   }
+  /**
+   * The credentials used on the machine under this hub's own label that this hub did not pair (#1405 review), and that
+   * `listed` does not name already, as used and gone. The machine's host leaves out a credential whose label's next one
+   * was paired the same way, taking it for its pairer again; under a hub's label only the hub can tell. Counted from the
+   * first use there of one this hub paired in its present run, so the credentials of its own earlier runs, which it does
+   * not remember, are not taken for another's
+   */
   notPairedHere(line, listed2) {
     if (!line.pairedAs) return [];
     const first = this.usedUnderHubLabels.findIndex((u) => this.isPairedHere(u));
@@ -158854,7 +158836,6 @@ var LinkedMachineConnection = class {
   observe(kind, list2) {
     if (kind === "sessions") {
       this.shown.clear();
-      this.hidden.clear();
       this.coordinators.clear();
       for (const s of list2) this.classify(s);
       this.deps.mirror.replace(this.id, "sessions", list2.filter((s) => !hiddenKind(s)));
@@ -159208,6 +159189,7 @@ var LinkedMachineConnection = class {
       // A host that can prove it holds the token is asked to, before the token goes out (#838)
       {
         redials: LINK_REDIALS,
+        stableMs: this.deps.stableMs ?? STABLE_MS,
         ...this.deps.client,
         url: endpoint.url,
         token: endpoint.token,
@@ -159351,8 +159333,7 @@ var LinkedMachineConnection = class {
   }
   classify(s) {
     if (!isObj(s) || typeof s.id !== "string") return;
-    if (hiddenKind(s)) this.hidden.add(s.id);
-    else this.shown.add(s.id);
+    if (!hiddenKind(s)) this.shown.add(s.id);
     if (s.kind === "coordinator") this.coordinators.set(s.id, s);
   }
   transportDown(reason) {
@@ -159367,14 +159348,6 @@ var LinkedMachineConnection = class {
   nextStep() {
     return this.autoReconnect ? KEEPS_TRYING : WAITS_FOR_PERSON;
   }
-  /**
-   * Asks the machine again after a delay. `backoff` (the default): the next step of the backoff, and nothing at all
-   * while Auto reconnect is off (#1341), where only the person's Connect tries again (after the client's quick redials,
-   * which an off machine keeps). `within`: part of an attempt that
-   * is under way or of the person's own request (a refusal asked again at once, a Connect that met an opening), so it
-   * goes ahead either way. `reads`: the versions check looking again for a change on either side; with the switch off it
-   * reads the line and connects nothing (`readsOnly`)
-   */
   /** The link is up, or was just: remembers when, and keeps it for the next start of this host */
   seen() {
     this.lastConnectedAt = Date.now();
@@ -159385,6 +159358,14 @@ var LinkedMachineConnection = class {
     clearTimeout(this.retryTimer);
     this.nextAttemptAt = null;
   }
+  /**
+   * Asks the machine again after a delay. `backoff` (the default): the next step of the backoff, and nothing at all
+   * while Auto reconnect is off (#1341), where only the person's Connect tries again (after the client's quick redials,
+   * which an off machine keeps). `within`: part of an attempt that
+   * is under way or of the person's own request (a refusal asked again at once, a Connect that met an opening), so it
+   * goes ahead either way. `reads`: the versions check looking again for a change on either side; with the switch off it
+   * reads the line and connects nothing (`readsOnly`)
+   */
   retryLater(fixedMs, mode = "backoff") {
     if (this.stopped || this.held) return;
     if (mode === "backoff" && !this.autoReconnect && !this.inOperation()) return;
@@ -159806,13 +159787,10 @@ var LinkedMachine = class extends LinkedMachineConnection {
     const client = this.client;
     if (!client?.connected) return "unreachable";
     try {
-      const r = await (allowed === void 0 ? client.call("host.hubAuto", {}) : client.call("host.setHubAuto", { allowed }));
-      return r?.allowed === true ? "on" : "off";
+      return await askHubAuto((method, params) => client.call(method, params), allowed);
     } catch (err) {
-      const message = err?.message ?? String(err);
-      if (/^Unknown method/.test(message)) return "older";
       if (!client.connected) return "unreachable";
-      throw rpcError(`${this.name} did not answer for its "Allow auto from a linked computer": ${message}`);
+      throw rpcError(`${this.name} did not answer for its "Allow auto from a linked computer": ${errorMessage(err)}`);
     }
   }
   /**
@@ -160243,8 +160221,8 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     await settle(m);
     return m.reachable ? null : { ok: false, error: awaySentence(m, tail) };
   };
-  const attempt = async (m, run4) => {
-    const down = await reach(m, TAIL.tryAgain);
+  const attempt = async (m, run4, tail = TAIL.tryAgain) => {
+    const down = await reach(m, tail);
     if (down) return down;
     try {
       return { ok: true, ...await run4() };
@@ -160257,13 +160235,13 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
       const m = find(id3);
       return m ? [m, null] : [null, { ok: false, error: refusal2(id3) }];
     };
-    const via = async (id3, run4) => {
+    const via = async (id3, run4, tail) => {
       const [m, refused2] = found(id3);
-      return m ? attempt(m, () => run4(m)) : refused2;
+      return m ? attempt(m, () => run4(m), tail) : refused2;
     };
     return [found, via];
   };
-  const [findSession, viaSession] = reaching(owner, (id3) => `Not a session of a linked machine: ${id3}`);
+  const [, viaSession] = reaching(owner, (id3) => `Not a session of a linked machine: ${id3}`);
   const [findProject2, viaProject] = reaching(owner, (id3) => `Not a project of a linked machine: ${id3}`);
   const [findMachineRef, viaMachine] = reaching(machineById, (id3) => `No linked machine ${id3}`);
   const listOf = async (m, method) => {
@@ -160459,8 +160437,9 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     },
     hubAuto(machineId) {
       return viaMachine(machineId, async (m) => {
-        const r = await m.call("host.hubAuto", {});
-        return { allowed: r?.allowed === true };
+        const state = await askHubAuto((method, params) => m.call(method, params));
+        if (state === "older") throw new Error(`${m.name} runs a Centralu from before "Allow auto from a linked computer"`);
+        return { allowed: state === "on" };
       });
     },
     origin(project2) {
@@ -160625,20 +160604,18 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
       const p = (m.lastKnown("projects") ?? []).find((x) => isObj(x) && x.id === s.projectId);
       return { name: oneLine4(s.name), project: `${isObj(p) ? oneLine4(p.name) : "(none)"} on ${m.name}` };
     },
-    async lastWords(sessionId, maxChars, opts) {
-      const [m, refusal2] = findSession(sessionId);
-      if (!m) return refusal2;
-      const down = await reach(m, TAIL.none);
-      if (down) return down;
-      try {
-        const answer = await m.call("host.lastAnswer", { sessionId: m.q.strip(sessionId, "The session"), maxChars: Math.min(maxChars, ANSWER_MAX_CHARS2), ...opts?.turn ? { turn: true } : {}, ...opts?.since !== void 0 ? { since: opts.since } : {} });
-        const r = HostLastAnswerResult.safeParse(answer);
-        if (!r.success) return { ok: false, error: `${m.name} answered in a shape this Centralu does not read` };
-        const text3 = r.data.text.length > maxChars || r.data.length > r.data.text.length ? `${r.data.text.slice(0, maxChars)}\u2026` : r.data.text;
-        return { ok: true, text: text3, length: r.data.length, seq: r.data.seq };
-      } catch (err) {
-        return { ok: false, error: cause(err) };
-      }
+    lastWords(sessionId, maxChars, opts) {
+      return viaSession(
+        sessionId,
+        async (m) => {
+          const answer = await m.call("host.lastAnswer", { sessionId: m.q.strip(sessionId, "The session"), maxChars: Math.min(maxChars, ANSWER_MAX_CHARS2), ...opts?.turn ? { turn: true } : {}, ...opts?.since !== void 0 ? { since: opts.since } : {} });
+          const r = HostLastAnswerResult.safeParse(answer);
+          if (!r.success) throw new Error(`${m.name} answered in a shape this Centralu does not read`);
+          const text3 = r.data.text.length > maxChars || r.data.length > r.data.text.length ? `${r.data.text.slice(0, maxChars)}\u2026` : r.data.text;
+          return { text: text3, length: r.data.length, seq: r.data.seq };
+        },
+        TAIL.none
+      );
     },
     async list() {
       const perMachine = await Promise.all(
@@ -160656,42 +160633,40 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     machineOf(sessionId) {
       return owner(sessionId)?.name ?? null;
     },
-    async read(sessionId, limit, opts) {
-      const [m, refusal2] = findSession(sessionId);
-      if (!m) return refusal2;
-      const down = await reach(m, TAIL.readAgain);
-      if (down) return down;
+    read(sessionId, limit, opts) {
       const toolMode = toolLinesOf(opts?.tools);
-      try {
-        const answer = await m.call("host.readSession", {
-          sessionId: m.q.strip(sessionId, "The session"),
-          ...limit !== void 0 ? { limit } : {},
-          ...opts?.around !== void 0 ? { around: opts.around } : {},
-          ...opts?.tools !== void 0 ? { toolLines: toolMode } : {},
-          ...opts?.maxChars !== void 0 ? { maxChars: budgetOf(opts.maxChars) } : {},
-          ...opts?.before !== void 0 ? { before: opts.before } : {},
-          ...opts?.from !== void 0 ? { from: opts.from } : {},
-          ...opts?.offset !== void 0 ? { offset: opts.offset } : {}
-        });
-        const r = HostReadSessionResult.safeParse(answer);
-        if (!r.success) return { ok: false, error: `${m.name} answered in a shape this Centralu does not read` };
-        const all = r.data.lines;
-        const kept = toolMode === "none" ? all.filter((l) => !isToolLine(l)) : all;
-        const spot = Math.min(Math.floor(Math.min(limit ?? 40, 200) / 2), all.length - 1);
-        const around = opts?.around !== void 0 && opts.before === void 0 && opts.from === void 0;
-        const center = !around ? null : Math.min(toolMode === "none" ? all.slice(0, spot).filter((l) => !isToolLine(l)).length : spot, kept.length - 1);
-        const lines = fitMachineLines(kept, budgetOf(opts?.maxChars), center);
-        return { ok: true, state: oneLine4(r.data.state, 40), lines: lines.map(fencedLine) };
-      } catch (err) {
-        return { ok: false, error: cause(err) };
-      }
+      return viaSession(
+        sessionId,
+        async (m) => {
+          const answer = await m.call("host.readSession", {
+            sessionId: m.q.strip(sessionId, "The session"),
+            ...limit !== void 0 ? { limit } : {},
+            ...opts?.around !== void 0 ? { around: opts.around } : {},
+            ...opts?.tools !== void 0 ? { toolLines: toolMode } : {},
+            ...opts?.maxChars !== void 0 ? { maxChars: budgetOf(opts.maxChars) } : {},
+            ...opts?.before !== void 0 ? { before: opts.before } : {},
+            ...opts?.from !== void 0 ? { from: opts.from } : {},
+            ...opts?.offset !== void 0 ? { offset: opts.offset } : {}
+          });
+          const r = HostReadSessionResult.safeParse(answer);
+          if (!r.success) throw new Error(`${m.name} answered in a shape this Centralu does not read`);
+          const all = r.data.lines;
+          const kept = toolMode === "none" ? all.filter((l) => !isToolLine(l)) : all;
+          const spot = Math.min(Math.floor(Math.min(limit ?? 40, 200) / 2), all.length - 1);
+          const around = opts?.around !== void 0 && opts.before === void 0 && opts.from === void 0;
+          const center = !around ? null : Math.min(toolMode === "none" ? all.slice(0, spot).filter((l) => !isToolLine(l)).length : spot, kept.length - 1);
+          const lines = fitMachineLines(kept, budgetOf(opts?.maxChars), center);
+          return { state: oneLine4(r.data.state, 40), lines: lines.map(fencedLine) };
+        },
+        TAIL.readAgain
+      );
     },
     async recall(query, limit) {
       const notSearched = [];
       const hits = await Promise.all(
         [...machines()].map(async (m) => {
           if (!m.reachable) {
-            notSearched.push(`${m.name} (not reachable right now)`);
+            notSearched.push(`${m.name} (${m.waitsForPerson ? "not connected; ask the person to connect it in Settings, Machines, Connect" : NOT_REACHABLE})`);
             return [];
           }
           try {
@@ -161100,7 +161075,7 @@ var Router = class {
         if (method === "apps.list" && isObj(params) && typeof params.machine === "string") {
           return this.byMachine(method, params, { result: (r, q2) => Array.isArray(r) ? r.map((a) => q2.app(a)) : r }, ctx);
         }
-        return this.merge(method, params);
+        return this.merge(method, params, ctx);
     }
   };
   /** The linked machine an id names, or null for the hub's own (an unprefixed id, or a prefix no link has) */
@@ -161213,7 +161188,7 @@ var Router = class {
    * mirror for it, marked `unreachable` and with `live` as last known, so the UI neither drops
    * them nor tries to wake them (§5, "Recovery").
    */
-  async merge(method, params) {
+  async merge(method, params, ctx) {
     const machines = [...this.opts.machines()];
     switch (method) {
       case "sessions.list":
@@ -161221,9 +161196,9 @@ var Router = class {
       case "projects.list":
         return this.mergeLists(machines, "projects", params);
       case "projects.reorder":
-        return this.reorderProjects(machines, params);
+        return this.reorderProjects(machines, params, ctx);
       case "approvals.deleteRule":
-        return this.deleteRule(machines, params);
+        return this.deleteRule(machines, params, ctx);
       default:
         return this.mergeSimple(method, machines, params);
     }
@@ -161285,7 +161260,7 @@ var Router = class {
    * out of it: a stale window cannot move what it never saw. The kept order forgets a project the hub no longer lists,
    * unless it is a linked machine's, which may only be out of reach.
    */
-  async reorderProjects(machines, params) {
+  async reorderProjects(machines, params, ctx) {
     const { orderedIds } = RpcMethods["projects.reorder"].params.parse(params);
     const kept = this.opts.order?.read() ?? [];
     const full = keepUnseen(orderedIds, kept);
@@ -161302,7 +161277,7 @@ var Router = class {
         const ordered = perMachine.get(m);
         if (!ordered) return this.listOf(m, "projects");
         try {
-          return m.q.projects(await this.forward(m, "projects.reorder", { orderedIds: ordered }));
+          return m.q.projects(await this.forward(m, "projects.reorder", { orderedIds: ordered }, ctx));
         } catch {
           return this.present(m, "projects", m.lastKnown("projects") ?? [], true);
         }
@@ -161315,13 +161290,13 @@ var Router = class {
     }
     return machines.length > 0 ? this.inPersonsOrder(all) : all;
   }
-  async deleteRule(machines, params) {
+  async deleteRule(machines, params, ctx) {
     const id3 = isObj(params) ? params.id : void 0;
     const folded = typeof id3 === "number" ? decodeNumber(id3) : null;
     if (!folded) return this.opts.local("approvals.deleteRule", params);
     const m = machines.find((x) => x.q.slot === folded.slot);
     if (!m) throw rpcError("That rule belongs to a machine that is no longer linked");
-    return this.forward(m, "approvals.deleteRule", { id: folded.n });
+    return this.forward(m, "approvals.deleteRule", { id: folded.n }, ctx);
   }
   /** The other merges: every reachable machine, each answer in the hub's terms, combined by kind */
   async mergeSimple(method, machines, params) {
@@ -161892,7 +161867,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 ? "3bbc42b" : "dev";
+var BUILD = true ? "5f99652" : "dev";
 var { values } = parseArgs({
   options: {
     port: { type: "string", default: "5175" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@centralu/host-linux-x64",
-  "version": "0.1.0-beta.50",
+  "version": "0.1.0-beta.51",
   "description": "Centralu's host without the window, for Linux on x86-64: what a hub installs on a linked machine",
   "license": "MIT",
   "author": "ijun17",