@centralu/host-linux-arm64 0.1.0-beta.37 → 0.1.0-beta.38

package/host/bundle-info.json

@@ -1,9 +1,9 @@
 {
-  "commit": "49153ff",
+  "commit": "bab6469",
   "protocolVersion": 1,
   "hostProof": 1,
   "tokenOnStdin": 1,
-  "builtAt": "2026-10-25T08:20:45.825Z",
+  "builtAt": "2026-10-25T19:49:35.014Z",
   "runtime": "system-node",
   "platform": "linux",
   "arch": "arm64"

package/host/centralu-package.json

@@ -1,6 +1,6 @@
 {
   "name": "centralu",
-  "version": "0.1.0-beta.37",
+  "version": "0.1.0-beta.38",
   "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.37",
-    "@centralu/linux-arm64": "0.1.0-beta.37",
-    "@centralu/linux-x64": "0.1.0-beta.37",
-    "@centralu/win32-x64": "0.1.0-beta.37"
+    "@centralu/darwin-arm64": "0.1.0-beta.38",
+    "@centralu/linux-arm64": "0.1.0-beta.38",
+    "@centralu/linux-x64": "0.1.0-beta.38",
+    "@centralu/win32-x64": "0.1.0-beta.38"
   }
 }

package/host/main.mjs

@@ -43053,9 +43053,11 @@ import { hostname as hostname5 } from "node:os";
 import { dirname as dirname23, join as join52 } from "node:path";
 import { mkdirSync as mkdirSync19, writeSync as writeSync3 } from "node:fs";
 
+// packages/protocol/src/version.generated.ts
+var APP_VERSION = "0.1.0-beta.38";
+
 // packages/protocol/src/brand.ts
 var APP_NAME = "Centralu";
-var APP_VERSION = "0.1.0-beta.37";
 var APP_SLUG = "centralu";
 var CLIENT_INFO = { name: APP_SLUG, title: APP_NAME, version: APP_VERSION };
 var DATA_DIR = ".centralu";
@@ -104106,7 +104108,7 @@ var NOT_CONNECTED = "not connected until the person connects it";
 var NOT_CONNECTED_PHRASE = "is not connected, and nothing here connects it by itself; ask the person to connect it (Settings, Machines, Connect)";
 function awayPhrase(why) {
   if (why === NOT_CONNECTED) return NOT_CONNECTED_PHRASE;
-  return why === NOT_REACHABLE ? `is ${NOT_REACHABLE}` : `could not be asked just now (${why})`;
+  return why === NOT_REACHABLE || why.startsWith(`${NOT_REACHABLE};`) ? `is ${why}` : `could not be asked just now (${why})`;
 }
 
 // packages/agent-host/src/adapters/contract/surface.ts
@@ -113241,11 +113243,12 @@ var RemoteAgents = class {
     if (!origin || !key) {
       return { error: `This project has ${origin ? "a local folder as its origin remote" : "no origin remote"}, so no checkout of it on ${machine.name} can be told apart. Start the agent here, without machine.` };
     }
-    const all = await reader.projects();
+    const all = await reader.projects({ machineId: machine.id });
     const away = all.away.find((a) => a.machineId === machine.id);
     if (away) {
       if (away.why === NOT_CONNECTED) return { error: `${machine.name} ${awayPhrase(NOT_CONNECTED)}, so nothing was started there. Try again once it is connected.` };
-      return { error: `${machine.name} cannot be reached (${away.why}), so nothing was started there. Try again once its link is back.` };
+      const cannot = away.why.startsWith(`${NOT_REACHABLE};`) ? `is ${away.why}` : `cannot be reached (${away.why})`;
+      return { error: `${machine.name} ${cannot}, so nothing was started there. Try again once its link is back.` };
     }
     const theirs = all.projects.filter((p) => p.machineId === machine.id);
     const read = await Promise.all(theirs.map(async (p) => ({ p, r: await reader.origin(p) })));
@@ -135715,7 +135718,7 @@ var AskProjectFlow = class {
     const exactHere = projects.some((p) => p.id === wanted);
     const hubs2 = this.hubs;
     const none = { projects: [], away: [] };
-    const [there, fromHubs] = (reader || hubs2) && !exactHere ? await Promise.all([reader ? reader.projects() : none, hubs2 ? hubs2.projects() : none]) : [none, none];
+    const [there, fromHubs] = (reader || hubs2) && !exactHere ? await Promise.all([reader ? reader.projects({ ref: wanted }) : none, hubs2 ? hubs2.projects() : none]) : [none, none];
     const askable = [
       ...projects.map((p) => ({ id: p.id, name: p.name, machine: null, machineId: null })),
       ...there.projects.map((p) => ({ id: p.id, name: p.name, machine: p.machine, machineId: p.machineId })),
@@ -144805,6 +144808,13 @@ var AUTO_RETRY_DELAYS_MS = [10 * 60 * 1e3, 60 * 60 * 1e3, 6 * 60 * 60 * 1e3];
 var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
 var NPM_RETRY_DELAY_MS = 3e4;
 var NPM_RETRY_WINDOW_MS = 10 * 60 * 1e3;
+var UNSTAMPED_VERSION = "0.0.0-dev";
+function installsByItself(build3, current) {
+  return build3 !== "dev" && current !== UNSTAMPED_VERSION;
+}
+function hubUpdatesMachines(f) {
+  return installsByItself(f.build, f.current) && f.autoApply && !f.draining;
+}
 function existingInstalledCopy() {
   const path2 = installedCopyPath();
   return existsSync22(path2) ? path2 : null;
@@ -144855,6 +144865,8 @@ var UpdateService = class {
   constructor(publish, deps = {}) {
     this.publish = publish;
     this.deps = {
+      current: deps.current ?? APP_VERSION,
+      build: deps.build ?? "",
       fetchLatest: deps.fetchLatest ?? fetchLatestFromRegistry,
       run: deps.run ?? runCommand,
       installedCopy: deps.installedCopy ?? existingInstalledCopy,
@@ -144880,13 +144892,13 @@ var UpdateService = class {
       /*
        * The honest source for "which build is this".
        *
-       * `APP_VERSION` is what the app was compiled from, and `tooling/brand.test.ts`
-       * fails the build if it disagrees with the npm packages that carry it. The
-       * workspace root's package.json is not it — that one is private, has no version
-       * anyone installs, and would have read `0.0.0` forever without ever being wrong
-       * enough to notice.
+       * `APP_VERSION` is what the app was compiled from: the version a release stamped
+       * into the build with the npm packages that carry it (#1501, `tooling/brand.test.ts`),
+       * or the placeholder `0.0.0-dev` of a source tree. The workspace root's package.json
+       * is not it — that one is private, has no version anyone installs, and would have
+       * read `0.0.0` forever without ever being wrong enough to notice.
        */
-      current: APP_VERSION,
+      current: this.deps.current,
       latest: null,
       newer: false,
       auto: this.deps.readAuto(),
@@ -144983,6 +144995,7 @@ var UpdateService = class {
    */
   installIfAutomatic() {
     if (!this.status.autoApply || !this.status.newer || !this.status.latest) return;
+    if (!installsByItself(this.deps.build, this.deps.current)) return;
     if (this.status.phase === "idle") {
       void this.apply();
       return;
@@ -145006,6 +145019,7 @@ var UpdateService = class {
     this.retryTimer = this.deps.schedule(() => {
       this.retryTimer = null;
       if (this.stopped || !this.status.autoApply || this.status.phase !== "failed" || !this.status.newer || !this.status.latest) return;
+      if (!installsByItself(this.deps.build, this.deps.current)) return;
       void this.apply();
     }, delay);
   }
@@ -147380,8 +147394,8 @@ function failure2(target, code2, detail) {
     case "dev_dirty":
       return `The working copy on ${target} has ${detail} uncommitted change${detail === "1" ? "" : "s"}; commit or stash them, or pass --allow-dirty to build them too. Nothing was built`;
     case "dev_base":
-      if (/^0\.0\.0-dev(?:\.|$)/.test(detail))
-        return `The working copy on ${target} carries no release version (${detail}): its version is stamped from a release tag at build time (#1501), which this dev build cannot do. Nothing was built`;
+      if (!detail || /^0\.0\.0-dev(?:\.|$)/.test(detail))
+        return `The working copy on ${target} has no release tag (v*) reachable from its HEAD, which a dev build takes its version from (#1501); fetch the tags there (git fetch --tags) and try again. Nothing was built`;
       return `The working copy on ${target} is version ${detail || "(none)"}; a dev build is cut from a prerelease (x.y.z-beta.N)`;
     case "dev_protocol": {
       const [have = "?", want = "?"] = detail.split(" ");
@@ -148220,7 +148234,11 @@ var KEEPS_TRYING = "reconnecting";
 var WAITS_FOR_PERSON = "press Connect to try again";
 var NEXT_STEP = new RegExp(`; (${KEEPS_TRYING}|asking the machine again|${WAITS_FOR_PERSON})$`);
 var ATTEMPT_WAIT_MS = 6e4;
+var CALL_WAIT_MS = 1e4;
+var CALL_FAILURE_KEPT_MS = 6e4;
+var CALL_WINDOW_MS = 15e3;
 var AWAY = /* @__PURE__ */ new Set(["unreachable", "away", "not_running", "refused", "stopped"]);
+var CALL_RETRIES = /* @__PURE__ */ new Set(["unreachable", "away", "not_running", "refused"]);
 var LinkedMachineConnection = class {
   constructor(record2, tunnel, deps) {
     this.record = record2;
@@ -148335,6 +148353,10 @@ var LinkedMachineConnection = class {
   nextAttemptAt = null;
   /** Calls waiting for an attempt to connect to end (`settled`) */
   statusWaiters = /* @__PURE__ */ new Set();
+  /** When a call last started an attempt (`reachForCall`), and how the attempt a call waited on ended, with when */
+  lastCallAttemptAt = 0;
+  callFailure = null;
+  callFailureAt = 0;
   get id() {
     return this.record.id;
   }
@@ -148376,7 +148398,11 @@ var LinkedMachineConnection = class {
   }
   /** Resolves once no attempt is under way, or after `waitMs` (a minute): connecting took 2 to 4 s on a LAN, a host started there adds its start */
   settled(waitMs = this.deps.attemptWaitMs ?? ATTEMPT_WAIT_MS) {
-    if (!this.attemptUnderWay) return Promise.resolve();
+    return this.waitUntil(() => !this.attemptUnderWay, waitMs);
+  }
+  /** Resolves once `ready()` holds (checked at every change of status and at the end of every opening), or after `waitMs` */
+  waitUntil(ready, waitMs) {
+    if (ready()) return Promise.resolve();
     return new Promise((resolve21) => {
       const done2 = () => {
         clearTimeout(timer);
@@ -148384,13 +148410,63 @@ var LinkedMachineConnection = class {
         resolve21();
       };
       const waiter = () => {
-        if (!this.attemptUnderWay) done2();
+        if (ready()) done2();
       };
       const timer = setTimeout(done2, waitMs);
       timer.unref?.();
       this.statusWaiters.add(waiter);
     });
   }
+  /**
+   * An agent's call needs this machine (#1532): with Auto reconnect on and the link down, it does what the person's Connect
+   * does (`connect`, the one action that opens a link now) instead of waiting out the backoff, and waits for it a short
+   * bound (`CALL_WAIT_MS`). The caller reads `reachable` afterwards: connected in time, the call goes through; not, it is
+   * answered as not reachable with `whyDown`, and the backoff goes on from where it was (`keepBackoff`).
+   *
+   * - one attempt at a time: a call that finds one under way (the backoff's, the person's press, another call's) waits on
+   *   it and starts none; so do ten calls at once, and a press at the same moment as a call;
+   * - calls cannot defeat the backoff: at most one attempt started by a call per machine within `CALL_WINDOW_MS`; a call
+   *   inside the window waits for nothing and is answered at once;
+   * - with Auto reconnect off nothing is started (#1341): the call is answered as not connected, and the person is named.
+   *   Neither does it when the person disconnected the machine, the host was stopped there, an operation holds the link
+   *   or the versions differ: a Connect does not help those, or is the person's to press
+   */
+  async reachForCall() {
+    if (this.reachable) return;
+    const until = Date.now() + (this.deps.callWaitMs ?? CALL_WAIT_MS);
+    const left = () => Math.max(0, until - Date.now());
+    await this.waitUntil(() => this.reachable || !this.redialing, left());
+    if (this.reachable) return;
+    if (this.attemptUnderWay) {
+      await this.settled(Math.min(left(), this.deps.attemptWaitMs ?? ATTEMPT_WAIT_MS));
+      return this.noteCallFailure();
+    }
+    if (this.stopped || this.parked || this.held || this.inOperation() || !this.autoReconnect || this.redialing) return;
+    if (!CALL_RETRIES.has(this.status)) return;
+    const now = Date.now();
+    if (now - this.lastCallAttemptAt < (this.deps.callWindowMs ?? CALL_WINDOW_MS)) return;
+    this.lastCallAttemptAt = now;
+    this.connect({ start: false, keepBackoff: true });
+    await this.settled(Math.min(left(), this.deps.attemptWaitMs ?? ATTEMPT_WAIT_MS));
+    this.noteCallFailure();
+  }
+  /** How the attempt a call waited on ended when it did not connect: the machine's own words. One still going is told as it is (`whyDown`) */
+  noteCallFailure() {
+    if (this.reachable || this.attemptUnderWay) return;
+    this.callFailure = this.error?.replace(NEXT_STEP, "") ?? null;
+    this.callFailureAt = Date.now();
+  }
+  /**
+   * What the answer to a call that could not take it says of the attempt to connect the machine (#1532), as a clause: that
+   * one is still under way, or that the one a call made last failed, with the machine's own words. Null once the link is
+   * up, and when no attempt was made or told of
+   */
+  get whyDown() {
+    if (this.reachable) return null;
+    if (this.attemptUnderWay) return "an attempt to connect it is still under way";
+    if (!this.callFailure || Date.now() - this.callFailureAt > CALL_FAILURE_KEPT_MS) return null;
+    return `the attempt to connect it just now failed: ${this.callFailure}`;
+  }
   /** An install, update or other operation the person started is running: its retries are part of it (`retryLater`) */
   inOperation() {
     return this.held;
@@ -148526,7 +148602,9 @@ var LinkedMachineConnection = class {
    * The person's Connect (`machines.reconnect`, #1134): opens now, forgetting the backoff, also a disconnected link and
    * also with Auto reconnect off (#1341), where it is the only way to try again. It is also the person's Start
    * (#1143): a host is started there even where they stopped it or the link stopped starting them. `start: false` is
-   * the orchestrator's reconnect without its card, which opens the link and starts nothing the link would not
+   * the orchestrator's reconnect without its card, which opens the link and starts nothing the link would not.
+   * `keepBackoff` is an agent's call that needs the machine (`reachForCall`, #1532): it opens now too, but the backoff
+   * goes on from the step it was at instead of starting over, so calls cannot hold it at its short steps
    */
   connect(opts = {}) {
     if (opts.start !== false) {
@@ -148535,7 +148613,7 @@ var LinkedMachineConnection = class {
       this.restartsSpent = false;
     }
     if (this.parked) return this.start();
-    this.reconnect();
+    this.reconnect(opts.keepBackoff === true);
   }
   /**
    * Closes the link and tries none until the person connects it again (#1134). The machine stays linked; its sessions
@@ -148580,9 +148658,9 @@ var LinkedMachineConnection = class {
     this.start();
   }
   /** Opens again now, forgetting the backoff (`machines.reconnect`, or the person accepted the versions) */
-  reconnect() {
+  reconnect(keepBackoff = false) {
     this.clearRetry();
-    this.attempt = 0;
+    if (!keepBackoff) this.attempt = 0;
     const under = this.opening;
     if (under) {
       if (this.status === "away") this.setStatus("connecting", null);
@@ -148995,6 +149073,7 @@ var LinkedMachineConnection = class {
   setStatus(status, error51) {
     if (this.status === "connected" && status !== "connected") this.seen();
     const changed = status !== this.status || error51 !== this.error;
+    if (status === "connected") this.callFailure = null;
     this.status = status;
     this.error = error51;
     if (changed) {
@@ -150301,9 +150380,12 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     for (const m of machines()) if (m.id === id3) return m;
     return null;
   };
-  const away = (m) => m.waitsForPerson ? `${m.name} ${awayPhrase(NOT_CONNECTED)}, then try again` : `${m.name} is ${NOT_REACHABLE}; try again once its link is back`;
+  const away = (m) => m.waitsForPerson ? `${m.name} ${awayPhrase(NOT_CONNECTED)}, then try again` : `${m.name} is ${notReachable(m)}; try again once its link is back`;
+  const notReachable = (m) => m.whyDown ? `${NOT_REACHABLE}; ${oneLine3(m.whyDown, 300)}` : NOT_REACHABLE;
   const settle = async (m) => {
-    if (m.attemptUnderWay) await m.settled?.();
+    if (m.reachable) return;
+    if (m.reachForCall) await m.reachForCall();
+    else if (m.attemptUnderWay) await m.settled?.();
   };
   const attempt = async (m, run4) => {
     await settle(m);
@@ -150373,26 +150455,36 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     }
     return out;
   };
-  const everyProject = async () => {
+  const projectsOf = async (m, tried = false) => {
     const away2 = [];
-    const perMachine = await Promise.all(
-      [...machines()].map(async (m) => {
-        const mirrored = (why) => {
-          away2.push({ machine: m.name, machineId: m.id, why });
-          return lastProjects(m).map((p) => ({ ...p, away: why }));
-        };
-        if (!m.reachable && m.attemptUnderWay) return lastProjects(m);
-        if (!m.reachable) return mirrored(m.waitsForPerson ? NOT_CONNECTED : NOT_REACHABLE);
-        try {
-          const list = await raceTimeout(m.call("projects.list", {}), lookupMs, TIMED_OUT);
-          if (list === TIMED_OUT) throw new Error(notWithin(lookupMs));
-          return (Array.isArray(list) ? list : []).map((raw) => projectOf(m, raw)).filter((p) => p !== null);
-        } catch (err) {
-          return mirrored(cause(m, err));
-        }
-      })
-    );
-    return { projects: perMachine.flat(), away: away2 };
+    const mirrored = (why) => {
+      away2.push({ machine: m.name, machineId: m.id, why });
+      return lastProjects(m).map((p) => ({ ...p, away: why }));
+    };
+    if (!m.reachable && m.attemptUnderWay && !tried) return { projects: lastProjects(m), away: away2 };
+    if (!m.reachable) return { projects: mirrored(m.waitsForPerson ? NOT_CONNECTED : notReachable(m)), away: away2 };
+    try {
+      const list = await raceTimeout(m.call("projects.list", {}), lookupMs, TIMED_OUT);
+      if (list === TIMED_OUT) throw new Error(notWithin(lookupMs));
+      return { projects: (Array.isArray(list) ? list : []).map((raw) => projectOf(m, raw)).filter((p) => p !== null), away: away2 };
+    } catch (err) {
+      return { projects: mirrored(cause(m, err)), away: away2 };
+    }
+  };
+  const needs = (m, need3) => {
+    if (need3.machineId === m.id) return true;
+    const ref = need3.ref?.trim();
+    if (!ref) return false;
+    const slash = ref.indexOf("/");
+    const prefix = slash > 0 ? ref.slice(0, slash).trim().toLowerCase() : null;
+    if (prefix === m.id || prefix === m.name.toLowerCase() || ref.startsWith(`${m.id}.`)) return true;
+    return lastProjects(m).some((p) => p.id === ref || p.name.toLowerCase() === ref.toLowerCase());
+  };
+  const everyProject = async (need3) => {
+    const all = [...machines()];
+    const wanted = need3 ? all.filter((m) => !m.reachable && needs(m, need3)) : [];
+    const parts = await Promise.all(all.map(async (m) => wanted.includes(m) ? (await settle(m), projectsOf(m, true)) : projectsOf(m)));
+    return { projects: parts.flatMap((p) => p.projects), away: parts.flatMap((p) => p.away) };
   };
   return {
     async send(sessionId, text2, fromName, ask) {
@@ -150410,7 +150502,7 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     },
     async findProjects(ref) {
       const wanted = ref.trim();
-      return (await everyProject()).projects.filter((p) => p.id === wanted || p.name === wanted);
+      return (await everyProject({ ref: wanted })).projects.filter((p) => p.id === wanted || p.name === wanted);
     },
     projects: everyProject,
     async projectSessions(project2) {
@@ -150676,7 +150768,7 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
       const m = owner(sessionId);
       if (!m) return { ok: false, error: `Not a session of a linked machine: ${sessionId}` };
       await settle(m);
-      if (!m.reachable) return { ok: false, error: m.waitsForPerson ? away(m) : `${m.name} is ${NOT_REACHABLE}` };
+      if (!m.reachable) return { ok: false, error: m.waitsForPerson ? away(m) : `${m.name} is ${notReachable(m)}` };
       try {
         const answer = await m.call("host.lastAnswer", { sessionId: m.q.strip(sessionId, "The session"), maxChars: Math.min(maxChars, ANSWER_MAX_CHARS2) });
         const r5 = HostLastAnswerResult.safeParse(answer);
@@ -150716,7 +150808,7 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
       const m = owner(sessionId);
       if (!m) return { ok: false, error: `Not a session of a linked machine: ${sessionId}` };
       await settle(m);
-      if (!m.reachable) return { ok: false, error: m.waitsForPerson ? away(m) : `${m.name} is not reachable right now; read it again once its link is back` };
+      if (!m.reachable) return { ok: false, error: m.waitsForPerson ? away(m) : `${m.name} is ${notReachable(m)}; read it again once its link is back` };
       const toolMode = toolLinesOf(opts?.tools);
       try {
         const answer = await m.call("host.readSession", {
@@ -151126,7 +151218,7 @@ var MachineUnreachableError = class extends Error {
   retryable = true;
   data;
   constructor(machine) {
-    super(`${machine.name} is not reachable right now; this works again once its link is back`);
+    super(`${machine.name} is not reachable right now${machine.whyDown ? `; ${machine.whyDown}` : ""}; this works again once its link is back`);
     this.data = { machine: machine.id, reason: "unreachable" };
   }
 };
@@ -151191,7 +151283,8 @@ var Router = class {
     for (const m of this.opts.machines()) if (m.id === id3) return m;
     return null;
   }
-  async forward(m, method, params) {
+  async forward(m, method, params, ctx) {
+    if (!m.reachable && ctx === void 0) await m.reachForCall?.();
     if (!m.reachable) throw new MachineUnreachableError(m);
     return m.call(method, params);
   }
@@ -151201,7 +151294,7 @@ var Router = class {
       const m2 = this.machineById(params.machine);
       if (!m2) throw rpcError(`No linked machine ${params.machine}`);
       const { machine: _machine2, ...rest } = params;
-      const r5 = await this.forward(m2, method, route.params ? route.params(rest, m2.q) : rest);
+      const r5 = await this.forward(m2, method, route.params ? route.params(rest, m2.q) : rest, ctx);
       return route.result ? route.result(r5, m2.q) : r5;
     }
     const m = this.owner(params[key]);
@@ -151212,7 +151305,7 @@ var Router = class {
     const done2 = this.opts.forwarding?.(method, params);
     let r;
     try {
-      r = await this.forward(m, method, p);
+      r = await this.forward(m, method, p, ctx);
     } catch (e) {
       done2?.(false);
       throw e;
@@ -151247,7 +151340,7 @@ var Router = class {
     const { machine: _machine, ...own } = params;
     const p = route.orMachine ? own : { ...params };
     for (const key of route.keys) if (typeof p[key] === "string") p[key] = target.q.strip(p[key], "The id");
-    const r = await this.forward(target, method, p);
+    const r = await this.forward(target, method, p, ctx);
     return route.result ? route.result(r, target.q) : r;
   }
   async byMachine(method, params, route, ctx) {
@@ -151259,7 +151352,7 @@ var Router = class {
       const shared = await this.sameAccountAnswer(m, method, rest, ctx);
       if (shared) return route.result ? route.result(shared, m.q) : shared;
     }
-    const r = await this.forward(m, method, rest);
+    const r = await this.forward(m, method, rest, ctx);
     return route.result ? route.result(r, m.q) : r;
   }
   /**
@@ -151915,7 +152008,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 ? "49153ff" : "dev";
+var BUILD = true ? "bab6469" : "dev";
 var { values } = parseArgs({
   options: {
     port: { type: "string", default: "5175" },
@@ -152178,6 +152271,8 @@ var { auto: autoUpdateCheck, autoApply: autoApplyUpdates } = updateSwitches(stor
 var themes = new ThemeFiles(join52(dataRoot(), "themes"), () => events.push({ type: "themes_changed" }));
 await themes.start().catch((e) => console.error(`[themes] the themes folder is unavailable: ${e.message}`));
 var updates = new UpdateService((status) => events.push({ type: "update_status", status }), {
+  // A host from source never installs by itself, whatever is stored (#1501 review, `installsByItself`)
+  build: BUILD,
   // On by default when nothing has been saved yet. Since the check is read-only and every failure
   // is swallowed, leaving it on costs nothing, while leaving it off traps **someone who never once
   // opens settings** on an old version forever — that person is exactly the one most likely to stay
@@ -152279,7 +152374,7 @@ var links = new Links({
   // When agents compact: this hub's setting governs the machines it links (#1376)
   autoCompact: () => autoCompactOf(mgr.uiPreferences()),
   // Automatic updates cover the linked machines too (#1508): one on an older release follows this hub's version; none starts mid-swap
-  autoUpdate: () => autoApplyUpdates.read() && !hostDrain.draining,
+  autoUpdate: () => hubUpdatesMachines({ build: BUILD, current: APP_VERSION, autoApply: autoApplyUpdates.read(), draining: hostDrain.draining }),
   reverse: reverseCalls({
     allowed: (machineId) => store.machines.linkedMachineAsks(machineId),
     projects: () => mgr.projectsForMachines(),

package/host/remote-install.mjs

@@ -462,12 +462,24 @@ function atLeast(a, b) {
 /** A release a dev build can be cut from: a prerelease, since `<base>.local.N` is SemVer only on one (`isLocalBuildVersion`) */
 const DEV_BASE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*$/
 /**
- * The placeholder a working copy's version files carry once its release version is stamped from the tag at build time
- * (#1501). A dev build of it would say it is `0.0.0-dev.local.N`, older than every release, so it is refused, by hubs
- * carrying this from before the switch lands.
+ * The placeholder a working copy's version files carry since its release version is stamped from the tag at build time
+ * (#1501). Never a dev build's base: `0.0.0-dev.local.N` would be older than every release.
  */
 const PLACEHOLDER = /^0\.0\.0-dev(?:\.|$)/
 
+/**
+ * The release a dev build of the working copy is cut from, as `scripts/app-version.mjs` resolves it for a local build
+ * (#1501): the newest release tag reachable from HEAD there. A commit from before the switch, in a clone without tags,
+ * still carries its version in the shim's manifest, which is taken then. An empty string when neither says.
+ */
+function devBase(repo, shim) {
+  const r = spawnSync('git', ['-C', repo, 'describe', '--tags', '--abbrev=0', '--match', 'v[0-9]*'], { cwd: repo, encoding: 'utf8', windowsHide: true })
+  const tag = r.status === 0 ? String(r.stdout).trim().replace(/^v/, '') : ''
+  if (tag) return tag
+  const own = String(shim.version ?? '')
+  return PLACEHOLDER.test(own) ? '' : own
+}
+
 /** git in the working copy, by name on PATH as the person runs it there; what it printed, or a refusal */
 function git(repo, args) {
   const r = spawnSync('git', ['-C', repo, ...args], { cwd: repo, encoding: 'utf8', windowsHide: true, maxBuffer: 16 * 1024 * 1024 })
@@ -514,7 +526,7 @@ export function devBuild(p, { dataDir = process.env.CC_DATA_DIR || join(homedir(
     const changes = git(repo, ['status', '--porcelain']).split('\n').filter((line) => line.trim()).length
     if (changes > 0 && !p.allowDirty) throw new Refusal('dev_dirty', String(changes))
     const shim = JSON.parse(readFileSync(join(repo, 'packaging', 'npm', 'centralu', 'package.json'), 'utf8'))
-    const base = String(shim.version ?? '')
+    const base = devBase(repo, shim)
     if (!DEV_BASE.test(base) || base.includes('.local.') || PLACEHOLDER.test(base)) throw new Refusal('dev_base', base)
     const protocol = Number(/export const PROTOCOL_VERSION = (\d+)/.exec(readFileSync(join(repo, 'packages', 'protocol', 'src', 'envelope.ts'), 'utf8'))?.[1])
     if (protocol !== p.protocol) throw new Refusal('dev_protocol', `${protocol} ${p.protocol}`)

package/package.json

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