@centralu/host-linux-arm64 0.1.0-beta.21 → 0.1.0-beta.22

package/host/bundle-info.json

@@ -1,7 +1,7 @@
 {
-  "commit": "5dca7b8",
+  "commit": "8dd78b6",
   "protocolVersion": 1,
-  "builtAt": "2026-10-13T12:07:09.843Z",
+  "builtAt": "2026-10-13T19:11:12.573Z",
   "runtime": "system-node",
   "platform": "linux",
   "arch": "arm64"

package/host/main.mjs

@@ -3235,7 +3235,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws2.readyState === ws2.CONNECTING) {
-          ws2.once("open", function open5() {
+          ws2.once("open", function open6() {
             duplex._final(callback);
           });
           return;
@@ -3256,7 +3256,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws2.readyState === ws2.CONNECTING) {
-          ws2.once("open", function open5() {
+          ws2.once("open", function open6() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -42965,7 +42965,7 @@ import { mkdirSync as mkdirSync11, writeSync as writeSync4 } from "node:fs";
 
 // packages/protocol/src/brand.ts
 var APP_NAME = "Centralu";
-var APP_VERSION = "0.1.0-beta.21";
+var APP_VERSION = "0.1.0-beta.22";
 var APP_SLUG = "centralu";
 var CLIENT_INFO = { name: APP_SLUG, title: APP_NAME, version: APP_VERSION };
 var DATA_DIR = ".centralu";
@@ -62908,17 +62908,17 @@ function portInUseMessage(port2, servedBy) {
 var VIEW_HANDOVER_KEY = "views.handover";
 var VIEW_HANDOVER_MAX_AGE_MS = 10 * 6e4;
 function recordViewHandover(settings, views2, inline, now = Date.now()) {
-  const open5 = views2.list().map((v) => {
+  const open6 = views2.list().map((v) => {
     const owner = inline?.owner(v.id);
     return owner ? { ...v, inline: { sessionId: owner.sessionId, callId: owner.callId, tool: owner.tool } } : v;
   });
-  if (open5.length === 0) {
+  if (open6.length === 0) {
     settings.deleteAppSetting(VIEW_HANDOVER_KEY);
     return 0;
   }
-  const record2 = { at: now, views: open5 };
+  const record2 = { at: now, views: open6 };
   settings.setAppSetting(VIEW_HANDOVER_KEY, JSON.stringify(record2));
-  return open5.length;
+  return open6.length;
 }
 function restoreViewHandover(settings, views2, inline, now = Date.now()) {
   const raw = settings.appSetting(VIEW_HANDOVER_KEY);
@@ -63639,9 +63639,9 @@ import { join as join15 } from "node:path";
 import { lstatSync as lstatSync2, watch } from "node:fs";
 
 // packages/agent-host/src/dev-services/fs.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { constants as constants3 } from "node:fs";
-import { lstat as lstat2, mkdir, open, readdir, readlink, realpath as realpath2, rename, rm, stat as stat2, writeFile } from "node:fs/promises";
+import { lstat as lstat2, mkdir, open as open2, readdir, readlink, realpath as realpath2, rename, rm, stat as stat2, writeFile } from "node:fs/promises";
 import { basename, dirname as dirname2, extname, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve, sep as sep2 } from "node:path";
 
 // packages/agent-host/src/dev-services/path-guard.ts
@@ -63776,7 +63776,8 @@ function isMissingFsPath(error51) {
 }
 
 // packages/agent-host/src/dev-services/git-exec.ts
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { open } from "node:fs/promises";
 import { devNull } from "node:os";
 import { promisify } from "node:util";
 
@@ -64002,6 +64003,40 @@ async function gitArgv(cwd, args, allowRepoPrograms = false) {
 }
 async function runGit(cwd, args, opts = {}) {
   const argv = await gitArgv(cwd, args, opts.allowRepoPrograms);
+  if (opts.outputFile) {
+    const output = await open(opts.outputFile, "w", 384);
+    try {
+      await new Promise((resolve12, reject) => {
+        const child = spawn(programPath("git"), argv, {
+          cwd,
+          stdio: ["pipe", output.fd, "pipe"],
+          timeout: opts.timeout ?? DEFAULTS.timeout,
+          ...opts.env ? { env: { ...process.env, ...opts.env } } : {}
+        });
+        let stderr = "";
+        let overflow = false;
+        child.stderr.on("data", (chunk) => {
+          if (overflow) return;
+          stderr += chunk.toString();
+          if (Buffer.byteLength(stderr) > (opts.maxBuffer ?? DEFAULTS.maxBuffer)) {
+            overflow = true;
+            child.kill();
+          }
+        });
+        child.on("error", reject);
+        child.on("close", (code2, signal) => {
+          if (code2 === 0 && !overflow) resolve12();
+          else reject(Object.assign(new Error(overflow ? "Git stderr exceeded maxBuffer" : stderr || `Git exited with ${code2 ?? signal}`), { code: code2, stderr }));
+        });
+        child.stdin.on("error", () => {
+        });
+        child.stdin.end(opts.input);
+      });
+      return "";
+    } finally {
+      await output.close();
+    }
+  }
   const run = exec(programPath("git"), argv, {
     cwd,
     timeout: opts.timeout ?? DEFAULTS.timeout,
@@ -64162,7 +64197,7 @@ async function readTextFile(root3, rel) {
   const file2 = await resolveExisting(root3, rel);
   const pathInfo = await stat2(file2, { bigint: true });
   if (!pathInfo.isFile()) fail2("Path is not a regular file");
-  const handle = await open(file2, READ_TEXT_FLAGS);
+  const handle = await open2(file2, READ_TEXT_FLAGS);
   try {
     const opened = await handle.stat({ bigint: true });
     if (!opened.isFile()) fail2("Path is not a regular file");
@@ -64228,7 +64263,7 @@ async function copyTree(src, dst, clone2 = cloneTree) {
 async function cloneTree(src, dst) {
   if (!clonesFiles()) return false;
   return new Promise((done) => {
-    const p = spawn("/bin/cp", ["-Rc", src, dst], { stdio: "ignore" });
+    const p = spawn2("/bin/cp", ["-Rc", src, dst], { stdio: "ignore" });
     p.on("error", () => done(false));
     p.on("close", (code2) => done(code2 === 0));
   });
@@ -64385,7 +64420,7 @@ function isSymlink(path2) {
 }
 
 // packages/agent-host/src/apps/external/app-process.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { closeSync as closeSync2, existsSync as existsSync5, mkdirSync, openSync as openSync2, renameSync as renameSync3, statSync as statSync3, writeSync as writeSync3 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
 
@@ -79941,7 +79976,7 @@ var AppProcess = class _AppProcess {
     log.note(`starting: ${spec.command} ${spec.args.join(" ")}`);
     const launch2 = resolveCommand(spec.command, spec.env);
     const spawnedAt = Date.now();
-    const child = spawn2(launch2.command, [...launch2.args, ...spec.args], {
+    const child = spawn3(launch2.command, [...launch2.args, ...spec.args], {
       cwd: spec.cwd,
       env: spec.env,
       /*
@@ -94045,7 +94080,7 @@ var RUN_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 var FAILURES_KEPT = 20;
 var SUMMARY_CHARS = 200;
 function announcingLedger(inner, announce) {
-  const open5 = /* @__PURE__ */ new Map();
+  const open6 = /* @__PURE__ */ new Map();
   const tell = (apps) => {
     for (const a of apps ?? []) announce(a);
   };
@@ -94054,20 +94089,20 @@ function announcingLedger(inner, announce) {
     begin(row) {
       inner.begin(row);
       const apps = [{ projectId: row.projectId, appId: row.appId }];
-      for (const up2 of row.parentRunId ? open5.get(row.parentRunId) ?? [] : []) {
+      for (const up2 of row.parentRunId ? open6.get(row.parentRunId) ?? [] : []) {
         if (!apps.some((a) => a.projectId === up2.projectId && a.appId === up2.appId)) apps.push(up2);
       }
-      open5.set(row.id, apps);
+      open6.set(row.id, apps);
       tell(apps);
     },
     link(id2, sessionId) {
       inner.link(id2, sessionId);
-      tell(open5.get(id2));
+      tell(open6.get(id2));
     },
     end(id2, e) {
       inner.end(id2, e);
-      tell(open5.get(id2));
-      open5.delete(id2);
+      tell(open6.get(id2));
+      open6.delete(id2);
     }
   };
 }
@@ -96600,8 +96635,8 @@ var ExternalApps = class {
       return { runId, status, result, error: error51, durationMs };
     };
     if (!e.manifest) return done("rejected", null, `This app's manifest is invalid: ${e.error}`);
-    const open5 = caller.kind === "session" && this.sessionBoundaryOpen(caller.sessionId);
-    if (!e.scope.trusted && !open5) return done("rejected", null, "This app's project is not trusted, so Centralu does not call its apps");
+    const open6 = caller.kind === "session" && this.sessionBoundaryOpen(caller.sessionId);
+    if (!e.scope.trusted && !open6) return done("rejected", null, "This app's project is not trusted, so Centralu does not call its apps");
     const held3 = this.held(e);
     if (held3) return done("rejected", null, held3);
     if (e.life.gaveUp) return done("rejected", null, `This app stopped after failing ${this.timing.maxFailures} times in a row`);
@@ -96649,7 +96684,7 @@ var ExternalApps = class {
           abort.abort();
           for (const sig of upstream) sig.removeEventListener("abort", onUp);
         }
-      }, open5);
+      }, open6);
     } catch (err) {
       return done("error", null, err.message);
     }
@@ -97960,9 +97995,9 @@ var InlineViews = class {
    * just opened is never the one closed.
    */
   capLive(sessionId, keep) {
-    const open5 = [...this.bySession.get(sessionId)?.values() ?? []].filter((x) => x.instanceId).sort((a, b2) => a.openedAt - b2.openedAt);
+    const open6 = [...this.bySession.get(sessionId)?.values() ?? []].filter((x) => x.instanceId).sort((a, b2) => a.openedAt - b2.openedAt);
     const n = this.limits.livePerSession;
-    for (const old of open5.slice(0, Math.max(0, open5.length - n))) {
+    for (const old of open6.slice(0, Math.max(0, open6.length - n))) {
       if (old === keep) continue;
       this.shut(old);
       this.deps.emit({
@@ -98172,8 +98207,9 @@ var OriginPorts = class {
 
 // packages/agent-host/src/dev-services/worktree-recovery.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync13 } from "node:fs";
-import { chmod, lstat as lstat3, mkdir as mkdir2, readFile, readdir as readdir2, realpath as realpath3, rm as rm2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { createReadStream, existsSync as existsSync13 } from "node:fs";
+import { chmod, lstat as lstat3, mkdir as mkdir2, mkdtemp, readFile, readdir as readdir2, realpath as realpath3, rm as rm2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
 import { join as join16, resolve as resolve2 } from "node:path";
 var WORKTREE_RECOVERY_MAX_BYTES = 256 * 1024 * 1024;
 var RECOVERY_TIMEOUT = 12e4;
@@ -98184,6 +98220,25 @@ function worktreeRecoveryDir(sessionId) {
 async function clearWorktreeRecovery(sessionId) {
   await rm2(worktreeRecoveryDir(sessionId), { recursive: true, force: true });
 }
+async function* gitRecords(repo, args, input) {
+  const dir = await mkdtemp(join16(tmpdir2(), "cc-recovery-git-"));
+  const file2 = join16(dir, "records");
+  try {
+    await runGit(repo, args, { outputFile: file2, timeout: RECOVERY_TIMEOUT, input });
+    let pending = "";
+    for await (const chunk of createReadStream(file2, { encoding: "utf8" })) {
+      pending += chunk;
+      let end;
+      while ((end = pending.indexOf("\0")) !== -1) {
+        yield pending.slice(0, end);
+        pending = pending.slice(end + 1);
+      }
+    }
+    if (pending) yield pending;
+  } finally {
+    await rm2(dir, { recursive: true, force: true });
+  }
+}
 async function saveWorktreeRecovery(sessionId, cwd, trunk, branch) {
   const plans = [];
   let bytes2 = 0;
@@ -98193,7 +98248,7 @@ async function saveWorktreeRecovery(sessionId, cwd, trunk, branch) {
       throw new Error(`Worktree recovery exceeds the 256 MiB input limit (tracked and non-ignored untracked files plus staged changes, including submodules). No files were staged or removed; save the work elsewhere before deleting.`);
     }
   };
-  const prepare = async (repo, path2) => {
+  const prepare = async (repo, path2, gitlinks = []) => {
     const tip = (await runGit(repo, ["rev-parse", "--verify", "HEAD"])).trim();
     const refs = ["HEAD"];
     if (!path2 && branch) {
@@ -98201,20 +98256,85 @@ async function saveWorktreeRecovery(sessionId, cwd, trunk, branch) {
       if (await runGit(repo, ["rev-parse", "--verify", ref]).then(() => true).catch(() => false)) refs.push(ref);
     } else if (path2) {
       refs.push(...(await runGit(repo, ["for-each-ref", "--format=%(refname)", "refs/heads/"])).trim().split("\n").filter(Boolean));
+      if (gitlinks.length) {
+        const available = await runGit(repo, ["cat-file", "--batch-check=%(objectname) %(objecttype)"], {
+          input: gitlinks.map((oid) => `${oid}^{commit}`).join("\n") + "\n",
+          timeout: RECOVERY_TIMEOUT,
+          // Older Git ignores the lazy-fetch switch; disallow transports there too.
+          env: { GIT_NO_LAZY_FETCH: "1", GIT_ALLOW_PROTOCOL: "" }
+        });
+        for (const row of available.trim().split("\n")) {
+          const [oid, type] = row.split(" ");
+          if (type === "commit") refs.push(oid);
+        }
+      }
     }
     const baselineOid = !path2 ? await runGit(repo, ["rev-parse", "--verify", `${trunk}^{commit}`]).then((s) => s.trim()).catch(() => null) : null;
-    const exclude = path2 ? ["--not", "--remotes"] : baselineOid ? ["--not", baselineOid] : [];
-    const commits = Number((await runGit(repo, ["rev-list", "--count", ...refs, ...exclude])).trim());
+    const exclude = path2 ? (await runGit(repo, ["for-each-ref", "--format=^%(objectname)", "refs/remotes/"])).trim().split("\n").filter(Boolean) : baselineOid ? [`^${baselineOid}`] : [];
+    const revisions = [...refs, ...exclude].join("\n") + "\n";
+    const commits = Number((await runGit(repo, ["rev-list", "--count", "--stdin"], { input: revisions, timeout: RECOVERY_TIMEOUT })).trim());
     plans.push({ repo, path: path2, tip, refs, commits });
     const stagedNames = new Set((await runGit(repo, ["diff", "--cached", "--name-only", "-z", "--no-renames", tip], { timeout: RECOVERY_TIMEOUT })).split("\0"));
     const modules = [];
+    const moduleCommits = /* @__PURE__ */ new Map();
+    const keepGitlink = (rel, oid) => {
+      modules.push(rel);
+      const tips = moduleCommits.get(rel) ?? /* @__PURE__ */ new Set();
+      tips.add(oid);
+      moduleCommits.set(rel, tips);
+    };
+    const manifests = /* @__PURE__ */ new Set();
+    const keepManifest = (rel, oid) => {
+      if (rel === ".gitmodules" && !/^0+$/.test(oid)) manifests.add(oid);
+    };
+    let change = null;
+    for await (const row of gitRecords(repo, ["log", "--raw", "-z", "--no-renames", "--ignore-submodules=none", "--no-abbrev", "--format=", "--root", "--diff-merges=separate", "--stdin"], revisions)) {
+      if (change) {
+        const [, oldMode, newMode, oldOid, newOid] = change;
+        if (oldMode === "160000") keepGitlink(row, oldOid);
+        if (newMode === "160000") keepGitlink(row, newOid);
+        keepManifest(row, oldOid);
+        keepManifest(row, newOid);
+        change = null;
+      } else change = row.match(/^\n*:(\d{6}) (\d{6}) ([a-f0-9]+) ([a-f0-9]+) [A-Z]$/);
+    }
+    for await (const row of gitRecords(repo, ["ls-tree", "-r", "-z", "HEAD"])) {
+      const tab = row.indexOf("	");
+      const [mode, , oid] = row.slice(0, tab).split(" ");
+      const rel = row.slice(tab + 1);
+      if (mode === "160000") keepGitlink(rel, oid);
+      keepManifest(rel, oid);
+    }
     const stagedObjects = [];
-    for (const row of (await runGit(repo, ["ls-files", "--stage", "-z"])).split("\0")) {
+    for await (const row of gitRecords(repo, ["ls-files", "--stage", "-z"])) {
       if (!row) continue;
       const tab = row.indexOf("	");
       const rel = row.slice(tab + 1);
-      if (row.startsWith("160000 ")) modules.push(rel);
-      else if (stagedNames.has(rel)) stagedObjects.push(row.split(" ")[1]);
+      const oid = row.split(" ")[1];
+      if (row.startsWith("160000 ")) keepGitlink(rel, oid);
+      else if (stagedNames.has(rel)) stagedObjects.push(oid);
+      keepManifest(rel, oid);
+    }
+    const modulePaths = /* @__PURE__ */ new Map();
+    for (const oid of manifests) {
+      const config2 = await runGit(repo, ["config", "--blob", oid, "-z", "--get-regexp", "^submodule\\..*\\.path$"]).catch((e) => {
+        if (e.code === 1) return "";
+        throw e;
+      });
+      for (const row of config2.split("\0").filter(Boolean)) {
+        const newline = row.indexOf("\n");
+        const name = row.slice("submodule.".length, newline - ".path".length);
+        const paths = modulePaths.get(name) ?? /* @__PURE__ */ new Set();
+        paths.add(row.slice(newline + 1));
+        modulePaths.set(name, paths);
+      }
+    }
+    for (const paths of modulePaths.values()) {
+      const tips = new Set([...paths].flatMap((rel) => [...moduleCommits.get(rel) ?? []]));
+      for (const rel of paths) {
+        modules.push(rel);
+        moduleCommits.set(rel, /* @__PURE__ */ new Set([...moduleCommits.get(rel) ?? [], ...tips]));
+      }
     }
     if (stagedObjects.length) {
       const sizes = await runGit(repo, ["cat-file", "--batch-check=%(objectsize)"], { input: stagedObjects.join("\n") + "\n" });
@@ -98236,7 +98356,7 @@ async function saveWorktreeRecovery(sessionId, cwd, trunk, branch) {
       await assertExistingPath(repo, rel).catch((e) => {
         if (existsSync13(join16(repo, rel))) throw e;
       });
-      if (existsSync13(join16(repo, rel, ".git"))) await prepare(join16(repo, rel), path2 ? `${path2}/${rel}` : rel);
+      if (existsSync13(join16(repo, rel, ".git"))) await prepare(join16(repo, rel), path2 ? `${path2}/${rel}` : rel, [...moduleCommits.get(rel) ?? []]);
     }
   };
   await prepare(cwd, "");
@@ -98257,7 +98377,26 @@ async function saveWorktreeRecovery(sessionId, cwd, trunk, branch) {
       const entry = { path: path2, tip, refs, patch: false, staged: false, bundle: commits > 0 };
       snapshot2.repositories.push(entry);
       snapshot2.commits += commits;
-      if (entry.bundle) await runGit(repo, ["bundle", "create", join16(dir, `${n}.bundle`), ...refs], { timeout: RECOVERY_TIMEOUT });
+      if (entry.bundle) {
+        const temporaryRefs = [];
+        const updates2 = [];
+        try {
+          entry.refs = [];
+          for (const ref of refs) {
+            if (ref === "HEAD" || ref.startsWith("refs/")) entry.refs.push(ref);
+            else {
+              const name = `refs/centralu-recovery/${snapshotId}/gitlink-${temporaryRefs.length}`;
+              temporaryRefs.push(name);
+              updates2.push(`create ${name} ${ref}`);
+              entry.refs.push(name);
+            }
+          }
+          if (updates2.length) await runGit(repo, ["update-ref", "--stdin"], { input: updates2.join("\n") + "\n", timeout: RECOVERY_TIMEOUT });
+          await runGit(repo, ["bundle", "create", join16(dir, `${n}.bundle`), "--stdin"], { input: entry.refs.join("\n") + "\n", timeout: RECOVERY_TIMEOUT });
+        } finally {
+          if (temporaryRefs.length) await runGit(repo, ["update-ref", "--stdin"], { input: temporaryRefs.map((ref) => `delete ${ref}`).join("\n") + "\n", timeout: RECOVERY_TIMEOUT });
+        }
+      }
       entry.staged = await patchFile(repo, tip, join16(dir, `${n}.staged.patch`));
       const stagedNames = await runGit(repo, ["diff", "--cached", "--name-only", "-z", "--no-renames", tip], { timeout: RECOVERY_TIMEOUT });
       const env = { GIT_INDEX_FILE: join16(dir, `${n}.index`) };
@@ -98292,7 +98431,28 @@ async function restoreWorktreeRecovery(sessionId, repo, path2, branch, recovery,
   const dir = join16(worktreeRecoveryDir(sessionId), recovery.snapshot);
   const snapshot2 = JSON.parse(await readFile(join16(dir, "snapshot.json"), "utf8"));
   const root3 = snapshot2.repositories[0];
+  let extraNotice = "";
+  if (root3.bundle) {
+    const heads = (await runGit(repo, ["bundle", "list-heads", join16(dir, "0.bundle")])).trim().split("\n");
+    for (const row of heads) {
+      const [tip, ref] = row.split(" ");
+      if (!tip || !ref?.startsWith("refs/heads/") || tip === recovery.tip) continue;
+      const base2 = `recovered/${sessionId}-stored-branch`;
+      let recovered = base2;
+      for (let suffix = 1; ; suffix++) {
+        const existing = await runGit(repo, ["rev-parse", "--verify", `refs/heads/${recovered}`]).then((s) => s.trim()).catch(() => null);
+        if (existing === tip) break;
+        if (!existing) {
+          await runGit(repo, ["fetch", join16(dir, "0.bundle"), `${ref}:refs/heads/${recovered}`], { allowRepoPrograms: trust.trusted === true });
+          break;
+        }
+        recovered = `${base2}-${suffix}`;
+      }
+      extraNotice += `Stored branch ${ref.slice("refs/heads/".length)} recovered as ${recovered}. `;
+    }
+  }
   if (!existsSync13(path2)) {
+    await rm2(join16(dir, "patches-applied"), { force: true });
     if (await runGit(repo, ["show-ref", "--verify", `refs/heads/${branch}`]).then(() => true).catch(() => false)) {
       branch = `recovered/${sessionId}`;
     }
@@ -98302,18 +98462,26 @@ async function restoreWorktreeRecovery(sessionId, repo, path2, branch, recovery,
       try {
         if (root3.staged) await runGit(path2, ["apply", "--cached", "--binary", join16(dir, "0.staged.patch")]);
         if (root3.patch) await runGit(path2, ["apply", "--binary", join16(dir, "0.patch")]);
+        await writeFile2(join16(dir, "patches-applied"), await realpath3(path2), { mode: 384 });
       } catch {
-        return { branch, notice: `Restored branch ${branch}. Patches could not all be applied. Recovery files remain at ${dir}; apply numbered .patch files manually with git apply and .staged.patch files with git apply --cached.` };
+        return { branch, notice: `Restored branch ${branch}. ${extraNotice}Patches could not all be applied. Recovery files remain at ${dir}; apply numbered .patch files manually with git apply and .staged.patch files with git apply --cached.` };
       }
     }
   } else {
     const common = async (cwd) => realpath3(resolve2(cwd, (await runGit(cwd, ["rev-parse", "--git-common-dir"])).trim()));
     if (await common(path2) !== await common(repo)) throw new Error(`The worktree path belongs to another repository. Recovery files remain at ${dir}`);
     branch = (await runGit(path2, ["symbolic-ref", "--quiet", "--short", "HEAD"])).trim();
+    if (root3.patch || root3.staged) {
+      const appliedTo = await readFile(join16(dir, "patches-applied"), "utf8").catch((e) => {
+        if (e.code === "ENOENT") return null;
+        throw e;
+      });
+      extraNotice += appliedTo === await realpath3(path2) ? "Saved patches were applied during the previous restore attempt; they were not reapplied on this retry. " : "The worktree already existed; saved patches were not applied on this retry and may still need manual recovery. ";
+    }
   }
   return {
     branch,
-    notice: `Restored branch ${branch}. Recovery files remain at ${dir}: ${recovery.changedFiles} uncommitted files, ${recovery.commits} commits absent from the trunk or submodule remotes. Numbered .patch files can be applied with git apply; .bundle files list their saved refs with git bundle list-heads and can be fetched with git fetch <bundle> <ref>:<branch>. snapshot.json names each repository and its refs. Submodule recovery is manual. These files are removed when this session is deleted for good.`
+    notice: `Restored branch ${branch}. ${extraNotice}Recovery files remain at ${dir}: ${recovery.changedFiles} uncommitted files, ${recovery.commits} commits absent from the trunk or submodule remotes. Numbered .patch files can be applied with git apply; .bundle files list their saved refs with git bundle list-heads and can be fetched with git fetch <bundle> <ref>:<branch>. snapshot.json names each repository and its refs. Submodule recovery is manual. These files are removed when this session is deleted for good.`
   };
 }
 
@@ -98406,8 +98574,12 @@ and approved skills, and whether every session can look at its own project), App
 Shortcuts (the shortcut list), and Updates.`,
   updates: `# Updates
 Check from Settings \u2192 Updates. It reports a new version based on the npm registry, and the person
-clicks to install it. The check for a new version runs on startup and every six hours, and it can
-be turned off.
+clicks to install it. With automatic checking on, the check runs on startup, every six hours, when
+Updates opens, and on focus when the last check is over an hour old. With it off, use Check now.
+Ordinary checks follow npm, including dist-tag rollbacks. Installing reuses a successful check
+from the last minute or checks again. Only while installing can a higher stored version seen less
+than an hour ago win over the fresh tag. Older observations yield to npm. If the check fails, it
+uses the stored version and says so. Checks preserve install errors until the next install attempt.
 Once installed, the desktop app offers "Apply now": it relaunches into the new version, and running
 agents, terminals and commands keep going. "Apply updates automatically when idle" (off by default)
 installs a new version without a click and applies it once no session is working or waiting, no
@@ -98780,6 +98952,7 @@ function agentRunText(r) {
     case "stopped":
       return { text: `Stopped ${who}.` };
     case "deleted":
+      if (r.branch === void 0) return { text: `Moved ${who} to the trash. Tell the person in one line.` };
       return {
         text: (r.warning ? `Moved ${who} to the trash. Warning: ${r.warning} ` : `Cleaned up ${who}: its worktree and branch "${r.branch}" were removed and the session went to the trash. `) + (r.setAside.changedFiles || r.setAside.commits ? `${r.setAside.changedFiles} uncommitted files, ${r.setAside.commits} commits not on the trunk, kept in the trash. ` : "Nothing needed setting aside. ") + "Tell the person in one line."
       };
@@ -101604,7 +101777,7 @@ async function readClaudeModels(q2) {
 }
 
 // packages/agent-host/src/adapters/local-process.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import { EventEmitter as EventEmitter3 } from "node:events";
 var EXIT_AFTER_OUTPUT_MS3 = 1e3;
 var STDERR_TAIL = 8 * 1024;
@@ -101634,7 +101807,7 @@ var LocalAgentProcess = class _LocalAgentProcess extends EventEmitter3 {
   exitReported = false;
   spawnedAt = Date.now();
   static spawn(spec, os2) {
-    const child = spawn4(spec.command, spec.args, {
+    const child = spawn5(spec.command, spec.args, {
       cwd: spec.cwd,
       env: spec.env,
       stdio: ["pipe", "pipe", "pipe"],
@@ -102818,10 +102991,19 @@ function readTarget(toolName, input) {
   const p = toolName === "Read" ? input.file_path : input.path;
   return typeof p === "string" && p ? p : null;
 }
-function permissionOptionsFor(preset) {
-  if (preset === "auto") return { permissionMode: "bypassPermissions" };
-  if (preset === "safe") return { permissionMode: "default" };
-  return { resolvePermissionModeInCli: true };
+async function permissionOptionsFor(opts) {
+  if (opts.permissionPreset === "auto") return { permissionMode: "bypassPermissions" };
+  if (opts.permissionPreset === "safe") return { permissionMode: "default" };
+  if (opts.noSettingFiles) return { permissionMode: await personsDefaultMode() ?? "default" };
+  try {
+    const resolved = await D9t({ cwd: opts.cwd, ...settingSourcesFor(opts) });
+    const mode = qtt(resolved).permissions?.defaultMode;
+    if (typeof mode === "string" && PERMISSION_MODES.includes(mode)) {
+      return { permissionMode: mode };
+    }
+  } catch {
+  }
+  return { permissionMode: "default" };
 }
 var PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
 async function personsDefaultMode() {
@@ -102961,7 +103143,7 @@ var ClaudeSession = class {
       this.orchestratorServer = orchestratorMcp(this.opts.orchestratorTools, this.opts.toolProfile, this.opts.sessionId);
     }
     const servers = this.mcpServers();
-    const personsMode = preset === "normal" && this.opts.noSettingFiles ? await personsDefaultMode() : null;
+    const permissionOptions = await permissionOptionsFor(this.opts);
     if (!this.opts.processSource?.adopt) await this.launch.gate.turn();
     this.runKey = run?.key ?? null;
     this.launch.links.acquire(this.runKey);
@@ -103054,7 +103236,7 @@ var ClaudeSession = class {
            */
           ...this.opts.systemPromptAppend ? { systemPrompt: { type: "preset", preset: "claude_code", append: this.opts.systemPromptAppend } } : {}
         } : {},
-        ...personsMode ? { permissionMode: personsMode } : permissionOptionsFor(preset),
+        ...permissionOptions,
         /*
          * The agent an app hands a schema and asks for output (M4 D-1). It is a per-query option,
          * so it can only be given when the session starts. Measured (SDK 0.3.263, CLI 2.1.282,
@@ -103296,8 +103478,8 @@ var ClaudeSession = class {
    * turn released, rather than left hanging; the person can send the message again.
    */
   releaseLostCalls(q2) {
-    const open5 = this.opts.processSource?.adopt?.openCalls ?? [];
-    const lost = open5.filter((c) => isOrchestratorTool(c.tool) || appToolOf(c.tool) !== null);
+    const open6 = this.opts.processSource?.adopt?.openCalls ?? [];
+    const lost = open6.filter((c) => isOrchestratorTool(c.tool) || appToolOf(c.tool) !== null);
     if (lost.length === 0) return;
     this.turnOpen = true;
     this.stream.stopped();
@@ -103428,11 +103610,11 @@ var ClaudeSession = class {
    * the model receives the answers in the CLI's own words (see the AskUserQuestion branch of `canUseTool`).
    */
   answerQuestion(requestId, answers) {
-    const open5 = this.questions.get(requestId);
-    if (!open5) return false;
+    const open6 = this.questions.get(requestId);
+    if (!open6) return false;
     this.questions.delete(requestId);
     const byQuestion = Object.fromEntries(answers.map((a) => [a.question, a.answers.join(", ")]));
-    open5.resolve({ behavior: "allow", updatedInput: { ...open5.input, answers: byQuestion } });
+    open6.resolve({ behavior: "allow", updatedInput: { ...open6.input, answers: byQuestion } });
     this.emit({ type: "question_resolved", sessionId: this.sessionId, requestId });
     return true;
   }
@@ -103708,8 +103890,8 @@ var ClaudeSession = class {
   }
   /** 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) {
-      open5.resolve({ behavior: "deny", message: why });
+    for (const [id2, open6] of this.questions) {
+      open6.resolve({ behavior: "deny", message: why });
       this.emit({ type: "question_resolved", sessionId: this.sessionId, requestId: id2 });
     }
     this.questions.clear();
@@ -103815,7 +103997,7 @@ var ClaudeAdapter = class _ClaudeAdapter {
     sleep: true
   };
   launchSettingsFingerprint(settings) {
-    return JSON.stringify({ v: settings.permissionPreset === "auto" ? 2 : 1, cwd: settings.cwd, permission: settings.permissionPreset, trusted: !!settings.projectTrusted, noSettings: !!settings.noSettingFiles });
+    return JSON.stringify({ v: settings.permissionPreset === "safe" ? 1 : 2, cwd: settings.cwd, permission: settings.permissionPreset, trusted: !!settings.projectTrusted, noSettings: !!settings.noSettingFiles });
   }
   async detect() {
     const path2 = whichTool("claude");
@@ -104163,7 +104345,7 @@ var CodexClient = class {
 };
 
 // packages/agent-host/src/adapters/codex/rollout.ts
-import { createReadStream as createReadStream2 } from "node:fs";
+import { createReadStream as createReadStream3 } from "node:fs";
 import { readdir as readdir5 } from "node:fs/promises";
 import { createInterface as createInterface2 } from "node:readline";
 import { homedir as homedir6 } from "node:os";
@@ -104199,7 +104381,7 @@ async function lastCompactSummary(threadId, sessionsDir) {
   if (!path2) return null;
   try {
     let last = null;
-    const rl2 = createInterface2({ input: createReadStream2(path2, "utf8"), crlfDelay: Infinity });
+    const rl2 = createInterface2({ input: createReadStream3(path2, "utf8"), crlfDelay: Infinity });
     for await (const line of rl2) {
       if (!line.includes('"compacted"')) continue;
       try {
@@ -106321,10 +106503,10 @@ var CodexSession = class {
     return this.opts.outputSchema ? { outputSchema: this.opts.outputSchema } : {};
   }
   respondApproval(requestId, decision, _scope, matcher) {
-    const open5 = this.approvals.get(requestId);
-    if (open5 === void 0) return false;
+    const open6 = this.approvals.get(requestId);
+    if (open6 === void 0) return false;
     this.approvals.delete(requestId);
-    const serverId = open5.serverId;
+    const serverId = open6.serverId;
     if (this.elicitations.delete(requestId)) {
       this.client.respond(serverId, {
         action: decision === "deny" ? "decline" : "accept",
@@ -110100,7 +110282,7 @@ async function sweepAttachments(maxBytes = ATTACHMENTS_MAX_BYTES) {
 
 // packages/agent-host/src/dev-services/message-image.ts
 import { constants as constants7 } from "node:fs";
-import { open as open4, realpath as realpath7 } from "node:fs/promises";
+import { open as open5, realpath as realpath7 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
 import { posix as posix3, sep as sep10, win32 as win326 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
@@ -110165,7 +110347,7 @@ async function readMessageImage(abs, max = IMAGE_PREVIEW_MAX_BYTES) {
   }
   let handle;
   try {
-    handle = await open4(file2, OPEN_FLAGS);
+    handle = await open5(file2, OPEN_FLAGS);
   } catch (e) {
     const code2 = e.code;
     if (code2 === "EACCES" || code2 === "EPERM") return refuse5("unreadable", `Centralu may not read ${file2}`, file2);
@@ -111451,14 +111633,14 @@ var SessionManager = class {
   }
   /** Tool calls the store holds for this session with no result after them (the newest 200 rows) */
   openToolCalls(sessionId) {
-    const open5 = /* @__PURE__ */ new Map();
+    const open6 = /* @__PURE__ */ new Map();
     for (const r of this.store.loadMessages(sessionId, 200)) {
       const p = r.payload;
       if (typeof p?.callId !== "string") continue;
-      if (r.kind === "tool_call" && typeof p.summary?.tool === "string") open5.set(p.callId, p.summary.tool);
-      else if (r.kind === "tool_result") open5.delete(p.callId);
+      if (r.kind === "tool_call" && typeof p.summary?.tool === "string") open6.set(p.callId, p.summary.tool);
+      else if (r.kind === "tool_result") open6.delete(p.callId);
     }
-    return [...open5].map(([callId, tool]) => ({ callId, tool }));
+    return [...open6].map(([callId, tool]) => ({ callId, tool }));
   }
   /**
    * Re-attaches the tool processes a previous host left running in the keeper (#280 step 2), so
@@ -111713,6 +111895,7 @@ var SessionManager = class {
       this.leaving.delete(sessionId);
     }
   }
+  trashing = /* @__PURE__ */ new Map();
   /**
    * Moves a session to the trash (#204) — what deleting a session means now. Nothing is destroyed: the process
    * stops, and the session leaves every list (sidebar, inbox, palette, grid, search, the agents' session tools and
@@ -111732,6 +111915,17 @@ var SessionManager = class {
    * tool, and **+ → Past conversations**, still have it.
    */
   async trashSession(sessionId, removeWorktree = false, removeExternal = false, recovery) {
+    const pending = this.trashing.get(sessionId);
+    if (pending) return pending;
+    const deleting = this.trashSessionOnce(sessionId, removeWorktree, removeExternal, recovery);
+    this.trashing.set(sessionId, deleting);
+    try {
+      await deleting;
+    } finally {
+      this.trashing.delete(sessionId);
+    }
+  }
+  async trashSessionOnce(sessionId, removeWorktree, removeExternal, recovery) {
     if (this.worktreeCleanup.has(sessionId) && !recovery) throw Object.assign(new Error("The session worktree is being removed"), { code: "internal" });
     const m = this.meta.get(sessionId);
     if (!m) {
@@ -114342,7 +114536,7 @@ ${list()}` : `${target.name} has no ordinary session. The person has to open one
    *   send    gives it more, including during the caller's turn on adapters that accept mid-turn input; refused
    *           while it works on the person's own message or has a higher preset than the caller
    *   stop    stops the turn the caller gave it; a turn the person started there is theirs
-   *   delete  sets aside local work in the trash, then removes an idle child's worktree and branch (#608)
+   *   delete  trashes a child without a worktree, stopping it first; worktree cleanup requires an idle child (#608)
    */
   async agentSession(callerId, opts, signal) {
     if (opts.sessionId === callerId && opts.action !== "status") {
@@ -114350,7 +114544,9 @@ ${list()}` : `${target.name} has no ordinary session. The person has to open one
     }
     const caller = this.meta.get(callerId);
     const child = this.meta.get(opts.sessionId);
-    if (!caller?.projectId || !child || child.askedBy !== callerId && !this.autoBoundaryOpen(callerId, "session ownership") || child.projectId !== caller.projectId) {
+    const deletingWithoutWorktree = opts.action === "delete" && !child?.worktree;
+    const startedHere = child?.askedBy === callerId || deletingWithoutWorktree && child?.parentSessionId === callerId;
+    if (!caller?.projectId || !child || !startedHere && (deletingWithoutWorktree || !this.autoBoundaryOpen(callerId, "session ownership")) || child.projectId !== caller.projectId) {
       return { ok: false, error: `${opts.sessionId} is not a session this session started. agent_session works only on sessions start_agent started here.` };
     }
     if (opts.sessionId === callerId) return this.agentAtRest(child);
@@ -114383,6 +114579,15 @@ ${list()}` : `${target.name} has no ordinary session. The person has to open one
           return { ok: true, state: "stopped", sessionId: child.id, sessionName: child.name, tool: child.tool };
         }
         case "delete": {
+          if (!child.worktree) {
+            const busy = child.state === "working" || child.state === "waiting_approval" || !!child.pendingApproval || child.pendingQuestions.length > 0 || this.agentRuns.has(child.id) && !this.agentRuns.get(child.id).finished;
+            if (!this.trashing.has(child.id) && busy && (!d2 || d2.settled || d2.callerId !== callerId)) {
+              return { ok: false, error: `"${child.name}" is busy with something else; the person may be using it. Wait for that turn and its pending approval or question to finish before deleting it.` };
+            }
+            await this.trashSession(child.id);
+            if (d2) this.delegations.delete(key);
+            return { ok: true, state: "deleted", sessionId: child.id, sessionName: child.name, tool: child.tool };
+          }
           if (d2 && !d2.settled) return { ok: false, error: `"${child.name}" is still working on what you gave it \u2014 stop it or wait first.` };
           const r = await this.cleanUpWorktreeChild(child);
           if (!r.ok) return r;
@@ -114468,6 +114673,9 @@ ${list()}` : `${target.name} has no ordinary session. The person has to open one
     if (target.state === "working" || target.state === "waiting_approval" || this.agentRuns.has(target.id) || sessionBusy({ ...target, live: this.handles.has(target.id) })) {
       return { ok: false, error: `"${target.name}" is still working \u2014 stop it or wait first` };
     }
+    if (!existsSync19(target.worktree.path)) {
+      return { ok: false, error: `The worktree folder for "${target.name}" is missing: ${target.worktree.path}. Restore the folder before cleanup; its branch has been left in place.` };
+    }
     if (this.resuming.has(target.id) || this.deferredRestarts.has(target.id)) return { ok: false, error: `"${target.name}" is waking or restarting \u2014 wait for it first` };
     if (this.worktreeCleanup.has(target.id)) return { ok: false, error: "This worktree is already being removed" };
     this.worktreeCleanup.add(target.id);
@@ -115355,8 +115563,8 @@ ${list()}` : `${target.name} has no ordinary session. The person has to open one
     return readMessageImage(abs);
   }
   repliesName(sessionId, written) {
-    const open5 = this.streams.get(sessionId);
-    if (open5?.kind === "text" && mentions(open5.text, written)) return true;
+    const open6 = this.streams.get(sessionId);
+    if (open6?.kind === "text" && mentions(open6.text, written)) return true;
     return writtenForms(written).some((form) => this.store.replyTextsContaining(sessionId, form).some((text2) => mentions(text2, written)));
   }
   /**
@@ -116558,9 +116766,9 @@ function broadcastAppChanges(send, windowMs = APP_CHANGE_WINDOW_MS) {
   return {
     emit(ref, cause2 = null) {
       const key = JSON.stringify([ref.projectId, ref.appId]);
-      const open5 = pending.get(key);
-      if (open5) {
-        if (!sameCause(open5.cause, cause2)) open5.cause = null;
+      const open6 = pending.get(key);
+      if (open6) {
+        if (!sameCause(open6.cause, cause2)) open6.cause = null;
         return;
       }
       const timer = setTimeout(() => {
@@ -117026,6 +117234,8 @@ var REGISTRY_URL = `https://registry.npmjs.org/${APP_SLUG}/latest`;
 var CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
 var SCHEDULED_TIMEOUT_MS = 3e3;
 var FORCED_TIMEOUT_MS = 8e3;
+var INSTALL_CHECK_MAX_AGE_MS = 6e4;
+var STORED_RELEASE_MAX_AGE_MS = 60 * 60 * 1e3;
 var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
 var NPM_RETRY_DELAY_MS = 3e4;
 var NPM_RETRY_WINDOW_MS = 10 * 60 * 1e3;
@@ -117106,6 +117316,8 @@ var UpdateService = class {
   }
   publish;
   status;
+  stopped = false;
+  installing = false;
   timer = null;
   deps;
   /** One check at a time — the timer and the button can land together */
@@ -117121,16 +117333,22 @@ var UpdateService = class {
    * closed while releases happened.
    */
   start() {
+    this.stopped = false;
     if (!this.status.auto) return;
     void this.check(false);
     this.startTimer();
   }
+  /** Shutdown (including a host swap): no asynchronous continuation may start more work. */
   stop() {
+    this.stopped = true;
+    this.stopTimer();
+  }
+  stopTimer() {
     if (this.timer) clearInterval(this.timer);
     this.timer = null;
   }
   startTimer() {
-    this.stop();
+    this.stopTimer();
     this.timer = setInterval(() => void this.check(false), CHECK_INTERVAL_MS);
     this.timer.unref?.();
   }
@@ -117146,7 +117364,7 @@ var UpdateService = class {
     this.status = { ...this.status, auto: enabled };
     this.deps.writeAuto(enabled);
     if (!enabled) {
-      this.stop();
+      this.stopTimer();
       this.emit();
       return this.current();
     }
@@ -117183,32 +117401,36 @@ var UpdateService = class {
    * failed, nothing about a background failure interrupts anyone.
    */
   async check(force) {
+    if (this.stopped || this.installing) return this.current();
     if (this.inFlight) return this.inFlight;
     if (!force && !this.status.auto) return this.current();
     if (!force && this.status.checkedAt !== null && !this.isDue()) return this.current();
     if (this.status.phase === "updating" || this.status.phase === "waiting_for_npm" || this.status.phase === "restart_required") return this.current();
-    this.status = { ...this.status, phase: "checking" };
+    const failure3 = this.status.phase === "failed" ? { error: this.status.error } : null;
+    if (!failure3) this.status = { ...this.status, phase: "checking" };
     this.emit();
-    this.inFlight = this.runCheck(force);
+    this.inFlight = this.runCheck(force, failure3);
     try {
       return await this.inFlight;
     } finally {
       this.inFlight = null;
     }
   }
-  async runCheck(force) {
+  async runCheck(force, failure3) {
     const res = await this.deps.fetchLatest(force ? FORCED_TIMEOUT_MS : SCHEDULED_TIMEOUT_MS);
+    if (this.stopped || this.installing) return this.current();
     if (!res.ok) {
-      this.status = { ...this.status, phase: "idle", error: res.reason };
+      this.status = { ...this.status, phase: failure3 ? "failed" : "idle", error: failure3 ? failure3.error : res.reason };
       this.emit();
       return this.current();
     }
+    const latest = res.version;
     this.status = {
       ...this.status,
-      latest: res.version,
-      newer: isNewerVersion(res.version, this.status.current),
-      phase: "idle",
-      error: null,
+      latest,
+      newer: isNewerVersion(latest, this.status.current),
+      phase: failure3 ? "failed" : "idle",
+      error: failure3?.error ?? null,
       checkedAt: this.deps.now()
     };
     this.emit();
@@ -117224,13 +117446,14 @@ var UpdateService = class {
    * rest of the story arrives as `update_status` events.
    */
   apply() {
-    if (this.status.phase === "updating" || this.status.phase === "waiting_for_npm") return this.current();
+    if (this.stopped || this.installing || this.status.phase === "restart_required") return this.current();
     const latest = this.status.latest;
     if (!this.status.newer || !latest) {
       this.status = { ...this.status, phase: "failed", error: "There is no newer version to install" };
       this.emit();
       return this.current();
     }
+    this.installing = true;
     this.status = { ...this.status, phase: "updating", error: null };
     this.emit();
     void this.runApply(latest);
@@ -117240,16 +117463,42 @@ var UpdateService = class {
     let packageInstalled = false;
     const copy = this.deps.installedCopy();
     try {
+      await this.inFlight;
+      if (this.stopped) return;
+      const age2 = this.status.checkedAt === null ? Infinity : this.deps.now() - this.status.checkedAt;
+      if (age2 < 0 || age2 >= INSTALL_CHECK_MAX_AGE_MS) {
+        const fresh = await this.deps.fetchLatest(FORCED_TIMEOUT_MS);
+        if (this.stopped) return;
+        if (fresh.ok) {
+          const now = this.deps.now();
+          const storedAge = this.status.checkedAt === null ? Infinity : now - this.status.checkedAt;
+          const keepStored = storedAge >= 0 && storedAge < STORED_RELEASE_MAX_AGE_MS && isNewerVersion(version2, fresh.version);
+          if (!keepStored) version2 = fresh.version;
+          this.status = { ...this.status, latest: version2, newer: isNewerVersion(version2, this.status.current), checkedAt: keepStored ? this.status.checkedAt : now };
+          if (!this.status.newer) {
+            this.status = { ...this.status, phase: "idle", error: null };
+            return;
+          }
+        } else {
+          this.status = { ...this.status, error: `Could not refresh latest (${fresh.reason}); using previously checked ${version2}.` };
+        }
+      }
+      this.emit();
       await this.installPackage(version2);
+      if (this.stopped) return;
       packageInstalled = true;
       if (copy) await this.deps.run(APP_SLUG, ["install"]);
-      this.status = { ...this.status, phase: "restart_required", error: null };
+      if (this.stopped) return;
+      this.status = { ...this.status, phase: "restart_required" };
     } catch (e) {
+      if (this.stopped) return;
       const reason = e.message;
       const error51 = packageInstalled ? `npm installed ${version2}, but the copy at ${copy} was not replaced (${reason}). Quit ${APP_NAME}, then run "${APP_SLUG} install" in a terminal.` : reason;
       this.status = { ...this.status, phase: "failed", error: error51 };
+    } finally {
+      this.installing = false;
+      if (!this.stopped) this.emit();
     }
-    this.emit();
   }
   /**
    * A just-published release can be visible from `latest` before its package is on the npm edge
@@ -117259,16 +117508,20 @@ var UpdateService = class {
    */
   async installPackage(version2) {
     const started = this.deps.now();
+    const notice = this.status.error;
     for (; ; ) {
+      if (this.stopped) return;
       try {
         await this.deps.run("npm", ["i", "-g", "--prefer-online", `${APP_SLUG}@${version2}`]);
         return;
       } catch (err) {
+        if (this.stopped) return;
         if (!npmHasNotServedVersion(err) || this.deps.now() - started >= NPM_RETRY_WINDOW_MS) throw err;
-        this.status = { ...this.status, phase: "waiting_for_npm", error: `Waiting for npm to serve ${version2}` };
+        this.status = { ...this.status, phase: "waiting_for_npm", error: `Waiting for npm to serve ${version2}${notice ? `. ${notice}` : ""}` };
         this.emit();
         await this.deps.wait(NPM_RETRY_DELAY_MS);
-        this.status = { ...this.status, phase: "updating", error: null };
+        if (this.stopped) return;
+        this.status = { ...this.status, phase: "updating", error: notice };
         this.emit();
       }
     }
@@ -118159,7 +118412,7 @@ async function verifiedPackage(name, version2, opts = {}) {
 }
 
 // packages/agent-host/src/links/tunnel.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } 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);
@@ -118423,7 +118676,7 @@ var SshTunnel = class {
   }
   run(args, stdin) {
     return new Promise((resolve12, reject) => {
-      const child = spawn5(this.opts.ssh ?? "ssh", args, { env: this.opts.env ?? process.env, stdio: [stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"] });
+      const child = spawn6(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", () => {
         });
@@ -118482,7 +118735,7 @@ var SshTunnel = class {
       this.opts.target,
       ...keepAlive ? [keepAlive] : []
     ];
-    const child = spawn5(this.opts.ssh ?? "ssh", args, { env: this.opts.env ?? process.env, stdio: ["ignore", "ignore", "pipe"] });
+    const child = spawn6(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));
@@ -118834,7 +119087,7 @@ async function removeAutostart(c) {
 }
 
 // packages/agent-host/src/links/probe.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 var PROBE_MARK = "CENTRALU-PROBE";
 var PROBE_PS = [
   "$ErrorActionPreference = 'SilentlyContinue'",
@@ -118889,7 +119142,7 @@ function probeTarget(target, opts = {}) {
       clearTimeout(timer);
       resolve12(parseProbe(t, run));
     };
-    const child = spawn6(opts.ssh ?? "ssh", args, { env: opts.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn7(opts.ssh ?? "ssh", args, { env: opts.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
       finish2({ code: 255, stdout: "", stderr: `ssh to ${t} did not answer in time` });
@@ -118902,7 +119155,7 @@ function probeTarget(target, opts = {}) {
 }
 
 // packages/agent-host/src/links/ssh-config.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { readdirSync as readdirSync8, readFileSync as readFileSync15, statSync as statSync13 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 import { isAbsolute as isAbsolute10, join as join32, normalize, parse as parse6, sep as sep12 } from "node:path";
@@ -119077,7 +119330,7 @@ function resolveAlias(alias, opts = {}) {
       resolve12(r);
     };
     const none = (error51) => ({ hostName: null, user: null, port: null, error: error51 });
-    const child = spawn7(opts.ssh ?? "ssh", args, { env: opts.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn8(opts.ssh ?? "ssh", args, { env: opts.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
       finish2(none("ssh -G did not answer"));
@@ -121198,7 +121451,7 @@ function storeMirror(store2) {
 var start = new StartSequence();
 start.at("launch variables");
 var launch = takeLaunchEnv();
-var BUILD = true ? "5dca7b8" : "dev";
+var BUILD = true ? "8dd78b6" : "dev";
 var { values } = parseArgs({
   options: {
     port: { type: "string", default: "5175" },

package/package.json

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