@centralu/darwin-arm64 0.1.0-beta.37 → 0.1.0-beta.39

package/Centralu.app/Contents/Resources/resources/host/main.mjs

@@ -43053,9 +43053,11 @@ import { hostname as hostname5 } from "node:os";
 import { dirname as dirname23, join as join52 } from "node:path";
 import { mkdirSync as mkdirSync19, writeSync as writeSync3 } from "node:fs";
 
+// packages/protocol/src/version.generated.ts
+var APP_VERSION = "0.1.0-beta.39";
+
 // packages/protocol/src/brand.ts
 var APP_NAME = "Centralu";
-var APP_VERSION = "0.1.0-beta.37";
 var APP_SLUG = "centralu";
 var CLIENT_INFO = { name: APP_SLUG, title: APP_NAME, version: APP_VERSION };
 var DATA_DIR = ".centralu";
@@ -59749,7 +59751,18 @@ var NormalizedEvent = external_exports.discriminatedUnion("type", [
      * The model the tool resolved the session's model name to (Claude's CLI: an alias such as `haiku` or the project's default
      * names a different model over time), when it says. With the window it is what `ModelWindows` keeps per model (#1376).
      */
-    model: external_exports.string().optional()
+    model: external_exports.string().optional(),
+    /**
+     * (#1553) `window` is the model's full context window as the host says it, so the share is used / the model's window whatever
+     * the tool reported (Claude's CLI reports the smaller of the model's window and the compaction point it was started with).
+     * The host sets `window` and `capped`; `capped`: the full window is not known (an adopted process with no kept ceiling, a model
+     * name that moved to another model), so `window` is only the tool's own reading, a floor under the model's.
+     * `compactAt`: the size in tokens at which this session's process compacts by itself, said by the adapter of a process Centralu's
+     * control started (Claude: the CLI's own threshold from every reading; Codex: the limit it was started with). The host drops one
+     * that is not under `window`.
+     */
+    capped: external_exports.boolean().optional(),
+    compactAt: external_exports.number().optional()
   }),
   external_exports.object({
     ...base,
@@ -60549,7 +60562,16 @@ var SessionInfo = external_exports.object({
    * tool and outlives us. So the store writes it down and reads it back (schema v17), and
    * `null` here means "this session has never reported one" rather than "we forgot".
    */
-  context: external_exports.object({ used: external_exports.number(), window: external_exports.number(), exactness: external_exports.enum(["exact", "estimate"]) }).nullable().default(null)
+  context: external_exports.object({
+    used: external_exports.number(),
+    /** The model's full window when known (`capped` absent), else the tool's own reading of it (#1553, `contextShare`) */
+    window: external_exports.number(),
+    exactness: external_exports.enum(["exact", "estimate"]),
+    /** `window` is a floor under the model's window, not the window itself */
+    capped: external_exports.boolean().optional(),
+    /** The size in tokens at which the session's process compacts by itself, when Centralu's control started it */
+    compactAt: external_exports.number().optional()
+  }).nullable().default(null)
 });
 var SettingsApplied = external_exports.enum(["restarted", "after_turn", "saved"]);
 var UpdateSettingsResult = SessionInfo.extend({ applied: SettingsApplied.optional() });
@@ -62458,6 +62480,17 @@ var sessionMethods = {
     params: external_exports.object({ sessionId: SessionId, seq: external_exports.number() }),
     result: external_exports.object({ ok: external_exports.literal(true) })
   },
+  /**
+   * Done on a session in `error` (#1549): it moves to `idle` and what the person saw is read, so the sidebar's mark and the
+   * inbox row go. `seq` is the newest row the window had: the error is cleared only when nothing newer exists (a later error
+   * the person has not seen stays), and rows up to `seq` are read either way. `cleared` says whether the state moved, `newer` that it stayed `error` because a newer row exists. A session
+   * not in `error` keeps its state (its rows up to `seq` are read). Nothing is stopped, retried or continued, and the error
+   * line stays in the conversation. The person's alone (the window): an agent's script may not hide a failure.
+   */
+  "sessions.clearError": {
+    params: external_exports.object({ sessionId: SessionId, seq: external_exports.number() }),
+    result: external_exports.object({ ok: external_exports.literal(true), cleared: external_exports.boolean(), newer: external_exports.boolean().default(false) })
+  },
   "messages.load": {
     params: external_exports.object({ sessionId: SessionId, limit: external_exports.number().default(200), beforeSeq: external_exports.number().optional() }),
     result: external_exports.array(StoredMessage)
@@ -63463,12 +63496,12 @@ function applySessionState(m, e, now) {
 function nextContext(context, e) {
   switch (e.type) {
     case "context_update":
-      return { used: e.used, window: e.window, exactness: e.exactness };
+      return { used: e.used, window: e.window, exactness: e.exactness, ...e.capped ? { capped: true } : {}, ...e.compactAt !== void 0 ? { compactAt: e.compactAt } : {} };
     case "conversation_reset":
       return null;
     case "compaction":
       if (e.failed || e.after === void 0 || !context) return context;
-      return { used: e.after, window: context.window, exactness: "estimate" };
+      return { ...context, used: e.after, exactness: "estimate" };
     default:
       return context;
   }
@@ -65186,6 +65219,8 @@ var METHOD_RIGHTS = {
   "sessions.list": "everyday",
   "sessions.rename": "everyday",
   "sessions.markRead": "everyday",
+  // Hiding a failure is the person's (an agent's script may not clear what went wrong with it)
+  "sessions.clearError": "window",
   // The trash: reading and restoring run; deleting for good asks
   "trash.list": "everyday",
   "trash.readRun": "everyday",
@@ -103624,6 +103659,19 @@ var ModelWindows = class {
     if (known && known.window === window2 && known.model === (resolved ?? null)) return;
     this.write(key, { window: window2, model: resolved ?? null });
   }
+  /**
+   * The window a session's context share is read against (#1553): the model's full window, whatever the process reported. Asked
+   * right after `note` took the same reading. A reading under the process's ceiling is the model's own window; one at it is a
+   * floor, and the model's window is then what `note` kept (the record for this model), or unknown: the reading stands in as
+   * `capped`, which the screen says. A tool with no ceiling (Codex, a process started without the setting) reports the model's own.
+   */
+  shareWindow(m, reported) {
+    const ceiling = this.ceilings.get(m.id);
+    const atCeiling = ceiling === "unknown" || ceiling !== void 0 && reported >= ceiling;
+    const known = atCeiling ? this.of(m) : null;
+    if (!atCeiling) return { window: reported, capped: false };
+    return known === null ? { window: reported, capped: true } : { window: Math.max(known, reported), capped: false };
+  }
   /** The model's window, or null when no session has read one */
   of(m) {
     return this.read(this.key(m))?.window ?? null;
@@ -104106,7 +104154,7 @@ var NOT_CONNECTED = "not connected until the person connects it";
 var NOT_CONNECTED_PHRASE = "is not connected, and nothing here connects it by itself; ask the person to connect it (Settings, Machines, Connect)";
 function awayPhrase(why) {
   if (why === NOT_CONNECTED) return NOT_CONNECTED_PHRASE;
-  return why === NOT_REACHABLE ? `is ${NOT_REACHABLE}` : `could not be asked just now (${why})`;
+  return why === NOT_REACHABLE || why.startsWith(`${NOT_REACHABLE};`) ? `is ${why}` : `could not be asked just now (${why})`;
 }
 
 // packages/agent-host/src/adapters/contract/surface.ts
@@ -104115,6 +104163,168 @@ var SURFACE_KINDS = ["command", "message", "capability"];
 // packages/agent-host/src/adapters/contract.ts
 var INTERRUPTED_BY_TOOL = "interrupted_by_tool";
 
+// packages/agent-host/src/sessions/ask-project.ts
+import { realpathSync as realpathSync3, statSync as statSync8 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
+
+// packages/agent-host/src/sessions/turn-answer.ts
+function turnAnswer(messages2, opts = {}) {
+  const parts = [];
+  for (let i = messages2.length - 1; i >= 0; i--) {
+    const m = messages2[i];
+    if (opts.afterSeq !== void 0 && m.seq <= opts.afterSeq) break;
+    if (m.role === "assistant" && m.kind === "reasoning") continue;
+    if (m.role === "assistant" && m.kind === "text") {
+      parts.unshift(String(m.payload.text ?? ""));
+      continue;
+    }
+    break;
+  }
+  return parts.join("\n\n").trim();
+}
+function turnAnswerSeq(messages2, opts = {}) {
+  let first = null;
+  for (let i = messages2.length - 1; i >= 0; i--) {
+    const m = messages2[i];
+    if (opts.afterSeq !== void 0 && m.seq <= opts.afterSeq) break;
+    if (m.role === "assistant" && m.kind === "reasoning") continue;
+    if (m.role === "assistant" && m.kind === "text") {
+      first = m.seq;
+      continue;
+    }
+    break;
+  }
+  return first;
+}
+function lastResponseSeq(messages2) {
+  let end = messages2.length;
+  while (end > 0 && !(messages2[end - 1].role === "assistant" && messages2[end - 1].kind === "text")) end--;
+  return turnAnswerSeq(messages2.slice(0, end));
+}
+function lastResponse(messages2) {
+  let end = messages2.length;
+  while (end > 0 && !(messages2[end - 1].role === "assistant" && messages2[end - 1].kind === "text")) end--;
+  return turnAnswer(messages2.slice(0, end));
+}
+function clipPreview(text2, max) {
+  return text2.length > max ? `${text2.slice(0, max)}\u2026` : text2;
+}
+
+// packages/agent-host/src/sessions/ask-project.ts
+var ASK_WAIT_MS = 24e4;
+var ANSWER_READ_MAX_CHARS = 1e5;
+var ANSWER_MAX_CHARS = 6e3;
+var ANSWER_HEAD_CHARS = 4500;
+var ANSWER_TAIL_CHARS = 1200;
+function taskLine(task, max = 160) {
+  const flat = oneLineText(task);
+  return flat.length > max ? `${flat.slice(0, max)}\u2026 (cut here; ${flat.length} characters in all)` : flat;
+}
+function askFrame(callerProject, task, asker) {
+  const who = asker ? ` It is the session ${JSON.stringify(frameField(asker.name))}${asker.sessionId ? ` [${asker.sessionId}]` : ""}.` : "";
+  return [
+    `[A session in the project "${frameField(callerProject)}" asks this project, through Centralu's ask_project.${who} Your final message goes back to it as the answer: keep it short, and name every file it should read by its absolute path.]`,
+    "",
+    task
+  ].join("\n");
+}
+function projectChoice(p) {
+  return `${p.name} [${p.id}] on ${p.machine ?? "this computer"}`;
+}
+function matchProjects(asked, projects, o = {}) {
+  const wanted = asked.trim();
+  const firstPerMachine = (found) => {
+    if (o.everyOne) return found;
+    const seen = /* @__PURE__ */ new Set();
+    return found.filter((p) => !seen.has(p.machineId) && !!seen.add(p.machineId));
+  };
+  const tiers = [
+    () => projects.filter((p) => p.id === wanted),
+    () => projects.filter((p) => p.name === wanted),
+    () => {
+      const slash = wanted.indexOf("/");
+      if (slash <= 0) return [];
+      const machine = wanted.slice(0, slash).trim().toLowerCase();
+      const name = wanted.slice(slash + 1).trim();
+      const there = projects.filter((p) => p.machineId !== null && (p.machineId === machine || p.machine?.toLowerCase() === machine));
+      return there.some((p) => p.name === name) ? there.filter((p) => p.name === name) : there.filter((p) => p.name.toLowerCase() === name.toLowerCase());
+    },
+    () => projects.filter((p) => p.name.toLowerCase() === wanted.toLowerCase())
+  ];
+  for (const tier of tiers) {
+    const found = firstPerMachine(tier());
+    if (found.length) return found;
+  }
+  return [];
+}
+function clipAnswer(answer, sessionName, at2) {
+  if (answer.length <= ANSWER_MAX_CHARS) return answer;
+  const cut2 = answer.length - ANSWER_HEAD_CHARS - ANSWER_TAIL_CHARS;
+  const where2 = at2 ? `read them with read_session(sessionId="${at2.sessionId}", around=${at2.seq}, offset=${ANSWER_HEAD_CHARS})` : `the whole answer is in the session "${sessionName}"`;
+  return answer.slice(0, ANSWER_HEAD_CHARS) + `
+\u2026[${cut2} characters cut here; ${where2}]\u2026
+` + answer.slice(-ANSWER_TAIL_CHARS);
+}
+function answerAt(reader, sessionId, answer) {
+  const rows3 = reader.loadMessages(sessionId, 50);
+  const seq = turnAnswerSeq(rows3);
+  return seq !== null && answer && turnAnswer(rows3) === answer ? { sessionId, seq } : void 0;
+}
+function pathsIn(answer) {
+  const found = [];
+  const re2 = /(?:^|[\s"'`(<[])((?:\/|[A-Za-z]:\\)[^\s"'`)>\]]+)/g;
+  for (const m of answer.matchAll(re2)) {
+    const p = m[1].replace(/[.,;:!?]+$/, "");
+    if (p === "/" || /^[A-Za-z]:\\?$/.test(p)) continue;
+    if (!found.includes(p)) found.push(p);
+  }
+  return found;
+}
+function real(p) {
+  try {
+    return realpathSync3.native(p);
+  } catch {
+    return null;
+  }
+}
+function readableGrants(paths, projectRoot) {
+  const root3 = real(projectRoot);
+  const granted = [];
+  const outside = [];
+  for (const p of paths) {
+    const r = real(p);
+    if (!root3 || !r || !isInside(root3, r)) {
+      outside.push(p);
+      continue;
+    }
+    let dir = false;
+    try {
+      dir = statSync8(r).isDirectory();
+    } catch {
+      outside.push(p);
+      continue;
+    }
+    if (dir && r === root3) {
+      outside.push(p);
+      continue;
+    }
+    if (!granted.includes(r)) granted.push(r);
+  }
+  return { granted, outside };
+}
+function underGrant(path2, grants, cwd) {
+  const r = canonicalPath(resolve7(cwd, path2));
+  for (const g5 of grants) if (isInside(g5, r)) return true;
+  return false;
+}
+function awayFor(wanted, away, known) {
+  const slash = wanted.indexOf("/");
+  const prefix = slash > 0 ? wanted.slice(0, slash).trim().toLowerCase() : null;
+  const byId = [...known, ...away.map((a) => a.machineId)].some((id3) => wanted.startsWith(`${id3}.`));
+  if (prefix === null && !byId) return [...away];
+  return away.filter((a) => a.machineId === prefix || a.machine.toLowerCase() === prefix || wanted.startsWith(`${a.machineId}.`));
+}
+
 // packages/agent-host/src/sessions/app-agents.ts
 var AgentRunWait = class {
   constructor(notify, sessionName, onUsage = () => {
@@ -104221,11 +104431,11 @@ var AgentRunWait = class {
 
 // packages/agent-host/src/sessions/worktree-sessions.ts
 import { dirname as dirname14, join as join27 } from "node:path";
-import { lstatSync as lstatSync8, statSync as statSync8 } from "node:fs";
+import { lstatSync as lstatSync8, statSync as statSync9 } from "node:fs";
 import { exec as exec2 } from "node:child_process";
 
 // packages/agent-host/src/dev-services/git.ts
-import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve7 } from "node:path";
+import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve8 } from "node:path";
 function git(cwd, args, trust = {}) {
   return runGit(cwd, args, { allowRepoPrograms: trust.trusted === true });
 }
@@ -104319,8 +104529,8 @@ function assertLexicalGitPath(cwd, path2) {
   if (!path2 || path2.includes("\0") || path2.startsWith(":")) {
     throw rpcError("Invalid git path");
   }
-  const root3 = resolve7(cwd);
-  const target = isAbsolute3(path2) ? resolve7(path2) : resolve7(root3, path2);
+  const root3 = resolve8(cwd);
+  const target = isAbsolute3(path2) ? resolve8(path2) : resolve8(root3, path2);
   const rel = relative2(root3, target);
   if (rel === "") throw rpcError("Path is the project root, not a file in it");
   if (isInside(root3, target)) return rel;
@@ -104830,7 +105040,7 @@ async function prepareWorktreeDependencies(projectCwd, worktreeCwd) {
 // packages/agent-host/src/adapters/edit-grant.ts
 import { lstat as lstat7, realpath as realpath5 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname13, isAbsolute as isAbsolute4, join as join26, relative as relative3, resolve as resolve8, sep as sep4 } from "node:path";
+import { dirname as dirname13, isAbsolute as isAbsolute4, join as join26, relative as relative3, resolve as resolve9, sep as sep4 } from "node:path";
 var PROTECTED_NAMES = /* @__PURE__ */ new Set([
   ".git",
   ".gitconfig",
@@ -104866,7 +105076,7 @@ var PROTECTED_NAMES = /* @__PURE__ */ new Set([
 var PROTECTED_PAIRS = [[".github", "workflows"], [".cargo", "config"], [".cargo", "config.toml"]];
 async function realPathOf(path2) {
   const tail = [];
-  let at2 = resolve8(path2);
+  let at2 = resolve9(path2);
   for (; ; ) {
     try {
       return join26(await realpath5(at2), ...tail.reverse());
@@ -104893,7 +105103,7 @@ async function insideFolder(folder, targets) {
   }
   for (const target of targets) {
     if (!target) return false;
-    const real3 = await realPathOf(resolve8(folder, target));
+    const real3 = await realPathOf(resolve9(folder, target));
     if (real3 === null) return false;
     const inside2 = relative3(root3, real3);
     if (inside2 === "" || isAbsolute4(inside2) || inside2 === ".." || inside2.startsWith(`..${sep4}`)) return false;
@@ -105132,7 +105342,7 @@ function worktreeFolderState(path2) {
   }
   const parent = dirname14(path2);
   try {
-    if (statSync8(parent).isDirectory()) return "gone";
+    if (statSync9(parent).isDirectory()) return "gone";
     return { unreachable: `${parent} is not a folder` };
   } catch (e) {
     return { unreachable: `${parent} cannot be read (${e.code ?? "error"}), so the folder may be on a volume that is not mounted` };
@@ -105600,49 +105810,6 @@ function scriptLabel(raw) {
   return plain3 || "unnamed";
 }
 
-// packages/agent-host/src/sessions/turn-answer.ts
-function turnAnswer(messages2, opts = {}) {
-  const parts = [];
-  for (let i = messages2.length - 1; i >= 0; i--) {
-    const m = messages2[i];
-    if (opts.afterSeq !== void 0 && m.seq <= opts.afterSeq) break;
-    if (m.role === "assistant" && m.kind === "reasoning") continue;
-    if (m.role === "assistant" && m.kind === "text") {
-      parts.unshift(String(m.payload.text ?? ""));
-      continue;
-    }
-    break;
-  }
-  return parts.join("\n\n").trim();
-}
-function turnAnswerSeq(messages2, opts = {}) {
-  let first = null;
-  for (let i = messages2.length - 1; i >= 0; i--) {
-    const m = messages2[i];
-    if (opts.afterSeq !== void 0 && m.seq <= opts.afterSeq) break;
-    if (m.role === "assistant" && m.kind === "reasoning") continue;
-    if (m.role === "assistant" && m.kind === "text") {
-      first = m.seq;
-      continue;
-    }
-    break;
-  }
-  return first;
-}
-function lastResponseSeq(messages2) {
-  let end = messages2.length;
-  while (end > 0 && !(messages2[end - 1].role === "assistant" && messages2[end - 1].kind === "text")) end--;
-  return turnAnswerSeq(messages2.slice(0, end));
-}
-function lastResponse(messages2) {
-  let end = messages2.length;
-  while (end > 0 && !(messages2[end - 1].role === "assistant" && messages2[end - 1].kind === "text")) end--;
-  return turnAnswer(messages2.slice(0, end));
-}
-function clipPreview(text2, max) {
-  return text2.length > max ? `${text2.slice(0, max)}\u2026` : text2;
-}
-
 // packages/agent-host/src/sessions/transcript-view.ts
 var MEMORY_MESSAGES = 40;
 var MEMORY_LINE_CHARS = 600;
@@ -106011,10 +106178,29 @@ function orchestratorToolsFor(host, orchestratorId, scopeIds, ownProject, hubVie
     },
     createSession: async (opts) => {
       const all = host.store.projects.listProjects();
-      const local = all.filter((p) => p.id === opts.project || p.name === opts.project);
       const reader = linked();
-      const exactHere = all.some((p) => p.id === opts.project);
-      const remote = reader && opts.project && !exactHere ? await reader.findProjects(opts.project) : [];
+      const wanted = (opts.project ?? "").trim();
+      const exactHere = all.some((p) => p.id === wanted);
+      const found = (machineProjects) => matchProjects(
+        wanted,
+        [
+          ...all.map((p) => ({ id: p.id, name: p.name, machine: null, machineId: null })),
+          ...machineProjects.map((p) => ({ id: p.id, name: p.name, machine: p.machine, machineId: p.machineId }))
+        ],
+        { everyOne: true }
+      );
+      let there = reader && wanted && !exactHere ? await reader.projects({ ref: wanted }) : null;
+      let matched = found(there?.projects ?? []);
+      if (reader && there && !matched.length) {
+        there = await reader.projects({ ref: wanted, anyDown: true, prior: there });
+        matched = found(there.projects);
+      }
+      const local = matched.flatMap((m) => all.filter((p) => m.machineId === null && p.id === m.id));
+      const remote = matched.flatMap((m) => (there?.projects ?? []).filter((p) => m.machineId !== null && p.id === m.id));
+      const missing = there && !matched.length ? awayFor(wanted, there.away, there.machines.map((m) => m.machineId)) : [];
+      if (missing.length) {
+        return { ok: false, error: `No such project: ${wanted}. Not asked, and its projects may be missing: ${missing.map((a) => `${a.machine} (${a.why})`).join(", ")}.` };
+      }
       if (local.length + remote.length > 1) {
         const named = [
           ...local.map((p) => `${p.name} [${p.id}] on this computer`),
@@ -106494,8 +106680,8 @@ function askedQuestion(asker, act) {
 }
 
 // packages/agent-host/src/sessions/asked-reach.ts
-import { realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname15, isAbsolute as isAbsolute5, join as join28, relative as relative4, resolve as resolve9 } from "node:path";
+import { realpathSync as realpathSync4 } from "node:fs";
+import { dirname as dirname15, isAbsolute as isAbsolute5, join as join28, relative as relative4, resolve as resolve10 } from "node:path";
 var GIVES_NOTHING = /* @__PURE__ */ new Set([
   "Write",
   "Edit",
@@ -106556,15 +106742,15 @@ function globPaths(path2, pattern) {
   return out.length > 0 ? out : [""];
 }
 function pinned(scope) {
-  return "paths" in scope ? { paths: scope.paths, real: scope.paths.map((p) => isAbsolute5(p) ? real(p) : p) } : scope;
+  return "paths" in scope ? { paths: scope.paths, real: scope.paths.map((p) => isAbsolute5(p) ? real2(p) : p) } : scope;
 }
-function real(path2) {
-  const full = resolve9(path2);
+function real2(path2) {
+  const full = resolve10(path2);
   let existing = full;
   const rest = [];
   for (let i = 0; i < 64; i++) {
     try {
-      return join28(realpathSync3.native(existing), ...rest);
+      return join28(realpathSync4.native(existing), ...rest);
     } catch {
       const up2 = dirname15(existing);
       if (up2 === existing) return full;
@@ -106593,10 +106779,10 @@ function outOfReach(name, scope, reach, projectOf) {
     const mine = [reach.project, reach.projectName].filter((p) => typeof p === "string" && p !== "");
     return mine.some((p) => p.toLowerCase() === asked) ? null : named(scope.project ?? "");
   }
-  const folders = reach.folders.filter((f) => isAbsolute5(f)).map(real);
+  const folders = reach.folders.filter((f) => isAbsolute5(f)).map(real2);
   for (const [i, path2] of scope.paths.entries()) {
     if (!isAbsolute5(path2)) return path2 === "" ? name : named(path2);
-    const there = scope.real?.[i] ?? real(path2);
+    const there = scope.real?.[i] ?? real2(path2);
     if (!folders.some((f) => inside(f, there))) return named(path2);
   }
   return null;
@@ -106734,114 +106920,6 @@ function withHubMark(settings, info) {
 // packages/agent-host/src/sessions/queued-requests.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
 
-// packages/agent-host/src/sessions/ask-project.ts
-import { realpathSync as realpathSync4, statSync as statSync9 } from "node:fs";
-import { resolve as resolve10 } from "node:path";
-var ASK_WAIT_MS = 24e4;
-var ANSWER_READ_MAX_CHARS = 1e5;
-var ANSWER_MAX_CHARS = 6e3;
-var ANSWER_HEAD_CHARS = 4500;
-var ANSWER_TAIL_CHARS = 1200;
-function taskLine(task, max = 160) {
-  const flat = oneLineText(task);
-  return flat.length > max ? `${flat.slice(0, max)}\u2026 (cut here; ${flat.length} characters in all)` : flat;
-}
-function askFrame(callerProject, task, asker) {
-  const who = asker ? ` It is the session ${JSON.stringify(frameField(asker.name))}${asker.sessionId ? ` [${asker.sessionId}]` : ""}.` : "";
-  return [
-    `[A session in the project "${frameField(callerProject)}" asks this project, through Centralu's ask_project.${who} Your final message goes back to it as the answer: keep it short, and name every file it should read by its absolute path.]`,
-    "",
-    task
-  ].join("\n");
-}
-function projectChoice(p) {
-  return `${p.name} [${p.id}] on ${p.machine ?? "this computer"}`;
-}
-function matchProjects(wanted, projects) {
-  const firstPerMachine = (found) => {
-    const seen = /* @__PURE__ */ new Set();
-    return found.filter((p) => !seen.has(p.machineId) && !!seen.add(p.machineId));
-  };
-  const tiers = [
-    () => projects.filter((p) => p.id === wanted),
-    () => projects.filter((p) => p.name === wanted),
-    () => {
-      const slash = wanted.indexOf("/");
-      if (slash <= 0) return [];
-      const machine = wanted.slice(0, slash).trim().toLowerCase();
-      const name = wanted.slice(slash + 1).trim();
-      const there = projects.filter((p) => p.machineId !== null && (p.machineId === machine || p.machine?.toLowerCase() === machine));
-      return there.some((p) => p.name === name) ? there.filter((p) => p.name === name) : there.filter((p) => p.name.toLowerCase() === name.toLowerCase());
-    },
-    () => projects.filter((p) => p.name.toLowerCase() === wanted.toLowerCase())
-  ];
-  for (const tier of tiers) {
-    const found = firstPerMachine(tier());
-    if (found.length) return found;
-  }
-  return [];
-}
-function clipAnswer(answer, sessionName, at2) {
-  if (answer.length <= ANSWER_MAX_CHARS) return answer;
-  const cut2 = answer.length - ANSWER_HEAD_CHARS - ANSWER_TAIL_CHARS;
-  const where2 = at2 ? `read them with read_session(sessionId="${at2.sessionId}", around=${at2.seq}, offset=${ANSWER_HEAD_CHARS})` : `the whole answer is in the session "${sessionName}"`;
-  return answer.slice(0, ANSWER_HEAD_CHARS) + `
-\u2026[${cut2} characters cut here; ${where2}]\u2026
-` + answer.slice(-ANSWER_TAIL_CHARS);
-}
-function answerAt(reader, sessionId, answer) {
-  const rows3 = reader.loadMessages(sessionId, 50);
-  const seq = turnAnswerSeq(rows3);
-  return seq !== null && answer && turnAnswer(rows3) === answer ? { sessionId, seq } : void 0;
-}
-function pathsIn(answer) {
-  const found = [];
-  const re2 = /(?:^|[\s"'`(<[])((?:\/|[A-Za-z]:\\)[^\s"'`)>\]]+)/g;
-  for (const m of answer.matchAll(re2)) {
-    const p = m[1].replace(/[.,;:!?]+$/, "");
-    if (p === "/" || /^[A-Za-z]:\\?$/.test(p)) continue;
-    if (!found.includes(p)) found.push(p);
-  }
-  return found;
-}
-function real2(p) {
-  try {
-    return realpathSync4.native(p);
-  } catch {
-    return null;
-  }
-}
-function readableGrants(paths, projectRoot) {
-  const root3 = real2(projectRoot);
-  const granted = [];
-  const outside = [];
-  for (const p of paths) {
-    const r = real2(p);
-    if (!root3 || !r || !isInside(root3, r)) {
-      outside.push(p);
-      continue;
-    }
-    let dir = false;
-    try {
-      dir = statSync9(r).isDirectory();
-    } catch {
-      outside.push(p);
-      continue;
-    }
-    if (dir && r === root3) {
-      outside.push(p);
-      continue;
-    }
-    if (!granted.includes(r)) granted.push(r);
-  }
-  return { granted, outside };
-}
-function underGrant(path2, grants, cwd) {
-  const r = canonicalPath(resolve10(cwd, path2));
-  for (const g5 of grants) if (isInside(g5, r)) return true;
-  return false;
-}
-
 // packages/agent-host/src/sessions/interruptions.ts
 var NETWORK_WORDS = [
   /\b(ECONNREFUSED|ENOTFOUND|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|ENETDOWN)\b/,
@@ -113241,11 +113319,12 @@ var RemoteAgents = class {
     if (!origin || !key) {
       return { error: `This project has ${origin ? "a local folder as its origin remote" : "no origin remote"}, so no checkout of it on ${machine.name} can be told apart. Start the agent here, without machine.` };
     }
-    const all = await reader.projects();
+    const all = await reader.projects({ machineId: machine.id });
     const away = all.away.find((a) => a.machineId === machine.id);
     if (away) {
       if (away.why === NOT_CONNECTED) return { error: `${machine.name} ${awayPhrase(NOT_CONNECTED)}, so nothing was started there. Try again once it is connected.` };
-      return { error: `${machine.name} cannot be reached (${away.why}), so nothing was started there. Try again once its link is back.` };
+      const cannot = away.why.startsWith(`${NOT_REACHABLE};`) ? `is ${away.why}` : `cannot be reached (${away.why})`;
+      return { error: `${machine.name} ${cannot}, so nothing was started there. Try again once its link is back.` };
     }
     const theirs = all.projects.filter((p) => p.machineId === machine.id);
     const read = await Promise.all(theirs.map(async (p) => ({ p, r: await reader.origin(p) })));
@@ -119428,6 +119507,10 @@ var SessionStarts = class {
   autoCompactFor(m, adopted) {
     const { tokens } = autoCompactPlan(autoCompactOf(this.host.uiPreferences()), this.host.modelWindows, m);
     this.host.modelWindows.started(m.id, tokens === null ? null : this.host.adapters.get(m.tool)?.windowCeilingFor?.(tokens) ?? null, adopted);
+    if (m.context?.compactAt !== void 0) {
+      const { compactAt: _before, ...rest } = m.context;
+      m.context = rest;
+    }
     const kept = adopted ? this.host.modelWindows.ceilingOf(m.id) : null;
     return { ...tokens === null ? {} : { autoCompactTokens: tokens }, ...kept === null ? {} : { autoCompactCeiling: kept } };
   }
@@ -120320,7 +120403,15 @@ var ContextMeter = class {
     if (used === m.context.used || now - s.at < ESTIMATE_GAP_MS) return null;
     s.at = now;
     s.estimated = true;
-    return { type: "context_update", sessionId: m.id, used, window: m.context.window, exactness: "estimate" };
+    return {
+      type: "context_update",
+      sessionId: m.id,
+      used,
+      window: m.context.window,
+      exactness: "estimate",
+      ...m.context.capped ? { capped: true } : {},
+      ...m.context.compactAt !== void 0 ? { compactAt: m.context.compactAt } : {}
+    };
   }
 };
 
@@ -120388,7 +120479,7 @@ var SessionEvents = class {
   meter = new ContextMeter();
   /** Receive event -> update metadata -> persist message -> broadcast */
   onEvent(raw, from = null) {
-    const e = raw.type === "files_touched" ? this.projectRelative(raw) : raw;
+    let e = raw.type === "files_touched" ? this.projectRelative(raw) : raw;
     if (from && e.sessionId && this.host.handles.get(e.sessionId) !== from && e.type !== "approval_resolved" && e.type !== "question_resolved" && e.type !== "tool_result" && e.type !== "background_tasks") {
       return;
     }
@@ -120410,6 +120501,7 @@ var SessionEvents = class {
       this.host.compactEvent(e, false);
       return;
     }
+    if (e.type === "context_update" && e.exactness !== "estimate") e = this.shareOf(e);
     if (e.type === "settings_changed" && e.by === "tool") {
       this.host.record.recordToolSettings(e);
       return;
@@ -120505,6 +120597,21 @@ var SessionEvents = class {
     if (e.type === "background_tasks" && e.sessionId) this.host.restartPolicy.applyDeferredRestart(e.sessionId);
     if (e.type === "background_tasks" && e.sessionId && this.host.children.pausedReports.has(e.sessionId)) this.host.reports.settlePausedReport(e.sessionId);
   }
+  /**
+   * The tool's reading of the context, as the rest of the host and the screens see it (#1553): `window` is the model's full window
+   * (`ModelWindows.shareWindow`), `capped` says it is not known, `compactAt` is where the adapter says the session's process compacts. The reading
+   * itself is what `ModelWindows` learns the model's window from, so it is noted first, against the window the tool reported. An
+   * estimate from a request (#1492) is no reading of the model's window and carries what the last reading did (`ContextMeter`).
+   */
+  shareOf(e) {
+    const m = this.host.meta.get(e.sessionId);
+    if (!m) return e;
+    this.host.modelWindows.note(m, e.window, e.model);
+    const { window: window2, capped } = this.host.modelWindows.shareWindow(m, e.window);
+    const { compactAt: said, ...rest } = e;
+    const compactAt = said !== void 0 && said > 0 && said < window2 ? said : null;
+    return { ...rest, window: window2, ...capped ? { capped: true } : {}, ...compactAt !== null ? { compactAt } : {} };
+  }
   /** A state hint, for storage: the core reducer's rules on the host's copy (`applySessionState`, protocol session-state.ts) */
   applyStateHint(e, m) {
     const from = m.state;
@@ -120557,7 +120664,6 @@ var SessionEvents = class {
         break;
       case "context_update":
         m.context = nextContext(m.context, e);
-        if (e.exactness !== "estimate") this.host.modelWindows.note(m, e.window, e.model);
         break;
       case "conversation_reset":
         m.context = nextContext(m.context, e);
@@ -120995,7 +121101,8 @@ var SelfCompaction = class {
     if (now - since < IDLE_COMPACT_MINUTES * 6e4) return false;
     const ctx = m.context;
     if (!ctx || ctx.window <= 0) return false;
-    const window2 = this.host.window(m) ?? ctx.window;
+    const window2 = this.host.window(m);
+    if (window2 === null || window2 <= 0) return false;
     return ctx.used >= COMPACT_FLOOR_TOKENS && ctx.used >= window2 * setting.idleShare;
   }
   /** Starts the sweep. A host that never calls it still serves `compact_self` */
@@ -121060,7 +121167,7 @@ var ContextNudges = class {
   }
   cycle(id3) {
     let c = this.cycles.get(id3);
-    if (!c) this.cycles.set(id3, c = { told: /* @__PURE__ */ new Set(), waiting: null, size: 0, sending: false });
+    if (!c) this.cycles.set(id3, c = { told: /* @__PURE__ */ new Set(), waiting: null, size: 0, sending: false, point: null });
     return c;
   }
   requested(id3, size) {
@@ -121068,25 +121175,31 @@ var ContextNudges = class {
     const setting = this.host.setting();
     const m = this.host.session(id3);
     if (!m || !setting.controlled || !setting.nudge || !this.host.hasCompactTool(id3)) return;
-    const window2 = this.host.window(m) ?? m.context?.window ?? 0;
-    if (window2 <= 0) return;
+    const window2 = this.host.window(m);
+    if (window2 === null || window2 <= 0) return;
     const c = this.cycle(id3);
     c.size = size;
     const share = size / window2;
-    const { first, second } = nudgeShares(setting);
-    const crossed = ["first", "second"].filter((k2) => !c.told.has(k2) && (k2 === "first" ? first : second) < setting.share && (k2 === "first" ? first : second) <= share);
+    const point = m.context?.compactAt !== void 0 && m.context.compactAt < window2 ? m.context.compactAt / window2 : null;
+    c.point = point;
+    const { first, second } = nudgeShares({ ...setting, share: point ?? setting.share });
+    const shares = [
+      ["first", first],
+      ["second", second]
+    ];
+    const crossed = shares.filter(([k2, at2]) => !c.told.has(k2) && (k2 === "first" ? at2 < (point ?? setting.share) : point !== null && at2 < point) && at2 <= share).map(([k2]) => k2);
     if (crossed.length > 0) {
       for (const k2 of crossed) c.told.add(k2);
       c.waiting = crossed.includes("second") ? "second" : "first";
     }
-    if (c.waiting) this.deliver(id3, c, m, window2, setting);
+    if (c.waiting) this.deliver(id3, c, m, window2);
   }
-  deliver(id3, c, m, window2, setting) {
+  deliver(id3, c, m, window2) {
     const which = c.waiting;
     if (!which || c.sending) return;
     const percent = Math.round(c.size / window2 * 100);
     const used = `${Math.round(c.size / 1e3)}k of ${Math.round(window2 / 1e3)}k tokens`;
-    const text2 = which === "second" ? `[Centralu] Your context is now about ${percent}% full (${used}), and the tool compacts it by itself in the middle of work at ${Math.round(setting.share * 100)}%. Call compact_self when the current step is done, at the latest; do not stop what you are doing for it.` : `[Centralu] Your context is now about ${percent}% full (${used}). When this step of the work is done, call compact_self so the next step starts from a summary; do not stop what you are doing for it.`;
+    const text2 = which === "second" && c.point !== null ? `[Centralu] Your context is now about ${percent}% full (${used}), and the tool compacts it by itself in the middle of work at ${Math.round(c.point * 100)}%. Call compact_self when the current step is done, at the latest; do not stop what you are doing for it.` : `[Centralu] Your context is now about ${percent}% full (${used}). When this step of the work is done, call compact_self so the next step starts from a summary; do not stop what you are doing for it.`;
     const failed3 = (err) => {
       c.waiting = null;
       console.error(`[compact] ${id3.slice(0, 8)}: could not send the context notice: ${err instanceof Error ? err.message : String(err)}`);
@@ -121359,6 +121472,10 @@ function compactPointOff(passed, reported, modelWindow) {
   if (reported < expected && modelWindow !== null && modelWindow < passed) return null;
   return expected;
 }
+function claudeCompactAt(opts, threshold) {
+  const controlled = opts.processSource?.adopt ? opts.autoCompactCeiling !== void 0 : opts.autoCompactTokens !== void 0;
+  return controlled && threshold > 0 ? threshold : void 0;
+}
 function claudeAutoCompactWindow(tokens) {
   return Math.min(CLAUDE_AUTO_COMPACT_MAX, Math.max(CLAUDE_AUTO_COMPACT_MIN, Math.round(tokens) + CLAUDE_AUTO_COMPACT_BUFFER));
 }
@@ -125231,8 +125348,10 @@ var ClaudeSession = class {
       this.contextWindow = window2 > 0 ? window2 : null;
       if (window2 > 0 && used >= 0) {
         const model = typeof usage?.model === "string" && usage.model ? usage.model : void 0;
-        this.emit({ type: "context_update", sessionId: this.sessionId, used, window: window2, exactness: "exact", ...model ? { model } : {} });
-        this.checkCompactPoint(Number(usage?.autoCompactThreshold ?? 0));
+        const threshold = Number(usage?.autoCompactThreshold ?? 0);
+        const compactAt = claudeCompactAt(this.opts, threshold);
+        this.emit({ type: "context_update", sessionId: this.sessionId, used, window: window2, exactness: "exact", ...model ? { model } : {}, ...compactAt !== void 0 ? { compactAt } : {} });
+        this.checkCompactPoint(threshold);
       }
     } catch {
     }
@@ -127824,6 +127943,9 @@ async function initializeAppServer(client, sessionId, adopted, emit) {
 function autoCompactConfig(opts) {
   return opts.autoCompactTokens ? { model_auto_compact_token_limit: opts.autoCompactTokens } : {};
 }
+function codexCompactAt(opts) {
+  return opts.autoCompactTokens && !opts.processSource?.adopt ? opts.autoCompactTokens : void 0;
+}
 function resumeThreadParams(opts, servers, workspaceConfig) {
   return {
     threadId: opts.resumeExternalId,
@@ -128360,7 +128482,9 @@ var CodexSession = class {
   /** A notification of this thread's own, as the events it maps to (`normalizeNotification`), each the way it goes out */
   emitNotification(n) {
     for (const said of normalizeNotification(this.sessionId, n)) {
-      const e = said.type === "compaction" ? { ...said, trigger: this.compactTurn ? "manual" : "auto" } : said;
+      const sort = said.type === "compaction" ? { ...said, trigger: this.compactTurn ? "manual" : "auto" } : said;
+      const compactAt = codexCompactAt(this.opts);
+      const e = sort.type === "context_update" && compactAt !== void 0 ? { ...sort, compactAt } : sort;
       if (e.type === "error" && this.inputReceipts.size) this.interrupt(new Error(e.error.message));
       if (e.type === "message_image" && !e.data && e.path) {
         void imageEventFromDisk(this.sessionId, e.path).then((filled2) => this.emit(filled2));
@@ -135714,16 +135838,21 @@ var AskProjectFlow = class {
     const reader = this.host.linkedReader;
     const exactHere = projects.some((p) => p.id === wanted);
     const hubs2 = this.hubs;
-    const none = { projects: [], away: [] };
-    const [there, fromHubs] = (reader || hubs2) && !exactHere ? await Promise.all([reader ? reader.projects() : none, hubs2 ? hubs2.projects() : none]) : [none, none];
-    const askable = [
+    const none = { projects: [], away: [], machines: [] };
+    const [first, fromHubs] = (reader || hubs2) && !exactHere ? await Promise.all([reader ? reader.projects({ ref: wanted }) : none, hubs2 ? hubs2.projects() : none]) : [none, none];
+    let there = first;
+    const askableOf = () => [
       ...projects.map((p) => ({ id: p.id, name: p.name, machine: null, machineId: null })),
       ...there.projects.map((p) => ({ id: p.id, name: p.name, machine: p.machine, machineId: p.machineId })),
       ...fromHubs.projects.map((p) => ({ id: p.id, name: p.name, machine: p.hub, machineId: p.hubId }))
     ];
+    let found = matchProjects(wanted, askableOf());
+    if (!found.length && reader && !exactHere) {
+      there = await reader.projects({ ref: wanted, anyDown: true, prior: there });
+      found = matchProjects(wanted, askableOf());
+    }
     const awayAll = [...there.away, ...fromHubs.away.map((a) => ({ machineId: a.hubId, machine: a.hub, why: a.why }))];
     const elsewhere = !!reader || fromHubs.projects.length > 0 || fromHubs.away.length > 0;
-    const found = matchProjects(wanted, askable);
     if (found.length > 1) {
       return {
         ok: false,
@@ -135740,7 +135869,8 @@ var AskProjectFlow = class {
         ...there.projects.map((p) => `${p.name} (on ${p.machine}${p.away ? `, ${p.away}` : ""})`),
         ...fromHubs.projects.map((p) => `${p.name} (on ${p.hub}${p.away ? `, ${p.away}` : ""})`)
       ];
-      const unasked = awayAll.length ? ` Not asked, and its projects may be missing: ${awayAll.map((a) => `${a.machine} (${a.why})`).join(", ")}.` : "";
+      const missing = awayFor(wanted, awayAll, [...there.machines.map((m) => m.machineId), ...fromHubs.projects.map((p) => p.hubId)]);
+      const unasked = missing.length ? ` Not asked, and its projects may be missing: ${missing.map((a) => `${a.machine} (${a.why})`).join(", ")}.` : "";
       return {
         ok: false,
         error: others.length ? `No project named "${wanted}". The other projects are: ${others.join(", ")}.${unasked}` : `No project named "${wanted}" \u2014 this is the only project in Centralu.${unasked}`
@@ -140450,6 +140580,21 @@ var SessionManager = class {
   rename(...a) {
     return this.sessionSettings.rename(...a);
   }
+  /**
+   * Done on a session in error (#1549): the person has read why, and nothing is left to do about the mark. It goes to `idle`
+   * (the table allows error → idle) through the statement a resume makes, so every window hears it and a new error marks the
+   * session again. The error line stays in the conversation; nothing is stopped or sent. Its last answer is read, so a stopped
+   * turn that waits unread in the inbox goes too.
+   */
+  clearError(sessionId, seq) {
+    const m = this.meta.get(sessionId);
+    if (!m) throw sessionNotFound(sessionId);
+    const newer = m.state === "error" && m.lastSeq > seq;
+    const cleared = m.state === "error" && !newer;
+    if (cleared) this.events.settleState(m, { type: "state_change", sessionId, state: "idle", reason: "error_cleared" });
+    this.markRead(sessionId, seq);
+    return { cleared, newer };
+  }
   /** `SessionSettings.markRead` (session-settings.ts), kept on the manager for its callers */
   markRead(...a) {
     return this.sessionSettings.markRead(...a);
@@ -143766,6 +143911,10 @@ function createRpcHandler(mgr2, adapters2, { settleDeletedProjects, deleteOutloo
       mgr2.rename(sessionId, name);
       return { ok: true };
     },
+    "sessions.clearError": async (p) => {
+      const { sessionId, seq } = RpcMethods["sessions.clearError"].params.parse(p);
+      return { ok: true, ...mgr2.clearError(sessionId, seq) };
+    },
     "sessions.markRead": async (p) => {
       const { sessionId, seq } = RpcMethods["sessions.markRead"].params.parse(p);
       mgr2.markRead(sessionId, seq);
@@ -144805,6 +144954,13 @@ var AUTO_RETRY_DELAYS_MS = [10 * 60 * 1e3, 60 * 60 * 1e3, 6 * 60 * 60 * 1e3];
 var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
 var NPM_RETRY_DELAY_MS = 3e4;
 var NPM_RETRY_WINDOW_MS = 10 * 60 * 1e3;
+var UNSTAMPED_VERSION = "0.0.0-dev";
+function installsByItself(build3, current) {
+  return build3 !== "dev" && current !== UNSTAMPED_VERSION;
+}
+function hubUpdatesMachines(f) {
+  return installsByItself(f.build, f.current) && f.autoApply && !f.draining;
+}
 function existingInstalledCopy() {
   const path2 = installedCopyPath();
   return existsSync22(path2) ? path2 : null;
@@ -144855,6 +145011,8 @@ var UpdateService = class {
   constructor(publish, deps = {}) {
     this.publish = publish;
     this.deps = {
+      current: deps.current ?? APP_VERSION,
+      build: deps.build ?? "",
       fetchLatest: deps.fetchLatest ?? fetchLatestFromRegistry,
       run: deps.run ?? runCommand,
       installedCopy: deps.installedCopy ?? existingInstalledCopy,
@@ -144880,13 +145038,13 @@ var UpdateService = class {
       /*
        * The honest source for "which build is this".
        *
-       * `APP_VERSION` is what the app was compiled from, and `tooling/brand.test.ts`
-       * fails the build if it disagrees with the npm packages that carry it. The
-       * workspace root's package.json is not it — that one is private, has no version
-       * anyone installs, and would have read `0.0.0` forever without ever being wrong
-       * enough to notice.
+       * `APP_VERSION` is what the app was compiled from: the version a release stamped
+       * into the build with the npm packages that carry it (#1501, `tooling/brand.test.ts`),
+       * or the placeholder `0.0.0-dev` of a source tree. The workspace root's package.json
+       * is not it — that one is private, has no version anyone installs, and would have
+       * read `0.0.0` forever without ever being wrong enough to notice.
        */
-      current: APP_VERSION,
+      current: this.deps.current,
       latest: null,
       newer: false,
       auto: this.deps.readAuto(),
@@ -144983,6 +145141,7 @@ var UpdateService = class {
    */
   installIfAutomatic() {
     if (!this.status.autoApply || !this.status.newer || !this.status.latest) return;
+    if (!installsByItself(this.deps.build, this.deps.current)) return;
     if (this.status.phase === "idle") {
       void this.apply();
       return;
@@ -145006,6 +145165,7 @@ var UpdateService = class {
     this.retryTimer = this.deps.schedule(() => {
       this.retryTimer = null;
       if (this.stopped || !this.status.autoApply || this.status.phase !== "failed" || !this.status.newer || !this.status.latest) return;
+      if (!installsByItself(this.deps.build, this.deps.current)) return;
       void this.apply();
     }, delay);
   }
@@ -147380,8 +147540,8 @@ function failure2(target, code2, detail) {
     case "dev_dirty":
       return `The working copy on ${target} has ${detail} uncommitted change${detail === "1" ? "" : "s"}; commit or stash them, or pass --allow-dirty to build them too. Nothing was built`;
     case "dev_base":
-      if (/^0\.0\.0-dev(?:\.|$)/.test(detail))
-        return `The working copy on ${target} carries no release version (${detail}): its version is stamped from a release tag at build time (#1501), which this dev build cannot do. Nothing was built`;
+      if (!detail || /^0\.0\.0-dev(?:\.|$)/.test(detail))
+        return `The working copy on ${target} has no release tag (v*) reachable from its HEAD, which a dev build takes its version from (#1501); fetch the tags there (git fetch --tags) and try again. Nothing was built`;
       return `The working copy on ${target} is version ${detail || "(none)"}; a dev build is cut from a prerelease (x.y.z-beta.N)`;
     case "dev_protocol": {
       const [have = "?", want = "?"] = detail.split(" ");
@@ -148220,7 +148380,11 @@ var KEEPS_TRYING = "reconnecting";
 var WAITS_FOR_PERSON = "press Connect to try again";
 var NEXT_STEP = new RegExp(`; (${KEEPS_TRYING}|asking the machine again|${WAITS_FOR_PERSON})$`);
 var ATTEMPT_WAIT_MS = 6e4;
+var CALL_WAIT_MS = 1e4;
+var CALL_FAILURE_KEPT_MS = 6e4;
+var CALL_WINDOW_MS = 15e3;
 var AWAY = /* @__PURE__ */ new Set(["unreachable", "away", "not_running", "refused", "stopped"]);
+var CALL_RETRIES = /* @__PURE__ */ new Set(["unreachable", "away", "not_running", "refused"]);
 var LinkedMachineConnection = class {
   constructor(record2, tunnel, deps) {
     this.record = record2;
@@ -148335,6 +148499,10 @@ var LinkedMachineConnection = class {
   nextAttemptAt = null;
   /** Calls waiting for an attempt to connect to end (`settled`) */
   statusWaiters = /* @__PURE__ */ new Set();
+  /** When a call last started an attempt (`reachForCall`), and how the attempt a call waited on ended, with when */
+  lastCallAttemptAt = 0;
+  callFailure = null;
+  callFailureAt = 0;
   get id() {
     return this.record.id;
   }
@@ -148376,7 +148544,11 @@ var LinkedMachineConnection = class {
   }
   /** Resolves once no attempt is under way, or after `waitMs` (a minute): connecting took 2 to 4 s on a LAN, a host started there adds its start */
   settled(waitMs = this.deps.attemptWaitMs ?? ATTEMPT_WAIT_MS) {
-    if (!this.attemptUnderWay) return Promise.resolve();
+    return this.waitUntil(() => !this.attemptUnderWay, waitMs);
+  }
+  /** Resolves once `ready()` holds (checked at every change of status and at the end of every opening), or after `waitMs` */
+  waitUntil(ready, waitMs) {
+    if (ready()) return Promise.resolve();
     return new Promise((resolve21) => {
       const done2 = () => {
         clearTimeout(timer);
@@ -148384,13 +148556,67 @@ var LinkedMachineConnection = class {
         resolve21();
       };
       const waiter = () => {
-        if (!this.attemptUnderWay) done2();
+        if (ready()) done2();
       };
       const timer = setTimeout(done2, waitMs);
       timer.unref?.();
       this.statusWaiters.add(waiter);
     });
   }
+  /**
+   * An agent's call needs this machine (#1532): with Auto reconnect on and the link down, it does what the person's Connect
+   * does (`connect`, the one action that opens a link now) instead of waiting out the backoff, and waits for it a short
+   * bound (`CALL_WAIT_MS`). The caller reads `reachable` afterwards: connected in time, the call goes through; not, it is
+   * answered as not reachable with `whyDown`, and the backoff goes on from where it was (`keepBackoff`).
+   *
+   * - one attempt at a time: a call that finds one under way (the backoff's, the person's press, another call's) waits on
+   *   it and starts none; so do ten calls at once, and a press at the same moment as a call;
+   * - calls cannot defeat the backoff: at most one attempt started by a call per machine within `CALL_WINDOW_MS`; a call
+   *   inside the window waits for nothing and is answered at once;
+   * - with Auto reconnect off nothing is started (#1341): the call is answered as not connected, and the person is named.
+   *   Neither does it when the person disconnected the machine, the host was stopped there, an operation holds the link
+   *   or the versions differ: a Connect does not help those, or is the person's to press
+   */
+  async reachForCall() {
+    if (this.reachable) return;
+    const until = Date.now() + (this.deps.callWaitMs ?? CALL_WAIT_MS);
+    const left = () => Math.max(0, until - Date.now());
+    await this.waitUntil(() => this.reachable || !this.redialing, left());
+    if (this.reachable) return;
+    if (this.attemptUnderWay) {
+      await this.settled(Math.min(left(), this.deps.attemptWaitMs ?? ATTEMPT_WAIT_MS));
+      return this.noteCallFailure();
+    }
+    if (this.stopped || this.parked || this.held || this.inOperation() || !this.autoReconnect || this.redialing) return;
+    if (!CALL_RETRIES.has(this.status)) return;
+    const now = Date.now();
+    if (now - this.lastCallAttemptAt < (this.deps.callWindowMs ?? CALL_WINDOW_MS)) return;
+    this.lastCallAttemptAt = now;
+    this.connect({ start: false, keepBackoff: true });
+    await this.settled(Math.min(left(), this.deps.attemptWaitMs ?? ATTEMPT_WAIT_MS));
+    this.noteCallFailure();
+  }
+  /** The window in which a call starts at most one attempt (`reachForCall`) */
+  get callWindowMs() {
+    return this.deps.callWindowMs ?? CALL_WINDOW_MS;
+  }
+  /** How the attempt a call waited on ended when it did not connect: the machine's own words. One still going is told as it is (`whyDown`) */
+  noteCallFailure() {
+    if (this.reachable || this.attemptUnderWay) return;
+    this.callFailure = this.error?.replace(NEXT_STEP, "") ?? null;
+    this.callFailureAt = Date.now();
+  }
+  /**
+   * What the answer to a call that could not take it says of the attempt to connect the machine (#1532), as a clause: that
+   * one is still under way, or that the one a call made last failed, with the machine's own words. Null once the link is
+   * up, and when no attempt was made or told of
+   */
+  get whyDown() {
+    if (this.reachable) return null;
+    if (this.attemptUnderWay) return "an attempt to connect it is still under way";
+    if (!this.callFailure || Date.now() - this.callFailureAt > CALL_FAILURE_KEPT_MS) return null;
+    return `the attempt to connect it just now failed: ${this.callFailure}`;
+  }
   /** An install, update or other operation the person started is running: its retries are part of it (`retryLater`) */
   inOperation() {
     return this.held;
@@ -148526,7 +148752,9 @@ var LinkedMachineConnection = class {
    * The person's Connect (`machines.reconnect`, #1134): opens now, forgetting the backoff, also a disconnected link and
    * also with Auto reconnect off (#1341), where it is the only way to try again. It is also the person's Start
    * (#1143): a host is started there even where they stopped it or the link stopped starting them. `start: false` is
-   * the orchestrator's reconnect without its card, which opens the link and starts nothing the link would not
+   * the orchestrator's reconnect without its card, which opens the link and starts nothing the link would not.
+   * `keepBackoff` is an agent's call that needs the machine (`reachForCall`, #1532): it opens now too, but the backoff
+   * goes on from the step it was at instead of starting over, so calls cannot hold it at its short steps
    */
   connect(opts = {}) {
     if (opts.start !== false) {
@@ -148535,7 +148763,7 @@ var LinkedMachineConnection = class {
       this.restartsSpent = false;
     }
     if (this.parked) return this.start();
-    this.reconnect();
+    this.reconnect(opts.keepBackoff === true);
   }
   /**
    * Closes the link and tries none until the person connects it again (#1134). The machine stays linked; its sessions
@@ -148580,9 +148808,9 @@ var LinkedMachineConnection = class {
     this.start();
   }
   /** Opens again now, forgetting the backoff (`machines.reconnect`, or the person accepted the versions) */
-  reconnect() {
+  reconnect(keepBackoff = false) {
     this.clearRetry();
-    this.attempt = 0;
+    if (!keepBackoff) this.attempt = 0;
     const under = this.opening;
     if (under) {
       if (this.status === "away") this.setStatus("connecting", null);
@@ -148995,6 +149223,7 @@ var LinkedMachineConnection = class {
   setStatus(status, error51) {
     if (this.status === "connected" && status !== "connected") this.seen();
     const changed = status !== this.status || error51 !== this.error;
+    if (status === "connected") this.callFailure = null;
     this.status = status;
     this.error = error51;
     if (changed) {
@@ -150301,9 +150530,12 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     for (const m of machines()) if (m.id === id3) return m;
     return null;
   };
-  const away = (m) => m.waitsForPerson ? `${m.name} ${awayPhrase(NOT_CONNECTED)}, then try again` : `${m.name} is ${NOT_REACHABLE}; try again once its link is back`;
+  const away = (m) => m.waitsForPerson ? `${m.name} ${awayPhrase(NOT_CONNECTED)}, then try again` : `${m.name} is ${notReachable(m)}; try again once its link is back`;
+  const notReachable = (m) => m.whyDown ? `${NOT_REACHABLE}; ${oneLine3(m.whyDown, 300)}` : NOT_REACHABLE;
   const settle = async (m) => {
-    if (m.attemptUnderWay) await m.settled?.();
+    if (m.reachable) return;
+    if (m.reachForCall) await m.reachForCall();
+    else if (m.attemptUnderWay) await m.settled?.();
   };
   const attempt = async (m, run4) => {
     await settle(m);
@@ -150373,26 +150605,65 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
     }
     return out;
   };
-  const everyProject = async () => {
+  const projectsOf = async (m, tried = false) => {
     const away2 = [];
-    const perMachine = await Promise.all(
-      [...machines()].map(async (m) => {
-        const mirrored = (why) => {
-          away2.push({ machine: m.name, machineId: m.id, why });
-          return lastProjects(m).map((p) => ({ ...p, away: why }));
-        };
-        if (!m.reachable && m.attemptUnderWay) return lastProjects(m);
-        if (!m.reachable) return mirrored(m.waitsForPerson ? NOT_CONNECTED : NOT_REACHABLE);
-        try {
-          const list = await raceTimeout(m.call("projects.list", {}), lookupMs, TIMED_OUT);
-          if (list === TIMED_OUT) throw new Error(notWithin(lookupMs));
-          return (Array.isArray(list) ? list : []).map((raw) => projectOf(m, raw)).filter((p) => p !== null);
-        } catch (err) {
-          return mirrored(cause(m, err));
-        }
+    const mirrored = (why) => {
+      away2.push({ machine: m.name, machineId: m.id, why });
+      return lastProjects(m).map((p) => ({ ...p, away: why }));
+    };
+    if (!m.reachable && m.attemptUnderWay && !tried) return { projects: lastProjects(m), away: away2 };
+    if (!m.reachable) return { projects: mirrored(m.waitsForPerson ? NOT_CONNECTED : notReachable(m)), away: away2 };
+    try {
+      const list = await raceTimeout(m.call("projects.list", {}), lookupMs, TIMED_OUT);
+      if (list === TIMED_OUT) throw new Error(notWithin(lookupMs));
+      return { projects: (Array.isArray(list) ? list : []).map((raw) => projectOf(m, raw)).filter((p) => p !== null), away: away2 };
+    } catch (err) {
+      return { projects: mirrored(cause(m, err)), away: away2 };
+    }
+  };
+  const qualifiedWith = (m, ref) => {
+    const slash = ref.indexOf("/");
+    const prefix = slash > 0 ? ref.slice(0, slash).trim().toLowerCase() : null;
+    return prefix === m.id || prefix === m.name.toLowerCase() || ref.startsWith(`${m.id}.`);
+  };
+  const needs = (m, need3) => {
+    if (need3.machineId === m.id) return true;
+    const ref = need3.ref?.trim();
+    if (!ref) return false;
+    if (qualifiedWith(m, ref)) return true;
+    return lastProjects(m).some((p) => p.id === ref || p.name.toLowerCase() === ref.toLowerCase());
+  };
+  const guessed = /* @__PURE__ */ new Map();
+  const guess = async (m) => {
+    const g5 = guessed.get(m.id);
+    if (g5 && Date.now() - g5.at < (m.callWindowMs ?? 0)) return g5.wait ?? void 0;
+    const entry = { at: Date.now(), wait: null };
+    entry.wait = settle(m).finally(() => {
+      entry.wait = null;
+    });
+    guessed.set(m.id, entry);
+    return entry.wait;
+  };
+  const everyProject = async (need3) => {
+    const all = [...machines()];
+    const ref = need3?.ref?.trim();
+    const bare2 = !!ref && !ref.includes("/") && !all.some((m) => qualifiedWith(m, ref));
+    const anyDown = !!need3?.anyDown && bare2;
+    const prior = need3?.prior;
+    if (prior && !anyDown) return prior;
+    const named = (m) => !!need3 && needs(m, need3);
+    const wanted = all.filter((m) => !m.reachable && (anyDown || named(m)));
+    const parts = await Promise.all(
+      all.map(async (m) => {
+        if (wanted.includes(m)) {
+          await (anyDown && !named(m) ? guess(m) : settle(m));
+          return projectsOf(m, true);
+        }
+        if (prior) return { projects: prior.projects.filter((p) => p.machineId === m.id), away: prior.away.filter((a) => a.machineId === m.id) };
+        return projectsOf(m);
       })
     );
-    return { projects: perMachine.flat(), away: away2 };
+    return { projects: parts.flatMap((p) => p.projects), away: parts.flatMap((p) => p.away), machines: all.map((m) => ({ machine: m.name, machineId: m.id })) };
   };
   return {
     async send(sessionId, text2, fromName, ask) {
@@ -150408,10 +150679,6 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
       if (!m) return { ok: false, error: `Not a session of a linked machine: ${sessionId}` };
       return attempt(m, async () => ({ info: await route("agents.updateSettings", { sessionId, ...s, by: "orchestrator" }) }));
     },
-    async findProjects(ref) {
-      const wanted = ref.trim();
-      return (await everyProject()).projects.filter((p) => p.id === wanted || p.name === wanted);
-    },
     projects: everyProject,
     async projectSessions(project2) {
       const m = owner(project2.id);
@@ -150676,7 +150943,7 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
       const m = owner(sessionId);
       if (!m) return { ok: false, error: `Not a session of a linked machine: ${sessionId}` };
       await settle(m);
-      if (!m.reachable) return { ok: false, error: m.waitsForPerson ? away(m) : `${m.name} is ${NOT_REACHABLE}` };
+      if (!m.reachable) return { ok: false, error: m.waitsForPerson ? away(m) : `${m.name} is ${notReachable(m)}` };
       try {
         const answer = await m.call("host.lastAnswer", { sessionId: m.q.strip(sessionId, "The session"), maxChars: Math.min(maxChars, ANSWER_MAX_CHARS2) });
         const r5 = HostLastAnswerResult.safeParse(answer);
@@ -150716,7 +150983,7 @@ function linkedSessions(machines, route = notRouted, hubName2, options = {}) {
       const m = owner(sessionId);
       if (!m) return { ok: false, error: `Not a session of a linked machine: ${sessionId}` };
       await settle(m);
-      if (!m.reachable) return { ok: false, error: m.waitsForPerson ? away(m) : `${m.name} is not reachable right now; read it again once its link is back` };
+      if (!m.reachable) return { ok: false, error: m.waitsForPerson ? away(m) : `${m.name} is ${notReachable(m)}; read it again once its link is back` };
       const toolMode = toolLinesOf(opts?.tools);
       try {
         const answer = await m.call("host.readSession", {
@@ -150883,6 +151150,7 @@ var ROUTES = {
   "attachments.save": session(),
   "sessions.rename": session(),
   "sessions.markRead": session(),
+  "sessions.clearError": session(),
   "messages.load": session(messages),
   "messages.subagent": session(messages),
   "messages.subagentTrashed": session(),
@@ -151126,7 +151394,7 @@ var MachineUnreachableError = class extends Error {
   retryable = true;
   data;
   constructor(machine) {
-    super(`${machine.name} is not reachable right now; this works again once its link is back`);
+    super(`${machine.name} is not reachable right now${machine.whyDown ? `; ${machine.whyDown}` : ""}; this works again once its link is back`);
     this.data = { machine: machine.id, reason: "unreachable" };
   }
 };
@@ -151191,7 +151459,8 @@ var Router = class {
     for (const m of this.opts.machines()) if (m.id === id3) return m;
     return null;
   }
-  async forward(m, method, params) {
+  async forward(m, method, params, ctx) {
+    if (!m.reachable && ctx === void 0) await m.reachForCall?.();
     if (!m.reachable) throw new MachineUnreachableError(m);
     return m.call(method, params);
   }
@@ -151201,7 +151470,7 @@ var Router = class {
       const m2 = this.machineById(params.machine);
       if (!m2) throw rpcError(`No linked machine ${params.machine}`);
       const { machine: _machine2, ...rest } = params;
-      const r5 = await this.forward(m2, method, route.params ? route.params(rest, m2.q) : rest);
+      const r5 = await this.forward(m2, method, route.params ? route.params(rest, m2.q) : rest, ctx);
       return route.result ? route.result(r5, m2.q) : r5;
     }
     const m = this.owner(params[key]);
@@ -151212,7 +151481,7 @@ var Router = class {
     const done2 = this.opts.forwarding?.(method, params);
     let r;
     try {
-      r = await this.forward(m, method, p);
+      r = await this.forward(m, method, p, ctx);
     } catch (e) {
       done2?.(false);
       throw e;
@@ -151247,7 +151516,7 @@ var Router = class {
     const { machine: _machine, ...own } = params;
     const p = route.orMachine ? own : { ...params };
     for (const key of route.keys) if (typeof p[key] === "string") p[key] = target.q.strip(p[key], "The id");
-    const r = await this.forward(target, method, p);
+    const r = await this.forward(target, method, p, ctx);
     return route.result ? route.result(r, target.q) : r;
   }
   async byMachine(method, params, route, ctx) {
@@ -151259,7 +151528,7 @@ var Router = class {
       const shared = await this.sameAccountAnswer(m, method, rest, ctx);
       if (shared) return route.result ? route.result(shared, m.q) : shared;
     }
-    const r = await this.forward(m, method, rest);
+    const r = await this.forward(m, method, rest, ctx);
     return route.result ? route.result(r, m.q) : r;
   }
   /**
@@ -151915,7 +152184,7 @@ var handedToken = launch.tokenOnStdin ? await readHandedToken(process.stdin).cat
   console.error(`[agent-host] the launcher did not hand over the token: ${e.message}`);
   process.exit(1);
 }) : launch.token;
-var BUILD = true ? "49153ff" : "dev";
+var BUILD = true ? "bd398a1" : "dev";
 var { values } = parseArgs({
   options: {
     port: { type: "string", default: "5175" },
@@ -152178,6 +152447,8 @@ var { auto: autoUpdateCheck, autoApply: autoApplyUpdates } = updateSwitches(stor
 var themes = new ThemeFiles(join52(dataRoot(), "themes"), () => events.push({ type: "themes_changed" }));
 await themes.start().catch((e) => console.error(`[themes] the themes folder is unavailable: ${e.message}`));
 var updates = new UpdateService((status) => events.push({ type: "update_status", status }), {
+  // A host from source never installs by itself, whatever is stored (#1501 review, `installsByItself`)
+  build: BUILD,
   // On by default when nothing has been saved yet. Since the check is read-only and every failure
   // is swallowed, leaving it on costs nothing, while leaving it off traps **someone who never once
   // opens settings** on an old version forever — that person is exactly the one most likely to stay
@@ -152279,7 +152550,7 @@ var links = new Links({
   // When agents compact: this hub's setting governs the machines it links (#1376)
   autoCompact: () => autoCompactOf(mgr.uiPreferences()),
   // Automatic updates cover the linked machines too (#1508): one on an older release follows this hub's version; none starts mid-swap
-  autoUpdate: () => autoApplyUpdates.read() && !hostDrain.draining,
+  autoUpdate: () => hubUpdatesMachines({ build: BUILD, current: APP_VERSION, autoApply: autoApplyUpdates.read(), draining: hostDrain.draining }),
   reverse: reverseCalls({
     allowed: (machineId) => store.machines.linkedMachineAsks(machineId),
     projects: () => mgr.projectsForMachines(),