pinomad 0.6.0 → 0.7.0

package/dist/{chunk-4btj08we.js → chunk-1nyzr0mg.js}

@@ -35,14 +35,25 @@ import {
 import {
   packagedVersion,
   webRoot
-} from "./chunk-c8nxym2z.js";
+} from "./chunk-rtwxjb90.js";
 import {
+  ATTACHMENT_TTL_MS,
   INVALID_FRAME_CLOSE_CODE,
+  MAX_ATTACHMENTS_PER_MESSAGE,
+  MAX_ATTACHMENT_NAME_LENGTH,
+  MAX_PENDING_ATTACHMENTS,
+  MAX_PENDING_ATTACHMENT_BYTES,
   PROTOCOL,
   UNAUTHORIZED_CLOSE_CODE,
+  attachmentBeginProblem,
+  attachmentBlock,
+  attachmentChunkProblem,
+  base64DecodedLength,
+  isAttachmentId,
   organize,
+  parseAttachmentBlock,
   parseClientFrame
-} from "./chunk-n4tjhcb7.js";
+} from "./chunk-e4ahjbmz.js";
 import {
   THINKING_LEVELS,
   isThinkingLevel
@@ -54,7 +65,7 @@ import"./chunk-df32avw6.js";
 
 // apps/host/src/main.ts
 import { homedir as homedir3 } from "node:os";
-import { join as join9, resolve as resolve4 } from "node:path";
+import { join as join12, 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";
@@ -259,480 +270,237 @@ function createCodemode() {
 }
 
 // apps/host/src/extensions/context.ts
-import { dirname, join, sep } from "node:path";
+import { dirname as dirname2, sep as sep4 } from "node:path";
 import { defineExtension as defineExtension2, section } from "@earendil-works/pi-durable";
-import { formatSkillsForPrompt, loadProjectContextFiles, loadSkills } from "@earendil-works/pi-coding-agent";
-var PREAMBLE = "You are PiNomad, a coding agent running on the user's own machine. You work in the project directory below with the read, write, edit, and bash tools: read files before changing them, prefer edit over rewriting whole files, and run commands to check your work. Keep answers short and concrete. When it is unclear what the user wants, ask instead of guessing.";
-var FORK_SHARED_DIR = "This conversation is a fork: it shares this working directory with the conversation it was forked from, which may be editing the same files. If your task needs isolation, create your own git worktree (for example `git worktree add <dir> -b <branch>`) and use absolute paths inside it for every read, write, edit and bash command.";
-function createContext(options) {
-  const { agentsHome } = options;
-  const resolveCheckout = (input, context) => options.checkout?.(input, context);
-  return {
-    extension: defineExtension2({
-      name: "context",
-      sections: [
-        section("preamble", () => PREAMBLE, { tag: false }),
-        section("environment", async (input, context) => {
-          const cwd = input.agent.cwd;
-          if (cwd === undefined)
-            return;
-          const resolved = await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context);
-          const checkout = resolved?.checkout;
-          const forkLine = resolved?.fork === true && checkout?.own !== true ? [FORK_SHARED_DIR] : [];
-          if (checkout === undefined) {
-            return [`Working directory: ${cwd}`, ...forkLine].join(`
-`);
-          }
-          return [
-            `Working directory: ${cwd}`,
-            checkout.own ? `This directory is a git worktree PiNomad created for this conversation, on branch ${checkout.branch} starting from commit ${checkout.base.slice(0, 12)}.` : `This directory is a git worktree PiNomad created for the conversation this one belongs to, on branch ${checkout.branch} starting from commit ${checkout.base.slice(0, 12)}.`,
-            `The user's project directory is ${checkout.projectPath} and must not be modified.`,
-            "This is a fresh checkout: ignored files (dependencies such as node_modules, or .env) are absent — install dependencies per AGENTS.md when needed.",
-            ...forkLine
-          ].join(`
-`);
-        }),
-        section("file_references", () => "When the user writes @./path in their message, it is a project file the user references; the path is relative to your current working directory. Its contents are not expanded for you — read the file yourself if the task needs them.", { tag: false }),
-        section("project_context", async (input, context) => {
-          const cwd = input.agent.cwd;
-          if (cwd === undefined)
-            return;
-          const checkout = (await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context))?.checkout;
-          let files;
-          if (checkout === undefined) {
-            files = loadProjectContextFiles({ cwd, agentDir: agentsHome });
-          } else {
-            const seen = new Set;
-            files = [
-              ...loadProjectContextFiles({ cwd: dirname(checkout.repo), agentDir: agentsHome }),
-              ...loadProjectContextFiles({ cwd, agentDir: agentsHome }).filter((file) => file.path.startsWith(checkout.worktreeRoot + sep))
-            ].filter((file) => {
-              if (seen.has(file.path))
-                return false;
-              seen.add(file.path);
-              return true;
-            });
-          }
-          return files.length === 0 ? undefined : files.map((file) => `## ${file.path}
+import { formatSkillsForPrompt, loadProjectContextFiles } from "@earendil-works/pi-coding-agent";
 
-${file.content}`).join(`
+// apps/host/src/skills.ts
+import { execFile as execFile2 } 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 { AgentDoc as AgentDoc3 } from "@earendil-works/pi-durable";
+import { loadSkills } from "@earendil-works/pi-coding-agent";
 
-`);
-        }),
-        section("skills", (input) => {
-          const cwd = input.agent.cwd;
-          if (cwd === undefined)
-            return;
-          const { skills } = loadSkills({
-            cwd,
-            agentDir: agentsHome,
-            includeDefaults: false,
-            skillPaths: [join(cwd, ".agents", "skills"), join(agentsHome, "skills")]
-          });
-          const text = formatSkillsForPrompt(skills, "read");
-          return text === "" ? undefined : text;
-        }, { tag: false })
-      ]
-    })
-  };
+// apps/host/src/checkout.ts
+import { execFile, spawn } 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);
+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 chunks = [];
+    let size = 0;
+    let killed = false;
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      if (killed)
+        return;
+      chunks.push(chunk);
+      size += chunk.length;
+      if (size > maxBytes) {
+        killed = true;
+        child.kill();
+        child.stdout.destroy();
+        child.stderr.destroy();
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderr.length < 8192)
+        stderr += chunk.toString("utf8");
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      const stdout = Buffer.concat(chunks).toString("utf8");
+      if (killed)
+        resolve({ stdout, truncated: true });
+      else if (code === 0)
+        resolve({ stdout, truncated: false });
+      else
+        reject(Object.assign(new Error(`Command failed: git ${args.join(" ")}
+${stderr}`), { code, stderr }));
+    });
+  });
+}
+var worktreeRoot = (dataDir) => join(dataDir, "worktrees");
+var worktreePath = (dataDir, id) => join(worktreeRoot(dataDir), String(id));
+var worktreeBranch = (id, suffix) => `pinomad/${id}-${suffix}`;
+var branchSuffix = () => randomBytes(2).toString("hex");
+var checkoutAt = (checkouts, cwd) => checkouts?.find((checkout) => cwd === checkout.path || cwd.startsWith(checkout.path + sep));
+async function gitBase(projectPath) {
+  const top = await git(projectPath, ["rev-parse", "--show-toplevel"]).then(({ stdout }) => stdout.trim(), () => {
+    return;
+  });
+  if (top === undefined)
+    return;
+  const repo = await realpath(top).catch(() => top);
+  const base = await git(repo, ["rev-parse", "--verify", "HEAD"]).then(({ stdout }) => stdout.trim(), () => {
+    return;
+  });
+  if (base === undefined)
+    return;
+  return { repo, subdir: relative(repo, projectPath), base };
+}
+async function branchOf(dir) {
+  const ref = await git(dir, ["symbolic-ref", "--quiet", "HEAD"]).then(({ stdout }) => stdout.trim(), () => {
+    return;
+  });
+  const prefix = "refs/heads/";
+  if (ref === undefined || !ref.startsWith(prefix))
+    return;
+  return ref.slice(prefix.length) || undefined;
+}
+var repoLocks = new Map;
+function locked(repo, work) {
+  const next = (repoLocks.get(repo) ?? Promise.resolve()).then(work, work);
+  const settled = next.then(() => {}, () => {});
+  repoLocks.set(repo, settled);
+  settled.then(() => {
+    if (repoLocks.get(repo) === settled)
+      repoLocks.delete(repo);
+  });
+  return next;
+}
+var worktreeExists = async (path) => stat(join(path, ".git")).then(() => true, () => false);
+var worktreeSettled = (record) => locked(record.repo, () => worktreeExists(record.path));
+async function ensureWorktree(record) {
+  await locked(record.repo, async () => {
+    if (await worktreeExists(record.path))
+      return;
+    await git(record.repo, ["worktree", "prune"]);
+    const branchExists = await git(record.repo, ["show-ref", "--verify", "--quiet", `refs/heads/${record.branch}`]).then(() => true, () => false);
+    if (branchExists) {
+      await git(record.repo, ["worktree", "add", record.path, record.branch]);
+      return;
+    }
+    await git(record.repo, ["worktree", "add", "-b", record.branch, record.path, record.base]);
+    if (record.snapshot !== undefined) {
+      await git(record.path, ["read-tree", "-u", "--reset", record.snapshot]);
+      await git(record.path, ["reset", "-q"]);
+    }
+  });
+}
+async function removeWorktree(record) {
+  return await locked(record.repo, async () => {
+    if (!await worktreeExists(record.path))
+      return;
+    return await git(record.repo, ["worktree", "remove", record.path]).then(() => {
+      return;
+    }, (error) => reasonOf(error));
+  });
+}
+function reasonOf(error) {
+  const stderr = error?.stderr;
+  const text = typeof stderr === "string" && stderr.trim() !== "" ? stderr.trim() : error instanceof Error ? error.message : String(error);
+  return text.split(`
+`).filter((line) => line.trim() !== "").at(-1) ?? text;
+}
+async function changesOf(dir, base, maxBytes = 1024 * 1024) {
+  const indexFile = join(tmpdir(), `pinomad-index-${randomBytes(8).toString("hex")}`);
+  const env = { GIT_INDEX_FILE: indexFile };
+  try {
+    await git(dir, ["read-tree", "HEAD"], env);
+    await git(dir, ["add", "-A"], env);
+    const { stdout, truncated } = await gitCapped(dir, ["diff", "--cached", "--no-color", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", base], maxBytes, env);
+    if (!truncated && Buffer.byteLength(stdout) <= maxBytes)
+      return { base, patch: stdout, truncated: false };
+    const cut = Buffer.from(stdout, "utf8").subarray(0, maxBytes);
+    const patch = cut.subarray(0, cut.lastIndexOf(10) + 1).toString("utf8");
+    return { base, patch, truncated: true };
+  } finally {
+    await rm(indexFile, { force: true });
+  }
 }
 
-// apps/host/src/extensions/subagent.ts
+// apps/host/src/files.ts
+import { spawn as spawn2 } 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 { 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 { clampThinkingLevel } from "@earendil-works/pi-ai";
 import {
   AgentDoc,
-  AssistantEntry,
-  configure,
-  defineExtension as defineExtension3,
-  defineTool as defineTool2,
-  section as section2
+  defineDoc as defineDoc3,
+  configure
 } from "@earendil-works/pi-durable";
-import { Type as Type3 } from "typebox";
 
-// apps/host/src/subagent-doc.ts
+// apps/host/src/message-content.ts
+function messageContent(text, images, attachmentText) {
+  if ((images === undefined || images.length === 0) && attachmentText === undefined)
+    return text;
+  return [
+    ...text === "" ? [] : [{ type: "text", text }],
+    ...attachmentText === undefined ? [] : [{ type: "text", text: attachmentText }],
+    ...(images ?? []).map(({ data, mimeType }) => ({ type: "image", data, mimeType }))
+  ];
+}
+
+// apps/host/src/role-doc.ts
 import { defineDoc as defineDoc2 } from "@earendil-works/pi-durable";
-var SubagentDoc = defineDoc2({
-  kind: "pinomad.subagent",
+var RoleDoc = defineDoc2({
+  kind: "pinomad.role",
   version: 1,
   scope: "conversation",
-  history: "latest",
-  fork: "initial",
+  history: "rewindable",
+  fork: "asOf",
   initial: () => ({})
 });
 
-// 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 THINKING_LEVELS2 = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-function createSubagent(options) {
-  const available = () => options.modelSummaries().map((model) => `${model.provider}/${model.modelId}`).join(", ");
-  const roles = options.roles ?? (() => []);
-  const roleNamed = (name) => {
-    const found = roles().find((each) => each.name === name);
-    if (found !== undefined)
-      return found;
-    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({
-    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()}.`,
-    parameters: Type3.Object({
-      task: Type3.String({
-        minLength: 1,
-        description: "Complete, self-contained instructions. The subagent sees none of this conversation."
-      }),
-      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."
-      })),
-      description: Type3.Optional(Type3.String({ description: 'A short 3-6 word label for the user, e.g. "Audit auth middleware".' })),
-      model: Type3.Optional(Type3.String({ description: "Optional `provider/modelId` to use instead of yours." })),
-      thinkingLevel: Type3.Optional(Type3.Union(THINKING_LEVELS2.map((level) => Type3.Literal(level)), { description: "Optional thinking level instead of yours." }))
-    }),
-    replay: "safe",
-    execute: async (args, api, 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);
-          return {
-            id: existing.id,
-            ...doc2?.model === undefined ? {} : { model: doc2.model },
-            ...doc2?.startedAt === undefined ? {} : { startedAt: doc2.startedAt }
-          };
-        }
-        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\``);
-        }
-        if (role?.thinkingLevel !== undefined && args.thinkingLevel !== undefined) {
-          throw new Error(`Agent "${role.name}" pins thinking level ${role.thinkingLevel}; omit \`thinkingLevel\``);
-        }
-        const modelString = role?.model ?? args.model;
-        const levelString = role?.thinkingLevel ?? args.thinkingLevel;
-        let model;
-        let thinkingLevel;
-        let override;
-        if (modelString !== undefined) {
-          const slash = modelString.indexOf("/");
-          const provider = slash === -1 ? "" : modelString.slice(0, slash);
-          const modelId = slash === -1 ? "" : modelString.slice(slash + 1);
-          override = provider === "" || modelId === "" ? undefined : options.models.getModel(provider, modelId);
-          const listed = options.modelSummaries().some((each) => each.provider === provider && each.modelId === modelId);
-          if (override === undefined || !listed) {
-            throw new Error(role === undefined ? `Unknown model "${modelString}". Available models: ${available()}` : `Agent "${role.name}" uses model "${modelString}", which is not available. Available models: ${available()}`);
-          }
-          model = { provider, modelId };
-        }
-        if (levelString !== undefined || override !== undefined) {
-          const parent = await tx.doc(AgentDoc, api.conversationId);
-          const effective = override ?? (parent.model === undefined ? undefined : options.models.getModel(parent.model.provider, parent.model.modelId));
-          if (levelString !== undefined) {
-            thinkingLevel = effective === undefined ? levelString : clampThinkingLevel(effective, levelString);
-          } else if (parent.thinkingLevel !== undefined) {
-            thinkingLevel = clampThinkingLevel(override, parent.thinkingLevel);
-          }
-        }
-        const change = {
-          extensions: { remove: [extension, ...options.exclude] },
-          instructions: role === undefined || role.prompt === "" ? INSTRUCTIONS : `${INSTRUCTIONS}
-
-${role.prompt}`,
-          ...model === undefined ? {} : { model },
-          ...thinkingLevel === undefined ? {} : { thinkingLevel }
-        };
-        const created = await tx.createConversation({ ownership: { kind: "task", taskId: api.taskId } });
-        await configure(tx, created.id, change);
-        const childAgent = await tx.doc(AgentDoc, created.id);
-        const ref = childAgent.model ?? model ?? (await tx.doc(AgentDoc, api.conversationId)).model;
-        const startedAt = Date.now();
-        const doc = await tx.doc(SubagentDoc, created.id);
-        doc.startedAt = startedAt;
-        if (ref !== undefined)
-          doc.model = `${ref.provider}/${ref.modelId}`;
-        if (role !== undefined)
-          doc.role = role.name;
-        const label = args.description?.trim();
-        if (label !== undefined && label !== "")
-          doc.label = label;
-        return { id: created.id, ...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 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 }
-        }
-      };
-      return result2;
-    }
-  });
-  const extension = defineExtension3({
-    name: "subagent",
-    tools: [tool],
-    sections: [
-      section2("agent_roles", () => {
-        const defined = roles();
-        if (defined.length === 0)
-          return;
-        return [
-          "Named agents: pass one as `role` to `subagent` to delegate to it. When the user writes @name for one of these agents, delegate the relevant work to that agent with `subagent`, putting everything it needs in `task`.",
-          ...defined.map((each) => `- ${each.name}: ${each.description.replace(/\s+/g, " ")}`)
-        ].join(`
-`);
-      })
-    ]
-  });
-  return { extension };
-}
-
-// apps/host/src/extensions/todo.ts
-import { defineDoc as defineDoc3, defineExtension as defineExtension4, defineTool as defineTool3 } from "@earendil-works/pi-durable";
-import { Type as Type4 } from "typebox";
-var TodoDoc = defineDoc3({
-  kind: "todo.list",
+// apps/host/src/organization.ts
+var IndexDoc = defineDoc3({
+  kind: "pinomad.index",
   version: 1,
-  scope: "conversation",
-  history: "rewindable",
-  fork: "asOf",
-  initial: () => ({ items: [] })
-});
-var todoWrite = defineTool3({
-  name: "todo_write",
-  description: "Replace the todo list shown to the user with the given items.",
-  parameters: Type4.Object({ items: Type4.Array(TodoItemSchema) }),
-  replay: "safe",
-  execute: async (args, api, context) => {
-    await api.commit(async (tx) => {
-      const doc = await tx.doc(TodoDoc, api.conversationId);
-      doc.items = args.items.map((item) => ({ ...item }));
-    }, context);
-    return { output: [{ type: "text", text: `Todo list updated: ${args.items.length} item(s).` }] };
-  }
+  scope: "session",
+  initial: () => ({ projects: [], conversations: [] })
 });
-var todo = {
-  extension: defineExtension4({ name: "todo", tools: [todoWrite] }),
-  docs: [{ token: TodoDoc, presentation: "pinomad.todo" }]
-};
-
-// apps/host/src/host.ts
-import { randomBytes as randomBytes3 } from "node:crypto";
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { basename as basename2, join as join8, sep as sep5 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
-import { createRegistry, Harness } from "@earendil-works/pi-durable";
-import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
-
-// apps/host/src/organization.ts
-import { mkdir, realpath as realpath2, stat as stat2 } from "node:fs/promises";
-import { basename, join as join3, resolve } from "node:path";
-import { clampThinkingLevel as clampThinkingLevel2 } from "@earendil-works/pi-ai";
-import {
-  AgentDoc as AgentDoc2,
-  defineDoc as defineDoc4
-} from "@earendil-works/pi-durable";
-
-// apps/host/src/checkout.ts
-import { execFile, spawn } from "node:child_process";
-import { randomBytes } from "node:crypto";
-import { realpath, rm, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join as join2, relative, sep as sep2 } from "node:path";
-import { promisify } from "node:util";
-var run = promisify(execFile);
-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 chunks = [];
-    let size = 0;
-    let killed = false;
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      if (killed)
-        return;
-      chunks.push(chunk);
-      size += chunk.length;
-      if (size > maxBytes) {
-        killed = true;
-        child.kill();
-        child.stdout.destroy();
-        child.stderr.destroy();
-      }
-    });
-    child.stderr.on("data", (chunk) => {
-      if (stderr.length < 8192)
-        stderr += chunk.toString("utf8");
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      const stdout = Buffer.concat(chunks).toString("utf8");
-      if (killed)
-        resolve({ stdout, truncated: true });
-      else if (code === 0)
-        resolve({ stdout, truncated: false });
-      else
-        reject(Object.assign(new Error(`Command failed: git ${args.join(" ")}
-${stderr}`), { code, stderr }));
-    });
-  });
+async function ensureIndex(harness, context) {
+  await harness.commit(async (tx) => {
+    await tx.doc(IndexDoc);
+  }, context);
 }
-var worktreeRoot = (dataDir) => join2(dataDir, "worktrees");
-var worktreePath = (dataDir, id) => join2(worktreeRoot(dataDir), String(id));
-var worktreeBranch = (id, suffix) => `pinomad/${id}-${suffix}`;
-var branchSuffix = () => randomBytes(2).toString("hex");
-var checkoutAt = (checkouts, cwd) => checkouts?.find((checkout) => cwd === checkout.path || cwd.startsWith(checkout.path + sep2));
-async function gitBase(projectPath) {
-  const top = await git(projectPath, ["rev-parse", "--show-toplevel"]).then(({ stdout }) => stdout.trim(), () => {
-    return;
-  });
-  if (top === undefined)
-    return;
-  const repo = await realpath(top).catch(() => top);
-  const base = await git(repo, ["rev-parse", "--verify", "HEAD"]).then(({ stdout }) => stdout.trim(), () => {
-    return;
-  });
-  if (base === undefined)
-    return;
-  return { repo, subdir: relative(repo, projectPath), base };
+async function normalizePath(path) {
+  return await realpath2(resolve(path));
 }
-async function branchOf(dir) {
-  const ref = await git(dir, ["symbolic-ref", "--quiet", "HEAD"]).then(({ stdout }) => stdout.trim(), () => {
-    return;
+async function addProject(harness, path, context) {
+  const normalized = await normalizePath(path).catch(() => {
+    throw new Error(`No such directory: ${path}`);
   });
-  const prefix = "refs/heads/";
-  if (ref === undefined || !ref.startsWith(prefix))
-    return;
-  return ref.slice(prefix.length) || undefined;
+  if (!(await stat2(normalized)).isDirectory())
+    throw new Error(`Not a directory: ${path}`);
+  return await harness.commit(async (tx) => {
+    const doc = await tx.doc(IndexDoc);
+    const existing = doc.projects.find((project2) => project2.path === normalized);
+    if (existing !== undefined)
+      return { ...existing };
+    const project = { path: normalized, name: basename(normalized), addedAt: Date.now() };
+    doc.projects.push(project);
+    return project;
+  }, context);
 }
-var repoLocks = new Map;
-function locked(repo, work) {
-  const next = (repoLocks.get(repo) ?? Promise.resolve()).then(work, work);
-  const settled = next.then(() => {}, () => {});
-  repoLocks.set(repo, settled);
-  settled.then(() => {
-    if (repoLocks.get(repo) === settled)
-      repoLocks.delete(repo);
-  });
-  return next;
+async function removeProject(harness, path, context) {
+  const normalized = await normalizePath(path).catch(() => resolve(path));
+  await harness.commit(async (tx) => {
+    const doc = await tx.doc(IndexDoc);
+    doc.projects = doc.projects.filter((project) => project.path !== normalized);
+  }, context);
 }
-var worktreeExists = async (path) => stat(join2(path, ".git")).then(() => true, () => false);
-async function ensureWorktree(record) {
-  await locked(record.repo, async () => {
-    if (await worktreeExists(record.path))
-      return;
-    await git(record.repo, ["worktree", "prune"]);
-    const branchExists = await git(record.repo, ["show-ref", "--verify", "--quiet", `refs/heads/${record.branch}`]).then(() => true, () => false);
-    if (branchExists) {
-      await git(record.repo, ["worktree", "add", record.path, record.branch]);
-      return;
-    }
-    await git(record.repo, ["worktree", "add", "-b", record.branch, record.path, record.base]);
-    if (record.snapshot !== undefined) {
-      await git(record.path, ["read-tree", "-u", "--reset", record.snapshot]);
-      await git(record.path, ["reset", "-q"]);
-    }
-  });
-}
-async function removeWorktree(record) {
-  return await locked(record.repo, async () => {
-    if (!await worktreeExists(record.path))
-      return;
-    return await git(record.repo, ["worktree", "remove", record.path]).then(() => {
-      return;
-    }, (error) => reasonOf(error));
-  });
-}
-function reasonOf(error) {
-  const stderr = error?.stderr;
-  const text = typeof stderr === "string" && stderr.trim() !== "" ? stderr.trim() : error instanceof Error ? error.message : String(error);
-  return text.split(`
-`).filter((line) => line.trim() !== "").at(-1) ?? text;
-}
-async function changesOf(dir, base, maxBytes = 1024 * 1024) {
-  const indexFile = join2(tmpdir(), `pinomad-index-${randomBytes(8).toString("hex")}`);
-  const env = { GIT_INDEX_FILE: indexFile };
-  try {
-    await git(dir, ["read-tree", "HEAD"], env);
-    await git(dir, ["add", "-A"], env);
-    const { stdout, truncated } = await gitCapped(dir, ["diff", "--cached", "--no-color", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", base], maxBytes, env);
-    if (!truncated && Buffer.byteLength(stdout) <= maxBytes)
-      return { base, patch: stdout, truncated: false };
-    const cut = Buffer.from(stdout, "utf8").subarray(0, maxBytes);
-    const patch = cut.subarray(0, cut.lastIndexOf(10) + 1).toString("utf8");
-    return { base, patch, truncated: true };
-  } finally {
-    await rm(indexFile, { force: true });
-  }
-}
-
-// apps/host/src/message-content.ts
-function messageContent(text, images) {
-  if (images === undefined || images.length === 0)
-    return text;
-  return [
-    ...text === "" ? [] : [{ type: "text", text }],
-    ...images.map(({ data, mimeType }) => ({ type: "image", data, mimeType }))
-  ];
-}
-
-// apps/host/src/organization.ts
-var IndexDoc = defineDoc4({
-  kind: "pinomad.index",
-  version: 1,
-  scope: "session",
-  initial: () => ({ projects: [], conversations: [] })
-});
-async function ensureIndex(harness, context) {
-  await harness.commit(async (tx) => {
-    await tx.doc(IndexDoc);
-  }, context);
-}
-async function normalizePath(path) {
-  return await realpath2(resolve(path));
-}
-async function addProject(harness, path, context) {
-  const normalized = await normalizePath(path).catch(() => {
-    throw new Error(`No such directory: ${path}`);
-  });
-  if (!(await stat2(normalized)).isDirectory())
-    throw new Error(`Not a directory: ${path}`);
-  return await harness.commit(async (tx) => {
-    const doc = await tx.doc(IndexDoc);
-    const existing = doc.projects.find((project2) => project2.path === normalized);
-    if (existing !== undefined)
-      return { ...existing };
-    const project = { path: normalized, name: basename(normalized), addedAt: Date.now() };
-    doc.projects.push(project);
-    return project;
-  }, context);
-}
-async function removeProject(harness, path, context) {
-  const normalized = await normalizePath(path).catch(() => resolve(path));
-  await harness.commit(async (tx) => {
-    const doc = await tx.doc(IndexDoc);
-    doc.projects = doc.projects.filter((project) => project.path !== normalized);
-  }, context);
-}
-
-class DuplicateRequest extends Error {
-  conversationId;
-  constructor(conversationId) {
-    super("conversation already created");
-    this.conversationId = conversationId;
-  }
+
+class DuplicateRequest extends Error {
+  conversationId;
+  constructor(conversationId) {
+    super("conversation already created");
+    this.conversationId = conversationId;
+  }
 }
 function requireRole(agents, name) {
   const found = agents.roles.find((role) => role.name === name);
@@ -756,7 +524,7 @@ async function createConversation(harness, dataDir, input, defaults, models, mod
   if (prior !== undefined) {
     const existing = await harness.conversation(prior.id, context);
     if (existing !== undefined) {
-      await existing.submit({ type: "input", content: messageContent(input.text, input.images), whenBusy: "followUp", requestId: input.requestId }, context);
+      await existing.submit({ type: "input", content: messageContent(input.text, input.images, input.attachmentText), whenBusy: "followUp", requestId: input.requestId }, context);
     }
     return prior.id;
   }
@@ -777,7 +545,7 @@ async function createConversation(harness, dataDir, input, defaults, models, mod
       throw new Error(`Model ${modelRef.provider}/${modelRef.modelId} is not available${suffix2}`);
     }
   }
-  const thinkingLevel = model === undefined ? input.thinkingLevel ?? role?.thinkingLevel ?? defaults.thinkingLevel : clampThinkingLevel2(model, input.thinkingLevel ?? role?.thinkingLevel ?? defaults.thinkingLevel ?? "off");
+  const thinkingLevel = model === undefined ? input.thinkingLevel ?? role?.thinkingLevel ?? defaults.thinkingLevel : clampThinkingLevel(model, input.thinkingLevel ?? role?.thinkingLevel ?? defaults.thinkingLevel ?? "off");
   const home = input.home;
   const projectPath = home.kind === "project" ? await normalizePath(home.path).catch(() => home.path) : undefined;
   const repo = home.kind === "project" && input.checkout !== "project" && projectPath !== undefined ? await gitBase(projectPath) : undefined;
@@ -807,6 +575,7 @@ async function createConversation(harness, dataDir, input, defaults, models, mod
           requestId: input.requestId,
           ...role === undefined ? {} : { role: role.name }
         });
+        (await tx.doc(RoleDoc, id)).name = role?.name ?? null;
         if (repo !== undefined && suffix !== undefined) {
           const path = worktreePath(dataDir, id);
           if (doc.checkouts === undefined)
@@ -819,26 +588,59 @@ async function createConversation(harness, dataDir, input, defaults, models, mod
             branch: worktreeBranch(id, suffix),
             base: repo.base
           });
-          (await tx.doc(AgentDoc2, id)).cwd = join3(path, repo.subdir);
+          (await tx.doc(AgentDoc, id)).cwd = join2(path, repo.subdir);
         } else if (home.kind === "chat") {
-          (await tx.doc(AgentDoc2, id)).cwd = join3(dataDir, "chats", String(id));
+          (await tx.doc(AgentDoc, id)).cwd = join2(dataDir, "chats", String(id));
         }
       }
     }, context);
     if (home.kind === "chat")
-      await mkdir(join3(dataDir, "chats", String(conversation.id)), { recursive: true });
-    await conversation.submit({ type: "input", content: messageContent(input.text, input.images), whenBusy: "followUp", requestId: input.requestId }, context);
+      await mkdir(join2(dataDir, "chats", String(conversation.id)), { recursive: true });
+    await conversation.submit({ type: "input", content: messageContent(input.text, input.images, input.attachmentText), whenBusy: "followUp", requestId: input.requestId }, context);
     return conversation.id;
   } catch (error) {
     if (!(error instanceof DuplicateRequest))
       throw error;
     const existing = await harness.conversation(error.conversationId, context);
     if (existing !== undefined) {
-      await existing.submit({ type: "input", content: messageContent(input.text, input.images), whenBusy: "followUp", requestId: input.requestId }, context);
+      await existing.submit({ type: "input", content: messageContent(input.text, input.images, input.attachmentText), whenBusy: "followUp", requestId: input.requestId }, context);
     }
     return error.conversationId;
   }
 }
+async function setAgent(harness, input, models, modelSummaries, agents, context) {
+  await harness.commit(async (tx) => {
+    const record = await tx.conversation(input.conversationId);
+    if (record === undefined)
+      throw new Error(`Conversation ${input.conversationId} does not exist`);
+    if (record.owner !== undefined)
+      throw new Error("Subagent conversations cannot switch agent");
+    const role = input.agent === null ? undefined : requireRole(agents, input.agent);
+    const state = await tx.doc(AgentDoc, input.conversationId);
+    let change;
+    if (role === undefined) {
+      change = { instructions: null };
+    } else {
+      const modelRef = roleModelRef(role) ?? state.model;
+      const listed = modelSummaries().map((model2) => `${model2.provider}/${model2.modelId}`).join(", ");
+      const suffix = listed === "" ? "" : `. Available models: ${listed}`;
+      if (modelRef === undefined) {
+        throw new Error(`Agent "${role.name}" has no model: the role pins none and the conversation has none${suffix}`);
+      }
+      const model = models.getModel(modelRef.provider, modelRef.modelId);
+      if (model === undefined || !modelSummaries().some((each) => each.provider === modelRef.provider && each.modelId === modelRef.modelId)) {
+        throw new Error(`Model ${modelRef.provider}/${modelRef.modelId} is not available${suffix}`);
+      }
+      change = {
+        model: modelRef,
+        thinkingLevel: clampThinkingLevel(model, role.thinkingLevel ?? state.thinkingLevel ?? "off"),
+        instructions: role.prompt === "" ? null : role.prompt
+      };
+    }
+    await configure(tx, input.conversationId, change);
+    (await tx.doc(RoleDoc, input.conversationId)).name = role?.name ?? null;
+  }, context);
+}
 async function archive(harness, id, archived, context) {
   await harness.commit(async (tx) => {
     const doc = await tx.doc(IndexDoc);
@@ -863,7 +665,7 @@ async function forkFlagOf(harness, id, context) {
   return record.parent !== undefined;
 }
 async function checkoutInfo(harness, input, context) {
-  const agent = await input.read.snapshot(AgentDoc2, input.conversationId, context);
+  const agent = await input.read.snapshot(AgentDoc, input.conversationId, context);
   const cwd = agent?.cwd;
   if (cwd === undefined)
     return;
@@ -878,7 +680,7 @@ async function checkoutInfo(harness, input, context) {
       checkout: {
         branch: checkout.branch,
         base: checkout.base,
-        projectPath: join3(checkout.repo, checkout.subdir),
+        projectPath: join2(checkout.repo, checkout.subdir),
         repo: checkout.repo,
         worktreeRoot: checkout.path,
         own: checkout.conversationId === input.conversationId
@@ -916,20 +718,724 @@ async function cleanupArchivedWorktrees(harness, rootId, context) {
         queue.push(child);
       }
     }
-  }
-  const kept = [];
-  for (const record of checkouts.filter((checkout) => subtree.has(checkout.conversationId))) {
-    const reason = await removeWorktree(record);
-    if (reason !== undefined)
-      kept.push({ record, reason });
-  }
-  return kept;
+  }
+  const kept = [];
+  for (const record of checkouts.filter((checkout) => subtree.has(checkout.conversationId))) {
+    const reason = await removeWorktree(record);
+    if (reason !== undefined)
+      kept.push({ record, reason });
+  }
+  return kept;
+}
+
+// apps/host/src/files.ts
+var CACHE_TTL_MS = 3000;
+var MAX_CACHED_ROOTS = 64;
+var MAX_CONCURRENT_SCANS = 4;
+var SCAN_BUDGET_MS = 5000;
+var MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+var MAX_WALK_ENTRIES = 20000;
+var MAX_RESULTS = 50;
+var UNUSABLE_PATH = /[\s`\x00-\x1f\x7f-\x9f]/;
+function createCandidateLister(enumerate, options = {}) {
+  const now = options.now ?? Date.now;
+  const ttlMs = options.ttlMs ?? CACHE_TTL_MS;
+  const maxConcurrent = options.maxConcurrent ?? MAX_CONCURRENT_SCANS;
+  const maxCached = options.maxCached ?? MAX_CACHED_ROOTS;
+  const cache = new Map;
+  const inflight = new Map;
+  let running = 0;
+  const waiting = [];
+  return (root, mode) => {
+    const key = `${mode}${root}`;
+    const hit = cache.get(key);
+    if (hit !== undefined) {
+      if (hit.expiresAt > now())
+        return Promise.resolve(hit.value);
+      cache.delete(key);
+    }
+    const pending = inflight.get(key);
+    if (pending !== undefined)
+      return pending;
+    const scan = (async () => {
+      if (running >= maxConcurrent)
+        await new Promise((release) => waiting.push(release));
+      running += 1;
+      try {
+        return await enumerate(root, mode);
+      } finally {
+        running -= 1;
+        waiting.shift()?.();
+      }
+    })();
+    inflight.set(key, scan);
+    scan.then((value) => {
+      const at = now();
+      for (const [cached, entry] of cache) {
+        if (entry.expiresAt <= at)
+          cache.delete(cached);
+      }
+      while (cache.size >= maxCached)
+        cache.delete(cache.keys().next().value);
+      cache.set(key, { value, expiresAt: at + ttlMs });
+    }, () => {});
+    return scan.finally(() => inflight.delete(key));
+  };
+}
+function gitLines(cwd, args, limits) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn2("git", ["-C", cwd, ...args], { stdio: ["ignore", "pipe", "pipe"] });
+    const chunks = [];
+    let bytes = 0;
+    let truncated = false;
+    let settled = false;
+    const kill = (markTruncated) => {
+      truncated ||= markTruncated;
+      child.kill("SIGKILL");
+    };
+    const timer = setTimeout(() => kill(true), Math.max(0, limits.deadline - limits.now()));
+    const finish = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (error !== undefined) {
+        rejectPromise(error);
+        return;
+      }
+      const output = Buffer.concat(chunks).toString("utf8");
+      const parts = output.split("\x00");
+      if (truncated)
+        parts.pop();
+      resolvePromise({ lines: parts.filter((part) => part !== ""), truncated });
+    };
+    child.stdout.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > limits.maxBytes) {
+        kill(true);
+        return;
+      }
+      chunks.push(chunk);
+      if (limits.now() > limits.deadline)
+        kill(true);
+    });
+    child.on("error", (error) => finish(error));
+    child.stderr.resume();
+    child.on("close", (code) => {
+      if (code === 0 || truncated) {
+        finish(undefined);
+      } else {
+        finish(new Error(`git ${args.join(" ")} exited with code ${code}`));
+      }
+    });
+  });
+}
+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"] });
+    let out = "";
+    child.stdout.on("data", (chunk) => out += chunk.toString("utf8"));
+    child.on("error", () => resolvePromise(false));
+    child.on("close", (code) => resolvePromise(code === 0 && out.trim() === "true"));
+  });
+}
+async function hasHead(root) {
+  return await new Promise((resolvePromise) => {
+    const child = spawn2("git", ["-C", root, "rev-parse", "--verify", "-q", "HEAD"], { stdio: ["ignore", "ignore", "ignore"] });
+    child.on("error", () => resolvePromise(false));
+    child.on("close", (code) => resolvePromise(code === 0));
+  });
+}
+var STAGED_RECORD = /^([0-7]{6}) [0-9a-f]{40,64} [0-7]\t/;
+async function gitWorkingFiles(root, limits) {
+  const listing = await gitLines(root, ["ls-files", "-z", "-s", "--cached", "--others", "--exclude-standard"], limits);
+  const deleted = await gitLines(root, ["ls-files", "-z", "--deleted"], limits);
+  const gone = new Set(deleted.lines);
+  const files = new Set;
+  for (const line of listing.lines) {
+    const staged = STAGED_RECORD.exec(line);
+    const path = staged === null ? line : line.slice(staged[0].length);
+    if (staged !== null && staged[1] === "160000")
+      continue;
+    if (path === "" || path.endsWith("/") || gone.has(path))
+      continue;
+    files.add(path);
+  }
+  return { files: [...files], truncated: listing.truncated || deleted.truncated };
+}
+async function gitHeadFiles(root, limits) {
+  const listing = await gitLines(root, ["ls-tree", "-r", "-z", "HEAD"], limits);
+  const files = [];
+  for (const line of listing.lines) {
+    const tab = line.indexOf("\t");
+    if (tab === -1)
+      continue;
+    const kind = line.slice(0, tab).split(" ")[1];
+    if (kind === "blob")
+      files.push(line.slice(tab + 1));
+  }
+  return { files, truncated: listing.truncated };
+}
+async function walkFiles(root, limits) {
+  const files = [];
+  let entries = 0;
+  let truncated = false;
+  const dirs = [{ dir: root, prefix: "" }];
+  while (dirs.length > 0) {
+    if (limits.now() > limits.deadline) {
+      truncated = true;
+      break;
+    }
+    const { dir, prefix } = dirs.pop();
+    let handle;
+    try {
+      handle = await opendir(dir);
+    } catch (error) {
+      if (prefix === "")
+        throw error;
+      truncated = true;
+      continue;
+    }
+    for await (const entry of handle) {
+      if (entries++ >= limits.maxEntries || limits.now() > limits.deadline) {
+        truncated = true;
+        break;
+      }
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+          continue;
+        dirs.push({ dir: join3(dir, entry.name), prefix: `${prefix}${entry.name}/` });
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        files.push(`${prefix}${entry.name}`);
+      }
+    }
+    if (truncated)
+      break;
+  }
+  return { files, truncated };
+}
+async function enumerateRoot(root, mode, limits = {}) {
+  const now = limits.now ?? Date.now;
+  const bounded = {
+    now,
+    deadline: now() + (limits.budgetMs ?? SCAN_BUDGET_MS),
+    maxBytes: limits.maxBytes ?? MAX_OUTPUT_BYTES,
+    maxEntries: limits.maxEntries ?? MAX_WALK_ENTRIES
+  };
+  if (!await inWorkTree(root)) {
+    return walkFiles(root, bounded);
+  }
+  if (mode === "head" && !await hasHead(root)) {
+    return walkFiles(root, bounded);
+  }
+  return mode === "head" ? gitHeadFiles(root, bounded) : gitWorkingFiles(root, bounded);
+}
+function matchFiles(candidates, query, max = MAX_RESULTS) {
+  const usable = candidates.filter((path) => !UNUSABLE_PATH.test(path));
+  if (query === "") {
+    const sorted = [...usable].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    return { files: sorted.slice(0, max), truncated: sorted.length > max };
+  }
+  const needle = query.toLowerCase();
+  const tiers = [[], [], []];
+  for (const path of usable) {
+    const base = path.slice(path.lastIndexOf("/") + 1).toLowerCase();
+    const lower = path.toLowerCase();
+    if (base.startsWith(needle))
+      tiers[0].push(path);
+    else if (base.includes(needle))
+      tiers[1].push(path);
+    else if (lower.includes(needle))
+      tiers[2].push(path);
+  }
+  const shorter = (a, b) => a.length - b.length || (a < b ? -1 : a > b ? 1 : 0);
+  const matched = [...tiers[0].sort(shorter), ...tiers[1].sort(shorter), ...tiers[2].sort(shorter)];
+  return { files: matched.slice(0, max), truncated: matched.length > max };
+}
+async function listFiles(harness, dataDir, enumerate, scope, query, context) {
+  let root;
+  let mode = "live";
+  if (scope.kind === "conversation") {
+    const agent = await harness.snapshot(AgentDoc2, scope.conversationId, context);
+    if (agent === undefined)
+      throw new Error(`Conversation ${scope.conversationId} does not exist`);
+    const cwd = agent.cwd;
+    if (cwd === undefined)
+      throw new Error(`Conversation ${scope.conversationId} has no checkout`);
+    if (cwd.startsWith(join3(dataDir, "chats") + sep2))
+      return { files: [], truncated: false };
+    const record = checkoutAt((await harness.snapshot(IndexDoc, context))?.checkouts, cwd);
+    const ready = record === undefined || await worktreeSettled(record);
+    const info = ready ? await stat3(cwd).catch(() => {
+      return;
+    }) : undefined;
+    if (info === undefined || !info.isDirectory()) {
+      throw new Error(`Conversation ${scope.conversationId}'s checkout is unavailable: ${cwd}`);
+    }
+    root = cwd;
+  } else {
+    const normalized = await realpath3(resolve2(scope.path)).catch(() => resolve2(scope.path));
+    const index = await harness.snapshot(IndexDoc, context);
+    if (!index?.projects.some((project) => project.path === normalized)) {
+      throw new Error(`Unknown project: ${scope.path}`);
+    }
+    const info = await stat3(normalized).catch(() => {
+      return;
+    });
+    if (info === undefined || !info.isDirectory()) {
+      throw new Error(`Not a directory: ${normalized}`);
+    }
+    root = normalized;
+    mode = scope.checkout === "worktree" ? "head" : "live";
+  }
+  const candidates = await enumerate(root, mode);
+  const matched = matchFiles(candidates.files, query);
+  return { files: matched.files, truncated: matched.truncated || candidates.truncated };
+}
+
+// apps/host/src/skills.ts
+var exec = promisify2(execFile2);
+function invocableSkillName(name) {
+  return name.length <= 64 && /^[a-z0-9-]+$/.test(name) && !name.startsWith("-") && !name.endsWith("-") && !name.includes("--");
+}
+var reportedDiagnostics = new Set;
+function reportDiagnostics(diagnostics) {
+  for (const diagnostic of diagnostics) {
+    const key = `${diagnostic.path ?? ""}\x00${diagnostic.message}`;
+    if (reportedDiagnostics.has(key))
+      continue;
+    reportedDiagnostics.add(key);
+    console.error(JSON.stringify({
+      event: "skill",
+      level: diagnostic.type === "error" ? "error" : "warning",
+      ...diagnostic.path === undefined ? {} : { path: diagnostic.path },
+      message: diagnostic.message
+    }));
+  }
+}
+function entrySkills(dir, source, agentsHome) {
+  if (!existsSync(dir))
+    return [];
+  const { skills, diagnostics } = loadSkills({ cwd: dir, agentDir: agentsHome, includeDefaults: false, skillPaths: [dir] });
+  reportDiagnostics(diagnostics);
+  return skills.map((skill) => ({ skill, source }));
+}
+function projectSkillLayers(root) {
+  const start = resolve3(root);
+  const dirs = [start];
+  let dir = start;
+  for (;; ) {
+    if (existsSync(join4(dir, ".git")))
+      return { dirs, gitRoot: dir };
+    const parent = dirname(dir);
+    if (parent === dir)
+      return { dirs: [start] };
+    dir = parent;
+    dirs.push(dir);
+  }
+}
+function projectSkills(dirs, agentsHome) {
+  return dirs.flatMap((dir) => entrySkills(join4(dir, ".agents", "skills"), "project", agentsHome));
+}
+function mergeSkills(entries) {
+  const seen = new Set;
+  const merged = [];
+  for (const entry of entries) {
+    for (const scoped of entry) {
+      if (seen.has(scoped.skill.name))
+        continue;
+      seen.add(scoped.skill.name);
+      merged.push(scoped);
+    }
+  }
+  return merged;
+}
+function scopedSkills(root, agentsHome) {
+  const project = root === undefined ? [] : projectSkills(projectSkillLayers(root).dirs, agentsHome);
+  return mergeSkills([project, entrySkills(join4(agentsHome, "skills"), "user", agentsHome)]);
+}
+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("/");
+    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 });
+  return new Set(stdout.split("\x00").filter((path) => path !== ""));
+}
+async function enumerateSkills(root, mode, agentsHome) {
+  let project = [];
+  if (root !== undefined) {
+    const layers = projectSkillLayers(root);
+    project = projectSkills(layers.dirs, agentsHome);
+    const gitRoot = layers.gitRoot;
+    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("/")));
+      }
+    }
+  }
+  const merged = mergeSkills([project, entrySkills(join4(agentsHome, "skills"), "user", agentsHome)]);
+  return merged.filter((scoped) => invocableSkillName(scoped.skill.name)).map(({ skill, source }) => ({
+    name: skill.name,
+    description: skill.description,
+    source,
+    filePath: skill.filePath,
+    baseDir: skill.baseDir
+  }));
+}
+var CACHE_TTL_MS2 = 3000;
+var MAX_CACHED_SCOPES = 64;
+function createSkillLister(enumerate, options = {}) {
+  const now = options.now ?? Date.now;
+  const ttlMs = options.ttlMs ?? CACHE_TTL_MS2;
+  const maxCached = options.maxCached ?? MAX_CACHED_SCOPES;
+  const cache = new Map;
+  const inflight = new Map;
+  return (root, mode) => {
+    const key = `${mode}${root ?? ""}`;
+    const hit = cache.get(key);
+    if (hit !== undefined) {
+      if (hit.expiresAt > now())
+        return Promise.resolve(hit.value);
+      cache.delete(key);
+    }
+    const pending = inflight.get(key);
+    if (pending !== undefined)
+      return pending;
+    const scan = enumerate(root, mode);
+    inflight.set(key, scan);
+    scan.then((value) => {
+      const at = now();
+      for (const [cached, entry] of cache) {
+        if (entry.expiresAt <= at)
+          cache.delete(cached);
+      }
+      while (cache.size >= maxCached)
+        cache.delete(cache.keys().next().value);
+      cache.set(key, { value, expiresAt: at + ttlMs });
+    }, () => {});
+    return scan.finally(() => inflight.delete(key));
+  };
+}
+async function scopeSkills(harness, lister, scope, context) {
+  if (scope.kind === "chat")
+    return lister(undefined, "live");
+  let root;
+  let mode = "live";
+  if (scope.kind === "conversation") {
+    const agent = await harness.snapshot(AgentDoc3, scope.conversationId, context);
+    if (agent === undefined)
+      throw new Error(`Conversation ${scope.conversationId} does not exist`);
+    const cwd = agent.cwd;
+    if (cwd === undefined)
+      throw new Error(`Conversation ${scope.conversationId} has no checkout`);
+    const record = checkoutAt((await harness.snapshot(IndexDoc, context))?.checkouts, cwd);
+    const ready = record === undefined || await worktreeSettled(record);
+    const info = ready ? await stat4(cwd).catch(() => {
+      return;
+    }) : undefined;
+    if (info === undefined || !info.isDirectory()) {
+      throw new Error(`Conversation ${scope.conversationId}'s checkout is unavailable: ${cwd}`);
+    }
+    root = cwd;
+  } else {
+    const normalized = await realpath4(resolve3(scope.path)).catch(() => resolve3(scope.path));
+    const index = await harness.snapshot(IndexDoc, context);
+    if (!index?.projects.some((project) => project.path === normalized)) {
+      throw new Error(`Unknown project: ${scope.path}`);
+    }
+    const info = await stat4(normalized).catch(() => {
+      return;
+    });
+    if (info === undefined || !info.isDirectory()) {
+      throw new Error(`Not a directory: ${normalized}`);
+    }
+    root = normalized;
+    mode = scope.checkout === "worktree" ? "head" : "live";
+  }
+  return lister(root, mode);
+}
+async function listSkills(harness, lister, scope, context) {
+  const skills = await scopeSkills(harness, lister, scope, context);
+  return { skills: skills.map(({ name, description, source }) => ({ name, description, source })) };
+}
+
+// apps/host/src/extensions/context.ts
+var PREAMBLE = "You are PiNomad, a coding agent running on the user's own machine. You work in the project directory below with the read, write, edit, and bash tools: read files before changing them, prefer edit over rewriting whole files, and run commands to check your work. Keep answers short and concrete. When it is unclear what the user wants, ask instead of guessing.";
+var FORK_SHARED_DIR = "This conversation is a fork: it shares this working directory with the conversation it was forked from, which may be editing the same files. If your task needs isolation, create your own git worktree (for example `git worktree add <dir> -b <branch>`) and use absolute paths inside it for every read, write, edit and bash command.";
+function createContext(options) {
+  const { agentsHome } = options;
+  const resolveCheckout = (input, context) => options.checkout?.(input, context);
+  return {
+    extension: defineExtension2({
+      name: "context",
+      sections: [
+        section("preamble", () => PREAMBLE, { tag: false }),
+        section("environment", async (input, context) => {
+          const cwd = input.agent.cwd;
+          if (cwd === undefined)
+            return;
+          const resolved = await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context);
+          const checkout = resolved?.checkout;
+          const forkLine = resolved?.fork === true && checkout?.own !== true ? [FORK_SHARED_DIR] : [];
+          if (checkout === undefined) {
+            return [`Working directory: ${cwd}`, ...forkLine].join(`
+`);
+          }
+          return [
+            `Working directory: ${cwd}`,
+            checkout.own ? `This directory is a git worktree PiNomad created for this conversation, on branch ${checkout.branch} starting from commit ${checkout.base.slice(0, 12)}.` : `This directory is a git worktree PiNomad created for the conversation this one belongs to, on branch ${checkout.branch} starting from commit ${checkout.base.slice(0, 12)}.`,
+            `The user's project directory is ${checkout.projectPath} and must not be modified.`,
+            "This is a fresh checkout: ignored files (dependencies such as node_modules, or .env) are absent — install dependencies per AGENTS.md when needed.",
+            ...forkLine
+          ].join(`
+`);
+        }),
+        section("file_references", () => "When the user writes @./path in their message, it is a project file the user references; the path is relative to your current working directory. Its contents are not expanded for you — read the file yourself if the task needs them.", { tag: false }),
+        section("project_context", async (input, context) => {
+          const cwd = input.agent.cwd;
+          if (cwd === undefined)
+            return;
+          const checkout = (await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context))?.checkout;
+          let files;
+          if (checkout === undefined) {
+            files = loadProjectContextFiles({ cwd, agentDir: agentsHome });
+          } else {
+            const seen = new Set;
+            files = [
+              ...loadProjectContextFiles({ cwd: dirname2(checkout.repo), agentDir: agentsHome }),
+              ...loadProjectContextFiles({ cwd, agentDir: agentsHome }).filter((file) => file.path.startsWith(checkout.worktreeRoot + sep4))
+            ].filter((file) => {
+              if (seen.has(file.path))
+                return false;
+              seen.add(file.path);
+              return true;
+            });
+          }
+          return files.length === 0 ? undefined : files.map((file) => `## ${file.path}
+
+${file.content}`).join(`
+
+`);
+        }),
+        section("skills", (input) => {
+          const cwd = input.agent.cwd;
+          if (cwd === undefined)
+            return;
+          const skills = scopedSkills(cwd, agentsHome).map((scoped) => scoped.skill);
+          const text = formatSkillsForPrompt(skills, "read");
+          return text === "" ? undefined : text;
+        }, { tag: false })
+      ]
+    })
+  };
+}
+
+// apps/host/src/extensions/subagent.ts
+import { clampThinkingLevel as clampThinkingLevel2 } from "@earendil-works/pi-ai";
+import {
+  AgentDoc as AgentDoc4,
+  AssistantEntry,
+  configure as configure2,
+  defineExtension as defineExtension3,
+  defineTool as defineTool2,
+  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({
+  kind: "pinomad.subagent",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({})
+});
+
+// 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 THINKING_LEVELS2 = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+function createSubagent(options) {
+  const available = () => options.modelSummaries().map((model) => `${model.provider}/${model.modelId}`).join(", ");
+  const roles = options.roles ?? (() => []);
+  const roleNamed = (name) => {
+    const found = roles().find((each) => each.name === name);
+    if (found !== undefined)
+      return found;
+    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({
+    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()}.`,
+    parameters: Type3.Object({
+      task: Type3.String({
+        minLength: 1,
+        description: "Complete, self-contained instructions. The subagent sees none of this conversation."
+      }),
+      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."
+      })),
+      description: Type3.Optional(Type3.String({ description: 'A short 3-6 word label for the user, e.g. "Audit auth middleware".' })),
+      model: Type3.Optional(Type3.String({ description: "Optional `provider/modelId` to use instead of yours." })),
+      thinkingLevel: Type3.Optional(Type3.Union(THINKING_LEVELS2.map((level) => Type3.Literal(level)), { description: "Optional thinking level instead of yours." }))
+    }),
+    replay: "safe",
+    execute: async (args, api, 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);
+          return {
+            id: existing.id,
+            ...doc2?.model === undefined ? {} : { model: doc2.model },
+            ...doc2?.startedAt === undefined ? {} : { startedAt: doc2.startedAt }
+          };
+        }
+        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\``);
+        }
+        if (role?.thinkingLevel !== undefined && args.thinkingLevel !== undefined) {
+          throw new Error(`Agent "${role.name}" pins thinking level ${role.thinkingLevel}; omit \`thinkingLevel\``);
+        }
+        const modelString = role?.model ?? args.model;
+        const levelString = role?.thinkingLevel ?? args.thinkingLevel;
+        let model;
+        let thinkingLevel;
+        let override;
+        if (modelString !== undefined) {
+          const slash = modelString.indexOf("/");
+          const provider = slash === -1 ? "" : modelString.slice(0, slash);
+          const modelId = slash === -1 ? "" : modelString.slice(slash + 1);
+          override = provider === "" || modelId === "" ? undefined : options.models.getModel(provider, modelId);
+          const listed = options.modelSummaries().some((each) => each.provider === provider && each.modelId === modelId);
+          if (override === undefined || !listed) {
+            throw new Error(role === undefined ? `Unknown model "${modelString}". Available models: ${available()}` : `Agent "${role.name}" uses model "${modelString}", which is not available. Available models: ${available()}`);
+          }
+          model = { provider, modelId };
+        }
+        if (levelString !== undefined || override !== undefined) {
+          const parent = await tx.doc(AgentDoc4, api.conversationId);
+          const effective = override ?? (parent.model === undefined ? undefined : options.models.getModel(parent.model.provider, parent.model.modelId));
+          if (levelString !== undefined) {
+            thinkingLevel = effective === undefined ? levelString : clampThinkingLevel2(effective, levelString);
+          } else if (parent.thinkingLevel !== undefined) {
+            thinkingLevel = clampThinkingLevel2(override, parent.thinkingLevel);
+          }
+        }
+        const change = {
+          extensions: { remove: [extension, ...options.exclude] },
+          instructions: role === undefined || role.prompt === "" ? INSTRUCTIONS : `${INSTRUCTIONS}
+
+${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 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;
+        if (ref !== undefined)
+          doc.model = `${ref.provider}/${ref.modelId}`;
+        if (role !== undefined)
+          doc.role = role.name;
+        const label = args.description?.trim();
+        if (label !== undefined && label !== "")
+          doc.label = label;
+        return { id: created.id, ...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 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 }
+        }
+      };
+      return result2;
+    }
+  });
+  const extension = defineExtension3({
+    name: "subagent",
+    tools: [tool],
+    sections: [
+      section2("agent_roles", () => {
+        const defined = roles();
+        if (defined.length === 0)
+          return;
+        return [
+          "Named agents: pass one as `role` to `subagent` to delegate to it. When the user writes @name for one of these agents, delegate the relevant work to that agent with `subagent`, putting everything it needs in `task`.",
+          ...defined.map((each) => `- ${each.name}: ${each.description.replace(/\s+/g, " ")}`)
+        ].join(`
+`);
+      })
+    ]
+  });
+  return { extension };
 }
 
+// apps/host/src/extensions/todo.ts
+import { defineDoc as defineDoc5, defineExtension as defineExtension4, defineTool as defineTool3 } from "@earendil-works/pi-durable";
+import { Type as Type4 } from "typebox";
+var TodoDoc = defineDoc5({
+  kind: "todo.list",
+  version: 1,
+  scope: "conversation",
+  history: "rewindable",
+  fork: "asOf",
+  initial: () => ({ items: [] })
+});
+var todoWrite = defineTool3({
+  name: "todo_write",
+  description: "Replace the todo list shown to the user with the given items.",
+  parameters: Type4.Object({ items: Type4.Array(TodoItemSchema) }),
+  replay: "safe",
+  execute: async (args, api, context) => {
+    await api.commit(async (tx) => {
+      const doc = await tx.doc(TodoDoc, api.conversationId);
+      doc.items = args.items.map((item) => ({ ...item }));
+    }, context);
+    return { output: [{ type: "text", text: `Todo list updated: ${args.items.length} item(s).` }] };
+  }
+});
+var todo = {
+  extension: defineExtension4({ name: "todo", tools: [todoWrite] }),
+  docs: [{ token: TodoDoc, presentation: "pinomad.todo" }]
+};
+
+// 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 { createRegistry, Harness } from "@earendil-works/pi-durable";
+import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
+
 // apps/host/src/mcp.ts
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { isAbsolute, resolve as resolve2 } from "node:path";
+import { isAbsolute, resolve as resolve4 } from "node:path";
 import {
   McpAuthRequiredError,
   McpClient,
@@ -1004,7 +1510,7 @@ function parseServer(name, raw, error) {
     const env = expandAll(raw.env, "env", (message) => error(`${name}: ${message}`));
     if (raw.env !== undefined && env === undefined)
       return;
-    const cwd = raw.cwd === undefined ? homedir() : isAbsolute(raw.cwd) ? raw.cwd : resolve2(homedir(), raw.cwd);
+    const cwd = raw.cwd === undefined ? homedir() : isAbsolute(raw.cwd) ? raw.cwd : resolve4(homedir(), raw.cwd);
     return {
       name,
       spec: { kind: "stdio", command: raw.command, args: raw.args, env, cwd },
@@ -1215,9 +1721,9 @@ ${stderr}`;
 
 // apps/host/src/agent-roles.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { existsSync, watch } from "node:fs";
+import { existsSync as existsSync2, watch } from "node:fs";
 import { mkdir as mkdir2, readdir, readFile as readFile2, rename, rm as rm2, writeFile } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
 
 // packages/protocol/src/agents.ts
@@ -1261,7 +1767,7 @@ async function load(dir) {
     const problem = (reason2) => void problems.push({ file, reason: reason2 });
     let parsed;
     try {
-      parsed = parseFrontmatter(await readFile2(join4(dir, file), "utf8"));
+      parsed = parseFrontmatter(await readFile2(join6(dir, file), "utf8"));
     } catch (error) {
       problem(`Couldn't parse the file: ${error instanceof Error ? error.message : String(error)}`);
       continue;
@@ -1319,11 +1825,14 @@ async function openAgentRoles(options) {
   const dir = options.dir;
   await mkdir2(dir, { recursive: true });
   const debounceMs = options.debounceMs ?? 150;
+  const rescanMs = options.rescanMs ?? 1000;
   const published = new Published({ roles: [], problems: [] }, (a, b) => sameList(a.roles, b.roles, sameRole) && sameList(a.problems, b.problems, sameProblem));
   let closed = false;
   let reported = false;
   let timer;
-  const reload = async () => {
+  let queued = false;
+  let chain = Promise.resolve();
+  const loadOnce = async () => {
     try {
       published.set(await load(dir));
       reported = false;
@@ -1333,7 +1842,18 @@ async function openAgentRoles(options) {
       reported = true;
     }
   };
-  await reload();
+  const reload = () => {
+    if (closed)
+      return Promise.resolve();
+    queued = true;
+    chain = chain.then(async () => {
+      if (!queued || closed)
+        return;
+      queued = false;
+      await loadOnce();
+    });
+    return chain;
+  };
   const watcher = watch(dir, () => {
     if (closed)
       return;
@@ -1344,7 +1864,10 @@ async function openAgentRoles(options) {
     if (!reported)
       console.error(`agent-roles watch failed: ${error.message}`);
     reported = true;
+    reload();
   });
+  await reload();
+  const rescan = setInterval(() => void reload(), rescanMs);
   let pending = Promise.resolve();
   const enqueue = (operation) => {
     const run2 = pending.then(operation, operation);
@@ -1356,13 +1879,13 @@ async function openAgentRoles(options) {
     if (problem !== undefined)
       throw new Error(problem);
     await enqueue(async () => {
-      const target = join4(dir, `${role.name}.md`);
-      const exists = existsSync(target);
+      const target = join6(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 = join4(dir, `.${role.name}.${randomBytes2(6).toString("hex")}.tmp`);
+      const temp = join6(dir, `.${role.name}.${randomBytes2(6).toString("hex")}.tmp`);
       try {
         await writeFile(temp, serialize(role));
         await rename(temp, target);
@@ -1383,377 +1906,618 @@ async function openAgentRoles(options) {
     async remove(name) {
       const problem = agentNameProblem(name);
       if (problem !== undefined)
-        throw new Error(problem);
-      await enqueue(async () => {
-        const target = join4(dir, `${name}.md`);
-        if (!existsSync(target))
-          throw new Error(`No such agent: "${name}"`);
-        await rm2(target);
-        await reload();
-      });
-    },
-    close() {
-      closed = true;
-      clearTimeout(timer);
-      watcher.close();
-    }
-  };
-}
-
-// apps/host/src/host.ts
-import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
-import lockfile from "proper-lockfile";
-
-// apps/host/src/gateway.ts
-import { createServer } from "node:http";
-import { homedir as homedir2, networkInterfaces } from "node:os";
-import { join as join7, sep as sep4 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
-import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
-import {
-  AgentDoc as AgentDoc4,
-  LiveDoc
-} from "@earendil-works/pi-durable";
-import { WebSocket, WebSocketServer } from "ws";
-import { Value as Value2 } from "typebox/value";
-
-// apps/host/src/folders.ts
-import { readdir as readdir2, realpath as realpath3, stat as stat3 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join5 } from "node:path";
-var denied = (error) => {
-  const code = error?.code;
-  return code === "EACCES" || code === "EPERM";
-};
-async function listFolders(path, home) {
-  if (path !== undefined && !isAbsolute2(path))
-    throw new Error(`Not an absolute path: ${path}`);
-  const given = path ?? home;
-  const dir = await realpath3(given).catch((error) => {
-    if (denied(error))
-      throw new Error(`Permission denied: ${given}`);
-    throw new Error(`No such directory: ${given}`);
-  });
-  if (!(await stat3(dir)).isDirectory())
-    throw new Error(`Not a directory: ${given}`);
-  let entries;
-  try {
-    entries = await readdir2(dir, { withFileTypes: true });
-  } catch (error) {
-    if (denied(error))
-      throw new Error(`Permission denied: ${given}`);
-    throw error;
-  }
-  const folders = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith("."))
-      continue;
-    let isDirectory = entry.isDirectory();
-    if (!isDirectory && entry.isSymbolicLink()) {
-      isDirectory = await stat3(join5(dir, entry.name)).then((target) => target.isDirectory(), () => false);
-    }
-    if (isDirectory)
-      folders.push({ name: entry.name, path: join5(dir, entry.name) });
-  }
-  folders.sort((a, b) => a.name.localeCompare(b.name, "en", { numeric: true, sensitivity: "base" }));
-  return { path: dir, home: await realpath3(home).catch(() => home), folders };
-}
-
-// apps/host/src/files.ts
-import { spawn as spawn2 } from "node:child_process";
-import { opendir, realpath as realpath4, stat as stat4 } from "node:fs/promises";
-import { join as join6, resolve as resolve3, sep as sep3 } from "node:path";
-import { AgentDoc as AgentDoc3 } from "@earendil-works/pi-durable";
-var CACHE_TTL_MS = 3000;
-var MAX_CACHED_ROOTS = 64;
-var MAX_CONCURRENT_SCANS = 4;
-var SCAN_BUDGET_MS = 5000;
-var MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
-var MAX_WALK_ENTRIES = 20000;
-var MAX_RESULTS = 50;
-var UNUSABLE_PATH = /[\s`\x00-\x1f\x7f-\x9f]/;
-function createCandidateLister(enumerate, options = {}) {
-  const now = options.now ?? Date.now;
-  const ttlMs = options.ttlMs ?? CACHE_TTL_MS;
-  const maxConcurrent = options.maxConcurrent ?? MAX_CONCURRENT_SCANS;
-  const maxCached = options.maxCached ?? MAX_CACHED_ROOTS;
-  const cache = new Map;
-  const inflight = new Map;
-  let running = 0;
-  const waiting = [];
-  return (root, mode) => {
-    const key = `${mode}${root}`;
-    const hit = cache.get(key);
-    if (hit !== undefined) {
-      if (hit.expiresAt > now())
-        return Promise.resolve(hit.value);
-      cache.delete(key);
-    }
-    const pending = inflight.get(key);
-    if (pending !== undefined)
-      return pending;
-    const scan = (async () => {
-      if (running >= maxConcurrent)
-        await new Promise((release) => waiting.push(release));
-      running += 1;
-      try {
-        return await enumerate(root, mode);
-      } finally {
-        running -= 1;
-        waiting.shift()?.();
-      }
-    })();
-    inflight.set(key, scan);
-    scan.then((value) => {
-      const at = now();
-      for (const [cached, entry] of cache) {
-        if (entry.expiresAt <= at)
-          cache.delete(cached);
-      }
-      while (cache.size >= maxCached)
-        cache.delete(cache.keys().next().value);
-      cache.set(key, { value, expiresAt: at + ttlMs });
-    }, () => {});
-    return scan.finally(() => inflight.delete(key));
-  };
-}
-function gitLines(cwd, args, limits) {
-  return new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn2("git", ["-C", cwd, ...args], { stdio: ["ignore", "pipe", "pipe"] });
-    const chunks = [];
-    let bytes = 0;
-    let truncated = false;
-    let settled = false;
-    const kill = (markTruncated) => {
-      truncated ||= markTruncated;
-      child.kill("SIGKILL");
-    };
-    const timer = setTimeout(() => kill(true), Math.max(0, limits.deadline - limits.now()));
-    const finish = (error) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      if (error !== undefined) {
-        rejectPromise(error);
-        return;
-      }
-      const output = Buffer.concat(chunks).toString("utf8");
-      const parts = output.split("\x00");
-      if (truncated)
-        parts.pop();
-      resolvePromise({ lines: parts.filter((part) => part !== ""), truncated });
-    };
-    child.stdout.on("data", (chunk) => {
-      bytes += chunk.length;
-      if (bytes > limits.maxBytes) {
-        kill(true);
-        return;
-      }
-      chunks.push(chunk);
-      if (limits.now() > limits.deadline)
-        kill(true);
-    });
-    child.on("error", (error) => finish(error));
-    child.stderr.resume();
-    child.on("close", (code) => {
-      if (code === 0 || truncated) {
-        finish(undefined);
-      } else {
-        finish(new Error(`git ${args.join(" ")} exited with code ${code}`));
-      }
-    });
-  });
+        throw new Error(problem);
+      await enqueue(async () => {
+        const target = join6(dir, `${name}.md`);
+        if (!existsSync2(target))
+          throw new Error(`No such agent: "${name}"`);
+        await rm2(target);
+        await reload();
+      });
+    },
+    close() {
+      closed = true;
+      clearTimeout(timer);
+      clearInterval(rescan);
+      watcher.close();
+    }
+  };
 }
-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"] });
-    let out = "";
-    child.stdout.on("data", (chunk) => out += chunk.toString("utf8"));
-    child.on("error", () => resolvePromise(false));
-    child.on("close", (code) => resolvePromise(code === 0 && out.trim() === "true"));
+
+// apps/host/src/host.ts
+import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
+import lockfile from "proper-lockfile";
+
+// apps/host/src/gateway.ts
+import { createServer } from "node:http";
+import { homedir as homedir2, networkInterfaces } from "node:os";
+import { join as join8, sep as sep5 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
+import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import {
+  AgentDoc as AgentDoc5,
+  configure as configure3,
+  InboxDoc,
+  LiveDoc
+} from "@earendil-works/pi-durable";
+import { WebSocket, WebSocketServer } from "ws";
+import { Value as Value2 } from "typebox/value";
+
+// apps/host/src/folders.ts
+import { readdir as readdir2, realpath as realpath5, stat as stat5 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join7 } from "node:path";
+var denied = (error) => {
+  const code = error?.code;
+  return code === "EACCES" || code === "EPERM";
+};
+async function listFolders(path, home) {
+  if (path !== undefined && !isAbsolute2(path))
+    throw new Error(`Not an absolute path: ${path}`);
+  const given = path ?? home;
+  const dir = await realpath5(given).catch((error) => {
+    if (denied(error))
+      throw new Error(`Permission denied: ${given}`);
+    throw new Error(`No such directory: ${given}`);
   });
+  if (!(await stat5(dir)).isDirectory())
+    throw new Error(`Not a directory: ${given}`);
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch (error) {
+    if (denied(error))
+      throw new Error(`Permission denied: ${given}`);
+    throw error;
+  }
+  const folders = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    let isDirectory = entry.isDirectory();
+    if (!isDirectory && entry.isSymbolicLink()) {
+      isDirectory = await stat5(join7(dir, entry.name)).then((target) => target.isDirectory(), () => false);
+    }
+    if (isDirectory)
+      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 };
 }
-async function hasHead(root) {
-  return await new Promise((resolvePromise) => {
-    const child = spawn2("git", ["-C", root, "rev-parse", "--verify", "-q", "HEAD"], { stdio: ["ignore", "ignore", "ignore"] });
-    child.on("error", () => resolvePromise(false));
-    child.on("close", (code) => resolvePromise(code === 0));
-  });
+
+// apps/host/src/skill-expansion.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { stripFrontmatter } from "@earendil-works/pi-coding-agent";
+
+// packages/client/src/skill-blocks.ts
+var OPEN = '<skill name="';
+var LOCATION = '" location="';
+var REFERENCES = `">
+References are relative to `;
+var CLOSE = `
+</skill>`;
+var SEPARATOR = `
+
+`;
+function withSkillBlocks(blocks, text) {
+  if (blocks.length === 0)
+    return text;
+  const written = blocks.map((block) => `${OPEN}${block.name}${LOCATION}${block.location}${REFERENCES}${block.baseDir}.
+
+${block.body}${CLOSE}`);
+  return [...written, text].join(SEPARATOR);
 }
-var STAGED_RECORD = /^([0-7]{6}) [0-9a-f]{40,64} [0-7]\t/;
-async function gitWorkingFiles(root, limits) {
-  const listing = await gitLines(root, ["ls-files", "-z", "-s", "--cached", "--others", "--exclude-standard"], limits);
-  const deleted = await gitLines(root, ["ls-files", "-z", "--deleted"], limits);
-  const gone = new Set(deleted.lines);
-  const files = new Set;
-  for (const line of listing.lines) {
-    const staged = STAGED_RECORD.exec(line);
-    const path = staged === null ? line : line.slice(staged[0].length);
-    if (staged !== null && staged[1] === "160000")
-      continue;
-    if (path === "" || path.endsWith("/") || gone.has(path))
-      continue;
-    files.add(path);
+var isNameUnit = (unit) => unit >= 48 && unit <= 57 || unit >= 97 && unit <= 122 || unit === 45;
+function blockEnd(text, at) {
+  if (!text.startsWith(OPEN, at))
+    return -1;
+  let i = at + OPEN.length;
+  const name = i;
+  while (i < text.length && isNameUnit(text.charCodeAt(i)))
+    i += 1;
+  if (i === name || !text.startsWith(LOCATION, i))
+    return -1;
+  i += LOCATION.length;
+  const location = i;
+  while (i < text.length && text[i] !== '"' && text[i] !== `
+`)
+    i += 1;
+  if (i === location || !text.startsWith(REFERENCES, i))
+    return -1;
+  i += REFERENCES.length;
+  const lineEnd = text.indexOf(`
+`, i);
+  if (lineEnd - i < 2 || text[lineEnd - 1] !== "." || text[lineEnd + 1] !== `
+`)
+    return -1;
+  const close = text.indexOf(CLOSE, lineEnd + 1);
+  return close === -1 ? -1 : close + CLOSE.length;
+}
+function stripSkillPrefix(text) {
+  const skills = [];
+  let at = 0;
+  for (;; ) {
+    const end = blockEnd(text, at);
+    if (end === -1 || !text.startsWith(SEPARATOR, end) || end + SEPARATOR.length === text.length) {
+      return { text: text.slice(at), skills };
+    }
+    skills.push(text.slice(at + OPEN.length, text.indexOf('"', at + OPEN.length)));
+    at = end + SEPARATOR.length;
   }
-  return { files: [...files], truncated: listing.truncated || deleted.truncated };
 }
-async function gitHeadFiles(root, limits) {
-  const listing = await gitLines(root, ["ls-tree", "-r", "-z", "HEAD"], limits);
-  const files = [];
-  for (const line of listing.lines) {
-    const tab = line.indexOf("\t");
-    if (tab === -1)
+function stripUserBlocks(content) {
+  const attachments = [];
+  let joined = "";
+  if (typeof content === "string") {
+    joined = content;
+  } else {
+    for (const block of content) {
+      if (block.type !== "text" || typeof block.text !== "string")
+        continue;
+      const files = parseAttachmentBlock(block.text);
+      if (files !== undefined)
+        attachments.push(...files);
+      else
+        joined += block.text;
+    }
+  }
+  const typed = stripSkillPrefix(joined);
+  return { text: typed.text, skills: typed.skills, attachments };
+}
+
+// packages/client/src/skill-mentions.ts
+var WHITESPACE = /\p{White_Space}/u;
+var WORD_CHAR = /[\p{Alphabetic}\p{N}_$]/u;
+var isNameUnit2 = (unit) => unit >= 48 && unit <= 57 || unit >= 97 && unit <= 122 || unit === 45;
+function skillMentionRanges(text, names) {
+  const known = new Set(names);
+  const ranges = [];
+  for (let i = 0;i < text.length; i += 1) {
+    if (text.charCodeAt(i) !== 36)
       continue;
-    const kind = line.slice(0, tab).split(" ")[1];
-    if (kind === "blob")
-      files.push(line.slice(tab + 1));
+    if (i > 0 && !WHITESPACE.test(text[i - 1]))
+      continue;
+    let end = i + 1;
+    while (end < text.length && isNameUnit2(text.charCodeAt(end)))
+      end += 1;
+    if (!known.has(text.slice(i + 1, end)))
+      continue;
+    if (end < text.length && WORD_CHAR.test(String.fromCodePoint(text.codePointAt(end))))
+      continue;
+    ranges.push({ start: i, end });
   }
-  return { files, truncated: listing.truncated };
+  return ranges;
 }
-async function walkFiles(root, limits) {
-  const files = [];
-  let entries = 0;
-  let truncated = false;
-  const dirs = [{ dir: root, prefix: "" }];
-  while (dirs.length > 0) {
-    if (limits.now() > limits.deadline) {
-      truncated = true;
-      break;
+
+// apps/host/src/skill-expansion.ts
+function mentionedSkillNames(text, names) {
+  return [...new Set(skillMentionRanges(text, names).map((range) => text.slice(range.start + 1, range.end)))];
+}
+async function expandSkills(text, names, skills) {
+  const byName = new Map(skills.map((skill) => [skill.name, skill]));
+  const blocks = [];
+  const missing = [];
+  const failures = [];
+  for (const name of new Set(names)) {
+    const skill = byName.get(name);
+    if (skill === undefined) {
+      missing.push(name);
+      continue;
     }
-    const { dir, prefix } = dirs.pop();
-    let handle;
     try {
-      handle = await opendir(dir);
+      const body = stripFrontmatter(await readFile3(skill.filePath, "utf8")).trim();
+      blocks.push({ name, location: skill.filePath, baseDir: skill.baseDir, body });
     } catch (error) {
-      if (prefix === "")
-        throw error;
-      truncated = true;
-      continue;
+      failures.push({ name, filePath: skill.filePath, message: error instanceof Error ? error.message : String(error) });
     }
-    for await (const entry of handle) {
-      if (entries++ >= limits.maxEntries || limits.now() > limits.deadline) {
-        truncated = true;
-        break;
-      }
-      if (entry.isDirectory()) {
-        if (entry.name.startsWith(".") || entry.name === "node_modules")
-          continue;
-        dirs.push({ dir: join6(dir, entry.name), prefix: `${prefix}${entry.name}/` });
-      } else if (entry.isFile() || entry.isSymbolicLink()) {
-        files.push(`${prefix}${entry.name}`);
-      }
+  }
+  return { text: withSkillBlocks(blocks, text), missing, failures };
+}
+
+// apps/host/src/commands.ts
+var BUILTIN_COMMANDS = [
+  {
+    info: {
+      name: "compact",
+      description: "Summarize older context to free up space",
+      argumentHint: "[instructions]",
+      source: "builtin"
+    },
+    run: async (target, args) => {
+      await target.compact(args?.trim() || undefined);
     }
-    if (truncated)
-      break;
   }
-  return { files, truncated };
+];
+function listCommands() {
+  return { commands: BUILTIN_COMMANDS.map((command) => command.info) };
 }
-async function enumerateRoot(root, mode, limits = {}) {
-  const now = limits.now ?? Date.now;
-  const bounded = {
-    now,
-    deadline: now() + (limits.budgetMs ?? SCAN_BUDGET_MS),
-    maxBytes: limits.maxBytes ?? MAX_OUTPUT_BYTES,
-    maxEntries: limits.maxEntries ?? MAX_WALK_ENTRIES
-  };
-  if (!await inWorkTree(root)) {
-    return walkFiles(root, bounded);
+async function runCommand(target, name, args) {
+  const command = BUILTIN_COMMANDS.find((candidate) => candidate.info.name === name);
+  if (command === undefined)
+    throw new Error(`Unknown command: /${name}`);
+  await command.run(target, args);
+}
+
+// packages/protocol/src/images.ts
+var IMAGE_MIME_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+var REF_ENCODER = new TextEncoder;
+var MAX_IMAGES_PER_MESSAGE = 4;
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+function imageProblem(images) {
+  if (images.length > MAX_IMAGES_PER_MESSAGE)
+    return `At most ${MAX_IMAGES_PER_MESSAGE} images per message`;
+  for (let i = 0;i < images.length; i++) {
+    const image = images[i];
+    if (!IMAGE_MIME_TYPES.includes(image.mimeType)) {
+      return `Unsupported image type: ${image.mimeType} (use JPEG, PNG, GIF or WebP)`;
+    }
+    if (image.data === "" || image.data.length % 4 !== 0 || !BASE64.test(image.data)) {
+      return `Image ${i + 1} is not valid base64`;
+    }
+    const padding = image.data.endsWith("==") ? 2 : image.data.endsWith("=") ? 1 : 0;
+    if (image.data.length * 3 / 4 - padding > MAX_IMAGE_BYTES)
+      return `Image ${i + 1} is larger than 5 MB`;
   }
-  if (mode === "head" && !await hasHead(root)) {
-    return walkFiles(root, bounded);
+  return;
+}
+
+// apps/host/src/image-refs.ts
+import { createHash } from "node:crypto";
+import { applyImmutable } from "@earendil-works/chord/delta";
+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) {
+  let ref = hashed.get(block);
+  if (ref === undefined) {
+    ref = createHash("sha256").update(block.mimeType).update(`
+`).update(block.data).digest("hex");
+    hashed.set(block, ref);
   }
-  return mode === "head" ? gitHeadFiles(root, bounded) : gitWorkingFiles(root, bounded);
+  return ref;
 }
-function matchFiles(candidates, query, max = MAX_RESULTS) {
-  const usable = candidates.filter((path) => !UNUSABLE_PATH.test(path));
-  if (query === "") {
-    const sorted = [...usable].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-    return { files: sorted.slice(0, max), truncated: sorted.length > max };
+function slotAt(path) {
+  if (path[0] === "entries") {
+    if (path.length === 1)
+      return "entries";
+    if (path.length === 2 && typeof path[1] === "number")
+      return "entry";
+    if (path.length === 3 && typeof path[1] === "number" && path[2] === "model")
+      return "messages";
+    if (path.length === 4 && typeof path[1] === "number" && path[2] === "model" && typeof path[3] === "number")
+      return "message";
+    if (path.length === 5 && typeof path[1] === "number" && path[2] === "model" && typeof path[3] === "number" && path[4] === "content")
+      return "content";
+    if (path.length === 6 && typeof path[1] === "number" && path[2] === "model" && typeof path[3] === "number" && path[4] === "content" && typeof path[5] === "number")
+      return "block";
+    return "none";
   }
-  const needle = query.toLowerCase();
-  const tiers = [[], [], []];
-  for (const path of usable) {
-    const base = path.slice(path.lastIndexOf("/") + 1).toLowerCase();
-    const lower = path.toLowerCase();
-    if (base.startsWith(needle))
-      tiers[0].push(path);
-    else if (base.includes(needle))
-      tiers[1].push(path);
-    else if (lower.includes(needle))
-      tiers[2].push(path);
+  if (path[0] !== "docs")
+    return "none";
+  if (path.length === 1)
+    return "docs";
+  if (path[1] === "pi.inbox") {
+    if (path.length === 2)
+      return "inbox";
+    if (path.length === 3 && path[2] === "items")
+      return "items";
+    if (path.length === 4 && path[2] === "items" && typeof path[3] === "number")
+      return "item";
+    if (path.length === 5 && path[2] === "items" && typeof path[3] === "number" && path[4] === "content")
+      return "content";
+    if (path.length === 6 && path[2] === "items" && typeof path[3] === "number" && path[4] === "content" && typeof path[5] === "number")
+      return "block";
+    return "none";
   }
-  const shorter = (a, b) => a.length - b.length || (a < b ? -1 : a > b ? 1 : 0);
-  const matched = [...tiers[0].sort(shorter), ...tiers[1].sort(shorter), ...tiers[2].sort(shorter)];
-  return { files: matched.slice(0, max), truncated: matched.length > max };
+  if (path[1] === "pi.live") {
+    if (path.length === 2)
+      return "live";
+    if (path.length === 3 && path[2] === "generation")
+      return "generation";
+    if (path.length === 4 && path[2] === "generation" && path[3] === "message")
+      return "message";
+    if (path.length === 5 && path[2] === "generation" && path[3] === "message" && path[4] === "content")
+      return "content";
+    if (path.length === 6 && path[2] === "generation" && path[3] === "message" && path[4] === "content" && typeof path[5] === "number")
+      return "block";
+    return "none";
+  }
+  return "none";
 }
-async function listFiles(harness, dataDir, enumerate, scope, query, context) {
-  let root;
-  let mode = "live";
-  if (scope.kind === "conversation") {
-    const agent = await harness.snapshot(AgentDoc3, scope.conversationId, context);
-    if (agent === undefined)
-      throw new Error(`Conversation ${scope.conversationId} does not exist`);
-    const cwd = agent.cwd;
-    if (cwd === undefined)
-      throw new Error(`Conversation ${scope.conversationId} has no checkout`);
-    if (cwd.startsWith(join6(dataDir, "chats") + sep3))
-      return { files: [], truncated: false };
-    const info = await stat4(cwd).catch(() => {
-      return;
-    });
-    if (info === undefined || !info.isDirectory()) {
-      throw new Error(`Conversation ${scope.conversationId}'s checkout is unavailable: ${cwd}`);
+function withRef(block) {
+  const ref = refOf(block);
+  const { data: _data, ...rest } = block;
+  return { ...rest, ref };
+}
+var HASH_YIELD_BYTES = 8 * 1024 * 1024;
+var yieldToEventLoop = () => new Promise((resolve5) => setImmediate(resolve5));
+async function hashBlocks(blocks) {
+  let bytes = 0;
+  for (const block of blocks) {
+    if (hashed.has(block))
+      continue;
+    if (bytes >= HASH_YIELD_BYTES) {
+      bytes = 0;
+      await yieldToEventLoop();
+    }
+    refOf(block);
+    bytes += block.data.length;
+  }
+}
+function rewriteEntries(value) {
+  if (!Array.isArray(value))
+    return value;
+  let out;
+  for (let i = 0;i < value.length; i++) {
+    const next = rewriteEntry(value[i]);
+    if (next !== value[i])
+      (out ??= value.slice())[i] = next;
+  }
+  return out ?? value;
+}
+function rewriteEntry(value) {
+  if (!isObject2(value) || value.model === undefined)
+    return value;
+  const model = rewriteMessages(value.model);
+  return model === value.model ? value : { ...value, model };
+}
+function rewriteMessages(value) {
+  if (!Array.isArray(value))
+    return value;
+  let out;
+  for (let i = 0;i < value.length; i++) {
+    const next = rewriteMessage(value[i]);
+    if (next !== value[i])
+      (out ??= value.slice())[i] = next;
+  }
+  return out ?? value;
+}
+function rewriteMessage(value) {
+  if (!isObject2(value) || value.content === undefined)
+    return value;
+  const content = rewriteContent(value.content);
+  return content === value.content ? value : { ...value, content };
+}
+function rewriteContent(value) {
+  if (!Array.isArray(value))
+    return value;
+  let out;
+  for (let i = 0;i < value.length; i++) {
+    const block = value[i];
+    const next = isObject2(block) && isImageBlock(block) ? withRef(block) : block;
+    if (next !== block)
+      (out ??= value.slice())[i] = next;
+  }
+  return out ?? value;
+}
+function rewriteItems(value) {
+  if (!Array.isArray(value))
+    return value;
+  let out;
+  for (let i = 0;i < value.length; i++) {
+    const next = rewriteItem(value[i]);
+    if (next !== value[i])
+      (out ??= value.slice())[i] = next;
+  }
+  return out ?? value;
+}
+function rewriteItem(value) {
+  if (!isObject2(value) || value.content === undefined)
+    return value;
+  const content = rewriteContent(value.content);
+  return content === value.content ? value : { ...value, content };
+}
+function rewriteInbox(value) {
+  if (!isObject2(value) || value.items === undefined)
+    return value;
+  const items = rewriteItems(value.items);
+  return items === value.items ? value : { ...value, items };
+}
+function rewriteGeneration(value) {
+  if (!isObject2(value) || value.message === undefined)
+    return value;
+  const message = rewriteMessage(value.message);
+  return message === value.message ? value : { ...value, message };
+}
+function rewriteLive(value) {
+  if (!isObject2(value) || value.generation === undefined)
+    return value;
+  const generation = rewriteGeneration(value.generation);
+  return generation === value.generation ? value : { ...value, generation };
+}
+function rewriteDocs(value) {
+  if (!isObject2(value))
+    return value;
+  let out;
+  for (const key of ["pi.inbox", "pi.live"]) {
+    const doc = value[key];
+    if (doc === undefined)
+      continue;
+    const next = key === "pi.inbox" ? rewriteInbox(doc) : rewriteLive(doc);
+    if (next !== doc)
+      (out ??= { ...value })[key] = next;
+  }
+  return out ?? value;
+}
+function rewriteView(value) {
+  if (!isObject2(value))
+    return value;
+  let out;
+  if (value.entries !== undefined) {
+    const entries = rewriteEntries(value.entries);
+    if (entries !== value.entries)
+      (out ??= { ...value }).entries = entries;
+  }
+  if (value.docs !== undefined) {
+    const docs = rewriteDocs(value.docs);
+    if (docs !== value.docs)
+      (out ??= { ...value }).docs = docs;
+  }
+  return out ?? value;
+}
+function rewriteSlot(slot, value) {
+  switch (slot) {
+    case "entries":
+      return rewriteEntries(value);
+    case "entry":
+      return rewriteEntry(value);
+    case "messages":
+      return rewriteMessages(value);
+    case "message":
+      return rewriteMessage(value);
+    case "content":
+      return rewriteContent(value);
+    case "block":
+      return isObject2(value) && isImageBlock(value) ? withRef(value) : value;
+    case "docs":
+      return rewriteDocs(value);
+    case "inbox":
+      return rewriteInbox(value);
+    case "items":
+      return rewriteItems(value);
+    case "item":
+      return rewriteItem(value);
+    case "live":
+      return rewriteLive(value);
+    case "generation":
+      return rewriteGeneration(value);
+    default:
+      return value;
+  }
+}
+function rewriteOp(op) {
+  switch (op[0]) {
+    case "r": {
+      const value = rewriteView(op[1]);
+      return value === op[1] ? op : ["r", value];
+    }
+    case "s": {
+      const slot = slotAt(op[1]);
+      if (slot === "none")
+        return op;
+      const value = rewriteSlot(slot, op[2]);
+      return value === op[2] ? op : ["s", op[1], value];
     }
-    root = cwd;
-  } else {
-    const normalized = await realpath4(resolve3(scope.path)).catch(() => resolve3(scope.path));
-    const index = await harness.snapshot(IndexDoc, context);
-    if (!index?.projects.some((project) => project.path === normalized)) {
-      throw new Error(`Unknown project: ${scope.path}`);
+    case "p": {
+      const path = op[1];
+      const start = op[2];
+      let items;
+      for (let i = 0;i < op[4].length; i++) {
+        const item = op[4][i];
+        const slot = slotAt([...path, start + i]);
+        const next = slot === "none" ? item : rewriteSlot(slot, item);
+        if (next !== item)
+          (items ??= op[4].slice())[i] = next;
+      }
+      return items === undefined ? op : ["p", op[1], op[2], op[3], items];
     }
-    const info = await stat4(normalized).catch(() => {
+    default:
+      return op;
+  }
+}
+function resolve5(root, path, length) {
+  let node = root;
+  for (let i = 0;i < length; i++) {
+    if (node === null || typeof node !== "object")
       return;
-    });
-    if (info === undefined || !info.isDirectory()) {
-      throw new Error(`Not a directory: ${normalized}`);
+    node = node[path[i]];
+  }
+  return node;
+}
+function reachesIntoImage(op, root) {
+  if (op[0] === "r" || op[0] === "m")
+    return false;
+  const path = op[1];
+  const depth = op[0] === "p" ? path.length : path.length - 1;
+  for (let length = 1;length <= depth; length++) {
+    if (slotAt(path.slice(0, length)) !== "block")
+      continue;
+    const node = resolve5(root, path, length);
+    if (isObject2(node) && isImageBlock(node))
+      return true;
+  }
+  return false;
+}
+function* contentArrays(view) {
+  if (!isObject2(view))
+    return;
+  if (Array.isArray(view.entries)) {
+    for (const entry of view.entries) {
+      if (!isObject2(entry) || !Array.isArray(entry.model))
+        continue;
+      for (const message of entry.model) {
+        if (isObject2(message) && Array.isArray(message.content))
+          yield message.content;
+      }
     }
-    root = normalized;
-    mode = scope.checkout === "worktree" ? "head" : "live";
   }
-  const candidates = await enumerate(root, mode);
-  const matched = matchFiles(candidates.files, query);
-  return { files: matched.files, truncated: matched.truncated || candidates.truncated };
+  if (!isObject2(view.docs))
+    return;
+  const inbox = view.docs["pi.inbox"];
+  if (isObject2(inbox) && Array.isArray(inbox.items)) {
+    for (const item of inbox.items) {
+      if (isObject2(item) && Array.isArray(item.content))
+        yield item.content;
+    }
+  }
+  const live = view.docs["pi.live"];
+  if (isObject2(live) && isObject2(live.generation) && isObject2(live.generation.message) && Array.isArray(live.generation.message.content)) {
+    yield live.generation.message.content;
+  }
 }
-
-// packages/protocol/src/images.ts
-var IMAGE_MIME_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
-var MAX_IMAGES_PER_MESSAGE = 4;
-var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
-var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
-function imageProblem(images) {
-  if (images.length > MAX_IMAGES_PER_MESSAGE)
-    return `At most ${MAX_IMAGES_PER_MESSAGE} images per message`;
-  for (let i = 0;i < images.length; i++) {
-    const image = images[i];
-    if (!IMAGE_MIME_TYPES.includes(image.mimeType)) {
-      return `Unsupported image type: ${image.mimeType} (use JPEG, PNG, GIF or WebP)`;
+function imageBlocks(view) {
+  const blocks = [];
+  for (const content of contentArrays(view)) {
+    for (const block of content) {
+      if (isObject2(block) && isImageBlock(block))
+        blocks.push(block);
     }
-    if (image.data === "" || image.data.length % 4 !== 0 || !BASE64.test(image.data)) {
-      return `Image ${i + 1} is not valid base64`;
+  }
+  return blocks;
+}
+function findImage(view, ref) {
+  for (const block of imageBlocks(view)) {
+    if (refOf(block) === ref) {
+      return { data: block.data, mimeType: block.mimeType };
     }
-    const padding = image.data.endsWith("==") ? 2 : image.data.endsWith("=") ? 1 : 0;
-    if (image.data.length * 3 / 4 - padding > MAX_IMAGE_BYTES)
-      return `Image ${i + 1} is larger than 5 MB`;
   }
   return;
 }
 
+class ImageRefs {
+  async value(view) {
+    const blocks = imageBlocks(view);
+    if (blocks.length > 0)
+      await hashBlocks(blocks);
+    return rewriteView(view);
+  }
+  image(view, ref) {
+    return findImage(view, ref);
+  }
+  async ops(ops, before) {
+    let state = before;
+    let touched = false;
+    for (const op of ops) {
+      if (!touched && reachesIntoImage(op, state))
+        touched = true;
+      state = applyImmutable(state, [op]);
+    }
+    if (touched) {
+      await hashBlocks(imageBlocks(state));
+      return [["r", rewriteView(state)]];
+    }
+    if (ops.some((op) => op[0] === "r"))
+      await hashBlocks(imageBlocks(state));
+    return ops.map(rewriteOp);
+  }
+}
+
 // apps/host/src/auto-title.ts
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 
 // apps/host/src/title-doc.ts
-import { defineDoc as defineDoc5 } from "@earendil-works/pi-durable";
-var TitleDoc = defineDoc5({
+import { defineDoc as defineDoc6 } from "@earendil-works/pi-durable";
+var TitleDoc = defineDoc6({
   kind: "pinomad.title",
   version: 1,
   scope: "conversation",
@@ -1822,7 +2586,8 @@ function attachAutoTitle(runs, deps) {
       const model = ref === null ? undefined : deps.models.getModel(ref.provider, ref.modelId);
       if (model === undefined)
         return;
-      const firstText = (textOf(first.model?.[0] !== undefined ? first.model[0].content : "") || "(images only)").slice(0, TITLE_INPUT_LIMIT);
+      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 request = {
         systemPrompt: TITLE_PROMPT,
@@ -1869,9 +2634,9 @@ ${answer}`}`,
 }
 
 // apps/host/src/push.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
-import { defineDoc as defineDoc6 } from "@earendil-works/pi-durable";
+import { defineDoc as defineDoc7 } from "@earendil-works/pi-durable";
 
 // packages/client/src/family.ts
 var SUBAGENT_TASK_PREFIX = /^\s*in the working directory\s+\S+,\s*/i;
@@ -1929,7 +2694,7 @@ function diffRunNotices(previous, organized) {
 
 // apps/host/src/push.ts
 var context2 = BACKGROUND_CONTEXT2;
-var PushDoc = defineDoc6({
+var PushDoc = defineDoc7({
   kind: "pinomad.push",
   version: 2,
   scope: "session",
@@ -2012,7 +2777,7 @@ var realTimers = {
   clearTimeout: (handle) => clearTimeout(handle)
 };
 var tokenHint = (token) => `…${token.slice(-6)}`;
-var collapseId = (hostKey, id) => createHash("sha256").update(`${hostKey}:${id}`).digest("hex").slice(0, 32);
+var collapseId = (hostKey, id) => createHash2("sha256").update(`${hostKey}:${id}`).digest("hex").slice(0, 32);
 async function attachPushSender(options) {
   const { harness, conversations } = options;
   const transport = options.transport ?? UNAVAILABLE_TRANSPORT;
@@ -2062,7 +2827,7 @@ async function attachPushSender(options) {
       return named;
     if (notice.body !== "Finished" || disposed)
       return FALLBACK_TITLE;
-    return await new Promise((resolve4) => {
+    return await new Promise((resolve6) => {
       const waiters = titleWaiters.get(notice.id) ?? new Set;
       titleWaiters.set(notice.id, waiters);
       const settle = (title) => {
@@ -2070,7 +2835,7 @@ async function attachPushSender(options) {
         if (waiters.size === 0)
           titleWaiters.delete(notice.id);
         timers.clearTimeout(timer);
-        resolve4(title);
+        resolve6(title);
       };
       const timer = timers.setTimeout(() => settle(FALLBACK_TITLE), TITLE_WAIT_MS);
       waiters.add(settle);
@@ -2270,6 +3035,28 @@ function toolTarget(args) {
 // apps/host/src/gateway.ts
 var context3 = BACKGROUND_CONTEXT3;
 var forkTails = new WeakMap;
+function assertQueuedInput(record, conversationId) {
+  if (record.conversationId !== conversationId) {
+    throw new Error(`Submission ${record.id} belongs to another conversation`);
+  }
+  if (record.type !== "input")
+    throw new Error(`Submission ${record.id} is a write, not a message`);
+}
+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))
+      continue;
+    for (const request of value.requests) {
+      if (request.resolution === undefined) {
+        request.resolution = { outcome: "dismissed", at: Date.now() };
+        dismissed = true;
+      }
+    }
+  }
+  return dismissed;
+}
 function serializedFork(harness, work) {
   const next = (forkTails.get(harness) ?? Promise.resolve()).then(work, work);
   const settled = next.then(() => {}, () => {});
@@ -2284,6 +3071,7 @@ var LOOPBACK_SECURE_PATH = "/secure";
 async function startGateway(options) {
   const conversations = await ConversationList.open(options.harness, options.docs);
   const fileLister = createCandidateLister(enumerateRoot);
+  const skillLister = createSkillLister((root, mode) => enumerateSkills(root, mode, options.agentsHome));
   const detachAutoTitle = options.autoTitle === false ? undefined : attachAutoTitle(conversations, {
     harness: options.harness,
     models: options.models,
@@ -2296,12 +3084,12 @@ async function startGateway(options) {
       response.end();
     });
   });
-  const server = new WebSocketServer({ server: http });
-  await new Promise((resolve4, reject) => {
-    http.once("listening", resolve4);
+  await new Promise((resolve6, reject) => {
+    http.once("listening", resolve6);
     http.once("error", reject);
     http.listen(options.port, "127.0.0.1");
   });
+  const server = new WebSocketServer({ server: http });
   const { port } = http.address();
   const browserOrigins = [...options.browserOrigins ?? [], `http://127.0.0.1:${port}`];
   const clients = new Set;
@@ -2315,7 +3103,7 @@ async function startGateway(options) {
     if (joined?.source === "account") {
       broadcast("info", `New device "${joined.name}" joined through your account`);
     }
-    const client = new GatewayClient(connection, options, conversations, fileLister, {
+    const client = new GatewayClient(connection, options, conversations, fileLister, skillLister, {
       devicePublicKey,
       closed: (self) => {
         clients.delete(self);
@@ -2375,7 +3163,11 @@ async function startGateway(options) {
     }
     register(tokenConnection(socket));
   });
-  remote = await startRemote(options, admission, register);
+  remote = await startRemote(options, admission, register).catch(async (error) => {
+    await new Promise((resolve6) => server.close(() => resolve6()));
+    await new Promise((resolve6) => http.close(() => resolve6()));
+    throw error;
+  });
   const secure = options.secure;
   const detachSettingsWatch = options.settings.subscribe((settings) => {
     if (!settings.acceptAccountDevices)
@@ -2447,8 +3239,8 @@ async function startGateway(options) {
       for (const socket of server.clients)
         socket.terminate();
       await remote?.close();
-      await new Promise((resolve4) => server.close(() => resolve4()));
-      await new Promise((resolve4) => http.close(() => resolve4()));
+      await new Promise((resolve6) => server.close(() => resolve6()));
+      await new Promise((resolve6) => http.close(() => resolve6()));
     }
   };
 }
@@ -2457,7 +3249,7 @@ function tokenConnection(socket) {
     get open() {
       return socket.readyState === WebSocket.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve4) => socket.send(text, () => resolve4())) : Promise.resolve(),
+    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve6) => socket.send(text, () => resolve6())) : Promise.resolve(),
     close: (code, reason) => socket.close(code, reason),
     handle(handlers) {
       socket.on("message", (data) => handlers.message(String(data)));
@@ -2470,9 +3262,9 @@ function secureConnection(socket, session) {
     get open() {
       return socket.readyState === WebSocket.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve4) => {
+    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve6) => {
       const chunks = session.seal(text);
-      chunks.forEach((chunk, index) => socket.send(chunk, index === chunks.length - 1 ? () => resolve4() : undefined));
+      chunks.forEach((chunk, index) => socket.send(chunk, index === chunks.length - 1 ? () => resolve6() : undefined));
     }) : Promise.resolve(),
     close: (code, reason) => socket.close(code, reason),
     handle(handlers) {
@@ -2575,13 +3367,13 @@ async function startRemote(options, admission, register) {
       response.end();
     });
   });
-  const secure = new WebSocketServer({ server: http });
-  secure.on("connection", (socket) => secureHandshake(socket, spec, admission, register));
   await new Promise((resolveListen, reject) => {
     http.once("listening", resolveListen);
     http.once("error", reject);
     http.listen(remote.port, "0.0.0.0");
   });
+  const secure = new WebSocketServer({ server: http });
+  secure.on("connection", (socket) => secureHandshake(socket, spec, admission, register));
   const { port } = http.address();
   const url = `ws://127.0.0.1:${port}`;
   const advertiseUrl = remote.publicUrl?.replace(/\/+$/, "") ?? `http://${pickLanAddress(networkInterfaces()) ?? "127.0.0.1"}:${port}`;
@@ -2591,8 +3383,8 @@ async function startRemote(options, admission, register) {
     async close() {
       for (const socket of secure.clients)
         socket.terminate();
-      await new Promise((resolve4) => secure.close(() => resolve4()));
-      await new Promise((resolve4) => http.close(() => resolve4()));
+      await new Promise((resolve6) => secure.close(() => resolve6()));
+      await new Promise((resolve6) => http.close(() => resolve6()));
     }
   };
 }
@@ -2658,6 +3450,7 @@ class ConversationList {
       if (typeof subagent?.role === "string" && subagent.role !== "")
         facts.role = subagent.role;
     }
+    facts.agent = roleNameOf(await harness.snapshot(RoleDoc, record.id, context3));
     const named = (await harness.snapshot(TitleDoc, record.id, context3))?.title;
     if (typeof named === "string" && named !== "")
       facts.named = named;
@@ -2714,6 +3507,9 @@ class ConversationList {
             next.delete(change.record.kind);
           facts.pending = next;
           touched.add(id);
+        } else if (change.record.kind === RoleDoc.definition.kind) {
+          facts.agent = roleNameOf(change.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;
@@ -2746,7 +3542,10 @@ class ConversationList {
   }
   #summaryOf(record) {
     const facts = this.#fact(record.id);
-    return summaryOf(record, facts, record.owner === undefined ? topLevelRole(record, this.#records, this.#roles) : facts.role);
+    if (record.owner !== undefined)
+      return summaryOf(record, facts, facts.role, facts.role ?? null);
+    const role = topLevelRole(record, this.#records, this.#roles);
+    return summaryOf(record, facts, role, (facts.agent === undefined ? role : facts.agent) ?? null);
   }
   #refreshSummaries(touched) {
     let next;
@@ -2797,6 +3596,11 @@ class ConversationList {
     this.#listeners.clear();
   }
 }
+function roleNameOf(value) {
+  if (value === null || value === undefined)
+    return;
+  return typeof value.name === "string" ? value.name : value.name === null ? null : undefined;
+}
 function rolesOf(index) {
   const roles = new Map;
   for (const entry of index?.conversations ?? []) {
@@ -2816,7 +3620,7 @@ function topLevelRole(record, records, roles) {
   }
   return;
 }
-function summaryOf(record, facts, role) {
+function summaryOf(record, facts, role, currentAgent) {
   const parent = record.parent?.conversationId ?? record.owner?.conversationId;
   const status = facts.pending.size > 0 ? "needs-answer" : facts.running === true ? "running" : facts.failed === true ? "failed" : undefined;
   const runningSlot = facts.running === true ? facts.tools?.find((slot) => slot.status === "running") : undefined;
@@ -2834,18 +3638,18 @@ function summaryOf(record, facts, role) {
     ...facts.updatedAt === undefined ? {} : { updatedAt: facts.updatedAt },
     ...facts.label === undefined ? {} : { label: facts.label },
     ...role === undefined ? {} : { role },
+    currentAgent,
     ...activity === undefined ? {} : { activity }
   };
 }
 function sameSummary(a, b) {
-  return a.id === b.id && a.kind === b.kind && 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.activity?.tool === b.activity?.tool && a.activity?.target === b.activity?.target;
+  return a.id === b.id && a.kind === b.kind && 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")
     return {};
-  const text = typeof message.content === "string" ? message.content : message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join(" ");
-  const title = text.replace(/\s+/g, " ").trim();
+  const title = stripUserBlocks(message.content).text.replace(/\s+/g, " ").trim();
   return title === "" ? {} : { title };
 }
 async function historyFacts(harness, id) {
@@ -2890,13 +3694,15 @@ class GatewayClient {
   #hooks;
   #options;
   #files;
+  #skills;
   #hostValues;
   #subscriptions = new Map;
   #disposed = false;
-  constructor(connection, options, conversations, files, hooks) {
+  constructor(connection, options, conversations, files, skills, hooks) {
     this.#connection = connection;
     this.#options = options;
     this.#files = files;
+    this.#skills = skills;
     this.#hostValues = {
       conversations,
       mcp: options.mcp ?? constantValue(null),
@@ -2961,15 +3767,15 @@ class GatewayClient {
   }
   async#receive(frame) {
     if (frame.type === "subscribe")
-      await this.#subscribe(frame.stream);
+      await this.#subscribe(frame.stream, frame.images === "ref");
     else if (frame.type === "unsubscribe")
       await this.#unsubscribe(frame.stream);
     else
       await this.#answer(frame.id, frame.method, frame.args);
   }
-  async#subscribe(stream) {
+  async#subscribe(stream, imageRefs) {
     const previous = this.#subscriptions.get(stream);
-    const state = {};
+    const state = imageRefs && stream.startsWith("conversation:") ? { images: new ImageRefs } : {};
     this.#subscriptions.set(stream, state);
     const current = () => !this.#disposed && this.#subscriptions.get(stream) === state;
     const send = (frame) => current() ? this.send(frame) : Promise.resolve();
@@ -2978,7 +3784,7 @@ class GatewayClient {
       await previous?.subscription?.stop();
       if (!current())
         return;
-      subscription = await this.#open(stream, send);
+      subscription = await this.#open(stream, send, state);
     } catch (error) {
       if (current()) {
         await send({ type: "ended", stream, reason: error instanceof Error ? error.message : String(error) });
@@ -2993,7 +3799,7 @@ class GatewayClient {
     }
     state.subscription = subscription;
   }
-  async#open(stream, send) {
+  async#open(stream, send, state) {
     const source = this.#hostValue(stream);
     if (source !== undefined) {
       send({ type: "snapshot", stream, value: source.value });
@@ -3018,7 +3824,7 @@ class GatewayClient {
       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);
+    return this.#forward(stream, await conversation.watch(context3), send, state);
   }
   #hostValue(stream) {
     return Object.hasOwn(this.#hostValues, stream) ? this.#hostValues[stream] : undefined;
@@ -3031,8 +3837,8 @@ class GatewayClient {
     await this.#conversation(id);
     const { harness } = this.#options;
     let signalCreation;
-    const created = new Promise((resolve4) => {
-      signalCreation = resolve4;
+    const created = new Promise((resolve6) => {
+      signalCreation = resolve6;
     });
     let inner;
     let stopped = false;
@@ -3080,11 +3886,60 @@ class GatewayClient {
       }
     };
   }
-  async#forward(stream, watch2, send) {
-    await send({ type: "snapshot", stream, value: watch2.value });
-    watch2.start((_value, ops) => send({ type: "ops", stream, ops }));
+  async#forward(stream, watch2, send, state) {
+    if (state?.images === undefined) {
+      await send({ type: "snapshot", stream, value: watch2.value });
+      watch2.start((_value, ops) => send({ type: "ops", stream, ops }));
+      return watch2;
+    }
+    const images = state.images;
+    let before = watch2.value;
+    state.view = before;
+    await send({ type: "snapshot", stream, value: await images.value(before) });
+    watch2.start(async (value, ops) => {
+      const sent = await images.ops(ops, before);
+      before = value;
+      state.view = before;
+      return send({ type: "ops", stream, ops: sent });
+    });
     return watch2;
   }
+  #shownImage(ref) {
+    for (const state of this.#subscriptions.values()) {
+      if (state.images === undefined || state.view === undefined)
+        continue;
+      const image = state.images.image(state.view, ref);
+      if (image !== undefined)
+        return image;
+    }
+    return;
+  }
+  #attachmentStore() {
+    const store = this.#options.attachments;
+    if (store === undefined)
+      throw new Error("Attachments are not available on this host");
+    return store;
+  }
+  async#attachmentText(ids) {
+    if (ids === undefined || ids.length === 0)
+      return;
+    const files = await this.#attachmentStore().use(ids);
+    return files === undefined ? undefined : attachmentBlock(files);
+  }
+  #attached(images) {
+    const resolved = images?.map((image, index) => {
+      if ("data" in image)
+        return image;
+      const shown = this.#shownImage(image.ref);
+      if (shown === undefined)
+        throw new Error(`Image ${index + 1} is no longer available`);
+      return shown;
+    });
+    const problem = imageProblem(resolved ?? []);
+    if (problem !== undefined)
+      throw new Error(problem);
+    return resolved;
+  }
   async#unsubscribe(stream) {
     const subscription = this.#subscriptions.get(stream);
     this.#subscriptions.delete(stream);
@@ -3096,6 +3951,11 @@ class GatewayClient {
       throw new Error(`Conversation ${id} does not exist`);
     return conversation;
   }
+  async#compact(conversation, instructions) {
+    const taskId = await conversation.compact(instructions, context3);
+    this.#options.harness.waitForTask(taskId, context3).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
+    return taskId;
+  }
   async#answer(id, method, args) {
     try {
       const value = await this.#call(method, args);
@@ -3111,16 +3971,37 @@ class GatewayClient {
       case "removeProject":
         await removeProject(this.#options.harness, args.path, context3);
         return null;
+      case "submit": {
+        const input = args;
+        const images = this.#attached(input.images);
+        const conversation2 = await this.#conversation(input.conversationId);
+        const attachments = await this.#attachmentText(input.attachments);
+        const text = await this.#expandSkills(input.text, { kind: "conversation", conversationId: conversation2.id }, input.skills);
+        const dismissed = await this.#dismissPendingQuestions(conversation2.id, context3);
+        const submission = await conversation2.submit({
+          type: "input",
+          content: messageContent(text, images, attachments),
+          whenBusy: dismissed ? "steer" : input.whenBusy,
+          requestId: input.requestId
+        }, context3);
+        submission.wait(context3).then((settled) => {
+          if (settled.status === "unanswered" && settled.reason !== "aborted") {
+            this.send({ type: "notice", level: "error", message: `No answer: ${settled.reason}` });
+          }
+        }, () => {});
+        return { submissionId: submission.id };
+      }
       case "createConversation": {
         const create = args;
-        const problem = imageProblem(create.images ?? []);
-        if (problem !== undefined)
-          throw new Error(problem);
+        const images = this.#attached(create.images);
+        const attachments = await this.#attachmentText(create.attachments);
+        const text = await this.#expandSkills(create.text, create.home.kind === "chat" ? { kind: "chat" } : { kind: "project", path: create.home.path, checkout: create.checkout ?? "worktree" }, create.skills);
         const conversationId = await createConversation(this.#options.harness, this.#options.dataDir, {
           home: create.home,
-          text: create.text,
+          text,
           requestId: create.requestId,
-          ...create.images === undefined ? {} : { images: create.images },
+          ...images === undefined ? {} : { images },
+          ...attachments === undefined ? {} : { attachmentText: attachments },
           ...create.checkout === undefined ? {} : { checkout: create.checkout },
           ...create.model === undefined ? {} : { model: create.model },
           ...create.thinkingLevel === undefined ? {} : { thinkingLevel: create.thinkingLevel },
@@ -3199,22 +4080,64 @@ class GatewayClient {
         const input = args;
         return listFiles(this.#options.harness, this.#options.dataDir, this.#files, input.scope, input.query, context3);
       }
+      case "listSkills": {
+        const input = args;
+        return listSkills(this.#options.harness, this.#skills, input.scope, context3);
+      }
+      case "image": {
+        const image = this.#shownImage(args.ref);
+        if (image === undefined)
+          throw new Error("Unknown image");
+        return image;
+      }
+      case "beginAttachment": {
+        const input = args;
+        const store = this.#attachmentStore();
+        return { attachmentId: await store.begin(input.name, input.size) };
+      }
+      case "appendAttachment": {
+        const input = args;
+        const store = this.#attachmentStore();
+        return await store.append(input.attachmentId, input.offset, input.data);
+      }
     }
     const conversation = await this.#conversation(args.conversationId);
     switch (method) {
-      case "submit": {
-        const { text, whenBusy, requestId, images } = args;
-        const problem = imageProblem(images ?? []);
-        if (problem !== undefined)
-          throw new Error(problem);
-        const dismissed = await this.#dismissPendingQuestions(conversation.id, context3);
-        const submission = await conversation.submit({ type: "input", content: messageContent(text, images), whenBusy: dismissed ? "steer" : whenBusy, requestId }, context3);
-        submission.wait(context3).then((settled) => {
-          if (settled.status === "unanswered" && settled.reason !== "aborted") {
-            this.send({ type: "notice", level: "error", message: `No answer: ${settled.reason}` });
+      case "withdrawQueued": {
+        const { conversationId, submissionId } = args;
+        const id = submissionId;
+        const submission = await this.#options.harness.submission(id, context3);
+        if (submission === undefined)
+          throw new Error(`Submission ${submissionId} does not exist`);
+        assertQueuedInput(await submission.status(context3), conversationId);
+        await this.#options.harness.abortSubmission(id, context3, conversationId);
+        const after = await this.#options.harness.submission(id, context3);
+        if (after === undefined)
+          throw new Error(`Submission ${submissionId} does not exist`);
+        return { outcome: (await after.status(context3)).entry === undefined ? "withdrawn" : "sent" };
+      }
+      case "steerQueued": {
+        const { conversationId, submissionId } = args;
+        const id = submissionId;
+        return await this.#options.harness.commit(async (tx) => {
+          const record = await tx.submission(id);
+          if (record === undefined)
+            throw new Error(`Submission ${submissionId} does not exist`);
+          assertQueuedInput(record, conversationId);
+          if (record.entry !== undefined)
+            return { outcome: "sent" };
+          if (record.status !== "queued")
+            return { outcome: "unavailable" };
+          const inbox = await tx.doc(InboxDoc, conversationId);
+          const item = inbox.items.find((candidate) => candidate.id === id);
+          if (item === undefined) {
+            throw new Error(`Submission ${submissionId} is not queued in the inbox`);
           }
-        }, () => {});
-        return { submissionId: submission.id };
+          await dismissPendingQuestions(tx, this.#questionDocs(), conversationId);
+          if (item.mode === "followUp")
+            item.mode = "steer";
+          return { outcome: "steered" };
+        }, context3);
       }
       case "renameConversation": {
         const { title } = args;
@@ -3241,29 +4164,44 @@ class GatewayClient {
         return null;
       case "compact": {
         const { instructions } = args;
-        const taskId = await conversation.compact(instructions, context3);
-        this.#options.harness.waitForTask(taskId, context3).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
-        return { taskId };
+        return { taskId: await this.#compact(conversation, instructions) };
+      }
+      case "listCommands":
+        return listCommands();
+      case "runCommand": {
+        const { name, args: input } = args;
+        await runCommand({ compact: (instructions) => this.#compact(conversation, instructions) }, name, input);
+        return null;
       }
       case "setModel": {
         const { model: ref } = args;
         const model = this.#options.models.getModel(ref.provider, ref.modelId);
         if (model === undefined)
           throw new Error(`Unknown model: ${ref.provider}/${ref.modelId}`);
-        const thinking = (await this.#agent(conversation.id)).thinkingLevel ?? "off";
-        await conversation.configure({ model: ref, thinkingLevel: clampThinkingLevel3(model, thinking) }, context3);
+        await this.#options.harness.commit(async (tx) => {
+          const state = await tx.doc(AgentDoc5, conversation.id);
+          const thinking = state.thinkingLevel ?? "off";
+          await configure3(tx, conversation.id, { model: ref, thinkingLevel: clampThinkingLevel3(model, thinking) });
+        }, context3);
         return null;
       }
       case "setThinkingLevel": {
         const { level } = args;
-        const agent = await this.#agent(conversation.id);
-        const model = agent.model === undefined ? undefined : this.#options.models.getModel(agent.model.provider, agent.model.modelId);
-        if (model === undefined)
-          throw new Error("No model selected");
-        if (!getSupportedThinkingLevels(model).includes(level)) {
-          throw new Error(`Thinking level ${level} is not supported by ${agent.model.provider}/${agent.model.modelId}`);
-        }
-        await conversation.configure({ thinkingLevel: level }, context3);
+        await this.#options.harness.commit(async (tx) => {
+          const state = await tx.doc(AgentDoc5, conversation.id);
+          const model = state.model === undefined ? undefined : this.#options.models.getModel(state.model.provider, state.model.modelId);
+          if (model === undefined)
+            throw new Error("No model selected");
+          if (!getSupportedThinkingLevels(model).includes(level)) {
+            throw new Error(`Thinking level ${level} is not supported by ${state.model.provider}/${state.model.modelId}`);
+          }
+          await configure3(tx, conversation.id, { thinkingLevel: level });
+        }, context3);
+        return null;
+      }
+      case "setAgent": {
+        const { conversationId, agent } = args;
+        await setAgent(this.#options.harness, { conversationId, agent }, this.#options.models, this.#options.modelSummaries, this.#options.agents?.value ?? { roles: [], problems: [] }, context3);
         return null;
       }
       case "fork": {
@@ -3292,7 +4230,10 @@ class GatewayClient {
           const remove = agent.tools.filter((tool) => removeTools.includes(tool.name));
           const fork = await conversation.fork(at, {
             ownership: { kind: "ownerless" },
-            ...remove.length === 0 ? {} : { agent: { tools: { remove } } }
+            ...remove.length === 0 ? {} : { agent: { tools: { remove } } },
+            init: async (tx, id) => {
+              await tx.doc(RoleDoc, id);
+            }
           }, context3);
           return { conversationId: fork.id };
         });
@@ -3336,30 +4277,47 @@ class GatewayClient {
       }
     }
   }
+  async#expandSkills(text, scope, bound) {
+    if (bound === undefined ? !text.includes("$") : bound.length === 0)
+      return text;
+    let skills;
+    try {
+      skills = await scopeSkills(this.#options.harness, this.#skills, scope, context3);
+    } catch (error) {
+      this.send({
+        type: "notice",
+        level: "warning",
+        message: `Skills were not expanded: ${error instanceof Error ? error.message : String(error)}`
+      });
+      return text;
+    }
+    const names = bound ?? mentionedSkillNames(text, skills.map((skill) => skill.name));
+    const expanded = await expandSkills(text, names, skills);
+    for (const name of expanded.missing) {
+      this.send({ type: "notice", level: "warning", message: `Skill "${name}" is not available here; sent without it` });
+    }
+    for (const failure of expanded.failures) {
+      this.send({
+        type: "notice",
+        level: "error",
+        message: `Could not read skill "${failure.name}" (${failure.filePath}): ${failure.message}`
+      });
+    }
+    return expanded.text;
+  }
   async#dismissPendingQuestions(conversationId, context4) {
-    const questionDocs = (this.#options.docs ?? []).filter((doc) => doc.presentation === "pinomad.question");
+    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));
     if (!pending)
       return false;
-    return await this.#options.harness.commit(async (tx) => {
-      let dismissed = false;
-      for (const doc of questionDocs) {
-        const value = await tx.doc(doc.token, conversationId);
-        if (!Value2.Check(QuestionSchema, value))
-          continue;
-        for (const request of value.requests) {
-          if (request.resolution === undefined) {
-            request.resolution = { outcome: "dismissed", at: Date.now() };
-            dismissed = true;
-          }
-        }
-      }
-      return dismissed;
-    }, context4);
+    return await this.#options.harness.commit((tx) => dismissPendingQuestions(tx, questionDocs, conversationId), context4);
+  }
+  #questionDocs() {
+    return (this.#options.docs ?? []).filter((doc) => doc.presentation === "pinomad.question");
   }
   get #chatsPrefix() {
-    return join7(this.#options.dataDir, "chats") + sep4;
+    return join8(this.#options.dataDir, "chats") + sep5;
   }
   async#changes(conversation, context4) {
     const cwd = (await conversation.agent(context4)).cwd;
@@ -3380,9 +4338,6 @@ class GatewayClient {
       return { available: false, reason: "Not in a git repository", branch };
     return { available: true, ...await changesOf(base.repo, base.base), branch };
   }
-  async#agent(id) {
-    return await this.#options.harness.snapshot(AgentDoc4, id, context3) ?? {};
-  }
   async dispose() {
     if (this.#disposed)
       return;
@@ -3394,21 +4349,330 @@ class GatewayClient {
   }
 }
 
+// apps/host/src/attachments.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+import {
+  chmod,
+  lstat,
+  mkdir as mkdir3,
+  open,
+  readFile as readFile4,
+  readdir as readdir3,
+  rename as rename2,
+  rm as rm3,
+  stat as stat6,
+  writeFile as writeFile2
+} from "node:fs/promises";
+import { basename as basename2, join as join9, resolve as resolve6 } from "node:path";
+var META = "meta.json";
+var DATA = "file";
+var CLEANUP_INTERVAL_MS = 6 * 60 * 60 * 1000;
+var FILE_NAME_BYTES = 200;
+function metaOf(value, id) {
+  if (value === null || typeof value !== "object")
+    return;
+  const meta = value;
+  if (meta.v !== 1)
+    return;
+  if (typeof meta.name !== "string" || typeof meta.fileName !== "string")
+    return;
+  if (typeof meta.size !== "number" || !Number.isSafeInteger(meta.size) || meta.size < 0)
+    return;
+  if (meta.state !== "uploading" && meta.state !== "complete" && meta.state !== "used")
+    return;
+  if (typeof meta.createdAt !== "number" || typeof meta.expiresAt !== "number")
+    return;
+  if (meta.fileName === "" || basename2(meta.fileName) !== meta.fileName || meta.fileName === "." || meta.fileName === "..") {
+    return;
+  }
+  return { ...meta, id };
+}
+function displayName2(name) {
+  const chars = Array.from(name);
+  return chars.length <= MAX_ATTACHMENT_NAME_LENGTH ? name : chars.slice(0, MAX_ATTACHMENT_NAME_LENGTH).join("");
+}
+function truncateUtf8(text, limit) {
+  let out = "";
+  let bytes = 0;
+  for (const char of text) {
+    const size = Buffer.byteLength(char, "utf8");
+    if (bytes + size > limit)
+      break;
+    out += char;
+    bytes += size;
+  }
+  return out;
+}
+function attachmentFileName(name) {
+  let clean = (name.split(/[\\/]/).pop() ?? "").replace(/[\u0000-\u001f\u007f]/g, "_").trim();
+  clean = clean.replace(/^\.+/, "");
+  if (clean === "")
+    return "file";
+  const dot = clean.lastIndexOf(".");
+  const rawExtension = dot > 0 ? clean.slice(dot) : "";
+  const extension = Buffer.byteLength(rawExtension, "utf8") <= 32 ? rawExtension : "";
+  const stem = extension === "" ? clean : clean.slice(0, -extension.length);
+  const extensionBytes = Buffer.byteLength(extension, "utf8");
+  const keptStem = truncateUtf8(stem, Math.max(0, FILE_NAME_BYTES - extensionBytes));
+  const trimmedStem = keptStem.replace(/[\s.]+$/u, "");
+  const candidate = trimmedStem + (trimmedStem === "" ? "" : extension);
+  return candidate === "" ? "file" : candidate;
+}
+
+class AttachmentStore {
+  #root;
+  #now;
+  #ttlMs;
+  #pendingLimit;
+  #pendingBytesLimit;
+  #cleanupIntervalMs;
+  #lock = Promise.resolve();
+  #pending = new Map;
+  #timer;
+  constructor(options) {
+    this.#root = resolve6(options.dir);
+    this.#now = options.now ?? Date.now;
+    this.#ttlMs = options.ttlMs ?? ATTACHMENT_TTL_MS;
+    this.#pendingLimit = options.pendingLimit ?? MAX_PENDING_ATTACHMENTS;
+    this.#pendingBytesLimit = options.pendingBytesLimit ?? MAX_PENDING_ATTACHMENT_BYTES;
+    this.#cleanupIntervalMs = options.cleanupIntervalMs ?? CLEANUP_INTERVAL_MS;
+  }
+  get root() {
+    return this.#root;
+  }
+  async open() {
+    await mkdir3(this.#root, { recursive: true });
+    await this.#rebuildPending();
+    await this.sweep();
+    this.#timer = setInterval(() => void this.sweep().catch(() => {}), this.#cleanupIntervalMs);
+    this.#timer.unref();
+  }
+  close() {
+    if (this.#timer !== undefined)
+      clearInterval(this.#timer);
+    this.#timer = undefined;
+  }
+  #run(work) {
+    const next = this.#lock.then(work, work);
+    this.#lock = next.then(() => {}, () => {});
+    return next;
+  }
+  #directory(id) {
+    return join9(this.#root, id);
+  }
+  #dataPath(meta) {
+    return join9(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);
+    } catch {
+      return;
+    }
+  }
+  async#writeMeta(meta) {
+    const { id, ...value } = meta;
+    const directory = this.#directory(id);
+    const temporary = join9(directory, `.meta.${randomBytes3(6).toString("hex")}.tmp`);
+    await writeFile2(temporary, `${JSON.stringify(value)}
+`, { mode: 384 });
+    await rename2(temporary, join9(directory, META));
+  }
+  async#rebuildPending() {
+    this.#pending.clear();
+    let entries;
+    try {
+      entries = await readdir3(this.#root, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const meta = await this.#readMeta(entry.name);
+      if (meta !== undefined && meta.state !== "used")
+        this.#pending.set(meta.id, meta.size);
+    }
+  }
+  begin(name, size) {
+    return this.#run(async () => {
+      const problem = attachmentBeginProblem(name, size);
+      if (problem !== undefined)
+        throw new Error(problem);
+      let pendingBytes = 0;
+      for (const bytes of this.#pending.values())
+        pendingBytes += bytes;
+      if (this.#pending.size + 1 > this.#pendingLimit) {
+        throw new Error(`Too many pending attachments (${this.#pendingLimit} at most); try again after unused uploads expire`);
+      }
+      if (pendingBytes + size > this.#pendingBytesLimit) {
+        throw new Error(`Pending attachments exceed the ${this.#pendingBytesLimit / (1024 * 1024)} MB budget; try again after unused uploads expire`);
+      }
+      const id = randomBytes3(16).toString("base64url");
+      const directory = this.#directory(id);
+      const meta = {
+        id,
+        v: 1,
+        name: displayName2(name),
+        fileName: attachmentFileName(name),
+        size,
+        state: size === 0 ? "complete" : "uploading",
+        createdAt: this.#now(),
+        expiresAt: this.#now() + this.#ttlMs
+      };
+      try {
+        await mkdir3(join9(directory, DATA), { recursive: true });
+        await writeFile2(this.#dataPath(meta), new Uint8Array(0), { mode: 384 });
+        if (size === 0)
+          await chmod(this.#dataPath(meta), 292);
+        await this.#writeMeta(meta);
+      } catch (error) {
+        await rm3(directory, { recursive: true, force: true }).catch(() => {});
+        throw error;
+      }
+      this.#pending.set(id, size);
+      return id;
+    });
+  }
+  append(id, offset, data) {
+    return this.#run(async () => {
+      const meta = await this.#readMeta(id);
+      if (meta === undefined)
+        throw new Error("Attachment not found or expired; attach it again");
+      if (meta.state === "complete" || meta.state === "used") {
+        return { received: meta.size, complete: true };
+      }
+      const problem = attachmentChunkProblem(data);
+      if (problem !== undefined)
+        throw new Error(problem);
+      const decoded = base64DecodedLength(data);
+      const path = this.#dataPath(meta);
+      const received = (await stat6(path)).size;
+      if (received === meta.size) {
+        await chmod(path, 292);
+        await this.#writeMeta({ ...meta, state: "complete" });
+        return { received, complete: true };
+      }
+      if (offset !== received)
+        return { received, complete: false };
+      if (received + decoded > meta.size)
+        throw new Error("Attachment chunk is larger than the remaining size");
+      const bytes = Buffer.from(data, "base64");
+      const handle = await open(path, "r+");
+      try {
+        const { bytesWritten } = await handle.write(bytes, 0, bytes.length, received);
+        if (bytesWritten !== bytes.length)
+          throw new Error("Could not write the whole attachment chunk");
+      } finally {
+        await handle.close();
+      }
+      const after = received + bytes.length;
+      if (after === meta.size) {
+        await chmod(path, 292);
+        await this.#writeMeta({ ...meta, state: "complete" });
+      }
+      return { received: after, complete: after === meta.size };
+    });
+  }
+  use(ids) {
+    return this.#run(async () => {
+      if (ids === undefined || ids.length === 0)
+        return;
+      if (ids.length > MAX_ATTACHMENTS_PER_MESSAGE) {
+        throw new Error(`At most ${MAX_ATTACHMENTS_PER_MESSAGE} attachments per message`);
+      }
+      const checked = [];
+      for (let index = 0;index < ids.length; index++) {
+        const id = ids[index];
+        const meta = await this.#readMeta(id);
+        if (meta === undefined)
+          throw new Error(`Attachment ${index + 1} has expired; attach it again`);
+        if (meta.state === "uploading")
+          throw new Error(`Attachment ${index + 1} is still uploading`);
+        const path = this.#dataPath(meta);
+        let info;
+        try {
+          info = await lstat(path);
+        } catch {
+          throw new Error(`Attachment ${index + 1} is unavailable; attach it again`);
+        }
+        if (!info.isFile() || info.size !== meta.size) {
+          throw new Error(`Attachment ${index + 1} is unavailable; attach it again`);
+        }
+        checked.push({ meta, path });
+      }
+      for (const { meta } of checked) {
+        if (meta.state === "used") {
+          this.#pending.delete(meta.id);
+          continue;
+        }
+        await this.#writeMeta({ ...meta, state: "used" });
+        this.#pending.delete(meta.id);
+      }
+      return checked.map(({ meta, path }) => ({ id: meta.id, name: meta.name, path, size: meta.size }));
+    });
+  }
+  sweep() {
+    return this.#run(async () => {
+      let removed = 0;
+      let entries;
+      try {
+        entries = await readdir3(this.#root, { withFileTypes: true });
+      } catch {
+        return 0;
+      }
+      const now = this.#now();
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const directory = this.#directory(entry.name);
+        const meta = await this.#readMeta(entry.name);
+        if (meta !== undefined) {
+          if (meta.state === "used") {
+            this.#pending.delete(meta.id);
+            continue;
+          }
+          if (meta.expiresAt > now) {
+            this.#pending.set(meta.id, meta.size);
+            continue;
+          }
+        } else {
+          this.#pending.delete(entry.name);
+          try {
+            if (now - (await stat6(directory)).mtimeMs <= this.#ttlMs)
+              continue;
+          } catch {
+            continue;
+          }
+        }
+        try {
+          await rm3(directory, { recursive: true, force: true });
+          this.#pending.delete(entry.name);
+          removed += 1;
+        } catch {}
+      }
+      return removed;
+    });
+  }
+}
+
 // apps/host/src/host.ts
 var context4 = BACKGROUND_CONTEXT4;
 async function hostToken(dataDir) {
-  const path = join8(dataDir, "token");
+  const path = join10(dataDir, "token");
   try {
-    return (await readFile3(path, "utf8")).trim();
+    return (await readFile5(path, "utf8")).trim();
   } catch {
-    const token = randomBytes3(24).toString("base64url");
-    await writeFile2(path, `${token}
+    const token = randomBytes4(24).toString("base64url");
+    await writeFile3(path, `${token}
 `, { mode: 384 });
     return token;
   }
 }
 async function openHost(options) {
-  await mkdir3(options.dataDir, { recursive: true });
+  await mkdir4(options.dataDir, { recursive: true });
   const stale = Math.max(2000, options.lockStaleMs ?? 1e4);
   const release = await lockfile.lock(options.dataDir, {
     realpath: false,
@@ -3420,13 +4684,16 @@ async function openHost(options) {
   let harness;
   let mcp;
   let agentRoles;
+  let attachments;
   let extensions = [];
   try {
     const token = await hostToken(options.dataDir);
+    attachments = new AttachmentStore({ dir: join10(options.dataDir, "attachments") });
+    await attachments.open();
     const reports = [];
     let report = (error) => void reports.push(error);
     const registry = createRegistry();
-    agentRoles = await openAgentRoles({ dir: join8(options.dataDir, "agents") });
+    agentRoles = await openAgentRoles({ dir: join10(options.dataDir, "agents") });
     extensions = typeof options.extensions === "function" ? options.extensions({
       harness: () => {
         if (harness === undefined)
@@ -3449,13 +4716,13 @@ async function openHost(options) {
       }
     });
     const hostSettings = await openHostSettings({
-      path: join8(options.dataDir, "settings.json"),
+      path: join10(options.dataDir, "settings.json"),
       fallback: options.settingsFallback,
       models: options.modelAuth?.models ?? constantValue(options.modelSummaries())
     });
     const environments = new Map;
-    const chatsDir = join8(options.dataDir, "chats");
-    harness = await Harness.open(await (options.openStorage ?? openNodeSqliteStorage)(join8(options.dataDir, "session.sqlite")), {
+    const chatsDir = join10(options.dataDir, "chats");
+    harness = await Harness.open(await (options.openStorage ?? openNodeSqliteStorage)(join10(options.dataDir, "session.sqlite")), {
       models: options.models,
       registry,
       env: async (target) => {
@@ -3463,16 +4730,16 @@ async function openHost(options) {
         if (cwd === undefined)
           return;
         const worktrees = worktreeRoot(options.dataDir);
-        if (cwd === worktrees || cwd.startsWith(worktrees + sep5)) {
+        if (cwd === worktrees || cwd.startsWith(worktrees + sep6)) {
           const index = await target.read.snapshot(IndexDoc, context4);
           const record = checkoutAt(index?.checkouts, cwd);
           if (record !== undefined) {
             await ensureWorktree(record);
-            await mkdir3(cwd, { recursive: true });
+            await mkdir4(cwd, { recursive: true });
           }
         }
         if (cwd.startsWith(`${chatsDir}/`))
-          await mkdir3(cwd, { recursive: true });
+          await mkdir4(cwd, { recursive: true });
         let env = environments.get(cwd);
         if (env === undefined) {
           env = new NodeExecutionEnv({ cwd });
@@ -3496,8 +4763,10 @@ async function openHost(options) {
       harness,
       models: options.models,
       modelSummaries: options.modelSummaries,
-      session: { id: basename2(options.dataDir), directory: options.dataDir },
+      session: { id: basename3(options.dataDir), directory: options.dataDir },
       dataDir: options.dataDir,
+      attachments,
+      agentsHome: options.agentsHome,
       settings: hostSettings,
       token,
       port: options.port,
@@ -3562,6 +4831,7 @@ async function openHost(options) {
             await gateway.close();
             await opened.close(context4);
             await mcp?.close();
+            attachments?.close();
             agentRoles?.close();
             for (const each of extensions)
               await each.close?.();
@@ -3576,6 +4846,7 @@ async function openHost(options) {
     };
   } catch (error) {
     options.modelAuth?.close();
+    attachments?.close();
     agentRoles?.close();
     for (const each of extensions)
       await each.close?.().catch(() => {});
@@ -3586,9 +4857,71 @@ async function openHost(options) {
   }
 }
 
+// apps/host/src/service/log-rotation.ts
+import { copyFile, rename as rename3, rm as rm4, stat as stat7, truncate } from "node:fs/promises";
+import { join as join11 } 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 rotationTempPath = (log) => `${log}.rotating`;
+var isMissing = (error) => error.code === "ENOENT";
+async function rotateHostLog(dataDir, copy = copyFile) {
+  const log = hostLogPath(dataDir);
+  const temp = rotationTempPath(log);
+  await rm4(temp, { force: true });
+  let size;
+  try {
+    size = (await stat7(log)).size;
+  } catch (error) {
+    if (isMissing(error))
+      return false;
+    throw error;
+  }
+  if (size <= HOST_LOG_MAX_BYTES)
+    return false;
+  try {
+    await copy(log, temp);
+  } catch (error) {
+    await rm4(temp, { force: true }).catch(() => {});
+    throw error;
+  }
+  await rm4(`${log}.${HOST_LOG_HISTORY}`, { force: true });
+  for (let index = HOST_LOG_HISTORY - 1;index >= 1; index -= 1) {
+    try {
+      await rename3(`${log}.${index}`, `${log}.${index + 1}`);
+    } catch (error) {
+      if (!isMissing(error))
+        throw error;
+    }
+  }
+  await rename3(temp, `${log}.1`);
+  await truncate(log, 0);
+  return true;
+}
+function startHostLogRotation(dataDir) {
+  let running = false;
+  const check = () => {
+    if (running)
+      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 })}
+`);
+    }).finally(() => {
+      running = false;
+    });
+  };
+  check();
+  const timer = setInterval(check, HOST_LOG_CHECK_INTERVAL_MS);
+  timer.unref();
+  return () => clearInterval(timer);
+}
+
 // apps/host/src/model-auth.ts
-import { existsSync as existsSync2, watch as watch2 } from "node:fs";
-import { basename as basename3, dirname as dirname2 } from "node:path";
+import { existsSync as existsSync3, watch as watch2 } from "node:fs";
+import { basename as basename4, dirname as dirname3 } from "node:path";
 
 // apps/host/src/pi-setup.ts
 import { getSupportedThinkingLevels as getSupportedThinkingLevels2 } from "@earendil-works/pi-ai";
@@ -3720,7 +5053,7 @@ async function watchModelAuth(modelRuntime, options) {
   const debounceMs = options.debounceMs ?? 150;
   const models = new Published(modelSummaries(modelRuntime), (a, b) => sameList(a, b, sameModel));
   const auth = new Published(await storedLogins(modelRuntime), (a, b) => sameList(a.logins, b.logins, sameLogin));
-  const fileName = basename3(options.authPath);
+  const fileName = basename4(options.authPath);
   let watcher;
   let timer;
   let reported = false;
@@ -3737,8 +5070,8 @@ async function watchModelAuth(modelRuntime, options) {
       reported = true;
     }
   };
-  const directory = dirname2(options.authPath);
-  if (existsSync2(directory)) {
+  const directory = dirname3(options.authPath);
+  if (existsSync3(directory)) {
     watcher = watch2(directory, (_event, changed) => {
       if (closed || changed !== null && changed !== fileName)
         return;
@@ -3788,7 +5121,7 @@ async function main(argv) {
       relay: { type: "string" }
     }
   });
-  const dataDir = resolve4(values["data-dir"] ?? DEFAULT_DATA_DIR);
+  const dataDir = resolve7(values["data-dir"] ?? DEFAULT_DATA_DIR);
   let relayOrigin;
   try {
     relayOrigin = resolveRelayOrigin(values.relay, await readServerConfig(dataDir));
@@ -3796,9 +5129,10 @@ async function main(argv) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
+  const agentsHome = join12(homedir3(), ".agents");
   const extensionsFor = (models, summaries, options2) => (host2) => [
     createContext({
-      agentsHome: join9(homedir3(), ".agents"),
+      agentsHome,
       checkout: (input, context5) => checkoutInfo(host2.harness(), input, context5)
     }),
     createCoding(options2),
@@ -3814,9 +5148,10 @@ async function main(argv) {
   ];
   const common = {
     dataDir,
+    agentsHome,
     projects: values.project ?? [],
     port: Number(values.port),
-    mcpConfig: join9(homedir3(), ".agents", "mcp.json"),
+    mcpConfig: join12(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"]) },
@@ -3860,7 +5195,7 @@ async function main(argv) {
   }
   async function piOptions() {
     const modelRuntime = await ModelRuntime.create();
-    const modelAuth = await watchModelAuth(modelRuntime, { authPath: join9(getAgentDir(), "auth.json") });
+    const modelAuth = await watchModelAuth(modelRuntime, { authPath: join12(getAgentDir(), "auth.json") });
     const settingsManager = SettingsManager.create(process.cwd());
     configureHarnessHttp(settingsManager);
     const summaries = () => modelAuth.models.value;
@@ -3886,13 +5221,14 @@ async function main(argv) {
   }
   const options = values.faux !== undefined ? fauxOptions(() => () => fauxAssistantMessage(values.faux)) : await piOptions();
   const host = await openHost(options);
+  const stopLogRotation = startHostLogRotation(dataDir);
   const { defaultModel: effectiveModel } = host.settings.value;
   const model = effectiveModel === null ? null : `${effectiveModel.provider}/${effectiveModel.modelId}`;
   const web = packagedVersion === undefined ? "http://127.0.0.1:5199/" : new URL(host.url.replace(/^ws/, "http")).href;
   console.log(JSON.stringify({
     event: "ready",
     url: host.url,
-    tokenFile: join9(dataDir, "token"),
+    tokenFile: join12(dataDir, "token"),
     dataDir,
     model,
     web,
@@ -3904,6 +5240,7 @@ async function main(argv) {
     if (stopping)
       return;
     stopping = true;
+    stopLogRotation();
     host.close().finally(() => process.exit(0));
   };
   process.on("SIGINT", stop);
@@ -3912,6 +5249,7 @@ async function main(argv) {
     if (end.reason !== "failed" || stopping)
       return;
     stopping = true;
+    stopLogRotation();
     const error = end.error instanceof Error ? end.error.message : String(end.error);
     process.stderr.write(`${JSON.stringify({ event: "fatal", error })}
 `);