@centralu/host-linux-arm64 0.1.0-beta.19 → 0.1.0-beta.20

package/host/bundle-info.json

@@ -1,7 +1,7 @@
 {
-  "commit": "60665cc",
+  "commit": "c6afa2e",
   "protocolVersion": 1,
-  "builtAt": "2026-10-12T21:22:21.807Z",
+  "builtAt": "2026-10-13T05:16:37.829Z",
   "runtime": "system-node",
   "platform": "linux",
   "arch": "arm64"

package/host/main.mjs

@@ -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.19";
+var APP_VERSION = "0.1.0-beta.20";
 var APP_SLUG = "centralu";
 var CLIENT_INFO = { name: APP_SLUG, title: APP_NAME, version: APP_VERSION };
 var DATA_DIR = ".centralu";
@@ -58249,6 +58249,8 @@ var AdapterCapabilities = external_exports.object({
    * The idle check (#297) needs that difference — a session whose background work is invisible is never called idle.
    */
   backgroundTasks: external_exports.boolean().default(false),
+  /** Whether send accepts input during a running turn without interrupting it (#592). Absent is unsupported. */
+  midTurnInput: external_exports.boolean().optional(),
   /**
    * Whether this tool can defer individual Centralu tool definitions until the model asks for
    * them. This is a serving property, not a list of tool names: the host uses it when it counts
@@ -59837,6 +59839,14 @@ var MessageImage = external_exports.discriminatedUnion("ok", [
   external_exports.object({ ok: external_exports.literal(true), mime: external_exports.string(), data: external_exports.string(), file: external_exports.string().optional() }),
   external_exports.object({ ok: external_exports.literal(false), reason: MessageImageRefusal, message: external_exports.string(), file: external_exports.string().optional() })
 ]);
+var AppHomeViewResult = external_exports.object({
+  instanceId: external_exports.string(),
+  tool: external_exports.string(),
+  resourceUri: external_exports.string(),
+  toolInput: external_exports.record(external_exports.string(), external_exports.unknown()),
+  toolResult: external_exports.looseObject({ content: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())) }),
+  runId: external_exports.string()
+});
 var RpcMethods = {
   "agents.createSession": { params: CreateSessionParams, result: SessionInfo },
   "agents.send": {
@@ -60433,7 +60443,8 @@ var RpcMethods = {
    * tool-result).
    *
    * If there is no `home`, or that tool did not declare a screen, or the app cannot be reached
-   * (not trusted, or failed to start), this fails with a reason and leaves no instance behind. If
+   * (not trusted, or failed to start), this fails with a reason and leaves no live screen behind. A
+   * keyed open keeps only a failure reservation during the lease grace period, without holding the app. If
    * the app itself answered with a failure, this still opens — drawing a failure is also the
    * screen's job.
    *
@@ -60442,21 +60453,16 @@ var RpcMethods = {
    * machine. Absent: this host's own app, as before.
    */
   "apps.openView": {
+    // openKey: one client-chosen UUID per logical open. Repeats reuse the instance and home outcome,
+    // including after a planned host handover, so a lost answer never runs the home tool twice.
     /*
      * `lease` (#392, additive): the view belongs to this window's connection. Once the connection ends, the host waits
      * a few minutes for a window to claim it (`apps.holdViews`) and then closes it, so a reloaded or closed window does
      * not hold its apps open for good. Without it (an older window, or a linked machine's view) the view lives until
      * `apps.closeView`.
      */
-    params: external_exports.object({ appId: AppId, projectId: ProjectId.nullable(), ...machineParam, lease: external_exports.boolean().optional() }),
-    result: external_exports.object({
-      instanceId: external_exports.string(),
-      tool: external_exports.string(),
-      resourceUri: external_exports.string(),
-      toolInput: external_exports.record(external_exports.string(), external_exports.unknown()),
-      toolResult: external_exports.looseObject({ content: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())) }),
-      runId: external_exports.string()
-    })
+    params: external_exports.object({ appId: AppId, projectId: ProjectId.nullable(), ...machineParam, lease: external_exports.boolean().optional(), openKey: external_exports.string().uuid().optional() }),
+    result: AppHomeViewResult
   },
   /**
    * Closes the pinned screen (M4 B-2). Releases the app the instance was holding on to — an app
@@ -60467,6 +60473,11 @@ var RpcMethods = {
     params: external_exports.object({ instanceId: external_exports.string() }),
     result: external_exports.object({ ok: external_exports.literal(true) })
   },
+  /** Reclaims a keyed home open after losing its answer; never calls the home tool. */
+  "apps.recoverView": {
+    params: external_exports.object({ appId: AppId, projectId: ProjectId.nullable(), ...machineParam, lease: external_exports.boolean().optional(), openKey: external_exports.string().uuid() }),
+    result: AppHomeViewResult
+  },
   /**
    * A window claims the pinned screens it shows (#392), after every reconnect: each leased instance
    * named becomes this connection's again and stops waiting to be closed. `missing` lists the ids
@@ -63175,6 +63186,7 @@ var ViewHost = class _ViewHost {
   }
   opts;
   instances = /* @__PURE__ */ new Map();
+  openingHomes = /* @__PURE__ */ new Map();
   origins = /* @__PURE__ */ new Map();
   /** Origin servers being closed, by key: one started again for the same key waits for its port to be free */
   closingOrigins = /* @__PURE__ */ new Map();
@@ -63212,6 +63224,42 @@ var ViewHost = class _ViewHost {
     this.instances.set(id2, { id: id2, app: ref, uri, doc: null, release, lease });
     return { instanceId: id2 };
   }
+  /** A logical home open may run its tool once, even when its answer is lost in a swap. */
+  homeOpen(app2, key, holder) {
+    const inst = [...this.instances.values()].find((i) => i.home?.key === key);
+    if (!inst) return null;
+    if (!sameApp(inst.app, app2)) fail("This open key belongs to another app");
+    if (inst.home.outcome) {
+      if (holder !== void 0) this.hold([inst.id], holder);
+      return Promise.resolve(inst.home.outcome);
+    }
+    if (inst.home.error) return Promise.reject(new Error(inst.home.error));
+    const opening = this.openingHomes.get(inst.id);
+    if (opening) {
+      if (holder !== void 0) this.hold([inst.id], holder);
+      return opening;
+    }
+    return Promise.reject(new Error(
+      "Host restarted while the home tool was running \u2014 the app may or may not have done this; check before opening again"
+    ));
+  }
+  rememberHome(instanceId, key, work) {
+    const inst = this.instances.get(instanceId);
+    inst.home = { key };
+    const opening = work().then((outcome) => {
+      inst.home.outcome = outcome;
+      return outcome;
+    }, (e) => {
+      inst.home.error = e instanceof Error ? e.message : String(e);
+      inst.release?.();
+      inst.release = null;
+      inst.lease = { holder: null, orphanSince: Date.now() };
+      this.scheduleSweep();
+      throw e;
+    }).finally(() => this.openingHomes.delete(instanceId));
+    this.openingHomes.set(instanceId, opening);
+    return opening;
+  }
   close(instanceId) {
     this.drop(instanceId);
   }
@@ -63265,7 +63313,7 @@ var ViewHost = class _ViewHost {
   }
   /** Every open instance, oldest first — what a planned hand-over records (view-handover.ts) */
   list() {
-    return [...this.instances.values()].map((i) => ({ id: i.id, app: { ...i.app }, uri: i.uri, ...i.lease ? { leased: true } : {} }));
+    return [...this.instances.values()].map((i) => ({ id: i.id, app: { ...i.app }, uri: i.uri, ...i.lease ? { leased: true } : {}, ...i.home ? { home: i.home } : {} }));
   }
   /**
    * Opens again, **under their old ids**, the instances a previous host handed over (#280: a build
@@ -63292,8 +63340,22 @@ var ViewHost = class _ViewHost {
         this.log(`[agent-host] view ${v.uri} (${_ViewHost.originKey(ref)}) not restored: ${err.message}`);
         continue;
       }
-      const lease = v.leased === true ? { holder: null, orphanSince: now } : null;
-      this.instances.set(v.id, { id: v.id, app: ref, uri: v.uri, doc: null, release, lease });
+      let lease = v.leased === true ? { holder: null, orphanSince: now } : null;
+      let home;
+      if (v.home && typeof v.home.key === "string" && RpcMethods["apps.openView"].params.shape.openKey.safeParse(v.home.key).success) {
+        const outcome = RpcMethods["apps.openView"].result.safeParse(v.home.outcome);
+        home = {
+          key: v.home.key,
+          ...outcome.success && outcome.data.instanceId === v.id ? { outcome: outcome.data } : {},
+          ...typeof v.home.error === "string" ? { error: v.home.error } : {}
+        };
+      }
+      if (home && !home.outcome) {
+        release?.();
+        release = null;
+        lease = { holder: null, orphanSince: now };
+      }
+      this.instances.set(v.id, { id: v.id, app: ref, uri: v.uri, doc: null, release, lease, ...home ? { home } : {} });
       opened.push(v.id);
     }
     if (opened.some((id2) => this.instances.get(id2)?.lease)) this.scheduleSweep();
@@ -98104,7 +98166,7 @@ var OriginPorts = class {
 };
 
 // packages/agent-host/src/sessions/manager.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 
 // packages/agent-host/src/sessions/tool-cost.ts
 import { createHash as createHash8 } from "node:crypto";
@@ -100183,10 +100245,11 @@ function finalAnswer(messages2) {
 }
 var AgentRunWait = class {
   constructor(notify, sessionName, onUsage = () => {
-  }) {
+  }, readAnswer2) {
     this.notify = notify;
     this.sessionName = sessionName;
     this.onUsage = onUsage;
+    this.readAnswer = readAnswer2;
     this.done = new Promise((resolve11, reject) => this.settle = { resolve: resolve11, reject });
     this.done.catch(() => {
     });
@@ -100194,6 +100257,7 @@ var AgentRunWait = class {
   notify;
   sessionName;
   onUsage;
+  readAnswer;
   /** The person stopped that session's turn (`SessionManager.interrupt`) */
   stoppedByPerson = false;
   /** The person deleted that session — there is no session left to conclude */
@@ -100201,17 +100265,46 @@ var AgentRunWait = class {
   done;
   settle;
   settled = false;
+  inputs = 0;
+  trackedInputs = false;
+  ending;
+  get waitingForInputs() {
+    return this.inputs > 0;
+  }
+  get finished() {
+    return this.settled;
+  }
+  get tracksInputs() {
+    return this.trackedInputs;
+  }
+  get completedAnswer() {
+    return this.ending?.answer;
+  }
+  /** A parent's note may join this turn or run after it. Hold before send, since adapters can emit synchronously. */
+  holdInput() {
+    this.trackedInputs = true;
+    this.inputs++;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.inputs--;
+      if (!this.inputs && this.ending) this.finish(this.ending);
+    };
+  }
   onEvent(e) {
     if (e.type === "usage_update") {
       const t = e.tokens;
       return this.onUsage({ input: t.inputTokens + t.cacheReadTokens + t.cacheCreationTokens, output: t.outputTokens });
     }
     if (this.settled) return;
+    if (e.type === "message_delta" || e.type === "state_change" && e.state === "working") this.ending = void 0;
     switch (e.type) {
       case "turn_complete":
         if (this.stoppedByPerson) return this.fail(new Error("the person stopped the agent before it finished"));
-        this.settled = true;
-        return this.settle.resolve(e.output === void 0 ? {} : { output: e.output });
+        this.ending = { ...e.output === void 0 ? {} : { output: e.output }, ...this.readAnswer ? { answer: this.readAnswer() } : {} };
+        if (this.inputs) return;
+        return this.finish(this.ending);
       case "error":
         return this.fail(new Error(this.stoppedByPerson ? "the person stopped the agent before it finished" : `the agent's turn failed: ${e.error.message}`));
       case "limit_reached":
@@ -100225,7 +100318,12 @@ var AgentRunWait = class {
   fail(err) {
     if (this.settled) return;
     this.settled = true;
-    this.settle.reject(err);
+    this.settle.reject(this.stoppedByPerson ? new Error("the person stopped the agent before it finished") : err);
+  }
+  finish(ending) {
+    if (this.settled) return;
+    this.settled = true;
+    this.settle.resolve(ending);
   }
 };
 
@@ -100457,6 +100555,11 @@ function agentFrame(parentName, task) {
     task
   ].join("\n");
 }
+function agentNoteFrame(parentName, text2) {
+  return `[A note from the parent session "${parentName}" through Centralu's agent_session. These are the parent's words about your ongoing work.]
+
+${text2}`;
+}
 function agentBranch(task, id2, max = 40) {
   const slug = task.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max).replace(/-+$/, "");
   return `${APP_SLUG}/${slug || "agent"}-${id2.replace(/[^a-z0-9]/gi, "").slice(0, 4).toLowerCase()}`;
@@ -100739,6 +100842,72 @@ import { exec as exec6 } from "node:child_process";
 // packages/agent-host/src/adapters/claude/index.ts
 init_sdk();
 import { homedir as homedir5 } from "node:os";
+import { randomUUID as randomUUID8 } from "node:crypto";
+
+// packages/agent-host/src/adapters/input-receipts.ts
+import { randomUUID as randomUUID7 } from "node:crypto";
+var InputReceipts = class {
+  pending = /* @__PURE__ */ new Map();
+  ended = /* @__PURE__ */ new Set();
+  create(observer) {
+    const id2 = randomUUID7();
+    let resolve11;
+    let reject;
+    const done = new Promise((yes, no2) => {
+      resolve11 = yes;
+      reject = no2;
+    });
+    done.catch(() => {
+    });
+    const receipt = { id: id2, done, cancelled: false, completed: false };
+    this.pending.set(id2, { receipt, resolve: resolve11, reject, observer });
+    return receipt;
+  }
+  get size() {
+    return this.pending.size;
+  }
+  get ids() {
+    return [...this.pending.keys()];
+  }
+  /** Codex's turn/start response can arrive after that turn's completion notification. */
+  bind(receipt, turn) {
+    const p = this.pending.get(receipt.id);
+    if (!p) return;
+    p.turn = turn;
+    if (this.ended.has(turn)) this.finish(receipt.id);
+  }
+  endTurn(turn) {
+    if (this.pending.size) this.ended.add(turn);
+    for (const [id2, p] of this.pending) if (p.turn === turn) this.finish(id2);
+  }
+  /** Retries can reorder inputs; only UUIDs actually reported as consumed have completed. */
+  complete(ids) {
+    for (const id2 of ids) this.finish(id2);
+  }
+  failAll(error51) {
+    const turns = [...new Set([...this.pending.values()].flatMap((p) => p.turn ? [p.turn] : []))];
+    const pending = [...this.pending.values()];
+    this.pending.clear();
+    this.ended.clear();
+    for (const p of pending) {
+      p.receipt.cancelled = true;
+      p.observer?.fail(error51);
+      p.reject(error51);
+    }
+    return turns;
+  }
+  finish(id2) {
+    const p = this.pending.get(id2);
+    if (!p) return;
+    this.pending.delete(id2);
+    if (!this.pending.size) this.ended.clear();
+    p.receipt.completed = true;
+    p.observer?.complete();
+    p.resolve();
+  }
+};
+
+// packages/agent-host/src/adapters/claude/index.ts
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 
@@ -102543,6 +102712,12 @@ var ClaudeSession = class {
   launch;
   externalId = null;
   queue = [];
+  inputReceipts = new InputReceipts();
+  /** Person messages already handed to the SDK, so an interrupt receipt can report cancellations. */
+  personInputs = /* @__PURE__ */ new Set();
+  trackedInputKnown = false;
+  /** Installed only after the initial CLI metadata confirms the protocol we have verified. */
+  sendTracked;
   /** The CLI version this process last reported (#297) */
   reportedVersion = null;
   notify = null;
@@ -102635,11 +102810,13 @@ var ClaudeSession = class {
         const next = self2.queue.shift();
         if (next !== void 0) {
           self2.inTurn.push(next);
+          if (!next.parentNote) self2.personInputs.add(next.uuid);
           yield {
             type: "user",
             parent_tool_use_id: null,
             session_id: self2.externalId ?? "",
-            message: { role: "user", content: [{ type: "text", text: next }] }
+            uuid: next.uuid,
+            message: { role: "user", content: [{ type: "text", text: next.text }] }
           };
           continue;
         }
@@ -102800,7 +102977,23 @@ var ClaudeSession = class {
         for await (const msg of q2) {
           if (this.closed) break;
           const m = msg;
+          if (!this.turnOpen && m.user_message_uuid && !m.parent_tool_use_id && (m.type === "assistant" || m.type === "stream_event")) {
+            this.turnOpen = true;
+            if (!this.pending.size && !this.questions.size) this.emit({ type: "state_change", sessionId: this.sessionId, state: "working" });
+          }
           if (m.type === "system" && m.subtype === "init" && m.session_id) this.externalId = m.session_id;
+          if (m.type === "system" && m.subtype === "init" && !this.trackedInputKnown) {
+            this.trackedInputKnown = true;
+            const version2 = typeof m.claude_code_version === "string" ? /^(\d+)\.(\d+)\.(\d+)$/.exec(m.claude_code_version) : null;
+            const supported = version2 && (Number(version2[1]) > 2 || Number(version2[1]) === 2 && (Number(version2[2]) > 1 || Number(version2[2]) === 1 && Number(version2[3]) >= 289));
+            if (supported && Array.isArray(m.capabilities) && m.capabilities.includes("interrupt_receipt_v1") && m.capabilities.includes("interrupt_cancel_queued_v1")) {
+              this.sendTracked = (text2, observer) => {
+                const receipt = this.inputReceipts.create(observer);
+                this.sendInput(text2, receipt.id, receipt);
+                return receipt.done;
+              };
+            }
+          }
           if (m.type === "system" && m.subtype === "init" && typeof m.claude_code_version === "string" && m.claude_code_version !== this.reportedVersion) {
             this.reportedVersion = m.claude_code_version;
             this.emit({ type: "agent_version", sessionId: this.sessionId, version: m.claude_code_version });
@@ -102814,8 +103007,23 @@ var ClaudeSession = class {
           if (m.type === "result") this.turnOpen = false;
           let events2 = this.stream.push(msg);
           const retrying = m.type === "result" && this.retryAfterRefreshRace(msg);
+          if (m.type === "result" && !retrying) {
+            const result = msg;
+            for (const id2 of result.user_message_uuids ?? (result.user_message_uuid ? [result.user_message_uuid] : [])) this.personInputs.delete(id2);
+          }
+          let completedInputs;
+          if (m.type === "result" && !retrying && this.inputReceipts.size && events2.some((e) => e.type === "turn_complete" || e.type === "error")) {
+            const result = msg;
+            const ids = result.user_message_uuids ?? [];
+            const failure3 = events2.find((e) => e.type === "error");
+            if (ids.length && failure3?.type === "error") this.cancelParentNotes(new Error(failure3.error.message));
+            else if (ids.length) completedInputs = ids;
+          }
           if (retrying) events2 = events2.filter((e) => e.type !== "error");
-          for (const e of events2) this.emit(e);
+          for (const e of events2) {
+            this.emit(e);
+            if (e.type === "turn_complete" && completedInputs) this.inputReceipts.complete(completedInputs);
+          }
           this.armScheduleLook();
           if (m.type === "result" && !retrying) void this.reportContext(q2);
         }
@@ -102984,14 +103192,18 @@ var ClaudeSession = class {
     }
   }
   send(text2) {
+    this.sendInput(text2);
+  }
+  sendInput(text2, uuid3 = randomUUID8(), note) {
     const goal = isGoalCommand(text2);
     if (!this.sendGate && !(goal && this.goalCommand === void 0)) {
-      this.deliver(text2);
+      this.deliver(text2, uuid3, !!note);
       return;
     }
     const gate = this.sendGate = (this.sendGate ?? this.goalKnown).then(() => {
+      if (note?.cancelled) return;
       if (!this.closed) {
-        this.deliver(text2);
+        this.deliver(text2, uuid3, !!note);
         return;
       }
       this.emit({
@@ -103008,7 +103220,7 @@ var ClaudeSession = class {
       if (this.sendGate === gate) this.sendGate = null;
     });
   }
-  deliver(text2) {
+  deliver(text2, uuid3, parentNote) {
     if (isGoalCommand(text2)) {
       if (this.goalCommand !== true) {
         this.emit({
@@ -103023,11 +103235,12 @@ var ClaudeSession = class {
       }
       this.stream.goal.commandSent();
     }
-    this.queue.push(text2);
+    const starting = !this.turnOpen;
+    this.queue.push({ text: text2, uuid: uuid3, parentNote });
     this.turnOpen = true;
     this.notify?.();
     this.notify = null;
-    this.emit({ type: "state_change", sessionId: this.sessionId, state: "working" });
+    if (starting) this.emit({ type: "state_change", sessionId: this.sessionId, state: "working" });
   }
   respondApproval(requestId, decision, scope, matcher) {
     const p = this.pending.get(requestId);
@@ -103166,7 +103379,11 @@ var ClaudeSession = class {
    *   2) SDK interrupt: this actually cuts the turn. We can call this method because we pass the
    *      prompt as an async generator, in streaming input mode.
    */
-  interrupt() {
+  interrupt(cancelQueued = this.inputReceipts.size > 0, reason = new Error("The parent note was stopped before it finished")) {
+    this.inputReceipts.failAll(reason);
+    const held3 = (cancelQueued ? this.queue.filter((input) => !input.parentNote).length : 0) + (this.retry?.texts.filter((input) => !input.parentNote).length ?? 0);
+    if (cancelQueued) this.queue.length = 0;
+    this.reportUndelivered(held3);
     this.opts.apps?.cancelAll();
     this.cancelRetry();
     for (const [id2, p] of this.pending) {
@@ -103176,7 +103393,13 @@ var ClaudeSession = class {
     this.pending.clear();
     this.releaseQuestions("Stopped by user");
     if (this.turnOpen) this.stream.stopped();
-    void this.query?.interrupt().catch((err) => {
+    void this.query?.interrupt(cancelQueued ? { cancelQueued: true } : void 0).then((response) => {
+      const cancelled = response?.cancelled;
+      if (!Array.isArray(cancelled)) return;
+      let count = 0;
+      for (const id2 of cancelled) if (typeof id2 === "string" && this.personInputs.delete(id2)) count++;
+      this.reportUndelivered(count);
+    }).catch((err) => {
       this.emit({
         type: "error",
         sessionId: this.sessionId,
@@ -103185,6 +103408,34 @@ var ClaudeSession = class {
     });
     this.emit({ type: "state_change", sessionId: this.sessionId, state: "waiting_input", reason: "interrupted" });
   }
+  /** A failed turn is already over. Cancel its parent notes without interrupting the person's next turn. */
+  cancelParentNotes(reason) {
+    const ids = this.inputReceipts.ids;
+    this.inputReceipts.failAll(reason);
+    this.queue = this.queue.filter((input) => !input.parentNote);
+    if (this.retry) {
+      const texts = this.retry.texts;
+      texts.splice(0, texts.length, ...texts.filter((input) => !input.parentNote));
+      if (!texts.length) this.cancelRetry();
+    }
+    const query = this.query;
+    if (!query?.cancelAsyncMessage || this.personInputs.size || this.queue.length || this.retry?.texts.length || this.sendGate) return;
+    for (const id2 of ids) void query.cancelAsyncMessage(id2).catch((error51) => {
+      this.emit({ type: "error", sessionId: this.sessionId, error: {
+        code: "internal",
+        message: `Could not cancel the parent note: ${error51.message}`,
+        retryable: false
+      } });
+    });
+  }
+  reportUndelivered(count) {
+    if (!count) return;
+    this.emit({
+      type: "error",
+      sessionId: this.sessionId,
+      error: { code: "internal", message: `${count} message(s) were still queued when the turn stopped and were not delivered \u2014 please resend`, retryable: false }
+    });
+  }
   /**
    * Stops one background task (#290). Measured on a backgrounded shell: `background_tasks_changed` without it,
    * `task_updated` killed and `task_notification` stopped follow at once, and the stream turns that into the
@@ -103203,6 +103454,7 @@ var ClaudeSession = class {
    * same way; only swapping the process was missing it.
    */
   async dispose() {
+    this.inputReceipts.failAll(new Error("The session closed before the parent note finished"));
     this.closed = true;
     this.notify?.();
     this.settleGoalKnown();
@@ -103244,6 +103496,7 @@ var ClaudeSession = class {
    * the process (#98) — and ends every background task the session listed (#290), for the same reason.
    */
   releaseAgents(why) {
+    this.inputReceipts.failAll(new Error(why));
     if (this.scheduleLook) clearTimeout(this.scheduleLook);
     this.scheduleLook = null;
     for (const e of this.stream.release(why)) this.emit(e);
@@ -103391,6 +103644,8 @@ var ClaudeAdapter = class _ClaudeAdapter {
     processModel: "per-session",
     builtInSubagents: true,
     peerMessaging: true,
+    // The query's prompt iterator reads queued user messages while the current turn continues.
+    midTurnInput: true,
     /*
      * An idle session may be put to sleep (#568): a resumed process read the prompt cache as the live one did (~100% at
      * 2, 6 and 10 min on the 1 h lifetime, CLI 2.1.29x with haiku, #561) for +0.7 s (p50) / +1.8 s (p95) before the first
@@ -105157,6 +105412,8 @@ var CodexSession = class {
    * **that we ourselves started**, and flush the queue as a single turn once that turn ends.
    */
   pendingInputs = [];
+  inputReceipts = new InputReceipts();
+  inputGroups = /* @__PURE__ */ new Map();
   /** An unsteerable turn (compact/review) is running — we know because we are the ones who started it */
   blockingTurn = false;
   /**
@@ -105524,6 +105781,16 @@ var CodexSession = class {
       this.activityBefore = null;
     }
     this.noteAppCall(n);
+    if (n.method === "item/started" || n.method === "item/completed") {
+      const p = n.params ?? {};
+      if (p.item?.type === "userMessage" && p.item.clientId && p.turnId) {
+        const group = this.inputGroups.get(p.item.clientId);
+        if (group) {
+          this.inputGroups.delete(p.item.clientId);
+          this.takeInputTurn({ turn: { id: p.turnId } }, group);
+        }
+      }
+    }
     if (n.method === "turn/completed" && this.blockingTurn) {
       this.blockingTurn = false;
       this.flushPending();
@@ -105541,6 +105808,7 @@ var CodexSession = class {
     }
     if (n.method === "mcpServer/startupStatus/updated" && !this.firstMcpFailure(n.params)) return;
     for (const e of normalizeNotification(this.sessionId, n)) {
+      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((filled) => this.emit(filled));
         continue;
@@ -105559,6 +105827,10 @@ var CodexSession = class {
         else this.activityBefore = e.activity;
       }
       this.emit(e);
+      if (e.type === "turn_complete") {
+        const ended = turnIdOf(n.params);
+        if (ended) this.inputReceipts.endTurn(ended);
+      }
     }
     this.noteSpawn(n);
     if (n.method === "turn/completed" && this.unlinked.size > 0) {
@@ -105730,13 +106002,21 @@ var CodexSession = class {
   applyRules(matchers) {
     this.alwaysAllow.addAll(matchers);
   }
+  sendTracked(text2, observer) {
+    const receipt = this.inputReceipts.create(observer);
+    this.sendInput(text2, receipt);
+    return receipt.done;
+  }
   send(text2) {
+    this.sendInput(text2);
+  }
+  sendInput(text2, receipt) {
     const nth = ++this.sendsIssued;
     void this.ready.then(() => {
-      if (nth <= this.sendsStopped) return;
+      if (nth <= this.sendsStopped || receipt?.cancelled) return;
       if (!this.threadId) throw new Error("Thread is not ready");
       if (this.blockingTurn) {
-        this.pendingInputs.push(text2);
+        this.pendingInputs.push({ text: text2, receipt });
         return;
       }
       if (text2.trim() === "/compact") {
@@ -105789,8 +106069,10 @@ var CodexSession = class {
           say2(status === "active" ? `Goal set: ${arg}` : `Goal set (${status}): ${arg}`);
         });
       }
+      if (receipt) this.inputGroups.set(receipt.id, [receipt]);
       return this.client.request("turn/start", {
         threadId: this.threadId,
+        ...receipt ? { clientUserMessageId: receipt.id } : {},
         input: [{ type: "text", text: text2 }],
         /*
          * Reasoning effort is passed per turn — this is the slot codex documents as applying
@@ -105799,8 +106081,11 @@ var CodexSession = class {
          */
         ...this.opts.effort ? { effort: this.opts.effort } : {},
         ...this.outputSchemaParam()
-      }).then((res) => this.takeStartedTurn(turnIdOf(res)));
+      }).then((res) => this.takeInputTurn(res, receipt ? [receipt] : []));
     }).catch((e) => {
+      if (receipt) this.inputGroups.delete(receipt.id);
+      if (receipt?.cancelled || receipt?.completed) return;
+      if (receipt) this.interrupt(e);
       if (this.startFailed) return;
       this.emit({
         type: "error",
@@ -105812,14 +106097,22 @@ var CodexSession = class {
   /** Sends the messages that were queued out as one turn — each message as its own input item (does not blur the boundary) */
   flushPending() {
     if (this.pendingInputs.length === 0 || !this.threadId) return;
-    const input = this.pendingInputs.map((text2) => ({ type: "text", text: text2 }));
+    const pending = this.pendingInputs;
+    const receipts = pending.flatMap((p) => p.receipt ? [p.receipt] : []);
+    const clientId = receipts[0]?.id;
+    if (clientId) this.inputGroups.set(clientId, receipts);
+    const input = pending.map(({ text: text2 }) => ({ type: "text", text: text2 }));
     this.pendingInputs = [];
     void this.client.request("turn/start", {
       threadId: this.threadId,
+      ...clientId ? { clientUserMessageId: clientId } : {},
       input,
       ...this.opts.effort ? { effort: this.opts.effort } : {},
       ...this.outputSchemaParam()
-    }).then((res) => this.takeStartedTurn(turnIdOf(res))).catch((e) => {
+    }).then((res) => this.takeInputTurn(res, receipts)).catch((e) => {
+      if (clientId) this.inputGroups.delete(clientId);
+      if (receipts.length && receipts.every((r) => r.cancelled || r.completed)) return;
+      if (this.inputReceipts.size) this.interrupt(e);
       this.emit({
         type: "error",
         sessionId: this.sessionId,
@@ -105827,6 +106120,25 @@ var CodexSession = class {
       });
     });
   }
+  takeInputTurn(res, receipts) {
+    if (receipts.length && receipts.every((r) => r.completed)) return;
+    const id2 = turnIdOf(res);
+    if (!receipts.length) {
+      this.takeStartedTurn(id2);
+      return;
+    }
+    if (!id2) {
+      this.interrupt(new Error("Codex did not identify the turn accepting the parent note"));
+      return;
+    }
+    if (receipts.some((r) => r.cancelled) && !this.endedTurns.includes(id2)) {
+      void this.client.request("turn/interrupt", { threadId: this.threadId, turnId: id2 }).catch(() => {
+      });
+    }
+    if (receipts.some((r) => r.cancelled)) return;
+    this.takeStartedTurn(id2);
+    for (const receipt of receipts) this.inputReceipts.bind(receipt, id2);
+  }
   /**
    * Takes a running turn's id from a response, unless the notifications already named one or already ended it. The
    * response and the notifications race: `turn/started` can come after the response (Stop pressed very quickly), and
@@ -105894,7 +106206,14 @@ var CodexSession = class {
     }
     return out;
   }
-  interrupt() {
+  interrupt(reason = new Error("The parent note was stopped before it finished")) {
+    const turns = this.inputReceipts.failAll(reason);
+    this.pendingInputs = this.pendingInputs.filter((p) => !p.receipt);
+    for (const turnId of turns) {
+      if (!this.threadId || turnId === this.turnId || this.endedTurns.includes(turnId)) continue;
+      void this.client.request("turn/interrupt", { threadId: this.threadId, turnId }).catch(() => {
+      });
+    }
     this.opts.apps?.cancelAll();
     if (!this.threadId && this.sendsIssued > this.sendsStopped) {
       this.sendsStopped = this.sendsIssued;
@@ -105927,6 +106246,8 @@ var CodexSession = class {
   }
   /** The app-server is gone, and the child threads with it — each still listed ends as stopped. */
   releaseChildren() {
+    this.inputGroups.clear();
+    this.inputReceipts.failAll(new Error("The session process ended before the parent note finished"));
     for (const e of this.children.release("Ended with the session process")) this.emit(e);
   }
   /**
@@ -106102,6 +106423,8 @@ var CodexAdapter = class {
     processModel: "per-session",
     builtInSubagents: true,
     peerMessaging: false,
+    // 0.160 TurnStartParams: turn/start steers an already-active regular turn; compact/review input is queued.
+    midTurnInput: true,
     /*
      * Not put to sleep (#568). Waking a large thread measured 7-13 s (`thread/resume` scales with the rollout, ~13.5 s for
      * 550 MB), and its cache on resume is unmeasured. The memory is better won by one shared app-server per account
@@ -109950,6 +110273,8 @@ var SessionManager = class {
    * app-server), even though the screen said "starting next turn".
    */
   restartAfterTurn = /* @__PURE__ */ new Set();
+  /** Input arriving after a note completes waits for its deferred process replacement, including disposal. */
+  deferredRestarts = /* @__PURE__ */ new Map();
   /** A new host served a different Centralu tool prefix; replace the old agent at its safe boundary. */
   definitionsRestartAfterTurn = /* @__PURE__ */ new Set();
   /** A kept process was started with adapter settings from an older host build (#589). */
@@ -110061,7 +110386,7 @@ var SessionManager = class {
       throw Object.assign(new Error(`Directory not found: ${path2}`), { code: "internal" });
     }
     const existing = this.store.findProjectByPath(path2);
-    const id2 = existing?.id ?? randomUUID7();
+    const id2 = existing?.id ?? randomUUID9();
     this.store.addProject({ id: id2, path: path2, name: basename5(path2) });
     return this.projectInfo(id2, path2);
   }
@@ -110589,7 +110914,7 @@ var SessionManager = class {
         );
       }
     }
-    const id2 = randomUUID7();
+    const id2 = randomUUID9();
     let worktree = null;
     if (params.worktree && params.projectId) {
       const summary = await gitSummary(params.cwd, this.gitTrust(params.projectId));
@@ -111610,20 +111935,30 @@ var SessionManager = class {
         }
       }
     }
+    const run = e.sessionId ? this.agentRuns.get(e.sessionId) : void 0;
+    run?.onEvent(e);
     this.emit(seq != null ? { ...e, seq } : e);
-    if (endedTurn && e.sessionId) void this.reportBackIfAwaited(e.sessionId, e);
-    if (e.sessionId) this.agentRuns.get(e.sessionId)?.onEvent(e);
+    if (endedTurn && e.sessionId && !run?.tracksInputs) void this.reportBackIfAwaited(e.sessionId, e, run?.completedAnswer);
     if (e.type === "approval_resolved" && e.sessionId) this.raiseHostAsks(e.sessionId);
     if (endedTurn && e.sessionId) this.forgetCommits(e.sessionId);
-    if (endedTurn && e.sessionId && this.restartAfterTurn.delete(e.sessionId)) {
-      const apps = this.appsRestartAfterTurn.delete(e.sessionId);
-      const definitions = this.definitionsRestartAfterTurn.delete(e.sessionId);
-      const launchSettings = this.launchSettingsRestartAfterTurn.delete(e.sessionId);
-      if ((apps || definitions || launchSettings || this.settingsDrifted(e.sessionId)) && this.handles.has(e.sessionId)) {
-        void this.restartSession(e.sessionId, launchSettings ? "launch_settings" : apps ? "thread_restart" : definitions ? "instructions" : this.restartCause(e.sessionId)).catch(() => {
-        });
-      }
-    }
+    if (endedTurn && e.sessionId) this.applyDeferredRestart(e.sessionId);
+  }
+  /** A note receipt follows turn_complete: re-check the same deferred change when the last hold is released. */
+  applyDeferredRestart(sessionId) {
+    const session2 = this.meta.get(sessionId);
+    if (!session2 || inTurn(session2.state) || this.deferredRestarts.has(sessionId) || this.agentRuns.get(sessionId)?.waitingForInputs || !this.restartAfterTurn.delete(sessionId)) return;
+    const apps = this.appsRestartAfterTurn.delete(sessionId);
+    const definitions = this.definitionsRestartAfterTurn.delete(sessionId);
+    const launchSettings = this.launchSettingsRestartAfterTurn.delete(sessionId);
+    if (!(apps || definitions || launchSettings || this.settingsDrifted(sessionId)) || !this.handles.has(sessionId)) return;
+    const cause2 = launchSettings ? "launch_settings" : apps ? "thread_restart" : definitions ? "instructions" : this.restartCause(sessionId);
+    const restarting = Promise.resolve().then(() => this.restartSession(sessionId, cause2)).then(() => {
+    }).finally(() => {
+      if (this.deferredRestarts.get(sessionId) === restarting) this.deferredRestarts.delete(sessionId);
+    });
+    this.deferredRestarts.set(sessionId, restarting);
+    void restarting.catch(() => {
+    });
   }
   /**
    * Notifies the orchestrator when the work it assigned finishes — **the other half of "one window".**
@@ -111637,14 +111972,14 @@ var SessionManager = class {
    *  - Once notified, the marker is cleared. Otherwise that session would wake the orchestrator on
    *    every turn it runs on its own afterward — which would become a loop of waking each other
    */
-  async reportBackIfAwaited(sessionId, ending) {
+  async reportBackIfAwaited(sessionId, ending, answer) {
     const orchestratorId = this.awaitingReport.get(sessionId);
     if (!orchestratorId) return;
     this.awaitingReport.delete(sessionId);
     const target = this.meta.get(sessionId);
     if (!target || !this.meta.has(orchestratorId)) return;
     const project2 = target.projectId ? this.store.listProjects().find((p) => p.id === target.projectId)?.name ?? "(project no longer exists)" : "(none)";
-    await this.deliverReport(orchestratorId, sessionId, target.name, project2, previewOf(this.store, sessionId, 600), ending);
+    await this.deliverReport(orchestratorId, sessionId, target.name, project2, answer?.slice(0, 600) ?? previewOf(this.store, sessionId, 600), ending);
   }
   /** Reports the end of a turn the orchestrator asked to hear about, as one message in its session (#166) */
   async deliverReport(orchestratorId, sessionId, name, project2, preview, ending) {
@@ -111980,7 +112315,9 @@ If you need more, you can read that session's recent conversation with read_sess
    * exposed on send(), which anything else can call — a boundary that can be flipped on by accident
    * is not a boundary.
    */
-  async deliver(sessionId, text2, attachments, from, relayed, fromApp, fromAppVia = "inline") {
+  async deliver(sessionId, text2, attachments, from, relayed, fromApp, fromAppVia = "inline", sendInput) {
+    const restarting = this.deferredRestarts.get(sessionId);
+    if (restarting) await restarting;
     const m = this.meta.get(sessionId);
     if (!m) throw Object.assign(new Error(`Session not found: ${sessionId}`), { code: "session_not_found" });
     if (!this.handles.has(sessionId)) {
@@ -112027,7 +112364,8 @@ If you need more, you can read that session's recent conversation with read_sess
     const adapterText = fromApp ? appMessageFrame(fromApp, text2, fromAppVia) : from && (relayed || this.directs(sessionId) && !this.directs(from.sessionId) && from.sessionId !== HUB_SENDER) ? untrustedSourceSessionNotification(from.sessionId) : attachments?.length ? `${text2}
 
 ${attachments.map((a) => `@${a.path}`).join("\n")}` : text2;
-    h.send(adapterText);
+    if (sendInput) sendInput(h, adapterText);
+    else h.send(adapterText);
   }
   /**
    * Switches a session's agent (claude <-> codex).
@@ -112710,6 +113048,7 @@ ${String(stderr).slice(0, 2e3)}`
   sessionIdle(sessionId) {
     const m = this.meta.get(sessionId);
     if (!m) throw Object.assign(new Error(`Session not found: ${sessionId}`), { code: "session_not_found" });
+    if (this.agentRuns.get(sessionId)?.waitingForInputs) return { idle: false, reason: "turn" };
     return sessionIdle(m, {
       running: this.handles.has(sessionId),
       reportsBackground: !!this.adapters.get(m.tool)?.capabilities.backgroundTasks
@@ -112737,7 +113076,7 @@ ${String(stderr).slice(0, 2e3)}`
    */
   async sleepSession(sessionId) {
     const h = this.handles.get(sessionId);
-    if (!h || this.resuming.has(sessionId) || this.sleeping.has(sessionId) || this.leaving.has(sessionId)) return false;
+    if (!h || this.resuming.has(sessionId) || this.deferredRestarts.has(sessionId) || this.sleeping.has(sessionId) || this.leaving.has(sessionId)) return false;
     if (!this.sessionIdle(sessionId).idle || this.waitsOn(sessionId).length > 0) return false;
     this.handles.delete(sessionId);
     this.running.delete(sessionId);
@@ -112757,12 +113096,13 @@ ${String(stderr).slice(0, 2e3)}`
     return true;
   }
   interrupt(sessionId) {
-    this.requireHandle(sessionId).interrupt();
+    const handle = this.requireHandle(sessionId);
+    const run = this.agentRuns.get(sessionId);
+    if (run) run.stoppedByPerson = true;
+    handle.interrupt();
     for (const d2 of this.delegations.values()) {
       if (d2.callerId === sessionId && (!d2.agent || (d2.waiters ?? 0) > 0)) d2.stop("the person stopped the session that asked");
     }
-    const run = this.agentRuns.get(sessionId);
-    if (run) run.stoppedByPerson = true;
   }
   /**
    * Restarts only the agent (an extension of FR-10).
@@ -113402,7 +113742,7 @@ ${String(stderr).slice(0, 2e3)}`
   askHost(sessionId, detail, signal) {
     return new Promise((resolve11) => {
       if (signal?.aborted) return resolve11(null);
-      const requestId = `${detail.kind === "project_access" ? "xp" : detail.kind === "agent_start" ? "ag" : detail.kind === "centralu_update" ? "up" : "mk"}-${randomUUID7()}`;
+      const requestId = `${detail.kind === "project_access" ? "xp" : detail.kind === "agent_start" ? "ag" : detail.kind === "centralu_update" ? "up" : "mk"}-${randomUUID9()}`;
       this.hostAsks.set(requestId, { requestId, sessionId, detail, shown: false, resolve: resolve11 });
       signal?.addEventListener("abort", () => {
         if (!this.hostAsks.delete(requestId)) return;
@@ -113528,31 +113868,38 @@ ${String(stderr).slice(0, 2e3)}`
   /** Registers the wait on the delegated session's turn (the same watcher an app's agent uses, `AgentRunWait`) */
   startDelegation(key, callerId, sessionId, target, agent = false) {
     let notice;
-    const wait = new AgentRunWait((message) => notice = message, () => this.meta.get(sessionId)?.name ?? "the session");
+    let answerAfter = this.meta.get(sessionId)?.lastSeq ?? 0;
+    const wait = new AgentRunWait((message) => notice = message, () => this.meta.get(sessionId)?.name ?? "the session", void 0, () => {
+      const answer = finalAnswer(this.store.loadMessages(sessionId, 50).filter((m) => m.seq > answerAfter));
+      answerAfter = this.meta.get(sessionId)?.lastSeq ?? answerAfter;
+      return answer;
+    });
     const d2 = {
       callerId,
       sessionId,
       target,
       wait,
-      settled: false,
+      get settled() {
+        return wait.finished;
+      },
       notice: () => notice,
       outcome: wait.done.then(
-        () => ({ ok: true }),
+        (r) => ({ ok: true, answer: r.answer }),
         (e) => ({ ok: false, error: e.message })
       ),
       stop: (why) => {
         if (d2.settled) return;
+        wait.fail(new Error(`${why}, so the delegated turn was stopped`));
         try {
           this.handles.get(sessionId)?.interrupt();
         } catch {
         }
-        wait.fail(new Error(`${why}, so the delegated turn was stopped`));
       },
       ...agent ? { agent: true } : {}
     };
-    void d2.outcome.then(() => {
-      d2.settled = true;
+    void d2.outcome.then((r) => {
       if (this.agentRuns.get(sessionId) === wait) this.agentRuns.delete(sessionId);
+      if (agent) void this.reportBackIfAwaited(sessionId, r.ok ? { type: "turn_complete", sessionId } : { type: "error", sessionId, error: { code: "internal", message: r.error, retryable: false } }, r.ok ? r.answer : void 0);
     });
     this.agentRuns.set(sessionId, wait);
     this.delegations.set(key, d2);
@@ -113589,7 +113936,7 @@ ${String(stderr).slice(0, 2e3)}`
           error: `${d2.target.name}'s session "${sessionName()}" [${d2.sessionId}] did not finish: ${r.error}. Tell the person, or ask again with a clearer task.`
         };
       }
-      const answer = finalAnswer(this.store.loadMessages(d2.sessionId, 50));
+      const answer = r.answer ?? finalAnswer(this.store.loadMessages(d2.sessionId, 50));
       const { granted, outside } = readableGrants(pathsIn(answer), d2.target.path);
       if (granted.length) {
         const set3 = this.readGrants.get(d2.callerId) ?? /* @__PURE__ */ new Set();
@@ -113708,8 +114055,8 @@ ${String(stderr).slice(0, 2e3)}`
    *
    *   status  where it stands, without waiting (the answer, once the turn the caller gave it has ended)
    *   wait    waits on that turn up to the bound, as start_agent does
-   *   send    gives it more: refused while a turn the caller gave it runs, while it works on the person's own
-   *           message, or when the person has since raised its preset above the caller's
+   *   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  cleans up a child's merged, clean worktree (`cleanUpWorktreeChild`, #76's hard gate, part 3)
    */
@@ -113743,26 +114090,48 @@ ${String(stderr).slice(0, 2e3)}`
         return { ok: true, state: "deleted", sessionId: child.id, sessionName: child.name, tool: child.tool, branch: r.branch, proof: r.proof };
       }
       case "send": {
-        if (d2 && !d2.settled) {
-          return { ok: false, error: `"${child.name}" is still working on what you gave it. Wait for it (action "wait") or stop it first.` };
-        }
-        if (d2) this.delegations.delete(key);
-        if (child.state === "working" || child.state === "waiting_approval" || this.agentRuns.has(child.id)) {
-          return { ok: false, error: `"${child.name}" is busy with something else (the person may be using it). Try again later.` };
-        }
         if (!presetWithin(child.permissionPreset, caller.permissionPreset)) {
           return {
             ok: false,
             error: `"${child.name}" now has more permissions (${child.permissionPreset}) than this session (${caller.permissionPreset}), so this session cannot give it work. Tell the person.`
           };
         }
+        const from = { sessionId: callerId, name: labelOf(this.store, caller) };
+        if (d2 && !d2.settled) {
+          const text2 = agentNoteFrame(from.name, opts.text ?? "");
+          if (!this.adapters.get(child.tool)?.capabilities.midTurnInput || !this.handles.get(child.id)?.sendTracked) {
+            return { ok: false, error: `"${child.name}" cannot take messages while working. Wait for it (action "wait") or stop it first.` };
+          }
+          const releaseHold = d2.wait.holdInput();
+          const release = () => {
+            releaseHold();
+            this.applyDeferredRestart(child.id);
+          };
+          try {
+            await this.deliver(child.id, text2, void 0, from, false, void 0, "inline", (h, input) => {
+              const fail4 = (e) => {
+                d2.wait.fail(e);
+                release();
+              };
+              void h.sendTracked(input, { complete: release, fail: fail4 }).then(release, fail4);
+            });
+          } catch (e) {
+            release();
+            return { ok: false, error: `Could not send it: ${e.message}` };
+          }
+          return this.agentWorking(d2, false);
+        }
+        if (child.state === "working" || child.state === "waiting_approval" || this.agentRuns.has(child.id) && !this.agentRuns.get(child.id).finished) {
+          return { ok: false, error: `"${child.name}" is busy with something else (the person may be using it). Try again later.` };
+        }
+        if (d2) this.delegations.delete(key);
         const full = this.agentCeilingError(child.projectId ?? "");
         if (full) return { ok: false, error: full };
         const project2 = this.store.listProjects().find((p) => p.id === child.projectId);
         const cwd = this.store.sessionCwd(child.id) ?? child.worktree?.path ?? project2?.path ?? "";
         const next = this.startDelegation(key, callerId, child.id, { id: child.projectId ?? "", name: project2?.name ?? "", path: cwd }, true);
         try {
-          await this.deliver(child.id, opts.text ?? "", void 0, { sessionId: callerId, name: labelOf(this.store, caller) }, false);
+          await this.deliver(child.id, agentFrame(from.name, opts.text ?? ""), void 0, from, false);
         } catch (e) {
           this.delegations.delete(key);
           if (this.agentRuns.get(child.id) === next.wait) this.agentRuns.delete(child.id);
@@ -113782,7 +114151,7 @@ ${String(stderr).slice(0, 2e3)}`
     if (!summary.isRepo) return { error: "This project is not a git repository, so it has no worktrees. Start the agent without one." };
     const asked = opts.branch?.trim();
     if (asked) return await gitValidBranchName(asked) ? { branch: asked } : { error: `Not a valid branch name: ${asked}` };
-    return { branch: agentBranch(opts.task, randomUUID7()) };
+    return { branch: agentBranch(opts.task, randomUUID9()) };
   }
   /**
    * Cleans up a child's merged worktree (#76's hard gate, moved from the retired worktree manager's tool to
@@ -113951,7 +114320,7 @@ ${String(stderr).slice(0, 2e3)}`
       if (r === "bound") return this.agentWorking(d2);
       if (this.delegations.get(key) === d2) this.delegations.delete(key);
       if (!r.ok) return { ok: false, error: `"${name()}" [${d2.sessionId}] did not finish: ${r.error}. Tell the person, or give it a clearer task.` };
-      const answer = finalAnswer(this.store.loadMessages(d2.sessionId, 50));
+      const answer = r.answer ?? finalAnswer(this.store.loadMessages(d2.sessionId, 50));
       const { granted, outside } = readableGrants(pathsIn(answer), d2.target.path);
       if (granted.length) {
         const set3 = this.readGrants.get(d2.callerId) ?? /* @__PURE__ */ new Set();
@@ -113978,7 +114347,7 @@ ${String(stderr).slice(0, 2e3)}`
       if (signal.aborted) return resolve11(null);
       const app2 = { appId: q2.app.appId, projectId: q2.app.projectId, name: q2.appName };
       if (q2.origin.kind === "session" && this.meta.has(q2.origin.sessionId)) {
-        const requestId = `cap-${randomUUID7()}`;
+        const requestId = `cap-${randomUUID9()}`;
         const ask = {
           requestId,
           sessionId: q2.origin.sessionId,
@@ -113997,7 +114366,7 @@ ${String(stderr).slice(0, 2e3)}`
         return;
       }
       const origin = q2.origin.kind === "view" ? q2.origin.app : q2.app;
-      const id2 = `q-${randomUUID7()}`;
+      const id2 = `q-${randomUUID9()}`;
       this.appQuestions.set(id2, {
         question: { id: id2, app: app2, capability: q2.capability, text: q2.text, origin: { appId: origin.appId, projectId: origin.projectId }, askedAt: q2.askedAt, expiresAt: q2.expiresAt },
         resolve: resolve11
@@ -115032,13 +115401,24 @@ async function stopStrays(pids, roots, selfPid = process.pid, held3 = []) {
 }
 
 // packages/agent-host/src/app-home-view.ts
-async function openHomeView(apps, views2, ref, holder) {
+async function openHomeView(apps, views2, ref, holder, openKey) {
+  const prior = openKey ? views2.homeOpen(ref, openKey, holder) : null;
+  if (prior) return prior;
   const home = await apps.homeView(ref);
+  const concurrent = openKey ? views2.homeOpen(ref, openKey, holder) : null;
+  if (concurrent) return concurrent;
   const toolInput = {};
-  const out = await apps.call(ref, home.tool, toolInput, { kind: "view" });
-  if (!out.result) throw Object.assign(new Error(out.error ?? `The home tool "${home.tool}" did not answer`), { code: "internal" });
-  const { instanceId } = views2.open(ref, home.resourceUri, holder);
-  return { instanceId, tool: home.tool, resourceUri: home.resourceUri, toolInput, toolResult: out.result, runId: out.runId };
+  const invoke = async () => {
+    const out = await apps.call(ref, home.tool, toolInput, { kind: "view" });
+    if (!out.result) throw Object.assign(new Error(out.error ?? `The home tool "${home.tool}" did not answer`), { code: "internal" });
+    return { tool: home.tool, resourceUri: home.resourceUri, toolInput, toolResult: out.result, runId: out.runId };
+  };
+  if (openKey) {
+    const { instanceId } = views2.open(ref, home.resourceUri, holder);
+    return views2.rememberHome(instanceId, openKey, async () => ({ instanceId, ...await invoke() }));
+  }
+  const outcome = await invoke();
+  return { ...views2.open(ref, home.resourceUri, holder), ...outcome };
 }
 
 // packages/agent-host/src/builder-requests.ts
@@ -115351,8 +115731,14 @@ function createRpcHandler(mgr2, adapters2, { terminals: terminals2, updates: upd
       return { appId: d2.app.appId, projectId: d2.app.projectId, uri: d2.uri, origin: d2.origin, resource: d2.resource };
     },
     "apps.openView": async (p, ctx) => {
-      const { appId, projectId, lease } = RpcMethods["apps.openView"].params.parse(p);
-      return openHomeView(requireExternalApps(), requireViews(), { appId, projectId }, lease && ctx ? ctx.client : void 0);
+      const { appId, projectId, lease, openKey } = RpcMethods["apps.openView"].params.parse(p);
+      return openHomeView(requireExternalApps(), requireViews(), { appId, projectId }, lease && ctx ? ctx.client : void 0, openKey);
+    },
+    "apps.recoverView": async (p, ctx) => {
+      const { appId, projectId, openKey, lease } = RpcMethods["apps.recoverView"].params.parse(p);
+      const prior = requireViews().homeOpen({ appId, projectId }, openKey, lease && ctx ? ctx.client : void 0);
+      if (prior) return prior;
+      throw new Error("The original app open could not be recovered \u2014 the home tool may or may not have run; check before opening again");
     },
     "apps.holdViews": async (p, ctx) => {
       const { instanceIds } = RpcMethods["apps.holdViews"].params.parse(p);
@@ -120129,6 +120515,7 @@ var ROUTES = {
    * link, not the window, so its views are opened without one and live until closed, as before
    */
   "apps.openView": { kind: "project", orMachine: true, result: (r, q2) => q2.openedView(r), params: ({ lease: _lease, ...p }) => p },
+  "apps.recoverView": { kind: "project", orMachine: true, result: (r, q2) => q2.openedView(r), params: ({ lease: _lease, ...p }) => p },
   "apps.readResource": view(["projectId", "instanceId"]),
   "apps.invoke": view(["projectId", "instanceId"]),
   "apps.inlineReopen": session((r, q2) => q2.inlineView(r)),
@@ -120488,7 +120875,7 @@ function storeMirror(store2) {
 var start = new StartSequence();
 start.at("launch variables");
 var launch = takeLaunchEnv();
-var BUILD = true ? "60665cc" : "dev";
+var BUILD = true ? "c6afa2e" : "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.19",
+  "version": "0.1.0-beta.20",
   "description": "Centralu's host without the window, for Linux on arm64: what a hub installs on a linked machine",
   "license": "MIT",
   "author": "ijun17",