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

package/Centralu/resources/host/bundle-info.json

@@ -1,7 +1,7 @@
 {
-  "commit": "1a563a8",
+  "commit": "34635b7",
   "protocolVersion": 1,
-  "builtAt": "2026-10-09T05:22:33.336Z",
+  "builtAt": "2026-10-11T13:12:10.756Z",
   "runtime": "system-node",
   "platform": "win32",
   "arch": "x64"

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.14";
+var APP_VERSION = "0.1.0-beta.15";
 var APP_SLUG = "centralu";
 var CLIENT_INFO = { name: APP_SLUG, title: APP_NAME, version: APP_VERSION };
 var DATA_DIR = ".centralu";
@@ -42926,7 +42926,10 @@ function isNewerVersion(a, b2) {
   }
   return false;
 }
-function split(v) {
+function split(raw) {
+  let v = raw.trim().replace(/^v/i, "");
+  const plus = v.indexOf("+");
+  if (plus !== -1) v = v.slice(0, plus);
   const dash = v.indexOf("-");
   const core = (dash === -1 ? v : v.slice(0, dash)).split(".").map(Number);
   const pre2 = dash === -1 ? null : v.slice(dash + 1);
@@ -58153,6 +58156,11 @@ var MachineOperation = external_exports.object({
   target: external_exports.string().nullable().default(null),
   at: external_exports.number()
 });
+var MachineAutostart = external_exports.object({
+  on: external_exports.boolean().catch(false),
+  how: external_exports.enum(["systemd", "task"]).nullable().catch(null),
+  linger: external_exports.boolean().nullable().catch(null).default(null)
+});
 var MachineInfo = external_exports.object({
   id: MachineId,
   /** What the person calls it; shown as the group header in the sidebar */
@@ -58197,7 +58205,13 @@ var MachineInfo = external_exports.object({
    * 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)
+  operation: MachineOperation.nullable().catch(null).default(null),
+  /**
+   * Whether the machine starts its host at boot, from its connection line and the last
+   * `machines.autostart` (`MachineAutostart`). Null when the machine has not answered, or predates it.
+   * Additive
+   */
+  autostart: MachineAutostart.nullable().catch(null).default(null)
 });
 var MachineInstallResult = external_exports.object({
   machine: MachineInfo,
@@ -58207,6 +58221,7 @@ var MachineInstallResult = external_exports.object({
   left: external_exports.array(external_exports.string()).default([])
 });
 var MachineUninstallResult = external_exports.object({ machine: MachineInfo, stopped: external_exports.boolean() });
+var MachineAutostartResult = external_exports.object({ machine: MachineInfo, autostart: MachineAutostart });
 var HostActivity = external_exports.object({
   working: external_exports.number().int().default(0),
   approvals: external_exports.number().int().default(0),
@@ -60820,6 +60835,14 @@ var RpcMethods = {
    * data and an npm install of its own. The machine stays linked
    */
   "machines.uninstall": { params: external_exports.object({ machineId: MachineId }), result: MachineUninstallResult },
+  /**
+   * Starts a linked machine's host at boot, or stops doing that, or (without `on`) reads whether it
+   * does (docs/plans/remote-hub.md §10.4, owner decision 4: per machine, off by default). The
+   * Centralu there writes its own entry (`centralu serve --autostart`): a systemd user unit with
+   * lingering on Linux, a scheduled task at sign-in on Windows and for WSL. A host running there is
+   * neither started nor stopped. Refused by a machine that predates it or offers none (macOS)
+   */
+  "machines.autostart": { params: external_exports.object({ machineId: MachineId, on: external_exports.boolean().optional() }), result: MachineAutostartResult },
   /**
    * 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)
@@ -62090,12 +62113,7 @@ var HostServer = class _HostServer {
         this.listenError = null;
         if (err.code === "EADDRINUSE") {
           reject(
-            new Error(
-              `Port ${this.opts.port} is already in use.
-  \xB7 If a host is already running, just use it (start only the UI)
-  \xB7 To clean up a leftover process: lsof -ti:${this.opts.port} | xargs kill
-  \xB7 To use another port: pnpm host --port ${this.opts.port + 1}`
-            )
+            new Error(portInUseMessage(this.opts.port, this.opts.servedBy))
           );
           return;
         }
@@ -62330,6 +62348,17 @@ function errorCode(raw) {
   const known = ProtocolErrorCode.safeParse(raw);
   return known.success ? known.data : "internal";
 }
+function portInUseMessage(port2, servedBy) {
+  if (servedBy === "serve") {
+    return `Port ${port2} is already in use.
+  \xB7 Another program listens on 127.0.0.1:${port2}; on Windows this is often WSL (wslrelay.exe) relaying a Centralu inside a distro
+  \xB7 To use another port: centralu serve --port <n> (it is kept for the next start)`;
+  }
+  return `Port ${port2} is already in use.
+  \xB7 If a host is already running, just use it (start only the UI)
+  \xB7 To clean up a leftover process: lsof -ti:${port2} | xargs kill
+  \xB7 To use another port: pnpm host --port ${port2 + 1}`;
+}
 
 // packages/agent-host/src/view-handover.ts
 var VIEW_HANDOVER_KEY = "views.handover";
@@ -98168,19 +98197,21 @@ ${summary}
 ` : "";
   const verbatimMark = "\u2500\u2500 verbatim from here \u2500\u2500\n\n";
   const fixed = bytes(instructions + touchedLine + summarySection + verbatimMark) + 200;
-  const size = () => rendered.reduce((n, e) => n + bytes(e.text) + 2, fixed);
+  const sizes = rendered.map((e) => bytes(e.text) + 2);
+  let size = sizes.reduce((n, s) => n + s, fixed);
   let dropped = 0;
-  while (size() > cap && rendered.length > 1) {
-    rendered.shift();
+  while (size > cap && rendered.length - dropped > 1) {
+    size -= sizes[dropped];
     dropped++;
   }
-  const from = rendered.length ? rendered[0].seq : lastSeq;
+  const kept = rendered.slice(dropped);
+  const from = kept.length ? kept[0].seq : lastSeq;
   const covers = `covers seq ${num(from)}\u2013${num(lastSeq)} of ${num(lastSeq)} \xB7 ${(cap / 1e6).toFixed(1)} MB cap` + (dropped > 0 || folded ? " \xB7 earlier material stays in the app's records" : "");
   const header = `# Handoff \xB7 ${opts.name} \xB7 ${opts.tool}${opts.toTool ? ` \u2192 ${opts.toTool}` : ""}
 ${covers}
 ${touchedLine}
 `;
-  return header + instructions + summarySection + verbatimMark + rendered.map((e) => e.text).join("\n\n") + "\n";
+  return header + instructions + summarySection + verbatimMark + kept.map((e) => e.text).join("\n\n") + "\n";
 }
 
 // packages/agent-host/src/sessions/orchestrator-proposals.ts
@@ -104218,6 +104249,7 @@ var SessionManager = class _SessionManager {
     if (m.projectId) project2 = this.store.listProjects().find((p) => p.id === m.projectId);
     this.running.delete(sessionId);
     this.restartAfterTurn.delete(sessionId);
+    this.prCheckedAt.delete(sessionId);
     this.meta.delete(sessionId);
     await this.store.trashSession(sessionId, {
       projectId: m.projectId,
@@ -104424,9 +104456,11 @@ var SessionManager = class _SessionManager {
    * location is no longer ours — it is never looked at.
    */
   async sweepOrphanHandoffNotes(projectId) {
-    const claimed = this.store.handoffPredecessors();
-    const trashed = this.store.trashedIds();
-    await sweepHandoffNotes((owner) => this.meta.has(owner) || claimed.has(owner) || trashed.has(owner), projectId);
+    await sweepHandoffNotes(
+      (owner) => this.meta.has(owner) || // A session in the trash still owns its note (#204) — restoring it must find it; only purging lets it go
+      this.store.trashedIds().has(owner) || this.store.handoffPredecessors().has(owner),
+      projectId
+    );
   }
   /**
    * Changes model or permissions (FR-7). If the adapter supports it, it applies starting next turn;
@@ -106916,7 +106950,7 @@ ${String(stderr).slice(0, 2e3)}`
       let merged = await gitBranchMerged(cwd, m.worktree.branch, m.worktree.base, trunk).catch(() => false);
       if (!merged && this.ghAvailable) {
         const now = Date.now();
-        if (now - (this.prCheckedAt.get(m.id) ?? 0) >= this.prPollMs) {
+        if (this.meta.get(m.id) === m && now - (this.prCheckedAt.get(m.id) ?? 0) >= this.prPollMs) {
           this.prCheckedAt.set(m.id, now);
           const pr = await this.prLookup(cwd, m.worktree.branch).catch(() => null);
           if (pr === "unavailable") {
@@ -106933,6 +106967,7 @@ ${String(stderr).slice(0, 2e3)}`
         }
       }
       if (!merged || this.meta.get(m.id) !== m) continue;
+      this.prCheckedAt.delete(m.id);
       m.worktreeMerged = true;
       this.emit({ type: "worktree_merged", sessionId: m.id });
       console.error(`[worktree] branch merged into trunk: ${m.worktree.branch} (${m.id.slice(0, 8)})`);
@@ -108880,7 +108915,7 @@ var ClaudeSession = class {
          * 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) => {
+        canUseTool: async (toolName, toolInput, options) => {
           if (isOrchestratorTool(toolName) && self2.orchestratorServer) {
             return { behavior: "allow", updatedInput: toolInput };
           }
@@ -108905,6 +108940,7 @@ var ClaudeSession = class {
             self2.emit({ type: "question_request", sessionId: self2.sessionId, requestId: requestId2, questions });
             return new Promise((resolve10) => {
               self2.questions.set(requestId2, { resolve: resolve10, input: toolInput });
+              self2.releaseOnCancel(requestId2, options?.signal);
             });
           }
           const detail = approvalDetail(toolName, toolInput, self2.opts.cwd);
@@ -108914,6 +108950,7 @@ var ClaudeSession = class {
           self2.emit({ type: "approval_request", sessionId: self2.sessionId, requestId, detail });
           return new Promise((resolve10) => {
             self2.pending.set(requestId, { resolve: resolve10, input: toolInput });
+            self2.releaseOnCancel(requestId, options?.signal);
           });
         }
       }
@@ -109377,6 +109414,32 @@ var ClaudeSession = class {
   releaseAgents(why) {
     for (const e of this.stream.release(why)) this.emit(e);
   }
+  /**
+   * Closes a card when the CLI withdraws its question. The SDK aborts the callback's `signal` when the CLI sends
+   * `control_cancel_request` for that permission request (the tool was aborted, or the turn ended without our Stop)
+   * and when the query closes. Nothing else tells us: without this the card stayed open forever, and answering it
+   * resolved a promise nobody was waiting on. A card already answered or released is no longer in its map, so this
+   * closes nothing twice.
+   */
+  releaseOnCancel(requestId, signal) {
+    if (!signal) return;
+    const release = () => {
+      const approval = this.pending.get(requestId);
+      if (approval) {
+        this.pending.delete(requestId);
+        approval.resolve({ behavior: "deny", message: "Cancelled by Claude Code" });
+        this.emit({ type: "approval_resolved", sessionId: this.sessionId, requestId, decision: "deny" });
+      }
+      const question = this.questions.get(requestId);
+      if (question) {
+        this.questions.delete(requestId);
+        question.resolve({ behavior: "deny", message: "Cancelled by Claude Code" });
+        this.emit({ type: "question_resolved", sessionId: this.sessionId, requestId });
+      }
+    };
+    if (signal.aborted) release();
+    else signal.addEventListener("abort", release, { once: true });
+  }
   /** Releases a choice that was still waiting on an answer — **never released silently**, for the same reason as approval. */
   releaseQuestions(why) {
     for (const [id2, open5] of this.questions) {
@@ -109684,10 +109747,19 @@ var CodexClient = class {
     const id2 = `${this.idPrefix}${this.nextId++}`;
     this.write({ id: id2, method, params });
     return new Promise((resolve10, reject) => {
-      this.pending.set(id2, { resolve: resolve10, reject });
-      setTimeout(() => {
+      const timer = setTimeout(() => {
         if (this.pending.delete(id2)) reject(new Error(`No response for ${method}`));
       }, timeoutMs);
+      this.pending.set(id2, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve10(v);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        }
+      });
     });
   }
   notify(method, params) {
@@ -109706,7 +109778,7 @@ var CodexClient = class {
     this.closed = true;
     this.proc.stdin.end();
     const exited = await new Promise((resolve10) => {
-      if (this.proc.exitCode !== null || this.finished) return resolve10(true);
+      if (this.proc.exitCode !== null || this.proc.signalCode != null || this.finished) return resolve10(true);
       const t = setTimeout(() => resolve10(false), 2e3);
       this.proc.once("exit", () => {
         clearTimeout(t);
@@ -110366,6 +110438,8 @@ var CODEX_KNOWN_NOTIFICATIONS = /* @__PURE__ */ new Set([
   "item/reasoning/summaryPartAdded",
   "thread/compacted",
   "account/rateLimits/updated",
+  // read in index.ts: closes the approval card of a request Codex ended without our answer
+  "serverRequest/resolved",
   // mapped by #290 for a child thread (CodexChildTracker); the parent's own status is still not read
   "thread/status/changed",
   // mapped by #304: notices, model switches and MCP servers that failed to start (thread/settings/updated in index.ts)
@@ -110383,7 +110457,6 @@ var CODEX_KNOWN_NOTIFICATIONS = /* @__PURE__ */ new Set([
   "rawResponseItem/completed",
   "rawResponse/completed",
   // correctly ignored
-  "serverRequest/resolved",
   "thread/started",
   "thread/archived",
   "thread/unarchived",
@@ -111027,7 +111100,18 @@ var CodexSession = class {
    * if stop is pressed very quickly, the response can arrive before the notification.
    */
   turnId = null;
-  /** Our requestId to the Codex server's request id */
+  /**
+   * Turns already reported ended (`turn/completed`/`turn/failed`), the latest few. The `turn/start` response can
+   * arrive after its own turn's `turn/completed`; taking the id from that late response would bring a finished
+   * turn back as the target of Stop, and the next Stop would send `turn/interrupt` for a dead turn and say
+   * "Could not stop". Bounded: only a response still in flight can name one of these.
+   */
+  endedTurns = [];
+  /**
+   * Our requestId to the Codex server's request, with the thread and turn it was asked in. Codex ends a request
+   * itself when its turn ends or is interrupted (and says so with `serverRequest/resolved`); the card has to close
+   * with it, or an answer goes to a request id nobody is waiting on.
+   */
   approvals = /* @__PURE__ */ new Map();
   /**
    * Cards raised for app tool approval (M4 A-5) — the answer has a different shape (elicitation's
@@ -111188,7 +111272,7 @@ var CodexSession = class {
       }
       this.threadId = threadIdOf(res) ?? this.opts.resumeExternalId;
       this.threadSettings = threadSettingsOf(res);
-      if (adopted) this.turnId ??= runningTurnOf(res) ?? await this.latestRunningTurn(res);
+      if (adopted) this.takeStartedTurn(runningTurnOf(res) ?? await this.latestRunningTurn(res));
       void this.client.request("thread/goal/get", { threadId: this.threadId }).then((r) => {
         const g5 = r.goal ? goalFromCodex(r.goal) : null;
         if (g5) this.emit({ type: "goal", sessionId: this.sessionId, goal: g5 });
@@ -111310,6 +111394,7 @@ var CodexSession = class {
   }
   onNotification(n) {
     this.noteFileChange(n);
+    this.noteRequestEnded(n);
     this.unmapped.note(n.method);
     const from = n.params?.threadId;
     if (typeof from === "string" && this.threadId !== null && from !== this.threadId) {
@@ -111319,7 +111404,11 @@ var CodexSession = class {
       return;
     }
     if (n.method === "turn/started") this.turnId = turnIdOf(n.params);
-    if (n.method === "turn/completed" || n.method === "turn/failed") this.turnId = null;
+    if (n.method === "turn/completed" || n.method === "turn/failed") {
+      this.turnId = null;
+      const ended = turnIdOf(n.params);
+      if (ended) this.endedTurns = [...this.endedTurns.slice(-(ENDED_TURNS_KEPT - 1)), ended];
+    }
     if (this.retrying && n.method.startsWith("item/")) {
       this.retrying = false;
       this.emit({ type: "activity", sessionId: this.sessionId, activity: this.activityBefore });
@@ -111421,6 +111510,34 @@ var CodexSession = class {
       for (const early of held3) this.onChildNotification(thread, early);
     }
   }
+  /**
+   * Closes the cards of server requests Codex ended without our answer. `serverRequest/resolved` names one request
+   * (generated `ServerRequestResolvedNotification`, codex-cli 0.160.0: `{ threadId, requestId }`); a turn that ends
+   * takes every request asked in it, whether or not that notification comes. A request we answered is already out of
+   * `approvals`, so its own `serverRequest/resolved` finds nothing and closes nothing twice.
+   */
+  noteRequestEnded(n) {
+    const p = n.params ?? {};
+    if (n.method === "serverRequest/resolved") {
+      if (typeof p.requestId !== "string" && typeof p.requestId !== "number") return;
+      const serverId = String(p.requestId);
+      this.closeApprovals((a) => String(a.serverId) === serverId);
+      return;
+    }
+    if (n.method !== "turn/completed" && n.method !== "turn/failed") return;
+    const turn = turnIdOf(n.params);
+    if (typeof p.threadId !== "string" || !turn) return;
+    this.closeApprovals((a) => a.threadId === p.threadId && a.turnId === turn);
+  }
+  /** Closes the matching cards as denied, without answering Codex: the request is already gone on its side */
+  closeApprovals(match) {
+    for (const [requestId, a] of this.approvals) {
+      if (!match(a)) continue;
+      this.approvals.delete(requestId);
+      this.elicitations.delete(requestId);
+      this.emit({ type: "approval_resolved", sessionId: this.sessionId, requestId, decision: "deny" });
+    }
+  }
   /** Keeps a file-change item's changes until it completes — see `fileChanges` */
   noteFileChange(n) {
     const p = n.params ?? {};
@@ -111460,7 +111577,7 @@ var CodexSession = class {
       const p = typeof r.params === "object" && r.params !== null ? r.params : {};
       if (typeof p.serverName === "string" && this.appServers.has(p.serverName) && approvalKindOf(p._meta) === "mcp_tool_call") {
         const requestId2 = `codex-req-${++this.reqCounter}`;
-        this.approvals.set(requestId2, r.id);
+        this.approvals.set(requestId2, requestOrigin(r));
         this.elicitations.add(requestId2);
         this.emit({ type: "approval_request", sessionId: this.sessionId, requestId: requestId2, detail: appApprovalDetail(p.serverName, p.message, p._meta) });
         return;
@@ -111488,7 +111605,7 @@ var CodexSession = class {
       return;
     }
     const requestId = `codex-req-${++this.reqCounter}`;
-    this.approvals.set(requestId, r.id);
+    this.approvals.set(requestId, requestOrigin(r));
     this.emit({ type: "approval_request", sessionId: this.sessionId, requestId, detail });
   }
   applyRules(matchers) {
@@ -111563,9 +111680,7 @@ var CodexSession = class {
          */
         ...this.opts.effort ? { effort: this.opts.effort } : {},
         ...this.outputSchemaParam()
-      }).then((res) => {
-        this.turnId ??= turnIdOf(res);
-      });
+      }).then((res) => this.takeStartedTurn(turnIdOf(res)));
     }).catch((e) => {
       if (this.startFailed) return;
       this.emit({
@@ -111585,9 +111700,7 @@ var CodexSession = class {
       input,
       ...this.opts.effort ? { effort: this.opts.effort } : {},
       ...this.outputSchemaParam()
-    }).then((res) => {
-      this.turnId ??= turnIdOf(res);
-    }).catch((e) => {
+    }).then((res) => this.takeStartedTurn(turnIdOf(res))).catch((e) => {
       this.emit({
         type: "error",
         sessionId: this.sessionId,
@@ -111595,6 +111708,14 @@ var CodexSession = class {
       });
     });
   }
+  /**
+   * Takes a running turn's id from a response, unless the notifications already named one or already ended it. The
+   * response and the notifications race: `turn/started` can come after the response (Stop pressed very quickly), and
+   * `turn/completed` can come before it (a short turn), so a late response must not bring an ended turn back.
+   */
+  takeStartedTurn(id2) {
+    if (id2 && !this.endedTurns.includes(id2)) this.turnId ??= id2;
+  }
   /**
    * A turn belonging to an agent that an app gave a schema and asked for (M4 D-1). Codex receives
    * the schema **per turn** — the installed 0.153.4's generated type is
@@ -111608,9 +111729,10 @@ var CodexSession = class {
     return this.opts.outputSchema ? { outputSchema: this.opts.outputSchema } : {};
   }
   respondApproval(requestId, decision, _scope, matcher) {
-    const serverId = this.approvals.get(requestId);
-    if (serverId === void 0) return false;
+    const open5 = this.approvals.get(requestId);
+    if (open5 === void 0) return false;
     this.approvals.delete(requestId);
+    const serverId = open5.serverId;
     if (this.elicitations.delete(requestId)) {
       this.client.respond(serverId, {
         action: decision === "deny" ? "decline" : "accept",
@@ -111659,6 +111781,10 @@ var CodexSession = class {
       this.emit({ type: "state_change", sessionId: this.sessionId, state: "waiting_input", reason: "interrupted" });
       return;
     }
+    for (const [requestId, a] of this.approvals) {
+      if (a.threadId !== null && a.threadId !== this.threadId) continue;
+      this.respondApproval(requestId, "deny");
+    }
     if (!this.threadId || !this.turnId) return;
     void this.client.request("turn/interrupt", { threadId: this.threadId, turnId: this.turnId }).catch((err) => {
       this.emit({
@@ -111801,6 +111927,15 @@ function runningTurnOf(res) {
   }
   return null;
 }
+var ENDED_TURNS_KEPT = 8;
+function requestOrigin(r) {
+  const p = typeof r.params === "object" && r.params !== null ? r.params : {};
+  return {
+    serverId: r.id,
+    threadId: typeof p.threadId === "string" ? p.threadId : null,
+    turnId: typeof p.turnId === "string" ? p.turnId : null
+  };
+}
 function turnIdOf(payload) {
   const turn = payload?.turn;
   return typeof turn?.id === "string" ? turn.id : null;
@@ -112916,6 +113051,10 @@ function createRpcHandler(mgr2, adapters2, { terminals: terminals2, updates: upd
     "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.autostart": async (p) => {
+      const { machineId, on: on2 } = RpcMethods["machines.autostart"].params.parse(p);
+      return requireMachines().autostart(machineId, on2);
+    },
     "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" });
@@ -114210,8 +114349,16 @@ 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) {
+var NotPublished = class extends Error {
+  constructor(id2) {
+    super(`${id2} is not on the npm registry`);
+    this.id = id2;
+  }
+  id;
+};
+async function getJson(url2, f, id2) {
   const res = await f(url2, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(3e4) });
+  if (res.status === 404 && id2) throw new NotPublished(id2);
   if (!res.ok) throw new Error(`The npm registry answered ${res.status} for ${url2}`);
   return res.json();
 }
@@ -114220,7 +114367,7 @@ async function verifiedPackage(name, version2, opts = {}) {
   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 [meta3, keys] = await Promise.all([getJson(`${registry2}/${name}/${version2}`, f, `${name}@${version2}`), 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;
@@ -114271,6 +114418,7 @@ function parseConnectionLine(stdout) {
         throw new Error("The remote answered with an incomplete connection line");
       }
       const install = parseInstall(o.install);
+      const autostart = parseAutostart(o.autostart);
       return {
         v: 1,
         port: o.port,
@@ -114279,7 +114427,8 @@ function parseConnectionLine(stdout) {
         protocolVersion: o.protocolVersion,
         dataDir: typeof o.dataDir === "string" ? o.dataDir : "",
         hostRunning: o.hostRunning === true,
-        ...install ? { install } : {}
+        ...install ? { install } : {},
+        ...autostart ? { autostart } : {}
       };
     }
   }
@@ -114294,6 +114443,13 @@ function parseInstall(raw) {
   };
   return { managed: o.managed === true, current: pointer(o.current), previous: pointer(o.previous), node: typeof o.node === "string" ? o.node : null };
 }
+function parseAutostart(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o.on !== "boolean") return null;
+  const how = o.how === "systemd" || o.how === "task" ? o.how : null;
+  return { on: o.on && how !== null, how, linger: typeof o.linger === "boolean" ? o.linger : null };
+}
 function parseDetachLine(stdout) {
   const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
   for (let i = lines.length - 1; i >= 0; i--) {
@@ -114316,6 +114472,15 @@ function powershell(script) {
 ${script}`;
   return `powershell -NoProfile -NonInteractive -EncodedCommand ${Buffer.from(full, "utf16le").toString("base64")}`;
 }
+var WINDOWS_INLINE_MAX = 7900;
+var PS_FROM_STDIN = "$s=[Console]::In.ReadToEnd(); $c=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String(($s -replace '[^A-Za-z0-9+/=]',''))); & ([ScriptBlock]::Create($c))";
+function powershellScript(script) {
+  const inline = powershell(script);
+  if (inline.length <= WINDOWS_INLINE_MAX) return inline;
+  const full = `[Console]::OutputEncoding=[Text.Encoding]::UTF8
+${script}`;
+  return { command: powershell(PS_FROM_STDIN), stdin: Buffer.from(full, "utf8").toString("base64") };
+}
 function wslKeepAlive(spec) {
   if (spec?.shell !== "wsl") return null;
   const distro = spec.wslDistro ?? "";
@@ -114337,6 +114502,9 @@ function stopCommand(spec) {
 function serveCommand(spec) {
   return remoteCommand(spec, "serve");
 }
+function autostartCommand(spec, action) {
+  return remoteCommand(spec, `serve --autostart ${action}`);
+}
 function remoteCommand(spec, args) {
   const custom2 = spec.command?.trim() || null;
   if (spec.shell === "powershell") {
@@ -114354,12 +114522,14 @@ function remoteCommand(spec, args) {
   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);
+  if (spec.shell === "powershell") return powershellScript(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'`);
+  const inline = powershell(`wsl.exe -d '${distro}' -- bash -lc 'echo ${b64} | base64 -d | bash -l'`);
+  if (inline.length <= WINDOWS_INLINE_MAX) return inline;
+  return { command: powershell(`$s=[Console]::In.ReadToEnd(); $s | wsl.exe -d '${distro}' -- bash -lc 'base64 -di | bash -l'`), stdin: b64 };
 }
 var SshTunnel = class {
   constructor(opts) {
@@ -114372,11 +114542,18 @@ var SshTunnel = class {
   asking = /* @__PURE__ */ new Set();
   downListeners = [];
   closing = false;
+  /**
+   * Forwards this tunnel ended on purpose (a reopen, a forward that did not come up in time): their
+   * exit is not the link going down. Reported as down, a reopen of a live link made the link retry,
+   * and that retry's reopen ended the new forward again, every few seconds without end
+   */
+  ended = /* @__PURE__ */ new WeakSet();
   /** 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;
+    await this.stopChild();
+    this.ifClosed();
     const line = await this.connectionLine().catch((err) => {
       this.ifClosed();
       throw err;
@@ -114402,6 +114579,16 @@ var SshTunnel = class {
     const served = hosting ? await this.untilServing() : line;
     return { url: `ws://127.0.0.1:${localPort}`, token: served.token, line: served, localPort };
   }
+  /**
+   * Where Centralu runs, for a sentence: "on <target>", or "in WSL (<distro>) on <target>" (#482).
+   * A Windows laptop can be linked twice, as Windows and as a distro, and both rows used to say
+   * "on <target>" alike.
+   */
+  get where() {
+    const remote = this.opts.remote;
+    if (remote?.shell !== "wsl") return `on ${this.opts.target}`;
+    return `in WSL (${remote.wslDistro || "its default distro"}) on ${this.opts.target}`;
+  }
   /**
    * 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
@@ -114415,7 +114602,7 @@ var SshTunnel = class {
     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)`);
+      throw new Error(`Centralu is not installed ${this.where} (run \`npm i -g centralu\` there, then \`centralu serve\` once)`);
     }
     let answer;
     try {
@@ -114444,7 +114631,8 @@ var SshTunnel = class {
    */
   async exec(command) {
     this.ifClosed();
-    const r = await this.run([...this.config(), "-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", "--", this.opts.target, command]);
+    const [line, stdin] = typeof command === "string" ? [command, void 0] : [command.command, command.stdin];
+    const r = await this.run([...this.config(), "-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=15", "--", this.opts.target, line], stdin);
     if (r.code === 255) throw new Error(`ssh could not reach ${this.opts.target}: ${lastLine(r.stderr) || "no answer"}`);
     return r;
   }
@@ -114474,16 +114662,24 @@ var SshTunnel = class {
   ifClosed() {
     if (this.closing) throw new Error(`The link to ${this.opts.target} was closed`);
   }
-  run(args) {
+  run(args, stdin) {
     return new Promise((resolve10, reject) => {
-      const child = spawn5(this.opts.ssh ?? "ssh", args, { env: this.opts.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn5(this.opts.ssh ?? "ssh", args, { env: this.opts.env ?? process.env, stdio: [stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"] });
+      if (stdin !== void 0) {
+        child.stdin.on("error", () => {
+        });
+        child.stdin.end(stdin);
+      }
       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("error", (e) => {
+        this.asking.delete(child);
+        reject(e);
+      });
       child.once("close", (code2) => resolve10({ code: code2, stdout, stderr }));
     });
   }
@@ -114496,7 +114692,7 @@ var SshTunnel = class {
     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)`);
+      throw new Error(`Centralu is not installed ${this.where} (run \`npm i -g centralu\` there, then \`centralu serve\` once)`);
     }
     try {
       return parseConnectionLine(r.stdout);
@@ -114543,7 +114739,7 @@ var SshTunnel = class {
       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)}` : ""}`);
+        if (!this.closing && !this.ended.has(child)) for (const l of this.downListeners) l(`ssh exited (${signal ?? code2})${stderr ? `: ${lastLine(stderr)}` : ""}`);
       });
       const poll = async () => {
         while (!settled) {
@@ -114553,6 +114749,7 @@ var SshTunnel = class {
             return resolve10();
           }
           if (Date.now() > deadline) {
+            this.ended.add(child);
             child.kill("SIGTERM");
             return fail4(`The ssh forward to ${this.opts.target} did not come up in time`);
           }
@@ -114566,6 +114763,7 @@ var SshTunnel = class {
     const child = this.child;
     this.child = null;
     if (!child || child.exitCode !== null || child.signalCode !== null) return;
+    this.ended.add(child);
     await new Promise((resolve10) => {
       child.once("exit", () => resolve10());
       child.kill("SIGTERM");
@@ -114790,12 +114988,21 @@ function readStep(run, ok, target) {
   if (!rest.startsWith(ok)) throw new Error(`Installing on ${target} answered something unexpected: ${rest.slice(0, 120)}`);
   return rest.slice(ok.length).trim();
 }
+var hostOnlyPackage = (platform) => `@centralu/host-${platform}`;
+async function hostPackage(platform, version2, registry2) {
+  try {
+    return await verifiedPackage(hostOnlyPackage(platform), version2, registry2);
+  } catch (err) {
+    if (err instanceof NotPublished) return verifiedPackage(`@centralu/${platform}`, version2, registry2);
+    throw err;
+  }
+}
 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 packages = await Promise.all([verifiedPackage("centralu", o.version, o.registry), hostPackage(pf2.platform, o.version, o.registry)]);
   const archive = o.runtime.node.archives[pf2.platform];
   const nodeVersion = o.runtime.node.version;
   o.onStep?.("node");
@@ -114821,6 +115028,52 @@ function remoteRuntime() {
   return JSON.parse(bundled("remote-runtime.json", "../../../../packaging/remote-runtime.json"));
 }
 
+// packages/agent-host/src/links/autostart.ts
+function parseAutostartLine(stdout) {
+  for (const line of stdout.split(/\r?\n/).reverse()) {
+    const t = line.trim();
+    if (!t.startsWith("{")) continue;
+    try {
+      const o = JSON.parse(t);
+      const state = o.v === 1 ? parseAutostart(o.autostart) : null;
+      if (state && typeof o.autostart?.ok === "boolean") {
+        return { ok: o.autostart.ok, state, message: typeof o.autostart.message === "string" ? o.autostart.message : null };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+var FAILED = {
+  on: "could not be set to start at boot",
+  off: "could not stop starting at boot",
+  status: "could not say whether it starts at boot"
+};
+async function autostartRemote(c, action) {
+  const r = await c.exec(autostartCommand(c.spec, action));
+  const unasked = (reason, message) => Object.assign(new Error(message), { reason });
+  if (r.stdout.includes(NOT_FOUND2)) throw unasked("not_found", `Centralu is not installed on ${c.target}`);
+  const answer = parseAutostartLine(r.stdout);
+  if (!answer) {
+    if (/unknown option for serve: --autostart/.test(r.stderr)) {
+      throw unasked("too_old", `The Centralu on ${c.target} is too old to start at boot; update it first`);
+    }
+    const why = lastLine(r.stderr);
+    throw new Error(`Centralu on ${c.target} gave no answer about starting at boot${why ? `: ${why}` : r.code ? ` (exit ${r.code})` : ""}`);
+  }
+  if (!answer.ok) throw new Error(`Centralu on ${c.target} ${FAILED[action]}: ${answer.message ?? "no reason given"}`);
+  return answer.state;
+}
+async function removeAutostart(c) {
+  try {
+    await autostartRemote(c, "off");
+    return true;
+  } catch (err) {
+    if (err.reason) return false;
+    throw err;
+  }
+}
+
 // packages/agent-host/src/links/update.ts
 var CHECK_MS = 3e4;
 function parseStopLine(stdout) {
@@ -114940,6 +115193,8 @@ async function uninstallRemote(c) {
   await c.hold();
   c.step("stop");
   const { wasRunning } = await stopRemoteHost(c);
+  c.step("autostart");
+  await removeAutostart(c);
   c.step("remove");
   readStep(await c.exec(uninstallCommand(c.spec)), "uninstalled", c.target);
   return { stopped: wasRunning };
@@ -115417,6 +115672,9 @@ var linkError2 = (message) => Object.assign(new Error(message), { code: "interna
 function installOf(i) {
   return i ? { managed: i.managed, current: i.current, previous: i.previous } : null;
 }
+function autostartOf(a) {
+  return a ? { on: a.on, how: a.how, linger: a.linger } : null;
+}
 function hiddenKind(s) {
   return isObj2(s) && (s.kind === "orchestrator" || s.kind === "coordinator");
 }
@@ -115463,6 +115721,8 @@ var LinkedMachine = class {
   helloWaiters = /* @__PURE__ */ new Set();
   /** What the hub installed there, from the last connection line (plan §10.5, S12) */
   installed = null;
+  /** Whether it starts its host at boot, from the last connection line or `machines.autostart` (plan §10.4) */
+  bootStart = null;
   get id() {
     return this.record.id;
   }
@@ -115488,7 +115748,8 @@ var LinkedMachine = class {
       sameLocalPort: this.endpoint ? this.endpoint.localPort === this.endpoint.line.port : false,
       hostStarted: this.hostStarted,
       install: this.installed,
-      operation: this.operation
+      operation: this.operation,
+      autostart: this.bootStart
     };
   }
   // ── RoutedMachine ───────────────────────────────────────────────────────────────────────
@@ -115584,10 +115845,38 @@ var LinkedMachine = class {
     return this.operate("uninstall", null, async (c) => {
       const r = await uninstallRemote(c);
       this.installed = { managed: false, current: null, previous: null };
+      if (this.bootStart) this.bootStart = { ...this.bootStart, on: false, linger: null };
       this.deps.log?.(`[links] ${this.name}: removed the Centralu this computer installed; its data stays`);
       return { machine: this.info(), stopped: r.stopped };
     });
   }
+  /**
+   * `machines.autostart` (plan §10.4, owner decision 4): the machine's host started at boot, or not, or
+   * (without `on`) whether it is. The Centralu there writes its own entry; nothing starts or stops now.
+   * Not while an install, update, rollback or uninstall runs there: the entry names a launcher that one
+   * may be removing
+   */
+  async autostart(on2) {
+    const exec8 = this.tunnel.exec?.bind(this.tunnel);
+    if (!exec8) throw linkError2(`This computer has no shell on ${this.name} to change how it starts`);
+    if (this.busy) throw linkError2(`${this.name} is busy with ${this.operation?.kind ?? "another change"}; wait until it is done`);
+    this.busy = true;
+    try {
+      const a = await autostartRemote({ exec: exec8, spec: this.record.remote, target: this.record.sshTarget }, on2 === void 0 ? "status" : on2 ? "on" : "off");
+      const state = { on: a.on, how: a.how, linger: a.linger };
+      this.bootStart = state;
+      if (on2 !== void 0) {
+        this.deps.log?.(`[links] ${this.name}: ${a.on ? `starts Centralu at boot (${a.how}${a.how === "systemd" && a.linger === false ? ", at login until lingering is enabled" : ""})` : "no longer starts Centralu at boot"}`);
+      }
+      this.deps.broadcast({ type: "machine_status", machine: this.info() });
+      return { machine: this.info(), autostart: state };
+    } catch (err) {
+      this.deps.log?.(`[links] ${this.name}: autostart ${on2 === void 0 ? "status" : on2 ? "on" : "off"} failed: ${err.message}`);
+      throw linkError2(err.message);
+    } finally {
+      this.busy = false;
+    }
+  }
   /**
    * 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
@@ -115643,8 +115932,9 @@ var LinkedMachine = class {
       this.operation = { kind, step: s, target, at: at2 };
       this.deps.broadcast({ type: "machine_status", machine: this.info() });
     };
+    let result;
     try {
-      return await fn2(this.control(tunnelExec, installer.script(), step), installer);
+      result = 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);
@@ -115656,6 +115946,7 @@ var LinkedMachine = class {
       if (!this.stopped && (wasHeld || this.status !== "connected")) this.reconnect();
       this.deps.broadcast({ type: "machine_status", machine: this.info() });
     }
+    return result && typeof result === "object" && "machine" in result ? { ...result, machine: this.info() } : result;
   }
   /** What update.ts runs things there with */
   control(exec8, script, step) {
@@ -115719,6 +116010,7 @@ var LinkedMachine = class {
     let endpoint = await this.openTunnel();
     if (!endpoint) return;
     this.installed = installOf(endpoint.line.install);
+    this.bootStart = autostartOf(endpoint.line.autostart);
     if (!endpoint.line.hostRunning && this.tunnel.startHost) {
       if (this.held) return;
       this.setStatus("starting", null);
@@ -115740,6 +116032,7 @@ var LinkedMachine = class {
       endpoint = await this.openTunnel();
       if (!endpoint) return;
       this.installed = installOf(endpoint.line.install);
+      this.bootStart = autostartOf(endpoint.line.autostart);
     }
     if (this.held) return;
     this.endpoint = endpoint;
@@ -115747,6 +116040,7 @@ var LinkedMachine = class {
       this.setStatus("not_running", `Centralu is installed on ${this.name}, but no \`centralu serve\` is running there`);
       return this.retryLater();
     }
+    for (const w of [...this.helloWaiters]) w(endpoint.line.version);
     const versions = this.check({ version: endpoint.line.version, protocolVersion: endpoint.line.protocolVersion, dev: false });
     if (!mayConnect(versions)) return;
     this.connectClient(endpoint);
@@ -115948,6 +116242,9 @@ var Links = class {
   uninstall(id2) {
     return this.need(id2).uninstall();
   }
+  autostart(id2, on2) {
+    return this.need(id2).autostart(on2);
+  }
   activity(id2) {
     return this.need(id2).activity();
   }
@@ -116176,6 +116473,7 @@ var ROUTES = {
   "machines.update": HUB,
   "machines.rollback": HUB,
   "machines.uninstall": HUB,
+  "machines.autostart": HUB,
   "machines.activity": HUB,
   // The hub's own answer; a hub asks a remote's through `machines.activity`
   "host.activity": HUB,
@@ -116313,7 +116611,11 @@ var Router = class {
     if (kind === "projects") return list.map((p) => mark(m.q.project(p)));
     return list.filter((s) => !m.hides(s)).map((s) => mark(m.q.session(s)));
   }
-  /** The person's project order, split per machine: each machine keeps the order of its own */
+  /**
+   * The person's project order, split per machine: each machine keeps the order of its own. A
+   * machine that cannot take it does not fail the rest, which has already been saved: its projects
+   * come back from the mirror as they were, marked `unreachable`, the way `projects.list` gives them
+   */
   async reorderProjects(machines, params) {
     const ids = isObj3(params) && Array.isArray(params.orderedIds) ? params.orderedIds : [];
     const perMachine = /* @__PURE__ */ new Map();
@@ -116325,7 +116627,13 @@ var Router = class {
     }
     const [mine, ...theirs] = await Promise.all([
       this.opts.local("projects.reorder", { ...isObj3(params) ? params : {}, orderedIds: local }),
-      ...[...perMachine].map(async ([m, orderedIds]) => m.q.projects(await this.forward(m, "projects.reorder", { orderedIds })))
+      ...[...perMachine].map(async ([m, orderedIds]) => {
+        try {
+          return m.q.projects(await this.forward(m, "projects.reorder", { orderedIds }));
+        } catch {
+          return this.present(m, "projects", m.lastKnown("projects") ?? [], true);
+        }
+      })
     ]);
     return [...mine, ...theirs.flat()];
   }
@@ -116419,7 +116727,7 @@ function storeMirror(store2) {
 }
 
 // packages/agent-host/src/main.ts
-var BUILD = true ? "1a563a8" : "dev";
+var BUILD = true ? "34635b7" : "dev";
 var underKeeper = process.env.CC_KEEPER === "1";
 var keeperSource = process.env.CC_HOST_SOURCE;
 var frontDoor = process.env.CC_FRONT_DOOR;
@@ -116682,6 +116990,7 @@ var router = new Router({
 });
 var server = new HostServer({
   port: Number(values.port),
+  ...startedByServe ? { servedBy: "serve" } : {},
   token,
   allowedOrigins,
   onRpc: router.handle,

package/Centralu/resources/host/remote-install.mjs

@@ -9,9 +9,9 @@
 // not survive the way back from Windows; tunnel.ts). The sentences for the person are the hub's.
 import { spawnSync } from 'node:child_process'
 import { createHash, randomBytes } from 'node:crypto'
-import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { join } from 'node:path'
+import { basename, join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 
 const WORD = /^[0-9A-Za-z][0-9A-Za-z.+-]{0,63}$/
@@ -86,27 +86,79 @@ export function prune(l) {
     }
   }
   sweep(l.versions, new Set(keep.map((p) => p.version)))
+  // What `placeVersion` moved aside and could not remove then
+  try {
+    for (const name of readdirSync(l.root).filter((n) => n.startsWith('.replaced-'))) {
+      try {
+        rmSync(join(l.root, name), { recursive: true, force: true })
+      } catch {
+        left.push(name)
+      }
+    }
+  } catch {}
   sweep(l.node, new Set(keep.map((p) => `v${p.node}`)))
   return { removed, left }
 }
 
-/** One installer at a time per data folder; a lock whose process is gone is taken over */
-function lock(l) {
-  for (let i = 0; i < 2; i++) {
+/** A lock folder with no pid in it, younger than this, is held: its installer has made it and not yet written the pid */
+const LOCK_YOUNG_MS = 60_000
+
+/**
+ * One installer at a time per data folder; a lock whose process is gone is taken over.
+ *
+ * Taking it is `mkdir`, which only one installer can do; the pid follows. A lock found with no pid is
+ * held while it is young (another installer between the two, which reading it as pid 0 once took
+ * over), and stale only after `LOCK_YOUNG_MS` (an installer that died between them). A stale lock is
+ * taken over by moving it aside first, so of two installers that both found it stale only one removes
+ * it, and one that moved a lock just replaced by a live one puts it back. Unlock removes the lock only
+ * while it is still this run's own (its `token`).
+ */
+export function lock(l) {
+  const token = `${process.pid}-${randomBytes(8).toString('hex')}`
+  for (let i = 0; i < 3; i++) {
     try {
       mkdirSync(l.lock)
       writeFileSync(join(l.lock, 'pid'), String(process.pid))
-      return () => rmSync(l.lock, { recursive: true, force: true })
+      writeFileSync(join(l.lock, 'token'), token)
+      return () => {
+        if (readFileSafe(join(l.lock, 'token')) === token) rmSync(l.lock, { recursive: true, force: true })
+      }
     } catch (err) {
       if (err.code !== 'EEXIST') throw err
-      const pid = Number(readFileSafe(join(l.lock, 'pid')))
-      if (pid > 0 && alive(pid)) throw new Refusal('busy', String(pid))
-      rmSync(l.lock, { recursive: true, force: true })
     }
+    const held = readFileSafe(join(l.lock, 'pid'))
+    if (!lockIsStale(l.lock, held)) throw new Refusal('busy', held.trim())
+    const aside = `${l.lock}.${token}.stale`
+    try {
+      renameSync(l.lock, aside)
+    } catch {
+      continue // gone already, or another installer moved it first
+    }
+    const moved = readFileSafe(join(aside, 'pid'))
+    if (moved !== held) {
+      // Replaced by a live lock between reading it and moving it: not ours to remove
+      try {
+        renameSync(aside, l.lock)
+      } catch {
+        // Someone holds a newer one; this one stays aside, named, and harmless
+      }
+      throw new Refusal('busy', moved.trim())
+    }
+    rmSync(aside, { recursive: true, force: true })
   }
   throw new Refusal('busy')
 }
 
+function lockIsStale(dir, pidText) {
+  const pid = Number(pidText.trim())
+  if (pidText.trim() && pid > 0) return !alive(pid)
+  try {
+    return Date.now() - statSync(dir).mtimeMs > LOCK_YOUNG_MS
+  } catch {
+    return true // gone: the next turn takes the lock
+  }
+}
+
 function readFileSafe(file) {
   try {
     return readFileSync(file, 'utf8')
@@ -144,10 +196,17 @@ export async function fetchChecked(pkg) {
   return bytes
 }
 
-/** Where the host sits in the platform package, and what of the package a remote never runs (plan S6) */
-function platformParts(platform) {
-  if (platform === 'win32-x64') return { host: join('Centralu', 'resources', 'host', 'main.mjs'), drop: [join('Centralu', 'centralu.exe')] }
-  return { host: join('host', 'main.mjs'), drop: ['Centralu.AppImage'] }
+/**
+ * Which package brings the host, where the host sits in it, and what of it a remote never runs (plan
+ * S6). The host-only package (`@centralu/host-<platform>`) is the host and nothing else; a version
+ * published before it existed comes as its platform package, whose window is thrown away
+ */
+function hostParts(platform, packages) {
+  const hostOnly = `@centralu/host-${platform}`
+  if (packages.some((pkg) => pkg.name === hostOnly)) return { pkg: hostOnly, host: join('host', 'main.mjs'), drop: [] }
+  const pkg = `@centralu/${platform}`
+  if (platform === 'win32-x64') return { pkg, host: join('Centralu', 'resources', 'host', 'main.mjs'), drop: [join('Centralu', 'centralu.exe')] }
+  return { pkg, host: join('host', 'main.mjs'), drop: ['Centralu.AppImage'] }
 }
 
 function sameInstall(dir, p) {
@@ -159,6 +218,32 @@ function sameInstall(dir, p) {
   }
 }
 
+/**
+ * Puts the unpacked `partial` folder in place as `dir`. A `dir` already there (the same version
+ * installed again with other bytes, possibly the one `current` runs) is moved aside first and removed
+ * only once the new one is in place, and put back if that fails: removing it first would leave
+ * `current` naming nothing after a failed rename, and on Windows a removal can stop halfway on the
+ * files of a host running from it (moving that folder is allowed, plan §10.5). What cannot be removed
+ * stays aside under a dot name, and the next prune tries again
+ */
+export function placeVersion(l, partial, dir) {
+  const aside = existsSync(dir) ? join(l.root, `.replaced-${basename(dir)}-${process.pid}-${randomBytes(4).toString('hex')}`) : null
+  if (aside) renameSync(dir, aside)
+  try {
+    renameSync(partial, dir)
+  } catch (err) {
+    if (aside) renameSync(aside, dir)
+    throw err
+  }
+  if (aside) {
+    try {
+      rmSync(aside, { recursive: true, force: true })
+    } catch {
+      // A Windows program still running from it; harmless where it is
+    }
+  }
+}
+
 /** Installs `p.version` beside what is there, switches `current` to it, and keeps `previous` */
 export async function install(p, { dataDir = process.env.CC_DATA_DIR || join(homedir(), '.centralu'), platform = process.platform } = {}) {
   if (!WORD.test(p.version) || !WORD.test(p.node)) throw new Refusal('params', 'version')
@@ -167,7 +252,7 @@ export async function install(p, { dataDir = process.env.CC_DATA_DIR || join(hom
   const unlock = lock(l)
   try {
     const dir = join(l.versions, p.version)
-    const parts = platformParts(p.platform)
+    const parts = hostParts(p.platform, p.packages)
     if (!sameInstall(dir, p)) {
       // Everything lands in a folder of its own first; the version's folder appears by one rename
       const partial = join(l.root, `.partial-${p.version}-${process.pid}`)
@@ -183,7 +268,7 @@ export async function install(p, { dataDir = process.env.CC_DATA_DIR || join(hom
           if (r.status !== 0) throw new Refusal('unpack', `${pkg.name}: ${(r.stderr || r.error?.message || '').trim().split('\n').at(-1)}`)
           rmSync(file, { force: true })
         }
-        const pkgDir = join(partial, 'node_modules', '@centralu', p.platform)
+        const pkgDir = join(partial, 'node_modules', ...parts.pkg.split('/'))
         if (!existsSync(join(pkgDir, parts.host))) throw new Refusal('no_host', p.platform)
         for (const d of parts.drop) rmSync(join(pkgDir, d), { force: true })
         writeFileSync(
@@ -191,8 +276,7 @@ export async function install(p, { dataDir = process.env.CC_DATA_DIR || join(hom
           JSON.stringify({ version: p.version, node: p.node, platform: p.platform, packages: p.packages.map(({ name, integrity }) => ({ name, integrity })), installedAt: new Date().toISOString(), by: p.hub ?? null }, null, 2) + '\n',
         )
         mkdirSync(l.versions, { recursive: true })
-        rmSync(dir, { recursive: true, force: true })
-        renameSync(partial, dir)
+        placeVersion(l, partial, dir)
       } finally {
         rmSync(partial, { recursive: true, force: true })
       }
@@ -249,8 +333,10 @@ export async function setPointers(p, { dataDir = process.env.CC_DATA_DIR || join
       return { current: null, previous: null }
     }
     const dir = join(l.versions, current.version)
-    const node = join(l.node, `v${current.node}`)
-    if (!existsSync(join(dir, 'install.json')) || !existsSync(node)) throw new Refusal('missing', `${current.version} ${current.node}`)
+    // Both must be there: a `previous` naming nothing would offer a rollback to a version that is gone
+    for (const v of [current, previous].filter(Boolean)) {
+      if (!existsSync(join(l.versions, v.version, 'install.json')) || !existsSync(join(l.node, `v${v.node}`))) throw new Refusal('missing', `${v.version} ${v.node}`)
+    }
     await ensureManagedLauncher(l, dir, current.version, platform)
     if (previous) writeAtomic(l.previous, `${previous.version} ${previous.node}\n`)
     else rmSync(l.previous, { force: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@centralu/win32-x64",
-  "version": "0.1.0-beta.14",
+  "version": "0.1.0-beta.15",
   "description": "Centralu app folder for Windows on x86-64",
   "license": "MIT",
   "author": "ijun17",