pinomad 0.2.0 → 0.4.0

package/dist/{chunk-fhtkkcgt.js → chunk-z5pmcscx.js}

@@ -1,52 +1,62 @@
 #!/usr/bin/env node
+import {
+  normalizeOrigin,
+  readServerBinding,
+  readServerConfig,
+  resolveRelayOrigin
+} from "./chunk-302y6by9.js";
 import {
   serveWebClient
 } from "./chunk-r6w5aqkw.js";
+import {
+  relayWsBase,
+  startRelayLink
+} from "./chunk-knaw1a9g.js";
 import {
   packagedVersion,
   webRoot
-} from "./chunk-rkfdsacq.js";
+} from "./chunk-fgx2sh7d.js";
 import {
+  HOST_SETTING_KEYS,
   INVALID_FRAME_CLOSE_CODE,
   PROTOCOL,
+  THINKING_LEVELS,
   UNAUTHORIZED_CLOSE_CODE,
+  isQueueMode,
+  isThinkingLevel,
+  organize,
   parseClientFrame
-} from "./chunk-h35fermn.js";
+} from "./chunk-myjp910s.js";
 import {
   DevicesDoc,
+  RevocationsDoc,
+  admitDevice,
   ensureDevices,
-  isRegistered,
   loadHostKey,
   loadRelayKey,
-  pairingOffers,
-  registerDevice,
-  revokeDevice
-} from "./chunk-fxaewke2.js";
+  pairingOffers
+} from "./chunk-837gh8nr.js";
 import {
-  RELAY_CLOSE,
   SECURE_PROLOGUE,
   SecureSession,
   decodeClientHello,
-  decodeRelayToHost,
   encodeHostHello,
-  encodeRelayFrame,
-  relayHostId,
   respondIK,
-  signRelayChallenge,
   toBase64Url
-} from "./chunk-z4x88s0q.js";
+} from "./chunk-7gmkgyaz.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-cjfmfyjb.js";
 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 {
@@ -93,6 +103,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")]),
@@ -100,7 +111,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({
@@ -169,10 +180,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 })
@@ -199,13 +211,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,
@@ -221,403 +232,32 @@ 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.";
@@ -625,11 +265,11 @@ 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;
@@ -649,7 +289,7 @@ function createContext(options) {
           ].join(`
 `);
         }),
-        section2("project_context", async (input, context) => {
+        section("project_context", async (input, context) => {
           const cwd = input.agent.cwd;
           if (cwd === undefined)
             return;
@@ -675,7 +315,7 @@ ${file.content}`).join(`
 
 `);
         }),
-        section2("skills", (input) => {
+        section("skills", (input) => {
           const cwd = input.agent.cwd;
           if (cwd === undefined)
             return;
@@ -699,10 +339,11 @@ 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";
@@ -717,20 +358,32 @@ var SubagentDoc = defineDoc2({
 
 // 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) => {
@@ -744,31 +397,43 @@ function createSubagent(options) {
             ...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 }
         };
@@ -781,6 +446,8 @@ function createSubagent(options) {
         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;
@@ -798,7 +465,7 @@ 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 }],
+        output: [{ type: "text", text: text === "" ? "(The subagent returned no text.)" : text }],
         details: {
           conversationId: child.id,
           ...child.model === undefined ? {} : { model: child.model },
@@ -808,13 +475,28 @@ function createSubagent(options) {
       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 defineDoc3, defineExtension as defineExtension5, defineTool as defineTool4 } from "@earendil-works/pi-durable";
-import { Type as Type5 } from "typebox";
+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,
@@ -823,33 +505,30 @@ var TodoDoc = defineDoc3({
   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_CONTEXT4 } from "@earendil-works/chord/context";
+import { createRegistry, Harness } from "@earendil-works/pi-durable";
 import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
 
 // apps/host/src/organization.ts
@@ -939,7 +618,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);
@@ -951,6 +630,16 @@ 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 = defineDoc4({
   kind: "pinomad.index",
@@ -1003,7 +692,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;
   }
@@ -1055,14 +744,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;
   }
@@ -1166,8 +855,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) {
@@ -1289,32 +978,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 };
     }
   });
 }
@@ -1323,6 +1003,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 = [];
@@ -1333,8 +1014,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 });
@@ -1351,16 +1032,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();
   };
@@ -1435,7 +1123,6 @@ ${stderr}`;
   });
   return {
     status,
-    scriptTools: () => [...toolsets.values()].flat(),
     async close() {
       closed = true;
       await Promise.all([...live].map((client) => client.close().catch(() => {})));
@@ -1443,23 +1130,882 @@ ${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";
+    case "acceptAccountDevices":
+      return typeof value === "boolean" ? 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.acceptAccountDevices === b.acceptAccountDevices && 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(),
+      acceptAccountDevices: fileValues.acceptAccountDevices ?? true,
+      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, 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_CONTEXT3 } from "@earendil-works/chord/context";
 import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
   AgentDoc as AgentDoc3,
   LiveDoc
 } from "@earendil-works/pi-durable";
-import { WebSocket as WebSocket2, WebSocketServer } from "ws";
+import { WebSocket, WebSocketServer } from "ws";
 import { Value as Value2 } from "typebox/value";
 
+// apps/host/src/folders.ts
+import { readdir as readdir2, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join5 } from "node:path";
+var denied = (error) => {
+  const code = error?.code;
+  return code === "EACCES" || code === "EPERM";
+};
+async function listFolders(path, home) {
+  if (path !== undefined && !isAbsolute2(path))
+    throw new Error(`Not an absolute path: ${path}`);
+  const given = path ?? home;
+  const dir = await realpath3(given).catch((error) => {
+    if (denied(error))
+      throw new Error(`Permission denied: ${given}`);
+    throw new Error(`No such directory: ${given}`);
+  });
+  if (!(await stat3(dir)).isDirectory())
+    throw new Error(`Not a directory: ${given}`);
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch (error) {
+    if (denied(error))
+      throw new Error(`Permission denied: ${given}`);
+    throw error;
+  }
+  const folders = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    let isDirectory = entry.isDirectory();
+    if (!isDirectory && entry.isSymbolicLink()) {
+      isDirectory = await stat3(join5(dir, entry.name)).then((target) => target.isDirectory(), () => false);
+    }
+    if (isDirectory)
+      folders.push({ name: entry.name, path: join5(dir, entry.name) });
+  }
+  folders.sort((a, b) => a.name.localeCompare(b.name, "en", { numeric: true, sensitivity: "base" }));
+  return { path: dir, home: await realpath3(home).catch(() => home), folders };
+}
+
+// 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);
+  });
+}
+
+// apps/host/src/push.ts
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
+import { defineDoc as defineDoc6 } from "@earendil-works/pi-durable";
+
+// packages/client/src/family.ts
+var SUBAGENT_TASK_PREFIX = /^\s*in the working directory\s+\S+,\s*/i;
+function displayName(summary) {
+  if (summary === undefined)
+    return "Conversation";
+  if (summary.kind !== "subagent")
+    return summary.title ?? "New conversation";
+  if (summary.label !== undefined)
+    return summary.label;
+  const title = summary.title?.replace(SUBAGENT_TASK_PREFIX, "").trim();
+  return title === undefined || title === "" ? "Subagent" : title;
+}
+
+// packages/client/src/run-notifications.ts
+var everySummary = (organized) => {
+  const summaries = [];
+  const visit = (node) => {
+    summaries.push(node.summary);
+    for (const child of node.children)
+      visit(child);
+  };
+  for (const root of [...organized.chats, ...organized.projects.flatMap((entry) => entry.conversations)])
+    visit(root);
+  return summaries;
+};
+function diffRunNotices(previous, organized) {
+  const notices = [];
+  const changed = [];
+  const baseline = new Map;
+  for (const summary of everySummary(organized)) {
+    baseline.set(summary.id, summary.status);
+    if (previous === undefined)
+      continue;
+    const before = previous.get(summary.id);
+    if (before !== summary.status)
+      changed.push(summary.id);
+    if (summary.status === "needs-answer" && before !== "needs-answer") {
+      notices.push({ id: summary.id, title: displayName(summary), body: "Waiting for your answer" });
+      continue;
+    }
+    const runEnded = before === "running" || before === "needs-answer";
+    if (runEnded && (summary.status === undefined || summary.status === "failed") && summary.kind !== "subagent") {
+      notices.push({ id: summary.id, title: displayName(summary), body: summary.status === "failed" ? "Failed" : "Finished" });
+    }
+  }
+  if (previous !== undefined) {
+    for (const gone of previous.keys()) {
+      if (!baseline.has(gone))
+        changed.push(gone);
+    }
+  }
+  return { notices, changed, baseline };
+}
+
+// apps/host/src/push.ts
+var context2 = BACKGROUND_CONTEXT2;
+var PushDoc = defineDoc6({
+  kind: "pinomad.push",
+  version: 1,
+  scope: "session",
+  initial: () => ({ registrations: [] })
+});
+var PUSH_TOKEN_PATTERN = /^Expo(?:nent)?PushToken\[[^\]]+\]$/;
+var PUSH_TOKEN_MAX_LENGTH = 256;
+function pushTokenProblem(token) {
+  if (token === null)
+    return;
+  if (token.length > PUSH_TOKEN_MAX_LENGTH) {
+    return `Push token is too long (${PUSH_TOKEN_MAX_LENGTH} characters at most)`;
+  }
+  if (!PUSH_TOKEN_PATTERN.test(token))
+    return "Not an Expo push token";
+  return;
+}
+async function setPushToken(harness, publicKey, token, context3) {
+  const problem = pushTokenProblem(token);
+  if (problem !== undefined)
+    throw new Error(problem);
+  await harness.commit(async (tx) => {
+    const devices = await tx.doc(DevicesDoc);
+    if (!devices.devices.some((entry) => entry.publicKey === publicKey)) {
+      throw new Error("Device is not paired");
+    }
+    const push = await tx.doc(PushDoc);
+    push.registrations = push.registrations.filter((entry) => entry.publicKey !== publicKey);
+    if (token !== null)
+      push.registrations.push({ publicKey, token, updatedAt: Date.now() });
+  }, context3);
+}
+async function revokeDevice(harness, publicKey, context3) {
+  await harness.commit(async (tx) => {
+    const devices = await tx.doc(DevicesDoc);
+    devices.devices = devices.devices.filter((entry) => entry.publicKey !== publicKey);
+    const push = await tx.doc(PushDoc);
+    push.registrations = push.registrations.filter((entry) => entry.publicKey !== publicKey);
+    const revocations = await tx.doc(RevocationsDoc);
+    if (!revocations.revoked.includes(publicKey))
+      revocations.revoked.push(publicKey);
+  }, context3);
+}
+async function dropTokenIfCurrent(harness, token, context3) {
+  await harness.commit(async (tx) => {
+    const push = await tx.doc(PushDoc);
+    push.registrations = push.registrations.filter((entry) => entry.token !== token);
+  }, context3);
+}
+var EXPO_SEND_URL = "https://exp.host/--/api/v2/push/send";
+var EXPO_RECEIPTS_URL = "https://exp.host/--/api/v2/push/getReceipts";
+var FALLBACK_TITLE = "PiNomad conversation";
+var TITLE_WAIT_MS = 15000;
+var TTL_SECONDS = 3600;
+var REQUEST_TIMEOUT_MS = 1e4;
+var MAX_ATTEMPTS = 4;
+var RETRY_BASE_MS = 5000;
+var RECEIPT_DELAY_MS = 15 * 60 * 1000;
+var MAX_PENDING = 128;
+var realTimers = {
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+var tokenHint = (token) => `…${token.slice(-6)}`;
+async function attachPushSender(options) {
+  const { harness, conversations } = options;
+  const fetcher = options.fetch ?? fetch;
+  const timers = options.timers ?? realTimers;
+  const indexWatch = await harness.watchDoc(IndexDoc, context2);
+  let index = indexWatch?.value ?? undefined;
+  let baseline;
+  let disposed = false;
+  const pending = new Set;
+  const titleWaiters = new Map;
+  const receiptTimers = new Set;
+  const generation = new Map;
+  const update = () => {
+    if (index === undefined)
+      return;
+    const organized = organize(index, conversations.value);
+    if (baseline === undefined) {
+      baseline = diffRunNotices(undefined, organized).baseline;
+      for (const id of baseline.keys())
+        generation.set(id, 0);
+      return;
+    }
+    const diff = diffRunNotices(baseline, organized);
+    baseline = diff.baseline;
+    for (const id of diff.changed)
+      generation.set(id, (generation.get(id) ?? 0) + 1);
+    for (const notice of diff.notices)
+      enqueue(notice);
+  };
+  const fresh = (item) => baseline?.has(item.notice.id) === true && generation.get(item.notice.id) === item.generation;
+  const registrations = async () => {
+    const doc = await harness.snapshot(PushDoc, context2);
+    return new Set((doc?.registrations ?? []).map((entry) => entry.token));
+  };
+  const post = async (url, payload) => {
+    const response = await fetcher(url, {
+      method: "POST",
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    return { status: response.status, body: await response.json() };
+  };
+  const ticketOf = (body) => {
+    const data = body?.data;
+    const ticket = Array.isArray(data) ? data[0] : data;
+    return ticket !== null && typeof ticket === "object" ? ticket : undefined;
+  };
+  const message = (item, title) => ({
+    to: item.token,
+    title,
+    body: item.notice.body,
+    sound: "default",
+    ttl: TTL_SECONDS,
+    data: { hostKey: options.hostKey, conversationId: item.notice.id },
+    threadId: `${options.hostKey}:${item.notice.id}`,
+    collapseId: `${options.hostKey}:${item.notice.id}`
+  });
+  const namedTitle = async (id) => {
+    const doc = await harness.snapshot(TitleDoc, id, context2);
+    return typeof doc?.title === "string" && doc.title !== "" ? doc.title : undefined;
+  };
+  const titleFor = async (notice) => {
+    const named = await namedTitle(notice.id);
+    if (named !== undefined)
+      return named;
+    if (notice.body !== "Finished" || disposed)
+      return FALLBACK_TITLE;
+    return await new Promise((resolve3) => {
+      const waiters = titleWaiters.get(notice.id) ?? new Set;
+      titleWaiters.set(notice.id, waiters);
+      const settle = (title) => {
+        waiters.delete(settle);
+        if (waiters.size === 0)
+          titleWaiters.delete(notice.id);
+        timers.clearTimeout(timer);
+        resolve3(title);
+      };
+      const timer = timers.setTimeout(() => settle(FALLBACK_TITLE), TITLE_WAIT_MS);
+      waiters.add(settle);
+      namedTitle(notice.id).then((title) => {
+        if (title !== undefined)
+          settle(title);
+      });
+    });
+  };
+  const drop = (item) => {
+    pending.delete(item);
+    if (item.timer !== undefined)
+      timers.clearTimeout(item.timer);
+  };
+  const attempt = async (item) => {
+    if (disposed || !pending.has(item))
+      return;
+    try {
+      if (!(await registrations()).has(item.token) || !fresh(item))
+        return drop(item);
+      if (item.title === undefined) {
+        item.title = await titleFor(item.notice);
+        if (disposed || !pending.has(item) || !(await registrations()).has(item.token) || !fresh(item))
+          return drop(item);
+      }
+      const { status, body } = await post(EXPO_SEND_URL, message(item, item.title));
+      const ticket = ticketOf(body);
+      if (ticket?.details?.error === "DeviceNotRegistered") {
+        drop(item);
+        console.error(`push: token ${tokenHint(item.token)} is not registered (ticket)`);
+        await dropTokenIfCurrent(harness, item.token, context2);
+        return;
+      }
+      if (status >= 200 && status < 300 && ticket?.status === "ok") {
+        drop(item);
+        if (typeof ticket.id === "string")
+          scheduleReceiptCheck(item.token, ticket.id);
+        return;
+      }
+      if ((status === 429 || status >= 500) && item.attempts + 1 < MAX_ATTEMPTS) {
+        item.attempts += 1;
+        item.timer = timers.setTimeout(() => void attempt(item), RETRY_BASE_MS * 2 ** (item.attempts - 1));
+        return;
+      }
+      console.error(`push: send to ${tokenHint(item.token)} failed permanently (HTTP ${status})`);
+      drop(item);
+    } catch (error) {
+      if (item.attempts + 1 < MAX_ATTEMPTS) {
+        item.attempts += 1;
+        item.timer = timers.setTimeout(() => void attempt(item), RETRY_BASE_MS * 2 ** (item.attempts - 1));
+        return;
+      }
+      console.error(`push: send to ${tokenHint(item.token)} gave up: ${error instanceof Error ? error.message : String(error)}`);
+      drop(item);
+    }
+  };
+  const scheduleReceiptCheck = (token, ticketId) => {
+    const timer = timers.setTimeout(() => {
+      receiptTimers.delete(timer);
+      checkReceipt(token, ticketId);
+    }, RECEIPT_DELAY_MS);
+    receiptTimers.add(timer);
+    while (receiptTimers.size > MAX_PENDING) {
+      const oldest = receiptTimers.values().next().value;
+      receiptTimers.delete(oldest);
+      timers.clearTimeout(oldest);
+    }
+  };
+  const checkReceipt = async (token, ticketId) => {
+    if (disposed)
+      return;
+    try {
+      const { status, body } = await post(EXPO_RECEIPTS_URL, { ids: [ticketId] });
+      const receipt = status >= 200 && status < 300 ? body?.data?.[ticketId] : undefined;
+      if (receipt === undefined || disposed)
+        return;
+      if (receipt.status === "error" && receipt.details?.error === "DeviceNotRegistered") {
+        console.error(`push: token ${tokenHint(token)} is not registered (receipt)`);
+        await dropTokenIfCurrent(harness, token, context2);
+        return;
+      }
+      if (receipt.status === "error")
+        console.error(`push: receipt ${ticketId} reports ${receipt.details?.error ?? "error"}`);
+    } catch (error) {
+      console.error(`push: receipt check ${ticketId} failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  const enqueue = async (notice) => {
+    if (disposed)
+      return;
+    const itemGeneration = generation.get(notice.id) ?? 0;
+    try {
+      const tokens = await registrations();
+      for (const token of tokens) {
+        if (disposed)
+          return;
+        if (pending.size >= MAX_PENDING) {
+          const [oldest] = pending;
+          drop(oldest);
+        }
+        const item = { token, notice, generation: itemGeneration, attempts: 0 };
+        pending.add(item);
+        attempt(item);
+      }
+    } catch (error) {
+      console.error(`push: could not read registrations: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  const unsubscribeConversations = conversations.subscribe(() => update());
+  const unsubscribeCommits = harness.subscribeCommits((publication) => {
+    for (const change of publication.changes) {
+      if (change.type !== "document" || change.record.kind !== TitleDoc.definition.kind)
+        continue;
+      const id = change.conversationId;
+      if (id === undefined)
+        continue;
+      const title = change.value?.title;
+      if (typeof title !== "string" || title === "")
+        continue;
+      const waiters = titleWaiters.get(id);
+      titleWaiters.delete(id);
+      for (const settle of waiters ?? [])
+        settle(title);
+    }
+  });
+  indexWatch?.start(async (value) => {
+    index = value ?? undefined;
+    update();
+  });
+  update();
+  return async () => {
+    disposed = true;
+    unsubscribeConversations();
+    unsubscribeCommits();
+    await indexWatch?.stop();
+    for (const item of pending)
+      drop(item);
+    pending.clear();
+    titleWaiters.clear();
+    for (const timer of receiptTimers)
+      timers.clearTimeout(timer);
+    receiptTimers.clear();
+  };
+}
+
 // packages/protocol/src/tool-target.ts
 var TARGET_KEYS = [
   "path",
@@ -1487,154 +2033,8 @@ function toolTarget(args) {
   return;
 }
 
-// apps/host/src/relay-link.ts
-import { WebSocket } from "ws";
-function relayWsBase(origin) {
-  const normalized = origin.replace(/\/+$/, "");
-  if (normalized.startsWith("https://"))
-    return `wss://${normalized.slice("https://".length)}`;
-  if (normalized.startsWith("http://"))
-    return `ws://${normalized.slice("http://".length)}`;
-  throw new Error(`relay origin must be an http(s) URL: ${origin}`);
-}
-var REJECTION_REASONS = {
-  [RELAY_CLOSE.badSignature]: () => `the relay rejected this host's registration signature — a version mismatch?`,
-  [RELAY_CLOSE.hostNotAllowed]: (hostId) => `the relay does not allow this host; add --allow-host ${hostId} to the relay's arguments`,
-  [RELAY_CLOSE.replaced]: () => `the relay replaced this control connection — another process registered the same hostId`
-};
-function startRelayLink(options) {
-  const origin = options.origin.replace(/\/+$/, "");
-  const wsBase = relayWsBase(origin);
-  const hostId = relayHostId(options.signingKey.publicKey);
-  const minDelay = options.reconnectDelayMs?.min ?? 1000;
-  const maxDelay = options.reconnectDelayMs?.max ?? 30000;
-  const maxPendingAccepts = options.maxPendingAccepts ?? 16;
-  let state = { status: "connecting" };
-  let stopped = false;
-  let control;
-  let delay = minDelay;
-  let retryTimer;
-  let pendingAccepts = 0;
-  function setState(next) {
-    const changed = state.status !== next.status || state.status === "rejected" && next.status === "rejected" && state.reason !== next.reason;
-    state = next;
-    if (changed)
-      options.onStateChange?.(next);
-  }
-  const watched = new Set;
-  const ponged = new WeakMap;
-  const pingIntervalMs = options.pingIntervalMs ?? 30000;
-  const pingTimer = setInterval(() => {
-    for (const socket of watched) {
-      if (socket.readyState !== WebSocket.OPEN)
-        continue;
-      if (ponged.get(socket) === true) {
-        ponged.set(socket, false);
-        socket.ping();
-      } else {
-        socket.terminate();
-      }
-    }
-  }, pingIntervalMs);
-  function watch(socket) {
-    watched.add(socket);
-    ponged.set(socket, true);
-    socket.on("pong", () => ponged.set(socket, true));
-    socket.once("close", () => watched.delete(socket));
-    socket.on("error", () => socket.terminate());
-  }
-  function connectControl() {
-    if (stopped)
-      return;
-    const socket = new WebSocket(`${wsBase}/host`, { handshakeTimeout: pingIntervalMs });
-    control = socket;
-    watch(socket);
-    socket.on("message", onControlMessage);
-    socket.once("close", onControlClosed);
-  }
-  function reconnect(at) {
-    if (stopped || retryTimer !== undefined)
-      return;
-    retryTimer = setTimeout(() => {
-      retryTimer = undefined;
-      connectControl();
-    }, at);
-  }
-  function onControlMessage(data, isBinary) {
-    let frame;
-    try {
-      if (isBinary)
-        throw new Error("binary control frame");
-      frame = decodeRelayToHost(data.toString());
-    } catch {
-      control?.close();
-      return;
-    }
-    switch (frame.t) {
-      case "challenge":
-        control?.send(encodeRelayFrame({
-          t: "register",
-          hostId,
-          signature: signRelayChallenge(options.signingKey.secretKey, { relayOrigin: origin, hostId, nonce: frame.nonce })
-        }));
-        break;
-      case "registered":
-        delay = minDelay;
-        setState({ status: "registered" });
-        break;
-      case "incoming": {
-        if (pendingAccepts >= maxPendingAccepts)
-          break;
-        pendingAccepts += 1;
-        const data2 = new WebSocket(`${wsBase}/accept/${frame.connId}`, { handshakeTimeout: pingIntervalMs });
-        watch(data2);
-        const release = () => {
-          pendingAccepts -= 1;
-          clearTimeout(ageOut);
-          data2.off("close", release);
-        };
-        const ageOut = setTimeout(release, 1e4);
-        data2.once("close", release);
-        options.accept(data2);
-        break;
-      }
-    }
-  }
-  function onControlClosed(code) {
-    control = undefined;
-    if (stopped)
-      return;
-    const rejection = REJECTION_REASONS[code];
-    if (rejection !== undefined) {
-      const reason = `relay ${origin}: ${rejection(hostId)} (${code})`;
-      setState({ status: "rejected", reason });
-      delay = maxDelay;
-      reconnect(maxDelay);
-      return;
-    }
-    setState({ status: "connecting" });
-    reconnect(delay);
-    delay = Math.min(maxDelay, delay * 2);
-  }
-  connectControl();
-  return {
-    hostId,
-    origin,
-    state: () => state,
-    close() {
-      stopped = true;
-      if (retryTimer !== undefined)
-        clearTimeout(retryTimer);
-      clearInterval(pingTimer);
-      for (const socket of watched)
-        socket.terminate();
-      return Promise.resolve();
-    }
-  };
-}
-
 // apps/host/src/gateway.ts
-var context = BACKGROUND_CONTEXT;
+var context3 = BACKGROUND_CONTEXT3;
 var forkTails = new WeakMap;
 function serializedFork(harness, work) {
   const next = (forkTails.get(harness) ?? Promise.resolve()).then(work, work);
@@ -1649,6 +2049,18 @@ function serializedFork(harness, work) {
 var LOOPBACK_SECURE_PATH = "/secure";
 async function startGateway(options) {
   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 detachPush = options.push === undefined ? undefined : await attachPushSender({
+    harness: options.harness,
+    conversations,
+    hostKey: options.push.hostKey,
+    ...options.push.fetch === undefined ? {} : { fetch: options.push.fetch },
+    ...options.push.timers === undefined ? {} : { timers: options.push.timers }
+  });
   const http = createServer((request, response) => {
     serveWebClient(request, response, options.webRoot).catch(() => {
       if (!response.headersSent)
@@ -1671,7 +2083,10 @@ async function startGateway(options) {
   };
   let remote;
   let relay;
-  const register = (connection, devicePublicKey) => {
+  const register = (connection, devicePublicKey, joined) => {
+    if (joined?.source === "account") {
+      broadcast("info", `New device "${joined.name}" joined through your account`);
+    }
     const client = new GatewayClient(connection, options, conversations, {
       devicePublicKey,
       closed: (self) => {
@@ -1688,20 +2103,30 @@ async function startGateway(options) {
         const spec = options.secure;
         if (spec === undefined)
           return;
-        const { secret, expiresAt } = spec.offers.create();
-        const pair = `pair=${toBase64Url(spec.hostKey.publicKey)}.${secret}`;
+        const pair = (secret2) => `pair=${toBase64Url(spec.hostKey.publicKey)}.${secret2}`;
         if (relay !== undefined) {
+          const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
           const target2 = `${relayWsBase(relay.origin)}/c/${relay.hostId}`;
-          return { url: `${relay.origin}/#${pair}&url=${encodeURIComponent(target2)}`, expiresAt };
+          return { url: `${relay.origin}/#${pair(secret2)}&url=${encodeURIComponent(target2)}`, expiresAt: expiresAt2 };
         }
-        if (remote !== undefined)
-          return { url: `${remote.advertiseUrl}/#${pair}`, expiresAt };
+        if (remote !== undefined) {
+          const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
+          return { url: `${remote.advertiseUrl}/#${pair(secret2)}`, expiresAt: expiresAt2 };
+        }
+        const { secret, expiresAt } = spec.offers.create("local");
         const target = `ws://127.0.0.1:${port}${LOOPBACK_SECURE_PATH}`;
-        return { url: `http://127.0.0.1:${port}/#${pair}&url=${encodeURIComponent(target)}`, expiresAt };
+        return { url: `http://127.0.0.1:${port}/#${pair(secret)}&url=${encodeURIComponent(target)}`, expiresAt };
       }
     });
     clients.add(client);
   };
+  const admission = {
+    harness: options.harness,
+    acceptAccountDevices: () => options.settings.value.acceptAccountDevices,
+    serverBinding: async () => await readServerBinding(options.dataDir).catch(() => {
+      return;
+    })
+  };
   server.on("connection", (socket, request) => {
     socket.on("error", () => socket.terminate());
     const url = new URL(request.url ?? "/", "ws://127.0.0.1");
@@ -1711,7 +2136,7 @@ async function startGateway(options) {
         socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
         return;
       }
-      secureHandshake(socket, secure2, options.harness, register);
+      secureHandshake(socket, secure2, admission, register);
       return;
     }
     const token = url.searchParams.get("token");
@@ -1722,14 +2147,34 @@ async function startGateway(options) {
     }
     register(tokenConnection(socket));
   });
-  remote = await startRemote(options, register);
+  remote = await startRemote(options, admission, register);
   const secure = options.secure;
+  const detachSettingsWatch = options.settings.subscribe((settings) => {
+    if (!settings.acceptAccountDevices)
+      secure?.offers.revokeAccount();
+  });
   if (secure?.relay !== undefined) {
+    const relayOrigin = secure.relay.origin;
     let link;
     link = startRelayLink({
-      origin: secure.relay.origin,
+      origin: relayOrigin,
       signingKey: secure.relay.signingKey,
-      accept: (socket) => secureHandshake(socket, secure, options.harness, register),
+      noisePublicKey: secure.hostKey.publicKey,
+      accept: (socket) => secureHandshake(socket, secure, admission, register),
+      accountOffer: async () => {
+        if (!options.settings.value.acceptAccountDevices)
+          return { ok: false, reason: "disabled" };
+        const config = await readServerConfig(options.dataDir).catch(() => {
+          return;
+        });
+        if (config?.binding === undefined)
+          return { ok: false, reason: "not_joined" };
+        if (normalizeOrigin(config.origin) !== normalizeOrigin(relayOrigin)) {
+          return { ok: false, reason: "rebinding" };
+        }
+        const { secret, expiresAt } = secure.offers.createAccount(config.binding);
+        return { ok: true, secret, expiresAt };
+      },
       onStateChange: (state) => {
         if (state.status === "registered") {
           console.log(JSON.stringify({ event: "relay", status: "registered", origin: link.origin, hostId: link.hostId }));
@@ -1752,6 +2197,9 @@ async function startGateway(options) {
     broadcast,
     async close() {
       await relay?.close();
+      detachAutoTitle?.();
+      detachSettingsWatch();
+      await detachPush?.();
       conversations.dispose();
       await Promise.all([...clients].map((client) => client.dispose()));
       for (const socket of server.clients)
@@ -1765,9 +2213,9 @@ async function startGateway(options) {
 function tokenConnection(socket) {
   return {
     get open() {
-      return socket.readyState === WebSocket2.OPEN;
+      return socket.readyState === WebSocket.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket2.OPEN ? new Promise((resolve3) => socket.send(text, () => resolve3())) : Promise.resolve(),
+    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve3) => socket.send(text, () => resolve3())) : Promise.resolve(),
     close: (code, reason) => socket.close(code, reason),
     handle(handlers) {
       socket.on("message", (data) => handlers.message(String(data)));
@@ -1778,9 +2226,9 @@ function tokenConnection(socket) {
 function secureConnection(socket, session) {
   return {
     get open() {
-      return socket.readyState === WebSocket2.OPEN;
+      return socket.readyState === WebSocket.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket2.OPEN ? new Promise((resolve3) => {
+    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve3) => {
       const chunks = session.seal(text);
       chunks.forEach((chunk, index) => socket.send(chunk, index === chunks.length - 1 ? () => resolve3() : undefined));
     }) : Promise.resolve(),
@@ -1815,7 +2263,7 @@ function pickLanAddress(interfaces) {
   }
   return fallback;
 }
-function secureHandshake(socket, secure, harness, register) {
+function secureHandshake(socket, secure, policy, register) {
   socket.on("error", () => socket.terminate());
   const responder = respondIK({ prologue: SECURE_PROLOGUE, static: secure.hostKey });
   let settled = false;
@@ -1837,7 +2285,7 @@ function secureHandshake(socket, secure, harness, register) {
       clearTimeout(timeout);
       const session = new SecureSession(admitted.result);
       socket.send(admitted.message);
-      register(secureConnection(socket, session), admitted.deviceKey);
+      register(secureConnection(socket, session), admitted.deviceKey, admitted.joined);
     }).catch(() => socket.close(1011, "handshake failed"));
     async function admit() {
       const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
@@ -1852,19 +2300,28 @@ function secureHandshake(socket, secure, harness, register) {
         return;
       }
       const deviceKey = toBase64Url(remoteStatic);
-      if (!await isRegistered(harness, deviceKey, context)) {
-        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);
+      const decision = await admitDevice(policy.harness, {
+        publicKey: deviceKey,
+        ...hello.pair === undefined ? {} : { pair: hello.pair },
+        offers: secure.offers,
+        acceptAccountDevices: policy.acceptAccountDevices,
+        serverBinding: policy.serverBinding
+      }, context3);
+      if (decision.outcome === "refused") {
+        socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
+        return;
       }
       const { message, result: result2 } = responder.writeMessage2(encodeHostHello({ v: 1 }));
-      return { result: result2, message, deviceKey };
+      return {
+        result: result2,
+        message,
+        deviceKey,
+        ...decision.outcome === "admitted" ? { joined: decision.entry } : {}
+      };
     }
   });
 }
-async function startRemote(options, register) {
+async function startRemote(options, admission, register) {
   const spec = options.secure;
   const remote = spec?.lan;
   if (spec === undefined || remote === undefined)
@@ -1877,7 +2334,7 @@ async function startRemote(options, register) {
     });
   });
   const secure = new WebSocketServer({ server: http });
-  secure.on("connection", (socket) => secureHandshake(socket, spec, options.harness, register));
+  secure.on("connection", (socket) => secureHandshake(socket, spec, admission, register));
   await new Promise((resolveListen, reject) => {
     http.once("listening", resolveListen);
     http.once("error", reject);
@@ -1905,6 +2362,7 @@ class ConversationList {
   #records = new Map;
   #facts = new Map;
   #index = new Map;
+  #runEnd = new Set;
   #list = [];
   #unsubscribe = () => {};
   #notifying = false;
@@ -1917,7 +2375,7 @@ class ConversationList {
     const summaries = [];
     let cursor;
     do {
-      const page = await harness.commit((tx) => tx.scanConversations({}, 256, cursor), context);
+      const page = await harness.commit((tx) => tx.scanConversations({}, 256, cursor), context3);
       for (const record of page.items) {
         list.#records.set(record.id, record);
         const facts = await list.#load(harness, record);
@@ -1934,24 +2392,30 @@ class ConversationList {
   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, context);
+    const live = await harness.snapshot(LiveDoc, record.id, context3);
     facts.running = live?.run !== undefined;
     facts.tools = live?.tools;
     for (const token of this.#questionTokens) {
-      const value = await harness.snapshot(token, record.id, context);
+      const value = await harness.snapshot(token, record.id, context3);
       if (Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined)) {
         facts.pending.add(token.definition.kind);
       }
     }
     if (record.owner !== undefined) {
-      const label = (await harness.snapshot(SubagentDoc, record.id, context))?.label;
-      if (typeof label === "string" && label !== "")
-        facts.label = label;
+      const subagent = await harness.snapshot(SubagentDoc, record.id, context3);
+      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, context3))?.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);
@@ -1981,9 +2445,12 @@ class ConversationList {
         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);
@@ -1995,8 +2462,13 @@ class ConversationList {
           facts.pending = next2;
           touched.add(id);
         } else if (change.record.kind === SubagentDoc.definition.kind) {
-          const label = change.value?.label;
-          facts.label = typeof label === "string" && label !== "" ? label : undefined;
+          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);
         }
       }
@@ -2019,6 +2491,13 @@ class ConversationList {
     }
     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);
@@ -2062,31 +2541,33 @@ function summaryOf(record, facts) {
     kind: record.owner !== undefined ? "subagent" : record.parent !== undefined ? "fork" : "conversation",
     ...parent === undefined ? {} : { parent },
     ...record.parent === undefined ? {} : { forkedAt: String(record.parent.at) },
-    ...facts.title === undefined ? {} : { title: facts.title },
+    ...(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.activity?.tool === b.activity?.tool && a.activity?.target === b.activity?.target;
+  return a.id === b.id && a.kind === b.kind && a.parent === b.parent && a.forkedAt === b.forkedAt && a.title === b.title && a.status === b.status && a.updatedAt === b.updatedAt && a.label === b.label && a.role === b.role && a.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 historyFacts(harness, id) {
-  const conversation = await harness.conversation(id, context);
+  const conversation = await harness.conversation(id, context3);
   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, context3);
+    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);
@@ -2120,13 +2601,20 @@ 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({
@@ -2165,7 +2653,7 @@ class GatewayClient {
       ...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 }
@@ -2216,36 +2704,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, context3);
+      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, context3);
+      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(context3), 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(context3), 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);
@@ -2268,7 +2754,7 @@ class GatewayClient {
       setImmediate(() => signalCreation());
     });
     try {
-      const existing = await harness.watchDoc(token, id, context);
+      const existing = await harness.watchDoc(token, id, context3);
       if (existing !== undefined) {
         unsubscribe();
         return this.#forward(stream, existing, send);
@@ -2281,13 +2767,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, context3);
+      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();
       }
@@ -2304,10 +2790,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);
@@ -2315,7 +2801,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, context3);
     if (conversation === undefined)
       throw new Error(`Conversation ${id} does not exist`);
     return conversation;
@@ -2331,27 +2817,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, context3);
       case "removeProject":
-        await removeProject(this.#options.harness, args.path, context);
+        await removeProject(this.#options.harness, args.path, context3);
         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, context3);
         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, context3);
         if (input.archived) {
-          const kept = await cleanupArchivedWorktrees(this.#options.harness, input.conversationId, context);
+          const kept = await cleanupArchivedWorktrees(this.#options.harness, input.conversationId, context3);
           for (const { record, reason } of kept) {
             await this.send({ type: "notice", level: "warning", message: `Kept worktree ${record.path} (branch ${record.branch}): ${reason}` });
           }
@@ -2366,31 +2856,95 @@ class GatewayClient {
       }
       case "revokeDevice": {
         const { publicKey } = args;
-        await revokeDevice(this.#options.harness, publicKey, context);
+        await revokeDevice(this.#options.harness, publicKey, context3);
         this.#hooks.closeDevice(publicKey);
         return null;
       }
+      case "setPushToken": {
+        const device = this.devicePublicKey;
+        if (device === undefined)
+          throw new Error("Push tokens register over the secure channel only");
+        await setPushToken(this.#options.harness, device, args.token, context3);
+        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, context3);
+        const submission = await conversation.submit({ type: "input", content: messageContent(text, images), whenBusy: dismissed ? "steer" : whenBusy, requestId }, context3);
+        submission.wait(context3).then((settled) => {
           if (settled.status === "unanswered" && settled.reason !== "aborted") {
             this.send({ type: "notice", level: "error", message: `No answer: ${settled.reason}` });
           }
         }, () => {});
         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";
+        }, context3);
+        return null;
+      }
       case "abort":
-        await conversation.abort(context);
+        await conversation.abort(context3);
         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, context3);
+        this.#options.harness.waitForTask(taskId, context3).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
         return { taskId };
       }
       case "setModel": {
@@ -2399,7 +2953,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) }, context3);
         return null;
       }
       case "setThinkingLevel": {
@@ -2411,7 +2965,7 @@ 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 }, context3);
         return null;
       }
       case "fork": {
@@ -2435,13 +2989,13 @@ class GatewayClient {
               }
               cursor = page.next;
             } while (cursor !== undefined);
-          }, context);
-          const agent = await conversation.agent(context);
+          }, context3);
+          const agent = await conversation.agent(context3);
           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 } } }
-          }, context);
+          }, context3);
           return { conversationId: fork.id };
         });
       }
@@ -2477,16 +3031,16 @@ class GatewayClient {
           }
           request.resolution = { outcome: "answered", answers, at: Date.now() };
           return { first: true };
-        }, context);
+        }, context3);
       }
       case "changes": {
-        return await this.#changes(conversation, context);
+        return await this.#changes(conversation, context3);
       }
     }
   }
-  async#dismissPendingQuestions(conversationId, context2) {
+  async#dismissPendingQuestions(conversationId, context4) {
     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, context4)));
     const pending = snapshots.some((value) => Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined));
     if (!pending)
       return false;
@@ -2504,18 +3058,18 @@ class GatewayClient {
         }
       }
       return dismissed;
-    }, context2);
+    }, context4);
   }
   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, context4) {
+    const cwd = (await conversation.agent(context4)).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, context4);
     const record = checkoutAt(index?.checkouts, cwd);
     if (record !== undefined) {
       if (!await worktreeExists(record.path))
@@ -2528,7 +3082,7 @@ class GatewayClient {
     return { available: true, ...await changesOf(base.repo, base.base) };
   }
   async#agent(id) {
-    return await this.#options.harness.snapshot(AgentDoc3, id, context) ?? {};
+    return await this.#options.harness.snapshot(AgentDoc3, id, context3) ?? {};
   }
   async dispose() {
     if (this.#disposed)
@@ -2542,20 +3096,20 @@ class GatewayClient {
 }
 
 // apps/host/src/host.ts
-var context2 = BACKGROUND_CONTEXT2;
+var context4 = BACKGROUND_CONTEXT4;
 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,
@@ -2566,25 +3120,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() ?? [],
+    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) => {
@@ -2593,15 +3165,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, context4);
           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 });
@@ -2609,35 +3181,42 @@ 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);
+    }, context4);
+    await ensureIndex(harness, context4);
+    await ensureDevices(harness, context4);
     for (const path of options.projects ?? [])
-      await addProject(harness, path, context2);
+      await addProject(harness, path, context4);
     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 },
+      ...options.autoTitle === undefined ? {} : { autoTitle: options.autoTitle },
+      ...options.push === undefined ? {} : {
+        push: {
+          hostKey: toBase64Url(hostKey.publicKey),
+          ...options.push.fetch === undefined ? {} : { fetch: options.push.fetch },
+          ...options.push.timers === undefined ? {} : { timers: options.push.timers }
+        }
+      },
       secure: {
         hostKey,
         offers,
@@ -2668,15 +3247,27 @@ async function openHost(options) {
       url: gateway.url,
       token,
       harness,
+      closed: opened.closed,
+      settings: hostSettings,
+      createAccountOffer: async () => {
+        const binding = await readServerBinding(options.dataDir).catch(() => {
+          return;
+        });
+        return binding === undefined ? undefined : offers.createAccount(binding);
+      },
       ...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(context4);
             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(context4)));
           } finally {
             await release();
           }
@@ -2685,15 +3276,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(context4).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";
@@ -2761,7 +3357,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();
@@ -2779,10 +3375,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;
     }
   };
 }
@@ -2802,11 +3398,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],
@@ -2824,31 +3490,34 @@ 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: (input, context3) => checkoutInfo(host2.harness(), input, context3)
-      }),
-      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 ?? {}))
-      })
-    ];
-  };
+  let relayOrigin;
+  try {
+    relayOrigin = resolveRelayOrigin(values.relay, await readServerConfig(dataDir));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  const extensionsFor = (models, summaries, options2) => (host2) => [
+    createContext({
+      agentsHome: join8(homedir3(), ".agents"),
+      checkout: (input, context5) => checkoutInfo(host2.harness(), input, context5)
+    }),
+    createCoding(options2),
+    todo,
+    question,
+    createSubagent({
+      models,
+      modelSummaries: summaries,
+      exclude: [question.extension],
+      roles: () => host2.agentRoles.value.roles
+    }),
+    createCodemode()
+  ];
   const 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"]) },
@@ -2858,7 +3527,7 @@ async function main(argv) {
         ...values["public-url"] === undefined ? {} : { publicUrl: values["public-url"] }
       }
     },
-    ...values.relay === undefined ? {} : { relay: { origin: values.relay } }
+    ...relayOrigin === undefined ? {} : { relay: { origin: relayOrigin } }
   };
   function fauxOptions(responses) {
     const faux = fauxProvider({ tokensPerSecond: Number(values["faux-tps"]), tokenSize: { min: 1, max: 1 } });
@@ -2872,7 +3541,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 {
@@ -2880,32 +3550,50 @@ 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),
+      push: {},
+      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,
@@ -2921,6 +3609,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)
   ;