@centralu/win32-x64 0.1.0-beta.13 → 0.1.0-beta.14

package/Centralu/resources/host/main.mjs

@@ -42886,7 +42886,7 @@ import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync10, writeSync
 
 // packages/protocol/src/brand.ts
 var APP_NAME = "Centralu";
-var APP_VERSION = "0.1.0-beta.13";
+var APP_VERSION = "0.1.0-beta.14";
 var APP_SLUG = "centralu";
 var CLIENT_INFO = { name: APP_SLUG, title: APP_NAME, version: APP_VERSION };
 var DATA_DIR = ".centralu";
@@ -58125,7 +58125,7 @@ function parseUiPreferences(raw) {
 // packages/protocol/src/machines.ts
 var MACHINE_ID_RE = /^[a-z][a-z0-9-]{0,31}$/;
 var MachineId = external_exports.string().regex(MACHINE_ID_RE, "Not a machine id");
-var MachineStatus = external_exports.enum(["connecting", "connected", "unreachable", "not_running", "versions_differ", "refused", "starting"]);
+var MachineStatus = external_exports.enum(["connecting", "connected", "unreachable", "not_running", "versions_differ", "refused", "starting", "updating"]);
 var MachineSide = external_exports.object({
   version: external_exports.string(),
   protocolVersion: external_exports.number().int(),
@@ -58145,6 +58145,14 @@ var MachineVersions = external_exports.object({
   /** The person chose to connect without aligning (`machines.acceptVersions`); only possible when compatible */
   accepted: external_exports.boolean().default(false)
 });
+var InstalledVersion = external_exports.object({ version: external_exports.string(), node: external_exports.string() });
+var MachineOperation = external_exports.object({
+  kind: external_exports.enum(["install", "update", "rollback", "uninstall"]).catch("update"),
+  step: external_exports.string(),
+  /** The version it brings the machine to, when there is one */
+  target: external_exports.string().nullable().default(null),
+  at: external_exports.number()
+});
 var MachineInfo = external_exports.object({
   id: MachineId,
   /** What the person calls it; shown as the group header in the sidebar */
@@ -58177,7 +58185,35 @@ var MachineInfo = external_exports.object({
    * because that machine blocks starting a process through WMI, and ends when the link does (`note`
    * says why). Null when the host was already running. Additive; an older hub sends nothing
    */
-  hostStarted: external_exports.object({ how: external_exports.enum(["detached", "link_bound"]).catch("detached"), at: external_exports.number(), note: external_exports.string().nullable().default(null) }).nullable().catch(null).default(null)
+  hostStarted: external_exports.object({ how: external_exports.enum(["detached", "link_bound"]).catch("detached"), at: external_exports.number(), note: external_exports.string().nullable().default(null) }).nullable().catch(null).default(null),
+  /**
+   * What the hub installed there, as the remote's connection line last said (docs/plans/remote-hub.md
+   * §10.5, S12): `managed` when the running `centralu` is that install, `current` and `previous` (the
+   * rollback target) from its pointer files. Null when the machine has not answered, or predates the
+   * field. Additive
+   */
+  install: external_exports.object({ managed: external_exports.boolean().catch(false), current: InstalledVersion.nullable().catch(null), previous: InstalledVersion.nullable().catch(null) }).nullable().catch(null).default(null),
+  /**
+   * An install, update, rollback or uninstall the hub is running there, and its step, while it runs
+   * (`machines.install` / `update` / `rollback` / `uninstall`). Null otherwise. Additive
+   */
+  operation: MachineOperation.nullable().catch(null).default(null)
+});
+var MachineInstallResult = external_exports.object({
+  machine: MachineInfo,
+  current: InstalledVersion,
+  previous: InstalledVersion.nullable(),
+  removed: external_exports.array(external_exports.string()).default([]),
+  left: external_exports.array(external_exports.string()).default([])
+});
+var MachineUninstallResult = external_exports.object({ machine: MachineInfo, stopped: external_exports.boolean() });
+var HostActivity = external_exports.object({
+  working: external_exports.number().int().default(0),
+  approvals: external_exports.number().int().default(0),
+  questions: external_exports.number().int().default(0),
+  background: external_exports.number().int().default(0),
+  terminals: external_exports.number().int().default(0),
+  commandRuns: external_exports.number().int().default(0)
 });
 
 // packages/protocol/src/events.ts
@@ -60754,6 +60790,43 @@ var RpcMethods = {
    * question comes again. Refused when the protocols differ.
    */
   "machines.acceptVersions": { params: external_exports.object({ machineId: MachineId }), result: MachineInfo },
+  /**
+   * Installs this hub's version on a linked machine over its ssh (docs/plans/remote-hub.md §10.2):
+   * the pinned Node and the npm packages, checked against the release's pin and the registry's
+   * signed metadata, beside what is there, with `current` switched to it and `previous` kept. A
+   * host running there is not touched; the next start runs the new version (`machines.update` stops
+   * and starts it in order). Refused by a development hub (its version is not on npm) and for
+   * a machine that runs a command of its own; answers when the install is done or refused
+   */
+  "machines.install": { params: external_exports.object({ machineId: MachineId }), result: MachineInstallResult },
+  /**
+   * Updates a linked machine to this hub's version (docs/plans/remote-hub.md §10.5): installs it beside
+   * the running one, stops the running host in order (`centralu serve --stop`; without a keeper its
+   * agents end and resume on the new host, a turn in progress is lost), switches `current`, starts it
+   * (`serve --detach`) and waits at most 30 s for a hello from the new version. When none comes, the
+   * old version is put back and started, and the call fails with the end of the new host's log. On
+   * success only the current and previous versions are kept. Progress is the machine's `operation`
+   * in `machine_status`. Refused like `machines.install`
+   */
+  "machines.update": { params: external_exports.object({ machineId: MachineId }), result: MachineInstallResult },
+  /**
+   * Switches a machine back to the version the hub installed before (`previous`), stopping and starting
+   * its host as `machines.update` does and checking the same way. One step only: `previous` is cleared,
+   * so a second rollback is not offered (a store migrated twice may not read on the older build)
+   */
+  "machines.rollback": { params: external_exports.object({ machineId: MachineId }), result: MachineInstallResult },
+  /**
+   * Stops the host there and removes what the hub installed (`<data>/remote/`), keeping the machine's
+   * data and an npm install of its own. The machine stays linked
+   */
+  "machines.uninstall": { params: external_exports.object({ machineId: MachineId }), result: MachineUninstallResult },
+  /**
+   * What would stop on a linked machine if its host stopped now (`host.activity`, asked of it), for the
+   * "Update <machine>" prompt. Null when the machine cannot say (unreachable, other protocol, older)
+   */
+  "machines.activity": { params: external_exports.object({ machineId: MachineId }), result: external_exports.object({ activity: HostActivity.nullable() }) },
+  /** What would stop if this host stopped now (the `hostBusy` rule); for a hub's `machines.activity` */
+  "host.activity": { params: external_exports.object({}), result: HostActivity },
   /**
    * Stops this host the way a signal would: agents, terminals, command runs and app processes
    * stopped in order, the store closed, then exit. For `centralu serve --stop` (docs/agent-host.md
@@ -60935,6 +61008,17 @@ function sessionBusy(s) {
 function hostBusy(s) {
   return s.terminals > 0 || s.commandRuns > 0 || s.sessions.some(sessionBusy);
 }
+function activityCounts(s) {
+  const c = { working: 0, approvals: 0, questions: 0, background: 0, terminals: s.terminals, commandRuns: s.commandRuns };
+  for (const x of s.sessions) {
+    if (!sessionBusy(x)) continue;
+    if (x.pendingApproval || x.state === "waiting_approval") c.approvals++;
+    else if ((x.pendingQuestions?.length ?? 0) > 0) c.questions++;
+    else if (BUSY_STATES.has(x.state)) c.working++;
+    else c.background++;
+  }
+  return c;
+}
 function sessionIdle(s, process4) {
   if (s.pendingApproval) return { idle: false, reason: "approval" };
   if (s.pendingQuestions.length > 0) return { idle: false, reason: "question" };
@@ -62278,8 +62362,9 @@ function restoreViewHandover(settings, views2, inline, now = Date.now()) {
   if (!(age2 >= 0 && age2 <= VIEW_HANDOVER_MAX_AGE_MS)) return { restored: 0, skipped: list.length };
   const opened = new Set(views2.restore(list));
   for (const v of list) {
+    if (typeof v !== "object" || v === null || !opened.has(v.id)) continue;
     const o = v.inline;
-    if (!opened.has(v.id) || !o || typeof o.sessionId !== "string" || typeof o.callId !== "string" || typeof o.tool !== "string") continue;
+    if (!o || typeof o.sessionId !== "string" || typeof o.callId !== "string" || typeof o.tool !== "string") continue;
     inline?.adopt({ sessionId: o.sessionId, callId: o.callId, ref: v.app, tool: o.tool, uri: v.uri, instanceId: v.id });
   }
   return { restored: opened.size, skipped: list.length - opened.size };
@@ -94949,7 +95034,8 @@ var AppVersions2 = class {
     for (const name of names) {
       if (name.startsWith(".")) continue;
       try {
-        out.push(JSON.parse(readFileSync7(join13(dir, name, "meta.json"), "utf8")));
+        const meta3 = JSON.parse(readFileSync7(join13(dir, name, "meta.json"), "utf8"));
+        if (meta3 && typeof meta3 === "object" && typeof meta3.id === "string" && typeof meta3.at === "number") out.push(meta3);
       } catch {
       }
     }
@@ -98105,6 +98191,19 @@ var SKILL_PROPOSALS_KEY = "orchestrator_skill_proposals";
 var SKILLS_KEY = "orchestrator_skills";
 var SKILL_MAX_COUNT = 10;
 var SKILL_MAX_CHARS = 2e3;
+var isText = (v) => typeof v === "string";
+var isTextList = (v) => Array.isArray(v) && v.every(isText);
+function storedList(raw, has) {
+  if (!raw) return [];
+  let v;
+  try {
+    v = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(v)) return [];
+  return v.filter((x) => typeof x === "object" && x !== null && !Array.isArray(x) && has(x));
+}
 var OrchestratorProposals = class {
   constructor(store2, apps) {
     this.store = store2;
@@ -98114,12 +98213,7 @@ var OrchestratorProposals = class {
   apps;
   /** MCP server proposals waiting on the person's approval */
   mcpProposals() {
-    try {
-      const raw = this.store.appSetting(MCP_PROPOSALS_KEY);
-      return raw ? JSON.parse(raw) : [];
-    } catch {
-      return [];
-    }
+    return storedList(this.store.appSetting(MCP_PROPOSALS_KEY), (x) => isText(x.name) && isText(x.command) && isTextList(x.args));
   }
   /** Saves an MCP server proposal (propose_mcp_server) — validation and persistence only */
   proposeMcpServer(spec) {
@@ -98219,21 +98313,11 @@ var OrchestratorProposals = class {
   }
   /** Skill proposals waiting on the person's approval (#71) */
   skillProposals() {
-    try {
-      const raw = this.store.appSetting(SKILL_PROPOSALS_KEY);
-      return raw ? JSON.parse(raw) : [];
-    } catch {
-      return [];
-    }
+    return storedList(this.store.appSetting(SKILL_PROPOSALS_KEY), (x) => isText(x.name) && isText(x.content));
   }
   /** Skills that have been approved and loaded into the orchestrator's role prompt (#71) */
   orchestratorSkills() {
-    try {
-      const raw = this.store.appSetting(SKILLS_KEY);
-      return raw ? JSON.parse(raw) : [];
-    } catch {
-      return [];
-    }
+    return storedList(this.store.appSetting(SKILLS_KEY), (x) => isText(x.name) && isText(x.content));
   }
   /**
    * Turns approved skills into a block appended to the role prompt (#71). This is tool-agnostic text
@@ -101914,11 +101998,17 @@ var Store = class _Store {
   forgetProjectConsent(fromProjectId, toProjectId, kind) {
     return this.db.prepare(`DELETE FROM project_consents WHERE from_project_id = ? AND to_project_id = ? AND kind = ?`).run(fromProjectId, toProjectId, kind).changes > 0;
   }
+  /**
+   * Only the kinds this build knows (#384). `kind` has no CHECK, so a newer build can add one without a breaking step;
+   * a row of a kind this build cannot name is left in place for that build rather than listed here, where the settings
+   * screen would show it without a label and could not revoke it (`projectConsents.revoke` takes known kinds only).
+   */
   listProjectConsents() {
-    return this.db.prepare(
+    const rows = this.db.prepare(
       `SELECT from_project_id as fromProjectId, to_project_id as toProjectId, kind, decided_at as decidedAt
            FROM project_consents ORDER BY decided_at DESC`
     ).all();
+    return rows.filter((r) => ProjectConsentKind.safeParse(r.kind).success);
   }
   // ── Linked machines (#82, v46) ─────────────────────────────────────────────────────────────
   listLinkedMachines() {
@@ -104491,7 +104581,7 @@ var SessionManager = class _SessionManager {
 ` : ending.type === "turn_complete" ? `[Centralu] The assigned work finished.
 ` : `[Centralu] The assigned work stopped before finishing.
 `;
-    const failure2 = ending.type === "error" ? `Error: ${ending.error.message.slice(0, 600)}
+    const failure3 = ending.type === "error" ? `Error: ${ending.error.message.slice(0, 600)}
 
 ` : "";
     try {
@@ -104501,7 +104591,7 @@ var SessionManager = class _SessionManager {
 id: ${sessionId}
 Project: ${frameField(project2)}
 
-` + failure2 + `Last response:
+` + failure3 + `Last response:
 ${preview || "(no content)"}
 
 If you need more, you can read that session's recent conversation with read_session.`,
@@ -105429,33 +105519,53 @@ ${String(stderr).slice(0, 2e3)}`
    * Screen preferences (UiPreferences) — read as one blob, and written back accepting **only what
    * changed.**
    *
-   * Corrupted JSON is treated the same as if it did not exist (parseUiPreferences). The app failing
-   * to start because of a single broken setting is worse than losing one value the person had chosen.
+   * Corrupted JSON is treated the same as if it did not exist (parseUiPreferences), and said once on
+   * stderr with the row it came from. The app failing to start because of a single broken setting is
+   * worse than losing one value the person had chosen.
    */
   uiPreferences() {
-    const raw = this.store.appSetting(UI_PREFS_KEY);
-    let stored;
-    try {
-      stored = raw === null ? void 0 : JSON.parse(raw);
-    } catch {
-      stored = void 0;
-    }
+    const stored = this.storedUiPreferences();
     const prefs = parseUiPreferences(stored);
-    const hasTextSize = typeof stored === "object" && stored !== null && "textSize" in stored;
-    if (!hasTextSize) {
+    if (!("textSize" in stored)) {
       const legacy = textSizeFromLegacyStep(this.loadWorkspace()?.textScale);
       if (legacy !== null) {
         prefs.textSize = legacy;
-        this.store.setAppSetting(UI_PREFS_KEY, JSON.stringify(prefs));
+        this.store.setAppSetting(UI_PREFS_KEY, JSON.stringify({ ...stored, textSize: legacy }));
       }
     }
     return prefs;
   }
+  /**
+   * Writes the patch **over the stored record, not over this build's reading of it** (#384). Another
+   * build reads and writes the same row: during a host swap, and after a person goes back a release.
+   * A field this build does not know, or a value it cannot read (a theme mode a newer build added),
+   * stays as it was unless the patch sets it, so changing the text size in an older build does not
+   * reset what a newer one chose.
+   */
   setUiPreferences(patch) {
-    const next = { ...this.uiPreferences(), ...patch };
-    this.store.setAppSetting(UI_PREFS_KEY, JSON.stringify(next));
-    return next;
+    const current = this.uiPreferences();
+    this.store.setAppSetting(UI_PREFS_KEY, JSON.stringify({ ...this.storedUiPreferences(), ...patch }));
+    if (patch.sessionTools !== void 0 && patch.sessionTools !== current.sessionTools) {
+      for (const id2 of this.meta.keys()) this.appsHub?.sessionAppsChanged(id2);
+    }
+    return { ...current, ...patch };
+  }
+  /** The stored record as written, every field kept; `{}` for none or for one that is not a JSON object */
+  storedUiPreferences() {
+    const raw = this.store.appSetting(UI_PREFS_KEY);
+    if (raw === null) return {};
+    try {
+      const v = JSON.parse(raw);
+      if (typeof v === "object" && v !== null && !Array.isArray(v)) return v;
+    } catch {
+    }
+    if (!this.brokenPrefsSaid) {
+      this.brokenPrefsSaid = true;
+      console.error(`[agent-host] app_settings.${UI_PREFS_KEY} is not a JSON object; screen preferences read as their defaults until the next change`);
+    }
+    return {};
   }
+  brokenPrefsSaid = false;
   /** The settings screen must be able to see and delete rules (FR-3: make the outcome visible) */
   listApprovalRules() {
     return this.store.listApprovalRules().filter((r) => r.matcher).map((r) => ({
@@ -106595,7 +106705,12 @@ ${String(stderr).slice(0, 2e3)}`
       ...opts,
       onDemand: {
         attached: (id2) => this.appAccess?.attached(id2) ?? [],
-        allowed: (session2, app) => this.appAccess?.allowed(session2, app) ?? false
+        /*
+         * Only while the session holds the reader set (#382): attach_app and detach_app are part of it, so a
+         * session the person turned the set off for (or that became a manager) would keep tools it can no
+         * longer detach. The records stay; they count again once the set is back.
+         */
+        allowed: (session2, app) => this.toolProfileOf(session2.id) === "reader" && (this.appAccess?.allowed(session2, app) ?? false)
       }
     });
     this.appAccess = new AppAccess({
@@ -107454,6 +107569,29 @@ async function readUsage(q2) {
   if (typeof fn2 !== "function") throw new Error(UNSUPPORTED2);
   return toSnapshot(await fn2.call(q2));
 }
+var USAGE_ASK_MS = 4e3;
+async function readUsageFromAny(queries, { timeoutMs = USAGE_ASK_MS, log = (line) => console.error(line) } = {}) {
+  let first = null;
+  for (const [i, { query, sessionId }] of queries.entries()) {
+    let timer;
+    try {
+      return await Promise.race([
+        readUsage(query),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error(`no answer within ${timeoutMs} ms`)), timeoutMs);
+        })
+      ]);
+    } catch (e) {
+      first ??= e;
+      const why = e instanceof Error ? e.message : String(e);
+      log(`[usage] claude: session ${sessionId ?? "unknown"} could not read usage (${i + 1} of ${queries.length}): ${why}`);
+      if (why === UNSUPPORTED2) break;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw first instanceof Error ? first : new Error("A running session is required to read usage");
+}
 
 // packages/agent-host/src/adapters/claude/orchestrator-mcp.ts
 init_sdk();
@@ -108736,22 +108874,22 @@ var ClaudeSession = class {
          *   Bash caught by an `ask` rule in the settings file   reaches the callback → answering allow runs it
          *   the same request, with no callback (old-style auto)   denied — "Claude requested permissions to use Bash, but you haven't granted it yet."
          *
-         * So auto's own callback only accepts question choices, and **denies everything else the
-         * way it used to.** Allowing it here would let our own callback approve an `ask` rule
+         * So auto's own callback only accepts question choices and Centralu's own tools (which every
+         * preset lets through, #382), and **denies everything else the way it used to.** Allowing it here would let our own callback approve an `ask` rule
          * written into a trusted project's own `.claude/settings.json` — the opposite direction
          * from #92, which exists so files from the repo cannot decide approvals. (The SDK leaves a
          * `CLAUDE_SDK_CAN_USE_TOOL_SHADOWED` warning line for this combination.)
          */
         canUseTool: async (toolName, toolInput) => {
+          if (isOrchestratorTool(toolName) && self2.orchestratorServer) {
+            return { behavior: "allow", updatedInput: toolInput };
+          }
           if (preset === "auto" && toolName !== "AskUserQuestion") {
             return {
               behavior: "deny",
               message: `Permission to use ${toolName} was not granted (a settings "ask" rule matched; the auto preset does not ask)`
             };
           }
-          if (isOrchestratorTool(toolName)) {
-            return { behavior: "allow", updatedInput: toolInput };
-          }
           const appTool = appToolOf(toolName);
           if (appTool && self2.opts.apps?.readOnly(appTool.server, appTool.tool)) {
             return { behavior: "allow", updatedInput: toolInput };
@@ -108781,6 +108919,7 @@ var ClaudeSession = class {
       }
     });
     ClaudeAdapter.liveQueries.add(q2);
+    ClaudeAdapter.querySessions.set(q2, this.sessionId);
     this.releaseLostCalls(q2);
     this.goalKnown = new Promise((resolve10) => this.settleGoalKnown = resolve10);
     q2.supportedCommands().then((list) => {
@@ -109306,6 +109445,8 @@ var ClaudeAdapter = class _ClaudeAdapter {
    * older session was still alive. Insertion order is the same as start order.
    */
   static liveQueries = /* @__PURE__ */ new Set();
+  /** Which session each live query belongs to, for the log line when one cannot answer (#481) */
+  static querySessions = /* @__PURE__ */ new WeakMap();
   /** The most recently started query that is still alive. */
   static get lastQuery() {
     let last = null;
@@ -109383,9 +109524,9 @@ var ClaudeAdapter = class _ClaudeAdapter {
    * a Query. It throws when there is no session at all, and the manager degrades with a reason.
    */
   async listUsage() {
-    const q2 = _ClaudeAdapter.lastQuery;
-    if (!q2) throw new Error("A running session is required to read usage");
-    return readUsage(q2);
+    const live = [..._ClaudeAdapter.liveQueries].reverse();
+    if (live.length === 0) throw new Error("A running session is required to read usage");
+    return readUsageFromAny(live.map((query) => ({ query, sessionId: _ClaudeAdapter.querySessions.get(query) ?? null })));
   }
   async listModels() {
     const q2 = _ClaudeAdapter.lastQuery;
@@ -110428,16 +110569,16 @@ function normalizeNotification(sessionId, n) {
      */
     case "turn/completed": {
       const turn = obj(p.turn);
-      const failure2 = obj(turn.error);
-      if (str7(turn.status) !== "failed" && !failure2.message) return [{ type: "turn_complete", sessionId }];
-      const detail = str7(failure2.additionalDetails);
+      const failure3 = obj(turn.error);
+      if (str7(turn.status) !== "failed" && !failure3.message) return [{ type: "turn_complete", sessionId }];
+      const detail = str7(failure3.additionalDetails);
       return [
         {
           type: "error",
           sessionId,
           error: {
             code: "internal",
-            message: [str7(failure2.message) || "The turn failed", detail].filter(Boolean).join("\n"),
+            message: [str7(failure3.message) || "The turn failed", detail].filter(Boolean).join("\n"),
             retryable: true
           }
         }
@@ -110895,6 +111036,8 @@ var CodexSession = class {
   elicitations = /* @__PURE__ */ new Set();
   /** App servers loaded onto this thread through the bridge — only elicitations under those names go to our cards */
   appServers = /* @__PURE__ */ new Set();
+  /** Whether this thread was given Centralu's own server — only then is an elicitation under that name ours to accept (#382) */
+  ownServer = false;
   reqCounter = 0;
   alwaysAllow = new AlwaysAllowRules();
   /**
@@ -111118,6 +111261,7 @@ var CodexSession = class {
     const bridge = this.opts.orchestratorBridge;
     const servers = {};
     const orchestrator = !!(this.opts.orchestratorTools && bridge);
+    this.ownServer = orchestrator;
     if (orchestrator) {
       servers[ORCHESTRATOR_MCP_NAME] = {
         command: process.execPath,
@@ -111321,7 +111465,7 @@ var CodexSession = class {
         this.emit({ type: "approval_request", sessionId: this.sessionId, requestId: requestId2, detail: appApprovalDetail(p.serverName, p.message, p._meta) });
         return;
       }
-      const ours = p.serverName === ORCHESTRATOR_MCP_NAME;
+      const ours = p.serverName === ORCHESTRATOR_MCP_NAME && this.ownServer;
       this.client.respond(r.id, { action: ours ? "accept" : "decline", content: null, _meta: null });
       return;
     }
@@ -112181,7 +112325,7 @@ var toInfo = (h) => ({
 function sessionIdsOf(panels) {
   return panels.flatMap((p) => p.kind === "session" ? [p.sessionId] : []);
 }
-function createRpcHandler(mgr2, adapters2, { terminals: terminals2, updates: updates2, commands, externalApps: externalApps2, views: views2, inlineViews: inlineViews2, heldPids, themes: themes2, agentVersions: agentVersions2, machines, stopHost } = {}) {
+function createRpcHandler(mgr2, adapters2, { terminals: terminals2, updates: updates2, commands, externalApps: externalApps2, views: views2, inlineViews: inlineViews2, heldPids, themes: themes2, agentVersions: agentVersions2, machines, stopHost, activity: activity2 } = {}) {
   const requireThemes = () => {
     if (!themes2) throw Object.assign(new Error("Theme files are unavailable"), { code: "internal" });
     return themes2;
@@ -112768,6 +112912,15 @@ function createRpcHandler(mgr2, adapters2, { terminals: terminals2, updates: upd
       return { ok: true };
     },
     "machines.reconnect": async (p) => requireMachines().reconnect(RpcMethods["machines.reconnect"].params.parse(p).machineId),
+    "machines.install": async (p) => requireMachines().install(RpcMethods["machines.install"].params.parse(p).machineId),
+    "machines.update": async (p) => requireMachines().update(RpcMethods["machines.update"].params.parse(p).machineId),
+    "machines.rollback": async (p) => requireMachines().rollback(RpcMethods["machines.rollback"].params.parse(p).machineId),
+    "machines.uninstall": async (p) => requireMachines().uninstall(RpcMethods["machines.uninstall"].params.parse(p).machineId),
+    "machines.activity": async (p) => ({ activity: await requireMachines().activity(RpcMethods["machines.activity"].params.parse(p).machineId) }),
+    "host.activity": async () => {
+      if (!activity2) throw Object.assign(new Error("This host does not report its activity"), { code: "internal" });
+      return activity2();
+    },
     "machines.acceptVersions": async (p) => requireMachines().acceptVersions(RpcMethods["machines.acceptVersions"].params.parse(p).machineId),
     "updates.status": async (p) => requireUpdates().check(RpcMethods["updates.status"].params.parse(p).force),
     "updates.setAuto": async (p) => requireUpdates().setAuto(RpcMethods["updates.setAuto"].params.parse(p).enabled),
@@ -114046,6 +114199,752 @@ async function runDrain(bound, deps) {
   return report;
 }
 
+// packages/agent-host/src/links/install.ts
+import { existsSync as existsSync20, readFileSync as readFileSync13 } from "node:fs";
+import { hostname as hostname3 } from "node:os";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { gzipSync } from "node:zlib";
+
+// packages/agent-host/src/links/registry.ts
+import { createPublicKey, verify } from "node:crypto";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+var PACKAGE_NAME = /^(@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+var VERSION = /^[0-9A-Za-z][0-9A-Za-z.+-]{0,63}$/;
+async function getJson(url2, f) {
+  const res = await f(url2, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(3e4) });
+  if (!res.ok) throw new Error(`The npm registry answered ${res.status} for ${url2}`);
+  return res.json();
+}
+async function verifiedPackage(name, version2, opts = {}) {
+  if (!PACKAGE_NAME.test(name) || !VERSION.test(version2)) throw new Error(`Not a package to install: ${name}@${version2}`);
+  const registry2 = (opts.registry ?? NPM_REGISTRY).replace(/\/+$/, "");
+  const f = opts.fetch ?? globalThis.fetch;
+  const now = opts.now?.() ?? Date.now();
+  const [meta3, keys] = await Promise.all([getJson(`${registry2}/${name}/${version2}`, f), getJson(`${registry2}/-/npm/v1/keys`, f)]);
+  const m = meta3;
+  if (m?.name !== name || m.version !== version2) throw new Error(`The npm registry answered for another package than ${name}@${version2}`);
+  const tarball = m.dist?.tarball;
+  const integrity = m.dist?.integrity;
+  if (typeof integrity !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(integrity)) {
+    throw new Error(`${name}@${version2} has no sha512 integrity in the registry`);
+  }
+  if (typeof tarball !== "string" || new URL(tarball).origin !== new URL(registry2).origin) {
+    throw new Error(`${name}@${version2}'s tarball is not served by the registry (${String(tarball)})`);
+  }
+  const known = /* @__PURE__ */ new Map();
+  for (const k2 of keys?.keys ?? []) {
+    if (k2 && typeof k2.keyid === "string" && typeof k2.key === "string") known.set(k2.keyid, k2);
+  }
+  const signed = `${name}@${version2}:${integrity}`;
+  const sigs = Array.isArray(m.dist?.signatures) ? m.dist.signatures : [];
+  const ok = sigs.some((s) => {
+    const key = typeof s?.keyid === "string" ? known.get(s.keyid) : void 0;
+    if (!key || typeof s.sig !== "string") return false;
+    if (key.expires && Date.parse(key.expires) <= now) return false;
+    try {
+      const pub = createPublicKey({ key: Buffer.from(key.key, "base64"), format: "der", type: "spki" });
+      return verify("sha256", Buffer.from(signed), pub, Buffer.from(s.sig, "base64"));
+    } catch {
+      return false;
+    }
+  });
+  if (!ok) throw new Error(`The npm registry's signature on ${name}@${version2} does not check out; nothing was installed`);
+  return { name, version: version2, tarball, integrity };
+}
+
+// packages/agent-host/src/links/tunnel.ts
+import { spawn as spawn5 } from "node:child_process";
+import { createConnection as createConnection2, createServer as createServer3 } from "node:net";
+function parseConnectionLine(stdout) {
+  const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let raw;
+    try {
+      raw = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    const o = raw;
+    if (o && typeof o === "object" && typeof o.v === "number") {
+      if (o.v !== 1) throw new Error(`The remote's Centralu speaks connection format ${o.v}; update Centralu on this computer`);
+      if (typeof o.port !== "number" || typeof o.token !== "string" || typeof o.protocolVersion !== "number") {
+        throw new Error("The remote answered with an incomplete connection line");
+      }
+      const install = parseInstall(o.install);
+      return {
+        v: 1,
+        port: o.port,
+        token: o.token,
+        version: typeof o.version === "string" ? o.version : "unknown",
+        protocolVersion: o.protocolVersion,
+        dataDir: typeof o.dataDir === "string" ? o.dataDir : "",
+        hostRunning: o.hostRunning === true,
+        ...install ? { install } : {}
+      };
+    }
+  }
+  throw new Error("The remote did not print a connection line; its Centralu may predate `centralu serve` (update it there: npm i -g centralu)");
+}
+function parseInstall(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  const pointer = (v) => {
+    const p = v;
+    return p && typeof p.version === "string" && typeof p.node === "string" ? { version: p.version, node: p.node } : null;
+  };
+  return { managed: o.managed === true, current: pointer(o.current), previous: pointer(o.previous), node: typeof o.node === "string" ? o.node : null };
+}
+function parseDetachLine(stdout) {
+  const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let raw;
+    try {
+      raw = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    const d2 = raw?.detach;
+    if (!d2 || typeof d2 !== "object") continue;
+    if (d2.ok === true) return { ok: true, line: parseConnectionLine(lines[i]), how: typeof d2.how === "string" ? d2.how : null };
+    return { ok: false, reason: typeof d2.reason === "string" ? d2.reason : "failed", message: typeof d2.message === "string" ? d2.message : "centralu serve --detach failed" };
+  }
+  throw new Error("The remote did not say whether it started");
+}
+var WSL_DISTRO_RE = /^[A-Za-z0-9._-]{1,64}$/;
+function powershell(script) {
+  const full = `[Console]::OutputEncoding=[Text.Encoding]::UTF8
+${script}`;
+  return `powershell -NoProfile -NonInteractive -EncodedCommand ${Buffer.from(full, "utf16le").toString("base64")}`;
+}
+function wslKeepAlive(spec) {
+  if (spec?.shell !== "wsl") return null;
+  const distro = spec.wslDistro ?? "";
+  if (!WSL_DISTRO_RE.test(distro)) throw new Error(`Not a WSL distro name: ${distro || "(none)"}`);
+  return `wsl.exe -d ${distro} --exec sleep infinity`;
+}
+var MANAGED_SH = 'm="${CC_DATA_DIR:-$HOME/.centralu}/remote/bin/centralu"';
+var MANAGED_PS = "$d = if ($env:CC_DATA_DIR) { $env:CC_DATA_DIR } else { Join-Path $env:USERPROFILE '.centralu' }; $m = Join-Path $d 'remote\\bin\\centralu.cmd'";
+var NOT_FOUND2 = "CENTRALU-NOT-FOUND";
+function connectionCommand(spec) {
+  return remoteCommand(spec, "serve --connection");
+}
+function detachCommand(spec) {
+  return remoteCommand(spec, "serve --detach");
+}
+function stopCommand(spec) {
+  return remoteCommand(spec, "serve --stop");
+}
+function serveCommand(spec) {
+  return remoteCommand(spec, "serve");
+}
+function remoteCommand(spec, args) {
+  const custom2 = spec.command?.trim() || null;
+  if (spec.shell === "powershell") {
+    if (custom2) return powershell(`${custom2} ${args}`);
+    return powershell(
+      `${MANAGED_PS}; if (Test-Path $m) { & $m ${args} } elseif (Get-Command centralu -ErrorAction SilentlyContinue) { & centralu ${args} } else { $l = Join-Path $env:USERPROFILE '.centralu\\bin\\centralu.cmd'; if (Test-Path $l) { & $l ${args} } else { '${NOT_FOUND2}' } }`
+    );
+  }
+  const lookup = `${MANAGED_SH}; if [ -x "$m" ]; then exec "$m" ${args}; elif command -v centralu >/dev/null 2>&1; then exec centralu ${args}; elif [ -x "$HOME/.centralu/bin/centralu" ]; then exec "$HOME/.centralu/bin/centralu" ${args}; else echo ${NOT_FOUND2}; exit 127; fi`;
+  if (spec.shell === "posix") return custom2 ? `${custom2} ${args}` : `sh -c '${lookup}'`;
+  const distro = spec.wslDistro ?? "";
+  if (!WSL_DISTRO_RE.test(distro)) throw new Error(`Not a WSL distro name: ${distro || "(none)"}`);
+  const script = custom2 ? `${custom2} ${args}` : `PATH=$(printf %s "$PATH" | tr : '\\n' | grep -v '^/mnt/' | paste -sd: -); ${lookup}`;
+  const b64 = Buffer.from(script, "utf8").toString("base64");
+  return powershell(`wsl.exe -d '${distro}' -- bash -lc 'echo ${b64} | base64 -d | bash -l'`);
+}
+function remoteScript(spec, script) {
+  if (spec.shell === "powershell") return powershell(script.ps);
+  const b64 = Buffer.from(script.sh, "utf8").toString("base64");
+  if (spec.shell === "posix") return `printf %s ${b64} | base64 -d | sh`;
+  const distro = spec.wslDistro ?? "";
+  if (!WSL_DISTRO_RE.test(distro)) throw new Error(`Not a WSL distro name: ${distro || "(none)"}`);
+  return powershell(`wsl.exe -d '${distro}' -- bash -lc 'echo ${b64} | base64 -d | bash -l'`);
+}
+var SshTunnel = class {
+  constructor(opts) {
+    this.opts = opts;
+    if (!opts.target.trim() || opts.target.startsWith("-")) throw new Error("Not an ssh target");
+  }
+  opts;
+  child = null;
+  /** The asking ssh runs, while they run */
+  asking = /* @__PURE__ */ new Set();
+  downListeners = [];
+  closing = false;
+  /** The remote cannot start a host outside a session (WMI blocked): the forward runs it (`startHost`) */
+  linkBound = false;
+  async open() {
+    await this.stopChild();
+    this.closing = false;
+    const line = await this.connectionLine().catch((err) => {
+      this.ifClosed();
+      throw err;
+    });
+    this.ifClosed();
+    if (!line.hostRunning && !this.linkBound) {
+      return { url: "", token: line.token, line, localPort: 0 };
+    }
+    const hosting = !line.hostRunning;
+    let localPort = await portFree(line.port) ? line.port : await freePort();
+    try {
+      await this.forward(localPort, line.port, hosting);
+    } catch (err) {
+      if (localPort !== line.port) throw err;
+      this.ifClosed();
+      localPort = await freePort();
+      await this.forward(localPort, line.port, hosting);
+    }
+    if (this.closing) {
+      await this.stopChild();
+      this.ifClosed();
+    }
+    const served = hosting ? await this.untilServing() : line;
+    return { url: `ws://127.0.0.1:${localPort}`, token: served.token, line: served, localPort };
+  }
+  /**
+   * Starts the remote's host with `centralu serve --detach` (plan §10.4, owner decision 7): it then
+   * runs outside any ssh session and outlives this link. When the remote says WMI process creation
+   * is blocked there (decision 3), every `open` from then on runs `centralu serve` as the forward's
+   * own remote command instead, so the host lives as long as the link.
+   */
+  async startHost() {
+    this.ifClosed();
+    const remote = this.opts.remote ?? { shell: "posix" };
+    const r = await this.run([...this.config(), "-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", "--", this.opts.target, detachCommand(remote)]);
+    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 new Error(`Centralu is not installed on ${this.opts.target} (run \`npm i -g centralu\` there, then \`centralu serve\` once)`);
+    }
+    let answer;
+    try {
+      answer = parseDetachLine(r.stdout);
+    } catch (err) {
+      if (/unknown option for serve: --detach/.test(r.stderr)) {
+        throw new Error(`Centralu on ${this.opts.target} is too old to be started from here: run \`centralu serve\` there, or update it (npm i -g centralu)`);
+      }
+      const why = lastLine(r.stderr);
+      throw new Error(`${err.message}${why ? `: ${why}` : r.code ? ` (exit ${r.code})` : ""}`);
+    }
+    if (answer.ok) {
+      this.linkBound = false;
+      return { how: "detached", note: null };
+    }
+    if (answer.reason === "wmi_blocked") {
+      this.linkBound = true;
+      return { how: "link_bound", note: answer.message };
+    }
+    throw new Error(answer.message);
+  }
+  /**
+   * Runs one command there the way the connection line is asked for (batch mode, `--` before the
+   * target), and answers what it printed. For the installer (install.ts): the command is already in
+   * the remote shell's terms. `close()` ends it like any asking ssh
+   */
+  async exec(command) {
+    this.ifClosed();
+    const r = await this.run([...this.config(), "-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", "--", this.opts.target, command]);
+    if (r.code === 255) throw new Error(`ssh could not reach ${this.opts.target}: ${lastLine(r.stderr) || "no answer"}`);
+    return r;
+  }
+  /** The connection line again until the link-bound host answers, or the forward that runs it ends */
+  async untilServing() {
+    const deadline = Date.now() + (this.opts.startTimeoutMs ?? 3e4);
+    for (; ; ) {
+      this.ifClosed();
+      if (!this.child) throw new Error(`The ssh session that runs Centralu on ${this.opts.target} ended before it served`);
+      const line = await this.connectionLine();
+      if (line.hostRunning) return line;
+      if (Date.now() > deadline) {
+        await this.stopChild();
+        throw new Error(`Centralu on ${this.opts.target} did not start serving in time`);
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  onDown(listener) {
+    this.downListeners.push(listener);
+  }
+  async close() {
+    this.closing = true;
+    for (const c of this.asking) c.kill("SIGTERM");
+    await this.stopChild();
+  }
+  ifClosed() {
+    if (this.closing) throw new Error(`The link to ${this.opts.target} was closed`);
+  }
+  run(args) {
+    return new Promise((resolve10, reject) => {
+      const child = spawn5(this.opts.ssh ?? "ssh", args, { env: this.opts.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+      this.asking.add(child);
+      child.once("exit", () => this.asking.delete(child));
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (d2) => stdout += String(d2));
+      child.stderr.on("data", (d2) => stderr += String(d2));
+      child.once("error", reject);
+      child.once("close", (code2) => resolve10({ code: code2, stdout, stderr }));
+    });
+  }
+  config() {
+    return this.opts.configFile ? ["-F", this.opts.configFile] : [];
+  }
+  async connectionLine() {
+    const remote = this.opts.remote ?? { shell: "posix" };
+    const base2 = [...this.config(), "-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", "--", this.opts.target];
+    const r = await this.run([...base2, connectionCommand(remote)]);
+    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 new Error(`Centralu is not installed on ${this.opts.target} (run \`npm i -g centralu\` there, then \`centralu serve\` once)`);
+    }
+    try {
+      return parseConnectionLine(r.stdout);
+    } catch (err) {
+      const why = lastLine(r.stderr);
+      throw new Error(`${err.message}${why ? `: ${why}` : r.code ? ` (exit ${r.code})` : ""}`);
+    }
+  }
+  forward(localPort, remotePort, hosting = false) {
+    this.ifClosed();
+    const keepAlive = hosting ? serveCommand(this.opts.remote ?? { shell: "posix" }) : wslKeepAlive(this.opts.remote);
+    const args = [
+      ...this.config(),
+      ...keepAlive ? ["-T"] : ["-N"],
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "ExitOnForwardFailure=yes",
+      "-o",
+      "ServerAliveInterval=15",
+      "-o",
+      "ServerAliveCountMax=3",
+      "-o",
+      "GatewayPorts=no",
+      "-L",
+      `127.0.0.1:${localPort}:127.0.0.1:${remotePort}`,
+      "--",
+      this.opts.target,
+      ...keepAlive ? [keepAlive] : []
+    ];
+    const child = spawn5(this.opts.ssh ?? "ssh", args, { env: this.opts.env ?? process.env, stdio: ["ignore", "ignore", "pipe"] });
+    this.child = child;
+    let stderr = "";
+    child.stderr.on("data", (d2) => stderr += String(d2));
+    return new Promise((resolve10, reject) => {
+      let settled = false;
+      const deadline = Date.now() + (this.opts.forwardTimeoutMs ?? 2e4);
+      const fail4 = (message) => {
+        if (settled) return;
+        settled = true;
+        reject(new Error(message));
+      };
+      child.once("error", (e) => fail4(`Could not start ssh: ${e.message}`));
+      child.once("exit", (code2, signal) => {
+        if (this.child === child) this.child = null;
+        if (!settled) return fail4(`The ssh forward to ${this.opts.target} ended (${signal ?? code2}): ${lastLine(stderr) || "no reason given"}`);
+        if (!this.closing) for (const l of this.downListeners) l(`ssh exited (${signal ?? code2})${stderr ? `: ${lastLine(stderr)}` : ""}`);
+      });
+      const poll = async () => {
+        while (!settled) {
+          if (await accepts(localPort)) {
+            settled = true;
+            this.opts.log?.(`[links] forward up: 127.0.0.1:${localPort} -> ${this.opts.target}:127.0.0.1:${remotePort}`);
+            return resolve10();
+          }
+          if (Date.now() > deadline) {
+            child.kill("SIGTERM");
+            return fail4(`The ssh forward to ${this.opts.target} did not come up in time`);
+          }
+          await new Promise((r) => setTimeout(r, 100));
+        }
+      };
+      void poll();
+    });
+  }
+  async stopChild() {
+    const child = this.child;
+    this.child = null;
+    if (!child || child.exitCode !== null || child.signalCode !== null) return;
+    await new Promise((resolve10) => {
+      child.once("exit", () => resolve10());
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        child.kill("SIGKILL");
+        resolve10();
+      }, 2e3).unref();
+    });
+  }
+};
+function lastLine(s) {
+  const lines = s.replace(/#< CLIXML[\s\S]*$/, "").split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("**") && !/^Node\.js v\d/.test(l) && !/^at /.test(l));
+  return [...lines].reverse().find((l) => /error|denied|refused|timed out|not found|cannot|could not/i.test(l)) ?? lines.at(-1) ?? "";
+}
+function accepts(port2) {
+  return new Promise((resolve10) => {
+    const s = createConnection2({ host: "127.0.0.1", port: port2 });
+    s.once("connect", () => {
+      s.destroy();
+      resolve10(true);
+    });
+    s.once("error", () => resolve10(false));
+  });
+}
+function portFree(port2) {
+  return new Promise((resolve10) => {
+    const probe = createServer3();
+    probe.once("error", () => resolve10(false));
+    probe.listen(port2, "127.0.0.1", () => probe.close(() => resolve10(true)));
+  });
+}
+function freePort() {
+  return new Promise((resolve10, reject) => {
+    const probe = createServer3();
+    probe.once("error", reject);
+    probe.listen(0, "127.0.0.1", () => {
+      const { port: port2 } = probe.address();
+      probe.close(() => resolve10(port2));
+    });
+  });
+}
+
+// packages/agent-host/src/links/install.ts
+var PREFLIGHT = "CENTRALU-PREFLIGHT";
+var STEP = "CENTRALU-INSTALL";
+var MIN_GLIBC = [2, 34];
+var NEED_MB = { linux: 600, win32: 300 };
+var DATA_SH = 'd="${CC_DATA_DIR:-$HOME/.centralu}"; r="$d/remote"';
+var DATA_PS = "$d = if ($env:CC_DATA_DIR) { $env:CC_DATA_DIR } else { Join-Path $env:USERPROFILE '.centralu' }; $r = Join-Path $d 'remote'";
+var PREFLIGHT_SH = `${DATA_SH}
+p="$d"; while [ ! -d "$p" ]; do p=$(dirname "$p"); done
+musl=0; if ldd --version 2>&1 | grep -qi musl; then musl=1; fi
+for f in /lib/ld-musl-*; do [ -e "$f" ] && musl=1; done
+has() { command -v "$1" >/dev/null 2>&1 && echo 1 || echo 0; }
+fetch=; if command -v curl >/dev/null 2>&1; then fetch=curl; elif command -v wget >/dev/null 2>&1; then fetch=wget; fi
+sha=; if command -v sha256sum >/dev/null 2>&1; then sha=sha256sum; elif command -v shasum >/dev/null 2>&1; then sha=shasum; fi
+echo "${PREFLIGHT} os=$(uname -s) arch=$(uname -m) glibc=$(getconf GNU_LIBC_VERSION 2>/dev/null | sed -n 's/^glibc //p') musl=$musl freeKb=$(df -Pk "$p" 2>/dev/null | awk 'NR==2 {print $4}') tar=$(has tar) gzip=$(has gzip) fetch=$fetch sha=$sha"
+`;
+var PREFLIGHT_PS = `${DATA_PS}
+$arch = if ($env:PROCESSOR_ARCHITEW6432) { $env:PROCESSOR_ARCHITEW6432 } else { $env:PROCESSOR_ARCHITECTURE }
+$p = $d; while (-not (Test-Path $p)) { $p = Split-Path $p }
+$free = try { [math]::Floor((New-Object IO.DriveInfo ([IO.Path]::GetPathRoot((Resolve-Path $p).Path))).AvailableFreeSpace / 1024) } catch { '' }
+$tar = [int](Test-Path (Join-Path $env:SystemRoot 'System32\\tar.exe'))
+$fetch = if (Test-Path (Join-Path $env:SystemRoot 'System32\\curl.exe')) { 'curl' } else { 'iwr' }
+"${PREFLIGHT} os=Windows arch=$arch glibc= musl=0 freeKb=$free tar=$tar gzip=1 fetch=$fetch sha=Get-FileHash"
+`;
+function preflightCommand(spec) {
+  return remoteScript(spec, { sh: PREFLIGHT_SH, ps: PREFLIGHT_PS });
+}
+function parsePreflight(stdout) {
+  const line = stdout.split(/\r?\n/).reverse().find((l) => l.startsWith(`${PREFLIGHT} `));
+  if (!line) throw new Error("The remote did not answer the install check");
+  const kv2 = new Map(line.slice(PREFLIGHT.length + 1).trim().split(/\s+/).map((w) => [w.slice(0, w.indexOf("=")), w.slice(w.indexOf("=") + 1)]));
+  const word = (k2) => kv2.get(k2) || null;
+  const free = Number(kv2.get("freeKb"));
+  return {
+    os: word("os") ?? "",
+    arch: word("arch") ?? "",
+    glibc: word("glibc"),
+    musl: kv2.get("musl") === "1",
+    freeKb: kv2.get("freeKb") && Number.isFinite(free) ? free : null,
+    tar: kv2.get("tar") === "1",
+    gzip: kv2.get("gzip") === "1",
+    fetch: word("fetch"),
+    sha: word("sha")
+  };
+}
+function preflight(f, runtime) {
+  const no2 = (reason) => ({ ok: false, reason });
+  let platform;
+  if (f.os === "Linux") {
+    if (f.musl) return no2("This Linux uses musl (Alpine and the like); Centralu runs on glibc 2.34 or later only");
+    const arch = f.arch === "x86_64" || f.arch === "amd64" ? "x64" : f.arch === "aarch64" || f.arch === "arm64" ? "arm64" : null;
+    if (!arch) return no2(`Centralu has no build for Linux on ${f.arch || "this processor"}`);
+    const [maj = 0, min = 0] = (f.glibc ?? "").split(".").map(Number);
+    if (!f.glibc || maj < MIN_GLIBC[0] || maj === MIN_GLIBC[0] && min < MIN_GLIBC[1]) {
+      return no2(`Centralu needs glibc ${MIN_GLIBC.join(".")} or later (Ubuntu 22.04, Debian 12, RHEL 9); this machine has ${f.glibc ? `glibc ${f.glibc}` : "none that it reports"}`);
+    }
+    platform = `linux-${arch}`;
+  } else if (f.os === "Windows") {
+    if (f.arch !== "AMD64") return no2(`Centralu has no build for Windows on ${f.arch || "this processor"}`);
+    platform = "win32-x64";
+  } else {
+    return no2(`Installing from here is for Linux and Windows; on ${f.os || "this system"}, install Centralu there (npm i -g centralu)`);
+  }
+  if (!runtime.node.archives[platform]) return no2(`This Centralu pins no Node for ${platform}`);
+  if (!f.tar) return no2(platform === "win32-x64" ? "tar.exe is missing (it comes with Windows 10 1803 and later)" : "tar is missing there; install it and try again");
+  if (!f.gzip) return no2("gzip is missing there; install it and try again");
+  if (!f.fetch) return no2("Neither curl nor wget is installed there; install one and try again");
+  if (!f.sha) return no2("No SHA-256 tool (sha256sum) is installed there; install coreutils and try again");
+  const need = NEED_MB[platform === "win32-x64" ? "win32" : "linux"];
+  if (f.freeKb !== null && f.freeKb < need * 1024) return no2(`Installing needs about ${need} MB free there; ${Math.floor(f.freeKb / 1024)} MB is`);
+  return { ok: true, platform };
+}
+var PLAIN = /^[0-9A-Za-z][0-9A-Za-z.+-]{0,63}$/;
+var SAFE_URL = /^https?:\/\/[0-9A-Za-z.:-]+(\/[0-9A-Za-z._~%/-]*)?$/;
+function nodeCommand(spec, n) {
+  if (!PLAIN.test(n.version) || !SAFE_URL.test(n.url) || !/^[0-9a-f]{64}$/.test(n.sha256)) throw new Error("Not a Node archive to install");
+  const sh = `${DATA_SH}; V="${n.version}"; n="$r/node/v$V"
+say() { echo "${STEP} $*"; }
+if [ -x "$n/bin/node" ] && "$n/bin/node" --version >/dev/null 2>&1; then say node ok; exit 0; fi
+t="$r/.partial-node-$$"; trap 'rm -rf "$t"' EXIT
+mkdir -p "$t/x" || { say fail mkdir; exit 1; }
+if command -v curl >/dev/null 2>&1; then curl -fsSL --retry 2 -o "$t/a" "${n.url}" || { say fail download node; exit 1; }
+else wget -q -O "$t/a" "${n.url}" || { say fail download node; exit 1; }; fi
+if command -v sha256sum >/dev/null 2>&1; then h=$(sha256sum "$t/a" | cut -d" " -f1); else h=$(shasum -a 256 "$t/a" | cut -d" " -f1); fi
+[ "$h" = "${n.sha256}" ] || { say fail node_hash "$h"; exit 1; }
+tar -xzf "$t/a" -C "$t/x" --strip-components 1 || { say fail unpack node; exit 1; }
+mkdir -p "$t/keep/bin" && mv "$t/x/bin/node" "$t/keep/bin/node" || { say fail unpack node; exit 1; }
+[ ! -f "$t/x/LICENSE" ] || mv "$t/x/LICENSE" "$t/keep/LICENSE"
+"$t/keep/bin/node" --version >/dev/null 2>&1 || { say fail node_runs; exit 1; }
+mkdir -p "$r/node" && rm -rf "$n" && mv "$t/keep" "$n" || { say fail place node; exit 1; }
+say node ok
+`;
+  const ps2 = `$ErrorActionPreference = 'Stop'; $ProgressPreference = 'SilentlyContinue'
+${DATA_PS}; $n = Join-Path $r 'node\\v${n.version}'
+function Say($s) { "${STEP} $s" }
+if ((Test-Path (Join-Path $n 'node.exe'))) { Say 'node ok'; return }
+$t = Join-Path $r ".partial-node-$PID"
+try {
+  New-Item -ItemType Directory -Force (Join-Path $t 'x') | Out-Null
+  $a = Join-Path $t 'a.zip'
+  $curl = Join-Path $env:SystemRoot 'System32\\curl.exe'
+  if (Test-Path $curl) { & $curl -fsSL --retry 2 -o $a '${n.url}'; if ($LASTEXITCODE -ne 0) { throw 'download node' } }
+  else { try { Invoke-WebRequest -UseBasicParsing '${n.url}' -OutFile $a } catch { throw 'download node' } }
+  $h = (Get-FileHash -Algorithm SHA256 $a).Hash.ToLower()
+  if ($h -ne '${n.sha256}') { throw "node_hash $h" }
+  & (Join-Path $env:SystemRoot 'System32\\tar.exe') -xf $a -C (Join-Path $t 'x') --strip-components 1
+  if ($LASTEXITCODE -ne 0) { throw 'unpack node' }
+  $k = Join-Path $t 'keep'; New-Item -ItemType Directory -Force $k | Out-Null
+  Move-Item (Join-Path $t 'x\\node.exe') $k
+  if (Test-Path (Join-Path $t 'x\\LICENSE')) { Move-Item (Join-Path $t 'x\\LICENSE') $k }
+  & (Join-Path $k 'node.exe') --version | Out-Null
+  if ($LASTEXITCODE -ne 0) { throw 'node_runs' }
+  New-Item -ItemType Directory -Force (Join-Path $r 'node') | Out-Null
+  if (Test-Path $n) { Remove-Item -Recurse -Force $n }
+  Move-Item $k $n
+  Say 'node ok'
+} catch {
+  $m = if ($_.Exception.Message) { $_.Exception.Message } else { "$_" }
+  Say "fail $($m -replace '\\s+', ' ')"
+} finally {
+  if (Test-Path $t) { Remove-Item -Recurse -Force $t -ErrorAction SilentlyContinue }
+}
+`;
+  return remoteScript(spec, { sh, ps: ps2 });
+}
+function installCommand(spec, script, params) {
+  if (!PLAIN.test(params.version) || !PLAIN.test(params.node)) throw new Error("Not a version to install");
+  const gz2 = gzipSync(Buffer.from(script, "utf8"), { level: 9 }).toString("base64");
+  const arg = Buffer.from(JSON.stringify(params), "utf8").toString("base64");
+  const sh = `${DATA_SH}; f="$r/.install-$$.mjs"
+mkdir -p "$r" && printf %s "${gz2}" | base64 -d | gzip -dc > "$f" || { echo "${STEP} fail script"; exit 1; }
+"$r/node/v${params.node}/bin/node" "$f" "${arg}"; c=$?; rm -f "$f"; exit $c
+`;
+  const ps2 = `${DATA_PS}; $f = Join-Path $r ".install-$PID.mjs"
+try {
+  New-Item -ItemType Directory -Force $r | Out-Null
+  $z = New-Object IO.Compression.GZipStream((New-Object IO.MemoryStream(,[Convert]::FromBase64String('${gz2}'))), [IO.Compression.CompressionMode]::Decompress)
+  $o = [IO.File]::Create($f); $z.CopyTo($o); $o.Close(); $z.Close()
+} catch { "${STEP} fail script"; return }
+& (Join-Path $r 'node\\v${params.node}\\node.exe') $f '${arg}'
+Remove-Item -Force $f -ErrorAction SilentlyContinue
+`;
+  return remoteScript(spec, { sh, ps: ps2 });
+}
+function failure2(target, code2, detail) {
+  switch (code2) {
+    case "node_hash":
+      return `The Node downloaded on ${target} does not match the SHA-256 this Centralu release pinned; nothing was installed`;
+    case "integrity":
+      return `${detail || "A package"} downloaded on ${target} does not match the integrity the npm registry signed; nothing was installed`;
+    case "download":
+      return `${target} could not download ${detail || "what it needs"}; check that it can reach nodejs.org and registry.npmjs.org`;
+    case "busy":
+      return `Another install is running on ${target}`;
+    case "no_host":
+      return `The package for ${detail} carries no host; this version cannot be installed on ${target}`;
+    case "no_launcher":
+      return `Centralu ${detail} predates installs from the app; install a newer version`;
+    case "node_runs":
+      return `The Node downloaded on ${target} does not run there`;
+    case "missing":
+      return `Centralu ${detail} is no longer installed on ${target}`;
+    case "remove":
+      return `What this computer installed on ${target} could not be removed: ${detail || "no reason given"}`;
+    default:
+      return `Installing on ${target} failed (${[code2, detail].filter(Boolean).join(": ")})`;
+  }
+}
+function readStep(run, ok, target) {
+  const line = run.stdout.split(/\r?\n/).reverse().find((l) => l.startsWith(`${STEP} `));
+  if (!line) {
+    const why = lastLine(run.stderr);
+    throw new Error(`Installing on ${target} stopped without saying why${why ? `: ${why}` : run.code ? ` (exit ${run.code})` : ""}`);
+  }
+  const rest = line.slice(STEP.length + 1).trim();
+  if (rest.startsWith("fail")) {
+    const [, code2 = "error", ...detail] = rest.split(" ");
+    throw new Error(failure2(target, code2, detail.join(" ")));
+  }
+  if (!rest.startsWith(ok)) throw new Error(`Installing on ${target} answered something unexpected: ${rest.slice(0, 120)}`);
+  return rest.slice(ok.length).trim();
+}
+async function installRemote(o) {
+  o.onStep?.("preflight");
+  const pf2 = preflight(parsePreflight((await o.exec(preflightCommand(o.spec))).stdout), o.runtime);
+  if (!pf2.ok) throw new Error(`Cannot install on ${o.target}: ${pf2.reason}`);
+  o.onStep?.("registry");
+  const packages = await Promise.all([verifiedPackage("centralu", o.version, o.registry), verifiedPackage(`@centralu/${pf2.platform}`, o.version, o.registry)]);
+  const archive = o.runtime.node.archives[pf2.platform];
+  const nodeVersion = o.runtime.node.version;
+  o.onStep?.("node");
+  const url2 = `${(o.nodeDist ?? "https://nodejs.org/dist").replace(/\/+$/, "")}/v${nodeVersion}/${archive.file}`;
+  readStep(await o.exec(nodeCommand(o.spec, { version: nodeVersion, url: url2, sha256: archive.sha256 })), "node ok", o.target);
+  o.onStep?.("centralu");
+  const params = { version: o.version, node: nodeVersion, platform: pf2.platform, hub: `${hostname3()} (Centralu ${o.version})`, packages: packages.map(({ name, tarball, integrity }) => ({ name, tarball, integrity })), ...o.activate === false ? { activate: false } : {} };
+  const done = readStep(await o.exec(installCommand(o.spec, o.script, params)), "done", o.target);
+  const r = JSON.parse(done);
+  return { current: r.current, previous: r.previous ?? null, removed: r.removed ?? [], left: r.left ?? [], ...r.installed ? { installed: r.installed } : {} };
+}
+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 (existsSync20(file2)) return readFileSync13(file2, "utf8");
+  }
+  throw new Error(`${name} is missing from this host`);
+}
+function installScript() {
+  return bundled("remote-install.mjs", "./remote-install.mjs");
+}
+function remoteRuntime() {
+  return JSON.parse(bundled("remote-runtime.json", "../../../../packaging/remote-runtime.json"));
+}
+
+// packages/agent-host/src/links/update.ts
+var CHECK_MS = 3e4;
+function parseStopLine(stdout) {
+  for (const line of stdout.split(/\r?\n/).reverse()) {
+    const t = line.trim();
+    if (!t.startsWith("{")) continue;
+    try {
+      const o = JSON.parse(t);
+      if (o.v === 1 && o.stop && typeof o.stop.ok === "boolean") {
+        return { ok: o.stop.ok, wasRunning: o.stop.wasRunning === true, message: typeof o.stop.message === "string" ? o.stop.message : null };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function stopRemoteHost(c) {
+  const r = await c.exec(stopCommand(c.spec));
+  if (r.stdout.includes(NOT_FOUND2)) return { wasRunning: false };
+  const answer = parseStopLine(r.stdout);
+  if (!answer) {
+    if (/unknown option for serve: --stop/.test(r.stderr)) {
+      throw new Error(`The Centralu running on ${c.target} is too old to be stopped from here: stop \`centralu serve\` there, then try again`);
+    }
+    const why = lastLine(r.stderr);
+    throw new Error(`Stopping Centralu on ${c.target} gave no answer${why ? `: ${why}` : r.code ? ` (exit ${r.code})` : ""}`);
+  }
+  if (!answer.ok) throw new Error(`Centralu on ${c.target} could not be stopped: ${answer.message ?? "no reason given"}`);
+  return { wasRunning: answer.wasRunning };
+}
+async function setPointers(c, run, current, previous) {
+  const out = readStep(await c.exec(installCommand(c.spec, c.script, { action: "pointers", version: run.version, node: run.node, current, previous })), "done", c.target);
+  return JSON.parse(out);
+}
+async function pruneThere(c, run) {
+  const out = JSON.parse(readStep(await c.exec(installCommand(c.spec, c.script, { action: "prune", version: run.version, node: run.node })), "done", c.target));
+  return { removed: out.removed ?? [], left: out.left ?? [] };
+}
+var TAIL_SH = `${DATA_SH}; tail -n 12 "$d/host.log" 2>/dev/null; true
+`;
+var TAIL_PS = `${DATA_PS}; Get-Content -Tail 12 (Join-Path $d 'host.log') -ErrorAction SilentlyContinue
+`;
+async function hostLogTail(c) {
+  const r = await c.exec(remoteScript(c.spec, { sh: TAIL_SH, ps: TAIL_PS }));
+  const lines = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).slice(-4);
+  const text2 = lines.join(" / ");
+  return text2.length > 600 ? `\u2026${text2.slice(-600)}` : text2;
+}
+async function startAndCheck(c, version2) {
+  c.step("start");
+  try {
+    await c.start();
+  } catch (err) {
+    return err.message;
+  }
+  c.step("check");
+  return await c.answers(version2, CHECK_MS) ? null : `it did not answer within ${CHECK_MS / 1e3} s`;
+}
+async function putBack(c, to, why, was) {
+  c.step("roll_back");
+  const tail = await hostLogTail(c).catch(() => "");
+  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 setPointers(c, to, was.current, was.previous);
+    if (was.running) await c.start();
+  } catch (err) {
+    throw new Error(`Centralu ${to.version} did not start on ${c.target} (${why}), and putting back ${back} failed too: ${err.message}.${log}`);
+  }
+  throw new Error(`Centralu ${to.version} did not start on ${c.target} (${why}); ${was.running ? `it runs ${back} again` : `${back} is back in place`}.${log}`);
+}
+async function updateRemote(c, o) {
+  const placed = await installRemote({ ...o, exec: c.exec, spec: c.spec, target: c.target, script: c.script, activate: false, onStep: c.step });
+  const next = placed.installed;
+  if (!next) throw new Error(`Installing on ${c.target} answered without saying what it placed; the Centralu there may predate updates from the app`);
+  const was = { current: placed.current ?? null, previous: placed.previous ?? null };
+  await c.hold();
+  c.step("stop");
+  const { wasRunning } = await stopRemoteHost(c);
+  c.step("switch");
+  const keep = was.current && was.current.version !== next.version ? was.current : was.previous;
+  await setPointers(c, next, next, keep);
+  const why = await startAndCheck(c, next.version);
+  if (why) return putBack(c, next, why, { ...was, running: wasRunning });
+  c.step("prune");
+  const pruned = await pruneThere(c, next).catch(() => ({ removed: [], left: [] }));
+  return { current: next, previous: keep, ...pruned };
+}
+async function rollbackRemote(c, there) {
+  await c.hold();
+  c.step("stop");
+  const { wasRunning } = await stopRemoteHost(c);
+  c.step("switch");
+  await setPointers(c, there.previous, there.previous, null);
+  const why = await startAndCheck(c, there.previous.version);
+  if (why) return putBack(c, there.previous, why, { current: there.current, previous: there.previous, running: wasRunning });
+  return { current: there.previous, previous: null, removed: [], left: [] };
+}
+var UNINSTALL_SH = `${DATA_SH}
+if [ -d "$r" ]; then rm -rf "$r" || { echo "${STEP} fail remove $r"; exit 1; }; fi
+echo "${STEP} uninstalled"
+`;
+var UNINSTALL_PS = `$ErrorActionPreference = 'Stop'
+${DATA_PS}
+try {
+  if (Test-Path $r) { Remove-Item -Recurse -Force $r }
+  "${STEP} uninstalled"
+} catch {
+  "${STEP} fail remove $($_.Exception.Message -replace '\\s+', ' ')"
+}
+`;
+function uninstallCommand(spec) {
+  return remoteScript(spec, { sh: UNINSTALL_SH, ps: UNINSTALL_PS });
+}
+async function uninstallRemote(c) {
+  await c.hold();
+  c.step("stop");
+  const { wasRunning } = await stopRemoteHost(c);
+  c.step("remove");
+  readStep(await c.exec(uninstallCommand(c.spec)), "uninstalled", c.target);
+  return { stopped: wasRunning };
+}
+
 // packages/agent-host/src/links/machine-ids.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 function isMachineId(value) {
@@ -114514,6 +115413,10 @@ function channel(version2) {
 
 // packages/agent-host/src/links/links.ts
 var isObj2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var linkError2 = (message) => Object.assign(new Error(message), { code: "internal" });
+function installOf(i) {
+  return i ? { managed: i.managed, current: i.current, previous: i.previous } : null;
+}
 function hiddenKind(s) {
   return isObj2(s) && (s.kind === "orchestrator" || s.kind === "coordinator");
 }
@@ -114547,6 +115450,19 @@ var LinkedMachine = class {
   opening = null;
   /** A refusal was already answered by asking the remote again; the next one is reported and backed off */
   refusedOnce = false;
+  /** One install, update, rollback or uninstall at a time per machine (the remote also holds `install.lock`) */
+  busy = false;
+  /** That operation and its step, for the row (`MachineInfo.operation`) */
+  operation = null;
+  /**
+   * While an update stops, switches and starts the host there, the link neither reconnects nor
+   * starts a host of its own: it would start the old version between the stop and the switch
+   */
+  held = false;
+  /** Called with the version of every hello, while an update waits for the new one */
+  helloWaiters = /* @__PURE__ */ new Set();
+  /** What the hub installed there, from the last connection line (plan §10.5, S12) */
+  installed = null;
   get id() {
     return this.record.id;
   }
@@ -114570,7 +115486,9 @@ var LinkedMachine = class {
       lastConnectedAt: this.lastConnectedAt,
       localPort: this.endpoint && this.endpoint.localPort > 0 ? this.endpoint.localPort : null,
       sameLocalPort: this.endpoint ? this.endpoint.localPort === this.endpoint.line.port : false,
-      hostStarted: this.hostStarted
+      hostStarted: this.hostStarted,
+      install: this.installed,
+      operation: this.operation
     };
   }
   // ── RoutedMachine ───────────────────────────────────────────────────────────────────────
@@ -114614,6 +115532,171 @@ var LinkedMachine = class {
     this.versions = { ...this.versions, accepted: true };
     this.reconnect();
   }
+  /**
+   * Installs the hub's version there (`machines.install`, install.ts, plan §10.2). A host running
+   * there keeps running; a link that is not connected (nothing was installed, or nothing runs) opens
+   * again at once, and finds the managed launcher first
+   */
+  install() {
+    return this.operate("install", this.deps.hub.version, async (c, installer) => {
+      const r = await installRemote({
+        exec: c.exec,
+        spec: c.spec,
+        target: c.target,
+        version: this.deps.hub.version,
+        runtime: installer.runtime(),
+        script: c.script,
+        registry: installer.registry,
+        nodeDist: installer.nodeDist,
+        onStep: c.step
+      });
+      this.deps.log?.(`[links] ${this.name}: installed Centralu ${r.current.version} on Node ${r.current.node}${r.previous ? `; ${r.previous.version} kept to roll back to` : ""}`);
+      return this.installedNow(r);
+    });
+  }
+  /** `machines.update` (update.ts, plan §10.5): install beside, stop, switch, start, check, or put back */
+  update() {
+    return this.operate("update", this.deps.hub.version, async (c, installer) => {
+      const r = await updateRemote(c, {
+        version: this.deps.hub.version,
+        runtime: installer.runtime(),
+        registry: installer.registry,
+        nodeDist: installer.nodeDist
+      });
+      this.deps.log?.(`[links] ${this.name}: updated to Centralu ${r.current.version}${r.previous ? `; ${r.previous.version} kept to roll back to` : ""}`);
+      return this.installedNow(r);
+    });
+  }
+  /** `machines.rollback`: back to `previous`, one step */
+  rollback() {
+    const current = this.installed?.current;
+    const previous = this.installed?.previous;
+    if (!current || !previous) return Promise.reject(linkError2(`There is no earlier version installed on ${this.name} to go back to`));
+    return this.operate("rollback", previous.version, async (c) => {
+      const r = await rollbackRemote(c, { current, previous });
+      this.deps.log?.(`[links] ${this.name}: rolled back to Centralu ${r.current.version}`);
+      return this.installedNow(r);
+    });
+  }
+  /** `machines.uninstall`: stops the host there and removes what the hub installed; the data stays */
+  uninstall() {
+    if (!this.installed?.current) return Promise.reject(linkError2(`Nothing this computer installed is on ${this.name}`));
+    return this.operate("uninstall", null, async (c) => {
+      const r = await uninstallRemote(c);
+      this.installed = { managed: false, current: null, previous: null };
+      this.deps.log?.(`[links] ${this.name}: removed the Centralu this computer installed; its data stays`);
+      return { machine: this.info(), stopped: r.stopped };
+    });
+  }
+  /**
+   * What would stop there if its host stopped now (`host.activity` on the remote), for the "Update"
+   * prompt. Through the link when connected; while the link is held at `versions_differ` on one
+   * protocol, through a short connection of its own. Null when the machine cannot say
+   */
+  activity() {
+    const read = (r) => {
+      const p = HostActivity.safeParse(r);
+      return p.success ? p.data : null;
+    };
+    if (this.client?.connected) return this.client.call("host.activity", {}).then(read, () => null);
+    const e = this.endpoint;
+    if (!e?.url || this.versions?.compatible === false || this.held) return Promise.resolve(null);
+    return new Promise((resolve10) => {
+      let settled = false;
+      const done = (v) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        client.close();
+        resolve10(v);
+      };
+      const client = new RemoteClient(
+        { ...this.deps.client, url: e.url, token: e.token, handshakeTimeoutMs: 5e3, callTimeoutMs: 5e3 },
+        { hello: () => void client.call("host.activity", {}).then(read, () => null).then(done), refused: () => done(null) }
+      );
+      const timer = setTimeout(() => done(null), 8e3);
+      client.connect();
+    });
+  }
+  installedNow(r) {
+    this.installed = { managed: true, current: r.current, previous: r.previous };
+    return { machine: this.info(), current: r.current, previous: r.previous, removed: r.removed, left: r.left };
+  }
+  /**
+   * Runs one install, update, rollback or uninstall: refused where this hub cannot install (no
+   * installer or shell, a development build, a command of the person's own), one at a time, with its
+   * steps in the row. Afterwards the link opens again, also after a failure
+   */
+  async operate(kind, target, fn2) {
+    const installer = this.deps.installer;
+    const tunnelExec = this.tunnel.exec?.bind(this.tunnel);
+    if (!installer || !tunnelExec) throw linkError2(`This computer cannot install on ${this.name}`);
+    if (this.deps.hub.dev && (kind === "install" || kind === "update")) {
+      throw linkError2(`A development build is not published, so it cannot be installed on ${this.name}; install the latest release there (npm i -g centralu)`);
+    }
+    if (this.record.remote.command) throw linkError2(`${this.name} runs a command of its own in place of centralu; clear it to use an installed one`);
+    if (this.busy) throw linkError2(`${this.name} is busy with ${this.operation?.kind ?? "another change"}; wait until it is done`);
+    this.busy = true;
+    const at2 = Date.now();
+    const step = (s) => {
+      this.deps.log?.(`[links] ${this.name}: ${kind}${target ? ` ${target}` : ""}: ${s}`);
+      this.operation = { kind, step: s, target, at: at2 };
+      this.deps.broadcast({ type: "machine_status", machine: this.info() });
+    };
+    try {
+      return await fn2(this.control(tunnelExec, installer.script(), step), installer);
+    } catch (err) {
+      this.deps.log?.(`[links] ${this.name}: ${kind} failed: ${err.message}`);
+      throw linkError2(err.message);
+    } finally {
+      this.busy = false;
+      const wasHeld = this.held;
+      this.held = false;
+      this.operation = null;
+      if (!this.stopped && (wasHeld || this.status !== "connected")) this.reconnect();
+      this.deps.broadcast({ type: "machine_status", machine: this.info() });
+    }
+  }
+  /** What update.ts runs things there with */
+  control(exec8, script, step) {
+    const hold = async () => {
+      this.held = true;
+      clearTimeout(this.retryTimer);
+      await this.opening?.catch(() => void 0);
+      clearTimeout(this.retryTimer);
+      this.client?.close();
+      this.client = null;
+      this.setStatus("updating", null);
+    };
+    return {
+      exec: exec8,
+      spec: this.record.remote,
+      target: this.record.sshTarget,
+      script,
+      hold,
+      step,
+      start: async () => {
+        if (!this.tunnel.startHost) throw new Error(`This computer cannot start Centralu on ${this.name}`);
+        const started = await this.tunnel.startHost();
+        this.hostStarted = { ...started, at: Date.now() };
+      },
+      answers: (version2, ms3) => new Promise((resolve10) => {
+        const waiter = (v) => {
+          if (v !== version2) return;
+          clearTimeout(timer);
+          this.helloWaiters.delete(waiter);
+          resolve10(true);
+        };
+        const timer = setTimeout(() => {
+          this.helloWaiters.delete(waiter);
+          void hold().then(() => resolve10(false));
+        }, this.deps.checkMs ?? ms3);
+        this.helloWaiters.add(waiter);
+        this.held = false;
+        this.reconnect();
+      })
+    };
+  }
   async stop() {
     this.stopped = true;
     clearTimeout(this.retryTimer);
@@ -114622,6 +115705,7 @@ var LinkedMachine = class {
     await this.tunnel.close();
   }
   open() {
+    if (this.held) return Promise.resolve();
     this.opening ??= this.doOpen().finally(() => {
       this.opening = null;
     });
@@ -114634,7 +115718,9 @@ var LinkedMachine = class {
     this.setStatus("connecting", null);
     let endpoint = await this.openTunnel();
     if (!endpoint) return;
+    this.installed = installOf(endpoint.line.install);
     if (!endpoint.line.hostRunning && this.tunnel.startHost) {
+      if (this.held) return;
       this.setStatus("starting", null);
       this.deps.log?.(`[links] ${this.name}: no Centralu host is running there; starting one (centralu serve --detach)`);
       let started;
@@ -114653,7 +115739,9 @@ var LinkedMachine = class {
       this.setStatus("starting", null);
       endpoint = await this.openTunnel();
       if (!endpoint) return;
+      this.installed = installOf(endpoint.line.install);
     }
+    if (this.held) return;
     this.endpoint = endpoint;
     if (!endpoint.line.hostRunning) {
       this.setStatus("not_running", `Centralu is installed on ${this.name}, but no \`centralu serve\` is running there`);
@@ -114727,6 +115815,7 @@ var LinkedMachine = class {
   }
   async onHello(client, h) {
     if (this.client !== client) return;
+    for (const w of [...this.helloWaiters]) w(h.build?.version ?? null);
     if (h.build) {
       const v = this.check({ version: h.build.version ?? this.versions?.remote.version ?? "unknown", protocolVersion: h.build.protocolVersion, dev: h.build.commit === "dev" });
       if (!mayConnect(v)) return;
@@ -114775,11 +115864,12 @@ var LinkedMachine = class {
     if (this.stopped) return;
     this.client?.close();
     this.client = null;
+    if (this.held) return;
     this.setStatus("unreachable", `The connection to ${this.name} ended (${reason}); reconnecting`);
     this.retryLater();
   }
   retryLater(fixedMs) {
-    if (this.stopped) return;
+    if (this.stopped || this.held) return;
     clearTimeout(this.retryTimer);
     const [first, max] = this.deps.retryMs ?? [2e3, 6e4];
     const delay = fixedMs ?? Math.min(max, first * 2 ** this.attempt++);
@@ -114846,6 +115936,21 @@ var Links = class {
     m.acceptVersions();
     return m.info();
   }
+  install(id2) {
+    return this.need(id2).install();
+  }
+  update(id2) {
+    return this.need(id2).update();
+  }
+  rollback(id2) {
+    return this.need(id2).rollback();
+  }
+  uninstall(id2) {
+    return this.need(id2).uninstall();
+  }
+  activity(id2) {
+    return this.need(id2).activity();
+  }
   need(id2) {
     const m = this.machines.get(id2);
     if (!m) throw Object.assign(new Error(`No linked machine ${id2}`), { code: "internal" });
@@ -115067,6 +116172,13 @@ var ROUTES = {
   // Stopping a remote host is `centralu serve --stop` over ssh, never a call through the link
   "host.stop": HUB,
   "machines.acceptVersions": HUB,
+  "machines.install": HUB,
+  "machines.update": HUB,
+  "machines.rollback": HUB,
+  "machines.uninstall": HUB,
+  "machines.activity": HUB,
+  // The hub's own answer; a hub asks a remote's through `machines.activity`
+  "host.activity": HUB,
   // ── Callbacks of the hub's own agents ───────────────────────────────────────────────────
   "orchestrator.tools": INTERNAL,
   "orchestrator.tool": INTERNAL,
@@ -115280,338 +116392,6 @@ function combine(method, acc, r, q2) {
   }
 }
 
-// packages/agent-host/src/links/tunnel.ts
-import { spawn as spawn5 } from "node:child_process";
-import { createConnection as createConnection2, createServer as createServer3 } from "node:net";
-function parseConnectionLine(stdout) {
-  const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
-  for (let i = lines.length - 1; i >= 0; i--) {
-    let raw;
-    try {
-      raw = JSON.parse(lines[i]);
-    } catch {
-      continue;
-    }
-    const o = raw;
-    if (o && typeof o === "object" && typeof o.v === "number") {
-      if (o.v !== 1) throw new Error(`The remote's Centralu speaks connection format ${o.v}; update Centralu on this computer`);
-      if (typeof o.port !== "number" || typeof o.token !== "string" || typeof o.protocolVersion !== "number") {
-        throw new Error("The remote answered with an incomplete connection line");
-      }
-      const install = parseInstall(o.install);
-      return {
-        v: 1,
-        port: o.port,
-        token: o.token,
-        version: typeof o.version === "string" ? o.version : "unknown",
-        protocolVersion: o.protocolVersion,
-        dataDir: typeof o.dataDir === "string" ? o.dataDir : "",
-        hostRunning: o.hostRunning === true,
-        ...install ? { install } : {}
-      };
-    }
-  }
-  throw new Error("The remote did not print a connection line; its Centralu may predate `centralu serve` (update it there: npm i -g centralu)");
-}
-function parseInstall(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const o = raw;
-  const pointer = (v) => {
-    const p = v;
-    return p && typeof p.version === "string" && typeof p.node === "string" ? { version: p.version, node: p.node } : null;
-  };
-  return { managed: o.managed === true, current: pointer(o.current), previous: pointer(o.previous), node: typeof o.node === "string" ? o.node : null };
-}
-function parseDetachLine(stdout) {
-  const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
-  for (let i = lines.length - 1; i >= 0; i--) {
-    let raw;
-    try {
-      raw = JSON.parse(lines[i]);
-    } catch {
-      continue;
-    }
-    const d2 = raw?.detach;
-    if (!d2 || typeof d2 !== "object") continue;
-    if (d2.ok === true) return { ok: true, line: parseConnectionLine(lines[i]), how: typeof d2.how === "string" ? d2.how : null };
-    return { ok: false, reason: typeof d2.reason === "string" ? d2.reason : "failed", message: typeof d2.message === "string" ? d2.message : "centralu serve --detach failed" };
-  }
-  throw new Error("The remote did not say whether it started");
-}
-var WSL_DISTRO_RE = /^[A-Za-z0-9._-]{1,64}$/;
-function powershell(script) {
-  const full = `[Console]::OutputEncoding=[Text.Encoding]::UTF8
-${script}`;
-  return `powershell -NoProfile -NonInteractive -EncodedCommand ${Buffer.from(full, "utf16le").toString("base64")}`;
-}
-function wslKeepAlive(spec) {
-  if (spec?.shell !== "wsl") return null;
-  const distro = spec.wslDistro ?? "";
-  if (!WSL_DISTRO_RE.test(distro)) throw new Error(`Not a WSL distro name: ${distro || "(none)"}`);
-  return `wsl.exe -d ${distro} --exec sleep infinity`;
-}
-var NOT_FOUND2 = "CENTRALU-NOT-FOUND";
-function connectionCommand(spec) {
-  return remoteCommand(spec, "serve --connection");
-}
-function detachCommand(spec) {
-  return remoteCommand(spec, "serve --detach");
-}
-function serveCommand(spec) {
-  return remoteCommand(spec, "serve");
-}
-function remoteCommand(spec, args) {
-  const custom2 = spec.command?.trim() || null;
-  if (spec.shell === "powershell") {
-    if (custom2) return powershell(`${custom2} ${args}`);
-    return powershell(
-      `if (Get-Command centralu -ErrorAction SilentlyContinue) { & centralu ${args} } else { $l = Join-Path $env:USERPROFILE '.centralu\\bin\\centralu.cmd'; if (Test-Path $l) { & $l ${args} } else { '${NOT_FOUND2}' } }`
-    );
-  }
-  const lookup = `if command -v centralu >/dev/null 2>&1; then exec centralu ${args}; elif [ -x "$HOME/.centralu/bin/centralu" ]; then exec "$HOME/.centralu/bin/centralu" ${args}; else echo ${NOT_FOUND2}; exit 127; fi`;
-  if (spec.shell === "posix") return custom2 ? `${custom2} ${args}` : `sh -c '${lookup}'`;
-  const distro = spec.wslDistro ?? "";
-  if (!WSL_DISTRO_RE.test(distro)) throw new Error(`Not a WSL distro name: ${distro || "(none)"}`);
-  const script = custom2 ? `${custom2} ${args}` : `PATH=$(printf %s "$PATH" | tr : '\\n' | grep -v '^/mnt/' | paste -sd: -); ${lookup}`;
-  const b64 = Buffer.from(script, "utf8").toString("base64");
-  return powershell(`wsl.exe -d '${distro}' -- bash -lc 'echo ${b64} | base64 -d | bash -l'`);
-}
-var SshTunnel = class {
-  constructor(opts) {
-    this.opts = opts;
-    if (!opts.target.trim() || opts.target.startsWith("-")) throw new Error("Not an ssh target");
-  }
-  opts;
-  child = null;
-  /** The asking ssh runs, while they run */
-  asking = /* @__PURE__ */ new Set();
-  downListeners = [];
-  closing = false;
-  /** The remote cannot start a host outside a session (WMI blocked): the forward runs it (`startHost`) */
-  linkBound = false;
-  async open() {
-    await this.stopChild();
-    this.closing = false;
-    const line = await this.connectionLine().catch((err) => {
-      this.ifClosed();
-      throw err;
-    });
-    this.ifClosed();
-    if (!line.hostRunning && !this.linkBound) {
-      return { url: "", token: line.token, line, localPort: 0 };
-    }
-    const hosting = !line.hostRunning;
-    let localPort = await portFree(line.port) ? line.port : await freePort();
-    try {
-      await this.forward(localPort, line.port, hosting);
-    } catch (err) {
-      if (localPort !== line.port) throw err;
-      this.ifClosed();
-      localPort = await freePort();
-      await this.forward(localPort, line.port, hosting);
-    }
-    if (this.closing) {
-      await this.stopChild();
-      this.ifClosed();
-    }
-    const served = hosting ? await this.untilServing() : line;
-    return { url: `ws://127.0.0.1:${localPort}`, token: served.token, line: served, localPort };
-  }
-  /**
-   * Starts the remote's host with `centralu serve --detach` (plan §10.4, owner decision 7): it then
-   * runs outside any ssh session and outlives this link. When the remote says WMI process creation
-   * is blocked there (decision 3), every `open` from then on runs `centralu serve` as the forward's
-   * own remote command instead, so the host lives as long as the link.
-   */
-  async startHost() {
-    this.ifClosed();
-    const remote = this.opts.remote ?? { shell: "posix" };
-    const r = await this.run([...this.config(), "-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", "--", this.opts.target, detachCommand(remote)]);
-    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 new Error(`Centralu is not installed on ${this.opts.target} (run \`npm i -g centralu\` there, then \`centralu serve\` once)`);
-    }
-    let answer;
-    try {
-      answer = parseDetachLine(r.stdout);
-    } catch (err) {
-      if (/unknown option for serve: --detach/.test(r.stderr)) {
-        throw new Error(`Centralu on ${this.opts.target} is too old to be started from here: run \`centralu serve\` there, or update it (npm i -g centralu)`);
-      }
-      const why = lastLine(r.stderr);
-      throw new Error(`${err.message}${why ? `: ${why}` : r.code ? ` (exit ${r.code})` : ""}`);
-    }
-    if (answer.ok) {
-      this.linkBound = false;
-      return { how: "detached", note: null };
-    }
-    if (answer.reason === "wmi_blocked") {
-      this.linkBound = true;
-      return { how: "link_bound", note: answer.message };
-    }
-    throw new Error(answer.message);
-  }
-  /** The connection line again until the link-bound host answers, or the forward that runs it ends */
-  async untilServing() {
-    const deadline = Date.now() + (this.opts.startTimeoutMs ?? 3e4);
-    for (; ; ) {
-      this.ifClosed();
-      if (!this.child) throw new Error(`The ssh session that runs Centralu on ${this.opts.target} ended before it served`);
-      const line = await this.connectionLine();
-      if (line.hostRunning) return line;
-      if (Date.now() > deadline) {
-        await this.stopChild();
-        throw new Error(`Centralu on ${this.opts.target} did not start serving in time`);
-      }
-      await new Promise((r) => setTimeout(r, 500));
-    }
-  }
-  onDown(listener) {
-    this.downListeners.push(listener);
-  }
-  async close() {
-    this.closing = true;
-    for (const c of this.asking) c.kill("SIGTERM");
-    await this.stopChild();
-  }
-  ifClosed() {
-    if (this.closing) throw new Error(`The link to ${this.opts.target} was closed`);
-  }
-  run(args) {
-    return new Promise((resolve10, reject) => {
-      const child = spawn5(this.opts.ssh ?? "ssh", args, { env: this.opts.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
-      this.asking.add(child);
-      child.once("exit", () => this.asking.delete(child));
-      let stdout = "";
-      let stderr = "";
-      child.stdout.on("data", (d2) => stdout += String(d2));
-      child.stderr.on("data", (d2) => stderr += String(d2));
-      child.once("error", reject);
-      child.once("close", (code2) => resolve10({ code: code2, stdout, stderr }));
-    });
-  }
-  config() {
-    return this.opts.configFile ? ["-F", this.opts.configFile] : [];
-  }
-  async connectionLine() {
-    const remote = this.opts.remote ?? { shell: "posix" };
-    const base2 = [...this.config(), "-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", "--", this.opts.target];
-    const r = await this.run([...base2, connectionCommand(remote)]);
-    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 new Error(`Centralu is not installed on ${this.opts.target} (run \`npm i -g centralu\` there, then \`centralu serve\` once)`);
-    }
-    try {
-      return parseConnectionLine(r.stdout);
-    } catch (err) {
-      const why = lastLine(r.stderr);
-      throw new Error(`${err.message}${why ? `: ${why}` : r.code ? ` (exit ${r.code})` : ""}`);
-    }
-  }
-  forward(localPort, remotePort, hosting = false) {
-    this.ifClosed();
-    const keepAlive = hosting ? serveCommand(this.opts.remote ?? { shell: "posix" }) : wslKeepAlive(this.opts.remote);
-    const args = [
-      ...this.config(),
-      ...keepAlive ? ["-T"] : ["-N"],
-      "-o",
-      "BatchMode=yes",
-      "-o",
-      "ExitOnForwardFailure=yes",
-      "-o",
-      "ServerAliveInterval=15",
-      "-o",
-      "ServerAliveCountMax=3",
-      "-o",
-      "GatewayPorts=no",
-      "-L",
-      `127.0.0.1:${localPort}:127.0.0.1:${remotePort}`,
-      "--",
-      this.opts.target,
-      ...keepAlive ? [keepAlive] : []
-    ];
-    const child = spawn5(this.opts.ssh ?? "ssh", args, { env: this.opts.env ?? process.env, stdio: ["ignore", "ignore", "pipe"] });
-    this.child = child;
-    let stderr = "";
-    child.stderr.on("data", (d2) => stderr += String(d2));
-    return new Promise((resolve10, reject) => {
-      let settled = false;
-      const deadline = Date.now() + (this.opts.forwardTimeoutMs ?? 2e4);
-      const fail4 = (message) => {
-        if (settled) return;
-        settled = true;
-        reject(new Error(message));
-      };
-      child.once("error", (e) => fail4(`Could not start ssh: ${e.message}`));
-      child.once("exit", (code2, signal) => {
-        if (this.child === child) this.child = null;
-        if (!settled) return fail4(`The ssh forward to ${this.opts.target} ended (${signal ?? code2}): ${lastLine(stderr) || "no reason given"}`);
-        if (!this.closing) for (const l of this.downListeners) l(`ssh exited (${signal ?? code2})${stderr ? `: ${lastLine(stderr)}` : ""}`);
-      });
-      const poll = async () => {
-        while (!settled) {
-          if (await accepts(localPort)) {
-            settled = true;
-            this.opts.log?.(`[links] forward up: 127.0.0.1:${localPort} -> ${this.opts.target}:127.0.0.1:${remotePort}`);
-            return resolve10();
-          }
-          if (Date.now() > deadline) {
-            child.kill("SIGTERM");
-            return fail4(`The ssh forward to ${this.opts.target} did not come up in time`);
-          }
-          await new Promise((r) => setTimeout(r, 100));
-        }
-      };
-      void poll();
-    });
-  }
-  async stopChild() {
-    const child = this.child;
-    this.child = null;
-    if (!child || child.exitCode !== null || child.signalCode !== null) return;
-    await new Promise((resolve10) => {
-      child.once("exit", () => resolve10());
-      child.kill("SIGTERM");
-      setTimeout(() => {
-        child.kill("SIGKILL");
-        resolve10();
-      }, 2e3).unref();
-    });
-  }
-};
-function lastLine(s) {
-  const lines = s.replace(/#< CLIXML[\s\S]*$/, "").split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("**") && !/^Node\.js v\d/.test(l) && !/^at /.test(l));
-  return [...lines].reverse().find((l) => /error|denied|refused|timed out|not found|cannot|could not/i.test(l)) ?? lines.at(-1) ?? "";
-}
-function accepts(port2) {
-  return new Promise((resolve10) => {
-    const s = createConnection2({ host: "127.0.0.1", port: port2 });
-    s.once("connect", () => {
-      s.destroy();
-      resolve10(true);
-    });
-    s.once("error", () => resolve10(false));
-  });
-}
-function portFree(port2) {
-  return new Promise((resolve10) => {
-    const probe = createServer3();
-    probe.once("error", () => resolve10(false));
-    probe.listen(port2, "127.0.0.1", () => probe.close(() => resolve10(true)));
-  });
-}
-function freePort() {
-  return new Promise((resolve10, reject) => {
-    const probe = createServer3();
-    probe.once("error", reject);
-    probe.listen(0, "127.0.0.1", () => {
-      const { port: port2 } = probe.address();
-      probe.close(() => resolve10(port2));
-    });
-  });
-}
-
 // packages/agent-host/src/links/stored.ts
 function storeRegistry(store2) {
   return {
@@ -115639,7 +116419,7 @@ function storeMirror(store2) {
 }
 
 // packages/agent-host/src/main.ts
-var BUILD = true ? "b974cd2" : "dev";
+var BUILD = true ? "1a563a8" : "dev";
 var underKeeper = process.env.CC_KEEPER === "1";
 var keeperSource = process.env.CC_HOST_SOURCE;
 var frontDoor = process.env.CC_FRONT_DOOR;
@@ -115879,6 +116659,7 @@ var links = new Links({
   mirror: storeMirror(store),
   registry: storeRegistry(store),
   tunnelFor: (record3) => new SshTunnel({ target: record3.sshTarget, remote: record3.remote, log: (line) => console.error(line) }),
+  installer: { runtime: remoteRuntime, script: installScript },
   log: (line) => console.error(line)
 });
 mgr.useLinkedSessions((id2) => links.knowsSession(id2));
@@ -115894,7 +116675,8 @@ var router = new Router({
     inlineViews,
     heldPids: held2?.heldPids,
     machines: links,
-    stopHost: startedByServe && !underKeeper ? () => stopFromRequest() : void 0
+    stopHost: startedByServe && !underKeeper ? () => stopFromRequest() : void 0,
+    activity: () => activityCounts(activity())
   }),
   machines: () => links.all()
 });