pinomad 0.1.1 → 0.3.0

package/dist/{chunk-mqbg2cbw.js → chunk-tfqc1djy.js}

@@ -5,12 +5,17 @@ import {
 import {
   packagedVersion,
   webRoot
-} from "./chunk-fpb6f9n5.js";
+} from "./chunk-3tf23vjq.js";
 import {
-  PROTOCOL_VERSION,
+  HOST_SETTING_KEYS,
+  INVALID_FRAME_CLOSE_CODE,
+  PROTOCOL,
+  THINKING_LEVELS,
   UNAUTHORIZED_CLOSE_CODE,
-  isClientFrame
-} from "./chunk-wgn3cx5q.js";
+  isQueueMode,
+  isThinkingLevel,
+  parseClientFrame
+} from "./chunk-c155p0t0.js";
 import {
   DevicesDoc,
   ensureDevices,
@@ -40,12 +45,13 @@ import {
 import"./chunk-df32avw6.js";
 
 // apps/host/src/main.ts
-import { homedir as homedir2 } from "node:os";
-import { join as join6, resolve as resolve3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join8, resolve as resolve3 } from "node:path";
 import { parseArgs } from "node:util";
 import { createModels } from "@earendil-works/pi-ai/models";
 import { fauxAssistantMessage, fauxProvider } from "@earendil-works/pi-ai/providers/faux";
-import { ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { createNodePhotonImages } from "@earendil-works/pi-durable/images/node";
 
 // apps/host/src/extensions/question.ts
 import {
@@ -92,6 +98,7 @@ var QuestionRequestSchema = Type.Object({
 var QuestionSchema = Type.Object({ requests: Type.Array(QuestionRequestSchema) });
 var DiffSchema = Type.Object({ patch: Type.String() });
 var CodemodeCallSchema = Type.Object({
+  id: Type.Optional(Type.Number()),
   name: Type.String(),
   args: Type.String(),
   status: Type.Union([Type.Literal("running"), Type.Literal("ok"), Type.Literal("error"), Type.Literal("cancelled")]),
@@ -99,7 +106,7 @@ var CodemodeCallSchema = Type.Object({
   error: Type.Optional(Type.String()),
   details: Type.Optional(Type.Unknown())
 });
-var CodemodeSchema = Type.Object({ code: Type.String(), calls: Type.Array(CodemodeCallSchema) });
+var CodemodeSchema = Type.Object({ code: Type.Optional(Type.String()), calls: Type.Array(CodemodeCallSchema) });
 
 // apps/host/src/extensions/question.ts
 var QuestionDoc = defineDoc({
@@ -168,10 +175,11 @@ function result(questions, resolution) {
   } else {
     text = "Question cancelled.";
   }
-  return { content: [{ type: "text", text }], details: { resolution } };
+  return { output: [{ type: "text", text }], details: { resolution } };
 }
 var askUserQuestion = defineTool({
   name: "ask_user_question",
+  callers: ["model"],
   description: "Ask the user 1–4 multiple-choice questions when their decision is needed to proceed (ambiguous requirements, choosing between approaches, scope). Blocks until answered. The user can always type a custom answer, so never add an 'Other' option. Keep headers short.",
   parameters: Type2.Object({
     questions: Type2.Array(QuestionItemSchema, { minItems: 1, maxItems: 4 })
@@ -198,13 +206,12 @@ var askUserQuestion = defineTool({
 });
 var question = {
   extension: defineExtension({ name: "question", tools: [askUserQuestion], tasks: [QuestionWait] }),
-  modelOnly: ["ask_user_question"],
   docs: [{ token: QuestionDoc, presentation: "pinomad.question" }]
 };
 
 // apps/host/src/extensions/coding.ts
 import { wrapTool } from "@earendil-works/pi-durable";
-import { CodingTools, createWriteTool } from "@earendil-works/pi-durable/tools";
+import { createCodingTools, createWriteTool } from "@earendil-works/pi-durable/tools";
 import { createPatch } from "diff";
 var writeWithDiff = wrapTool(createWriteTool(), (tool) => ({
   ...tool,
@@ -220,433 +227,68 @@ var writeWithDiff = wrapTool(createWriteTool(), (tool) => ({
     return { ...result2, details: { patch: createPatch(args.path, oldContent, args.content) } };
   }
 }));
-var coding = {
-  extension: { ...CodingTools, wraps: [writeWithDiff] },
-  tools: { edit: "pinomad.diff", write: "pinomad.diff" }
-};
+function createCoding(options) {
+  return {
+    extension: { ...createCodingTools(options), wraps: [writeWithDiff] },
+    tools: { edit: "pinomad.diff", write: "pinomad.diff" }
+  };
+}
+var coding = createCoding();
 
 // apps/host/src/extensions/codemode.ts
-import { withAbortSignal } from "@earendil-works/chord/context";
-import {
-  CodemodeSandbox,
-  CodemodeSourceError,
-  loadQuickJSWasm,
-  parseCodemodeSource,
-  renderToolSignature
-} from "@earendil-works/pi-codemode";
-import { validateToolArguments } from "@earendil-works/pi-ai/utils/validation";
-import {
-  defineExtension as defineExtension2,
-  defineTool as defineTool2,
-  section
-} from "@earendil-works/pi-durable";
-import { Type as Type3 } from "typebox";
+import { CodemodeSandbox, loadQuickJSWasm } from "@earendil-works/pi-codemode";
+import { createCodemodeExtension } from "@earendil-works/pi-durable/codemode";
 var wasm = loadQuickJSWasm();
-var OUTPUT_CAP = 1024 * 1024;
-var OUTPUT_HALF = OUTPUT_CAP / 2;
-
-class NestedOutput {
-  #head = "";
-  #tail = "";
-  #dropped = 0;
-  #decoder = new TextDecoder;
-  push(chunk) {
-    const text = typeof chunk === "string" ? chunk : this.#decoder.decode(chunk, { stream: true });
-    if (this.#dropped === 0 && this.#head.length + text.length <= OUTPUT_CAP) {
-      this.#head += text;
-      return;
-    }
-    if (this.#dropped === 0) {
-      const rest = this.#head.slice(OUTPUT_HALF) + text;
-      this.#head = this.#head.slice(0, OUTPUT_HALF);
-      this.#dropped = Math.max(0, rest.length - OUTPUT_HALF);
-      this.#tail = rest.slice(-OUTPUT_HALF);
-      return;
-    }
-    const merged = this.#tail + text;
-    this.#dropped += Math.max(0, merged.length - OUTPUT_HALF);
-    this.#tail = merged.slice(-OUTPUT_HALF);
-  }
-  text() {
-    const tail = this.#tail + this.#decoder.decode();
-    return this.#dropped === 0 ? this.#head + tail : `${this.#head}
-[... ${this.#dropped} characters omitted ...]
-${tail}`;
-  }
-}
-var summarizeArgs = (args) => {
-  let text;
-  try {
-    text = JSON.stringify(args) ?? "null";
-  } catch {
-    text = String(args);
-  }
-  return text.length <= 200 ? text : `${text.slice(0, 199)}…`;
-};
-var errorText = (error) => error instanceof Error ? error.message : String(error);
-var textOf = (content) => content.flatMap((block) => block.type === "text" ? [block.text] : []).join("");
-var TOKENIZE = /[^a-z0-9]+/;
-var tokens = (text) => text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(TOKENIZE).filter(Boolean);
-function search(callables, query, limit, namespace) {
-  const docs = [...callables].filter((tool) => namespace === undefined || tool.namespace?.name === namespace).map((tool) => {
-    const text = [tool.name, tool.description, tool.namespace?.name, tool.namespace?.description].filter(Boolean).join(" ");
-    return { tool, terms: tokens(text) };
-  });
-  const avgLength = docs.length === 0 ? 1 : docs.reduce((sum, doc) => sum + doc.terms.length, 0) / docs.length;
-  const frequency = new Map;
-  for (const doc of docs)
-    for (const term of new Set(doc.terms))
-      frequency.set(term, (frequency.get(term) ?? 0) + 1);
-  const scored = docs.map((doc) => {
-    const counts = new Map;
-    for (const term of doc.terms)
-      counts.set(term, (counts.get(term) ?? 0) + 1);
-    let score = 0;
-    for (const term of tokens(query)) {
-      const df = frequency.get(term);
-      if (df === undefined)
-        continue;
-      const idf = Math.log(1 + (docs.length - df + 0.5) / (df + 0.5));
-      const tf = counts.get(term) ?? 0;
-      score += idf * tf * 2.2 / (tf + 1.2 * (0.25 + 0.75 * doc.terms.length / avgLength));
-    }
-    return { tool: doc.tool, score };
-  });
-  return scored.filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((entry) => ({
-    name: entry.tool.name,
-    description: entry.tool.description.length <= 300 ? entry.tool.description : `${entry.tool.description.slice(0, 299)}…`
-  }));
-}
-function createCodemode(options) {
-  const excluded = new Set([...options.modelOnly, "codemode"]);
-  const modelOnlyList = [...excluded].join(", ");
-  const tool = defineTool2({
-    name: "codemode",
-    description: DESCRIPTION.replace("{MODEL_ONLY}", modelOnlyList),
-    parameters: Type3.Object({
-      code: Type3.String({ minLength: 1, description: "Raw JavaScript source; see the tool description." })
-    }),
-    execute: async (args, api, context) => {
-      let parsed;
-      try {
-        parsed = parseCodemodeSource(args.code);
-      } catch (error) {
-        if (error instanceof CodemodeSourceError) {
-          return { content: [{ type: "text", text: `Script failed: ${error.message}` }], isError: true };
-        }
-        throw error;
-      }
-      const agent = await api.agent(context);
-      const callables = new Map;
-      for (const offered of agent.tools) {
-        if (!excluded.has(offered.name))
-          callables.set(offered.name, { kind: "agent", tool: offered });
-      }
-      for (const scriptTool of options.scriptTools())
-        callables.set(scriptTool.name, { kind: "script", tool: scriptTool });
-      const calls = [];
-      let detailsBudget = 512 * 1024;
-      const snapshot = () => ({
-        code: parsed.code,
-        calls: calls.map((call) => ({ ...call }))
-      });
-      const publish = () => {
-        api.details(snapshot(), context).catch(() => {});
-      };
-      const executeNested = async (name, callArgs, signal) => {
-        const record = { name, args: summarizeArgs(callArgs), status: "running" };
-        calls.push(record);
-        publish();
-        const started2 = Date.now();
-        try {
-          const callable = callables.get(name);
-          if (callable === undefined)
-            throw new Error(`Unknown tool "${name}"`);
-          const value = callable.kind === "script" ? await callable.tool.call(callArgs, signal) : await runAgentTool(callable.tool, callArgs, signal, record, calls.length - 1);
-          record.status = signal.aborted ? "cancelled" : "ok";
-          return value;
-        } catch (error) {
-          record.status = signal.aborted ? "cancelled" : "error";
-          record.error = errorText(error).slice(0, 500);
-          throw error;
-        } finally {
-          record.durationMs = Date.now() - started2;
-          publish();
-        }
-      };
-      const runAgentTool = async (offered, callArgs, signal, record, index) => {
-        const prepared = offered.prepareArguments === undefined ? callArgs : offered.prepareArguments(callArgs);
-        const validated = validateToolArguments(offered, {
-          type: "toolCall",
-          id: `${api.callId}/${index}`,
-          name: offered.name,
-          arguments: prepared
-        });
-        const output = new NestedOutput;
-        const diagnostics = [];
-        let reported;
-        const derived = {
-          ...api,
-          callId: `${api.callId}/${index}`,
-          output: (chunk) => output.push(chunk),
-          outputWindow: undefined,
-          diagnostic: (diagnostic) => diagnostics.push(`[${diagnostic.severity}] ${diagnostic.message}`),
-          details: async (value) => {
-            reported = value;
-          }
-        };
-        let result2;
-        try {
-          result2 = await offered.execute(validated, derived, withAbortSignal(signal, context));
-        } catch (error) {
-          if (signal.aborted)
-            throw error;
-          throw new Error(`${[output.text(), errorText(error)].filter(Boolean).join(`
-`)}`.trim());
-        }
-        const captured = result2.details ?? reported;
-        if (captured !== undefined && options.presentations[offered.name] !== undefined) {
-          try {
-            const size = JSON.stringify(captured).length;
-            if (size <= 64 * 1024 && detailsBudget >= size) {
-              detailsBudget -= size;
-              record.details = captured;
-            }
-          } catch {}
-        }
-        const collected = [output.text(), ...diagnostics].filter(Boolean).join(`
-`);
-        const content = result2.content ?? [{ type: "text", text: collected }];
-        if (result2.isError === true)
-          throw new Error(textOf(content) || collected);
-        const texts = content.filter((block) => block.type === "text");
-        return texts.length === content.length ? texts.map((block) => block.text).join("") : content;
-      };
-      const globals = [
-        {
-          name: "searchTools",
-          spread: true,
-          description: "Search callable tools by relevance.",
-          execute: (callArgs) => {
-            const [query, opts] = callArgs;
-            return search([...callables.values()].map((callable) => callable.kind === "script" ? { name: callable.tool.name, description: callable.tool.description, namespace: callable.tool.namespace } : { name: callable.tool.name, description: callable.tool.description ?? "", namespace: undefined }), String(query ?? ""), typeof opts?.limit === "number" && opts.limit > 0 ? Math.floor(opts.limit) : 8, opts?.namespace);
-          }
-        },
-        {
-          name: "describeTool",
-          description: "The declaration of one callable tool, or undefined.",
-          execute: (callArgs) => {
-            const callable = callables.get(String(callArgs));
-            if (callable === undefined)
-              return;
-            return {
-              name: callable.tool.name,
-              description: callable.tool.description,
-              declaration: renderToolSignature(callable.kind === "script" ? { name: callable.tool.name, inputSchema: callable.tool.inputSchema, outputSchema: callable.tool.outputSchema } : { name: callable.tool.name, inputSchema: callable.tool.parameters })
-            };
-          }
-        },
-        {
-          name: "describeNamespace",
-          description: "The tools of one script-only namespace, or undefined.",
-          execute: (callArgs) => {
-            const wanted = String(callArgs);
-            const members = options.scriptTools().filter((tool2) => tool2.namespace?.name === wanted);
-            if (members.length === 0)
-              return;
-            const first = members[0].namespace;
-            return {
-              name: wanted,
-              ...first.description === undefined ? {} : { description: first.description },
-              ...first.instructions === undefined ? {} : { instructions: first.instructions },
-              tools: members.map((tool2) => ({ name: tool2.name, description: tool2.description }))
-            };
-          }
-        }
-      ];
-      const sandbox = new CodemodeSandbox({
-        tools: [...callables.values()].map((callable) => ({
-          name: callable.tool.name,
-          ...callable.tool.description === undefined ? {} : { description: callable.tool.description },
-          inputSchema: callable.kind === "script" ? callable.tool.inputSchema : callable.tool.parameters,
-          ...callable.kind === "script" && callable.tool.outputSchema !== undefined ? { outputSchema: callable.tool.outputSchema } : {},
-          execute: (callArgs, { signal }) => executeNested(callable.tool.name, callArgs, signal)
-        })),
-        globals,
-        memoryLimitBytes: 256 * 1024 * 1024,
-        timeoutMs: parsed.options.timeoutMs ?? Infinity,
-        wasm
-      });
-      const started = Date.now();
-      try {
-        const result2 = await sandbox.execute(parsed.code, { signal: context.abortSignal });
-        context.abortSignal?.throwIfAborted();
-        return {
-          content: resultContent(result2, started, parsed.options.maxOutputTokens),
-          isError: !result2.ok,
-          details: snapshot()
-        };
-      } finally {
-        await sandbox.close();
-      }
-    }
-  });
+function createCodemode() {
+  const sandbox = new CodemodeSandbox({ wasm, memoryLimitBytes: 256 * 1024 * 1024 });
+  const namespaced = (namespaces) => createCodemodeExtension({ sandbox, namespaces });
   return {
-    extension: defineExtension2({
-      name: "codemode",
-      tools: [tool],
-      sections: [
-        section("codemode", (input) => {
-          const offered = new Set(input.agent.tools.map((each) => each.name));
-          const namespaces = new Map;
-          for (const tool2 of options.scriptTools()) {
-            if (tool2.namespace === undefined)
-              continue;
-            const entry = namespaces.get(tool2.namespace.name) ?? { scriptOnly: 0 };
-            namespaces.set(tool2.namespace.name, {
-              description: entry.description ?? tool2.namespace.description,
-              scriptOnly: entry.scriptOnly + (offered.has(tool2.name) ? 0 : 1)
-            });
-          }
-          const scriptOnly = [...namespaces.entries()].filter(([, entry]) => entry.scriptOnly > 0).sort(([a], [b]) => a.localeCompare(b));
-          let text = `Every tool declared to you except ${modelOnlyList} can also be called from codemode scripts as tools.<name>(args), with the same arguments.`;
-          if (scriptOnly.length > 0) {
-            const lines = scriptOnly.map(([name, entry]) => {
-              const firstLine = entry.description?.split(`
-`)[0];
-              const clipped = firstLine === undefined ? "" : `: ${firstLine.slice(0, 200)}`;
-              return `- ${name} (${entry.scriptOnly} tools)${clipped}`;
-            });
-            text += `
-
-These namespaces are reachable only from codemode scripts; find their tools with describeNamespace(name) or searchTools(query):
-${lines.join(`
-`)}`;
-          }
-          return text;
-        })
-      ]
-    }),
+    extension: namespaced([]),
     tools: { codemode: "pinomad.codemode" },
-    modelOnly: ["codemode"]
+    namespaced,
+    close: () => sandbox.close()
   };
 }
-var DESCRIPTION = `Run a JavaScript script that calls other tools; only what the script outputs reaches you. Use it to run several tool calls in parallel (Promise.all / Promise.allSettled), to filter or aggregate large results before you see them, and to call tools that are only reachable from scripts, such as most MCP tools.
-
-\`code\` is raw JavaScript, not JSON and not a markdown fence. It runs as the body of an async function in a QuickJS sandbox, so top-level await and return work. There are no Node APIs, file system, network, timers, or modules: scripts reach the outside world only through tools. The script may start with one options line: // @options: {"max_output_tokens": 2000, "timeout_ms": 60000}. max_output_tokens defaults to 10000; longer output keeps its start and end. timeout_ms is unset by default.
-
-Globals:
-- tools.<name>(args): call a tool with one arguments object. Characters that are invalid in identifiers become _, so mcp__my-server__search is tools.mcp__my_server__search.
-- text(value): add to the output; strings as is, other values as JSON. console.log(...) and a top-level \`return value\` do the same.
-- image(block): add an image from an image block { type: "image", data, mimeType } or a base64 data: URL.
-- exit(): end the script successfully.
-- ALL_TOOLS: every callable tool as { name, description }.
-- searchTools(query, { limit?, namespace? }): resolves to the callable tools ranked by relevance (default limit 8), as { name, description }[].
-- describeTool(name): resolves to { name, description, declaration } with the tool's TypeScript declaration, or undefined.
-- describeNamespace(name): resolves to { name, description?, instructions?, tools } for a namespace such as an MCP server, or undefined.
-These three return promises: await them.
-
-What a call resolves to: MCP tools resolve to their CallToolResult { content, isError?, structuredContent? }, also when isError is true. Other tools resolve to their text output, or to an array of text and image blocks when the output has images. A call that fails or gets invalid arguments rejects with an Error carrying the tool's error text; use Promise.allSettled to keep the calls that succeed. Tool calls are real: calls made before a failure are not undone, and calls still running when the script ends are cancelled.
-
-Call describeTool before using a tool whose arguments you have not seen. Scripts cannot call {MODEL_ONLY}.`;
-function resultContent(result2, started, maxOutputTokens) {
-  const seconds = ((Date.now() - started) / 1000).toFixed(1);
-  const items = [
-    { type: "text", text: result2.ok ? `Script completed in ${seconds}s` : `Script failed in ${seconds}s` }
-  ];
-  for (const item of result2.output) {
-    items.push(item.type === "text" ? { type: "text", text: item.text } : { type: "image", data: item.data, mimeType: item.mimeType });
-  }
-  if (result2.ok && result2.value !== undefined) {
-    items.push({ type: "text", text: typeof result2.value === "string" ? result2.value : JSON.stringify(result2.value) });
-  }
-  if (!result2.ok) {
-    const error = result2.error;
-    items.push({
-      type: "text",
-      text: error.kind === "timeout" ? "Script error: timed out" : error.kind === "aborted" ? "Script error: aborted" : `Script error: ${error.name ?? "Error"}: ${error.message}`
-    });
-  }
-  return truncateText(mergeText(items), (maxOutputTokens ?? 1e4) * 4);
-}
-function mergeText(items) {
-  const merged = [];
-  for (const item of items) {
-    const last = merged.at(-1);
-    if (item.type === "text" && last?.type === "text")
-      merged[merged.length - 1] = { type: "text", text: `${last.text}
-${item.text}` };
-    else
-      merged.push(item);
-  }
-  return merged;
-}
-function truncateText(items, budget) {
-  const total = items.reduce((sum, item) => sum + (item.type === "text" ? item.text.length : 0), 0);
-  if (total <= budget)
-    return items;
-  const headBudget = Math.floor(budget / 2);
-  const tailStart = total - (budget - headBudget);
-  const omitted = total - headBudget - (total - tailStart);
-  const out = [];
-  let offset = 0;
-  let marked = false;
-  for (const item of items) {
-    if (item.type !== "text") {
-      out.push(item);
-      continue;
-    }
-    const end = offset + item.text.length;
-    const head = item.text.slice(0, Math.max(headBudget - offset, 0));
-    const tail = end > tailStart ? item.text.slice(Math.max(tailStart - offset, 0)) : "";
-    if (head !== "")
-      out.push({ type: "text", text: head });
-    if (!marked && end >= headBudget) {
-      out.push({ type: "text", text: `
-[... ${omitted} characters omitted ...]
-` });
-      marked = true;
-    }
-    if (tail !== "")
-      out.push({ type: "text", text: tail });
-    offset = end;
-  }
-  return mergeText(out);
-}
 
 // apps/host/src/extensions/context.ts
 import { dirname, join, sep } from "node:path";
-import { defineExtension as defineExtension3, section as section2 } from "@earendil-works/pi-durable";
+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: defineExtension3({
+    extension: defineExtension2({
       name: "context",
       sections: [
-        section2("preamble", () => PREAMBLE, { tag: false }),
-        section2("environment", async (input, context) => {
+        section("preamble", () => PREAMBLE, { tag: false }),
+        section("environment", async (input, context) => {
           const cwd = input.agent.cwd;
           if (cwd === undefined)
             return;
-          const checkout = await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context);
-          if (checkout === undefined)
-            return `Working directory: ${cwd}`;
+          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}`,
-            `This directory is a git worktree PiNomad created for this conversation, on branch ${checkout.branch} starting from commit ${checkout.base.slice(0, 12)}.`,
+            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."
+            "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(`
 `);
         }),
-        section2("project_context", async (input, context) => {
+        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);
+          const checkout = (await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context))?.checkout;
           let files;
           if (checkout === undefined) {
             files = loadProjectContextFiles({ cwd, agentDir: agentsHome });
@@ -668,7 +310,7 @@ ${file.content}`).join(`
 
 `);
         }),
-        section2("skills", (input) => {
+        section("skills", (input) => {
           const cwd = input.agent.cwd;
           if (cwd === undefined)
             return;
@@ -692,68 +334,124 @@ import {
   AgentDoc,
   AssistantEntry,
   configure,
-  defineExtension as defineExtension4,
-  defineTool as defineTool3
+  defineExtension as defineExtension3,
+  defineTool as defineTool2,
+  section as section2
 } from "@earendil-works/pi-durable";
-import { Type as Type4 } from "typebox";
+import { Type as Type3 } from "typebox";
+
+// apps/host/src/subagent-doc.ts
+import { defineDoc as defineDoc2 } from "@earendil-works/pi-durable";
+var SubagentDoc = defineDoc2({
+  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_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+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 tool = defineTool3({
+  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",
-    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; `description` only labels the call. " + `Available models: ${available()}.`,
-    parameters: Type4.Object({
-      task: Type4.String({
+    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."
       }),
-      description: Type4.Optional(Type4.String({ description: 'A short 3-6 word label for the user, e.g. "Audit auth middleware".' })),
-      model: Type4.Optional(Type4.String({ description: "Optional `provider/modelId` to use instead of yours." })),
-      thinkingLevel: Type4.Optional(Type4.Union(THINKING_LEVELS.map((level) => Type4.Literal(level)), { description: "Optional thinking level instead of yours." }))
+      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)
-          return existing.id;
+        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 (args.model !== undefined) {
-          const slash = args.model.indexOf("/");
-          const provider = slash === -1 ? "" : args.model.slice(0, slash);
-          const modelId = slash === -1 ? "" : args.model.slice(slash + 1);
+        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(`Unknown model "${args.model}". Available models: ${available()}`);
+          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 (args.thinkingLevel !== undefined || override !== undefined) {
+        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 (args.thinkingLevel !== undefined) {
-            thinkingLevel = effective === undefined ? args.thinkingLevel : clampThinkingLevel(effective, args.thinkingLevel);
+          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: INSTRUCTIONS,
+          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);
-        return created.id;
+        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 }, context);
-      const handle = await api.conversation(child, 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} does not exist`);
+        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")
@@ -762,20 +460,39 @@ function createSubagent(options) {
       const message = answer?.model?.[0];
       const text = message?.role === "assistant" ? message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("") : "";
       const result2 = {
-        content: [{ type: "text", text: text === "" ? "(The subagent returned no text.)" : text }],
-        details: { conversationId: child }
+        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 = defineExtension4({ name: "subagent", tools: [tool] });
-  return { extension, modelOnly: ["subagent"] };
+  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 defineDoc2, defineExtension as defineExtension5, defineTool as defineTool4 } from "@earendil-works/pi-durable";
-import { Type as Type5 } from "typebox";
-var TodoDoc = defineDoc2({
+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",
   version: 1,
   scope: "conversation",
@@ -783,33 +500,30 @@ var TodoDoc = defineDoc2({
   fork: "asOf",
   initial: () => ({ items: [] })
 });
-var todoWrite = defineTool4({
+var todoWrite = defineTool3({
   name: "todo_write",
   description: "Replace the todo list shown to the user with the given items.",
-  parameters: Type5.Object({ items: Type5.Array(TodoItemSchema) }),
+  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 { content: [{ type: "text", text: `Todo list updated: ${args.items.length} item(s).` }] };
+    return { output: [{ type: "text", text: `Todo list updated: ${args.items.length} item(s).` }] };
   }
 });
 var todo = {
-  extension: defineExtension5({ name: "todo", tools: [todoWrite] }),
+  extension: defineExtension4({ name: "todo", tools: [todoWrite] }),
   docs: [{ token: TodoDoc, presentation: "pinomad.todo" }]
 };
 
 // apps/host/src/host.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile2, writeFile } from "node:fs/promises";
-import { basename as basename2, join as join5, sep as sep4 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
-import {
-  createRegistry,
-  Harness
-} from "@earendil-works/pi-durable";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, join as join7, sep as sep4 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } 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
@@ -818,7 +532,7 @@ import { basename, join as join3, resolve } from "node:path";
 import { clampThinkingLevel as clampThinkingLevel2 } from "@earendil-works/pi-ai";
 import {
   AgentDoc as AgentDoc2,
-  defineDoc as defineDoc3
+  defineDoc as defineDoc4
 } from "@earendil-works/pi-durable";
 
 // apps/host/src/checkout.ts
@@ -849,27 +563,6 @@ async function gitBase(projectPath) {
     return;
   return { repo, subdir: relative(repo, projectPath), base };
 }
-var SNAPSHOT_IDENTITY = {
-  GIT_AUTHOR_NAME: "PiNomad",
-  GIT_AUTHOR_EMAIL: "pinomad@localhost",
-  GIT_COMMITTER_NAME: "PiNomad",
-  GIT_COMMITTER_EMAIL: "pinomad@localhost"
-};
-async function snapshotOf(sourceDir) {
-  const indexFile = join2(tmpdir(), `pinomad-index-${randomBytes(8).toString("hex")}`);
-  const env = { GIT_INDEX_FILE: indexFile };
-  try {
-    const { stdout: head } = await git(sourceDir, ["rev-parse", "--verify", "HEAD"], env);
-    const base = head.trim();
-    await git(sourceDir, ["read-tree", base], env);
-    await git(sourceDir, ["add", "-A"], env);
-    const { stdout: tree } = await git(sourceDir, ["write-tree"], env);
-    const { stdout: commit } = await git(sourceDir, ["commit-tree", tree.trim(), "-p", base, "-m", "pinomad fork snapshot"], { ...env, ...SNAPSHOT_IDENTITY });
-    return { base, snapshot: commit.trim() };
-  } finally {
-    await rm(indexFile, { force: true });
-  }
-}
 var repoLocks = new Map;
 function locked(repo, work) {
   const next = (repoLocks.get(repo) ?? Promise.resolve()).then(work, work);
@@ -920,7 +613,7 @@ async function changesOf(dir, base, maxBytes = 1024 * 1024) {
   try {
     await git(dir, ["read-tree", "HEAD"], env);
     await git(dir, ["add", "-A"], env);
-    const { stdout } = await git(dir, ["diff", "--cached", "--no-color", "--find-renames", base], env);
+    const { stdout } = await git(dir, ["diff", "--cached", "--no-color", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", base], env);
     if (Buffer.byteLength(stdout) <= maxBytes)
       return { base, patch: stdout, truncated: false };
     const cut = stdout.slice(0, maxBytes);
@@ -932,8 +625,18 @@ async function changesOf(dir, base, maxBytes = 1024 * 1024) {
   }
 }
 
+// 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 = defineDoc3({
+var IndexDoc = defineDoc4({
   kind: "pinomad.index",
   version: 1,
   scope: "session",
@@ -984,7 +687,7 @@ async function createConversation(harness, dataDir, input, defaults, models, con
   if (prior !== undefined) {
     const existing = await harness.conversation(prior.id, context);
     if (existing !== undefined) {
-      await existing.submit({ type: "input", content: input.text, whenBusy: "followUp", requestId: input.requestId }, context);
+      await existing.submit({ type: "input", content: messageContent(input.text, input.images), whenBusy: "followUp", requestId: input.requestId }, context);
     }
     return prior.id;
   }
@@ -1036,14 +739,14 @@ async function createConversation(harness, dataDir, input, defaults, models, con
     }, context);
     if (home.kind === "chat")
       await mkdir(join3(dataDir, "chats", String(conversation.id)), { recursive: true });
-    await conversation.submit({ type: "input", content: input.text, whenBusy: "followUp", requestId: input.requestId }, context);
+    await conversation.submit({ type: "input", content: messageContent(input.text, input.images), 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: input.text, whenBusy: "followUp", requestId: input.requestId }, context);
+      await existing.submit({ type: "input", content: messageContent(input.text, input.images), whenBusy: "followUp", requestId: input.requestId }, context);
     }
     return error.conversationId;
   }
@@ -1057,21 +760,42 @@ async function archive(harness, id, archived, context) {
     entry.archived = archived;
   }, context);
 }
-async function checkoutInfo(input, context) {
+var forkFlags = new WeakMap;
+async function forkFlagOf(harness, id, context) {
+  const cached = forkFlags.get(harness)?.get(id);
+  if (cached !== undefined)
+    return cached;
+  const record = await harness.commit((tx) => tx.conversation(id), context);
+  if (record === undefined)
+    return false;
+  let flags = forkFlags.get(harness);
+  if (flags === undefined)
+    forkFlags.set(harness, flags = new Map);
+  flags.set(id, record.parent !== undefined);
+  return record.parent !== undefined;
+}
+async function checkoutInfo(harness, input, context) {
   const agent = await input.read.snapshot(AgentDoc2, input.conversationId, context);
   const cwd = agent?.cwd;
   if (cwd === undefined)
     return;
-  const index = await input.read.snapshot(IndexDoc, context);
-  const record = checkoutAt(index?.checkouts, cwd);
-  if (record === undefined)
-    return;
+  const [index, fork] = await Promise.all([
+    input.read.snapshot(IndexDoc, context),
+    forkFlagOf(harness, input.conversationId, context)
+  ]);
+  const checkout = checkoutAt(index?.checkouts, cwd);
   return {
-    branch: record.branch,
-    base: record.base,
-    projectPath: join3(record.repo, record.subdir),
-    repo: record.repo,
-    worktreeRoot: record.path
+    fork,
+    ...checkout === undefined ? {} : {
+      checkout: {
+        branch: checkout.branch,
+        base: checkout.base,
+        projectPath: join3(checkout.repo, checkout.subdir),
+        repo: checkout.repo,
+        worktreeRoot: checkout.path,
+        own: checkout.conversationId === input.conversationId
+      }
+    }
   };
 }
 async function cleanupArchivedWorktrees(harness, rootId, context) {
@@ -1126,8 +850,8 @@ import {
   StreamableHttpTransport,
   toLlmContent
 } from "@earendil-works/pi-mcp";
-import { defineExtension as defineExtension6, defineTool as defineTool5 } from "@earendil-works/pi-durable";
-import { Type as Type6 } from "typebox";
+import { defineExtension as defineExtension5, defineTool as defineTool4 } from "@earendil-works/pi-durable";
+import { Type as Type5 } from "typebox";
 var ENV_VAR = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 function expand(value) {
@@ -1249,32 +973,23 @@ var callToolResultSchema = (tool) => ({
   },
   required: ["content"]
 });
-function scriptTool(client, timeoutMs, server, description, name, tool) {
-  return {
+function mcpTool(client, timeoutMs, exposure, name, tool) {
+  return defineTool4({
     name,
     description: tool.description ?? tool.title ?? tool.name,
-    inputSchema: tool.inputSchema,
-    outputSchema: callToolResultSchema(tool),
-    namespace: {
-      name: server,
-      ...description === undefined ? {} : { description },
-      ...client.instructions === undefined ? {} : { instructions: client.instructions }
-    },
-    call: (args, signal) => client.callTool(tool.name, args, { signal, timeoutMs })
-  };
-}
-function asModelTool(tool) {
-  return defineTool5({
-    name: tool.name,
-    description: tool.description,
-    parameters: Type6.Unsafe({
+    parameters: Type5.Unsafe({
       ...tool.inputSchema,
       type: "object",
       properties: tool.inputSchema.properties ?? {}
     }),
+    ...exposure === "direct" ? {} : { callers: ["tools"] },
+    structuredOutputSchema: Type5.Unsafe(callToolResultSchema(tool)),
     execute: async (args, _api, context) => {
-      const result2 = await tool.call(args, context.abortSignal ?? NEVER_ABORT);
-      return { content: toLlmContent(result2), isError: result2.isError === true };
+      const result2 = await client.callTool(tool.name, args, {
+        signal: context.abortSignal ?? NEVER_ABORT,
+        timeoutMs
+      });
+      return { output: toLlmContent(result2), structuredOutput: result2, isError: result2.isError === true };
     }
   });
 }
@@ -1283,6 +998,7 @@ function startMcp(options) {
   const listeners = new Set;
   const servers = new Map;
   const toolsets = new Map;
+  const namespaces = new Map;
   const exposures = new Map;
   const live = new Set;
   let errors = [];
@@ -1293,8 +1009,8 @@ function startMcp(options) {
       listener(value);
   };
   const install = () => {
-    const direct = [...toolsets.entries()].flatMap(([name, tools]) => exposures.get(name) === "direct" ? tools.map(asModelTool) : []);
-    options.registry.install(defineExtension6({ name: "mcp", tools: direct }));
+    options.registry.install(defineExtension5({ name: "mcp", tools: [...toolsets.values()].flat() }));
+    options.onNamespaces?.([...namespaces.values()]);
   };
   const set = (name, patch) => {
     servers.set(name, { name, tools: 0, ...servers.get(name), ...patch });
@@ -1311,16 +1027,23 @@ function startMcp(options) {
         continue;
       }
       taken.add(wire);
-      tools.push(scriptTool(client, timeoutMs, name, description, wire, tool));
+      tools.push(mcpTool(client, timeoutMs, exposures.get(name) ?? "codemode", wire, tool));
     }
     if (closed)
       return;
     toolsets.set(name, tools);
+    namespaces.set(name, {
+      name,
+      ...description === undefined ? {} : { description },
+      ...client.instructions === undefined ? {} : { instructions: client.instructions },
+      prefix: callName(name, "")
+    });
     set(name, { state: "connected", tools: tools.length, error: collisions.length === 0 ? undefined : collisions.join("; ") });
     install();
   };
   const fail = (name, error) => {
     toolsets.delete(name);
+    namespaces.delete(name);
     set(name, { state: "failed", error, tools: 0 });
     install();
   };
@@ -1395,7 +1118,6 @@ ${stderr}`;
   });
   return {
     status,
-    scriptTools: () => [...toolsets.values()].flat(),
     async close() {
       closed = true;
       await Promise.all([...live].map((client) => client.close().catch(() => {})));
@@ -1403,22 +1125,559 @@ ${stderr}`;
   };
 }
 
+// apps/host/src/agent-roles.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync, 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 { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+
+// packages/protocol/src/agents.ts
+var MAX_AGENT_NAME = 32;
+var MAX_AGENT_DESCRIPTION = 1024;
+var NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function agentNameProblem(name) {
+  return name.length > MAX_AGENT_NAME || !NAME_PATTERN.test(name) ? `Name must be lowercase letters, digits and hyphens (max ${MAX_AGENT_NAME})` : undefined;
+}
+function agentRoleProblem(role) {
+  const name = agentNameProblem(role.name);
+  if (name !== undefined)
+    return name;
+  const description = role.description.trim();
+  if (description === "")
+    return "description is required";
+  if (description.length > MAX_AGENT_DESCRIPTION)
+    return `description is too long (max ${MAX_AGENT_DESCRIPTION})`;
+  if (role.model !== undefined) {
+    const slash = role.model.indexOf("/");
+    if (slash <= 0 || slash === role.model.length - 1)
+      return "model must be provider/modelId";
+  }
+  if (role.thinkingLevel !== undefined && !isThinkingLevel(role.thinkingLevel)) {
+    return `thinkingLevel must be one of ${THINKING_LEVELS.join(", ")}`;
+  }
+  return;
+}
+
+// apps/host/src/host-value.ts
+function constantValue(value) {
+  return {
+    value,
+    subscribe: () => () => {}
+  };
+}
+
+class Published {
+  #listeners = new Set;
+  #equal;
+  #value;
+  constructor(value, equal) {
+    this.#value = value;
+    this.#equal = equal;
+  }
+  get value() {
+    return this.#value;
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  set(next) {
+    if (this.#equal(this.#value, next))
+      return;
+    this.#value = next;
+    for (const listener of this.#listeners)
+      listener(next);
+  }
+}
+var sameList = (a, b, same) => a.length === b.length && a.every((entry, index) => same(entry, b[index]));
+
+// apps/host/src/agent-roles.ts
+var KNOWN_FIELDS = new Set(["description", "model", "thinkingLevel"]);
+async function load(dir) {
+  const roles = [];
+  const problems = [];
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md"))
+      continue;
+    const file = entry.name;
+    const name = file.slice(0, -".md".length);
+    const problem = (reason2) => void problems.push({ file, reason: reason2 });
+    let parsed;
+    try {
+      parsed = parseFrontmatter(await readFile2(join4(dir, file), "utf8"));
+    } catch (error) {
+      problem(`Couldn't parse the file: ${error instanceof Error ? error.message : String(error)}`);
+      continue;
+    }
+    if (typeof parsed.frontmatter !== "object" || parsed.frontmatter === null || Array.isArray(parsed.frontmatter)) {
+      problem("Frontmatter must be a record of fields");
+      continue;
+    }
+    const unknown = Object.keys(parsed.frontmatter).find((key) => !KNOWN_FIELDS.has(key));
+    if (unknown !== undefined) {
+      problem(`Unknown field "${unknown}"`);
+      continue;
+    }
+    const bad = Object.entries(parsed.frontmatter).find(([, value]) => typeof value !== "string");
+    if (bad !== undefined) {
+      problem(`Field "${bad[0]}" must be a string`);
+      continue;
+    }
+    const frontmatter = parsed.frontmatter;
+    const role = {
+      name,
+      description: frontmatter.description ?? "",
+      ...frontmatter.model === undefined ? {} : { model: frontmatter.model },
+      ...frontmatter.thinkingLevel === undefined ? {} : { thinkingLevel: frontmatter.thinkingLevel },
+      prompt: parsed.body.trim()
+    };
+    const reason = agentRoleProblem(role);
+    if (reason !== undefined) {
+      problem(reason);
+      continue;
+    }
+    roles.push(role);
+  }
+  roles.sort((a, b) => a.name.localeCompare(b.name));
+  problems.sort((a, b) => a.file.localeCompare(b.file));
+  return { roles, problems };
+}
+function serialize(role) {
+  const fields = [
+    `description: ${JSON.stringify(role.description)}`,
+    ...role.model === undefined ? [] : [`model: ${JSON.stringify(role.model)}`],
+    ...role.thinkingLevel === undefined ? [] : [`thinkingLevel: ${JSON.stringify(role.thinkingLevel)}`]
+  ];
+  return `---
+${fields.join(`
+`)}
+---
+
+${role.prompt}
+`;
+}
+var sameRole = (a, b) => a.name === b.name && a.description === b.description && a.model === b.model && a.thinkingLevel === b.thinkingLevel && a.prompt === b.prompt;
+var sameProblem = (a, b) => a.file === b.file && a.reason === b.reason;
+async function openAgentRoles(options) {
+  const dir = options.dir;
+  await mkdir2(dir, { recursive: true });
+  const debounceMs = options.debounceMs ?? 150;
+  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 () => {
+    try {
+      published.set(await load(dir));
+      reported = false;
+    } catch (error) {
+      if (!reported)
+        console.error(`agent-roles reload failed: ${error instanceof Error ? error.message : String(error)}`);
+      reported = true;
+    }
+  };
+  await reload();
+  const watcher = watch(dir, () => {
+    if (closed)
+      return;
+    clearTimeout(timer);
+    timer = setTimeout(() => void reload(), debounceMs);
+  });
+  watcher.on("error", (error) => {
+    if (!reported)
+      console.error(`agent-roles watch failed: ${error.message}`);
+    reported = true;
+  });
+  let pending = Promise.resolve();
+  const enqueue = (operation) => {
+    const run2 = pending.then(operation, operation);
+    pending = run2.then(() => {}, () => {});
+    return run2;
+  };
+  const write = async (role, mustExist) => {
+    const problem = agentRoleProblem(role);
+    if (problem !== undefined)
+      throw new Error(problem);
+    await enqueue(async () => {
+      const target = join4(dir, `${role.name}.md`);
+      const exists = existsSync(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`);
+      try {
+        await writeFile(temp, serialize(role));
+        await rename(temp, target);
+      } catch (error) {
+        await rm2(temp, { force: true }).catch(() => {});
+        throw error;
+      }
+      await reload();
+    });
+  };
+  return {
+    get value() {
+      return published.value;
+    },
+    subscribe: (listener) => published.subscribe(listener),
+    create: (role) => write(role, false),
+    update: (role) => write(role, true),
+    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-settings.ts
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+function settingsDefaults(settings) {
+  return {
+    ...settings.defaultModel === null ? {} : { model: settings.defaultModel },
+    ...settings.defaultThinkingLevel === null ? {} : { thinkingLevel: settings.defaultThinkingLevel }
+  };
+}
+var isModelRef = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.provider === "string" && value.provider !== "" && typeof value.modelId === "string" && value.modelId !== "";
+var fileValueError = (key, value, models) => {
+  switch (key) {
+    case "defaultModel":
+      if (!isModelRef(value))
+        return "malformed";
+      return models.some((each) => each.provider === value.provider && each.modelId === value.modelId) ? undefined : "unavailable";
+    case "defaultThinkingLevel":
+      return isThinkingLevel(value) ? undefined : "malformed";
+    case "steeringMode":
+    case "followUpMode":
+      return isQueueMode(value) ? undefined : "malformed";
+  }
+};
+var sameModel = (a, b) => a === b || a !== null && b !== null && a.provider === b.provider && a.modelId === b.modelId;
+var sameSettings = (a, b) => a.steeringMode === b.steeringMode && a.followUpMode === b.followUpMode && a.defaultThinkingLevel === b.defaultThinkingLevel && sameModel(a.defaultModel, b.defaultModel) && sameList(a.custom, b.custom, (x, y) => x === y);
+var parse = (path, text) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Invalid settings file ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Invalid settings file ${path}: expected a JSON object`);
+  }
+  return parsed;
+};
+async function openHostSettings(options) {
+  let file = await readFile3(options.path, "utf8").then((text) => parse(options.path, text), (error) => {
+    if (error.code === "ENOENT")
+      return {};
+    throw new Error(`Cannot read settings file ${options.path}: ${error instanceof Error ? error.message : String(error)}`);
+  });
+  const warned = new Set;
+  const compute = () => {
+    const fileValues = {};
+    const custom = [];
+    for (const key of HOST_SETTING_KEYS) {
+      if (!Object.hasOwn(file, key))
+        continue;
+      const value = file[key];
+      const invalid = fileValueError(key, value, options.models.value);
+      if (invalid === "malformed" && !warned.has(key)) {
+        warned.add(key);
+        console.error(`${options.path}: ignoring invalid value for settings key "${key}": ${JSON.stringify(value)}`);
+      }
+      if (invalid !== undefined)
+        continue;
+      fileValues[key] = value;
+      custom.push(key);
+    }
+    const { fallback } = options;
+    return {
+      defaultModel: fileValues.defaultModel ?? fallback.defaultModel(),
+      defaultThinkingLevel: fileValues.defaultThinkingLevel ?? fallback.defaultThinkingLevel(),
+      steeringMode: fileValues.steeringMode ?? fallback.steeringMode(),
+      followUpMode: fileValues.followUpMode ?? fallback.followUpMode(),
+      custom
+    };
+  };
+  const published = new Published(compute(), sameSettings);
+  options.models.subscribe(() => published.set(compute()));
+  let tail = Promise.resolve();
+  const write = async (patch) => {
+    const model = patch.defaultModel;
+    if (model !== undefined && model !== null && !options.models.value.some((each) => each.provider === model.provider && each.modelId === model.modelId)) {
+      throw new Error(`Unknown model: ${model.provider}/${model.modelId}`);
+    }
+    const next = { ...file };
+    for (const key of HOST_SETTING_KEYS) {
+      const value = patch[key];
+      if (value === undefined)
+        continue;
+      if (value === null)
+        delete next[key];
+      else
+        next[key] = value;
+    }
+    const tmp = `${options.path}.tmp`;
+    await mkdir3(dirname2(options.path), { recursive: true });
+    await writeFile2(tmp, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 });
+    await rename2(tmp, options.path);
+    file = next;
+    published.set(compute());
+  };
+  return {
+    get value() {
+      return published.value;
+    },
+    subscribe: (listener) => published.subscribe(listener),
+    update: (patch) => tail = tail.then(() => write(patch), () => write(patch))
+  };
+}
+
 // 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 { networkInterfaces } from "node:os";
-import { join as join4, relative as relative2, sep as sep3 } from "node:path";
-import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { homedir as homedir2, networkInterfaces } from "node:os";
+import { join as join6, sep as sep3 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
 import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
-  AgentDoc as AgentDoc3
+  AgentDoc as AgentDoc3,
+  LiveDoc
 } from "@earendil-works/pi-durable";
 import { WebSocket as WebSocket2, 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 };
+}
+
+// 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)`;
+    }
+    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`;
+  }
+  return;
+}
+
+// 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({
+  kind: "pinomad.title",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({})
+});
+
+// apps/host/src/auto-title.ts
+var context = BACKGROUND_CONTEXT;
+var TITLE_PROMPT = "You name conversations between a user and a coding agent. Reply with only the title: at most 6 words" + " (about 20 characters for Chinese or Japanese), in the same language as the user's message, no quotes," + " no trailing punctuation. Name the task, not the agent's answer.";
+var TITLE_INPUT_LIMIT = 2000;
+var TITLE_MAX_LENGTH = 80;
+var textOf = (content) => {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.flatMap((block) => typeof block === "object" && block !== null && block.type === "text" ? [block.text ?? ""] : []).join("");
+};
+function cleanTitle(raw) {
+  const line = raw.split(`
+`).map((each) => each.trim()).find((each) => each !== "");
+  if (line === undefined)
+    return;
+  let text = line.replace(/^\s*title\s*:\s*/i, "");
+  let before = "";
+  while (text !== before) {
+    before = text;
+    text = text.replace(/^["'“”‘’「」`]+/, "").replace(/["'“”‘’「」`]+$/, "").replace(/[.。!！?？]+$/, "");
+  }
+  text = text.replace(/\s+/g, " ").trim();
+  if (text === "")
+    return;
+  return text.length > TITLE_MAX_LENGTH ? text.slice(0, TITLE_MAX_LENGTH).trimEnd() : text;
+}
+function attachAutoTitle(runs, deps) {
+  const inFlight = new Set;
+  const pending = new Set;
+  const start = (id) => {
+    inFlight.add(id);
+    setImmediate(() => void title(id));
+  };
+  const title = async (id) => {
+    try {
+      const existing = await deps.harness.snapshot(TitleDoc, id, context);
+      if (typeof existing?.title === "string" && existing.title !== "")
+        return;
+      const conversation = await deps.harness.conversation(id, context);
+      if (conversation === undefined)
+        return;
+      let first;
+      let newest;
+      let cursor;
+      do {
+        const page = await conversation.entries({}, 256, cursor, context);
+        first = page.items.findLast((entry) => entry.kind === "pi.user" && entry.conversationId === id) ?? first;
+        newest ??= page.items.find((entry) => entry.conversationId === id && entry.kind === "pi.assistant");
+        cursor = page.next;
+      } while (cursor !== undefined);
+      const last = newest?.model?.[0];
+      if (first === undefined || last?.role !== "assistant" || last.stopReason === "error" || last.stopReason === "aborted") {
+        return;
+      }
+      const ref = deps.settings.value.defaultModel;
+      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 answer = textOf(last.content).slice(0, TITLE_INPUT_LIMIT);
+      const request = {
+        systemPrompt: TITLE_PROMPT,
+        messages: [
+          {
+            role: "user",
+            content: `User's first message:
+${firstText}${answer === "" ? "" : `
+
+Agent's reply:
+${answer}`}`,
+            timestamp: Date.now()
+          }
+        ]
+      };
+      const generated = await deps.models.completeSimple(model, request, { maxTokens: 256 });
+      const cleaned = cleanTitle(generated.content.flatMap((block) => block.type === "text" ? [block.text] : []).join(""));
+      if (generated.stopReason === "error" || cleaned === undefined) {
+        console.error(`auto-title: conversation ${id}: ${generated.stopReason === "error" ? generated.errorMessage ?? "provider error" : "unusable model output"}`);
+        return;
+      }
+      await deps.harness.commit(async (tx) => {
+        const doc = await tx.doc(TitleDoc, id);
+        if (typeof doc.title === "string" && doc.title !== "")
+          return;
+        doc.title = cleaned;
+        doc.source = "auto";
+      }, context);
+    } catch (error) {
+      console.error(`auto-title: conversation ${id}: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      inFlight.delete(id);
+      if (pending.delete(id))
+        start(id);
+    }
+  };
+  return runs.onRunEnd((id) => {
+    if (inFlight.has(id)) {
+      pending.add(id);
+      return;
+    }
+    start(id);
+  });
+}
+
+// packages/protocol/src/tool-target.ts
+var TARGET_KEYS = [
+  "path",
+  "file_path",
+  "filePath",
+  "command",
+  "cmd",
+  "query",
+  "pattern",
+  "url",
+  "name",
+  "description",
+  "task"
+];
+var TARGET_MAX_LENGTH = 120;
+function toolTarget(args) {
+  if (typeof args !== "object" || args === null)
+    return;
+  for (const key of TARGET_KEYS) {
+    const value = args[key];
+    if (typeof value === "string" && value.length > 0) {
+      return value.length > TARGET_MAX_LENGTH ? `${value.slice(0, TARGET_MAX_LENGTH)}…` : value;
+    }
+  }
+  return;
+}
+
 // apps/host/src/relay-link.ts
 import { WebSocket } from "ws";
 function relayWsBase(origin) {
@@ -1468,7 +1727,7 @@ function startRelayLink(options) {
       }
     }
   }, pingIntervalMs);
-  function watch(socket) {
+  function watch2(socket) {
     watched.add(socket);
     ponged.set(socket, true);
     socket.on("pong", () => ponged.set(socket, true));
@@ -1480,7 +1739,7 @@ function startRelayLink(options) {
       return;
     const socket = new WebSocket(`${wsBase}/host`, { handshakeTimeout: pingIntervalMs });
     control = socket;
-    watch(socket);
+    watch2(socket);
     socket.on("message", onControlMessage);
     socket.once("close", onControlClosed);
   }
@@ -1519,7 +1778,7 @@ function startRelayLink(options) {
           break;
         pendingAccepts += 1;
         const data2 = new WebSocket(`${wsBase}/accept/${frame.connId}`, { handshakeTimeout: pingIntervalMs });
-        watch(data2);
+        watch2(data2);
         const release = () => {
           pendingAccepts -= 1;
           clearTimeout(ageOut);
@@ -1566,9 +1825,26 @@ function startRelayLink(options) {
 }
 
 // apps/host/src/gateway.ts
-var context = BACKGROUND_CONTEXT;
+var context2 = BACKGROUND_CONTEXT2;
+var forkTails = new WeakMap;
+function serializedFork(harness, work) {
+  const next = (forkTails.get(harness) ?? Promise.resolve()).then(work, work);
+  const settled = next.then(() => {}, () => {});
+  forkTails.set(harness, settled);
+  settled.then(() => {
+    if (forkTails.get(harness) === settled)
+      forkTails.delete(harness);
+  });
+  return next;
+}
+var LOOPBACK_SECURE_PATH = "/secure";
 async function startGateway(options) {
-  const conversations = await ConversationList.open(options.harness);
+  const conversations = await ConversationList.open(options.harness, options.docs);
+  const detachAutoTitle = options.autoTitle === false ? undefined : attachAutoTitle(conversations, {
+    harness: options.harness,
+    models: options.models,
+    settings: options.settings
+  });
   const http = createServer((request, response) => {
     serveWebClient(request, response, options.webRoot).catch(() => {
       if (!response.headersSent)
@@ -1606,22 +1882,35 @@ async function startGateway(options) {
       },
       createPairing: () => {
         const spec = options.secure;
-        if (spec === undefined || remote === undefined && relay === undefined)
+        if (spec === undefined)
           return;
         const { secret, expiresAt } = spec.offers.create();
         const pair = `pair=${toBase64Url(spec.hostKey.publicKey)}.${secret}`;
         if (relay !== undefined) {
-          const target = `${relayWsBase(relay.origin)}/c/${relay.hostId}`;
-          return { url: `${relay.origin}/#${pair}&url=${encodeURIComponent(target)}`, expiresAt };
+          const target2 = `${relayWsBase(relay.origin)}/c/${relay.hostId}`;
+          return { url: `${relay.origin}/#${pair}&url=${encodeURIComponent(target2)}`, expiresAt };
         }
-        return { url: `${remote.advertiseUrl}/#${pair}`, expiresAt };
+        if (remote !== undefined)
+          return { url: `${remote.advertiseUrl}/#${pair}`, expiresAt };
+        const target = `ws://127.0.0.1:${port}${LOOPBACK_SECURE_PATH}`;
+        return { url: `http://127.0.0.1:${port}/#${pair}&url=${encodeURIComponent(target)}`, expiresAt };
       }
     });
     clients.add(client);
   };
   server.on("connection", (socket, request) => {
     socket.on("error", () => socket.terminate());
-    const token = new URL(request.url ?? "/", "ws://127.0.0.1").searchParams.get("token");
+    const url = new URL(request.url ?? "/", "ws://127.0.0.1");
+    if (url.pathname === LOOPBACK_SECURE_PATH) {
+      const secure2 = options.secure;
+      if (secure2 === undefined) {
+        socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
+        return;
+      }
+      secureHandshake(socket, secure2, options.harness, register);
+      return;
+    }
+    const token = url.searchParams.get("token");
     const origin = request.headers.origin;
     if (token !== options.token || origin !== undefined && !browserOrigins.includes(origin)) {
       socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
@@ -1659,6 +1948,7 @@ async function startGateway(options) {
     broadcast,
     async close() {
       await relay?.close();
+      detachAutoTitle?.();
       conversations.dispose();
       await Promise.all([...clients].map((client) => client.dispose()));
       for (const socket of server.clients)
@@ -1759,12 +2049,12 @@ function secureHandshake(socket, secure, harness, register) {
         return;
       }
       const deviceKey = toBase64Url(remoteStatic);
-      if (!await isRegistered(harness, deviceKey, context)) {
+      if (!await isRegistered(harness, deviceKey, context2)) {
         if (hello.pair === undefined || !secure.offers.consume(hello.pair.secret)) {
           socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
           return;
         }
-        await registerDevice(harness, { publicKey: deviceKey, name: hello.pair.name }, context);
+        await registerDevice(harness, { publicKey: deviceKey, name: hello.pair.name }, context2);
       }
       const { message, result: result2 } = responder.writeMessage2(encodeHostHello({ v: 1 }));
       return { result: result2, message, deviceKey };
@@ -1807,36 +2097,153 @@ async function startRemote(options, register) {
 
 class ConversationList {
   #listeners = new Set;
-  #list;
+  #questionTokens;
+  #questionKinds;
+  #records = new Map;
+  #facts = new Map;
+  #index = new Map;
+  #runEnd = new Set;
+  #list = [];
   #unsubscribe = () => {};
   #notifying = false;
-  constructor(list) {
-    this.#list = list;
+  constructor(docs) {
+    this.#questionTokens = (docs ?? []).filter((doc) => doc.presentation === "pinomad.question").map((doc) => doc.token);
+    this.#questionKinds = new Set(this.#questionTokens.map((token) => token.definition.kind));
   }
-  static async open(harness) {
+  static async open(harness, docs) {
+    const list = new ConversationList(docs);
     const summaries = [];
     let cursor;
     do {
-      const page = await harness.commit((tx) => tx.scanConversations({}, 256, cursor), context);
-      for (const record of page.items)
-        summaries.push({ ...summaryOf(record), ...await firstInput(harness, record.id) });
+      const page = await harness.commit((tx) => tx.scanConversations({}, 256, cursor), context2);
+      for (const record of page.items) {
+        list.#records.set(record.id, record);
+        const facts = await list.#load(harness, record);
+        list.#facts.set(record.id, facts);
+        list.#index.set(record.id, summaries.length);
+        summaries.push(summaryOf(record, facts));
+      }
       cursor = page.next;
     } while (cursor !== undefined);
-    const list = new ConversationList(summaries);
-    list.#unsubscribe = harness.subscribeCommits((publication) => {
-      let next = list.#list;
-      for (const change of publication.changes) {
-        if (change.type === "conversation") {
-          next = [...next, summaryOf(change.value)];
-        } else if (change.type === "entry" && change.value.kind === "pi.user") {
-          const id = change.value.conversationId;
-          next = next.map((summary) => summary.id === id && summary.title === undefined ? { ...summary, ...titleOf(change.value) } : summary);
+    list.#list = summaries;
+    list.#unsubscribe = harness.subscribeCommits((publication) => list.#observe(publication));
+    return list;
+  }
+  async#load(harness, record) {
+    const history = await historyFacts(harness, record.id);
+    const facts = { pending: new Set, ...history };
+    const live = await harness.snapshot(LiveDoc, record.id, context2);
+    facts.running = live?.run !== undefined;
+    facts.tools = live?.tools;
+    for (const token of this.#questionTokens) {
+      const value = await harness.snapshot(token, record.id, context2);
+      if (Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined)) {
+        facts.pending.add(token.definition.kind);
+      }
+    }
+    if (record.owner !== undefined) {
+      const subagent = await harness.snapshot(SubagentDoc, record.id, context2);
+      if (typeof subagent?.label === "string" && subagent.label !== "")
+        facts.label = subagent.label;
+      if (typeof subagent?.role === "string" && subagent.role !== "")
+        facts.role = subagent.role;
+    }
+    const named = (await harness.snapshot(TitleDoc, record.id, context2))?.title;
+    if (typeof named === "string" && named !== "")
+      facts.named = named;
+    return facts;
+  }
+  #observe(publication) {
+    const touched = new Set;
+    const ended = new Set;
+    for (const change of publication.changes) {
+      if (change.type === "conversation") {
+        this.#records.set(change.value.id, change.value);
+        touched.add(change.value.id);
+      }
+    }
+    for (const change of publication.changes) {
+      if (change.type === "entry") {
+        const entry = change.value;
+        if (entry.kind !== "pi.user" && entry.kind !== "pi.assistant")
+          continue;
+        const facts = this.#fact(entry.conversationId);
+        if (entry.kind === "pi.user" && facts.title === undefined)
+          Object.assign(facts, titleOf(entry));
+        if (facts.newest !== undefined && entry.id <= facts.newest)
+          continue;
+        touched.add(entry.conversationId);
+        facts.newest = entry.id;
+        const message = entry.model?.[0];
+        facts.updatedAt = typeof message?.timestamp === "number" ? message.timestamp : undefined;
+        facts.failed = entry.kind === "pi.assistant" && message?.role === "assistant" && message.stopReason === "error";
+        facts.calls = entry.kind === "pi.assistant" ? callsOf(message) : undefined;
+      } else if (change.type === "document") {
+        const id = change.conversationId;
+        if (id === undefined)
+          continue;
+        const facts = this.#fact(id);
+        if (change.record.kind === "pi.live") {
+          const live = change.value;
+          const wasRunning = facts.running === true;
+          facts.running = live?.run !== undefined;
+          facts.tools = live?.tools;
+          touched.add(id);
+          if (wasRunning && !facts.running && this.#records.get(id)?.owner === undefined)
+            ended.add(id);
+        } else if (this.#questionKinds.has(change.record.kind)) {
+          const value = change.value;
+          const pending = Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined);
+          const next2 = new Set(facts.pending);
+          if (pending)
+            next2.add(change.record.kind);
+          else
+            next2.delete(change.record.kind);
+          facts.pending = next2;
+          touched.add(id);
+        } else if (change.record.kind === SubagentDoc.definition.kind) {
+          const value = change.value;
+          facts.label = typeof value?.label === "string" && value.label !== "" ? value.label : undefined;
+          facts.role = typeof value?.role === "string" && value.role !== "" ? value.role : undefined;
+          touched.add(id);
+        } else if (change.record.kind === TitleDoc.definition.kind) {
+          const named = change.value?.title;
+          facts.named = typeof named === "string" && named !== "" ? named : undefined;
+          touched.add(id);
         }
       }
-      if (next !== list.#list)
-        list.#set(next);
-    });
-    return list;
+    }
+    let next;
+    for (const id of touched) {
+      const record = this.#records.get(id);
+      if (record === undefined)
+        continue;
+      const summary = summaryOf(record, this.#fact(id));
+      const index = this.#index.get(id);
+      if (index === undefined) {
+        next ??= this.#list.slice();
+        this.#index.set(id, next.length);
+        next.push(summary);
+      } else if (!sameSummary(this.#list[index], summary)) {
+        next ??= this.#list.slice();
+        next[index] = summary;
+      }
+    }
+    if (next !== undefined)
+      this.#set(next);
+    for (const id of ended)
+      for (const listener of this.#runEnd)
+        listener(id);
+  }
+  onRunEnd(listener) {
+    this.#runEnd.add(listener);
+    return () => this.#runEnd.delete(listener);
+  }
+  #fact(id) {
+    let facts = this.#facts.get(id);
+    if (facts === undefined)
+      this.#facts.set(id, facts = { pending: new Set });
+    return facts;
   }
   get value() {
     return this.#list;
@@ -1861,31 +2268,72 @@ class ConversationList {
     this.#listeners.clear();
   }
 }
-function summaryOf(record) {
+function summaryOf(record, facts) {
   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;
+  const activity = runningSlot === undefined ? undefined : {
+    tool: runningSlot.name,
+    ...facts.calls?.get(runningSlot.callId) === undefined ? {} : { target: facts.calls.get(runningSlot.callId) }
+  };
   return {
     id: record.id,
     kind: record.owner !== undefined ? "subagent" : record.parent !== undefined ? "fork" : "conversation",
-    ...parent === undefined ? {} : { parent }
+    ...parent === undefined ? {} : { parent },
+    ...record.parent === undefined ? {} : { forkedAt: String(record.parent.at) },
+    ...(facts.named ?? facts.title) === undefined ? {} : { title: facts.named ?? facts.title },
+    ...status === undefined ? {} : { status },
+    ...facts.updatedAt === undefined ? {} : { updatedAt: facts.updatedAt },
+    ...facts.label === undefined ? {} : { label: facts.label },
+    ...facts.role === undefined ? {} : { role: facts.role },
+    ...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;
+}
 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(" ");
-  return { title: text.replace(/\s+/g, " ").trim() };
+  const title = text.replace(/\s+/g, " ").trim();
+  return title === "" ? {} : { title };
 }
-async function firstInput(harness, id) {
-  const conversation = await harness.conversation(id, context);
+async function historyFacts(harness, id) {
+  const conversation = await harness.conversation(id, context2);
   let first;
+  let newest;
   let cursor;
   do {
-    const page = await conversation.entries({}, 256, cursor, context);
-    first = page.items.findLast((entry) => entry.kind === "pi.user" && entry.conversationId === id) ?? first;
+    const page = await conversation.entries({}, 256, cursor, context2);
+    first = page.items.findLast((entry) => entry.kind === "pi.user" && entry.conversationId === id && titleOf(entry).title !== undefined) ?? first;
+    newest ??= page.items.find((entry) => entry.conversationId === id && (entry.kind === "pi.user" || entry.kind === "pi.assistant"));
     cursor = page.next;
   } while (cursor !== undefined);
-  return titleOf(first);
+  const message = newest?.model?.[0];
+  return {
+    ...titleOf(first),
+    ...newest === undefined ? {} : {
+      newest: newest.id,
+      ...typeof message?.timestamp === "number" ? { updatedAt: message.timestamp } : {},
+      failed: newest.kind === "pi.assistant" && message?.role === "assistant" && message.stopReason === "error",
+      ...newest.kind === "pi.assistant" ? { calls: callsOf(message) } : {}
+    }
+  };
+}
+function callsOf(message) {
+  if (message?.role !== "assistant")
+    return;
+  const content = message.content;
+  if (!Array.isArray(content))
+    return;
+  const calls = new Map;
+  for (const block of content) {
+    if (block?.type === "toolCall" && typeof block.id === "string")
+      calls.set(block.id, toolTarget(block.arguments));
+  }
+  return calls.size === 0 ? undefined : calls;
 }
 
 class GatewayClient {
@@ -1893,38 +2341,59 @@ class GatewayClient {
   #connection;
   #hooks;
   #options;
-  #conversations;
+  #hostValues;
   #subscriptions = new Map;
   #disposed = false;
   constructor(connection, options, conversations, hooks) {
     this.#connection = connection;
     this.#options = options;
-    this.#conversations = conversations;
+    this.#hostValues = {
+      conversations,
+      mcp: options.mcp ?? constantValue(null),
+      models: options.modelAuth?.models ?? constantValue(options.modelSummaries()),
+      auth: options.modelAuth?.auth ?? constantValue({ logins: [] }),
+      settings: options.settings,
+      agents: options.agents ?? constantValue({ roles: [], problems: [] })
+    };
     this.#hooks = hooks;
     this.devicePublicKey = hooks.devicePublicKey;
     connection.handle({
       message: (text) => {
-        let frame;
+        let parsed;
         try {
-          frame = JSON.parse(text);
+          parsed = parseClientFrame(JSON.parse(text));
         } catch {
-          connection.close(1008, "Invalid client frame");
+          connection.close(INVALID_FRAME_CLOSE_CODE, "Invalid client frame");
           return;
         }
-        if (!isClientFrame(frame)) {
-          connection.close(1008, "Invalid client frame");
-          return;
+        switch (parsed.kind) {
+          case "frame":
+            this.#receive(parsed.frame).catch(() => connection.close(1011, "Gateway request failed"));
+            return;
+          case "unsupportedCall":
+            this.send({ type: "result", id: parsed.id, ok: false, error: `Unsupported method: ${parsed.method}` });
+            return;
+          case "unsupportedStream":
+            if (parsed.type === "subscribe") {
+              this.send({ type: "ended", stream: parsed.stream, reason: "Unsupported stream" });
+            }
+            return;
+          case "unknownType":
+            return;
+          case "malformed":
+            connection.close(INVALID_FRAME_CLOSE_CODE, "Invalid client frame");
+            return;
         }
-        this.#receive(frame).catch(() => connection.close(1011, "Gateway request failed"));
       },
       closed: () => hooks.closed(this)
     });
     this.send({
       type: "hello",
-      protocol: PROTOCOL_VERSION,
+      protocol: PROTOCOL,
+      ...packagedVersion === undefined ? {} : { hostVersion: packagedVersion },
       session: options.session,
       models: options.modelSummaries(),
-      defaults: options.defaults,
+      defaults: settingsDefaults(options.settings.value),
       docs: (options.docs ?? []).map((doc) => ({
         kind: doc.token.definition.kind,
         ...doc.presentation === undefined ? {} : { presentation: doc.presentation }
@@ -1975,36 +2444,34 @@ class GatewayClient {
     state.subscription = subscription;
   }
   async#open(stream, send) {
-    if (stream === "conversations") {
-      send({ type: "snapshot", stream, value: this.#conversations.value });
-      const unsubscribe = this.#conversations.subscribe((value) => void send({ type: "snapshot", stream, value }));
-      return { stop: unsubscribe };
+    const source = this.#hostValue(stream);
+    if (source !== undefined) {
+      send({ type: "snapshot", stream, value: source.value });
+      return { stop: source.subscribe((value) => void send({ type: "snapshot", stream, value })) };
     }
     if (stream === "index") {
-      const watch = await this.#options.harness.watchDoc(IndexDoc, context);
-      if (watch === undefined)
+      const watch2 = await this.#options.harness.watchDoc(IndexDoc, context2);
+      if (watch2 === undefined)
         throw new Error("Index document is missing");
-      return this.#forward(stream, watch, send);
+      return this.#forward(stream, watch2, send);
     }
     if (stream === "devices") {
-      const watch = await this.#options.harness.watchDoc(DevicesDoc, context);
-      if (watch === undefined)
+      const watch2 = await this.#options.harness.watchDoc(DevicesDoc, context2);
+      if (watch2 === undefined)
         throw new Error("Devices document is missing");
-      return this.#forward(stream, watch, send);
+      return this.#forward(stream, watch2, send);
     }
     if (stream === "tasks")
-      return this.#forward(stream, await this.#options.harness.watchTaskGraph(context), send);
-    if (stream === "mcp") {
-      await send({ type: "snapshot", stream, value: this.#options.mcp?.value ?? null });
-      const mcp = this.#options.mcp;
-      return mcp === undefined ? { stop: () => {} } : { stop: mcp.subscribe((value) => void send({ type: "snapshot", stream, value })) };
-    }
+      return this.#forward(stream, await this.#options.harness.watchTaskGraph(context2), send);
     if (stream.startsWith("doc:")) {
       const at = stream.lastIndexOf(":");
       return this.#openDoc(stream, stream.slice("doc:".length, at), Number(stream.slice(at + 1)), send);
     }
     const conversation = await this.#conversation(Number(stream.slice("conversation:".length)));
-    return this.#forward(stream, await conversation.watch(context), send);
+    return this.#forward(stream, await conversation.watch(context2), send);
+  }
+  #hostValue(stream) {
+    return Object.hasOwn(this.#hostValues, stream) ? this.#hostValues[stream] : undefined;
   }
   async#openDoc(stream, kind, id, send) {
     const doc = this.#options.docs?.find((candidate) => candidate.token.definition.kind === kind);
@@ -2027,7 +2494,7 @@ class GatewayClient {
       setImmediate(() => signalCreation());
     });
     try {
-      const existing = await harness.watchDoc(token, id, context);
+      const existing = await harness.watchDoc(token, id, context2);
       if (existing !== undefined) {
         unsubscribe();
         return this.#forward(stream, existing, send);
@@ -2040,13 +2507,13 @@ class GatewayClient {
     created.then(async () => {
       if (stopped)
         return;
-      const watch = await harness.watchDoc(token, id, context);
-      if (watch === undefined)
+      const watch2 = await harness.watchDoc(token, id, context2);
+      if (watch2 === undefined)
         return;
       if (stopped)
-        await watch.stop();
+        await watch2.stop();
       else {
-        inner = await this.#forward(stream, watch, send);
+        inner = await this.#forward(stream, watch2, send);
         if (stopped)
           await inner.stop();
       }
@@ -2063,10 +2530,10 @@ class GatewayClient {
       }
     };
   }
-  async#forward(stream, watch, send) {
-    await send({ type: "snapshot", stream, value: watch.value });
-    watch.start((_value, ops) => send({ type: "ops", stream, ops }));
-    return watch;
+  async#forward(stream, watch2, send) {
+    await send({ type: "snapshot", stream, value: watch2.value });
+    watch2.start((_value, ops) => send({ type: "ops", stream, ops }));
+    return watch2;
   }
   async#unsubscribe(stream) {
     const subscription = this.#subscriptions.get(stream);
@@ -2074,7 +2541,7 @@ class GatewayClient {
     await subscription?.subscription?.stop();
   }
   async#conversation(id) {
-    const conversation = await this.#options.harness.conversation(id, context);
+    const conversation = await this.#options.harness.conversation(id, context2);
     if (conversation === undefined)
       throw new Error(`Conversation ${id} does not exist`);
     return conversation;
@@ -2090,27 +2557,31 @@ class GatewayClient {
   async#call(method, args) {
     switch (method) {
       case "addProject":
-        return addProject(this.#options.harness, args.path, context);
+        return addProject(this.#options.harness, args.path, context2);
       case "removeProject":
-        await removeProject(this.#options.harness, args.path, context);
+        await removeProject(this.#options.harness, args.path, context2);
         return null;
       case "createConversation": {
         const create = args;
+        const problem = imageProblem(create.images ?? []);
+        if (problem !== undefined)
+          throw new Error(problem);
         const conversationId = await createConversation(this.#options.harness, this.#options.dataDir, {
           home: create.home,
           text: create.text,
           requestId: create.requestId,
+          ...create.images === undefined ? {} : { images: create.images },
           ...create.checkout === undefined ? {} : { checkout: create.checkout },
           ...create.model === undefined ? {} : { model: create.model },
           ...create.thinkingLevel === undefined ? {} : { thinkingLevel: create.thinkingLevel }
-        }, this.#options.defaults, this.#options.models, context);
+        }, settingsDefaults(this.#options.settings.value), this.#options.models, context2);
         return { conversationId };
       }
       case "archive": {
         const input = args;
-        await archive(this.#options.harness, input.conversationId, input.archived, context);
+        await archive(this.#options.harness, input.conversationId, input.archived, context2);
         if (input.archived) {
-          const kept = await cleanupArchivedWorktrees(this.#options.harness, input.conversationId, context);
+          const kept = await cleanupArchivedWorktrees(this.#options.harness, input.conversationId, context2);
           for (const { record, reason } of kept) {
             await this.send({ type: "notice", level: "warning", message: `Kept worktree ${record.path} (branch ${record.branch}): ${reason}` });
           }
@@ -2125,31 +2596,88 @@ class GatewayClient {
       }
       case "revokeDevice": {
         const { publicKey } = args;
-        await revokeDevice(this.#options.harness, publicKey, context);
+        await revokeDevice(this.#options.harness, publicKey, context2);
         this.#hooks.closeDevice(publicKey);
         return null;
       }
+      case "logout": {
+        const modelAuth = this.#options.modelAuth;
+        if (modelAuth === undefined)
+          throw new Error("Logging out is not available on this host");
+        await modelAuth.logout(args.providerId);
+        return null;
+      }
+      case "updateSettings": {
+        await this.#options.settings.update(args.patch);
+        return null;
+      }
+      case "createAgent": {
+        const store = this.#options.agents;
+        if (store === undefined)
+          throw new Error("Named agents are not available on this host");
+        await store.create(args.role);
+        return null;
+      }
+      case "updateAgent": {
+        const store = this.#options.agents;
+        if (store === undefined)
+          throw new Error("Named agents are not available on this host");
+        await store.update(args.role);
+        return null;
+      }
+      case "deleteAgent": {
+        const store = this.#options.agents;
+        if (store === undefined)
+          throw new Error("Named agents are not available on this host");
+        await store.remove(args.name);
+        return null;
+      }
+      case "listFolders":
+        return listFolders(args.path, homedir2());
     }
     const conversation = await this.#conversation(args.conversationId);
     switch (method) {
       case "submit": {
-        const { text, whenBusy, requestId } = args;
-        const dismissed = await this.#dismissPendingQuestions(conversation.id, context);
-        const submission = await conversation.submit({ type: "input", content: text, whenBusy: dismissed ? "steer" : whenBusy, requestId }, context);
-        submission.wait(context).then((settled) => {
+        const { text, whenBusy, requestId, images } = args;
+        const problem = imageProblem(images ?? []);
+        if (problem !== undefined)
+          throw new Error(problem);
+        const dismissed = await this.#dismissPendingQuestions(conversation.id, context2);
+        const submission = await conversation.submit({ type: "input", content: messageContent(text, images), whenBusy: dismissed ? "steer" : whenBusy, requestId }, context2);
+        submission.wait(context2).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 "renameConversation": {
+        const { title } = args;
+        const trimmed = title.trim();
+        if (trimmed === "")
+          throw new Error("Title cannot be empty");
+        if (trimmed.length > 200)
+          throw new Error("Title is too long (200 characters at most)");
+        await this.#options.harness.commit(async (tx) => {
+          const record = await tx.conversation(conversation.id);
+          if (record === undefined)
+            throw new Error(`Conversation ${conversation.id} does not exist`);
+          if (record.owner !== undefined) {
+            throw new Error("Subagent conversations are named by the call that started them");
+          }
+          const doc = await tx.doc(TitleDoc, conversation.id);
+          doc.title = trimmed;
+          doc.source = "manual";
+        }, context2);
+        return null;
+      }
       case "abort":
-        await conversation.abort(context);
+        await conversation.abort(context2);
         return null;
       case "compact": {
         const { instructions } = args;
-        const taskId = await conversation.compact(instructions, context);
-        this.#options.harness.waitForTask(taskId, context).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
+        const taskId = await conversation.compact(instructions, context2);
+        this.#options.harness.waitForTask(taskId, context2).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
         return { taskId };
       }
       case "setModel": {
@@ -2158,7 +2686,7 @@ class GatewayClient {
         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) }, context);
+        await conversation.configure({ model: ref, thinkingLevel: clampThinkingLevel3(model, thinking) }, context2);
         return null;
       }
       case "setThinkingLevel": {
@@ -2170,20 +2698,39 @@ class GatewayClient {
         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 }, context);
+        await conversation.configure({ thinkingLevel: level }, context2);
         return null;
       }
       case "fork": {
         const { entryId, removeTools = [] } = args;
-        const agent = await conversation.agent(context);
-        const remove = agent.tools.filter((tool) => removeTools.includes(tool.name));
-        const init = await this.#forkCheckout(agent.cwd);
-        const fork = await conversation.fork(Number(entryId), {
-          ownership: { kind: "ownerless" },
-          ...remove.length === 0 ? {} : { agent: { tools: { remove } } },
-          ...init === undefined ? {} : { init }
-        }, context);
-        return { conversationId: fork.id };
+        return await serializedFork(this.#options.harness, async () => {
+          const at = Number(entryId);
+          await this.#options.harness.commit(async (tx) => {
+            const record = await tx.conversation(conversation.id);
+            if (record === undefined)
+              throw new Error(`Conversation ${conversation.id} does not exist`);
+            if (record.parent !== undefined || record.owner !== undefined) {
+              throw new Error("Only top-level conversations can be forked");
+            }
+            let cursor;
+            do {
+              const page = await tx.scanConversations({}, 256, cursor);
+              for (const candidate of page.items) {
+                if (candidate.parent?.conversationId === conversation.id && candidate.parent.at === at) {
+                  throw new Error("This message already has a fork");
+                }
+              }
+              cursor = page.next;
+            } while (cursor !== undefined);
+          }, context2);
+          const agent = await conversation.agent(context2);
+          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 } } }
+          }, context2);
+          return { conversationId: fork.id };
+        });
       }
       case "answer": {
         const { kind, requestId, answers } = args;
@@ -2217,16 +2764,16 @@ class GatewayClient {
           }
           request.resolution = { outcome: "answered", answers, at: Date.now() };
           return { first: true };
-        }, context);
+        }, context2);
       }
       case "changes": {
-        return await this.#changes(conversation, context);
+        return await this.#changes(conversation, context2);
       }
     }
   }
-  async#dismissPendingQuestions(conversationId, context2) {
+  async#dismissPendingQuestions(conversationId, context3) {
     const questionDocs = (this.#options.docs ?? []).filter((doc) => doc.presentation === "pinomad.question");
-    const snapshots = await Promise.all(questionDocs.map((doc) => this.#options.harness.snapshot(doc.token, conversationId, context2)));
+    const snapshots = await Promise.all(questionDocs.map((doc) => this.#options.harness.snapshot(doc.token, conversationId, context3)));
     const pending = snapshots.some((value) => Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined));
     if (!pending)
       return false;
@@ -2244,18 +2791,18 @@ class GatewayClient {
         }
       }
       return dismissed;
-    }, context2);
+    }, context3);
   }
   get #chatsPrefix() {
-    return join4(this.#options.dataDir, "chats") + sep3;
+    return join6(this.#options.dataDir, "chats") + sep3;
   }
-  async#changes(conversation, context2) {
-    const cwd = (await conversation.agent(context2)).cwd;
+  async#changes(conversation, context3) {
+    const cwd = (await conversation.agent(context3)).cwd;
     if (cwd === undefined)
       return { available: false, reason: "No working directory" };
     if (cwd.startsWith(this.#chatsPrefix))
       return { available: false, reason: "Chat conversations have no repository" };
-    const index = await this.#options.harness.snapshot(IndexDoc, context2);
+    const index = await this.#options.harness.snapshot(IndexDoc, context3);
     const record = checkoutAt(index?.checkouts, cwd);
     if (record !== undefined) {
       if (!await worktreeExists(record.path))
@@ -2267,43 +2814,8 @@ class GatewayClient {
       return { available: false, reason: "Not in a git repository" };
     return { available: true, ...await changesOf(base.repo, base.base) };
   }
-  async#forkCheckout(cwd) {
-    if (cwd === undefined)
-      return;
-    const index = await this.#options.harness.snapshot(IndexDoc, context);
-    const existing = checkoutAt(index?.checkouts, cwd);
-    let source;
-    if (existing !== undefined) {
-      source = { repo: existing.repo, dir: existing.path, subdir: relative2(existing.path, cwd) };
-    } else {
-      if (cwd.startsWith(this.#chatsPrefix))
-        return;
-      const base2 = await gitBase(cwd);
-      if (base2 === undefined)
-        return;
-      source = { repo: base2.repo, dir: base2.repo, subdir: base2.subdir };
-    }
-    const { base, snapshot } = await snapshotOf(source.dir);
-    const suffix = branchSuffix();
-    return async (tx, id) => {
-      const path = worktreePath(this.#options.dataDir, id);
-      const doc = await tx.doc(IndexDoc);
-      if (doc.checkouts === undefined)
-        doc.checkouts = [];
-      doc.checkouts.push({
-        conversationId: id,
-        path,
-        repo: source.repo,
-        subdir: source.subdir,
-        branch: worktreeBranch(id, suffix),
-        base,
-        snapshot
-      });
-      (await tx.doc(AgentDoc3, id)).cwd = join4(path, source.subdir);
-    };
-  }
   async#agent(id) {
-    return await this.#options.harness.snapshot(AgentDoc3, id, context) ?? {};
+    return await this.#options.harness.snapshot(AgentDoc3, id, context2) ?? {};
   }
   async dispose() {
     if (this.#disposed)
@@ -2317,20 +2829,20 @@ class GatewayClient {
 }
 
 // apps/host/src/host.ts
-var context2 = BACKGROUND_CONTEXT2;
+var context3 = BACKGROUND_CONTEXT3;
 async function hostToken(dataDir) {
-  const path = join5(dataDir, "token");
+  const path = join7(dataDir, "token");
   try {
-    return (await readFile2(path, "utf8")).trim();
+    return (await readFile4(path, "utf8")).trim();
   } catch {
-    const token = randomBytes2(24).toString("base64url");
-    await writeFile(path, `${token}
+    const token = randomBytes3(24).toString("base64url");
+    await writeFile3(path, `${token}
 `, { mode: 384 });
     return token;
   }
 }
 async function openHost(options) {
-  await mkdir2(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,
@@ -2341,18 +2853,43 @@ async function openHost(options) {
   });
   let harness;
   let mcp;
+  let agentRoles;
+  let extensions = [];
   try {
     const token = await hostToken(options.dataDir);
     const reports = [];
     let report = (error) => void reports.push(error);
     const registry = createRegistry();
-    const extensions = typeof options.extensions === "function" ? options.extensions({ scriptTools: () => mcp?.scriptTools() ?? [] }) : options.extensions ?? [];
+    agentRoles = await openAgentRoles({ dir: join7(options.dataDir, "agents") });
+    extensions = typeof options.extensions === "function" ? options.extensions({
+      harness: () => {
+        if (harness === undefined)
+          throw new Error("harness is not open yet");
+        return harness;
+      },
+      agentRoles
+    }) : options.extensions ?? [];
     for (const { extension } of extensions)
       registry.install(extension);
-    mcp = options.mcpConfig === undefined ? undefined : startMcp({ configPath: options.mcpConfig, registry });
+    mcp = options.mcpConfig === undefined ? undefined : startMcp({
+      configPath: options.mcpConfig,
+      registry,
+      onNamespaces: (namespaces) => {
+        for (const each of extensions) {
+          const rebuilt = each.namespaced?.(namespaces);
+          if (rebuilt !== undefined)
+            registry.install(rebuilt);
+        }
+      }
+    });
+    const hostSettings = await openHostSettings({
+      path: join7(options.dataDir, "settings.json"),
+      fallback: options.settingsFallback,
+      models: options.modelAuth?.models ?? constantValue(options.modelSummaries())
+    });
     const environments = new Map;
-    const chatsDir = join5(options.dataDir, "chats");
-    harness = await Harness.open(await openNodeSqliteStorage(join5(options.dataDir, "session.sqlite")), {
+    const chatsDir = join7(options.dataDir, "chats");
+    harness = await Harness.open(await (options.openStorage ?? openNodeSqliteStorage)(join7(options.dataDir, "session.sqlite")), {
       models: options.models,
       registry,
       env: async (target) => {
@@ -2361,15 +2898,15 @@ async function openHost(options) {
           return;
         const worktrees = worktreeRoot(options.dataDir);
         if (cwd === worktrees || cwd.startsWith(worktrees + sep4)) {
-          const index = await target.read.snapshot(IndexDoc, context2);
+          const index = await target.read.snapshot(IndexDoc, context3);
           const record = checkoutAt(index?.checkouts, cwd);
           if (record !== undefined) {
             await ensureWorktree(record);
-            await mkdir2(cwd, { recursive: true });
+            await mkdir4(cwd, { recursive: true });
           }
         }
         if (cwd.startsWith(`${chatsDir}/`))
-          await mkdir2(cwd, { recursive: true });
+          await mkdir4(cwd, { recursive: true });
         let env = environments.get(cwd);
         if (env === undefined) {
           env = new NodeExecutionEnv({ cwd });
@@ -2377,54 +2914,51 @@ async function openHost(options) {
         }
         return env;
       },
-      ...options.settings === undefined ? {} : { settings: options.settings },
+      ...options.settings === undefined ? {} : {
+        settings: typeof options.settings === "function" ? options.settings(hostSettings) : options.settings
+      },
       onReport: (error) => report(error)
-    }, context2);
-    const { initialModel } = options;
-    await ensureIndex(harness, context2);
-    await ensureDevices(harness, context2);
+    }, context3);
+    await ensureIndex(harness, context3);
+    await ensureDevices(harness, context3);
     for (const path of options.projects ?? [])
-      await addProject(harness, path, context2);
-    const remoteAccess = options.remote !== undefined || options.relay !== undefined;
-    const hostKey = remoteAccess ? await loadHostKey(options.dataDir) : undefined;
-    const offers = remoteAccess ? pairingOffers(options.remote?.pairingTtlMs) : undefined;
+      await addProject(harness, path, context3);
+    const hostKey = await loadHostKey(options.dataDir);
+    const offers = pairingOffers(options.remote?.pairingTtlMs);
     const relayKey = options.relay === undefined ? undefined : await loadRelayKey(options.dataDir);
-    const defaults = initialModel === undefined ? {} : {
-      model: { provider: initialModel.provider, modelId: initialModel.modelId },
-      ...initialModel.thinkingLevel === undefined ? {} : { thinkingLevel: initialModel.thinkingLevel }
-    };
     const gateway = await startGateway({
       harness,
       models: options.models,
       modelSummaries: options.modelSummaries,
       session: { id: basename2(options.dataDir), directory: options.dataDir },
       dataDir: options.dataDir,
-      defaults,
+      settings: hostSettings,
       token,
       port: options.port,
+      agents: agentRoles,
       ...options.browserOrigins === undefined ? {} : { browserOrigins: options.browserOrigins },
       docs: extensions.flatMap((extension) => extension.docs ?? []),
       toolPresentations: Object.assign({}, ...extensions.map((extension) => extension.tools ?? {})),
       ...mcp === undefined ? {} : { mcp: mcp.status },
+      ...options.modelAuth === undefined ? {} : { modelAuth: options.modelAuth },
       ...options.webRoot === undefined ? {} : { webRoot: options.webRoot },
-      ...hostKey === undefined || offers === undefined ? {} : {
-        secure: {
-          hostKey,
-          offers,
-          ...options.remote?.handshakeTimeoutMs === undefined ? {} : { handshakeTimeoutMs: options.remote.handshakeTimeoutMs },
-          ...options.remote === undefined ? {} : {
-            lan: {
-              port: options.remote.port,
-              ...options.remote.publicUrl === undefined ? {} : { publicUrl: options.remote.publicUrl }
-            }
-          },
-          ...options.relay === undefined || relayKey === undefined ? {} : {
-            relay: {
-              origin: options.relay.origin,
-              signingKey: relayKey,
-              ...options.relay.reconnectDelayMs === undefined ? {} : { reconnectDelayMs: options.relay.reconnectDelayMs },
-              ...options.relay.pingIntervalMs === undefined ? {} : { pingIntervalMs: options.relay.pingIntervalMs }
-            }
+      ...options.autoTitle === undefined ? {} : { autoTitle: options.autoTitle },
+      secure: {
+        hostKey,
+        offers,
+        ...options.remote?.handshakeTimeoutMs === undefined ? {} : { handshakeTimeoutMs: options.remote.handshakeTimeoutMs },
+        ...options.remote === undefined ? {} : {
+          lan: {
+            port: options.remote.port,
+            ...options.remote.publicUrl === undefined ? {} : { publicUrl: options.remote.publicUrl }
+          }
+        },
+        ...options.relay === undefined || relayKey === undefined ? {} : {
+          relay: {
+            origin: options.relay.origin,
+            signingKey: relayKey,
+            ...options.relay.reconnectDelayMs === undefined ? {} : { reconnectDelayMs: options.relay.reconnectDelayMs },
+            ...options.relay.pingIntervalMs === undefined ? {} : { pingIntervalMs: options.relay.pingIntervalMs }
           }
         }
       }
@@ -2439,15 +2973,21 @@ async function openHost(options) {
       url: gateway.url,
       token,
       harness,
+      closed: opened.closed,
+      settings: hostSettings,
       ...gateway.remote === undefined || hostKey === undefined ? {} : { remote: { url: gateway.remote.url, advertiseUrl: gateway.remote.advertiseUrl, hostKey: hostKey.publicKey } },
       ...gateway.relay === undefined ? {} : { relay: { origin: gateway.relay.origin, hostId: gateway.relay.hostId, state: () => gateway.relay.state() } },
       close() {
         closing ??= (async () => {
           try {
             await gateway.close();
-            await opened.close(context2);
+            await opened.close(context3);
             await mcp?.close();
-            await Promise.all([...environments.values()].map((env) => env.cleanup(context2)));
+            agentRoles?.close();
+            for (const each of extensions)
+              await each.close?.();
+            options.modelAuth?.close();
+            await Promise.all([...environments.values()].map((env) => env.cleanup(context3)));
           } finally {
             await release();
           }
@@ -2456,15 +2996,20 @@ async function openHost(options) {
       }
     };
   } catch (error) {
+    options.modelAuth?.close();
+    agentRoles?.close();
+    for (const each of extensions)
+      await each.close?.().catch(() => {});
     await mcp?.close().catch(() => {});
-    await harness?.close(context2).catch(() => {});
+    await harness?.close(context3).catch(() => {});
     await release().catch(() => {});
     throw error;
   }
 }
 
-// apps/host/src/main.ts
-import { getSupportedThinkingLevels as getSupportedThinkingLevels3 } from "@earendil-works/pi-ai";
+// apps/host/src/model-auth.ts
+import { existsSync as existsSync2, watch as watch2 } from "node:fs";
+import { basename as basename3, dirname as dirname3 } from "node:path";
 
 // apps/host/src/pi-setup.ts
 import { getSupportedThinkingLevels as getSupportedThinkingLevels2 } from "@earendil-works/pi-ai";
@@ -2532,7 +3077,7 @@ function configureHarnessHttp(settingsManager) {
   applyHttpProxySettings(settingsManager.getGlobalSettings().httpProxy);
   configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
 }
-function createHarnessSettings(settingsManager) {
+function createHarnessSettings(settingsManager, modes) {
   return {
     get stream() {
       const provider = settingsManager.getProviderRetrySettings();
@@ -2550,10 +3095,10 @@ function createHarnessSettings(settingsManager) {
       return settingsManager.getRetrySettings();
     },
     get steeringMode() {
-      return settingsManager.getSteeringMode();
+      return modes.value.steeringMode;
     },
     get followUpMode() {
-      return settingsManager.getFollowUpMode();
+      return modes.value.followUpMode;
     }
   };
 }
@@ -2573,11 +3118,81 @@ function modelSummaries(modelRuntime) {
     modelId: model.id,
     name: model.name,
     contextWindow: model.contextWindow,
-    thinkingLevels: getSupportedThinkingLevels2(model)
+    thinkingLevels: getSupportedThinkingLevels2(model),
+    images: model.input.includes("image")
   }));
 }
 
+// apps/host/src/model-auth.ts
+var sameModel2 = (a, b) => a.provider === b.provider && a.modelId === b.modelId && a.name === b.name && a.contextWindow === b.contextWindow && sameList(a.thinkingLevels, b.thinkingLevels, (x, y) => x === y);
+var sameLogin = (a, b) => a.providerId === b.providerId && a.name === b.name && a.kind === b.kind && a.subscription === b.subscription;
+async function storedLogins(modelRuntime) {
+  const credentials = await modelRuntime.listCredentials();
+  const logins = credentials.map((credential) => ({
+    providerId: credential.providerId,
+    name: modelRuntime.getProvider(credential.providerId)?.name ?? credential.providerId,
+    kind: credential.type,
+    subscription: modelRuntime.isUsingSubscription(credential.providerId)
+  }));
+  logins.sort((a, b) => a.providerId.localeCompare(b.providerId));
+  return { logins };
+}
+async function watchModelAuth(modelRuntime, options) {
+  const debounceMs = options.debounceMs ?? 150;
+  const models = new Published(modelSummaries(modelRuntime), (a, b) => sameList(a, b, sameModel2));
+  const auth = new Published(await storedLogins(modelRuntime), (a, b) => sameList(a.logins, b.logins, sameLogin));
+  const fileName = basename3(options.authPath);
+  let watcher;
+  let timer;
+  let reported = false;
+  let closed = false;
+  const refresh = async () => {
+    try {
+      await modelRuntime.getAvailable();
+      models.set(modelSummaries(modelRuntime));
+      auth.set(await storedLogins(modelRuntime));
+      reported = false;
+    } catch (error) {
+      if (!reported)
+        console.error(`model-auth refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+      reported = true;
+    }
+  };
+  const directory = dirname3(options.authPath);
+  if (existsSync2(directory)) {
+    watcher = watch2(directory, (_event, changed) => {
+      if (closed || changed !== null && changed !== fileName)
+        return;
+      clearTimeout(timer);
+      timer = setTimeout(() => void refresh(), debounceMs);
+    });
+    watcher.on("error", (error) => {
+      if (!reported)
+        console.error(`model-auth watch failed: ${error.message}`);
+      reported = true;
+    });
+  }
+  return {
+    models,
+    auth,
+    async logout(providerId) {
+      if (!auth.value.logins.some((login) => login.providerId === providerId)) {
+        throw new Error(`No stored credential for provider "${providerId}"`);
+      }
+      await modelRuntime.logout(providerId);
+      models.set(modelSummaries(modelRuntime));
+      auth.set(await storedLogins(modelRuntime));
+    },
+    close() {
+      closed = true;
+      clearTimeout(timer);
+      watcher?.close();
+    }
+  };
+}
+
 // apps/host/src/main.ts
+import { getSupportedThinkingLevels as getSupportedThinkingLevels3 } from "@earendil-works/pi-ai";
 async function main(argv) {
   const { values } = parseArgs({
     args: [...argv],
@@ -2595,28 +3210,27 @@ async function main(argv) {
     }
   });
   const dataDir = resolve3(values["data-dir"] ?? DEFAULT_DATA_DIR);
-  const extensionsFor = (models, summaries) => (host2) => {
-    const others = [
-      createContext({ agentsHome: join6(homedir2(), ".agents"), checkout: checkoutInfo }),
-      coding,
-      todo,
-      question,
-      createSubagent({ models, modelSummaries: summaries, exclude: [question.extension] })
-    ];
-    return [
-      ...others,
-      createCodemode({
-        scriptTools: host2.scriptTools,
-        modelOnly: others.flatMap((extension) => extension.modelOnly ?? []),
-        presentations: Object.assign({}, ...others.map((extension) => extension.tools ?? {}))
-      })
-    ];
-  };
+  const extensionsFor = (models, summaries, options2) => (host2) => [
+    createContext({
+      agentsHome: join8(homedir3(), ".agents"),
+      checkout: (input, context4) => checkoutInfo(host2.harness(), input, context4)
+    }),
+    createCoding(options2),
+    todo,
+    question,
+    createSubagent({
+      models,
+      modelSummaries: summaries,
+      exclude: [question.extension],
+      roles: () => host2.agentRoles.value.roles
+    }),
+    createCodemode()
+  ];
   const common = {
     dataDir,
     projects: values.project ?? [],
     port: Number(values.port),
-    mcpConfig: join6(homedir2(), ".agents", "mcp.json"),
+    mcpConfig: join8(homedir3(), ".agents", "mcp.json"),
     browserOrigins: values["browser-origin"] ?? ["http://127.0.0.1:5199"],
     webRoot,
     ...values["lock-stale-ms"] === undefined ? {} : { lockStaleMs: Number(values["lock-stale-ms"]) },
@@ -2640,7 +3254,8 @@ async function main(argv) {
         modelId: model2.id,
         name: model2.name,
         contextWindow: model2.contextWindow,
-        thinkingLevels: getSupportedThinkingLevels3(model2)
+        thinkingLevels: getSupportedThinkingLevels3(model2),
+        images: model2.input.includes("image")
       }
     ];
     return {
@@ -2648,32 +3263,49 @@ async function main(argv) {
       models,
       modelSummaries: summaries,
       extensions: extensionsFor(models, summaries),
-      initialModel: { provider: model2.provider, modelId: model2.id }
+      autoTitle: false,
+      settingsFallback: {
+        defaultModel: () => ({ provider: model2.provider, modelId: model2.id }),
+        defaultThinkingLevel: () => null,
+        steeringMode: () => "one-at-a-time",
+        followUpMode: () => "one-at-a-time"
+      }
     };
   }
   async function piOptions() {
     const modelRuntime = await ModelRuntime.create();
+    const modelAuth = await watchModelAuth(modelRuntime, { authPath: join8(getAgentDir(), "auth.json") });
     const settingsManager = SettingsManager.create(process.cwd());
     configureHarnessHttp(settingsManager);
-    const initialModel = defaultModel(settingsManager, modelRuntime);
-    const summaries = () => modelSummaries(modelRuntime);
+    const summaries = () => modelAuth.models.value;
+    const images = await createNodePhotonImages();
     return {
       ...common,
       models: modelRuntime,
       modelSummaries: summaries,
-      extensions: extensionsFor(modelRuntime, summaries),
-      settings: createHarnessSettings(settingsManager),
-      ...initialModel === undefined ? {} : { initialModel }
+      modelAuth,
+      extensions: extensionsFor(modelRuntime, summaries, { images }),
+      settings: (store) => createHarnessSettings(settingsManager, store),
+      settingsFallback: {
+        defaultModel: () => {
+          const model2 = defaultModel(settingsManager, modelRuntime);
+          return model2 === undefined ? null : { provider: model2.provider, modelId: model2.modelId };
+        },
+        defaultThinkingLevel: () => settingsManager.getDefaultThinkingLevel() ?? null,
+        steeringMode: () => settingsManager.getSteeringMode(),
+        followUpMode: () => settingsManager.getFollowUpMode()
+      }
     };
   }
   const options = values.faux !== undefined ? fauxOptions(() => () => fauxAssistantMessage(values.faux)) : await piOptions();
   const host = await openHost(options);
-  const model = options.initialModel === undefined ? null : `${options.initialModel.provider}/${options.initialModel.modelId}`;
+  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: join6(dataDir, "token"),
+    tokenFile: join8(dataDir, "token"),
     dataDir,
     model,
     web,
@@ -2689,6 +3321,15 @@ async function main(argv) {
   };
   process.on("SIGINT", stop);
   process.on("SIGTERM", stop);
+  host.closed.then((end) => {
+    if (end.reason !== "failed" || stopping)
+      return;
+    stopping = true;
+    const error = end.error instanceof Error ? end.error.message : String(end.error);
+    process.stderr.write(`${JSON.stringify({ event: "fatal", error })}
+`);
+    host.close().finally(() => process.exit(1));
+  });
 }
 if (false)
   ;