pinomad 0.12.0 → 0.14.0

package/dist/{chunk-ksfxqd8s.js → chunk-35szq73k.js}

@@ -5,7 +5,7 @@ import {
   openHostSettings,
   sameList,
   settingsDefaults
-} from "./chunk-nppgxh6c.js";
+} from "./chunk-6j6hkfbj.js";
 import {
   DevicesDoc,
   RevocationsDoc,
@@ -14,7 +14,7 @@ import {
   loadHostKey,
   loadRelayKey,
   pairingOffers
-} from "./chunk-t91zt5f0.js";
+} from "./chunk-hg9gs396.js";
 import {
   REMOVAL_NOTICE_FILE,
   markRemoved,
@@ -30,18 +30,34 @@ import {
   relayHostId,
   relayWsBase,
   startRelayLink
-} from "./chunk-g3ahp7b9.js";
+} from "./chunk-9trbbz4r.js";
+import {
+  installCommand,
+  npmBeside,
+  outputTail,
+  packagePrefix,
+  parseRelease,
+  viewCommand
+} from "./chunk-0dh2k3er.js";
+import {
+  serviceManager
+} from "./chunk-mxwcnnkg.js";
 import {
   ATTACHMENT_TTL_MS,
+  HOST_UPGRADING_ERROR,
   INVALID_FRAME_CLOSE_CODE,
   MAX_ATTACHMENTS_PER_MESSAGE,
   MAX_ATTACHMENT_NAME_LENGTH,
   MAX_PENDING_ATTACHMENTS,
   MAX_PENDING_ATTACHMENT_BYTES,
+  MAX_TRANSCRIPT_PAGE,
   PROTOCOL,
+  QuestionItemSchema,
+  QuestionSchema,
   RTC_DATA_CHANNEL_LABEL,
   RTC_DEFAULT_STUN,
   RTC_MAX_RECORD_BYTES,
+  TodoItemSchema,
   UNAUTHORIZED_CLOSE_CODE,
   attachmentBeginProblem,
   attachmentBlock,
@@ -49,6 +65,7 @@ import {
   base64DecodedLength,
   isAttachmentId,
   isCustomProviderApi,
+  isProcessActive,
   organize,
   parseAttachmentBlock,
   parseClientFrame,
@@ -56,7 +73,7 @@ import {
   rtcCandidateType,
   sdpCandidates,
   withRtcCandidates
-} from "./chunk-47ff1d1t.js";
+} from "./chunk-1mjbt2z2.js";
 import {
   ENDPOINT_SET_SCHEMA_VERSION,
   MAX_HOST_ENDPOINT_URL_LENGTH,
@@ -72,29 +89,348 @@ import {
   parseEndpointSet,
   respondIK,
   toBase64Url
-} from "./chunk-pqe7q1s7.js";
+} from "./chunk-6vbp1vva.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-ngf1zatm.js";
 import {
   packagedVersion,
   webRoot
-} from "./chunk-7wj0jh3t.js";
+} from "./chunk-1rdbnvy6.js";
 import {
   __require
 } from "./chunk-df32avw6.js";
 
 // apps/host/src/main.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { join as join12, resolve as resolve7 } from "node:path";
+import { join as join13, resolve as resolve7 } from "node:path";
 import { parseArgs } from "node:util";
 import { createModels } from "@earendil-works/pi-ai/models";
 import { fauxAssistantMessage, fauxProvider } from "@earendil-works/pi-ai/providers/faux";
 import { ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { createNodePhotonImages } from "@earendil-works/pi-durable/images/node";
 
+// apps/host/src/upgrade/host-upgrader.ts
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+
+// apps/host/src/upgrade/upgrader.ts
+var CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+var AUTO_TICK_MS = 60 * 1000;
+var AUTO_MIN_AGE_MS = 3 * 24 * 60 * 60 * 1000;
+var AUTO_QUIET_MS = 15 * 60 * 1000;
+var sameUpgrade = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+var message = (error) => error instanceof Error ? error.message : String(error);
+function compareVersions(a, b) {
+  const parse = (version) => {
+    const [core = "", pre] = version.split("-", 2);
+    return { parts: core.split(".").map((part) => Number.parseInt(part, 10) || 0), pre };
+  };
+  const x = parse(a);
+  const y = parse(b);
+  for (let i = 0;i < Math.max(x.parts.length, y.parts.length); i++) {
+    const diff = (x.parts[i] ?? 0) - (y.parts[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  if (x.pre === y.pre)
+    return 0;
+  if (x.pre === undefined)
+    return 1;
+  if (y.pre === undefined)
+    return -1;
+  return x.pre < y.pre ? -1 : 1;
+}
+
+class HostUpgrader {
+  #options;
+  #published;
+  #stops = [];
+  #check;
+  #lastActivity;
+  #admitting = 0;
+  constructor(options) {
+    this.#options = options;
+    this.#lastActivity = options.now();
+    this.#published = new Published({
+      current: options.current,
+      available: null,
+      blocked: null,
+      phase: "idle",
+      target: null,
+      attempt: 0,
+      checking: false,
+      checkedAt: null,
+      checkError: null,
+      failure: null
+    }, sameUpgrade);
+  }
+  get value() {
+    return this.#published.value;
+  }
+  subscribe(listener) {
+    return this.#published.subscribe(listener);
+  }
+  get installing() {
+    return this.value.phase === "installing";
+  }
+  async begin() {
+    const { busy, mode, every } = this.#options;
+    this.#stops.push(busy.subscribe((value) => {
+      this.touch();
+      if (!value)
+        this.#installIfIdle();
+    }), mode.subscribe((value) => {
+      if (value !== "off")
+        this.check().catch(() => {});
+    }), every(CHECK_INTERVAL_MS, () => void this.check().catch(() => {})), every(AUTO_TICK_MS, () => this.#autoTick()));
+    await this.#refreshBlocked();
+    if (mode.value !== "off")
+      this.check().catch(() => {});
+  }
+  close() {
+    for (const stop of this.#stops.splice(0))
+      stop();
+  }
+  touch() {
+    this.#lastActivity = this.#options.now();
+  }
+  admit() {
+    if (this.installing)
+      throw new Error(HOST_UPGRADING_ERROR);
+    this.touch();
+    this.#admitting++;
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      this.#admitting--;
+      this.touch();
+    };
+  }
+  check() {
+    if (this.#options.mode.value === "off")
+      return Promise.reject(new Error("Upgrade checks are off on this host"));
+    this.#check ??= this.#runCheck().finally(() => {
+      this.#check = undefined;
+    });
+    return this.#check;
+  }
+  async start(when) {
+    await this.#refreshBlocked();
+    const { blocked, available, phase } = this.value;
+    if (blocked !== null)
+      throw new Error(`This host can't upgrade itself (${blocked})`);
+    if (phase !== "idle")
+      throw new Error("An upgrade is already in progress");
+    if (available === null)
+      throw new Error("No newer release");
+    this.#begin(when, available.version);
+  }
+  #begin(when, version) {
+    this.#set({ attempt: this.value.attempt + 1 });
+    if (when === "now" || !this.#busy())
+      this.#install(version);
+    else
+      this.#set({ phase: "waiting", target: version });
+  }
+  #busy() {
+    return this.#options.busy.value || this.#admitting > 0;
+  }
+  #installIfIdle() {
+    if (this.value.phase === "waiting" && !this.#busy())
+      this.#install(this.value.target);
+  }
+  cancel() {
+    if (this.value.phase === "installing")
+      throw new Error("The upgrade is installing and can't be cancelled");
+    if (this.value.phase === "waiting")
+      this.#set({ phase: "idle", target: null });
+  }
+  async#runCheck() {
+    this.#set({ checking: true });
+    try {
+      const release = await this.#options.latest();
+      const newer = compareVersions(release.version, this.#options.current) > 0;
+      this.#set({
+        checking: false,
+        checkedAt: this.#options.now(),
+        checkError: null,
+        available: newer ? {
+          version: release.version,
+          publishedAt: release.publishedAt,
+          crossesMajor: release.protocolMajor !== this.#options.protocolMajor
+        } : null
+      });
+    } catch (error) {
+      this.#set({ checking: false, checkedAt: this.#options.now(), checkError: message(error) });
+      throw error;
+    }
+  }
+  async#refreshBlocked() {
+    this.#set({ blocked: await this.#options.blocked() });
+  }
+  #autoTick() {
+    if (this.#busy())
+      this.touch();
+    this.#installIfIdle();
+    const candidate = this.#autoCandidate();
+    if (candidate === undefined)
+      return;
+    this.#refreshBlocked().then(() => {
+      if (this.#autoCandidate() === candidate)
+        this.#begin("idle", candidate);
+    }, () => {});
+  }
+  #autoCandidate() {
+    const { mode, now } = this.#options;
+    const { available, blocked, phase, failure } = this.value;
+    if (mode.value !== "auto" || phase !== "idle" || blocked !== null || available === null)
+      return;
+    if (available.crossesMajor || failure?.version === available.version)
+      return;
+    if (now() - available.publishedAt < AUTO_MIN_AGE_MS || this.#busy() || now() - this.#lastActivity < AUTO_QUIET_MS) {
+      return;
+    }
+    return available.version;
+  }
+  async#install(version) {
+    this.#set({ phase: "installing", target: version });
+    try {
+      await this.#options.drain?.();
+    } catch (error) {
+      this.#set({ phase: "idle", target: null, failure: { version, message: message(error), attempt: this.value.attempt } });
+      return;
+    }
+    let result;
+    try {
+      result = await this.#options.install(version);
+    } catch (error) {
+      result = { ok: false, message: message(error) };
+    }
+    if (result.ok) {
+      this.#options.restart();
+      return;
+    }
+    this.#set({ phase: "idle", target: null, failure: { version, message: result.message, attempt: this.value.attempt } });
+  }
+  #set(patch) {
+    this.#published.set({ ...this.value, ...patch });
+  }
+}
+
+// apps/host/src/upgrade/host-upgrader.ts
+var exec = promisify(execFile);
+var withPath = (npm) => npm.binDir === undefined ? process.env : { ...process.env, PATH: `${npm.binDir}:${process.env.PATH ?? ""}` };
+var UPGRADE_EXIT_CODE = 75;
+async function upgradeBlocker(dataDir, {
+  packaged = packagedVersion !== undefined && packagePrefix() !== undefined,
+  manager = serviceManager
+} = {}) {
+  if (!packaged)
+    return "source";
+  try {
+    const service = manager();
+    const spec = await service.read();
+    if (spec === undefined || spec.dataDir !== dataDir)
+      return "no-service";
+    const state = await service.state();
+    if (!state.installed)
+      return "no-service";
+    if (state.stopped)
+      return "stopped";
+    return state.running ? null : "no-service";
+  } catch {
+    return "no-service";
+  }
+}
+async function latestRelease() {
+  const npm = viewCommand(npmBeside(process.execPath));
+  const { stdout } = await exec(npm.command, [...npm.args], { env: withPath(npm), timeout: 60000 });
+  return parseRelease(stdout);
+}
+function installRelease(version) {
+  const prefix = packagePrefix();
+  if (prefix === undefined)
+    return Promise.resolve({ ok: false, message: "pinomad isn't a global npm install" });
+  const npm = installCommand(npmBeside(process.execPath), prefix, `pinomad@${version}`);
+  return new Promise((resolve) => {
+    let output = "";
+    const child = spawn(npm.command, [...npm.args], { env: withPath(npm), stdio: ["ignore", "pipe", "pipe"] });
+    const collect = (chunk) => {
+      output = (output + chunk.toString("utf8")).slice(-64 * 1024);
+    };
+    child.stdout.on("data", collect);
+    child.stderr.on("data", collect);
+    child.once("error", (error) => resolve({ ok: false, message: error.message }));
+    child.once("exit", (code, signal) => resolve(code === 0 ? { ok: true } : { ok: false, message: outputTail(output) || `npm exited with ${signal ?? code}` }));
+  });
+}
+async function busyValue(harness, context) {
+  const watch = await harness.watchTaskGraph(context);
+  const busy = new Published(Object.keys(watch.value.tasks).length > 0, (a, b) => a === b);
+  watch.start((call) => {
+    if (call.kind === "value")
+      busy.set(Object.keys(call.value.tasks).length > 0);
+    return Promise.resolve();
+  });
+  return Object.assign(busy, { stop: () => watch.stop() });
+}
+function mergedBusy(tasks, processes) {
+  if (processes === undefined)
+    return tasks;
+  const busy = new Published(tasks.value || processes.value, (a, b) => a === b);
+  const stopTasks = tasks.subscribe((value) => busy.set(value || processes.value));
+  const stopProcesses = processes.subscribe((value) => busy.set(tasks.value || value));
+  return Object.assign(busy, {
+    stop: () => {
+      stopTasks();
+      stopProcesses();
+      tasks.stop();
+    }
+  });
+}
+function modeValue(settings) {
+  const mode = new Published(settings.value.autoUpgrade ?? "notify", (a, b) => a === b);
+  const stop = settings.subscribe((value) => mode.set(value.autoUpgrade ?? "notify"));
+  return Object.assign(mode, { stop });
+}
+var every = (ms, run) => {
+  const timer = setInterval(run, ms);
+  timer.unref();
+  return () => clearInterval(timer);
+};
+async function startHostUpgrader(options) {
+  const taskBusy = await busyValue(options.harness, options.context);
+  const busy = mergedBusy(taskBusy, options.processesBusy);
+  const mode = modeValue(options.settings);
+  const { seams } = options;
+  const upgrader = new HostUpgrader({
+    current: options.current,
+    protocolMajor: PROTOCOL.major,
+    blocked: seams.blocked ?? (() => upgradeBlocker(options.dataDir)),
+    latest: seams.latest ?? latestRelease,
+    install: seams.install ?? installRelease,
+    restart: seams.restart,
+    ...options.drain === undefined ? {} : { drain: options.drain },
+    busy,
+    mode,
+    now: Date.now,
+    every: seams.every ?? every
+  });
+  const close = upgrader.close.bind(upgrader);
+  upgrader.close = () => {
+    close();
+    busy.stop();
+    mode.stop();
+  };
+  await upgrader.begin();
+  return upgrader;
+}
+
 // apps/host/src/extensions/question.ts
 import {
   defineDoc,
@@ -102,55 +438,7 @@ import {
   defineTask,
   defineTool
 } from "@earendil-works/pi-durable";
-import { Type as Type2 } from "typebox";
-
-// packages/protocol/src/presentation.ts
 import { Type } from "typebox";
-import { Value } from "typebox/value";
-var TodoItemSchema = Type.Object({
-  text: Type.String({ minLength: 1 }),
-  status: Type.Union([Type.Literal("pending"), Type.Literal("in_progress"), Type.Literal("completed")])
-});
-var TodoSchema = Type.Object({ items: Type.Array(TodoItemSchema) });
-var QuestionOptionSchema = Type.Object({
-  label: Type.String({ minLength: 1 }),
-  description: Type.Optional(Type.String())
-});
-var QuestionItemSchema = Type.Object({
-  question: Type.String({ minLength: 1 }),
-  header: Type.String({ minLength: 1, maxLength: 16 }),
-  options: Type.Array(QuestionOptionSchema, { minItems: 2, maxItems: 4 }),
-  multiSelect: Type.Optional(Type.Boolean())
-});
-var QuestionAnswerSchema = Type.Object({
-  selected: Type.Array(Type.String()),
-  other: Type.Optional(Type.String())
-});
-var QuestionResolutionSchema = Type.Union([
-  Type.Object({ outcome: Type.Literal("answered"), answers: Type.Array(QuestionAnswerSchema), at: Type.Number() }),
-  Type.Object({ outcome: Type.Literal("dismissed"), at: Type.Number() }),
-  Type.Object({ outcome: Type.Literal("cancelled"), at: Type.Number() })
-]);
-var QuestionRequestSchema = Type.Object({
-  id: Type.String({ minLength: 1 }),
-  questions: Type.Array(QuestionItemSchema, { minItems: 1, maxItems: 4 }),
-  askedAt: Type.Number(),
-  resolution: Type.Optional(QuestionResolutionSchema)
-});
-var QuestionSchema = Type.Object({ requests: Type.Array(QuestionRequestSchema) });
-var DiffSchema = Type.Object({ patch: Type.String() });
-var CodemodeCallSchema = Type.Object({
-  id: Type.Optional(Type.Number()),
-  name: Type.String(),
-  args: Type.String(),
-  status: Type.Union([Type.Literal("running"), Type.Literal("ok"), Type.Literal("error"), Type.Literal("cancelled")]),
-  durationMs: Type.Optional(Type.Number()),
-  error: Type.Optional(Type.String()),
-  details: Type.Optional(Type.Unknown())
-});
-var CodemodeSchema = Type.Object({ code: Type.Optional(Type.String()), calls: Type.Array(CodemodeCallSchema) });
-
-// apps/host/src/extensions/question.ts
 var QuestionDoc = defineDoc({
   kind: "question.requests",
   version: 1,
@@ -178,8 +466,10 @@ var QuestionWait = defineTask({
             resolve(initial);
             return;
           }
-          watch.start(async (value) => {
-            const found = resolutionOf(value, task.input.requestId);
+          watch.start(async (call) => {
+            if (call.kind !== "value")
+              return;
+            const found = resolutionOf(call.value, task.input.requestId);
             if (found !== undefined)
               resolve(found);
           });
@@ -224,8 +514,8 @@ var askUserQuestion = defineTool({
   name: "ask_user_question",
   callers: ["model"],
   description: "Ask the user 1–4 multiple-choice questions when their decision is needed to proceed (ambiguous requirements, choosing between approaches, scope). Blocks until answered. The user can always type a custom answer, so never add an 'Other' option. Keep everything short: headers a word or two, option labels a few words. Usually leave option descriptions out; add one only when the label alone is ambiguous, as one line of at most ~60 characters.",
-  parameters: Type2.Object({
-    questions: Type2.Array(QuestionItemSchema, { minItems: 1, maxItems: 4 })
+  parameters: Type.Object({
+    questions: Type.Array(QuestionItemSchema, { minItems: 1, maxItems: 4 })
   }),
   replay: "safe",
   execute: async (args, api, context) => {
@@ -294,31 +584,31 @@ function createCodemode() {
 }
 
 // apps/host/src/extensions/context.ts
-import { dirname as dirname2, sep as sep4 } from "node:path";
+import { dirname as dirname2, sep as sep5 } from "node:path";
 import { defineExtension as defineExtension2, section } from "@earendil-works/pi-durable";
 import { formatSkillsForPrompt, loadProjectContextFiles } from "@earendil-works/pi-coding-agent";
 
 // apps/host/src/skills.ts
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { existsSync } from "node:fs";
 import { realpath as realpath4, stat as stat4 } from "node:fs/promises";
-import { dirname, join as join4, relative as relative2, resolve as resolve3, sep as sep3 } from "node:path";
-import { promisify as promisify2 } from "node:util";
+import { dirname, join as join4, relative as relative2, resolve as resolve3, sep as sep4 } from "node:path";
+import { promisify as promisify3 } from "node:util";
 import { AgentDoc as AgentDoc3 } from "@earendil-works/pi-durable";
 import { loadSkills } from "@earendil-works/pi-coding-agent";
 
 // apps/host/src/checkout.ts
-import { execFile, spawn } from "node:child_process";
+import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { realpath, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, relative, sep } from "node:path";
-import { promisify } from "node:util";
-var run = promisify(execFile);
+import { promisify as promisify2 } from "node:util";
+var run = promisify2(execFile2);
 var git = (dir, args, env) => run("git", ["-C", dir, ...args], env === undefined ? {} : { env: { ...process.env, ...env } });
 function gitCapped(dir, args, maxBytes, env) {
   return new Promise((resolve, reject) => {
-    const child = spawn("git", ["-C", dir, ...args], env === undefined ? {} : { env: { ...process.env, ...env } });
+    const child = spawn2("git", ["-C", dir, ...args], env === undefined ? {} : { env: { ...process.env, ...env } });
     const chunks = [];
     let size = 0;
     let killed = false;
@@ -443,14 +733,14 @@ async function changesOf(dir, base, maxBytes = 1024 * 1024) {
 }
 
 // apps/host/src/files.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { opendir, realpath as realpath3, stat as stat3 } from "node:fs/promises";
-import { join as join3, resolve as resolve2, sep as sep2 } from "node:path";
+import { join as join3, resolve as resolve2, sep as sep3 } from "node:path";
 import { AgentDoc as AgentDoc2 } from "@earendil-works/pi-durable";
 
 // apps/host/src/organization.ts
 import { mkdir, realpath as realpath2, stat as stat2 } from "node:fs/promises";
-import { basename, join as join2, resolve } from "node:path";
+import { basename, join as join2, resolve, sep as sep2 } from "node:path";
 import { clampThinkingLevel } from "@earendil-works/pi-ai";
 import {
   AgentDoc,
@@ -756,6 +1046,17 @@ async function familyRoot(harness, id, context) {
   }
   return current;
 }
+async function subagentWorktreeBase(harness, dataDir, dispatcher, context) {
+  const unavailable = (why) => new Error(`checkout "worktree" needs ${why}; use "shared"`);
+  const cwd = (await harness.snapshot(AgentDoc, dispatcher, context))?.cwd;
+  if (cwd === undefined || cwd.startsWith(join2(dataDir, "chats") + sep2))
+    throw unavailable("a project conversation, not a Chat");
+  const head = await gitBase(cwd);
+  if (head === undefined)
+    throw unavailable("a Git repository with at least one commit");
+  const record = checkoutAt((await harness.snapshot(IndexDoc, context))?.checkouts, cwd);
+  return record === undefined ? head : { repo: record.repo, subdir: record.subdir, base: head.base };
+}
 async function cleanupArchivedWorktrees(harness, rootId, context) {
   const index = await harness.snapshot(IndexDoc, context);
   const checkouts = index?.checkouts ?? [];
@@ -827,7 +1128,7 @@ function createCandidateLister(enumerate, options = {}) {
 }
 function gitLines(cwd, args, limits) {
   return new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn2("git", ["-C", cwd, ...args], { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn3("git", ["-C", cwd, ...args], { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     let bytes = 0;
     let truncated = false;
@@ -875,7 +1176,7 @@ function gitLines(cwd, args, limits) {
 }
 async function inWorkTree(root) {
   return await new Promise((resolvePromise) => {
-    const child = spawn2("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { stdio: ["ignore", "pipe", "ignore"] });
+    const child = spawn3("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { stdio: ["ignore", "pipe", "ignore"] });
     let out = "";
     child.stdout.on("data", (chunk) => out += chunk.toString("utf8"));
     child.on("error", () => resolvePromise(false));
@@ -884,7 +1185,7 @@ async function inWorkTree(root) {
 }
 async function hasHead(root) {
   return await new Promise((resolvePromise) => {
-    const child = spawn2("git", ["-C", root, "rev-parse", "--verify", "-q", "HEAD"], { stdio: ["ignore", "ignore", "ignore"] });
+    const child = spawn3("git", ["-C", root, "rev-parse", "--verify", "-q", "HEAD"], { stdio: ["ignore", "ignore", "ignore"] });
     child.on("error", () => resolvePromise(false));
     child.on("close", (code) => resolvePromise(code === 0));
   });
@@ -1005,7 +1306,7 @@ async function listFiles(harness, dataDir, enumerate, scope, query, context) {
     const cwd = agent.cwd;
     if (cwd === undefined)
       throw new Error(`Conversation ${scope.conversationId} has no checkout`);
-    if (cwd.startsWith(join3(dataDir, "chats") + sep2))
+    if (cwd.startsWith(join3(dataDir, "chats") + sep3))
       return { files: [], truncated: false };
     const record = checkoutAt((await harness.snapshot(IndexDoc, context))?.checkouts, cwd);
     const ready = record === undefined || await worktreeSettled(record);
@@ -1037,7 +1338,7 @@ async function listFiles(harness, dataDir, enumerate, scope, query, context) {
 }
 
 // apps/host/src/skills.ts
-var exec = promisify2(execFile2);
+var exec2 = promisify3(execFile3);
 function invocableSkillName(name) {
   return name.length <= 64 && /^[a-z0-9-]+$/.test(name) && !name.startsWith("-") && !name.endsWith("-") && !name.includes("--");
 }
@@ -1101,10 +1402,10 @@ async function committedSkillFiles(gitRoot, layers) {
   if (!await inWorkTree(gitRoot) || !await hasHead(gitRoot))
     return null;
   const pathspecs = layers.map((dir) => {
-    const rel = relative2(gitRoot, dir).split(sep3).join("/");
+    const rel = relative2(gitRoot, dir).split(sep4).join("/");
     return rel === "" ? ".agents/skills" : `${rel}/.agents/skills`;
   });
-  const { stdout } = await exec("git", ["-C", gitRoot, "ls-tree", "-r", "-z", "--full-name", "--name-only", "HEAD", "--", ...pathspecs], { maxBuffer: 4 * 1024 * 1024 });
+  const { stdout } = await exec2("git", ["-C", gitRoot, "ls-tree", "-r", "-z", "--full-name", "--name-only", "HEAD", "--", ...pathspecs], { maxBuffer: 4 * 1024 * 1024 });
   return new Set(stdout.split("\x00").filter((path) => path !== ""));
 }
 async function enumerateSkills(root, mode, agentsHome) {
@@ -1116,7 +1417,7 @@ async function enumerateSkills(root, mode, agentsHome) {
     if (mode === "head" && gitRoot !== undefined) {
       const committed = await committedSkillFiles(gitRoot, layers.dirs);
       if (committed !== null) {
-        project = project.filter((scoped) => committed.has(relative2(gitRoot, scoped.skill.filePath).split(sep3).join("/")));
+        project = project.filter((scoped) => committed.has(relative2(gitRoot, scoped.skill.filePath).split(sep4).join("/")));
       }
     }
   }
@@ -1250,7 +1551,7 @@ function createContext(options) {
             const seen = new Set;
             files = [
               ...loadProjectContextFiles({ cwd: dirname2(checkout.repo), agentDir: agentsHome }),
-              ...loadProjectContextFiles({ cwd, agentDir: agentsHome }).filter((file) => file.path.startsWith(checkout.worktreeRoot + sep4))
+              ...loadProjectContextFiles({ cwd, agentDir: agentsHome }).filter((file) => file.path.startsWith(checkout.worktreeRoot + sep5))
             ].filter((file) => {
               if (seen.has(file.path))
                 return false;
@@ -1277,21 +1578,336 @@ ${file.content}`).join(`
   };
 }
 
+// apps/host/src/extensions/context-breakdown.ts
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { defineDoc as defineDoc4, defineExtension as defineExtension3, GenerationTask, hook } from "@earendil-works/pi-durable";
+
+// packages/client/src/context-usage.ts
+var contextTokens = (usage) => usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+
+// apps/host/src/context-breakdown.ts
+var CHARS_PER_TOKEN = 4;
+var tokensOf = (text) => Math.ceil(text.length / CHARS_PER_TOKEN);
+var MCP_TOOL = /^mcp__/;
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var arrayOf = (value) => Array.isArray(value) ? value : [];
+function textOf(value) {
+  if (typeof value === "string")
+    return value;
+  if (isObject(value) && "parts" in value)
+    return textOf(value.parts);
+  return arrayOf(value).map((block) => isObject(block) && typeof block.text === "string" ? block.text : "").join(`
+`);
+}
+var sourcesOf = (payload) => [payload, payload.config, payload.context].filter(isObject);
+var systemItemsOf = (source) => [...arrayOf(source.messages), ...arrayOf(source.input)].filter((item) => isObject(item) && (item.role === "system" || item.role === "developer"));
+function systemTextOf(payload) {
+  return sourcesOf(payload).flatMap((source) => [
+    textOf(source.system),
+    textOf(source.instructions),
+    textOf(source.systemInstruction),
+    ...systemItemsOf(source).flatMap((item) => [
+      textOf(item.content),
+      ...isObject(item.sections) ? Object.values(item.sections).filter((section2) => typeof section2 === "string") : []
+    ])
+  ]).filter((text) => text !== "").join(`
+`);
+}
+function toolsOf(payload) {
+  const listed = sourcesOf(payload).flatMap((source) => [
+    ...arrayOf(source.tools),
+    ...arrayOf(isObject(source.toolConfig) ? source.toolConfig.tools : undefined),
+    ...systemItemsOf(source).flatMap((item) => [...arrayOf(item.tools), ...arrayOf(item.toolsAdded)])
+  ]);
+  return listed.flatMap((tool) => isObject(tool) && Array.isArray(tool.functionDeclarations) ? tool.functionDeclarations.filter(isObject) : isObject(tool) ? [tool] : []);
+}
+function toolName(tool) {
+  for (const holder of [tool, tool.function, tool.toolSpec]) {
+    if (isObject(holder) && typeof holder.name === "string")
+      return holder.name;
+  }
+  return;
+}
+function cut(text, tag) {
+  const open = text.indexOf(`<${tag}>`);
+  const close = open < 0 ? -1 : text.indexOf(`</${tag}>`, open);
+  if (close < 0)
+    return { inside: "", rest: text };
+  return { inside: text.slice(open, close + tag.length + 3), rest: text.slice(0, open) + text.slice(close + tag.length + 3) };
+}
+function splitCodemode(section2, namespaces) {
+  const starts = namespaces.map(({ name }) => section2.search(new RegExp(`\\n## ${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\n| \\(|$)`))).filter((index) => index >= 0);
+  if (starts.length === 0)
+    return { builtin: section2, mcp: "" };
+  const first = Math.min(...starts);
+  return { builtin: section2.slice(0, first), mcp: section2.slice(first) };
+}
+function estimateRequest(payload, namespaces) {
+  if (!isObject(payload))
+    return;
+  const system = systemTextOf(payload);
+  const tools = toolsOf(payload);
+  if (system === "" && tools.length === 0)
+    return;
+  const skills = cut(system, "available_skills");
+  const codemode = cut(skills.rest, "codemode");
+  const { builtin, mcp } = splitCodemode(codemode.inside, namespaces);
+  let toolTokens = 0;
+  let mcpTokens = tokensOf(mcp);
+  for (const tool of tools) {
+    const cost = tokensOf(JSON.stringify(tool));
+    if (MCP_TOOL.test(toolName(tool) ?? ""))
+      mcpTokens += cost;
+    else
+      toolTokens += cost;
+  }
+  return {
+    system: tokensOf(codemode.rest) + tokensOf(builtin),
+    skills: tokensOf(skills.inside),
+    tools: toolTokens,
+    mcp: mcpTokens
+  };
+}
+function breakdownOf(estimate, used) {
+  const fixed = estimate.system + estimate.skills + estimate.tools + estimate.mcp;
+  const scale = fixed > used ? used / fixed : 1;
+  const system = Math.floor(estimate.system * scale);
+  const skills = Math.floor(estimate.skills * scale);
+  const tools = Math.floor(estimate.tools * scale);
+  const mcp = Math.floor(estimate.mcp * scale);
+  return { used, system, skills, tools, mcp, messages: used - system - skills - tools - mcp };
+}
+
+// apps/host/src/extensions/context-breakdown.ts
+var ContextBreakdownDoc = defineDoc4({
+  kind: "context.breakdown",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "current",
+  initial: () => ({ used: 0, system: 0, skills: 0, tools: 0, mcp: 0, messages: 0 }),
+  checkpointWhen: () => false
+});
+function createContextBreakdown(options) {
+  let namespaces = [];
+  const pending = new Map;
+  const build = () => defineExtension3({
+    name: "context-breakdown",
+    hooks: [
+      hook(GenerationTask, {
+        beforeProviderRequest: (request, api) => {
+          const estimate = estimateRequest(request.payload, namespaces);
+          if (estimate === undefined)
+            pending.delete(api.taskId);
+          else
+            pending.set(api.taskId, estimate);
+          return;
+        },
+        afterResponse: (message2, api) => {
+          const estimate = pending.get(api.taskId);
+          pending.delete(api.taskId);
+          if (estimate === undefined || message2.stopReason === "aborted" || message2.stopReason === "error")
+            return;
+          const used = message2.usage ? contextTokens(message2.usage) : 0;
+          if (!(used > 0))
+            return;
+          const value = breakdownOf(estimate, used);
+          options.harness().commit(async (tx) => {
+            Object.assign(await tx.doc(ContextBreakdownDoc, api.conversationId), value);
+          }, BACKGROUND_CONTEXT).catch((error) => {
+            console.error(`context-breakdown: conversation ${api.conversationId}: ${error instanceof Error ? error.message : String(error)}`);
+          });
+        }
+      })
+    ]
+  });
+  return {
+    extension: build(),
+    docs: [{ token: ContextBreakdownDoc, presentation: "pinomad.context" }],
+    namespaced: (next) => {
+      namespaces = next;
+      return build();
+    }
+  };
+}
+
+// apps/host/src/extensions/processes.ts
+import { randomUUID } from "node:crypto";
+import { defineExtension as defineExtension4, defineTool as defineTool2 } from "@earendil-works/pi-durable";
+import { Type as Type2 } from "typebox";
+
+// packages/client/src/processes.ts
+function processStatusText(state) {
+  if (state === "starting")
+    return "Starting";
+  if (state === "running")
+    return "Running";
+  if (state === "lost")
+    return "Lost track after a host restart; it may still be running";
+  if (typeof state === "object" && "stopped" in state) {
+    switch (state.stopped) {
+      case "agent":
+        return "Stopped by the agent";
+      case "user":
+        return "Stopped by the user";
+      case "archive":
+        return "Stopped when the conversation was archived";
+      case "shutdown":
+        return "Stopped when the host shut down";
+    }
+  }
+  if (typeof state === "object" && "failed" in state)
+    return `Failed to start: ${state.failed}`;
+  if (typeof state === "object" && "exited" in state) {
+    if (state.signal !== undefined)
+      return `Exited after signal ${state.signal}`;
+    if (state.exited === null)
+      return "Exited";
+    return `Exited with code ${state.exited}`;
+  }
+  return "Unknown";
+}
+
+// apps/host/src/process-doc.ts
+import { defineDoc as defineDoc5 } from "@earendil-works/pi-durable";
+var ProcessDoc = defineDoc5({
+  kind: "pinomad.processes",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ processes: [] }),
+  checkpointWhen: () => false
+});
+
+// apps/host/src/extensions/processes.ts
+var ID = Type2.String({ minLength: 1, description: "The process id returned by process_start." });
+function createProcesses(options) {
+  const { runtime } = options;
+  if (runtime === undefined) {
+    return {
+      extension: defineExtension4({ name: "processes", tools: [] }),
+      docs: [{ token: ProcessDoc, presentation: "pinomad.processes" }]
+    };
+  }
+  const start = defineTool2({
+    name: "process_start",
+    callers: ["model"],
+    description: "Start a long-running command in the background and return its id. The command runs in your conversation's working directory under a pty, so dev servers and monitors keep running after the call returns. " + "It cannot receive input. Use process_output to read it, process_stop to end it, and process_list to recover ids after a context reset. " + "The host keeps at most 8 unfinished processes per conversation family. Write monitors as commands that exit when the event happens (for example a one-shot grep) so the exit report wakes you; line-by-line callbacks are not supported.",
+    parameters: Type2.Object({
+      command: Type2.String({ minLength: 1, description: "Shell command; it is run with the login shell's -c." }),
+      name: Type2.Optional(Type2.String({ description: `Short label for lists, e.g. "dev server". Defaults to the command's first line.` }))
+    }),
+    replay: "unsafe",
+    execute: async (args, api, context) => {
+      const agent = await api.agent(context);
+      const cwd = agent.cwd;
+      if (cwd === undefined)
+        throw new Error("This conversation has no working directory");
+      const name = cleanName(args.name) ?? defaultName(args.command);
+      const memo = await api.memo("process.start", { id: randomUUID(), name }, context);
+      const process2 = await runtime.start({
+        conversationId: api.conversationId,
+        command: args.command,
+        name: memo.name,
+        cwd,
+        id: memo.id
+      }, context);
+      return result2(processResult("Started", process2), { id: process2.id, name: process2.name });
+    }
+  });
+  const output = defineTool2({
+    name: "process_output",
+    callers: ["model"],
+    description: `Read a background process's output after a raw character position. Omit "since" for the retained output; pass the previous result's "next" to read only what is new. ` + 'Returns at most 16 KiB of text with ANSI escapes removed; "next" stays a raw output position. "truncated" is true when the start of the retained output was already dropped. ' + "If the process ended, status and exitCode say how; output may be unavailable after it falls out of history or the host restarts.",
+    parameters: Type2.Object({
+      id: ID,
+      since: Type2.Optional(Type2.Integer({ minimum: 0, description: "The previous result's next position." }))
+    }),
+    replay: "safe",
+    execute: async (args, api, context) => {
+      const value = await runtime.output({
+        conversationId: api.conversationId,
+        id: args.id,
+        ...args.since === undefined ? {} : { since: args.since }
+      }, context);
+      const heading = statusLine(value.status);
+      const body = value.released === true ? "Output is no longer available." : value.text === "" ? "(no new output)" : value.text;
+      const truncated = value.truncated && value.released !== true ? `
+(the beginning of the retained output was truncated)` : "";
+      return result2(`${heading}
+${body}${truncated}`, value);
+    }
+  });
+  const stop = defineTool2({
+    name: "process_stop",
+    callers: ["model"],
+    description: "Stop a background process and wait until it has exited. The host sends SIGTERM to the whole process group, then SIGKILL after 5 seconds. " + "A process that exits after this call is treated as stopped, so it will not report back to you; the result carries its final state. Stopping an already ended process returns that state.",
+    parameters: Type2.Object({ id: ID }),
+    replay: "safe",
+    execute: async (args, api, context) => {
+      const process2 = await runtime.stop({
+        conversationId: api.conversationId,
+        id: args.id,
+        reason: "agent"
+      }, context);
+      return result2(processResult("Stopped", process2), { state: process2.state });
+    }
+  });
+  const list = defineTool2({
+    name: "process_list",
+    callers: ["model"],
+    description: "List this conversation family's background processes, running and recently ended, with ids and states. Use it to recover ids after a context reset. Output and stop work only while the host still has the process's pty.",
+    parameters: Type2.Object({}),
+    replay: "safe",
+    execute: async (_args, api, context) => {
+      const processes = await runtime.list(api.conversationId, context);
+      const text = processes.length === 0 ? "No background processes." : processes.map((process2) => `${process2.id}  ${process2.name}  [${statusLine(process2.state)}]  ${process2.command}`).join(`
+`);
+      return result2(text, { processes });
+    }
+  });
+  return {
+    extension: defineExtension4({ name: "processes", tools: [start, output, stop, list] }),
+    docs: [{ token: ProcessDoc, presentation: "pinomad.processes" }]
+  };
+}
+function result2(text, details) {
+  return { output: [{ type: "text", text }], details };
+}
+function processResult(verb, process2) {
+  return `${verb} ${process2.name} (${process2.id}): ${statusLine(process2.state)}`;
+}
+function statusLine(state) {
+  return processStatusText(state);
+}
+function cleanName(name) {
+  const trimmed = name?.trim();
+  return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+function defaultName(command) {
+  const line = command.trim().split(`
+`, 1)[0].trim();
+  if (line === "")
+    return "Background process";
+  return line.length <= 60 ? line : `${line.slice(0, 59)}…`;
+}
+
 // apps/host/src/extensions/subagent.ts
+import { join as join6 } from "node:path";
 import { clampThinkingLevel as clampThinkingLevel2 } from "@earendil-works/pi-ai";
 import {
   AgentDoc as AgentDoc4,
-  AssistantEntry,
   configure as configure2,
-  defineExtension as defineExtension3,
-  defineTool as defineTool2,
+  defineExtension as defineExtension5,
+  defineTool as defineTool3,
   section as section2
 } from "@earendil-works/pi-durable";
 import { Type as Type3 } from "typebox";
 
 // apps/host/src/subagent-doc.ts
-import { defineDoc as defineDoc4 } from "@earendil-works/pi-durable";
-var SubagentDoc = defineDoc4({
+import { defineDoc as defineDoc6 } from "@earendil-works/pi-durable";
+var SubagentDoc = defineDoc6({
   kind: "pinomad.subagent",
   version: 1,
   scope: "conversation",
@@ -1301,8 +1917,273 @@ var SubagentDoc = defineDoc4({
   checkpointWhen: () => false
 });
 
+// apps/host/src/subagents.ts
+import {
+  AssistantEntry,
+  defineDoc as defineDoc7,
+  defineTask as defineTask2
+} from "@earendil-works/pi-durable";
+var SubagentsDoc = defineDoc7({
+  kind: "pinomad.subagents",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ agents: {} }),
+  checkpointWhen: () => false
+});
+var MAX_WORKING_SUBAGENTS = 8;
+var NAME = /^[\p{L}\p{N}][\p{L}\p{N}_-]{0,39}$/u;
+async function familyRootIn(tx, id) {
+  let current = id;
+  for (let depth = 0;depth < 256; depth++) {
+    const record = await tx.conversation(current);
+    const up = record?.parent?.conversationId ?? record?.owner?.conversationId;
+    if (up === undefined)
+      return current;
+    current = up;
+  }
+  return current;
+}
+function nameFromDescription(description) {
+  const base = (description ?? "").trim().toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+/, "").slice(0, 32).replace(/-+$/, "");
+  return base === "" ? "subagent" : base;
+}
+function uniqueName(base, taken) {
+  if (!taken(base))
+    return base;
+  for (let n = 2;; n++) {
+    const candidate = `${base}-${n}`;
+    if (!taken(candidate))
+      return candidate;
+  }
+}
+function assertValidName(name) {
+  if (!NAME.test(name)) {
+    throw new Error(`Invalid subagent name "${name}": use 1-40 letters, digits, "-" or "_", starting with a letter or digit`);
+  }
+}
+async function isLive(tx, id) {
+  if (id === undefined)
+    return false;
+  const task = await tx.task(id);
+  return task !== undefined && task.state.status !== "terminal";
+}
+async function inCall(tx, record) {
+  return await isLive(tx, record.call);
+}
+async function statusOf(tx, record) {
+  if (record.status !== "working" || record.reporters.length > 0 || await inCall(tx, record))
+    return record.status;
+  return "stopped";
+}
+async function workingCount(tx, root) {
+  let count = 0;
+  for (const record of Object.values((await tx.doc(SubagentsDoc, root)).agents)) {
+    if (record.reporters.length > 0 || await inCall(tx, record))
+      count++;
+  }
+  return count;
+}
+async function assertCapacity(tx, root) {
+  if (await workingCount(tx, root) >= MAX_WORKING_SUBAGENTS) {
+    throw new Error(`At most ${MAX_WORKING_SUBAGENTS} subagents can work at once in this conversation; wait for one to answer or stop one with subagent_stop`);
+  }
+}
+function recordNamed(agents, name) {
+  const found = Object.hasOwn(agents, name) ? agents[name] : undefined;
+  if (found !== undefined)
+    return found;
+  const names = Object.keys(agents);
+  throw new Error(names.length === 0 ? `No subagent named "${name}"` : `No subagent named "${name}". Subagents: ${names.join(", ")}`);
+}
+async function recordOf(tx, childId) {
+  if ((await tx.conversation(childId))?.owner === undefined)
+    return;
+  const root = await familyRootIn(tx, childId);
+  const agents = (await tx.doc(SubagentsDoc, root)).agents;
+  for (const [name, record] of Object.entries(agents)) {
+    if (record.conversationId === childId)
+      return { root, name, record };
+  }
+  return;
+}
+var SubagentAnchor = defineTask2({
+  name: "pinomad.subagent-anchor",
+  version: 1,
+  initial: () => ({ phase: "done" }),
+  phases: {
+    done: (_anchor, runtime, context) => runtime.commit(() => ({ status: "terminal", outcome: { status: "completed", result: null } }), context)
+  },
+  abort: (_anchor, runtime, context) => runtime.commit(() => ({ status: "terminal", outcome: { status: "aborted" } }), context)
+});
+var SubagentReporter = defineTask2({
+  name: "pinomad.subagent-reporter",
+  version: 1,
+  initial: () => ({ phase: "deliver" }),
+  phases: {
+    deliver: async (reporter, runtime, context) => {
+      const input = reporter.input;
+      const child = await runtime.conversation(input.conversationId, context);
+      const sender = await runtime.conversation(runtime.conversationId, context);
+      await runtime.commit(async (tx) => {
+        const record = (await tx.doc(SubagentsDoc, input.root)).agents[input.name];
+        if (input.message === undefined) {
+          if (record !== undefined)
+            release(record, reporter.id, "idle");
+          return { status: "terminal", outcome: { status: "completed", result: null } };
+        }
+        const message2 = input.message;
+        if (child !== undefined) {
+          if (record?.cancelled?.includes(reporter.id) === true) {
+            await settle(tx, sender, reporter.id, input, "cancelled", runtime.now());
+            return { status: "terminal", outcome: { status: "completed", result: null } };
+          }
+          await child.submit(tx, draftOf(reporter.id, message2));
+        }
+        return { status: "running", checkpoint: { phase: "wait" } };
+      }, context);
+    },
+    wait: async (reporter, runtime, context) => {
+      const input = reporter.input;
+      const child = await runtime.conversation(input.conversationId, context);
+      const message2 = input.message;
+      const settled = child === undefined || message2 === undefined ? undefined : await (await child.submit(draftOf(reporter.id, message2), context)).wait(context);
+      const sender = await runtime.conversation(runtime.conversationId, context);
+      await runtime.commit(async (tx) => {
+        if (message2 === undefined) {
+          const record = (await tx.doc(SubagentsDoc, input.root)).agents[input.name];
+          if (record !== undefined)
+            release(record, reporter.id, "idle");
+        } else {
+          await settle(tx, sender, reporter.id, input, settled, runtime.now());
+        }
+        return { status: "terminal", outcome: { status: "completed", result: null } };
+      }, context);
+    }
+  },
+  abort: (reporter, runtime, context) => runtime.commit(async (tx) => {
+    const record = (await tx.doc(SubagentsDoc, reporter.input.root)).agents[reporter.input.name];
+    if (record !== undefined)
+      release(record, reporter.id, "stopped");
+    return { status: "terminal", outcome: { status: "aborted" } };
+  }, context)
+});
+function draftOf(reporter, message2) {
+  return { type: "input", content: message2, whenBusy: "steer", requestId: `subagent:${reporter}` };
+}
+function release(record, reporter, status) {
+  record.reporters = record.reporters.filter((id) => id !== reporter);
+  if (record.cancelled !== undefined)
+    record.cancelled = record.cancelled.filter((id) => id !== reporter);
+  if (record.reporters.length === 0)
+    record.status = status;
+}
+function stopRecord(record, by) {
+  record.stop = { by, noted: false };
+  record.cancelled = [...record.reporters];
+}
+function steer(text) {
+  return { type: "input", content: text, whenBusy: "steer" };
+}
+function note(text, now) {
+  return { type: "write", entry: { kind: "pi.user", model: [{ role: "user", content: text, timestamp: now }] } };
+}
+async function settle(tx, sender, reporter, input, settled, now) {
+  const record = (await tx.doc(SubagentsDoc, input.root)).agents[input.name];
+  if (record === undefined)
+    return;
+  const name = input.name;
+  let report;
+  let status;
+  if (settled !== "cancelled" && settled?.status === "done" && settled.type === "input") {
+    status = "idle";
+    const key = `${sender.id}:${settled.answer}`;
+    if (record.reported[key] !== "steer") {
+      report = steer(`${answeredHeader(name, record)}
+
+${await answerText(tx, settled.answer)}`);
+      record.reported[key] = "steer";
+    }
+  } else if (settled === "cancelled" || settled?.status === "unanswered" && settled.reason === "aborted") {
+    status = "stopped";
+    const stop = record.stop ?? { by: "user", noted: false };
+    if (stop.by === "user" && !stop.noted) {
+      report = note(`[The user stopped subagent ${name}.]`, now);
+      stop.noted = true;
+    }
+    record.stop = stop;
+  } else {
+    status = "failed";
+    const reason = settled === undefined ? "its conversation no longer exists" : settled.status === "unanswered" ? settled.reason : "no answer";
+    report = steer(`[subagent ${name} failed: ${reason}]`);
+  }
+  if (report !== undefined)
+    await sender.submit(tx, { ...report, requestId: `subagent-report:${reporter}` });
+  release(record, reporter, status);
+}
+function answeredHeader(name, record) {
+  return record?.branch === undefined ? `[subagent ${name} answered]` : `[subagent ${name} answered on branch ${record.branch} (from ${record.base?.slice(0, 12) ?? "?"})]`;
+}
+async function answerText(tx, id) {
+  const message2 = (await tx.entry(AssistantEntry, id))?.model?.[0];
+  const text = message2?.role === "assistant" ? message2.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("") : "";
+  return text === "" ? "(The subagent returned no text.)" : text;
+}
+async function entriesSince(tx, record) {
+  const entries = [];
+  let cursor;
+  do {
+    const page = await tx.scanEntries({
+      conversationId: record.conversationId,
+      order: "ascending",
+      ...record.readUpTo === undefined ? {} : { minEntryId: record.readUpTo + 1 }
+    }, 256, cursor);
+    entries.push(...page.items);
+    cursor = page.next;
+  } while (cursor !== undefined);
+  return entries;
+}
+async function assertDispatchable(tx, root, name) {
+  const record = recordNamed((await tx.doc(SubagentsDoc, root)).agents, name);
+  if (await inCall(tx, record)) {
+    throw new Error(`Subagent "${name}" is still answering the subagent call that dispatched it`);
+  }
+  if (record.reporters.length === 0)
+    await assertCapacity(tx, root);
+  return record;
+}
+async function dispatch(tx, options) {
+  const record = recordNamed((await tx.doc(SubagentsDoc, options.root)).agents, options.name);
+  const reporter = await tx.createTask(SubagentReporter, {
+    root: options.root,
+    name: options.name,
+    conversationId: record.conversationId,
+    message: options.message
+  }, { ownership: { kind: "conversation" }, conversationId: options.sender, background: true });
+  record.reporters.push(reporter);
+  record.status = "working";
+  delete record.stop;
+  delete record.call;
+  const doc = await tx.doc(SubagentDoc, record.conversationId);
+  if (doc.lifecycle !== "background")
+    doc.lifecycle = "background";
+  return reporter;
+}
+async function markStop(tx, childId, by) {
+  const found = await recordOf(tx, childId);
+  if (found === undefined)
+    return false;
+  stopRecord(found.record, by);
+  return true;
+}
+
 // apps/host/src/extensions/subagent.ts
-var INSTRUCTIONS = "You are a subagent working on one delegated task. You cannot ask the user questions; if you need a decision or clarification, stop and state exactly what you need in your final answer. Your final message is returned to the delegating agent as the result, so make it a complete, self-contained report.";
+var instructions = (name) => `You are a subagent named "${name}", working on tasks delegated to you. You cannot ask the user questions; if you need a decision or clarification, stop and state exactly what you need in your final answer. Each final answer is returned to whoever sent the message, so make it a complete, self-contained report. You may get more messages later from the delegating agent.`;
+var READ_LIMIT = 16000;
+function contentText(content) {
+  return typeof content === "string" ? content : content.flatMap((block) => block.type === "text" && block.text !== undefined ? [block.text] : []).join("");
+}
 var THINKING_LEVELS2 = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 function createSubagent(options) {
   const available = () => options.modelSummaries().map((model) => `${model.provider}/${model.modelId}`).join(", ");
@@ -1314,15 +2195,22 @@ function createSubagent(options) {
     const defined = roles();
     throw new Error(defined.length === 0 ? "No named agents are defined" : `Unknown agent "${name}". Available agents: ${defined.map((each) => each.name).join(", ")}`);
   };
-  const tool = defineTool2({
+  const tool = defineTool3({
     name: "subagent",
     callers: ["model"],
-    description: "Delegate a self-contained task to a subagent that runs in its own conversation and returns its final answer. " + "The subagent starts with none of this conversation's context, so put everything it needs in `task`. " + "It works in the same files as you: subagents called in the same turn run concurrently, so give parallel subagents read-only work or non-overlapping files. " + "It cannot ask the user questions. `model` and `thinkingLevel` override what it inherits from you; `role` delegates to a named agent; a model or thinking level it pins cannot be overridden; `description` only labels the call. " + `Available models: ${available()}.`,
+    description: "Delegate a self-contained task to a named subagent that runs in its own conversation. " + "Without `background` the call blocks until the subagent answers and returns its answer; with `background: true` it returns at once, you keep working, and the answer is reported to you when it arrives. " + "Either way the subagent stays available afterwards: continue with subagent_send, stop it with subagent_stop, read its answers again with subagent_read, and list subagents with subagent_list. " + "The subagent starts with none of this conversation's context, so put everything it needs in `task`. " + '`checkout` is required: "shared" works in your files (use it for read-only work; parallel subagents must not edit the same files), "worktree" gets its own Git worktree for work that edits files. ' + "It cannot ask the user questions. `model` and `thinkingLevel` override what it inherits from you; `role` delegates to a named agent; a model or thinking level it pins cannot be overridden. " + `Available models: ${available()}.`,
     parameters: Type3.Object({
       task: Type3.String({
         minLength: 1,
         description: "Complete, self-contained instructions. The subagent sees none of this conversation."
       }),
+      checkout: Type3.Union([Type3.Literal("shared"), Type3.Literal("worktree")], {
+        description: '"shared": your working directory. "worktree": its own Git worktree from your HEAD; uncommitted changes are not carried over.'
+      }),
+      name: Type3.Optional(Type3.String({
+        description: 'Optional unique name, e.g. "reviewer"; derived from `description` when omitted. Use it with the other subagent tools.'
+      })),
+      background: Type3.Optional(Type3.Boolean({ description: "Return at once instead of waiting; the answer is reported to you when it arrives." })),
       role: Type3.Optional(Type3.String({
         description: "Optional named agent to delegate to, from the Named agents list in your instructions. Its prompt applies, plus any model or thinking level it pins."
       })),
@@ -1332,16 +2220,39 @@ function createSubagent(options) {
     }),
     replay: "safe",
     execute: async (args, api, context) => {
+      const background = args.background === true;
+      let repo;
+      if (args.checkout === "worktree") {
+        if (options.worktree === undefined)
+          throw new Error('checkout "worktree" is not available on this host; use "shared"');
+        repo = await options.worktree.base(api.conversationId, context);
+      }
       const child = await api.commit(async (tx) => {
-        const existing = (await tx.scanConversations({ ownerTaskId: api.taskId }, 1)).items[0];
-        if (existing !== undefined) {
-          const doc2 = await tx.doc(SubagentDoc, existing.id);
+        const root = await familyRootIn(tx, api.conversationId);
+        const registry = await tx.doc(SubagentsDoc, root);
+        const recorded = Object.entries(registry.agents).find(([, record]) => record.createdBy === api.taskId);
+        const existingId = recorded?.[1].conversationId ?? (await tx.scanConversations({ ownerTaskId: api.taskId }, 1)).items[0]?.id;
+        if (existingId !== undefined) {
+          const doc2 = await tx.doc(SubagentDoc, existingId);
           return {
-            id: existing.id,
+            id: existingId,
+            name: recorded?.[0] ?? doc2?.name,
+            ...recorded?.[1].branch === undefined ? {} : { branch: recorded[1].branch, base: recorded[1].base },
             ...doc2?.model === undefined ? {} : { model: doc2.model },
             ...doc2?.startedAt === undefined ? {} : { startedAt: doc2.startedAt }
           };
         }
+        const taken = (name3) => Object.hasOwn(registry.agents, name3);
+        let name2;
+        if (args.name !== undefined) {
+          name2 = args.name.trim();
+          assertValidName(name2);
+          if (taken(name2))
+            throw new Error(`A subagent named "${name2}" already exists; message it with subagent_send or pick another name`);
+        } else {
+          const words = args.description?.trim() || args.task.trim().split(/\s+/).slice(0, 4).join(" ");
+          name2 = uniqueName(nameFromDescription(words), taken);
+        }
         const role = args.role === undefined ? undefined : roleNamed(args.role);
         if (role?.model !== undefined && args.model !== undefined) {
           throw new Error(`Agent "${role.name}" pins model ${role.model}; omit \`model\``);
@@ -1374,21 +2285,38 @@ function createSubagent(options) {
             thinkingLevel = clampThinkingLevel2(override, parent.thinkingLevel);
           }
         }
+        await assertCapacity(tx, root);
         const change = {
           extensions: { remove: [extension, ...options.exclude] },
-          instructions: role === undefined || role.prompt === "" ? INSTRUCTIONS : `${INSTRUCTIONS}
+          instructions: role === undefined || role.prompt === "" ? instructions(name2) : `${instructions(name2)}
 
 ${role.prompt}`,
           ...model === undefined ? {} : { model },
           ...thinkingLevel === undefined ? {} : { thinkingLevel }
         };
-        const created = await tx.createConversation({ ownership: { kind: "task", taskId: api.taskId } });
-        await configure2(tx, created.id, change);
+        const owner = background ? await tx.createTask(SubagentAnchor, null, {
+          ownership: { kind: "conversation" },
+          conversationId: api.conversationId,
+          background: true
+        }) : api.taskId;
+        const created = await tx.createConversation({ ownership: { kind: "task", taskId: owner } });
+        let worktree;
+        if (repo !== undefined) {
+          const path = options.worktree.path(created.id);
+          worktree = { branch: worktreeBranch(created.id, branchSuffix()), base: repo.base, cwd: join6(path, repo.subdir) };
+          const index = await tx.doc(IndexDoc);
+          if (index.checkouts === undefined)
+            index.checkouts = [];
+          index.checkouts.push({ conversationId: created.id, path, repo: repo.repo, subdir: repo.subdir, branch: worktree.branch, base: repo.base });
+        }
+        await configure2(tx, created.id, worktree === undefined ? change : { ...change, cwd: worktree.cwd });
         const childAgent = await tx.doc(AgentDoc4, created.id);
         const ref = childAgent.model ?? model ?? (await tx.doc(AgentDoc4, api.conversationId)).model;
         const startedAt = Date.now();
         const doc = await tx.doc(SubagentDoc, created.id);
         doc.startedAt = startedAt;
+        doc.name = name2;
+        doc.lifecycle = background ? "background" : "foreground";
         if (ref !== undefined)
           doc.model = `${ref.provider}/${ref.modelId}`;
         if (role !== undefined)
@@ -1396,33 +2324,183 @@ ${role.prompt}`,
         const label = args.description?.trim();
         if (label !== undefined && label !== "")
           doc.label = label;
-        return { id: created.id, ...ref === undefined ? {} : { model: doc.model }, startedAt };
+        registry.agents[name2] = {
+          conversationId: created.id,
+          dispatcher: api.conversationId,
+          createdBy: api.taskId,
+          ...background ? {} : { call: api.taskId },
+          checkout: worktree === undefined ? "shared" : "worktree",
+          ...worktree === undefined ? {} : { branch: worktree.branch, base: worktree.base },
+          ...label === undefined || label === "" ? {} : { description: label },
+          status: "working",
+          reporters: [],
+          reported: {}
+        };
+        if (background) {
+          await dispatch(tx, { root, name: name2, sender: api.conversationId, message: args.task });
+        }
+        return {
+          id: created.id,
+          name: name2,
+          ...worktree === undefined ? {} : { branch: worktree.branch, base: worktree.base },
+          ...ref === undefined ? {} : { model: doc.model },
+          startedAt
+        };
       }, context);
-      await api.details({ conversationId: child.id, ...child.model === undefined ? {} : { model: child.model }, ...child.startedAt === undefined ? {} : { startedAt: child.startedAt } }, context);
+      const details = {
+        conversationId: child.id,
+        ...child.name === undefined ? {} : { name: child.name },
+        ...background ? { background: true } : {},
+        ...child.branch === undefined ? {} : { branch: child.branch, base: child.base },
+        ...child.model === undefined ? {} : { model: child.model },
+        ...child.startedAt === undefined ? {} : { startedAt: child.startedAt }
+      };
+      const name = child.name ?? "subagent";
+      if (background) {
+        return {
+          output: [
+            {
+              type: "text",
+              text: `Started subagent "${name}" in the background` + (child.branch === undefined ? "" : ` on its own worktree branch ${child.branch} (from ${child.base?.slice(0, 12)})`) + ". Its answer will be reported to you when it arrives; message it with subagent_send."
+            }
+          ],
+          details
+        };
+      }
+      await api.details(details, context);
       const handle = await api.conversation(child.id, context);
       if (handle === undefined)
         throw new Error(`Subagent conversation ${child.id} does not exist`);
       const request = { type: "input", content: args.task, requestId: `subagent:${api.taskId}` };
       const settled = await (await handle.submit(request, context)).wait(context);
-      if (settled.status !== "done" || settled.type !== "input")
-        throw new Error(`Subagent failed: ${settled.status}`);
-      const answer = await api.commit((tx) => tx.entry(AssistantEntry, settled.answer), context);
-      const message = answer?.model?.[0];
-      const text = message?.role === "assistant" ? message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("") : "";
-      const result2 = {
-        output: [{ type: "text", text: text === "" ? "(The subagent returned no text.)" : text }],
-        details: {
-          conversationId: child.id,
-          ...child.model === undefined ? {} : { model: child.model },
-          ...child.startedAt === undefined ? {} : { startedAt: child.startedAt }
+      const answered = settled.status === "done" && settled.type === "input";
+      const text = await api.commit(async (tx) => {
+        const found = await recordOf(tx, child.id);
+        if (found !== undefined) {
+          delete found.record.call;
+          if (found.record.reporters.length === 0) {
+            found.record.status = answered ? "idle" : settled.status === "unanswered" && settled.reason === "aborted" ? "stopped" : "failed";
+          }
+          if (answered)
+            found.record.reported[`${api.conversationId}:${settled.answer}`] = "steer";
         }
+        return answered ? await answerText(tx, settled.answer) : undefined;
+      }, context);
+      if (text === undefined)
+        throw new Error(`Subagent failed: ${settled.status === "unanswered" ? settled.reason : settled.status}`);
+      return {
+        output: [{ type: "text", text: `${answeredHeader(name, child)}
+
+${text}` }],
+        details
+      };
+    }
+  });
+  const send = defineTool3({
+    name: "subagent_send",
+    callers: ["model"],
+    description: "Send a message to one of your subagents (started with `subagent`), for example a follow-up question or new instructions. Returns at once; its answer is reported to you when it arrives. A message to a subagent that is still working steers its current answer.",
+    parameters: Type3.Object({
+      name: Type3.String({ description: "The subagent's name." }),
+      message: Type3.String({ minLength: 1, description: "Self-contained message; it sees only its own conversation." })
+    }),
+    replay: "unsafe",
+    execute: async (args, api, context) => {
+      const conversationId = await api.commit(async (tx) => {
+        const root = await familyRootIn(tx, api.conversationId);
+        const record = await assertDispatchable(tx, root, args.name);
+        await dispatch(tx, { root, name: args.name, sender: api.conversationId, message: args.message });
+        return record.conversationId;
+      }, context);
+      return {
+        output: [{ type: "text", text: `Sent to subagent "${args.name}". Its answer will be reported to you when it arrives.` }],
+        details: { conversationId, name: args.name }
       };
-      return result2;
     }
   });
-  const extension = defineExtension3({
+  const stop = defineTool3({
+    name: "subagent_stop",
+    callers: ["model"],
+    description: "Stop what one of your subagents is doing now and drop its queued messages. It stays available for subagent_send.",
+    parameters: Type3.Object({ name: Type3.String({ description: "The subagent's name." }) }),
+    replay: "unsafe",
+    execute: async (args, api, context) => {
+      const conversationId = await api.commit(async (tx) => {
+        const root = await familyRootIn(tx, api.conversationId);
+        const record = recordNamed((await tx.doc(SubagentsDoc, root)).agents, args.name);
+        stopRecord(record, "model");
+        return record.conversationId;
+      }, context);
+      const handle = await api.conversation(conversationId, context);
+      if (handle === undefined)
+        throw new Error(`Subagent conversation ${conversationId} does not exist`);
+      await handle.abort(context);
+      return {
+        output: [{ type: "text", text: `Stopped subagent "${args.name}". It keeps its conversation; message it again with subagent_send.` }],
+        details: { conversationId, name: args.name }
+      };
+    }
+  });
+  const read = defineTool3({
+    name: "subagent_read",
+    callers: ["model"],
+    description: "Read the answers one of your subagents gave since you last read it, without its tool calls — for example after your own context was compacted.",
+    parameters: Type3.Object({ name: Type3.String({ description: "The subagent's name." }) }),
+    replay: "unsafe",
+    execute: async (args, api, context) => {
+      const text = await api.commit(async (tx) => {
+        const root = await familyRootIn(tx, api.conversationId);
+        const record = recordNamed((await tx.doc(SubagentsDoc, root)).agents, args.name);
+        const entries = await entriesSince(tx, record);
+        const lines = [];
+        for (const entry of entries) {
+          const message2 = entry.model?.[0];
+          if (entry.kind !== "pi.assistant" || message2?.role !== "assistant")
+            continue;
+          const said = contentText(message2.content);
+          if (said !== "")
+            lines.push(`${args.name}: ${said}`);
+        }
+        const last = entries.at(-1);
+        if (last !== undefined)
+          record.readUpTo = last.id;
+        if (lines.length === 0)
+          return `Nothing new in subagent "${args.name}" since you last read it.`;
+        const joined = lines.join(`
+
+`);
+        return joined.length <= READ_LIMIT ? joined : `(Earlier answers omitted.)
+
+${joined.slice(-READ_LIMIT)}`;
+      }, context);
+      return { output: [{ type: "text", text }] };
+    }
+  });
+  const list = defineTool3({
+    name: "subagent_list",
+    callers: ["model"],
+    description: "List the subagents of this conversation with their status: working, idle, stopped, or failed.",
+    parameters: Type3.Object({}),
+    replay: "safe",
+    execute: async (_args, api, context) => {
+      const text = await api.commit(async (tx) => {
+        const root = await familyRootIn(tx, api.conversationId);
+        const lines = [];
+        for (const [name, record] of Object.entries((await tx.doc(SubagentsDoc, root)).agents)) {
+          const label = record.description === undefined ? "" : ` — ${record.description}`;
+          const checkout = record.branch === undefined ? record.checkout : `worktree, branch ${record.branch}`;
+          lines.push(`- ${name}: ${await statusOf(tx, record)}${label} (checkout: ${checkout})`);
+        }
+        return lines.length === 0 ? "No subagents." : lines.join(`
+`);
+      }, context);
+      return { output: [{ type: "text", text }] };
+    }
+  });
+  const extension = defineExtension5({
     name: "subagent",
-    tools: [tool],
+    tools: [tool, send, stop, read, list],
+    tasks: [SubagentAnchor, SubagentReporter],
     sections: [
       section2("agent_roles", () => {
         const defined = roles();
@@ -1440,9 +2518,9 @@ ${role.prompt}`,
 }
 
 // apps/host/src/extensions/todo.ts
-import { defineDoc as defineDoc5, defineExtension as defineExtension4, defineTool as defineTool3 } from "@earendil-works/pi-durable";
+import { defineDoc as defineDoc8, defineExtension as defineExtension6, defineTool as defineTool4 } from "@earendil-works/pi-durable";
 import { Type as Type4 } from "typebox";
-var TodoDoc = defineDoc5({
+var TodoDoc = defineDoc8({
   kind: "todo.list",
   version: 1,
   scope: "conversation",
@@ -1451,7 +2529,7 @@ var TodoDoc = defineDoc5({
   initial: () => ({ items: [] }),
   checkpointWhen: () => false
 });
-var todoWrite = defineTool3({
+var todoWrite = defineTool4({
   name: "todo_write",
   description: "Replace the todo list shown to the user with the given items.",
   parameters: Type4.Object({ items: Type4.Array(TodoItemSchema) }),
@@ -1465,7 +2543,7 @@ var todoWrite = defineTool3({
   }
 });
 var todo = {
-  extension: defineExtension4({ name: "todo", tools: [todoWrite] }),
+  extension: defineExtension6({ name: "todo", tools: [todoWrite] }),
   docs: [{ token: TodoDoc, presentation: "pinomad.todo" }]
 };
 
@@ -1473,8 +2551,8 @@ var todo = {
 import { stat as stat6 } from "node:fs/promises";
 import { createServer } from "node:http";
 import { homedir, networkInterfaces } from "node:os";
-import { join as join7, sep as sep5 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
+import { join as join8, sep as sep6 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
 import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
   AgentDoc as AgentDoc5,
@@ -1483,7 +2561,7 @@ import {
   LiveDoc
 } from "@earendil-works/pi-durable";
 import { WebSocket as WebSocket2, WebSocketServer } from "ws";
-import { Value as Value2 } from "typebox/value";
+import { Value } from "typebox/value";
 
 // apps/host/src/secure-carrier.ts
 import { WebSocket } from "ws";
@@ -1519,7 +2597,7 @@ function webSocketCarrier(socket) {
 }
 
 // apps/host/src/rtc.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 var BUFFER_HIGH_WATER = 256 * 1024;
 var BUFFER_LOW_WATER = 64 * 1024;
 var PUMP_STALL_MS = 1e4;
@@ -1778,7 +2856,7 @@ function nodeRtcFactory(loaded) {
       const max = parseRtcMaxMessageSize(input.offerSdp);
       if (max.kind === "invalid")
         throw new Error(max.reason);
-      const pc = new ndc.PeerConnection(`pinomad-${randomUUID()}`, { iceServers: [...input.stun] });
+      const pc = new ndc.PeerConnection(`pinomad-${randomUUID2()}`, { iceServers: [...input.stun] });
       const timers = input.timers;
       const candidates = new Set;
       let localSdp;
@@ -2037,17 +3115,17 @@ function dataChannelCarrier(channel, timers, log, onClosed) {
       stallTimer = timers.setTimeout(stall, 1000);
   };
   channel.onBufferedAmountLow(() => pump());
-  channel.onMessage((message) => {
-    if (typeof message === "string")
+  channel.onMessage((message2) => {
+    if (typeof message2 === "string")
       handlers?.text();
-    else if (message instanceof ArrayBuffer)
-      handlers?.binary(new Uint8Array(message));
+    else if (message2 instanceof ArrayBuffer)
+      handlers?.binary(new Uint8Array(message2));
     else
-      handlers?.binary(message);
+      handlers?.binary(message2);
   });
   channel.onClosed(finish);
-  channel.onError((message) => {
-    log("rtc-datachannel-error", { message });
+  channel.onError((message2) => {
+    log("rtc-datachannel-error", { message: message2 });
     finish();
   });
   return {
@@ -2077,12 +3155,218 @@ function dataChannelCarrier(channel, timers, log, onClosed) {
 }
 
 // apps/host/src/terminals.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { userInfo } from "node:os";
-var TERMINAL_LIMIT = 8;
+
+// apps/host/src/output-buffer.ts
 var BUFFER_SIZE = 512 * 1024;
 var FLUSH_MS = 8;
 var MAX_CHUNK = 16 * 1024;
+
+class OutputBuffer {
+  #bufferSize;
+  #flushMs;
+  #maxChunk;
+  #onFlush;
+  #viewers = new Set;
+  #buffer = "";
+  #start = 0;
+  #pending = "";
+  #timer;
+  #ended = false;
+  constructor(options = {}) {
+    this.#bufferSize = options.bufferSize ?? BUFFER_SIZE;
+    this.#flushMs = options.flushMs ?? FLUSH_MS;
+    this.#maxChunk = options.maxChunk ?? MAX_CHUNK;
+    this.#onFlush = options.onFlush;
+  }
+  get start() {
+    return this.#start;
+  }
+  get end() {
+    return this.#start + this.#buffer.length;
+  }
+  get length() {
+    return this.#buffer.length;
+  }
+  get ended() {
+    return this.#ended;
+  }
+  push(data) {
+    if (this.#ended || data === "")
+      return;
+    this.#pending += data;
+    if (this.#pending.length >= this.#maxChunk)
+      this.flush();
+    else
+      this.#timer ??= setTimeout(() => this.flush(), this.#flushMs);
+  }
+  flush() {
+    if (this.#timer !== undefined)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+    const data = this.#pending;
+    if (data === "")
+      return;
+    this.#pending = "";
+    this.#buffer += data;
+    this.#trim();
+    this.#onFlush?.(data);
+    for (const viewer of this.#viewers)
+      this.#pump(viewer);
+  }
+  discard() {
+    if (this.#timer !== undefined)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+    const gap = this.#buffer.length + this.#pending.length + 1;
+    this.#buffer = "";
+    this.#pending = "";
+    this.#start += gap;
+    for (const viewer of this.#viewers)
+      viewer.position = undefined;
+  }
+  close(reason) {
+    if (this.#ended)
+      return;
+    if (this.#timer !== undefined)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+    this.#ended = true;
+    for (const viewer of this.#viewers)
+      viewer.sink.ended(reason);
+    this.#viewers.clear();
+  }
+  attach(since, sink) {
+    const position = since !== undefined && since >= this.#start && since <= this.end ? since : undefined;
+    const viewer = { sink, position, sending: false };
+    this.#viewers.add(viewer);
+    this.#pump(viewer);
+    return () => {
+      this.#viewers.delete(viewer);
+    };
+  }
+  snapshot(since, maxChunk = this.#maxChunk) {
+    const end = this.end;
+    const from = since === undefined ? this.#start : Math.min(Math.max(since, this.#start), end);
+    let to = Math.min(end, from + maxChunk);
+    if (to < end) {
+      const partial = partialEscapeStart(this.#buffer, from - this.#start, to - this.#start);
+      if (partial !== undefined && this.#start + partial > from)
+        to = this.#start + partial;
+    }
+    if (to < end && isHighSurrogate(this.#buffer.charCodeAt(to - this.#start - 1)))
+      to--;
+    const text = this.#buffer.slice(from - this.#start, to - this.#start);
+    return {
+      text,
+      next: to,
+      truncated: since === undefined ? this.#start > 0 : since < this.#start
+    };
+  }
+  #trim() {
+    if (this.#buffer.length <= this.#bufferSize)
+      return;
+    let cut2 = this.#buffer.length - this.#bufferSize;
+    const line = this.#buffer.indexOf(`
+`, cut2);
+    if (line !== -1 && line - cut2 < 1024)
+      cut2 = line + 1;
+    this.#buffer = this.#buffer.slice(cut2);
+    this.#start += cut2;
+  }
+  async#pump(viewer) {
+    if (viewer.sending)
+      return;
+    viewer.sending = true;
+    try {
+      while (this.#viewers.has(viewer)) {
+        const end = this.end;
+        const reset = viewer.position === undefined || viewer.position < this.#start;
+        const from = reset ? this.#start : viewer.position;
+        if (reset && end === this.#start)
+          return;
+        if (!reset && from >= end)
+          return;
+        let to = reset ? end : Math.min(end, from + this.#maxChunk);
+        if (to < end && isHighSurrogate(this.#buffer.charCodeAt(to - this.#start - 1)))
+          to--;
+        const data = this.#buffer.slice(from - this.#start, to - this.#start);
+        viewer.position = to;
+        await viewer.sink.output(reset ? { seq: to, data, reset: true } : { seq: to, data });
+      }
+    } finally {
+      viewer.sending = false;
+    }
+  }
+}
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+function partialEscapeStart(text, from, to) {
+  let index = from;
+  while (index < to) {
+    if (text.charCodeAt(index) !== 27) {
+      index++;
+      continue;
+    }
+    const end = escapeEnd(text, index, to);
+    if (end === -1)
+      return index;
+    index = end;
+  }
+  return;
+}
+function escapeEnd(text, start, limit) {
+  let index = start + 1;
+  if (index >= limit)
+    return -1;
+  const kind = text.charCodeAt(index);
+  if (kind === 91) {
+    index++;
+    while (index < limit) {
+      const code = text.charCodeAt(index);
+      if (code >= 64 && code <= 126)
+        return index + 1;
+      index++;
+    }
+    return -1;
+  }
+  if (kind === 93) {
+    index++;
+    while (index < limit) {
+      const code = text.charCodeAt(index);
+      if (code === 7)
+        return index + 1;
+      if (code === 27 && index + 1 < limit && text.charCodeAt(index + 1) === 92)
+        return index + 2;
+      index++;
+    }
+    return -1;
+  }
+  if (kind === 80 || kind === 88 || kind === 94 || kind === 95) {
+    index++;
+    while (index < limit) {
+      if (text.charCodeAt(index) === 27 && index + 1 < limit && text.charCodeAt(index + 1) === 92) {
+        return index + 2;
+      }
+      index++;
+    }
+    return -1;
+  }
+  while (index < limit) {
+    const code = text.charCodeAt(index);
+    if (code >= 32 && code <= 47) {
+      index++;
+      continue;
+    }
+    return index + 1;
+  }
+  return -1;
+}
+
+// apps/host/src/terminals.ts
+var TERMINAL_LIMIT = 8;
 var MAX_TITLE = 1024;
 var TITLE = /\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
 
@@ -2122,7 +3406,7 @@ class Terminals {
     const number = (this.#numbers.get(owner) ?? 0) + 1;
     this.#numbers.set(owner, number);
     const terminal = {
-      id: randomUUID2(),
+      id: randomUUID3(),
       owner,
       cwd,
       number,
@@ -2133,12 +3417,16 @@ class Terminals {
       title: undefined,
       rename: undefined,
       exit: undefined,
-      buffer: "",
-      start: 0,
-      pending: "",
-      flushTimer: undefined,
-      titleCarry: "",
-      viewers: new Set
+      output: new OutputBuffer({
+        ...this.#options.bufferSize === undefined ? {} : { bufferSize: this.#options.bufferSize },
+        ...this.#options.flushMs === undefined ? {} : { flushMs: this.#options.flushMs },
+        ...this.#options.maxChunk === undefined ? {} : { maxChunk: this.#options.maxChunk },
+        onFlush: (data) => {
+          if (this.#readTitle(terminal, data))
+            this.#changed(owner);
+        }
+      }),
+      titleCarry: ""
     };
     this.#terminals.set(terminal.id, terminal);
     try {
@@ -2168,16 +3456,12 @@ class Terminals {
   restart(id, size) {
     const terminal = this.#get(id);
     this.#stop(terminal);
-    terminal.start += terminal.buffer.length + terminal.pending.length + 1;
-    terminal.buffer = "";
-    terminal.pending = "";
+    terminal.output.discard();
     terminal.titleCarry = "";
     terminal.title = undefined;
     terminal.exit = undefined;
     terminal.cols = size.cols;
     terminal.rows = size.rows;
-    for (const viewer of terminal.viewers)
-      viewer.position = undefined;
     try {
       this.#start(terminal);
     } catch (error) {
@@ -2206,15 +3490,7 @@ class Terminals {
     this.closeOwners([...this.#terminals.values()].map((terminal) => terminal.owner));
   }
   attach(id, since, sink) {
-    const terminal = this.#get(id);
-    const end = terminal.start + terminal.buffer.length;
-    const position = since !== undefined && since >= terminal.start && since <= end ? since : undefined;
-    const viewer = { sink, position, sending: false };
-    terminal.viewers.add(viewer);
-    this.#pump(terminal, viewer);
-    return () => {
-      terminal.viewers.delete(viewer);
-    };
+    return this.#get(id).output.attach(since, sink);
   }
   #get(id) {
     const terminal = this.#terminals.get(id);
@@ -2236,25 +3512,19 @@ class Terminals {
     pty.onData((data) => {
       if (terminal.generation !== generation)
         return;
-      terminal.pending += data;
-      if (terminal.pending.length >= (this.#options.maxChunk ?? MAX_CHUNK))
-        this.#flush(terminal);
-      else
-        terminal.flushTimer ??= setTimeout(() => this.#flush(terminal), this.#options.flushMs ?? FLUSH_MS);
+      this.#options.onOutput?.();
+      terminal.output.push(data);
     });
     pty.onExit(({ exitCode, signal }) => {
       if (terminal.generation !== generation || !this.#terminals.has(terminal.id))
         return;
-      this.#flush(terminal);
+      terminal.output.flush();
       terminal.pty = undefined;
       terminal.exit = signal === undefined || signal === 0 ? { code: exitCode } : { code: exitCode, signal };
       this.#changed(terminal.owner);
     });
   }
   #stop(terminal) {
-    if (terminal.flushTimer !== undefined)
-      clearTimeout(terminal.flushTimer);
-    terminal.flushTimer = undefined;
     terminal.generation++;
     const pty = terminal.pty;
     terminal.pty = undefined;
@@ -2264,10 +3534,8 @@ class Terminals {
   }
   #remove(terminal) {
     this.#stop(terminal);
+    terminal.output.close("Terminal closed");
     this.#terminals.delete(terminal.id);
-    for (const viewer of terminal.viewers)
-      viewer.sink.ended("Terminal closed");
-    terminal.viewers.clear();
   }
   #resize(terminal, size) {
     if (terminal.cols === size.cols && terminal.rows === size.rows)
@@ -2279,30 +3547,6 @@ class Terminals {
     } catch {}
     this.#changed(terminal.owner);
   }
-  #flush(terminal) {
-    if (terminal.flushTimer !== undefined)
-      clearTimeout(terminal.flushTimer);
-    terminal.flushTimer = undefined;
-    const data = terminal.pending;
-    if (data === "")
-      return;
-    terminal.pending = "";
-    terminal.buffer += data;
-    const bufferSize = this.#options.bufferSize ?? BUFFER_SIZE;
-    if (terminal.buffer.length > bufferSize) {
-      let cut = terminal.buffer.length - bufferSize;
-      const line = terminal.buffer.indexOf(`
-`, cut);
-      if (line !== -1 && line - cut < 1024)
-        cut = line + 1;
-      terminal.buffer = terminal.buffer.slice(cut);
-      terminal.start += cut;
-    }
-    if (this.#readTitle(terminal, data))
-      this.#changed(terminal.owner);
-    for (const viewer of terminal.viewers)
-      this.#pump(terminal, viewer);
-  }
   #readTitle(terminal, data) {
     const text = terminal.titleCarry + data;
     let title;
@@ -2318,29 +3562,6 @@ class Terminals {
     terminal.title = title;
     return terminal.rename === undefined;
   }
-  async#pump(terminal, viewer) {
-    if (viewer.sending)
-      return;
-    viewer.sending = true;
-    try {
-      const maxChunk = this.#options.maxChunk ?? MAX_CHUNK;
-      while (terminal.viewers.has(viewer)) {
-        const end = terminal.start + terminal.buffer.length;
-        const reset = viewer.position === undefined || viewer.position < terminal.start;
-        const from = reset ? terminal.start : viewer.position;
-        if (!reset && from >= end)
-          return;
-        let to = reset ? end : Math.min(end, from + maxChunk);
-        if (to < end && isHighSurrogate(terminal.buffer.charCodeAt(to - terminal.start - 1)))
-          to--;
-        const data = terminal.buffer.slice(from - terminal.start, to - terminal.start);
-        viewer.position = to;
-        await viewer.sink.output(reset ? { seq: to, data, reset: true } : { seq: to, data });
-      }
-    } finally {
-      viewer.sending = false;
-    }
-  }
   #changed(owner) {
     const watchers = this.#watchers.get(owner);
     if (watchers === undefined)
@@ -2351,20 +3572,20 @@ class Terminals {
   }
 }
 async function startTerminals(options = {}) {
-  let spawn3 = options.spawn;
-  if (spawn3 === undefined) {
+  let spawn4 = options.spawn;
+  if (spawn4 === undefined) {
     try {
       const loaded = options.load === undefined ? await import("@lydell/node-pty") : await options.load();
       if (typeof loaded.spawn !== "function")
         throw new Error("the module has no spawn()");
-      spawn3 = loaded.spawn;
+      spawn4 = loaded.spawn;
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
       (options.diagnostic ?? console.error)(`Terminals unavailable: cannot load @lydell/node-pty on ${process.platform} (${process.arch}); missing @lydell/node-pty-${process.platform}-${process.arch}. Install without --omit=optional; the host continues without hello.terminals. (${detail})`);
       return;
     }
   }
-  return new Terminals({ ...options, spawn: spawn3, shell: options.shell ?? loginShell(), env: options.env ?? shellEnv(process.env) });
+  return new Terminals({ ...options, spawn: spawn4, shell: options.shell ?? loginShell(), env: options.env ?? shellEnv(process.env) });
 }
 function loginShell() {
   let file = process.env.SHELL;
@@ -2378,12 +3599,12 @@ function loginShell() {
   return { file: file === undefined || file === "" ? "/bin/sh" : file, args: ["-l"] };
 }
 function shellEnv(env) {
-  const result2 = {};
+  const result3 = {};
   for (const [key, value] of Object.entries(env)) {
     if (value !== undefined && !key.startsWith("PINOMAD_"))
-      result2[key] = value;
+      result3[key] = value;
   }
-  return result2;
+  return result3;
 }
 function info(terminal) {
   return {
@@ -2395,13 +3616,10 @@ function info(terminal) {
     ...terminal.exit === undefined ? {} : { exit: terminal.exit }
   };
 }
-function isHighSurrogate(code) {
-  return code >= 55296 && code <= 56319;
-}
 
 // apps/host/src/folders.ts
 import { readdir, realpath as realpath5, stat as stat5 } from "node:fs/promises";
-import { isAbsolute, join as join6 } from "node:path";
+import { isAbsolute, join as join7 } from "node:path";
 var denied = (error) => {
   const code = error?.code;
   return code === "EACCES" || code === "EPERM";
@@ -2431,10 +3649,10 @@ async function listFolders(path, home) {
       continue;
     let isDirectory = entry.isDirectory();
     if (!isDirectory && entry.isSymbolicLink()) {
-      isDirectory = await stat5(join6(dir, entry.name)).then((target) => target.isDirectory(), () => false);
+      isDirectory = await stat5(join7(dir, entry.name)).then((target) => target.isDirectory(), () => false);
     }
     if (isDirectory)
-      folders.push({ name: entry.name, path: join6(dir, entry.name) });
+      folders.push({ name: entry.name, path: join7(dir, entry.name) });
   }
   folders.sort((a, b) => a.name.localeCompare(b.name, "en", { numeric: true, sensitivity: "base" }));
   return { path: dir, home: await realpath5(home).catch(() => home), folders };
@@ -2620,7 +3838,7 @@ function imageProblem(images) {
 // apps/host/src/image-refs.ts
 import { createHash } from "node:crypto";
 import { applyImmutable } from "@earendil-works/chord/delta";
-var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isObject2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var isImageBlock = (value) => value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string";
 var hashed = new WeakMap;
 function refOf(block) {
@@ -2712,7 +3930,7 @@ function rewriteEntries(value) {
   return out ?? value;
 }
 function rewriteEntry(value) {
-  if (!isObject(value) || value.model === undefined)
+  if (!isObject2(value) || value.model === undefined)
     return value;
   const model = rewriteMessages(value.model);
   return model === value.model ? value : { ...value, model };
@@ -2729,7 +3947,7 @@ function rewriteMessages(value) {
   return out ?? value;
 }
 function rewriteMessage(value) {
-  if (!isObject(value) || value.content === undefined)
+  if (!isObject2(value) || value.content === undefined)
     return value;
   const content = rewriteContent(value.content);
   return content === value.content ? value : { ...value, content };
@@ -2740,7 +3958,7 @@ function rewriteContent(value) {
   let out;
   for (let i = 0;i < value.length; i++) {
     const block = value[i];
-    const next = isObject(block) && isImageBlock(block) ? withRef(block) : block;
+    const next = isObject2(block) && isImageBlock(block) ? withRef(block) : block;
     if (next !== block)
       (out ??= value.slice())[i] = next;
   }
@@ -2758,31 +3976,31 @@ function rewriteItems(value) {
   return out ?? value;
 }
 function rewriteItem(value) {
-  if (!isObject(value) || value.content === undefined)
+  if (!isObject2(value) || value.content === undefined)
     return value;
   const content = rewriteContent(value.content);
   return content === value.content ? value : { ...value, content };
 }
 function rewriteInbox(value) {
-  if (!isObject(value) || value.items === undefined)
+  if (!isObject2(value) || value.items === undefined)
     return value;
   const items = rewriteItems(value.items);
   return items === value.items ? value : { ...value, items };
 }
 function rewriteGeneration(value) {
-  if (!isObject(value) || value.message === undefined)
+  if (!isObject2(value) || value.message === undefined)
     return value;
-  const message = rewriteMessage(value.message);
-  return message === value.message ? value : { ...value, message };
+  const message2 = rewriteMessage(value.message);
+  return message2 === value.message ? value : { ...value, message: message2 };
 }
 function rewriteLive(value) {
-  if (!isObject(value) || value.generation === undefined)
+  if (!isObject2(value) || value.generation === undefined)
     return value;
   const generation = rewriteGeneration(value.generation);
   return generation === value.generation ? value : { ...value, generation };
 }
 function rewriteDocs(value) {
-  if (!isObject(value))
+  if (!isObject2(value))
     return value;
   let out;
   for (const key of ["pi.inbox", "pi.live"]) {
@@ -2796,7 +4014,7 @@ function rewriteDocs(value) {
   return out ?? value;
 }
 function rewriteView(value) {
-  if (!isObject(value))
+  if (!isObject2(value))
     return value;
   let out;
   if (value.entries !== undefined) {
@@ -2824,7 +4042,7 @@ function rewriteSlot(slot, value) {
     case "content":
       return rewriteContent(value);
     case "block":
-      return isObject(value) && isImageBlock(value) ? withRef(value) : value;
+      return isObject2(value) && isImageBlock(value) ? withRef(value) : value;
     case "docs":
       return rewriteDocs(value);
     case "inbox":
@@ -2889,35 +4107,35 @@ function reachesIntoImage(op, root) {
     if (slotAt(path.slice(0, length)) !== "block")
       continue;
     const node = resolve4(root, path, length);
-    if (isObject(node) && isImageBlock(node))
+    if (isObject2(node) && isImageBlock(node))
       return true;
   }
   return false;
 }
 function* contentArrays(view) {
-  if (!isObject(view))
+  if (!isObject2(view))
     return;
   if (Array.isArray(view.entries)) {
     for (const entry of view.entries) {
-      if (!isObject(entry) || !Array.isArray(entry.model))
+      if (!isObject2(entry) || !Array.isArray(entry.model))
         continue;
-      for (const message of entry.model) {
-        if (isObject(message) && Array.isArray(message.content))
-          yield message.content;
+      for (const message2 of entry.model) {
+        if (isObject2(message2) && Array.isArray(message2.content))
+          yield message2.content;
       }
     }
   }
-  if (!isObject(view.docs))
+  if (!isObject2(view.docs))
     return;
   const inbox = view.docs["pi.inbox"];
-  if (isObject(inbox) && Array.isArray(inbox.items)) {
+  if (isObject2(inbox) && Array.isArray(inbox.items)) {
     for (const item of inbox.items) {
-      if (isObject(item) && Array.isArray(item.content))
+      if (isObject2(item) && Array.isArray(item.content))
         yield item.content;
     }
   }
   const live = view.docs["pi.live"];
-  if (isObject(live) && isObject(live.generation) && isObject(live.generation.message) && Array.isArray(live.generation.message.content)) {
+  if (isObject2(live) && isObject2(live.generation) && isObject2(live.generation.message) && Array.isArray(live.generation.message.content)) {
     yield live.generation.message.content;
   }
 }
@@ -2925,7 +4143,7 @@ function imageBlocks(view) {
   const blocks = [];
   for (const content of contentArrays(view)) {
     for (const block of content) {
-      if (isObject(block) && isImageBlock(block))
+      if (isObject2(block) && isImageBlock(block))
         blocks.push(block);
     }
   }
@@ -3013,8 +4231,8 @@ class ImageVariants {
       if (job === undefined)
         return;
       this.#active += 1;
-      this.#derive(job.key, job.variant, job.original).then((result2) => {
-        job.resolve(result2);
+      this.#derive(job.key, job.variant, job.original).then((result3) => {
+        job.resolve(result3);
         this.#finish();
       }, (error) => {
         job.reject(error instanceof Error ? error : new Error(String(error)));
@@ -3035,13 +4253,13 @@ class ImageVariants {
       if (prepared === undefined || prepared.data === original.data && prepared.mimeType === original.mimeType) {
         return { ...original, variant: "original" };
       }
-      const result2 = {
+      const result3 = {
         data: prepared.data,
         mimeType: prepared.mimeType,
         variant
       };
-      this.#write(key, result2);
-      return result2;
+      this.#write(key, result3);
+      return result3;
     } catch {
       return { ...original, variant: "original" };
     }
@@ -3054,8 +4272,8 @@ class ImageVariants {
     this.#cache.set(key, cached);
     return cached;
   }
-  #write(key, result2) {
-    const bytes = result2.data.length;
+  #write(key, result3) {
+    const bytes = result3.data.length;
     if (bytes > this.#maxCacheBytes)
       return;
     while (this.#cacheBytes + bytes > this.#maxCacheBytes) {
@@ -3066,17 +4284,17 @@ class ImageVariants {
       this.#cache.delete(oldest);
       this.#cacheBytes -= previous.data.length;
     }
-    this.#cache.set(key, result2);
+    this.#cache.set(key, result3);
     this.#cacheBytes += bytes;
   }
 }
 
 // apps/host/src/auto-title.ts
-import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
 
 // apps/host/src/title-doc.ts
-import { defineDoc as defineDoc6 } from "@earendil-works/pi-durable";
-var TitleDoc = defineDoc6({
+import { defineDoc as defineDoc9 } from "@earendil-works/pi-durable";
+var TitleDoc = defineDoc9({
   kind: "pinomad.title",
   version: 1,
   scope: "conversation",
@@ -3087,11 +4305,11 @@ var TitleDoc = defineDoc6({
 });
 
 // apps/host/src/auto-title.ts
-var context = BACKGROUND_CONTEXT;
+var context = BACKGROUND_CONTEXT2;
 var TITLE_PROMPT = "You name conversations between a user and a coding agent. Reply with only the title: at most 6 words" + " (about 20 characters for Chinese or Japanese), in the same language as the user's message, no quotes," + " no trailing punctuation. Name the task, not the agent's answer.";
 var TITLE_INPUT_LIMIT = 2000;
 var TITLE_MAX_LENGTH = 80;
-var textOf = (content) => {
+var textOf2 = (content) => {
   if (typeof content === "string")
     return content;
   if (!Array.isArray(content))
@@ -3148,7 +4366,7 @@ function attachAutoTitle(runs, deps) {
         return;
       const firstMessage = first.model?.[0];
       const firstText = (stripUserBlocks(firstMessage?.content ?? "").text || "(images or files only)").slice(0, TITLE_INPUT_LIMIT);
-      const answer = textOf(last.content).slice(0, TITLE_INPUT_LIMIT);
+      const answer = textOf2(last.content).slice(0, TITLE_INPUT_LIMIT);
       const request = {
         systemPrompt: TITLE_PROMPT,
         messages: [
@@ -3195,8 +4413,8 @@ ${answer}`}`,
 
 // apps/host/src/push.ts
 import { createHash as createHash2 } from "node:crypto";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
-import { defineDoc as defineDoc7 } from "@earendil-works/pi-durable";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
+import { defineDoc as defineDoc10 } from "@earendil-works/pi-durable";
 
 // packages/client/src/family.ts
 var SUBAGENT_TASK_PREFIX = /^\s*in the working directory\s+\S+,\s*/i;
@@ -3253,8 +4471,8 @@ function diffRunNotices(previous, organized) {
 }
 
 // apps/host/src/push.ts
-var context2 = BACKGROUND_CONTEXT2;
-var PushDoc = defineDoc7({
+var context2 = BACKGROUND_CONTEXT3;
+var PushDoc = defineDoc10({
   kind: "pinomad.push",
   version: 2,
   scope: "session",
@@ -3391,18 +4609,18 @@ async function attachPushSender(options) {
     return await new Promise((resolve5) => {
       const waiters = titleWaiters.get(notice.id) ?? new Set;
       titleWaiters.set(notice.id, waiters);
-      const settle = (title) => {
-        waiters.delete(settle);
+      const settle2 = (title) => {
+        waiters.delete(settle2);
         if (waiters.size === 0)
           titleWaiters.delete(notice.id);
         timers.clearTimeout(timer);
         resolve5(title);
       };
-      const timer = timers.setTimeout(() => settle(FALLBACK_TITLE), TITLE_WAIT_MS);
-      waiters.add(settle);
+      const timer = timers.setTimeout(() => settle2(FALLBACK_TITLE), TITLE_WAIT_MS);
+      waiters.add(settle2);
       namedTitle(notice.id).then((title) => {
         if (title !== undefined)
-          settle(title);
+          settle2(title);
       });
     });
   };
@@ -3529,24 +4747,29 @@ async function attachPushSender(options) {
     }
   };
   const unsubscribeConversations = conversations.subscribe(() => update());
-  const unsubscribeCommits = harness.subscribeCommits((publication) => {
-    for (const change of publication.changes) {
-      if (change.type !== "document" || change.record.kind !== TitleDoc.definition.kind)
-        continue;
-      const id = change.conversationId;
-      if (id === undefined)
-        continue;
-      const title = change.value?.title;
-      if (typeof title !== "string" || title === "")
-        continue;
-      const waiters = titleWaiters.get(id);
-      titleWaiters.delete(id);
-      for (const settle of waiters ?? [])
-        settle(title);
-    }
+  const commits = harness.observeCommits({
+    advance: (publication) => {
+      for (const change of publication.changes) {
+        if (change.type !== "document" || change.kind !== "change" || change.record.kind !== TitleDoc.definition.kind)
+          continue;
+        const id = change.conversationId;
+        if (id === undefined)
+          continue;
+        const title = change.value.title;
+        if (typeof title !== "string" || title === "")
+          continue;
+        const waiters = titleWaiters.get(id);
+        titleWaiters.delete(id);
+        for (const settle2 of waiters ?? [])
+          settle2(title);
+      }
+    },
+    end: () => {}
   });
-  indexWatch?.start(async (value) => {
-    index = value ?? undefined;
+  indexWatch?.start(async (call) => {
+    if (call.kind !== "value")
+      return;
+    index = call.value;
     update();
   });
   update();
@@ -3555,7 +4778,7 @@ async function attachPushSender(options) {
     async close() {
       disposed = true;
       unsubscribeConversations();
-      unsubscribeCommits();
+      commits.detach();
       await indexWatch?.stop();
       for (const item of pending)
         drop(item);
@@ -3594,7 +4817,7 @@ function toolTarget(args) {
 }
 
 // apps/host/src/gateway.ts
-var context3 = BACKGROUND_CONTEXT3;
+var context3 = BACKGROUND_CONTEXT4;
 var forkTails = new WeakMap;
 function assertQueuedInput(record, conversationId) {
   if (record.conversationId !== conversationId) {
@@ -3607,7 +4830,7 @@ async function dismissPendingQuestions(tx, docs, conversationId) {
   let dismissed = false;
   for (const doc of docs) {
     const value = await tx.doc(doc.token, conversationId);
-    if (!Value2.Check(QuestionSchema, value))
+    if (!Value.Check(QuestionSchema, value))
       continue;
     for (const request of value.requests) {
       if (request.resolution === undefined) {
@@ -3659,6 +4882,19 @@ function submitResult(record) {
     ...record.entry === undefined ? {} : { entry: record.entry }
   };
 }
+var AGENT_WORK_CALLS = new Set(["submit", "createConversation", "runCommand", "compact", "answer"]);
+var NO_UPGRADES = constantValue({
+  current: packagedVersion ?? null,
+  available: null,
+  blocked: "source",
+  phase: "idle",
+  target: null,
+  attempt: 0,
+  checking: false,
+  checkedAt: null,
+  checkError: null,
+  failure: null
+});
 var LOOPBACK_SECURE_PATH = "/secure";
 async function startGateway(options) {
   if (options.secure?.lan?.publicUrl !== undefined)
@@ -3694,10 +4930,16 @@ async function startGateway(options) {
   const clients = new Set;
   let rtc;
   const rtcHello = () => rtc?.hello();
-  const terminals = await startTerminals(options.terminals);
-  const broadcast = (level, message) => {
+  const terminals = await startTerminals({
+    ...options.terminals,
+    onOutput: () => {
+      options.terminals?.onOutput?.();
+      options.upgrade?.touch();
+    }
+  });
+  const broadcast = (level, message2) => {
     for (const client of clients)
-      client.send({ type: "notice", level, message });
+      client.send({ type: "notice", level, message: message2 });
   };
   let remote;
   let relay;
@@ -3732,6 +4974,7 @@ async function startGateway(options) {
       devicePublicKey,
       rtcHello,
       terminals,
+      ...options.processes === undefined ? {} : { processes: options.processes },
       closed: (self) => {
         clients.delete(self);
         connections.delete(self);
@@ -3969,6 +5212,7 @@ async function startGateway(options) {
       await detachPush?.close();
       conversations.dispose();
       terminals?.closeAll();
+      await options.processes?.close(context3);
       await rtc?.close();
       await Promise.all([...connections].map((connection) => connection.dispose()));
       for (const socket of server.clients)
@@ -4141,6 +5385,8 @@ function secureHandshake(carrier, secure, policy, handlers) {
         session = new SecureSession(admitted.result);
         stage = "settled";
         await carrier.send(admitted.message);
+        if (closed)
+          return;
         if (admitted.purpose === "signal")
           handlers.signal?.(connection, admitted.deviceKey);
         else
@@ -4201,10 +5447,10 @@ function secureHandshake(carrier, secure, policy, handlers) {
         if (decision.outcome === "admitted" && decision.requestId !== undefined) {
           policy.accountAdmitted(decision.requestId, deviceKey);
         }
-        const { message, result: result2 } = responder.writeMessage2(encodeHostHello({ v: 1 }));
+        const { message: message2, result: result3 } = responder.writeMessage2(encodeHostHello({ v: 1 }));
         return {
-          result: result2,
-          message,
+          result: result3,
+          message: message2,
           deviceKey,
           purpose,
           ...decision.outcome === "admitted" ? { joined: decision.entry } : {}
@@ -4271,12 +5517,16 @@ class ConversationList {
   #list = [];
   #unsubscribe = () => {};
   #notifying = false;
+  #harness;
+  #live = new Map;
+  #disposed = false;
   constructor(docs) {
     this.#questionTokens = (docs ?? []).filter((doc) => doc.presentation === "pinomad.question").map((doc) => doc.token);
     this.#questionKinds = new Set(this.#questionTokens.map((token) => token.definition.kind));
   }
   static async open(harness, docs) {
     const list = new ConversationList(docs);
+    list.#harness = harness;
     const summaries = [];
     let cursor;
     const records = [];
@@ -4295,10 +5545,13 @@ class ConversationList {
       summaries.push(list.#summaryOf(record));
     }
     list.#list = summaries;
-    list.#unsubscribe = harness.subscribeCommits((publication) => list.#observe(publication));
+    const observation = harness.observeCommits({ advance: (publication) => list.#observe(publication), end: () => {} });
+    list.#unsubscribe = () => observation.detach();
     const touched = new Set;
     list.#reindex(await harness.snapshot(IndexDoc, context3), touched);
     list.#refreshSummaries(touched);
+    for (const [id, facts] of list.#facts)
+      list.#followLive(id, facts.running === true);
     return list;
   }
   async#load(harness, record) {
@@ -4309,7 +5562,7 @@ class ConversationList {
     facts.tools = live?.tools;
     for (const token of this.#questionTokens) {
       const value = await harness.snapshot(token, record.id, context3);
-      if (Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined)) {
+      if (Value.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined)) {
         facts.pending.add(token.definition.kind);
       }
     }
@@ -4320,6 +5573,9 @@ class ConversationList {
       if (typeof subagent?.role === "string" && subagent.role !== "")
         facts.role = subagent.role;
       facts.model = modelRefOf(subagent?.model);
+      if (typeof subagent?.name === "string" && subagent.name !== "")
+        facts.name = subagent.name;
+      facts.lifecycle = subagent?.lifecycle === "background" ? "background" : "foreground";
     }
     facts.agent = roleNameOf(await harness.snapshot(RoleDoc, record.id, context3));
     const named = (await harness.snapshot(TitleDoc, record.id, context3))?.title;
@@ -4348,29 +5604,30 @@ class ConversationList {
           continue;
         touched.add(entry.conversationId);
         facts.newest = entry.id;
-        const message = entry.model?.[0];
-        facts.updatedAt = typeof message?.timestamp === "number" ? message.timestamp : undefined;
-        facts.failed = entry.kind === "pi.assistant" && message?.role === "assistant" && message.stopReason === "error";
-        facts.calls = entry.kind === "pi.assistant" ? callsOf(message) : undefined;
+        const message2 = entry.model?.[0];
+        facts.updatedAt = typeof message2?.timestamp === "number" ? message2.timestamp : undefined;
+        facts.failed = entry.kind === "pi.assistant" && message2?.role === "assistant" && message2.stopReason === "error";
+        facts.calls = entry.kind === "pi.assistant" ? callsOf(message2) : undefined;
       } else if (change.type === "document") {
         const id = change.conversationId;
+        const value = change.kind === "change" ? change.value : null;
         if (id === undefined) {
           if (change.record.kind === IndexDoc.definition.kind)
-            this.#reindex(change.value, touched);
+            this.#reindex(value, touched);
           continue;
         }
         const facts = this.#fact(id);
         if (change.record.kind === "pi.live") {
-          const live = change.value;
+          const live = value;
           const wasRunning = facts.running === true;
           facts.running = live?.run !== undefined;
           facts.tools = live?.tools;
           touched.add(id);
+          this.#followLive(id, facts.running);
           if (wasRunning && !facts.running && this.#records.get(id)?.owner === undefined)
             ended.add(id);
         } else if (this.#questionKinds.has(change.record.kind)) {
-          const value = change.value;
-          const pending = Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined);
+          const pending = Value.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined);
           const next = new Set(facts.pending);
           if (pending)
             next.add(change.record.kind);
@@ -4379,16 +5636,18 @@ class ConversationList {
           facts.pending = next;
           touched.add(id);
         } else if (change.record.kind === RoleDoc.definition.kind) {
-          facts.agent = roleNameOf(change.value);
+          facts.agent = roleNameOf(value);
           touched.add(id);
         } else if (change.record.kind === SubagentDoc.definition.kind) {
-          const value = change.value;
-          facts.label = typeof value?.label === "string" && value.label !== "" ? value.label : undefined;
-          facts.role = typeof value?.role === "string" && value.role !== "" ? value.role : undefined;
-          facts.model = modelRefOf(value?.model);
+          const subagent = value;
+          facts.label = typeof subagent?.label === "string" && subagent.label !== "" ? subagent.label : undefined;
+          facts.role = typeof subagent?.role === "string" && subagent.role !== "" ? subagent.role : undefined;
+          facts.model = modelRefOf(subagent?.model);
+          facts.name = typeof subagent?.name === "string" && subagent.name !== "" ? subagent.name : undefined;
+          facts.lifecycle = subagent?.lifecycle === "background" ? "background" : "foreground";
           touched.add(id);
         } else if (change.record.kind === TitleDoc.definition.kind) {
-          const named = change.value?.title;
+          const named = value?.title;
           facts.named = typeof named === "string" && named !== "" ? named : undefined;
           touched.add(id);
         }
@@ -4463,9 +5722,51 @@ class ConversationList {
         listener(this.#list);
     });
   }
+  #followLive(id, running) {
+    if (!running || this.#disposed) {
+      const watch = this.#live.get(id);
+      this.#live.delete(id);
+      watch?.stop();
+      return;
+    }
+    if (this.#live.has(id))
+      return;
+    this.#live.set(id, undefined);
+    setImmediate(() => {
+      this.#harness.watchDoc(LiveDoc, id, context3).then(async (watch) => {
+        if (watch === undefined)
+          return;
+        if (this.#live.get(id) !== undefined || !this.#live.has(id)) {
+          await watch.stop();
+          return;
+        }
+        this.#live.set(id, watch);
+        const apply = (live) => {
+          const facts = this.#fact(id);
+          if (live.run === undefined)
+            return;
+          facts.tools = live.tools;
+          this.#refreshSummaries(new Set([id]));
+        };
+        apply(watch.value);
+        watch.start(async (call) => {
+          if (call.kind === "value")
+            apply(call.value);
+        });
+      }, (error) => {
+        if (this.#live.get(id) === undefined)
+          this.#live.delete(id);
+        console.error(`conversation ${id}: could not follow pi.live: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    });
+  }
   dispose() {
+    this.#disposed = true;
     this.#unsubscribe();
     this.#listeners.clear();
+    for (const watch of this.#live.values())
+      watch?.stop();
+    this.#live.clear();
   }
 }
 function roleNameOf(value) {
@@ -4511,7 +5812,8 @@ function summaryOf(record, facts, role, currentAgent) {
   return {
     id: record.id,
     kind: record.owner !== undefined ? "subagent" : record.parent !== undefined ? "fork" : "conversation",
-    ...record.owner === undefined ? {} : { lifecycle: "foreground" },
+    ...record.owner === undefined ? {} : { lifecycle: facts.lifecycle ?? "foreground" },
+    ...facts.name === undefined ? {} : { name: facts.name },
     ...facts.model === undefined ? {} : { model: facts.model },
     ...parent === undefined ? {} : { parent },
     ...record.parent === undefined ? {} : { forkedAt: String(record.parent.at) },
@@ -4525,15 +5827,47 @@ function summaryOf(record, facts, role, currentAgent) {
   };
 }
 function sameSummary(a, b) {
-  return a.id === b.id && a.kind === b.kind && a.lifecycle === b.lifecycle && a.model?.provider === b.model?.provider && a.model?.modelId === b.model?.modelId && a.parent === b.parent && a.forkedAt === b.forkedAt && a.title === b.title && a.status === b.status && a.updatedAt === b.updatedAt && a.label === b.label && a.role === b.role && a.currentAgent === b.currentAgent && a.activity?.tool === b.activity?.tool && a.activity?.target === b.activity?.target;
+  return a.id === b.id && a.kind === b.kind && a.lifecycle === b.lifecycle && a.name === b.name && a.model?.provider === b.model?.provider && a.model?.modelId === b.model?.modelId && a.parent === b.parent && a.forkedAt === b.forkedAt && a.title === b.title && a.status === b.status && a.updatedAt === b.updatedAt && a.label === b.label && a.role === b.role && a.currentAgent === b.currentAgent && a.activity?.tool === b.activity?.tool && a.activity?.target === b.activity?.target;
 }
 function titleOf(entry) {
-  const message = entry?.model?.[0];
-  if (message?.role !== "user")
+  const message2 = entry?.model?.[0];
+  if (message2?.role !== "user")
     return {};
-  const title = stripUserBlocks(message.content).text.replace(/\s+/g, " ").trim();
+  const title = stripUserBlocks(message2.content).text.replace(/\s+/g, " ").trim();
   return title === "" ? {} : { title };
 }
+var WHOLE_TRANSCRIPT = { min: Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER };
+var TURN_STARTS = new Set(["pi.user", "pi.compaction", "pi.reset"]);
+async function turnPage(conversation, before, limit) {
+  const want = Math.min(limit, MAX_TRANSCRIPT_PAGE);
+  const done = (taken2) => taken2.length >= MAX_TRANSCRIPT_PAGE || taken2.length >= want && TURN_STARTS.has(taken2.at(-1).kind);
+  const query = { order: "descending", ...before === undefined ? {} : { maxEntryId: before } };
+  const taken = [];
+  let cursor;
+  for (;; ) {
+    const page = await conversation.entries(query, Math.max(want + 1 - taken.length, 64), cursor, context3);
+    for (const entry of page.items) {
+      if (done(taken))
+        return { entries: taken.reverse(), before: entry.id };
+      taken.push(entry);
+    }
+    if (page.next === undefined)
+      return { entries: taken.reverse() };
+    cursor = page.next;
+  }
+}
+async function viewWindow(conversation, window) {
+  if (window === undefined)
+    return WHOLE_TRANSCRIPT;
+  const from = window.from ?? await startOf(conversation, window.limit);
+  return from === undefined ? WHOLE_TRANSCRIPT : { ...WHOLE_TRANSCRIPT, from };
+}
+async function startOf(conversation, limit) {
+  const page = await turnPage(conversation, undefined, limit);
+  return page.before === undefined ? undefined : page.entries[0].id;
+}
+var shownOps = (call) => isGone(call) ? [["r", null]] : call.ops;
+var isGone = (call) => call.retired && !call.ops.some((op) => op[0] === "r");
 async function historyFacts(harness, id) {
   const conversation = await harness.conversation(id, context3);
   let first;
@@ -4545,21 +5879,21 @@ async function historyFacts(harness, id) {
     newest ??= page.items.find((entry) => entry.conversationId === id && (entry.kind === "pi.user" || entry.kind === "pi.assistant"));
     cursor = page.next;
   } while (cursor !== undefined);
-  const message = newest?.model?.[0];
+  const message2 = newest?.model?.[0];
   return {
     ...titleOf(first),
     ...newest === undefined ? {} : {
       newest: newest.id,
-      ...typeof message?.timestamp === "number" ? { updatedAt: message.timestamp } : {},
-      failed: newest.kind === "pi.assistant" && message?.role === "assistant" && message.stopReason === "error",
-      ...newest.kind === "pi.assistant" ? { calls: callsOf(message) } : {}
+      ...typeof message2?.timestamp === "number" ? { updatedAt: message2.timestamp } : {},
+      failed: newest.kind === "pi.assistant" && message2?.role === "assistant" && message2.stopReason === "error",
+      ...newest.kind === "pi.assistant" ? { calls: callsOf(message2) } : {}
     }
   };
 }
-function callsOf(message) {
-  if (message?.role !== "assistant")
+function callsOf(message2) {
+  if (message2?.role !== "assistant")
     return;
-  const content = message.content;
+  const content = message2.content;
   if (!Array.isArray(content))
     return;
   const calls = new Map;
@@ -4666,6 +6000,12 @@ class GatewayClient {
       throw new Error("Provider setup is not available on this host");
     return modelAuth;
   }
+  #upgrades() {
+    const upgrade = this.#options.upgrade;
+    if (upgrade === undefined)
+      throw new Error("This host can't upgrade itself (source)");
+    return upgrade;
+  }
   #hostValues;
   #subscriptions = new Map;
   #terminalSizes = new Map;
@@ -4683,7 +6023,8 @@ class GatewayClient {
       auth: options.modelAuth?.auth ?? constantValue({ logins: [] }),
       providers: options.modelAuth?.providers ?? constantValue({ providers: [], logins: [] }),
       settings: options.settings,
-      agents: options.agents ?? constantValue({ roles: [], problems: [] })
+      agents: options.agents ?? constantValue({ roles: [], problems: [] }),
+      upgrade: options.upgrade ?? NO_UPGRADES
     };
     this.#hooks = hooks;
     this.devicePublicKey = hooks.devicePublicKey;
@@ -4732,7 +6073,8 @@ class GatewayClient {
       toolPresentations: options.toolPresentations ?? {},
       endpointSet: this.#hooks.endpointSet(),
       ...rtc === undefined ? {} : { rtc },
-      ...this.#hooks.terminals === undefined ? {} : { terminals: { limit: this.#hooks.terminals.limit } }
+      ...this.#hooks.terminals === undefined ? {} : { terminals: { limit: this.#hooks.terminals.limit } },
+      ...this.#hooks.processes === undefined ? {} : { processes: this.#hooks.processes.hello }
     });
   }
   send(frame) {
@@ -4745,15 +6087,19 @@ class GatewayClient {
   }
   async#receive(frame) {
     if (frame.type === "subscribe")
-      await this.#subscribe(frame.stream, frame.images === "ref", frame.since);
+      await this.#subscribe(frame.stream, frame.images === "ref", frame.since, frame.window);
     else if (frame.type === "unsubscribe")
       await this.#unsubscribe(frame.stream);
     else
       await this.#answer(frame.id, frame.method, frame.args);
   }
-  async#subscribe(stream, imageRefs, since) {
+  async#subscribe(stream, imageRefs, since, window) {
     const previous = this.#subscriptions.get(stream);
-    const state = imageRefs && stream.startsWith("conversation:") ? { images: new ImageRefs } : since === undefined ? {} : { since };
+    const state = {
+      ...imageRefs && stream.startsWith("conversation:") ? { images: new ImageRefs } : {},
+      ...since === undefined ? {} : { since },
+      ...window === undefined ? {} : { window }
+    };
     this.#subscriptions.set(stream, state);
     const current = () => !this.#disposed && this.#subscriptions.get(stream) === state;
     const send = (frame) => current() ? this.send(frame) : Promise.resolve();
@@ -4815,12 +6161,24 @@ class GatewayClient {
       });
       return { stop: detach };
     }
+    if (stream.startsWith("process:")) {
+      const processStream = stream;
+      const detach = this.#processes().attach(processStream.slice("process:".length), state?.since, {
+        output: (frame) => send({ type: "output", stream: processStream, ...frame }),
+        ended: (reason) => {
+          send({ type: "ended", stream, reason });
+          if (this.#subscriptions.get(stream) === state)
+            this.#subscriptions.delete(stream);
+        }
+      });
+      return { stop: detach };
+    }
     if (stream.startsWith("doc:")) {
       const at = stream.lastIndexOf(":");
       return this.#openDoc(stream, stream.slice("doc:".length, at), Number(stream.slice(at + 1)), send);
     }
     const conversation = await this.#conversation(Number(stream.slice("conversation:".length)));
-    return this.#forward(stream, await conversation.watch(context3), send, state);
+    return this.#forward(stream, await conversation.watch(context3, await viewWindow(conversation, state?.window)), send, state);
   }
   #hostValue(stream) {
     return Object.hasOwn(this.#hostValues, stream) ? this.#hostValues[stream] : undefined;
@@ -4838,13 +6196,17 @@ class GatewayClient {
     });
     let inner;
     let stopped = false;
-    const unsubscribe = harness.subscribeCommits((publication) => {
-      const matches = publication.changes.some((change) => (change.type === "document" || change.type === "document.copy") && change.record.kind === kind && change.conversationId === id);
-      if (!matches)
-        return;
-      unsubscribe();
-      setImmediate(() => signalCreation());
+    const observation = harness.observeCommits({
+      advance: (publication) => {
+        const matches = publication.changes.some((change) => (change.type === "document" || change.type === "document.copy") && change.record.kind === kind && change.conversationId === id);
+        if (!matches)
+          return;
+        unsubscribe();
+        setImmediate(() => signalCreation());
+      },
+      end: () => {}
     });
+    const unsubscribe = () => observation.detach();
     try {
       const existing = await harness.watchDoc(token, id, context3);
       if (existing !== undefined) {
@@ -4885,16 +6247,19 @@ class GatewayClient {
   async#forward(stream, watch, send, state) {
     if (state?.images === undefined) {
       await send({ type: "snapshot", stream, value: watch.value });
-      watch.start((_value, ops) => send({ type: "ops", stream, ops }));
+      watch.start((call) => call.kind === "value" ? send({ type: "ops", stream, ops: shownOps(call) }) : Promise.resolve());
       return watch;
     }
     const images = state.images;
     let before = watch.value;
     state.view = before;
     await send({ type: "snapshot", stream, value: await images.value(before) });
-    watch.start(async (value, ops) => {
+    watch.start(async (call) => {
+      if (call.kind !== "value")
+        return;
+      const ops = shownOps(call);
       const sent = await images.ops(ops, before);
-      before = value;
+      before = isGone(call) ? null : call.value;
       state.view = before;
       return send({ type: "ops", stream, ops: sent });
     });
@@ -4904,7 +6269,7 @@ class GatewayClient {
     for (const state of this.#subscriptions.values()) {
       if (state.images === undefined || state.view === undefined)
         continue;
-      const image = state.images.image(state.view, ref);
+      const image = state.images.image(state.view, ref) ?? (state.earlier === undefined ? undefined : state.images.image({ entries: state.earlier }, ref));
       if (image !== undefined)
         return image;
     }
@@ -4953,8 +6318,11 @@ class GatewayClient {
   #submissionByRequest(conversationId, requestId) {
     return this.#options.harness.commit((tx) => tx.submissionByRequest(conversationId, requestId), context3);
   }
-  async#compact(conversation, instructions) {
-    const taskId = await conversation.compact(instructions, context3);
+  async#isSubagent(id) {
+    return await this.#options.harness.commit(async (tx) => (await tx.conversation(id))?.owner !== undefined, context3);
+  }
+  async#compact(conversation, instructions2) {
+    const taskId = await conversation.compact(instructions2, context3);
     this.#options.harness.waitForTask(taskId, context3).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
     return taskId;
   }
@@ -4972,6 +6340,17 @@ class GatewayClient {
     }
   }
   async#call(method, args) {
+    if (AGENT_WORK_CALLS.has(method) && this.#options.upgrade !== undefined) {
+      const release2 = this.#options.upgrade.admit();
+      try {
+        return await this.#dispatch(method, args);
+      } finally {
+        release2();
+      }
+    }
+    return this.#dispatch(method, args);
+  }
+  async#dispatch(method, args) {
     switch (method) {
       case "terminalInput": {
         const input = args;
@@ -5001,6 +6380,11 @@ class GatewayClient {
         this.#terminals().close(args.terminalId);
         this.#terminalSizes.delete(args.terminalId);
         return null;
+      case "stopProcess": {
+        const input = args;
+        const process2 = await this.#processes().stop({ conversationId: input.conversationId, id: input.id, reason: "user" }, context3);
+        return { state: process2.state };
+      }
       case "addProject":
         return addProject(this.#options.harness, args.path, context3);
       case "removeProject":
@@ -5013,6 +6397,9 @@ class GatewayClient {
           const existing = await this.#submissionByRequest(input.conversationId, input.requestId);
           if (existing !== undefined)
             return submitResult(existing);
+          if (await this.#isSubagent(input.conversationId)) {
+            throw new Error("Subagents take no messages from the user: tell the conversation that dispatched it");
+          }
           const resolved = images();
           const conversation2 = await this.#conversation(input.conversationId);
           const attachments = await this.#attachmentText(input.attachments);
@@ -5062,13 +6449,27 @@ class GatewayClient {
       }
       case "archive": {
         const input = args;
-        await archive(this.#options.harness, input.conversationId, input.archived, context3);
-        if (input.archived) {
-          this.#hooks.terminals?.closeOwners(await conversationSubtree(this.#options.harness, input.conversationId, context3));
-          const kept = await cleanupArchivedWorktrees(this.#options.harness, input.conversationId, context3);
-          for (const { record, reason } of kept) {
-            await this.send({ type: "notice", level: "warning", message: `Kept worktree ${record.path} (branch ${record.branch}): ${reason}` });
-          }
+        if (!input.archived) {
+          await archive(this.#options.harness, input.conversationId, false, context3);
+          this.#hooks.processes?.unseal(await conversationSubtree(this.#options.harness, input.conversationId, context3));
+          return null;
+        }
+        const subtree = await conversationSubtree(this.#options.harness, input.conversationId, context3);
+        this.#hooks.processes?.seal(subtree);
+        try {
+          await archive(this.#options.harness, input.conversationId, true, context3);
+        } catch (error) {
+          this.#hooks.processes?.unseal(subtree);
+          throw error;
+        }
+        for (const id of subtree) {
+          await (await this.#options.harness.conversation(id, context3))?.abort(context3, { background: true });
+        }
+        await this.#hooks.processes?.closeOwners(subtree, "archive", context3);
+        this.#hooks.terminals?.closeOwners(subtree);
+        const kept = await cleanupArchivedWorktrees(this.#options.harness, input.conversationId, context3);
+        for (const { record, reason } of kept) {
+          await this.send({ type: "notice", level: "warning", message: `Kept worktree ${record.path} (branch ${record.branch}): ${reason}` });
         }
         return null;
       }
@@ -5137,6 +6538,15 @@ class GatewayClient {
         await this.#options.settings.update(args.patch);
         return null;
       }
+      case "startUpgrade":
+        await this.#upgrades().start(args.when);
+        return null;
+      case "cancelUpgrade":
+        this.#upgrades().cancel();
+        return null;
+      case "checkUpgrade":
+        await this.#upgrades().check();
+        return null;
       case "createAgent": {
         const store = this.#options.agents;
         if (store === undefined)
@@ -5168,6 +6578,26 @@ class GatewayClient {
         const input = args;
         return listSkills(this.#options.harness, this.#skills, input.scope, context3);
       }
+      case "earlierEntries": {
+        const { conversationId, before, limit } = args;
+        const stream = `conversation:${conversationId}`;
+        const state = this.#subscriptions.get(stream);
+        if (state === undefined)
+          throw new Error(`Not subscribed to conversation ${conversationId}`);
+        const replaced = () => this.#subscriptions.get(stream) !== state;
+        const resubscribed = () => new Error(`Conversation ${conversationId} was resubscribed while its page loaded`);
+        const page = await turnPage(await this.#conversation(conversationId), before, limit);
+        if (replaced())
+          throw resubscribed();
+        if (state.images === undefined)
+          return page;
+        const raw = page.entries;
+        const { entries } = await state.images.value({ entries: raw });
+        if (replaced())
+          throw resubscribed();
+        state.earlier = [...state.earlier ?? [], ...raw];
+        return { ...page, entries };
+      }
       case "image": {
         const input = args;
         const image = this.#shownImage(input.ref);
@@ -5229,6 +6659,37 @@ class GatewayClient {
           return { outcome: "steered" };
         }, context3);
       }
+      case "reorderQueued": {
+        const { conversationId, submissionId, before } = args;
+        return await this.#options.harness.commit(async (tx) => {
+          const queuedState = async (id) => {
+            const record = await tx.submission(id);
+            if (record === undefined)
+              throw new Error(`Submission ${id} does not exist`);
+            assertQueuedInput(record, conversationId);
+            if (record.entry !== undefined)
+              return "sent";
+            return record.status === "queued" ? "queued" : "unavailable";
+          };
+          const moved = await queuedState(submissionId);
+          if (moved !== "queued")
+            return { outcome: moved };
+          if (before !== undefined && await queuedState(before) !== "queued") {
+            return { outcome: "unavailable" };
+          }
+          if (before === submissionId)
+            return { outcome: "moved" };
+          const items = (await tx.doc(InboxDoc, conversationId)).items;
+          const from = items.findIndex((candidate) => candidate.id === submissionId);
+          if (from < 0 || before !== undefined && !items.some((candidate) => candidate.id === before)) {
+            return { outcome: "unavailable" };
+          }
+          const [item] = items.splice(from, 1);
+          const to = before === undefined ? items.findLastIndex((candidate) => candidate.mode !== "write") + 1 : items.findIndex((candidate) => candidate.id === before);
+          items.splice(to, 0, item);
+          return { outcome: "moved" };
+        }, context3);
+      }
       case "renameConversation": {
         const { title } = args;
         const trimmed = title.trim();
@@ -5250,17 +6711,20 @@ class GatewayClient {
         return null;
       }
       case "abort":
+        if (await this.#isSubagent(conversation.id)) {
+          await this.#options.harness.commit((tx) => markStop(tx, conversation.id, "user"), context3);
+        }
         await conversation.abort(context3);
         return null;
       case "compact": {
-        const { instructions } = args;
-        return { taskId: await this.#compact(conversation, instructions) };
+        const { instructions: instructions2 } = args;
+        return { taskId: await this.#compact(conversation, instructions2) };
       }
       case "listCommands":
         return listCommands();
       case "runCommand": {
         const { name, args: input } = args;
-        await runCommand({ compact: (instructions) => this.#compact(conversation, instructions) }, name, input);
+        await runCommand({ compact: (instructions2) => this.#compact(conversation, instructions2) }, name, input);
         return null;
       }
       case "setModel": {
@@ -5336,7 +6800,7 @@ class GatewayClient {
         const token = doc.token;
         return await this.#options.harness.commit(async (tx) => {
           const value = await tx.doc(token, conversation.id);
-          if (!Value2.Check(QuestionSchema, value))
+          if (!Value.Check(QuestionSchema, value))
             throw new Error(`Document ${kind} does not hold question requests`);
           const request = value.requests.find((candidate) => candidate.id === requestId);
           if (request === undefined)
@@ -5385,6 +6849,11 @@ class GatewayClient {
       throw new Error("Terminals are unavailable on this host");
     return this.#hooks.terminals;
   }
+  #processes() {
+    if (this.#hooks.processes === undefined)
+      throw new Error("Background processes are unavailable on this host");
+    return this.#hooks.processes;
+  }
   async#terminalOwner(conversation) {
     const cwd = (await conversation.agent(context3)).cwd;
     if (cwd === undefined)
@@ -5424,7 +6893,7 @@ class GatewayClient {
   async#dismissPendingQuestions(conversationId, context4) {
     const questionDocs = this.#questionDocs();
     const snapshots = await Promise.all(questionDocs.map((doc) => this.#options.harness.snapshot(doc.token, conversationId, context4)));
-    const pending = snapshots.some((value) => Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined));
+    const pending = snapshots.some((value) => Value.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined));
     if (!pending)
       return false;
     return await this.#options.harness.commit((tx) => dismissPendingQuestions(tx, questionDocs, conversationId), context4);
@@ -5433,7 +6902,7 @@ class GatewayClient {
     return (this.#options.docs ?? []).filter((doc) => doc.presentation === "pinomad.question");
   }
   get #chatsPrefix() {
-    return join7(this.#options.dataDir, "chats") + sep5;
+    return join8(this.#options.dataDir, "chats") + sep6;
   }
   async#changes(conversation, context4) {
     const cwd = (await conversation.agent(context4)).cwd;
@@ -5468,8 +6937,8 @@ class GatewayClient {
 // apps/host/src/host.ts
 import { randomBytes as randomBytes4 } from "node:crypto";
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename3, join as join10, sep as sep6 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
+import { basename as basename3, join as join11, sep as sep7 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT6 } from "@earendil-works/chord/context";
 import { createRegistry, Harness } from "@earendil-works/pi-durable";
 import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
 
@@ -5485,10 +6954,10 @@ import {
   StreamableHttpTransport,
   toLlmContent
 } from "@earendil-works/pi-mcp";
-import { defineExtension as defineExtension5, defineTool as defineTool4 } from "@earendil-works/pi-durable";
+import { defineExtension as defineExtension7, defineTool as defineTool5 } from "@earendil-works/pi-durable";
 import { Type as Type5 } from "typebox";
 var ENV_VAR = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
-var isObject2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isObject3 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 function expand(value) {
   let missing;
   const expanded = value.replace(ENV_VAR, (_all, name) => {
@@ -5502,7 +6971,7 @@ function expand(value) {
 function expandAll(values, field, error) {
   if (values === undefined)
     return;
-  if (!isObject2(values)) {
+  if (!isObject3(values)) {
     error(`"${field}" must be an object of strings`);
     return;
   }
@@ -5512,21 +6981,21 @@ function expandAll(values, field, error) {
       error(`"${field}.${key}" must be a string`);
       return;
     }
-    const result2 = expand(value);
-    if (typeof result2 !== "string") {
-      error(`"${field}.${key}" references unset environment variable ${result2.missing}`);
+    const result3 = expand(value);
+    if (typeof result3 !== "string") {
+      error(`"${field}.${key}" references unset environment variable ${result3.missing}`);
       return;
     }
-    expanded[key] = result2;
+    expanded[key] = result3;
   }
   return expanded;
 }
 function parseServer(name, raw, error) {
-  const fail = (message) => {
-    error(`${name}: ${message}`);
+  const fail = (message2) => {
+    error(`${name}: ${message2}`);
     return;
   };
-  if (!isObject2(raw))
+  if (!isObject3(raw))
     return fail("server entry must be an object");
   if (raw.enabled === false)
     return { name, disabled: true };
@@ -5548,7 +7017,7 @@ function parseServer(name, raw, error) {
     }
     if (raw.cwd !== undefined && typeof raw.cwd !== "string")
       return fail(`"cwd" must be a string`);
-    const env = expandAll(raw.env, "env", (message) => error(`${name}: ${message}`));
+    const env = expandAll(raw.env, "env", (message2) => error(`${name}: ${message2}`));
     if (raw.env !== undefined && env === undefined)
       return;
     const cwd = raw.cwd === undefined ? homedir2() : isAbsolute2(raw.cwd) ? raw.cwd : resolve5(homedir2(), raw.cwd);
@@ -5563,7 +7032,7 @@ function parseServer(name, raw, error) {
   if (raw.url !== undefined || raw.type === "http" || raw.type === "sse") {
     if (typeof raw.url !== "string" || raw.url === "")
       return fail(`HTTP server needs a "url"`);
-    const headers = expandAll(raw.headers, "headers", (message) => error(`${name}: ${message}`));
+    const headers = expandAll(raw.headers, "headers", (message2) => error(`${name}: ${message2}`));
     if (raw.headers !== undefined && headers === undefined)
       return;
     return {
@@ -5585,13 +7054,13 @@ async function loadConfig(configPath) {
       return { errors: [], entries: [] };
     return { errors: [`${configPath}: ${error instanceof Error ? error.message : String(error)}`], entries: [] };
   }
-  if (!isObject2(parsed) || parsed.mcpServers !== undefined && !isObject2(parsed.mcpServers)) {
+  if (!isObject3(parsed) || parsed.mcpServers !== undefined && !isObject3(parsed.mcpServers)) {
     return { errors: [`${configPath}: "mcpServers" must be an object`], entries: [] };
   }
   const errors = [];
   const entries = [];
   for (const [name, raw] of Object.entries(parsed.mcpServers ?? {})) {
-    const entry = parseServer(name, raw, (message) => errors.push(message));
+    const entry = parseServer(name, raw, (message2) => errors.push(message2));
     if (entry !== undefined)
       entries.push(entry);
   }
@@ -5609,7 +7078,7 @@ var callToolResultSchema = (tool) => ({
   required: ["content"]
 });
 function mcpTool(client, timeoutMs, exposure, name, tool) {
-  return defineTool4({
+  return defineTool5({
     name,
     description: tool.description ?? tool.title ?? tool.name,
     parameters: Type5.Unsafe({
@@ -5620,11 +7089,11 @@ function mcpTool(client, timeoutMs, exposure, name, tool) {
     ...exposure === "direct" ? {} : { callers: ["tools"] },
     structuredOutputSchema: Type5.Unsafe(callToolResultSchema(tool)),
     execute: async (args, _api, context4) => {
-      const result2 = await client.callTool(tool.name, args, {
+      const result3 = await client.callTool(tool.name, args, {
         signal: context4.abortSignal ?? NEVER_ABORT,
         timeoutMs
       });
-      return { output: toLlmContent(result2), structuredOutput: result2, isError: result2.isError === true };
+      return { output: toLlmContent(result3), structuredOutput: result3, isError: result3.isError === true };
     }
   });
 }
@@ -5644,7 +7113,7 @@ function startMcp(options) {
       listener(value);
   };
   const install = () => {
-    options.registry.install(defineExtension5({ name: "mcp", tools: [...toolsets.values()].flat() }));
+    options.registry.install(defineExtension7({ name: "mcp", tools: [...toolsets.values()].flat() }));
     options.onNamespaces?.([...namespaces.values()]);
   };
   const set = (name, patch) => {
@@ -5764,7 +7233,7 @@ ${stderr}`;
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync2, watch } from "node:fs";
 import { mkdir as mkdir2, readdir as readdir2, readFile as readFile3, rename, rm as rm2, writeFile } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
 
 // packages/protocol/src/agents.ts
@@ -5808,7 +7277,7 @@ async function load(dir) {
     const problem = (reason2) => void problems.push({ file, reason: reason2 });
     let parsed;
     try {
-      parsed = parseFrontmatter(await readFile3(join8(dir, file), "utf8"));
+      parsed = parseFrontmatter(await readFile3(join9(dir, file), "utf8"));
     } catch (error) {
       problem(`Couldn't parse the file: ${error instanceof Error ? error.message : String(error)}`);
       continue;
@@ -5920,13 +7389,13 @@ async function openAgentRoles(options) {
     if (problem !== undefined)
       throw new Error(problem);
     await enqueue(async () => {
-      const target = join8(dir, `${role.name}.md`);
+      const target = join9(dir, `${role.name}.md`);
       const exists = existsSync2(target);
       if (mustExist && !exists)
         throw new Error(`No such agent: "${role.name}"`);
       if (!mustExist && exists)
         throw new Error(`Agent "${role.name}" already exists`);
-      const temp = join8(dir, `.${role.name}.${randomBytes2(6).toString("hex")}.tmp`);
+      const temp = join9(dir, `.${role.name}.${randomBytes2(6).toString("hex")}.tmp`);
       try {
         await writeFile(temp, serialize(role));
         await rename(temp, target);
@@ -5949,7 +7418,7 @@ async function openAgentRoles(options) {
       if (problem !== undefined)
         throw new Error(problem);
       await enqueue(async () => {
-        const target = join8(dir, `${name}.md`);
+        const target = join9(dir, `${name}.md`);
         if (!existsSync2(target))
           throw new Error(`No such agent: "${name}"`);
         await rm2(target);
@@ -5983,7 +7452,7 @@ import {
   stat as stat7,
   writeFile as writeFile2
 } from "node:fs/promises";
-import { basename as basename2, join as join9, resolve as resolve6 } from "node:path";
+import { basename as basename2, join as join10, resolve as resolve6 } from "node:path";
 var META = "meta.json";
 var DATA = "file";
 var CLEANUP_INTERVAL_MS = 6 * 60 * 60 * 1000;
@@ -6078,16 +7547,16 @@ class AttachmentStore {
     return next;
   }
   #directory(id) {
-    return join9(this.#root, id);
+    return join10(this.#root, id);
   }
   #dataPath(meta) {
-    return join9(this.#directory(meta.id), DATA, meta.fileName);
+    return join10(this.#directory(meta.id), DATA, meta.fileName);
   }
   async#readMeta(id) {
     if (!isAttachmentId(id))
       return;
     try {
-      return metaOf(JSON.parse(await readFile4(join9(this.#directory(id), META), "utf8")), id);
+      return metaOf(JSON.parse(await readFile4(join10(this.#directory(id), META), "utf8")), id);
     } catch {
       return;
     }
@@ -6095,10 +7564,10 @@ class AttachmentStore {
   async#writeMeta(meta) {
     const { id, ...value } = meta;
     const directory = this.#directory(id);
-    const temporary = join9(directory, `.meta.${randomBytes3(6).toString("hex")}.tmp`);
+    const temporary = join10(directory, `.meta.${randomBytes3(6).toString("hex")}.tmp`);
     await writeFile2(temporary, `${JSON.stringify(value)}
 `, { mode: 384 });
-    await rename2(temporary, join9(directory, META));
+    await rename2(temporary, join10(directory, META));
   }
   async#rebuildPending() {
     this.#pending.clear();
@@ -6143,7 +7612,7 @@ class AttachmentStore {
         expiresAt: this.#now() + this.#ttlMs
       };
       try {
-        await mkdir3(join9(directory, DATA), { recursive: true });
+        await mkdir3(join10(directory, DATA), { recursive: true });
         await writeFile2(this.#dataPath(meta), new Uint8Array(0), { mode: 384 });
         if (size === 0)
           await chmod(this.#dataPath(meta), 292);
@@ -6279,16 +7748,16 @@ class AttachmentStore {
 }
 
 // apps/host/src/answer-timing.ts
-function withAnswerStart(message, answerStartedAt) {
-  const pinomad = message.pinomad;
-  return { ...message, pinomad: { ...pinomad, answerStartedAt } };
+function withAnswerStart(message2, answerStartedAt) {
+  const pinomad = message2.pinomad;
+  return { ...message2, pinomad: { ...pinomad, answerStartedAt } };
 }
 function stripPinomad(context4) {
   let changed = false;
-  const messages = context4.messages.map((message) => {
-    if (message.role !== "assistant" || !("pinomad" in message))
-      return message;
-    const { pinomad: _pinomad, ...rest } = message;
+  const messages = context4.messages.map((message2) => {
+    if (message2.role !== "assistant" || !("pinomad" in message2))
+      return message2;
+    const { pinomad: _pinomad, ...rest } = message2;
     changed = true;
     return rest;
   });
@@ -6313,7 +7782,7 @@ function trackAnswerStart(stream) {
   const push = stream.push.bind(stream);
   stream.push = (event) => push(annotate(event));
   const end = stream.end.bind(stream);
-  stream.end = (result2) => end(result2 === undefined || answerStartedAt === undefined ? result2 : withAnswerStart(result2, answerStartedAt));
+  stream.end = (result3) => end(result3 === undefined || answerStartedAt === undefined ? result3 : withAnswerStart(result3, answerStartedAt));
   return stream;
 }
 function withAnswerTiming(models) {
@@ -6328,10 +7797,594 @@ function withAnswerTiming(models) {
   });
 }
 
+// apps/host/src/processes.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT5 } from "@earendil-works/chord/context";
+var PROCESS_LIMIT = 8;
+var ENDED_PROCESS_LIMIT = 20;
+var ENDED_OUTPUT_BUDGET = 64 * 1024 * 1024;
+var STOP_GRACE_MS = 5000;
+var GROUP_WAIT_MS = 2000;
+var OUTPUT_CHUNK = 16 * 1024;
+var REPORT_LIMIT = 4 * 1024;
+var REPORT_LINES = 40;
+var REPORT_TAIL = `
+
+Last output:
+`;
+
+class Processes {
+  #options;
+  #limit;
+  #endedLimit;
+  #outputBudget;
+  #processes = new Map;
+  #roots = new Map;
+  #sealed = new Set;
+  #busy;
+  #closing = false;
+  constructor(options) {
+    this.#options = options;
+    this.#limit = options.limit ?? PROCESS_LIMIT;
+    this.#endedLimit = options.endedLimit ?? ENDED_PROCESS_LIMIT;
+    this.#outputBudget = options.outputBudget ?? ENDED_OUTPUT_BUDGET;
+    this.#busy = new Published(false, (a, b) => a === b);
+  }
+  get limit() {
+    return this.#limit;
+  }
+  get hello() {
+    return { limit: this.#limit };
+  }
+  get busy() {
+    return this.#busy;
+  }
+  async open(context4) {
+    await settleLostProcesses(this.#options.harness(), context4);
+  }
+  async start(input, context4) {
+    const harness = this.#options.harness();
+    const root = await this.#root(input.conversationId);
+    if (this.#closing)
+      throw new Error("The host is shutting down");
+    if (this.#options.installing?.() === true)
+      throw new Error("An upgrade is installing; try again after it finishes");
+    if (this.#sealed.has(input.conversationId) || await this.#archivedInFamily(harness, input.conversationId, context4)) {
+      throw new Error("This conversation is archived");
+    }
+    if (this.#closing)
+      throw new Error("The host is shutting down");
+    if (this.#options.installing?.() === true)
+      throw new Error("An upgrade is installing; try again after it finishes");
+    if (this.#sealed.has(input.conversationId))
+      throw new Error("This conversation is archived");
+    const existing = input.id === undefined ? undefined : this.#processes.get(input.id);
+    if (existing !== undefined) {
+      if (!isProcessActive(existing.info.state))
+        throw new Error(`Process ${existing.info.id} has already ended`);
+      return info2(existing);
+    }
+    const active = [...this.#processes.values()].filter((entry2) => entry2.root === root && isProcessActive(entry2.info.state)).length;
+    if (active >= this.#limit)
+      throw new Error(`Process limit reached (${this.#limit})`);
+    const id = input.id ?? randomUUID4();
+    let resolveDone;
+    const done = new Promise((resolve7) => {
+      resolveDone = resolve7;
+    });
+    const entry = {
+      info: {
+        id,
+        owner: input.conversationId,
+        name: input.name,
+        command: input.command,
+        startedAt: this.#now(),
+        state: "starting"
+      },
+      root,
+      output: new OutputBuffer({
+        ...this.#options.bufferSize === undefined ? {} : { bufferSize: this.#options.bufferSize },
+        ...this.#options.flushMs === undefined ? {} : { flushMs: this.#options.flushMs },
+        onFlush: () => this.#options.onOutput?.()
+      }),
+      done,
+      resolveDone,
+      pty: undefined,
+      stopReason: undefined,
+      killTimer: undefined,
+      groupTimer: undefined,
+      killed: false,
+      killedAt: undefined,
+      killWaitTimer: undefined,
+      finishing: false,
+      generation: 0,
+      released: false
+    };
+    this.#processes.set(id, entry);
+    this.#refreshBusy();
+    try {
+      await harness.commit((tx) => this.#applyDoc(tx, entry), context4);
+    } catch (error) {
+      this.#processes.delete(id);
+      this.#refreshBusy();
+      throw error;
+    }
+    try {
+      this.#spawn(entry, input.cwd);
+    } catch (error) {
+      await this.#fail(entry, message2(error), context4);
+      throw error;
+    }
+    await this.#write(entry, context4);
+    return info2(entry);
+  }
+  async output(input, context4) {
+    const root = await this.#root(input.conversationId);
+    const entry = this.#processes.get(input.id);
+    if (entry !== undefined && entry.root === root && !entry.released) {
+      entry.output.flush();
+      const slice = entry.output.snapshot(input.since, OUTPUT_CHUNK);
+      const state = entry.info.state;
+      return {
+        text: stripAnsi(slice.text),
+        next: slice.next,
+        truncated: slice.truncated,
+        status: state,
+        ...typeof state === "object" && "exited" in state ? { exitCode: state.exited } : {}
+      };
+    }
+    const record = await this.#docEntry(root, input.id, context4);
+    if (record === undefined)
+      throw new Error("Unknown process");
+    return {
+      text: "",
+      next: input.since ?? 0,
+      truncated: true,
+      status: record.state,
+      ...typeof record.state === "object" && "exited" in record.state ? { exitCode: record.state.exited } : {},
+      released: true
+    };
+  }
+  async stop(input, context4) {
+    const root = await this.#root(input.conversationId);
+    const entry = this.#processes.get(input.id);
+    if (entry !== undefined && entry.root === root) {
+      return await this.#stopEntry(entry, input.reason ?? "user", context4);
+    }
+    if (entry !== undefined)
+      throw new Error("This process does not belong to the conversation's family");
+    const record = await this.#docEntry(root, input.id, context4);
+    if (record === undefined)
+      throw new Error("Unknown process");
+    return record;
+  }
+  async list(conversationId, context4) {
+    const root = await this.#root(conversationId);
+    const doc = await this.#options.harness().snapshot(ProcessDoc, root, context4);
+    return doc?.processes ?? [];
+  }
+  async#docEntry(root, id, context4) {
+    const doc = await this.#options.harness().snapshot(ProcessDoc, root, context4);
+    return doc?.processes.find((process2) => process2.id === id);
+  }
+  attach(id, since, sink) {
+    const entry = this.#processes.get(id);
+    if (entry === undefined)
+      throw new Error("Unknown process");
+    if (entry.released)
+      throw new Error("The output of this process is no longer available");
+    return entry.output.attach(since, sink);
+  }
+  seal(owners) {
+    for (const owner of owners)
+      this.#sealed.add(owner);
+  }
+  unseal(owners) {
+    for (const owner of owners)
+      this.#sealed.delete(owner);
+  }
+  async closeOwners(owners, reason, context4) {
+    const set = new Set(owners);
+    const entries = [...this.#processes.values()].filter((entry) => set.has(entry.info.owner));
+    await Promise.all(entries.map((entry) => this.#stopEntry(entry, reason, context4)));
+    for (const entry of entries) {
+      this.#release(entry, "Conversation archived");
+      this.#processes.delete(entry.info.id);
+      entry.resolveDone();
+    }
+    this.#refreshBusy();
+  }
+  async drain(context4) {
+    const entries = [...this.#processes.values()].filter((entry) => isProcessActive(entry.info.state));
+    await Promise.all(entries.map((entry) => this.#stopEntry(entry, "shutdown", context4)));
+  }
+  async close(context4) {
+    this.#closing = true;
+    const entries = [...this.#processes.values()];
+    await Promise.all(entries.filter((entry) => isProcessActive(entry.info.state)).map((entry) => this.#stopEntry(entry, "shutdown", context4)));
+    for (const entry of entries) {
+      this.#release(entry, "The host shut down");
+      this.#processes.delete(entry.info.id);
+      entry.resolveDone();
+    }
+    this.#sealed.clear();
+    this.#refreshBusy();
+  }
+  async#archivedInFamily(harness, conversationId, context4) {
+    let current = conversationId;
+    const seen = new Set;
+    while (current !== undefined && !seen.has(current)) {
+      seen.add(current);
+      const index = await harness.snapshot(IndexDoc, context4);
+      if (index?.conversations.some((entry) => entry.id === current && entry.archived === true) === true)
+        return true;
+      const record = await harness.commit((tx) => tx.conversation(current), BACKGROUND_CONTEXT5);
+      current = record?.parent?.conversationId ?? record?.owner?.conversationId;
+    }
+    return false;
+  }
+  async#root(conversationId) {
+    const cached = this.#roots.get(conversationId);
+    if (cached !== undefined)
+      return cached;
+    const root = await familyRoot(this.#options.harness(), conversationId, BACKGROUND_CONTEXT5);
+    this.#roots.set(conversationId, root);
+    return root;
+  }
+  #spawn(entry, cwd) {
+    const generation = ++entry.generation;
+    const { shell, env } = this.#options;
+    const pty = this.#options.spawn(shell.file, [...shell.args, "-c", entry.info.command], {
+      name: "xterm-256color",
+      cols: 120,
+      rows: 40,
+      cwd,
+      env: { ...env, TERM: "xterm-256color", COLORTERM: "truecolor" }
+    });
+    entry.pty = pty;
+    if (pty.pid !== undefined)
+      entry.info.pid = pty.pid;
+    entry.info.state = "running";
+    pty.onData((data) => {
+      if (entry.generation !== generation || entry.released)
+        return;
+      entry.output.push(data);
+    });
+    pty.onExit(({ exitCode, signal }) => {
+      if (entry.generation !== generation || entry.released || !this.#processes.has(entry.info.id))
+        return;
+      this.#exit(entry, exitCode, signal);
+    });
+  }
+  async#exit(entry, exitCode, signal) {
+    entry.pty = undefined;
+    entry.output.flush();
+    if (entry.stopReason === undefined && this.#closing)
+      entry.stopReason = "shutdown";
+    if (entry.stopReason !== undefined) {
+      if (this.#groupAlive(entry)) {
+        this.#ensureKillTimer(entry);
+        this.#pollGroup(entry);
+        return;
+      }
+      await this.#finishStopped(entry);
+      return;
+    }
+    this.#clearStopTimers(entry);
+    entry.info.endedAt = this.#now();
+    entry.info.state = signal === undefined || signal === 0 ? { exited: exitCode } : { exited: null, signal: signalName(signal) };
+    const report = this.#options.installing?.() !== true;
+    try {
+      if (report)
+        await this.#reportAndWrite(entry);
+      else
+        await this.#write(entry, BACKGROUND_CONTEXT5);
+    } catch (error) {
+      this.#diagnose(error);
+    }
+    entry.resolveDone();
+    this.#refreshBusy();
+    this.#evictOutputs();
+  }
+  async#finishStopped(entry) {
+    if (entry.finishing)
+      return;
+    entry.finishing = true;
+    this.#clearStopTimers(entry);
+    entry.info.endedAt = this.#now();
+    entry.info.state = { stopped: entry.stopReason ?? "shutdown" };
+    try {
+      await this.#write(entry, BACKGROUND_CONTEXT5);
+    } catch (error) {
+      this.#diagnose(error);
+    }
+    entry.resolveDone();
+    this.#refreshBusy();
+    this.#evictOutputs();
+  }
+  #ensureKillTimer(entry) {
+    if (entry.killTimer !== undefined || entry.killed)
+      return;
+    const grace = this.#options.stopGraceMs ?? STOP_GRACE_MS;
+    entry.killTimer = setTimeout(() => {
+      entry.killTimer = undefined;
+      entry.killed = true;
+      entry.killedAt = this.#now();
+      this.#signal(entry, "SIGKILL");
+      entry.killWaitTimer ??= setTimeout(() => this.#finishAfterKillWait(entry), this.#options.groupWaitMs ?? GROUP_WAIT_MS);
+    }, grace);
+  }
+  #pollGroup(entry) {
+    if (entry.groupTimer !== undefined || entry.finishing)
+      return;
+    const check = () => {
+      entry.groupTimer = undefined;
+      if (entry.finishing || entry.released || !this.#processes.has(entry.info.id))
+        return;
+      if (!this.#groupAlive(entry)) {
+        this.#finishStopped(entry);
+        return;
+      }
+      const wait = this.#options.groupWaitMs ?? GROUP_WAIT_MS;
+      if (entry.killedAt !== undefined && this.#now() - entry.killedAt >= wait) {
+        this.#finishAfterKillWait(entry);
+        return;
+      }
+      entry.groupTimer = setTimeout(check, 25);
+    };
+    check();
+  }
+  #finishAfterKillWait(entry) {
+    entry.killWaitTimer = undefined;
+    if (entry.finishing || entry.released || !this.#processes.has(entry.info.id))
+      return;
+    if (this.#groupAlive(entry)) {
+      this.#diagnose(`Process group ${entry.info.pid ?? "unknown"} still appears alive after SIGKILL; marking it stopped`);
+    }
+    this.#finishStopped(entry);
+  }
+  #groupAlive(entry) {
+    const pid = entry.info.pid;
+    if (pid === undefined)
+      return false;
+    const alive = this.#options.groupAlive ?? ((group) => {
+      try {
+        process.kill(-group, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    try {
+      return alive(pid);
+    } catch {
+      return false;
+    }
+  }
+  #clearStopTimers(entry) {
+    if (entry.killTimer !== undefined)
+      clearTimeout(entry.killTimer);
+    if (entry.groupTimer !== undefined)
+      clearTimeout(entry.groupTimer);
+    if (entry.killWaitTimer !== undefined)
+      clearTimeout(entry.killWaitTimer);
+    entry.killTimer = undefined;
+    entry.groupTimer = undefined;
+    entry.killWaitTimer = undefined;
+  }
+  async#fail(entry, reason, context4) {
+    entry.generation++;
+    entry.pty = undefined;
+    entry.info.state = { failed: reason };
+    entry.info.endedAt = this.#now();
+    try {
+      await this.#write(entry, context4);
+    } catch (error) {
+      this.#diagnose(error);
+    }
+    entry.resolveDone();
+    this.#refreshBusy();
+    this.#evictOutputs();
+  }
+  async#stopEntry(entry, reason, context4) {
+    if (!isProcessActive(entry.info.state))
+      return info2(entry);
+    entry.stopReason ??= reason;
+    this.#signal(entry, "SIGTERM");
+    this.#ensureKillTimer(entry);
+    await entry.done;
+    return info2(entry);
+  }
+  #signal(entry, signal) {
+    const pid = entry.info.pid;
+    try {
+      if (pid !== undefined) {
+        const kill = this.#options.kill ?? ((target, value) => process.kill(target, value));
+        kill(-pid, signal);
+      } else {
+        entry.pty?.kill(signal);
+      }
+    } catch {}
+  }
+  async#write(entry, context4) {
+    const kept = await this.#options.harness().commit((tx) => this.#applyDoc(tx, entry), context4);
+    this.#retireMissing(kept, entry.root);
+  }
+  async#reportAndWrite(entry) {
+    const harness = this.#options.harness();
+    const conversation = await harness.conversation(entry.info.owner, BACKGROUND_CONTEXT5);
+    const report = reportText(entry);
+    if (conversation === undefined) {
+      await this.#write(entry, BACKGROUND_CONTEXT5);
+      return;
+    }
+    const kept = await conversation.commit(async (tx) => {
+      await conversation.submit(tx, {
+        type: "input",
+        content: report,
+        whenBusy: "steer",
+        requestId: `process:${entry.info.id}:exit`
+      });
+      return this.#applyDoc(tx, entry);
+    }, BACKGROUND_CONTEXT5);
+    this.#retireMissing(kept, entry.root);
+  }
+  async#applyDoc(tx, entry) {
+    const doc = await tx.doc(ProcessDoc, entry.root);
+    const next = docEntry(entry.info);
+    const index = doc.processes.findIndex((process2) => process2.id === entry.info.id);
+    if (index === -1)
+      doc.processes.push(next);
+    else
+      doc.processes[index] = next;
+    const ended = doc.processes.filter((process2) => !isProcessActive(process2.state)).sort((a, b) => (b.endedAt ?? b.startedAt) - (a.endedAt ?? a.startedAt)).slice(0, this.#endedLimit);
+    const keep = new Set(ended.map((process2) => process2.id));
+    doc.processes = doc.processes.filter((process2) => isProcessActive(process2.state) || keep.has(process2.id));
+    return new Set(doc.processes.map((process2) => process2.id));
+  }
+  #retireMissing(kept, root) {
+    for (const [id, entry] of this.#processes) {
+      if (entry.root !== root || kept.has(id) || isProcessActive(entry.info.state))
+        continue;
+      this.#release(entry, "Output released");
+      this.#processes.delete(id);
+      entry.resolveDone();
+    }
+    this.#refreshBusy();
+  }
+  #release(entry, reason) {
+    if (entry.released)
+      return;
+    entry.released = true;
+    this.#clearStopTimers(entry);
+    entry.output.close(reason);
+    entry.output.discard();
+  }
+  #evictOutputs() {
+    let total = 0;
+    const ended = [];
+    for (const entry of this.#processes.values()) {
+      if (isProcessActive(entry.info.state) || entry.released)
+        continue;
+      total += entry.output.length;
+      ended.push(entry);
+    }
+    if (total <= this.#outputBudget)
+      return;
+    ended.sort((a, b) => (a.info.endedAt ?? a.info.startedAt) - (b.info.endedAt ?? b.info.startedAt));
+    for (const entry of ended) {
+      if (total <= this.#outputBudget)
+        return;
+      total -= entry.output.length;
+      this.#release(entry, "Output released");
+    }
+  }
+  #refreshBusy() {
+    this.#busy.set([...this.#processes.values()].some((entry) => isProcessActive(entry.info.state)));
+  }
+  #now() {
+    return (this.#options.now ?? Date.now)();
+  }
+  #diagnose(error) {
+    (this.#options.diagnostic ?? console.error)(`Background process update failed: ${message2(error)}`);
+  }
+}
+async function startProcesses(options) {
+  let spawn4 = options.spawn;
+  if (spawn4 === undefined) {
+    try {
+      const loaded = options.load === undefined ? await import("@lydell/node-pty") : await options.load();
+      if (typeof loaded.spawn !== "function")
+        throw new Error("the module has no spawn()");
+      spawn4 = loaded.spawn;
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      (options.diagnostic ?? console.error)(`Background processes unavailable: cannot load @lydell/node-pty on ${process.platform} (${process.arch}); missing @lydell/node-pty-${process.platform}-${process.arch}. Install without --omit=optional; the host continues without hello.processes. (${detail})`);
+      return;
+    }
+  }
+  return new Processes({
+    ...options,
+    spawn: spawn4,
+    shell: options.shell ?? loginShell(),
+    env: options.env ?? shellEnv(process.env)
+  });
+}
+async function settleLostProcesses(harness, context4) {
+  let cursor;
+  do {
+    const page = await harness.commit((tx) => tx.scanConversations({}, 256, cursor), context4);
+    for (const record of page.items) {
+      if (record.parent !== undefined || record.owner !== undefined)
+        continue;
+      const doc = await harness.snapshot(ProcessDoc, record.id, context4);
+      if (doc === undefined || !doc.processes.some((process2) => process2.state === "starting" || process2.state === "running")) {
+        continue;
+      }
+      await harness.commit(async (tx) => {
+        const value = await tx.doc(ProcessDoc, record.id);
+        for (const process2 of value.processes) {
+          if (process2.state === "starting" || process2.state === "running")
+            process2.state = "lost";
+        }
+      }, context4);
+    }
+    cursor = page.next;
+  } while (cursor !== undefined);
+}
+function info2(entry) {
+  return { ...entry.info, ...entry.info.pid === undefined ? {} : { pid: entry.info.pid } };
+}
+function docEntry(entry) {
+  return {
+    id: entry.id,
+    owner: entry.owner,
+    name: entry.name,
+    command: entry.command,
+    ...entry.pid === undefined ? {} : { pid: entry.pid },
+    startedAt: entry.startedAt,
+    ...entry.endedAt === undefined ? {} : { endedAt: entry.endedAt },
+    state: typeof entry.state === "object" ? { ...entry.state } : entry.state
+  };
+}
+function reportText(entry) {
+  const state = entry.info.state;
+  const outcome = typeof state === "object" && "exited" in state ? state.signal === undefined ? `exited with code ${state.exited ?? "unknown"}` : `exited after signal ${state.signal}` : "exited";
+  const raw = entry.output.snapshot(undefined, Number.MAX_SAFE_INTEGER).text;
+  const clean = stripAnsi(raw).replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+  const tail = clean.split(`
+`).slice(-REPORT_LINES).join(`
+`).trimEnd();
+  const header = `Background process "${entry.info.name}" (${entry.info.id}) ${outcome}.`;
+  const available = Math.max(0, REPORT_LIMIT - header.length - REPORT_TAIL.length);
+  const body = truncateTail(tail, available);
+  return body === "" ? header : `${header}${REPORT_TAIL}${body}`;
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b[PX^_][^\x1b]*(?:\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b[@-_]/g, "");
+}
+function truncateTail(text, max) {
+  if (text.length <= max)
+    return text;
+  let from = text.length - max;
+  const code = text.charCodeAt(from);
+  if (code >= 56320 && code <= 57343)
+    from++;
+  return text.slice(from);
+}
+function signalName(signal) {
+  return signal === 1 ? "SIGHUP" : signal === 2 ? "SIGINT" : signal === 9 ? "SIGKILL" : signal === 15 ? "SIGTERM" : String(signal);
+}
+function message2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // apps/host/src/host.ts
-var context4 = BACKGROUND_CONTEXT4;
+var context4 = BACKGROUND_CONTEXT6;
 async function hostToken(dataDir) {
-  const path = join10(dataDir, "token");
+  const path = join11(dataDir, "token");
   try {
     return (await readFile5(path, "utf8")).trim();
   } catch {
@@ -6346,7 +8399,7 @@ async function openHost(options) {
     validatePublicUrl(options.remote.publicUrl);
   await mkdir4(options.dataDir, { recursive: true });
   const stale = Math.max(2000, options.lockStaleMs ?? 1e4);
-  const release = await lockfile.lock(options.dataDir, {
+  const release2 = await lockfile.lock(options.dataDir, {
     realpath: false,
     stale,
     retries: { retries: Math.ceil(stale / 1000) + 2, minTimeout: 1000, maxTimeout: 1000 }
@@ -6354,26 +8407,38 @@ async function openHost(options) {
     throw new Error(`Session is already open in another process: ${options.dataDir}`, { cause: error });
   });
   let harness;
+  let processes;
   let mcp;
   let agentRoles;
   let attachments;
   let extensions = [];
+  let upgrader;
   try {
     const models = withAnswerTiming(options.models);
     const token = await hostToken(options.dataDir);
-    attachments = new AttachmentStore({ dir: join10(options.dataDir, "attachments") });
+    attachments = new AttachmentStore({ dir: join11(options.dataDir, "attachments") });
     await attachments.open();
     const reports = [];
     let report = (error) => void reports.push(error);
+    processes = await startProcesses({
+      ...options.processes,
+      installing: () => upgrader?.installing === true,
+      harness: () => {
+        if (harness === undefined)
+          throw new Error("harness is not open yet");
+        return harness;
+      }
+    });
     const registry = createRegistry();
-    agentRoles = await openAgentRoles({ dir: join10(options.dataDir, "agents") });
+    agentRoles = await openAgentRoles({ dir: join11(options.dataDir, "agents") });
     extensions = typeof options.extensions === "function" ? options.extensions({
       harness: () => {
         if (harness === undefined)
           throw new Error("harness is not open yet");
         return harness;
       },
-      agentRoles
+      agentRoles,
+      ...processes === undefined ? {} : { processes }
     }) : options.extensions ?? [];
     for (const { extension } of extensions)
       registry.install(extension);
@@ -6389,13 +8454,13 @@ async function openHost(options) {
       }
     });
     const hostSettings = await openHostSettings({
-      path: join10(options.dataDir, "settings.json"),
+      path: join11(options.dataDir, "settings.json"),
       fallback: options.settingsFallback,
       models: options.modelAuth?.models ?? constantValue(options.modelSummaries())
     });
     const environments = new Map;
-    const chatsDir = join10(options.dataDir, "chats");
-    harness = await Harness.open(await (options.openStorage ?? openNodeSqliteStorage)(join10(options.dataDir, "session.sqlite")), {
+    const chatsDir = join11(options.dataDir, "chats");
+    harness = await Harness.open(await (options.openStorage ?? openNodeSqliteStorage)(join11(options.dataDir, "session.sqlite")), {
       models,
       registry,
       env: async (target) => {
@@ -6403,7 +8468,7 @@ async function openHost(options) {
         if (cwd === undefined)
           return;
         const worktrees = worktreeRoot(options.dataDir);
-        if (cwd === worktrees || cwd.startsWith(worktrees + sep6)) {
+        if (cwd === worktrees || cwd.startsWith(worktrees + sep7)) {
           const index = await target.read.snapshot(IndexDoc, context4);
           const record = checkoutAt(index?.checkouts, cwd);
           if (record !== undefined) {
@@ -6425,6 +8490,10 @@ async function openHost(options) {
       },
       onReport: (error) => report(error)
     }, context4);
+    if (processes === undefined)
+      await settleLostProcesses(harness, context4);
+    else
+      await processes.open(context4);
     await ensureIndex(harness, context4);
     await ensureDevices(harness, context4);
     for (const path of options.projects ?? [])
@@ -6432,6 +8501,18 @@ async function openHost(options) {
     const hostKey = await loadHostKey(options.dataDir);
     const offers = pairingOffers(options.remote?.pairingTtlMs);
     const relayKey = options.relay === undefined ? undefined : await loadRelayKey(options.dataDir);
+    upgrader = options.upgrade === undefined ? undefined : await startHostUpgrader({
+      current: options.upgrade.current,
+      dataDir: options.dataDir,
+      harness,
+      settings: hostSettings,
+      context: context4,
+      seams: options.upgrade,
+      ...processes === undefined ? {} : {
+        processesBusy: processes.busy,
+        drain: () => processes.drain(context4)
+      }
+    });
     const gateway = await startGateway({
       harness,
       models,
@@ -6461,6 +8542,8 @@ async function openHost(options) {
       },
       ...options.rtc === undefined ? {} : { rtc: options.rtc },
       ...options.terminals === undefined ? {} : { terminals: options.terminals },
+      ...processes === undefined ? {} : { processes },
+      ...upgrader === undefined ? {} : { upgrade: upgrader },
       secure: {
         hostKey,
         offers,
@@ -6493,6 +8576,7 @@ async function openHost(options) {
       harness,
       closed: opened.closed,
       settings: hostSettings,
+      ...processes === undefined ? {} : { processes },
       createAccountOffer: async () => {
         const binding = await readServerBinding(options.dataDir).catch(() => {
           return;
@@ -6512,6 +8596,7 @@ async function openHost(options) {
       close() {
         closing ??= (async () => {
           try {
+            upgrader?.close();
             await gateway.close();
             await opened.close(context4);
             await mcp?.close();
@@ -6522,13 +8607,16 @@ async function openHost(options) {
             options.modelAuth?.close();
             await Promise.all([...environments.values()].map((env) => env.cleanup(context4)));
           } finally {
-            await release();
+            await release2();
           }
         })();
         return closing;
       }
     };
   } catch (error) {
+    upgrader?.close();
+    if (processes !== undefined)
+      await processes.close(context4).catch(() => {});
     options.modelAuth?.close();
     attachments?.close();
     agentRoles?.close();
@@ -6536,18 +8624,18 @@ async function openHost(options) {
       await each.close?.().catch(() => {});
     await mcp?.close().catch(() => {});
     await harness?.close(context4).catch(() => {});
-    await release().catch(() => {});
+    await release2().catch(() => {});
     throw error;
   }
 }
 
 // apps/host/src/service/log-rotation.ts
 import { copyFile, rename as rename3, rm as rm4, stat as stat8, truncate } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 var HOST_LOG_MAX_BYTES = 10 * 1024 * 1024;
 var HOST_LOG_HISTORY = 3;
 var HOST_LOG_CHECK_INTERVAL_MS = 10 * 60 * 1000;
-var hostLogPath = (dataDir) => join11(dataDir, "logs", "host.log");
+var hostLogPath = (dataDir) => join12(dataDir, "logs", "host.log");
 var rotationTempPath = (log) => `${log}.rotating`;
 var isMissing = (error) => error.code === "ENOENT";
 async function rotateHostLog(dataDir, copy = copyFile) {
@@ -6590,8 +8678,8 @@ function startHostLogRotation(dataDir) {
       return;
     running = true;
     rotateHostLog(dataDir).catch((error) => {
-      const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`${JSON.stringify({ event: "log-rotation-failed", error: message })}
+      const message3 = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`${JSON.stringify({ event: "log-rotation-failed", error: message3 })}
 `);
     }).finally(() => {
       running = false;
@@ -6604,10 +8692,10 @@ function startHostLogRotation(dataDir) {
 }
 
 // apps/host/src/model-auth.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { mkdir as mkdir5, readFile as readFile6, rename as rename4, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
-import { getBuiltinProviders } from "@earendil-works/pi-ai/providers/all";
+import { getBuiltinModels, getBuiltinProviders } from "@earendil-works/pi-ai/providers/all";
 
 // apps/host/src/pi-setup.ts
 import { getSupportedThinkingLevels as getSupportedThinkingLevels2 } from "@earendil-works/pi-ai";
@@ -6722,11 +8810,22 @@ function modelSummaries(modelRuntime) {
 }
 
 // apps/host/src/model-auth.ts
-var BUILTIN = new Set(getBuiltinProviders());
+var BUILTIN_PROVIDERS = getBuiltinProviders();
+var BUILTIN = new Set(BUILTIN_PROVIDERS);
 var CUSTOM_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
 var LOGIN_TIMEOUT_MS = 15 * 60000;
 var FINISHED_LOGIN_TTL_MS = 60000;
 var ENDPOINT_TIMEOUT_MS = 1e4;
+var CATALOG_THINKING_LEVELS = new Map;
+for (const provider of BUILTIN_PROVIDERS) {
+  for (const model of getBuiltinModels(provider)) {
+    if (!model.reasoning || model.thinkingLevelMap === undefined)
+      continue;
+    const maps = CATALOG_THINKING_LEVELS.get(model.id) ?? [];
+    maps.push(model.thinkingLevelMap);
+    CATALOG_THINKING_LEVELS.set(model.id, maps);
+  }
+}
 var sameModel = (a, b) => a.provider === b.provider && a.modelId === b.modelId && a.name === b.name && a.contextWindow === b.contextWindow && a.images === b.images && sameList(a.thinkingLevels, b.thinkingLevels, (x, y) => x === y);
 var sameLogin = (a, b) => a.providerId === b.providerId && a.name === b.name && a.kind === b.kind && a.subscription === b.subscription;
 async function readModelsFile(path) {
@@ -6887,6 +8986,45 @@ async function openModelAuth(runtime, options) {
     tail = next.catch(() => {});
     return next;
   };
+  const opened = await readModelsFile(options.modelsPath);
+  Promise.all([...custom].flatMap(([id, endpoint]) => {
+    const entries = opened.providers[id]?.models;
+    if (!Array.isArray(entries) || !entries.some(lacksLimits))
+      return [];
+    return [
+      (async () => {
+        const key = (await runtime.getAuth(id))?.auth.apiKey;
+        const listed = await fetchEndpointModels(endpoint.api, endpoint.baseUrl, key).catch(() => []);
+        return { id, endpoint, listed: new Map(listed.map((model) => [model.id, model])) };
+      })()
+    ];
+  })).then((answers) => serial(async () => {
+    if (closed)
+      return;
+    const filled = new Set;
+    const fill = (target) => {
+      for (const { id, endpoint, listed } of answers) {
+        const entry = target.providers[id];
+        if (entry?.api !== endpoint.api || entry.baseUrl !== endpoint.baseUrl || !Array.isArray(entry.models))
+          continue;
+        for (const model of entry.models) {
+          const limits = listed.get(model.id);
+          for (const field of LIMITS) {
+            if (field in model || limits?.[field] === undefined)
+              continue;
+            model[field] = limits[field];
+            filled.add(id);
+          }
+        }
+      }
+    };
+    fill(await readModelsFile(options.modelsPath));
+    if (filled.size === 0)
+      return;
+    await updateModelsFile(fill);
+    await runtime.refresh({ providers: [...filled], allowNetwork: false });
+    await republish();
+  }));
   return {
     models,
     auth,
@@ -6908,7 +9046,7 @@ async function openModelAuth(runtime, options) {
       if ([...logins.values()].some((login2) => login2.flow.providerId === providerId && login2.flow.state === "running")) {
         throw new Error(`A login for ${provider.name} is already in progress`);
       }
-      const id = randomUUID3();
+      const id = randomUUID5();
       const login = {
         flow: { id, providerId, method, events: [], state: "running" },
         controller: new AbortController,
@@ -7073,32 +9211,98 @@ async function fetchEndpointModels(api, baseUrl, key) {
   if (!response.ok)
     throw new Error(`${url.host} answered ${response.status} for /models`);
   const body = await response.json();
-  const models = api === "google-generative-ai" ? (body.models ?? []).flatMap((model) => typeof model.name === "string" ? [
-    endpointModel(model.name.replace(/^models\//, ""), {
-      contextWindow: positive(model.inputTokenLimit),
-      maxTokens: positive(model.outputTokenLimit),
-      reasoning: model.thinking === true,
-      image: false
-    })
-  ] : []) : (body.data ?? []).flatMap((model) => typeof model.id === "string" ? [
-    endpointModel(model.id, {
-      contextWindow: positive(model.context_window) ?? positive(model.context_length) ?? positive(model.max_input_tokens),
-      maxTokens: positive(model.max_output_tokens),
-      reasoning: model.reasoning === true,
-      image: Array.isArray(model.modalities?.input) && model.modalities.input.includes("image")
-    })
-  ] : []);
+  const models = api === "google-generative-ai" ? (body.models ?? []).flatMap((model) => {
+    if (typeof model.name !== "string")
+      return [];
+    const id = model.name.replace(/^models\//, "");
+    const reasoning = model.thinking === true;
+    return [
+      endpointModel(id, {
+        contextWindow: positive(model.inputTokenLimit),
+        maxTokens: positive(model.outputTokenLimit),
+        reasoning,
+        image: false,
+        thinkingLevelMap: reasoning ? thinkingLevelMapFrom(reportedThinkingLevels(model)) ?? catalogThinkingLevelMap(id) : undefined
+      })
+    ];
+  }) : (body.data ?? []).flatMap((model) => {
+    if (typeof model.id !== "string")
+      return [];
+    const id = model.id;
+    const reasoning = model.reasoning === true;
+    return [
+      endpointModel(id, {
+        contextWindow: positive(model.context_window) ?? positive(model.context_length) ?? positive(model.max_input_tokens),
+        maxTokens: positive(model.max_output_tokens),
+        reasoning,
+        image: Array.isArray(model.modalities?.input) && model.modalities.input.includes("image"),
+        thinkingLevelMap: reasoning ? thinkingLevelMapFrom(reportedThinkingLevels(model)) ?? catalogThinkingLevelMap(id) : undefined
+      })
+    ];
+  });
   if (models.length === 0)
     throw new Error(`${url.host} listed no models`);
   return models;
 }
+var LIMITS = ["contextWindow", "maxTokens"];
+var lacksLimits = (model) => typeof model === "object" && model !== null && LIMITS.some((field) => !(field in model));
 var positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+var THINKING_LEVELS3 = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+function reportedThinkingLevels(model) {
+  const levels = new Map;
+  const add = (value) => {
+    if (typeof value !== "string")
+      return;
+    const level = value.trim();
+    const piLevel = level.toLowerCase() === "none" ? "off" : level.toLowerCase();
+    if (!THINKING_LEVELS3.includes(piLevel) || levels.has(piLevel))
+      return;
+    levels.set(piLevel, level);
+  };
+  if (Array.isArray(model.reasoning_levels)) {
+    for (const value of model.reasoning_levels)
+      add(value);
+  }
+  if (Array.isArray(model.supported_reasoning_levels)) {
+    for (const value of model.supported_reasoning_levels) {
+      if (typeof value === "string")
+        add(value);
+      else if (typeof value === "object" && value !== null && "effort" in value)
+        add(value.effort);
+    }
+  }
+  return levels;
+}
+function thinkingLevelMapFrom(levels) {
+  if (levels.size === 0)
+    return;
+  return {
+    off: levels.get("off") ?? null,
+    minimal: levels.get("minimal") ?? null,
+    low: levels.get("low") ?? null,
+    medium: levels.get("medium") ?? null,
+    high: levels.get("high") ?? null,
+    xhigh: levels.get("xhigh") ?? null,
+    max: levels.get("max") ?? null
+  };
+}
+function catalogThinkingLevelMap(id) {
+  let matches = CATALOG_THINKING_LEVELS.get(id);
+  if (matches === undefined) {
+    const slash = id.indexOf("/");
+    if (slash === -1)
+      return;
+    matches = CATALOG_THINKING_LEVELS.get(id.slice(slash + 1));
+  }
+  return matches?.length === 1 ? matches[0] : undefined;
+}
 function endpointModel(id, reported) {
   return {
     id,
     ...reported.contextWindow === undefined ? {} : { contextWindow: reported.contextWindow },
     ...reported.maxTokens === undefined ? {} : { maxTokens: reported.maxTokens },
     ...reported.reasoning ? { reasoning: true } : {},
+    ...reported.thinkingLevelMap === undefined ? {} : { thinkingLevelMap: reported.thinkingLevelMap },
     ...reported.image ? { input: ["text", "image"] } : {}
   };
 }
@@ -7133,29 +9337,40 @@ async function main(argv) {
   }
   if (relayOrigin !== undefined)
     validateRelayOrigin(relayOrigin);
-  const agentsHome = join12(homedir3(), ".agents");
-  const extensionsFor = (models, summaries, options2) => (host2) => [
-    createContext({
-      agentsHome,
-      checkout: (input, context5) => checkoutInfo(host2.harness(), input, context5)
-    }),
-    createCoding(options2),
-    todo,
-    question,
-    createSubagent({
-      models,
-      modelSummaries: summaries,
-      exclude: [question.extension],
-      roles: () => host2.agentRoles.value.roles
-    }),
-    createCodemode()
-  ];
+  const agentsHome = join13(homedir3(), ".agents");
+  const extensionsFor = (models, summaries, options2) => (host2) => {
+    const processes = createProcesses({
+      ...host2.processes === undefined ? {} : { runtime: host2.processes }
+    });
+    return [
+      createContext({
+        agentsHome,
+        checkout: (input, context5) => checkoutInfo(host2.harness(), input, context5)
+      }),
+      createCoding(options2),
+      todo,
+      question,
+      processes,
+      createSubagent({
+        models,
+        modelSummaries: summaries,
+        exclude: [question.extension, processes.extension],
+        roles: () => host2.agentRoles.value.roles,
+        worktree: {
+          base: (dispatcher, context5) => subagentWorktreeBase(host2.harness(), dataDir, dispatcher, context5),
+          path: (child) => worktreePath(dataDir, child)
+        }
+      }),
+      createCodemode(),
+      createContextBreakdown({ harness: host2.harness })
+    ];
+  };
   const common = {
     dataDir,
     agentsHome,
     projects: values.project ?? [],
     port: Number(values.port),
-    mcpConfig: join12(agentsHome, "mcp.json"),
+    mcpConfig: join13(agentsHome, "mcp.json"),
     browserOrigins: values["browser-origin"] ?? ["http://127.0.0.1:5199"],
     webRoot,
     ...values["lock-stale-ms"] === undefined ? {} : { lockStaleMs: Number(values["lock-stale-ms"]) },
@@ -7198,10 +9413,10 @@ async function main(argv) {
     };
   }
   async function piOptions() {
-    const modelsPath = join12(dataDir, "models.json");
-    const modelRuntime = await ModelRuntime.create({ authPath: join12(dataDir, "auth.json"), modelsPath });
+    const modelsPath = join13(dataDir, "models.json");
+    const modelRuntime = await ModelRuntime.create({ authPath: join13(dataDir, "auth.json"), modelsPath });
     const modelAuth = await openModelAuth(modelRuntime, { modelsPath, installId: await installId(dataDir) });
-    const settingsManager = SettingsManager.inMemory(await piSettings(join12(dataDir, "settings.json")));
+    const settingsManager = SettingsManager.inMemory(await piSettings(join13(dataDir, "settings.json")));
     configureHarnessHttp(settingsManager);
     const summaries = () => modelAuth.models.value;
     const images = await createNodePhotonImages();
@@ -7226,7 +9441,11 @@ async function main(argv) {
     };
   }
   const options = values.faux !== undefined ? fauxOptions(() => () => fauxAssistantMessage(values.faux)) : await piOptions();
-  const host = await openHost(options);
+  let stop = () => {};
+  const host = await openHost({
+    ...options,
+    ...packagedVersion === undefined ? {} : { upgrade: { current: packagedVersion, restart: () => stop(UPGRADE_EXIT_CODE) } }
+  });
   const stopLogRotation = startHostLogRotation(dataDir);
   const { defaultModel: effectiveModel } = host.settings.value;
   const model = effectiveModel === null ? null : `${effectiveModel.provider}/${effectiveModel.modelId}`;
@@ -7234,7 +9453,7 @@ async function main(argv) {
   console.log(JSON.stringify({
     event: "ready",
     url: host.url,
-    tokenFile: join12(dataDir, "token"),
+    tokenFile: join13(dataDir, "token"),
     dataDir,
     model,
     web,
@@ -7242,17 +9461,21 @@ async function main(argv) {
     ...host.relay === undefined ? {} : { relay: { origin: host.relay.origin, hostId: host.relay.hostId } }
   }));
   let stopping = false;
-  const stop = () => {
+  stop = (code) => {
     if (stopping)
       return;
     stopping = true;
     stopLogRotation();
-    host.close().finally(() => process.exit(0));
+    if (code === UPGRADE_EXIT_CODE) {
+      console.log(JSON.stringify({ event: "upgraded", exitCode: code }));
+      setTimeout(() => process.exit(code), 15000).unref();
+    }
+    host.close().finally(() => process.exit(code));
   };
-  process.on("SIGINT", stop);
-  process.on("SIGTERM", stop);
+  process.on("SIGINT", () => stop(0));
+  process.on("SIGTERM", () => stop(0));
   host.closed.then((end) => {
-    if (end.reason !== "failed" || stopping)
+    if (end.kind !== "failed" || stopping)
       return;
     stopping = true;
     stopLogRotation();
@@ -7280,10 +9503,10 @@ async function piSettings(path) {
   return typeof block === "object" && block !== null && !Array.isArray(block) ? block : {};
 }
 async function installId(dataDir) {
-  const path = join12(dataDir, "install-id");
+  const path = join13(dataDir, "install-id");
   let id = (await readFile7(path, "utf8").catch(() => "")).trim();
   if (id === "") {
-    id = randomUUID4();
+    id = randomUUID6();
     await mkdir6(dataDir, { recursive: true });
     await writeFile5(path, `${id}
 `, { mode: 384 });