pinomad 0.7.0 → 0.9.0

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

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   serveWebClient
-} from "./chunk-r6w5aqkw.js";
+} from "./chunk-wb10efyq.js";
 import {
   Published,
   constantValue,
   openHostSettings,
   sameList,
   settingsDefaults
-} from "./chunk-b1h374jr.js";
+} from "./chunk-v414b5pp.js";
 import {
   DevicesDoc,
   RevocationsDoc,
@@ -21,21 +21,16 @@ import {
   readServerBinding,
   readServerConfig,
   resolveRelayOrigin
-} from "./chunk-0xh6cy9v.js";
+} from "./chunk-5gp9svzs.js";
 import {
-  SECURE_PROLOGUE,
-  SecureSession,
-  decodeClientHello,
-  encodeHostHello,
+  relayHostId,
   relayWsBase,
-  respondIK,
-  startRelayLink,
-  toBase64Url
-} from "./chunk-7qb9tq54.js";
+  startRelayLink
+} from "./chunk-khcpv54k.js";
 import {
   packagedVersion,
   webRoot
-} from "./chunk-rtwxjb90.js";
+} from "./chunk-vyvyaavr.js";
 import {
   ATTACHMENT_TTL_MS,
   INVALID_FRAME_CLOSE_CODE,
@@ -44,32 +39,56 @@ import {
   MAX_PENDING_ATTACHMENTS,
   MAX_PENDING_ATTACHMENT_BYTES,
   PROTOCOL,
+  RTC_DATA_CHANNEL_LABEL,
+  RTC_DEFAULT_STUN,
+  RTC_MAX_RECORD_BYTES,
   UNAUTHORIZED_CLOSE_CODE,
   attachmentBeginProblem,
   attachmentBlock,
   attachmentChunkProblem,
   base64DecodedLength,
   isAttachmentId,
+  isCustomProviderApi,
   organize,
   parseAttachmentBlock,
-  parseClientFrame
-} from "./chunk-e4ahjbmz.js";
+  parseClientFrame,
+  parseRtcMaxMessageSize,
+  rtcCandidateType,
+  sdpCandidates,
+  withRtcCandidates
+} from "./chunk-jgd38rna.js";
 import {
+  ENDPOINT_SET_SCHEMA_VERSION,
+  MAX_HOST_ENDPOINT_URL_LENGTH,
+  SECURE_PROLOGUE,
+  SIGNAL_PROLOGUE,
+  SecureSession,
   THINKING_LEVELS,
-  isThinkingLevel
-} from "./chunk-znhn8af7.js";
+  decodeClientHello,
+  encodeEndpointSetParam,
+  encodeHostHello,
+  isLoopbackUrl,
+  isThinkingLevel,
+  parseEndpointSet,
+  respondIK,
+  toBase64Url
+} from "./chunk-sygeb9qb.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-ngf1zatm.js";
-import"./chunk-df32avw6.js";
+import {
+  __require
+} from "./chunk-df32avw6.js";
 
 // apps/host/src/main.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { join as join12, resolve as resolve7 } from "node:path";
 import { parseArgs } from "node:util";
 import { createModels } from "@earendil-works/pi-ai/models";
 import { fauxAssistantMessage, fauxProvider } from "@earendil-works/pi-ai/providers/faux";
-import { getAgentDir, ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { createNodePhotonImages } from "@earendil-works/pi-durable/images/node";
 
 // apps/host/src/extensions/question.ts
@@ -134,7 +153,8 @@ var QuestionDoc = defineDoc({
   scope: "conversation",
   history: "latest",
   fork: "initial",
-  initial: () => ({ requests: [] })
+  initial: () => ({ requests: [] }),
+  checkpointWhen: () => false
 });
 var resolutionOf = (value, requestId) => value?.requests.find((request) => request.id === requestId)?.resolution;
 var createWait = (tx, owner, requestId) => tx.createTask(QuestionWait, { requestId }, { ownership: { kind: "task", taskId: owner } });
@@ -453,7 +473,8 @@ var RoleDoc = defineDoc2({
   scope: "conversation",
   history: "rewindable",
   fork: "asOf",
-  initial: () => ({})
+  initial: () => ({}),
+  checkpointWhen: () => false
 });
 
 // apps/host/src/organization.ts
@@ -461,7 +482,8 @@ var IndexDoc = defineDoc3({
   kind: "pinomad.index",
   version: 1,
   scope: "session",
-  initial: () => ({ projects: [], conversations: [] })
+  initial: () => ({ projects: [], conversations: [] }),
+  checkpointWhen: () => false
 });
 async function ensureIndex(harness, context) {
   await harness.commit(async (tx) => {
@@ -1254,7 +1276,8 @@ var SubagentDoc = defineDoc4({
   scope: "conversation",
   history: "latest",
   fork: "initial",
-  initial: () => ({})
+  initial: () => ({}),
+  checkpointWhen: () => false
 });
 
 // apps/host/src/extensions/subagent.ts
@@ -1404,7 +1427,8 @@ var TodoDoc = defineDoc5({
   scope: "conversation",
   history: "rewindable",
   fork: "asOf",
-  initial: () => ({ items: [] })
+  initial: () => ({ items: [] }),
+  checkpointWhen: () => false
 });
 var todoWrite = defineTool3({
   name: "todo_write",
@@ -1424,568 +1448,655 @@ var todo = {
   docs: [{ token: TodoDoc, presentation: "pinomad.todo" }]
 };
 
-// apps/host/src/host.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename3, join as join10, sep as sep6 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
-import { createRegistry, Harness } from "@earendil-works/pi-durable";
-import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
-
-// apps/host/src/mcp.ts
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { isAbsolute, resolve as resolve4 } from "node:path";
+// apps/host/src/gateway.ts
+import { createServer } from "node:http";
+import { homedir, networkInterfaces } from "node:os";
+import { join as join7, sep as sep5 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
+import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
-  McpAuthRequiredError,
-  McpClient,
-  McpHttpError,
-  StdioTransport,
-  StreamableHttpTransport,
-  toLlmContent
-} from "@earendil-works/pi-mcp";
-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) {
-  let missing;
-  const expanded = value.replace(ENV_VAR, (_all, name) => {
-    const found = process.env[name];
-    if (found === undefined)
-      missing = name;
-    return found ?? "";
-  });
-  return missing === undefined ? expanded : { missing };
+  AgentDoc as AgentDoc5,
+  configure as configure3,
+  InboxDoc,
+  LiveDoc
+} from "@earendil-works/pi-durable";
+import { WebSocket as WebSocket2, WebSocketServer } from "ws";
+import { Value as Value2 } from "typebox/value";
+
+// apps/host/src/secure-carrier.ts
+import { WebSocket } from "ws";
+function webSocketCarrier(socket) {
+  socket.on("error", () => socket.terminate());
+  return {
+    get open() {
+      return socket.readyState === WebSocket.OPEN;
+    },
+    send: (bytes) => socket.readyState === WebSocket.OPEN ? new Promise((resolve4) => socket.send(bytes, () => resolve4())) : Promise.resolve(),
+    close: (code, reason) => {
+      try {
+        socket.close(code, reason);
+      } catch {
+        socket.terminate();
+      }
+    },
+    handle(handlers) {
+      socket.on("message", (data, isBinary) => {
+        if (!isBinary) {
+          handlers.text();
+          return;
+        }
+        if (Array.isArray(data)) {
+          handlers.binary(new Uint8Array(Buffer.concat(data)));
+          return;
+        }
+        handlers.binary(data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+      });
+      socket.once("close", () => handlers.closed());
+    }
+  };
 }
-function expandAll(values, field, error) {
-  if (values === undefined)
-    return;
-  if (!isObject(values)) {
-    error(`"${field}" must be an object of strings`);
-    return;
-  }
-  const expanded = {};
-  for (const [key, value] of Object.entries(values)) {
-    if (typeof value !== "string") {
-      error(`"${field}.${key}" must be a string`);
+
+// apps/host/src/rtc.ts
+import { randomUUID } from "node:crypto";
+var BUFFER_HIGH_WATER = 256 * 1024;
+var BUFFER_LOW_WATER = 64 * 1024;
+var PUMP_STALL_MS = 1e4;
+var FALLBACK_POLL_MS = 50;
+var CANDIDATE_BUDGET_MS = 2000;
+var PEER_TIMEOUT_MS = 20000;
+var PER_DEVICE_PEERS = 2;
+var HOST_PEERS = 8;
+var systemRtcTimers = {
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (handle) => clearTimeout(handle),
+  now: () => Date.now()
+};
+function platformPackageName(platform = process.platform, arch = process.arch) {
+  if (platform === "linux" && arch === "x64")
+    return "@node-datachannel/linux-x64-gnu";
+  if (platform === "linux" && arch === "arm64")
+    return "@node-datachannel/linux-arm64-gnu";
+  if (platform === "darwin" && arch === "arm64")
+    return "@node-datachannel/darwin-arm64";
+  if (platform === "darwin" && arch === "x64")
+    return "@node-datachannel/darwin-x64";
+  if (platform === "win32" && arch === "x64")
+    return "@node-datachannel/win32-x64-msvc";
+  if (platform === "win32" && arch === "arm64")
+    return "@node-datachannel/win32-arm64-msvc";
+  if (platform === "android" && arch === "arm64")
+    return "@node-datachannel/android-arm64";
+  return `@node-datachannel/${platform}-${arch}`;
+}
+function rtcUnavailableDiagnostic(error, platform = process.platform, arch = process.arch) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return `RTC unavailable: cannot load node-datachannel on ${platform} (${arch}); ` + `missing ${platformPackageName(platform, arch)}. ` + "Install without --omit=optional (or build node-datachannel locally); " + "the host continues without hello.rtc. " + `(${detail})`;
+}
+async function startRtcHost(options) {
+  let factory = options.factory;
+  if (factory === undefined) {
+    let loaded;
+    try {
+      loaded = options.load === undefined ? await import("node-datachannel") : await options.load();
+    } catch (error) {
+      (options.diagnostic ?? console.error)(rtcUnavailableDiagnostic(error));
       return;
     }
-    const result2 = expand(value);
-    if (typeof result2 !== "string") {
-      error(`"${field}.${key}" references unset environment variable ${result2.missing}`);
+    try {
+      factory = nodeRtcFactory(loaded);
+    } catch (error) {
+      (options.diagnostic ?? console.error)(rtcUnavailableDiagnostic(error));
       return;
     }
-    expanded[key] = result2;
   }
-  return expanded;
+  return new PeerHost(factory, options);
 }
-function parseServer(name, raw, error) {
-  const fail = (message) => {
-    error(`${name}: ${message}`);
-    return;
-  };
-  if (!isObject(raw))
-    return fail("server entry must be an object");
-  if (raw.enabled === false)
-    return { name, disabled: true };
-  const timeout = raw.timeout === undefined ? 60000 : typeof raw.timeout === "number" && raw.timeout > 0 ? raw.timeout * 1000 : undefined;
-  if (timeout === undefined)
-    return fail(`"timeout" must be a positive number of seconds`);
-  if (raw.exposure !== undefined && raw.exposure !== "codemode" && raw.exposure !== "direct") {
-    return fail(`"exposure" must be "codemode" or "direct"`);
+
+class PeerHost {
+  #factory;
+  #options;
+  #timers;
+  #peers = new Set;
+  #byAttempt = new Map;
+  #log;
+  constructor(factory, options) {
+    this.#factory = factory;
+    this.#options = options;
+    this.#timers = options.timers ?? systemRtcTimers;
+    this.#log = options.log ?? (() => {});
+  }
+  hello() {
+    return { stun: [...this.#options.stun()], signalOnly: true };
+  }
+  async offer(input) {
+    if (input.attempt === "")
+      throw new Error("rtcOffer requires a non-empty attempt id");
+    const stun = this.#options.stun();
+    if (stun.length === 0)
+      this.#log("rtc-no-stun", { attempt: input.attempt });
+    const key = `${input.deviceKey ?? ""}\x00${input.attempt}`;
+    const existing = this.#byAttempt.get(key);
+    if (existing !== undefined) {
+      if (existing.answer !== undefined)
+        return { sdp: existing.answer };
+      if (existing.failure === undefined) {
+        return { sdp: await Promise.race([existing.answerPromise, existing.closedSignal]) };
+      }
+      existing.close();
+    }
+    const perDevice = this.#options.perDeviceLimit ?? PER_DEVICE_PEERS;
+    const hostLimit = this.#options.hostLimit ?? HOST_PEERS;
+    if (input.deviceKey !== undefined) {
+      const count = [...this.#peers].filter((peer2) => peer2.deviceKey === input.deviceKey).length;
+      if (count >= perDevice) {
+        throw new Error(`Too many WebRTC peers for this device (limit ${perDevice})`);
+      }
+    }
+    if (this.#peers.size >= hostLimit) {
+      throw new Error(`Too many WebRTC peers on this host (limit ${hostLimit})`);
+    }
+    const peer = new ManagedPeer(this, {
+      attempt: input.attempt,
+      owner: input.owner,
+      ...input.deviceKey === undefined ? {} : { deviceKey: input.deviceKey },
+      timers: this.#timers
+    });
+    this.#peers.add(peer);
+    this.#byAttempt.set(key, peer);
+    let connection;
+    try {
+      connection = this.#factory.connect({
+        offerSdp: input.sdp,
+        stun,
+        timers: this.#timers,
+        onChannel: (channel) => this.#onChannel(peer, channel),
+        onClosed: () => this.#remove(peer),
+        log: this.#log
+      });
+    } catch (error) {
+      this.#remove(peer);
+      throw error;
+    }
+    peer.attach(connection);
+    peer.answerPromise = connection.answer.then((sdp) => {
+      if (peer.closed)
+        throw new Error("WebRTC peer closed before its answer was ready");
+      peer.answer = sdp;
+      return sdp;
+    }, (error) => {
+      peer.failure = error instanceof Error ? error.message : String(error);
+      this.#remove(peer);
+      throw error;
+    });
+    peer.answerPromise.catch(() => {});
+    peer.arm(this.#options.peerTimeoutMs ?? PEER_TIMEOUT_MS);
+    return { sdp: await Promise.race([peer.answerPromise, peer.closedSignal]) };
   }
-  if (raw.description !== undefined && typeof raw.description !== "string")
-    return fail(`"description" must be a string`);
-  const exposure = raw.exposure ?? "codemode";
-  const description = raw.description;
-  if (raw.command !== undefined || raw.type === "stdio") {
-    if (typeof raw.command !== "string" || raw.command === "")
-      return fail(`stdio server needs a "command"`);
-    if (raw.args !== undefined && (!Array.isArray(raw.args) || !raw.args.every((arg) => typeof arg === "string"))) {
-      return fail(`"args" must be an array of strings`);
+  #onChannel(peer, channel) {
+    if (peer.closed) {
+      channel.carrier.close(1008, "peer closed");
+      return;
     }
-    if (raw.cwd !== undefined && typeof raw.cwd !== "string")
-      return fail(`"cwd" must be a string`);
-    const env = expandAll(raw.env, "env", (message) => error(`${name}: ${message}`));
-    if (raw.env !== undefined && env === undefined)
+    if (peer.channel !== undefined) {
+      channel.carrier.close(1008, "duplicate DataChannel");
       return;
-    const cwd = raw.cwd === undefined ? homedir() : isAbsolute(raw.cwd) ? raw.cwd : resolve4(homedir(), raw.cwd);
-    return {
-      name,
-      spec: { kind: "stdio", command: raw.command, args: raw.args, env, cwd },
-      timeoutMs: timeout,
-      exposure,
-      ...description === undefined ? {} : { description }
-    };
+    }
+    peer.channel = channel;
+    this.#options.onChannel(peer, channel);
   }
-  if (raw.url !== undefined || raw.type === "http" || raw.type === "sse") {
-    if (typeof raw.url !== "string" || raw.url === "")
-      return fail(`HTTP server needs a "url"`);
-    const headers = expandAll(raw.headers, "headers", (message) => error(`${name}: ${message}`));
-    if (raw.headers !== undefined && headers === undefined)
+  #remove(peer) {
+    if (!this.#peers.delete(peer))
       return;
-    return {
-      name,
-      spec: { kind: "http", url: raw.url, headers },
-      timeoutMs: timeout,
-      exposure,
-      ...description === undefined ? {} : { description }
-    };
+    for (const [key, candidate] of this.#byAttempt) {
+      if (candidate === peer)
+        this.#byAttempt.delete(key);
+    }
+    peer.teardown();
   }
-  return fail(`needs "command" (stdio) or "url" (HTTP)`);
-}
-async function loadConfig(configPath) {
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(configPath, "utf8"));
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return { errors: [], entries: [] };
-    return { errors: [`${configPath}: ${error instanceof Error ? error.message : String(error)}`], entries: [] };
+  closeOwner(owner) {
+    for (const peer of [...this.#peers]) {
+      if (peer.owner === owner && !peer.handedOff)
+        peer.close();
+    }
   }
-  if (!isObject(parsed) || parsed.mcpServers !== undefined && !isObject(parsed.mcpServers)) {
-    return { errors: [`${configPath}: "mcpServers" must be an object`], entries: [] };
+  closeDevice(deviceKey) {
+    for (const peer of [...this.#peers]) {
+      if (peer.deviceKey === deviceKey && !peer.handedOff)
+        peer.close();
+    }
   }
-  const errors = [];
-  const entries = [];
-  for (const [name, raw] of Object.entries(parsed.mcpServers ?? {})) {
-    const entry = parseServer(name, raw, (message) => errors.push(message));
-    if (entry !== undefined)
-      entries.push(entry);
+  async close() {
+    for (const peer of [...this.#peers])
+      peer.close();
+  }
+  remove(peer) {
+    this.#remove(peer);
   }
-  return { errors, entries };
 }
-var callName = (server, tool) => `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_]/g, "_").slice(0, 64);
-var callToolResultSchema = (tool) => ({
-  type: "object",
-  properties: {
-    content: { type: "array", items: { type: "object" } },
-    isError: { type: "boolean" },
-    _meta: { type: "object" },
-    structuredContent: tool.outputSchema ?? { type: "object" }
-  },
-  required: ["content"]
-});
-function mcpTool(client, timeoutMs, exposure, name, tool) {
-  return defineTool4({
-    name,
-    description: tool.description ?? tool.title ?? tool.name,
-    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 client.callTool(tool.name, args, {
-        signal: context.abortSignal ?? NEVER_ABORT,
-        timeoutMs
-      });
-      return { output: toLlmContent(result2), structuredOutput: result2, isError: result2.isError === true };
+
+class ManagedPeer {
+  attempt;
+  deviceKey;
+  owner;
+  timers;
+  answer;
+  answerPromise = Promise.reject(new Error("peer has no connection"));
+  closedSignal;
+  failure;
+  channel;
+  handedOff = false;
+  closed = false;
+  #connection;
+  #timer;
+  #rejectClosed;
+  #host;
+  constructor(host, input) {
+    this.#host = host;
+    this.attempt = input.attempt;
+    this.owner = input.owner;
+    this.deviceKey = input.deviceKey;
+    this.timers = input.timers;
+    this.answerPromise.catch(() => {});
+    this.closedSignal = new Promise((_, reject) => {
+      this.#rejectClosed = reject;
+    });
+    this.closedSignal.catch(() => {});
+  }
+  attach(connection) {
+    this.#connection = connection;
+  }
+  arm(timeoutMs) {
+    if (this.closed)
+      return;
+    this.#timer = this.timers.setTimeout(() => {
+      this.#timer = undefined;
+      if (this.closed || this.handedOff)
+        return;
+      this.close();
+    }, timeoutMs);
+  }
+  handOff() {
+    if (this.closed)
+      return;
+    this.handedOff = true;
+    if (this.#timer !== undefined) {
+      this.timers.clearTimeout(this.#timer);
+      this.#timer = undefined;
     }
-  });
+  }
+  close() {
+    this.#host.remove(this);
+  }
+  teardown() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    if (this.#timer !== undefined) {
+      this.timers.clearTimeout(this.#timer);
+      this.#timer = undefined;
+    }
+    this.#rejectClosed(new Error(this.failure ?? "WebRTC peer closed"));
+    try {
+      this.#connection?.close();
+    } catch {}
+    this.channel?.carrier.close(1008, "peer closed");
+  }
 }
-var NEVER_ABORT = new AbortController().signal;
-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 = [];
-  let closed = false;
-  const publish = () => {
-    const value = { configPath: options.configPath, errors, servers: [...servers.values()] };
-    for (const listener of listeners)
-      listener(value);
-  };
-  const install = () => {
-    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 });
-    publish();
-  };
-  const relist = async (name, client, timeoutMs, description) => {
-    const taken = new Set([...toolsets.entries()].flatMap(([other, tools2]) => other === name ? [] : tools2.map((tool) => tool.name)));
-    const tools = [];
-    const collisions = [];
-    for (const tool of await client.listTools()) {
-      const wire = callName(name, tool.name);
-      if (taken.has(wire)) {
-        collisions.push(`tool "${tool.name}" collides as ${wire}; skipped`);
-        continue;
+function nativeModule(loaded) {
+  const candidate = loaded.default ?? loaded;
+  if (typeof candidate.PeerConnection !== "function") {
+    throw new Error("node-datachannel did not export PeerConnection");
+  }
+  return candidate;
+}
+function nodeRtcFactory(loaded) {
+  const ndc = nativeModule(loaded);
+  return {
+    connect(input) {
+      const max = parseRtcMaxMessageSize(input.offerSdp);
+      if (max.kind === "invalid")
+        throw new Error(max.reason);
+      const pc = new ndc.PeerConnection(`pinomad-${randomUUID()}`, { iceServers: [...input.stun] });
+      const timers = input.timers;
+      const candidates = new Set;
+      let localSdp;
+      let gatheringDone = false;
+      let deadlineReached = false;
+      let settled = false;
+      let deadline;
+      let pollTimer;
+      let commitTimer;
+      let resolveAnswer;
+      let rejectAnswer;
+      const answer = new Promise((resolve4, reject) => {
+        resolveAnswer = resolve4;
+        rejectAnswer = reject;
+      });
+      answer.catch(() => {});
+      const addCandidate = (raw) => {
+        const type = rtcCandidateType(raw);
+        if (type !== "host" && type !== "srflx" && type !== "prflx")
+          return;
+        candidates.add(raw.startsWith("a=") ? raw.slice(2) : raw);
+      };
+      const stopTimers = () => {
+        if (deadline !== undefined) {
+          timers.clearTimeout(deadline);
+          deadline = undefined;
+        }
+        if (pollTimer !== undefined) {
+          timers.clearTimeout(pollTimer);
+          pollTimer = undefined;
+        }
+        if (commitTimer !== undefined) {
+          timers.clearTimeout(commitTimer);
+          commitTimer = undefined;
+        }
+      };
+      const fail = (error) => {
+        if (settled)
+          return;
+        settled = true;
+        stopTimers();
+        try {
+          pc.close();
+        } catch {}
+        rejectAnswer(error);
+      };
+      const commit = () => {
+        if (settled)
+          return;
+        const local = pc.localDescription();
+        if (local !== null)
+          localSdp = local.sdp;
+        if (localSdp === undefined)
+          return;
+        for (const candidate of sdpCandidates(localSdp))
+          addCandidate(candidate);
+        if (candidates.size === 0) {
+          if (deadlineReached)
+            fail(new Error("no usable local ICE candidates"));
+          return;
+        }
+        settled = true;
+        stopTimers();
+        resolveAnswer(withRtcCandidates(localSdp, [...candidates]));
+      };
+      const maybeCommit = () => {
+        if (commitTimer !== undefined && !deadlineReached)
+          return;
+        if (localSdp !== undefined && (gatheringDone || deadlineReached))
+          commit();
+      };
+      const scheduleCommit = () => {
+        if (settled)
+          return;
+        if (commitTimer !== undefined)
+          timers.clearTimeout(commitTimer);
+        commitTimer = timers.setTimeout(() => {
+          commitTimer = undefined;
+          maybeCommit();
+        }, 0);
+      };
+      pc.onLocalDescription((sdp) => {
+        localSdp = sdp;
+        if (gatheringDone)
+          scheduleCommit();
+        else
+          maybeCommit();
+      });
+      pc.onLocalCandidate((candidate) => {
+        addCandidate(candidate);
+        if (gatheringDone)
+          scheduleCommit();
+      });
+      pc.onGatheringStateChange((state) => {
+        if (state === "complete") {
+          gatheringDone = true;
+          scheduleCommit();
+        }
+      });
+      pc.onStateChange((state) => {
+        if (state === "closed" || state === "failed")
+          input.onClosed();
+      });
+      pc.onDataChannel((channel) => {
+        if (channel.getLabel() !== RTC_DATA_CHANNEL_LABEL) {
+          channel.close();
+          return;
+        }
+        let delivered = false;
+        const ready = () => {
+          if (delivered || settled === false)
+            return;
+          delivered = true;
+          const limit = channel.maxMessageSize();
+          if (limit !== 0 && limit < RTC_MAX_RECORD_BYTES) {
+            input.log("rtc-datachannel-too-small", { maxMessageSize: limit });
+            channel.close();
+            return;
+          }
+          input.onChannel({
+            carrier: dataChannelCarrier(channel, timers, input.log, () => input.onClosed())
+          });
+        };
+        channel.onOpen(ready);
+        if (channel.isOpen())
+          ready();
+      });
+      const poll = () => {
+        if (settled)
+          return;
+        const local = pc.localDescription();
+        if (local !== null) {
+          localSdp = local.sdp;
+          if (gatheringDone)
+            scheduleCommit();
+          else
+            maybeCommit();
+        }
+        if (!settled)
+          pollTimer = timers.setTimeout(poll, 25);
+      };
+      pollTimer = timers.setTimeout(poll, 25);
+      deadline = timers.setTimeout(() => {
+        deadlineReached = true;
+        const local = pc.localDescription();
+        if (local !== null)
+          localSdp = local.sdp;
+        if (localSdp === undefined)
+          fail(new Error(`no local description within ${CANDIDATE_BUDGET_MS} ms`));
+        else
+          commit();
+      }, CANDIDATE_BUDGET_MS);
+      try {
+        pc.setRemoteDescription(input.offerSdp, "offer");
+      } catch (error) {
+        fail(error instanceof Error ? error : new Error(String(error)));
       }
-      taken.add(wire);
-      tools.push(mcpTool(client, timeoutMs, exposures.get(name) ?? "codemode", wire, tool));
+      return {
+        answer,
+        close: () => {
+          stopTimers();
+          try {
+            pc.close();
+          } catch {}
+        }
+      };
+    }
+  };
+}
+function dataChannelCarrier(channel, timers, log, onClosed) {
+  channel.setBufferedAmountLowThreshold(BUFFER_LOW_WATER);
+  let handlers;
+  let closed = false;
+  let pumping = false;
+  let falseSends = 0;
+  let lastProgress = timers.now();
+  let pollTimer;
+  let stallTimer;
+  const queue = [];
+  const clearTimers = () => {
+    if (pollTimer !== undefined) {
+      timers.clearTimeout(pollTimer);
+      pollTimer = undefined;
+    }
+    if (stallTimer !== undefined) {
+      timers.clearTimeout(stallTimer);
+      stallTimer = undefined;
     }
+  };
+  const finish = () => {
     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();
+    closed = true;
+    clearTimers();
+    for (const item of queue.splice(0))
+      item.resolve();
+    handlers?.closed();
+    onClosed?.();
   };
-  const fail = (name, error) => {
-    toolsets.delete(name);
-    namespaces.delete(name);
-    set(name, { state: "failed", error, tools: 0 });
-    install();
-  };
-  const describeConnectError = (error, transport) => {
-    if (error instanceof McpAuthRequiredError || error instanceof McpHttpError && error.status === 401) {
-      return "requires sign-in (OAuth), not supported yet";
+  const stall = () => {
+    stallTimer = undefined;
+    if (closed || queue.length === 0)
+      return;
+    if (timers.now() - lastProgress < PUMP_STALL_MS) {
+      stallTimer = timers.setTimeout(stall, 1000);
+      return;
     }
-    const base = error instanceof Error ? error.message : String(error);
-    const stderr = transport?.stderr.trim().split(`
-`).slice(-5).join(`
-`);
-    return stderr === undefined || stderr === "" ? base : `${base}
-${stderr}`;
-  };
-  const connect = async (name, spec, timeoutMs, description) => {
-    const client = new McpClient({ name: "pinomad", version: "0.0.0" });
-    live.add(client);
-    let stdio;
+    log("rtc-datachannel-stalled", { queued: queue.length, falseSends, buffered: channel.bufferedAmount() });
+    finish();
     try {
-      const transport = spec.kind === "stdio" ? stdio = new StdioTransport({ command: spec.command, args: spec.args, cwd: spec.cwd, env: spec.env, stderr: "pipe" }) : new StreamableHttpTransport({ url: spec.url, headers: spec.headers });
-      await client.connect(transport);
-      if (closed)
-        return;
-      let lastError;
-      client.onError((error) => {
-        lastError = error.message;
-      });
-      client.onClose(() => {
-        if (!closed)
-          fail(name, `disconnected${lastError === undefined ? "" : `: ${lastError}`}`);
-      });
-      client.onNotification("notifications/tools/list_changed", () => {
-        relist(name, client, timeoutMs, description).catch((error) => {
-          fail(name, error instanceof Error ? error.message : String(error));
-        });
-      });
-      await relist(name, client, timeoutMs, description);
-    } catch (error) {
-      live.delete(client);
-      if (!closed)
-        fail(name, describeConnectError(error, stdio));
-      await client.close().catch(() => {});
-    }
+      channel.close();
+    } catch {}
   };
-  const status = {
-    get value() {
-      return { configPath: options.configPath, errors, servers: [...servers.values()] };
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
+  const pump = () => {
+    if (closed || pumping)
+      return;
+    pumping = true;
+    try {
+      while (queue.length > 0 && !closed) {
+        if (!channel.isOpen())
+          break;
+        if (channel.bufferedAmount() >= BUFFER_HIGH_WATER)
+          break;
+        const item = queue[0];
+        const max = channel.maxMessageSize();
+        if (max !== 0 && item.bytes.length > max) {
+          log("rtc-datachannel-record-too-large", { bytes: item.bytes.length, maxMessageSize: max });
+          finish();
+          try {
+            channel.close();
+          } catch {}
+          return;
+        }
+        if (channel.sendMessageBinary(item.bytes) === false)
+          falseSends += 1;
+        queue.shift();
+        item.resolve();
+        lastProgress = timers.now();
+      }
+    } finally {
+      pumping = false;
     }
-  };
-  loadConfig(options.configPath).then((loaded) => {
     if (closed)
       return;
-    errors = loaded.errors;
-    for (const entry of loaded.entries) {
-      if (entry.disabled === true)
-        servers.set(entry.name, { name: entry.name, state: "disabled", tools: 0 });
-      else
-        servers.set(entry.name, { name: entry.name, state: "connecting", tools: 0 });
+    if (queue.length === 0) {
+      clearTimers();
+      return;
     }
-    publish();
-    install();
-    for (const entry of loaded.entries) {
-      if (entry.disabled === true)
-        continue;
-      exposures.set(entry.name, entry.exposure);
-      connect(entry.name, entry.spec, entry.timeoutMs, entry.description);
+    if (pollTimer === undefined) {
+      pollTimer = timers.setTimeout(() => {
+        pollTimer = undefined;
+        pump();
+      }, FALLBACK_POLL_MS);
     }
+    if (stallTimer === undefined)
+      stallTimer = timers.setTimeout(stall, 1000);
+  };
+  channel.onBufferedAmountLow(() => pump());
+  channel.onMessage((message) => {
+    if (typeof message === "string")
+      handlers?.text();
+    else if (message instanceof ArrayBuffer)
+      handlers?.binary(new Uint8Array(message));
+    else
+      handlers?.binary(message);
+  });
+  channel.onClosed(finish);
+  channel.onError((message) => {
+    log("rtc-datachannel-error", { message });
+    finish();
   });
   return {
-    status,
-    async close() {
-      closed = true;
-      await Promise.all([...live].map((client) => client.close().catch(() => {})));
+    get open() {
+      return !closed && channel.isOpen();
+    },
+    send(bytes) {
+      if (closed || !channel.isOpen())
+        return Promise.resolve();
+      return new Promise((resolve4) => {
+        queue.push({ bytes, resolve: resolve4 });
+        pump();
+      });
+    },
+    close(_code, _reason) {
+      if (closed)
+        return;
+      finish();
+      try {
+        channel.close();
+      } catch {}
+    },
+    handle(next) {
+      handlers = next;
     }
   };
 }
 
-// apps/host/src/agent-roles.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { existsSync as existsSync2, watch } from "node:fs";
-import { mkdir as mkdir2, readdir, readFile as readFile2, rename, rm as rm2, writeFile } from "node:fs/promises";
-import { join as join6 } 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(", ")}`;
+// apps/host/src/folders.ts
+import { readdir, realpath as realpath5, stat as stat5 } from "node:fs/promises";
+import { isAbsolute, join as join6 } from "node:path";
+var denied = (error) => {
+  const code = error?.code;
+  return code === "EACCES" || code === "EPERM";
+};
+async function listFolders(path, home) {
+  if (path !== undefined && !isAbsolute(path))
+    throw new Error(`Not an absolute path: ${path}`);
+  const given = path ?? home;
+  const dir = await realpath5(given).catch((error) => {
+    if (denied(error))
+      throw new Error(`Permission denied: ${given}`);
+    throw new Error(`No such directory: ${given}`);
+  });
+  if (!(await stat5(dir)).isDirectory())
+    throw new Error(`Not a directory: ${given}`);
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch (error) {
+    if (denied(error))
+      throw new Error(`Permission denied: ${given}`);
+    throw error;
   }
-  return;
-}
-
-// 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(() => []);
+  const folders = [];
   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(join6(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);
+    if (entry.name.startsWith("."))
       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 rescanMs = options.rescanMs ?? 1000;
-  const published = new Published({ roles: [], problems: [] }, (a, b) => sameList(a.roles, b.roles, sameRole) && sameList(a.problems, b.problems, sameProblem));
-  let closed = false;
-  let reported = false;
-  let timer;
-  let queued = false;
-  let chain = Promise.resolve();
-  const loadOnce = 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;
-    }
-  };
-  const reload = () => {
-    if (closed)
-      return Promise.resolve();
-    queued = true;
-    chain = chain.then(async () => {
-      if (!queued || closed)
-        return;
-      queued = false;
-      await loadOnce();
-    });
-    return chain;
-  };
-  const watcher = watch(dir, () => {
-    if (closed)
-      return;
-    clearTimeout(timer);
-    timer = setTimeout(() => void reload(), debounceMs);
-  });
-  watcher.on("error", (error) => {
-    if (!reported)
-      console.error(`agent-roles watch failed: ${error.message}`);
-    reported = true;
-    reload();
-  });
-  await reload();
-  const rescan = setInterval(() => void reload(), rescanMs);
-  let pending = Promise.resolve();
-  const enqueue = (operation) => {
-    const run2 = pending.then(operation, operation);
-    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 = join6(dir, `${role.name}.md`);
-      const exists = existsSync2(target);
-      if (mustExist && !exists)
-        throw new Error(`No such agent: "${role.name}"`);
-      if (!mustExist && exists)
-        throw new Error(`Agent "${role.name}" already exists`);
-      const temp = join6(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 = join6(dir, `${name}.md`);
-        if (!existsSync2(target))
-          throw new Error(`No such agent: "${name}"`);
-        await rm2(target);
-        await reload();
-      });
-    },
-    close() {
-      closed = true;
-      clearTimeout(timer);
-      clearInterval(rescan);
-      watcher.close();
-    }
-  };
-}
-
-// apps/host/src/host.ts
-import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
-import lockfile from "proper-lockfile";
-
-// apps/host/src/gateway.ts
-import { createServer } from "node:http";
-import { homedir as homedir2, networkInterfaces } from "node:os";
-import { join as join8, sep as sep5 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
-import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
-import {
-  AgentDoc as AgentDoc5,
-  configure as configure3,
-  InboxDoc,
-  LiveDoc
-} from "@earendil-works/pi-durable";
-import { WebSocket, WebSocketServer } from "ws";
-import { Value as Value2 } from "typebox/value";
-
-// apps/host/src/folders.ts
-import { readdir as readdir2, realpath as realpath5, stat as stat5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join7 } from "node:path";
-var denied = (error) => {
-  const code = error?.code;
-  return code === "EACCES" || code === "EPERM";
-};
-async function listFolders(path, home) {
-  if (path !== undefined && !isAbsolute2(path))
-    throw new Error(`Not an absolute path: ${path}`);
-  const given = path ?? home;
-  const dir = await realpath5(given).catch((error) => {
-    if (denied(error))
-      throw new Error(`Permission denied: ${given}`);
-    throw new Error(`No such directory: ${given}`);
-  });
-  if (!(await stat5(dir)).isDirectory())
-    throw new Error(`Not a directory: ${given}`);
-  let entries;
-  try {
-    entries = await readdir2(dir, { withFileTypes: true });
-  } catch (error) {
-    if (denied(error))
-      throw new Error(`Permission denied: ${given}`);
-    throw error;
-  }
-  const folders = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith("."))
-      continue;
-    let isDirectory = entry.isDirectory();
-    if (!isDirectory && entry.isSymbolicLink()) {
-      isDirectory = await stat5(join7(dir, entry.name)).then((target) => target.isDirectory(), () => false);
+    let isDirectory = entry.isDirectory();
+    if (!isDirectory && entry.isSymbolicLink()) {
+      isDirectory = await stat5(join6(dir, entry.name)).then((target) => target.isDirectory(), () => false);
     }
     if (isDirectory)
-      folders.push({ name: entry.name, path: join7(dir, entry.name) });
+      folders.push({ name: entry.name, path: join6(dir, entry.name) });
   }
   folders.sort((a, b) => a.name.localeCompare(b.name, "en", { numeric: true, sensitivity: "base" }));
   return { path: dir, home: await realpath5(home).catch(() => home), folders };
 }
 
 // apps/host/src/skill-expansion.ts
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { stripFrontmatter } from "@earendil-works/pi-coding-agent";
 
 // packages/client/src/skill-blocks.ts
@@ -2104,7 +2215,7 @@ async function expandSkills(text, names, skills) {
       continue;
     }
     try {
-      const body = stripFrontmatter(await readFile3(skill.filePath, "utf8")).trim();
+      const body = stripFrontmatter(await readFile(skill.filePath, "utf8")).trim();
       blocks.push({ name, location: skill.filePath, baseDir: skill.baseDir, body });
     } catch (error) {
       failures.push({ name, filePath: skill.filePath, message: error instanceof Error ? error.message : String(error) });
@@ -2164,7 +2275,7 @@ function imageProblem(images) {
 // apps/host/src/image-refs.ts
 import { createHash } from "node:crypto";
 import { applyImmutable } from "@earendil-works/chord/delta";
-var isObject2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var isImageBlock = (value) => value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string";
 var hashed = new WeakMap;
 function refOf(block) {
@@ -2230,7 +2341,7 @@ function withRef(block) {
   return { ...rest, ref };
 }
 var HASH_YIELD_BYTES = 8 * 1024 * 1024;
-var yieldToEventLoop = () => new Promise((resolve5) => setImmediate(resolve5));
+var yieldToEventLoop = () => new Promise((resolve4) => setImmediate(resolve4));
 async function hashBlocks(blocks) {
   let bytes = 0;
   for (const block of blocks) {
@@ -2256,7 +2367,7 @@ function rewriteEntries(value) {
   return out ?? value;
 }
 function rewriteEntry(value) {
-  if (!isObject2(value) || value.model === undefined)
+  if (!isObject(value) || value.model === undefined)
     return value;
   const model = rewriteMessages(value.model);
   return model === value.model ? value : { ...value, model };
@@ -2273,7 +2384,7 @@ function rewriteMessages(value) {
   return out ?? value;
 }
 function rewriteMessage(value) {
-  if (!isObject2(value) || value.content === undefined)
+  if (!isObject(value) || value.content === undefined)
     return value;
   const content = rewriteContent(value.content);
   return content === value.content ? value : { ...value, content };
@@ -2284,7 +2395,7 @@ function rewriteContent(value) {
   let out;
   for (let i = 0;i < value.length; i++) {
     const block = value[i];
-    const next = isObject2(block) && isImageBlock(block) ? withRef(block) : block;
+    const next = isObject(block) && isImageBlock(block) ? withRef(block) : block;
     if (next !== block)
       (out ??= value.slice())[i] = next;
   }
@@ -2302,31 +2413,31 @@ function rewriteItems(value) {
   return out ?? value;
 }
 function rewriteItem(value) {
-  if (!isObject2(value) || value.content === undefined)
+  if (!isObject(value) || value.content === undefined)
     return value;
   const content = rewriteContent(value.content);
   return content === value.content ? value : { ...value, content };
 }
 function rewriteInbox(value) {
-  if (!isObject2(value) || value.items === undefined)
+  if (!isObject(value) || value.items === undefined)
     return value;
   const items = rewriteItems(value.items);
   return items === value.items ? value : { ...value, items };
 }
 function rewriteGeneration(value) {
-  if (!isObject2(value) || value.message === undefined)
+  if (!isObject(value) || value.message === undefined)
     return value;
   const message = rewriteMessage(value.message);
   return message === value.message ? value : { ...value, message };
 }
 function rewriteLive(value) {
-  if (!isObject2(value) || value.generation === undefined)
+  if (!isObject(value) || value.generation === undefined)
     return value;
   const generation = rewriteGeneration(value.generation);
   return generation === value.generation ? value : { ...value, generation };
 }
 function rewriteDocs(value) {
-  if (!isObject2(value))
+  if (!isObject(value))
     return value;
   let out;
   for (const key of ["pi.inbox", "pi.live"]) {
@@ -2340,7 +2451,7 @@ function rewriteDocs(value) {
   return out ?? value;
 }
 function rewriteView(value) {
-  if (!isObject2(value))
+  if (!isObject(value))
     return value;
   let out;
   if (value.entries !== undefined) {
@@ -2368,7 +2479,7 @@ function rewriteSlot(slot, value) {
     case "content":
       return rewriteContent(value);
     case "block":
-      return isObject2(value) && isImageBlock(value) ? withRef(value) : value;
+      return isObject(value) && isImageBlock(value) ? withRef(value) : value;
     case "docs":
       return rewriteDocs(value);
     case "inbox":
@@ -2415,7 +2526,7 @@ function rewriteOp(op) {
       return op;
   }
 }
-function resolve5(root, path, length) {
+function resolve4(root, path, length) {
   let node = root;
   for (let i = 0;i < length; i++) {
     if (node === null || typeof node !== "object")
@@ -2432,36 +2543,36 @@ function reachesIntoImage(op, root) {
   for (let length = 1;length <= depth; length++) {
     if (slotAt(path.slice(0, length)) !== "block")
       continue;
-    const node = resolve5(root, path, length);
-    if (isObject2(node) && isImageBlock(node))
+    const node = resolve4(root, path, length);
+    if (isObject(node) && isImageBlock(node))
       return true;
   }
   return false;
 }
 function* contentArrays(view) {
-  if (!isObject2(view))
+  if (!isObject(view))
     return;
   if (Array.isArray(view.entries)) {
     for (const entry of view.entries) {
-      if (!isObject2(entry) || !Array.isArray(entry.model))
+      if (!isObject(entry) || !Array.isArray(entry.model))
         continue;
       for (const message of entry.model) {
-        if (isObject2(message) && Array.isArray(message.content))
+        if (isObject(message) && Array.isArray(message.content))
           yield message.content;
       }
     }
   }
-  if (!isObject2(view.docs))
+  if (!isObject(view.docs))
     return;
   const inbox = view.docs["pi.inbox"];
-  if (isObject2(inbox) && Array.isArray(inbox.items)) {
+  if (isObject(inbox) && Array.isArray(inbox.items)) {
     for (const item of inbox.items) {
-      if (isObject2(item) && Array.isArray(item.content))
+      if (isObject(item) && Array.isArray(item.content))
         yield item.content;
     }
   }
   const live = view.docs["pi.live"];
-  if (isObject2(live) && isObject2(live.generation) && isObject2(live.generation.message) && Array.isArray(live.generation.message.content)) {
+  if (isObject(live) && isObject(live.generation) && isObject(live.generation.message) && Array.isArray(live.generation.message.content)) {
     yield live.generation.message.content;
   }
 }
@@ -2469,7 +2580,7 @@ function imageBlocks(view) {
   const blocks = [];
   for (const content of contentArrays(view)) {
     for (const block of content) {
-      if (isObject2(block) && isImageBlock(block))
+      if (isObject(block) && isImageBlock(block))
         blocks.push(block);
     }
   }
@@ -2512,6 +2623,109 @@ class ImageRefs {
   }
 }
 
+// apps/host/src/image-variants.ts
+var PROFILES = {
+  thumbnail: { maxWidth: 768, maxHeight: 768, maxBytes: 128 * 1024 },
+  preview: { maxWidth: 1536, maxHeight: 1536, maxBytes: 384 * 1024 }
+};
+var MAX_IN_FLIGHT = 2;
+
+class ImageVariants {
+  #processor;
+  #maxCacheBytes;
+  #cache = new Map;
+  #pending = new Map;
+  #queue = [];
+  #cacheBytes = 0;
+  #active = 0;
+  constructor(processor, options = {}) {
+    this.#processor = processor;
+    this.#maxCacheBytes = options.maxCacheBytes ?? 32 * 1024 * 1024;
+  }
+  async get(ref, variant, original) {
+    const key = `${variant}:${ref}`;
+    const cached = this.#read(key);
+    if (cached !== undefined)
+      return cached;
+    let pending = this.#pending.get(key);
+    if (pending === undefined) {
+      pending = new Promise((resolve5, reject) => {
+        this.#queue.push({ key, variant, original, resolve: resolve5, reject });
+      });
+      this.#pending.set(key, pending);
+      this.#pump();
+    }
+    try {
+      return await pending;
+    } finally {
+      if (this.#pending.get(key) === pending)
+        this.#pending.delete(key);
+    }
+  }
+  #pump() {
+    while (this.#active < MAX_IN_FLIGHT) {
+      const job = this.#queue.shift();
+      if (job === undefined)
+        return;
+      this.#active += 1;
+      this.#derive(job.key, job.variant, job.original).then((result2) => {
+        job.resolve(result2);
+        this.#finish();
+      }, (error) => {
+        job.reject(error instanceof Error ? error : new Error(String(error)));
+        this.#finish();
+      });
+    }
+  }
+  #finish() {
+    this.#active -= 1;
+    this.#pump();
+  }
+  async#derive(key, variant, original) {
+    if (this.#processor === undefined)
+      return { ...original, variant: "original" };
+    try {
+      const bytes = new Uint8Array(Buffer.from(original.data, "base64"));
+      const prepared = await this.#processor.prepare(bytes, original.mimeType, PROFILES[variant]);
+      if (prepared === undefined || prepared.data === original.data && prepared.mimeType === original.mimeType) {
+        return { ...original, variant: "original" };
+      }
+      const result2 = {
+        data: prepared.data,
+        mimeType: prepared.mimeType,
+        variant
+      };
+      this.#write(key, result2);
+      return result2;
+    } catch {
+      return { ...original, variant: "original" };
+    }
+  }
+  #read(key) {
+    const cached = this.#cache.get(key);
+    if (cached === undefined)
+      return;
+    this.#cache.delete(key);
+    this.#cache.set(key, cached);
+    return cached;
+  }
+  #write(key, result2) {
+    const bytes = result2.data.length;
+    if (bytes > this.#maxCacheBytes)
+      return;
+    while (this.#cacheBytes + bytes > this.#maxCacheBytes) {
+      const oldest = this.#cache.keys().next().value;
+      if (oldest === undefined)
+        break;
+      const previous = this.#cache.get(oldest);
+      this.#cache.delete(oldest);
+      this.#cacheBytes -= previous.data.length;
+    }
+    this.#cache.set(key, result2);
+    this.#cacheBytes += bytes;
+  }
+}
+
 // apps/host/src/auto-title.ts
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 
@@ -2523,7 +2737,8 @@ var TitleDoc = defineDoc6({
   scope: "conversation",
   history: "latest",
   fork: "initial",
-  initial: () => ({})
+  initial: () => ({}),
+  checkpointWhen: () => false
 });
 
 // apps/host/src/auto-title.ts
@@ -2699,7 +2914,8 @@ var PushDoc = defineDoc7({
   version: 2,
   scope: "session",
   initial: () => ({ registrations: [] }),
-  migrate: () => ({ registrations: [] })
+  migrate: () => ({ registrations: [] }),
+  checkpointWhen: () => false
 });
 var APNS_TOKEN_PATTERN = /^(?:[0-9a-f]{2})+$/;
 var APNS_TOKEN_MAX_CHARS = 256;
@@ -2827,7 +3043,7 @@ async function attachPushSender(options) {
       return named;
     if (notice.body !== "Finished" || disposed)
       return FALLBACK_TITLE;
-    return await new Promise((resolve6) => {
+    return await new Promise((resolve5) => {
       const waiters = titleWaiters.get(notice.id) ?? new Set;
       titleWaiters.set(notice.id, waiters);
       const settle = (title) => {
@@ -2835,7 +3051,7 @@ async function attachPushSender(options) {
         if (waiters.size === 0)
           titleWaiters.delete(notice.id);
         timers.clearTimeout(timer);
-        resolve6(title);
+        resolve5(title);
       };
       const timer = timers.setTimeout(() => settle(FALLBACK_TITLE), TITLE_WAIT_MS);
       waiters.add(settle);
@@ -3067,11 +3283,48 @@ function serializedFork(harness, work) {
   });
   return next;
 }
+var submissionTails = new WeakMap;
+function serializedSubmission(harness, conversationId, requestId, work) {
+  let tails = submissionTails.get(harness);
+  if (tails === undefined) {
+    tails = new Map;
+    submissionTails.set(harness, tails);
+  }
+  const lanes = tails;
+  const key = `${conversationId}\x00${requestId}`;
+  const next = (lanes.get(key) ?? Promise.resolve()).then(work, work);
+  const settled = next.then(() => {}, () => {});
+  lanes.set(key, settled);
+  settled.then(() => {
+    if (lanes.get(key) === settled)
+      lanes.delete(key);
+  });
+  return next;
+}
+function submissionResult(record) {
+  return {
+    submissionId: record.id,
+    status: record.status,
+    ...record.entry === undefined ? {} : { entry: record.entry }
+  };
+}
+function submitResult(record) {
+  return {
+    submissionId: record.id,
+    ...record.entry === undefined ? {} : { entry: record.entry }
+  };
+}
 var LOOPBACK_SECURE_PATH = "/secure";
 async function startGateway(options) {
+  if (options.secure?.lan?.publicUrl !== undefined)
+    validatePublicUrl(options.secure.lan.publicUrl);
+  if (options.secure?.relay !== undefined) {
+    validateRelayTarget(options.secure.relay.origin, options.secure.relay.signingKey.publicKey);
+  }
   const conversations = await ConversationList.open(options.harness, options.docs);
   const fileLister = createCandidateLister(enumerateRoot);
   const skillLister = createSkillLister((root, mode) => enumerateSkills(root, mode, options.agentsHome));
+  const imageVariants = new ImageVariants(options.images);
   const detachAutoTitle = options.autoTitle === false ? undefined : attachAutoTitle(conversations, {
     harness: options.harness,
     models: options.models,
@@ -3084,57 +3337,125 @@ async function startGateway(options) {
       response.end();
     });
   });
-  await new Promise((resolve6, reject) => {
-    http.once("listening", resolve6);
+  await new Promise((resolve5, reject) => {
+    http.once("listening", resolve5);
     http.once("error", reject);
     http.listen(options.port, "127.0.0.1");
   });
   const server = new WebSocketServer({ server: http });
   const { port } = http.address();
   const browserOrigins = [...options.browserOrigins ?? [], `http://127.0.0.1:${port}`];
+  const connections = new Set;
   const clients = new Set;
+  let rtc;
+  const rtcHello = () => rtc?.hello();
   const broadcast = (level, message) => {
     for (const client of clients)
       client.send({ type: "notice", level, message });
   };
   let remote;
   let relay;
-  const register = (connection, devicePublicKey, joined) => {
-    if (joined?.source === "account") {
-      broadcast("info", `New device "${joined.name}" joined through your account`);
+  const currentAdvertisement = () => {
+    const advertiseUrl = remote?.advertiseUrl;
+    const endpoints = remoteEndpointCandidates({
+      ...relay === undefined ? {} : { relay: { origin: relay.origin, hostId: relay.hostId } },
+      ...advertiseUrl === undefined ? {} : { direct: { advertiseUrl } }
+    });
+    return { endpoints, ...advertiseUrl === undefined ? {} : { advertiseUrl } };
+  };
+  const checkedEndpointSet = (endpoints) => {
+    const parsed = parseEndpointSet({ schemaVersion: ENDPOINT_SET_SCHEMA_VERSION, endpoints });
+    if (parsed.kind !== "valid" || parsed.endpointSet.endpoints.length !== endpoints.length) {
+      throw new Error("The host generated an invalid remote endpoint set");
     }
-    const client = new GatewayClient(connection, options, conversations, fileLister, skillLister, {
+    return parsed.endpointSet;
+  };
+  const currentEndpointSet = () => checkedEndpointSet(currentAdvertisement().endpoints);
+  const register = (connection, devicePublicKey) => {
+    const client = new GatewayClient(connection, options, conversations, fileLister, skillLister, imageVariants, {
       devicePublicKey,
+      rtcHello,
       closed: (self) => {
         clients.delete(self);
+        connections.delete(self);
+        rtc?.closeOwner(self);
         self.dispose();
       },
       closeDevice: (publicKey) => {
-        for (const client2 of clients) {
-          if (client2.devicePublicKey === publicKey)
-            client2.closeConnection(UNAUTHORIZED_CLOSE_CODE, "device revoked");
+        for (const connection2 of [...connections]) {
+          if (connection2.devicePublicKey === publicKey) {
+            connection2.closeConnection(UNAUTHORIZED_CLOSE_CODE, "device revoked");
+          }
         }
+        rtc?.closeDevice(publicKey);
+      },
+      rtcOffer: (owner, key, attempt, sdp) => {
+        if (rtc === undefined)
+          throw new Error("WebRTC is not available on this host");
+        return rtc.offer({ owner, ...key === undefined ? {} : { deviceKey: key }, attempt, sdp });
       },
       createPairing: () => {
         const spec = options.secure;
         if (spec === undefined)
           return;
         const pair = (secret2) => `pair=${toBase64Url(spec.hostKey.publicKey)}.${secret2}`;
+        const fragment = (secret2, target2, endpointSet2) => `${pair(secret2)}&url=${encodeURIComponent(target2)}${endpointSet2 === undefined ? "" : `&endpointSet=${encodeEndpointSetParam(endpointSet2)}`}`;
+        const advertisement = currentAdvertisement();
+        const endpointSet = checkedEndpointSet(advertisement.endpoints);
+        const relayReachable = endpointSet.endpoints.some((endpoint) => endpoint.role === "relay");
+        if (relayReachable && relay !== undefined) {
+          const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
+          return {
+            url: `${relay.origin}/#${fragment(secret2, relaySocketTarget(relay.origin, relay.hostId), endpointSet)}`,
+            expiresAt: expiresAt2
+          };
+        }
+        if (endpointSet.endpoints.length > 0) {
+          const direct = endpointSet.endpoints.find((endpoint) => endpoint.role === "direct");
+          const advertise = advertisement.advertiseUrl;
+          if (direct === undefined || advertise === undefined) {
+            throw new Error("The host generated an invalid remote endpoint set");
+          }
+          const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
+          return { url: `${advertise}/#${fragment(secret2, direct.url, endpointSet)}`, expiresAt: expiresAt2 };
+        }
         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(secret2)}&url=${encodeURIComponent(target2)}`, expiresAt: expiresAt2 };
+          return {
+            url: `${relay.origin}/#${fragment(secret2, relaySocketTarget(relay.origin, relay.hostId))}`,
+            expiresAt: expiresAt2
+          };
         }
         if (remote !== undefined) {
+          const advertise = advertisement.advertiseUrl;
+          if (advertise === undefined)
+            throw new Error("The host generated an invalid remote endpoint set");
           const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
-          return { url: `${remote.advertiseUrl}/#${pair(secret2)}`, expiresAt: expiresAt2 };
+          return { url: `${advertise}/#${fragment(secret2, advertiseEndpointUrl(advertise))}`, 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(secret)}&url=${encodeURIComponent(target)}`, expiresAt };
-      }
+        return { url: `http://127.0.0.1:${port}/#${fragment(secret, target)}`, expiresAt };
+      },
+      endpointSet: currentEndpointSet
     });
     clients.add(client);
+    connections.add(client);
+  };
+  const registerSignal = (connection, devicePublicKey) => {
+    const client = new SignalClient(connection, devicePublicKey, {
+      rtcHello,
+      rtcOffer: (owner, key, attempt, sdp) => {
+        if (rtc === undefined)
+          throw new Error("WebRTC is not available on this host");
+        return rtc.offer({ owner, ...key === undefined ? {} : { deviceKey: key }, attempt, sdp });
+      },
+      closed: (self) => {
+        connections.delete(self);
+        rtc?.closeOwner(self);
+      }
+    });
+    connections.add(client);
   };
   const admission = {
     harness: options.harness,
@@ -3143,6 +3464,26 @@ async function startGateway(options) {
       return;
     })
   };
+  const secure = options.secure;
+  const handshakeHandlers = {
+    client: register,
+    signal: registerSignal,
+    prologues: "both"
+  };
+  if (secure !== undefined) {
+    rtc = await startRtcHost({
+      ...options.rtc,
+      stun: () => options.settings.value.rtcStun ?? RTC_DEFAULT_STUN,
+      onChannel: (peer, channel) => {
+        secureHandshake(channel.carrier, secure, admission, {
+          client: register,
+          prologues: "business",
+          ...peer.deviceKey === undefined ? {} : { expectedDeviceKey: peer.deviceKey },
+          onRegistered: () => peer.handOff()
+        });
+      }
+    });
+  }
   server.on("connection", (socket, request) => {
     socket.on("error", () => socket.terminate());
     const url = new URL(request.url ?? "/", "ws://127.0.0.1");
@@ -3152,7 +3493,7 @@ async function startGateway(options) {
         socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
         return;
       }
-      secureHandshake(socket, secure2, admission, register);
+      secureHandshake(webSocketCarrier(socket), secure2, admission, handshakeHandlers);
       return;
     }
     const token = url.searchParams.get("token");
@@ -3163,12 +3504,11 @@ async function startGateway(options) {
     }
     register(tokenConnection(socket));
   });
-  remote = await startRemote(options, admission, register).catch(async (error) => {
-    await new Promise((resolve6) => server.close(() => resolve6()));
-    await new Promise((resolve6) => http.close(() => resolve6()));
+  remote = await startRemote(options, admission, handshakeHandlers).catch(async (error) => {
+    await new Promise((resolve5) => server.close(() => resolve5()));
+    await new Promise((resolve5) => http.close(() => resolve5()));
     throw error;
   });
-  const secure = options.secure;
   const detachSettingsWatch = options.settings.subscribe((settings) => {
     if (!settings.acceptAccountDevices)
       secure?.offers.revokeAccount();
@@ -3180,7 +3520,7 @@ async function startGateway(options) {
       origin: relayOrigin,
       signingKey: secure.relay.signingKey,
       noisePublicKey: secure.hostKey.publicKey,
-      accept: (socket) => secureHandshake(socket, secure, admission, register),
+      accept: (socket) => secureHandshake(webSocketCarrier(socket), secure, admission, handshakeHandlers),
       hostName: {
         get value() {
           return options.settings.value.hostName;
@@ -3198,8 +3538,15 @@ async function startGateway(options) {
         if (normalizeOrigin(config.origin) !== normalizeOrigin(relayOrigin)) {
           return { ok: false, reason: "rebinding" };
         }
+        let endpointSet;
+        try {
+          const current = checkedEndpointSet(currentAdvertisement().endpoints);
+          endpointSet = current.endpoints.length === 0 ? undefined : current;
+        } catch {
+          return { ok: false, reason: "invalid_endpoint" };
+        }
         const { secret, expiresAt } = secure.offers.createAccount(config.binding);
-        return { ok: true, secret, expiresAt };
+        return { ok: true, secret, expiresAt, ...endpointSet === undefined ? {} : { endpointSet } };
       },
       onStateChange: (state) => {
         if (state.status === "registered") {
@@ -3224,9 +3571,15 @@ async function startGateway(options) {
     ...options.push.transport === undefined ? relay === undefined ? {} : { transport: { send: (request) => relay.sendPush(request) } } : { transport: options.push.transport },
     ...options.push.timers === undefined ? {} : { timers: options.push.timers }
   });
+  const remoteInfo = remote === undefined ? undefined : {
+    url: remote.url,
+    get advertiseUrl() {
+      return remote.advertiseUrl;
+    }
+  };
   return {
     url: `ws://127.0.0.1:${port}`,
-    ...remote === undefined ? {} : { remote: { url: remote.url, advertiseUrl: remote.advertiseUrl } },
+    ...remoteInfo === undefined ? {} : { remote: remoteInfo },
     ...relay === undefined ? {} : { relay },
     broadcast,
     async close() {
@@ -3235,21 +3588,22 @@ async function startGateway(options) {
       detachSettingsWatch();
       await detachPush?.close();
       conversations.dispose();
-      await Promise.all([...clients].map((client) => client.dispose()));
+      await rtc?.close();
+      await Promise.all([...connections].map((connection) => connection.dispose()));
       for (const socket of server.clients)
         socket.terminate();
       await remote?.close();
-      await new Promise((resolve6) => server.close(() => resolve6()));
-      await new Promise((resolve6) => http.close(() => resolve6()));
+      await new Promise((resolve5) => server.close(() => resolve5()));
+      await new Promise((resolve5) => http.close(() => resolve5()));
     }
   };
 }
 function tokenConnection(socket) {
   return {
     get open() {
-      return socket.readyState === WebSocket.OPEN;
+      return socket.readyState === WebSocket2.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve6) => socket.send(text, () => resolve6())) : Promise.resolve(),
+    send: (text) => socket.readyState === WebSocket2.OPEN ? new Promise((resolve5) => socket.send(text, () => resolve5())) : Promise.resolve(),
     close: (code, reason) => socket.close(code, reason),
     handle(handlers) {
       socket.on("message", (data) => handlers.message(String(data)));
@@ -3257,30 +3611,6 @@ function tokenConnection(socket) {
     }
   };
 }
-function secureConnection(socket, session) {
-  return {
-    get open() {
-      return socket.readyState === WebSocket.OPEN;
-    },
-    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve6) => {
-      const chunks = session.seal(text);
-      chunks.forEach((chunk, index) => socket.send(chunk, index === chunks.length - 1 ? () => resolve6() : undefined));
-    }) : Promise.resolve(),
-    close: (code, reason) => socket.close(code, reason),
-    handle(handlers) {
-      socket.on("message", (data) => {
-        try {
-          const text = session.open(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
-          if (text !== undefined)
-            handlers.message(text);
-        } catch {
-          socket.close(1008, "corrupt secure record");
-        }
-      });
-      socket.once("close", () => handlers.closed());
-    }
-  };
-}
 var RFC1918 = /^(?:10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.)/;
 var PREFERRED_NAME = /^(?:en|eth|wlan|wl)/;
 var VIRTUAL_NAME = /^(?:utun|tun|tap|wg|ppp|ipsec|bridge|docker|veth|vmnet|llw|awdl)/;
@@ -3297,65 +3627,219 @@ function pickLanAddress(interfaces) {
   }
   return fallback;
 }
-function secureHandshake(socket, secure, policy, register) {
-  socket.on("error", () => socket.terminate());
-  const responder = respondIK({ prologue: SECURE_PROLOGUE, static: secure.hostKey });
-  let settled = false;
-  let deciding = false;
-  const timeout = setTimeout(() => socket.close(1008, "handshake timeout"), secure.handshakeTimeoutMs ?? 1e4);
-  socket.once("close", () => clearTimeout(timeout));
-  socket.on("message", (data, isBinary) => {
-    if (settled)
-      return;
-    if (deciding || !isBinary) {
-      socket.close(1008, "expected handshake");
-      return;
+function advertiseEndpointUrl(advertiseUrl) {
+  const url = new URL(advertiseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (!url.pathname.endsWith("/"))
+    url.pathname = `${url.pathname}/`;
+  return url.href;
+}
+var normalizeAdvertiseUrl = (url) => url.replace(/\/+$/, "");
+function relaySocketTarget(origin, hostId) {
+  return `${relayWsBase(origin)}/c/${hostId}`;
+}
+function remoteEndpointCandidates(input) {
+  const endpoints = [];
+  if (input.relay !== undefined) {
+    const endpoint = {
+      transport: "webSocket",
+      role: "relay",
+      url: relaySocketTarget(input.relay.origin, input.relay.hostId)
+    };
+    if (!isLoopbackUrl(endpoint.url))
+      endpoints.push(endpoint);
+  }
+  if (input.direct !== undefined) {
+    const endpoint = {
+      transport: "webSocket",
+      role: "direct",
+      url: advertiseEndpointUrl(input.direct.advertiseUrl)
+    };
+    if (!isLoopbackUrl(endpoint.url))
+      endpoints.push(endpoint);
+  }
+  return endpoints;
+}
+function endpointProblem(endpoint) {
+  if (endpoint.url.length > MAX_HOST_ENDPOINT_URL_LENGTH) {
+    return `is longer than ${MAX_HOST_ENDPOINT_URL_LENGTH} UTF-16 units`;
+  }
+  const parsed = parseEndpointSet({ schemaVersion: ENDPOINT_SET_SCHEMA_VERSION, endpoints: [endpoint] });
+  return parsed.kind === "valid" && parsed.endpointSet.endpoints.length === 1 ? undefined : "is not a ws:// or wss:// URL";
+}
+function validatePublicUrl(publicUrl) {
+  if (publicUrl.includes("#")) {
+    throw new Error(`--public-url must not include a fragment: ${publicUrl}`);
+  }
+  let url;
+  try {
+    url = new URL(publicUrl);
+  } catch {
+    throw new Error(`--public-url must be an absolute http(s) URL: ${publicUrl}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`--public-url must be an absolute http(s) URL: ${publicUrl}`);
+  }
+  const problem = endpointProblem({
+    transport: "webSocket",
+    role: "direct",
+    url: advertiseEndpointUrl(normalizeAdvertiseUrl(publicUrl))
+  });
+  if (problem !== undefined)
+    throw new Error(`--public-url ${problem}: ${publicUrl}`);
+}
+function validateRelayOrigin(origin) {
+  if (origin.includes("#")) {
+    throw new Error(`--relay must not include a fragment: ${origin}`);
+  }
+  try {
+    relayWsBase(origin);
+  } catch {
+    throw new Error(`--relay must be an absolute http(s) URL: ${origin}`);
+  }
+}
+function validateRelayTarget(origin, signingKey) {
+  validateRelayOrigin(origin);
+  const hostId = relayHostId(signingKey);
+  const target = relaySocketTarget(origin, hostId);
+  const problem = endpointProblem({ transport: "webSocket", role: "relay", url: target });
+  if (problem !== undefined)
+    throw new Error(`--relay ${problem}: ${origin}`);
+}
+function secureHandshake(carrier, secure, policy, handlers) {
+  let stage = "new";
+  let session;
+  let pending;
+  let closed = false;
+  let sendTail = Promise.resolve();
+  const timeout = setTimeout(() => carrier.close(1008, "handshake timeout"), secure.handshakeTimeoutMs ?? 1e4);
+  const connection = {
+    get open() {
+      return !closed && carrier.open;
+    },
+    send(text) {
+      if (closed || session === undefined)
+        return Promise.resolve();
+      const next = sendTail.then(async () => {
+        if (closed || session === undefined)
+          return;
+        for (const chunk of session.seal(text))
+          await carrier.send(chunk);
+      }).catch(() => carrier.close(1011, "send failed"));
+      sendTail = next;
+      return next;
+    },
+    close: (code, reason) => carrier.close(code, reason ?? ""),
+    handle: (next) => {
+      pending = next;
     }
-    deciding = true;
-    admit().then((admitted) => {
-      if (admitted === undefined)
-        return;
-      settled = true;
-      clearTimeout(timeout);
-      const session = new SecureSession(admitted.result);
-      socket.send(admitted.message);
-      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);
-      let hello;
-      let remoteStatic;
-      try {
-        const opened = responder.readMessage1(bytes);
-        remoteStatic = opened.remoteStatic;
-        hello = decodeClientHello(opened.payload);
-      } catch {
-        socket.close(1008, "bad handshake");
+  };
+  carrier.handle({
+    binary(bytes) {
+      if (stage === "settled") {
+        try {
+          const text = session.open(bytes);
+          if (text !== undefined)
+            pending?.message(text);
+        } catch {
+          carrier.close(1008, "corrupt secure record");
+        }
         return;
       }
-      const deviceKey = toBase64Url(remoteStatic);
-      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");
+      if (stage === "deciding") {
+        carrier.close(1008, "expected handshake");
         return;
       }
-      const { message, result: result2 } = responder.writeMessage2(encodeHostHello({ v: 1 }));
-      return {
-        result: result2,
-        message,
-        deviceKey,
-        ...decision.outcome === "admitted" ? { joined: decision.entry } : {}
-      };
+      stage = "deciding";
+      admit(bytes).then(async (admitted) => {
+        if (admitted === undefined)
+          return;
+        if (closed)
+          return;
+        clearTimeout(timeout);
+        session = new SecureSession(admitted.result);
+        stage = "settled";
+        await carrier.send(admitted.message);
+        if (admitted.purpose === "signal")
+          handlers.signal?.(connection, admitted.deviceKey);
+        else
+          handlers.client(connection, admitted.deviceKey, admitted.joined);
+        handlers.onRegistered?.();
+      }).catch(() => carrier.close(1011, "handshake failed"));
+      async function admit(bytes2) {
+        let purpose = "business";
+        let opened;
+        let responder = respondIK({ prologue: SECURE_PROLOGUE, static: secure.hostKey });
+        try {
+          opened = responder.readMessage1(bytes2);
+        } catch {
+          if (handlers.prologues === "business") {
+            carrier.close(1008, "bad handshake");
+            return;
+          }
+          responder = respondIK({ prologue: SIGNAL_PROLOGUE, static: secure.hostKey });
+          try {
+            opened = responder.readMessage1(bytes2);
+            purpose = "signal";
+          } catch {
+            carrier.close(1008, "bad handshake");
+            return;
+          }
+        }
+        let hello;
+        try {
+          hello = decodeClientHello(opened.payload);
+        } catch {
+          carrier.close(1008, "bad handshake");
+          return;
+        }
+        if (purpose === "signal" && hello.pair !== undefined) {
+          carrier.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
+          return;
+        }
+        const deviceKey = toBase64Url(opened.remoteStatic);
+        if (handlers.expectedDeviceKey !== undefined && deviceKey !== handlers.expectedDeviceKey) {
+          carrier.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
+          return;
+        }
+        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") {
+          carrier.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
+          return;
+        }
+        if (purpose === "signal" && decision.outcome !== "registered") {
+          carrier.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
+          return;
+        }
+        const { message, result: result2 } = responder.writeMessage2(encodeHostHello({ v: 1 }));
+        return {
+          result: result2,
+          message,
+          deviceKey,
+          purpose,
+          ...decision.outcome === "admitted" ? { joined: decision.entry } : {}
+        };
+      }
+    },
+    text() {
+      carrier.close(1008, stage === "settled" ? "unexpected text record" : "expected handshake");
+    },
+    closed() {
+      if (closed)
+        return;
+      closed = true;
+      clearTimeout(timeout);
+      pending?.closed();
     }
   });
 }
-async function startRemote(options, admission, register) {
+async function startRemote(options, admission, handlers) {
   const spec = options.secure;
   const remote = spec?.lan;
   if (spec === undefined || remote === undefined)
@@ -3373,18 +3857,20 @@ async function startRemote(options, admission, register) {
     http.listen(remote.port, "0.0.0.0");
   });
   const secure = new WebSocketServer({ server: http });
-  secure.on("connection", (socket) => secureHandshake(socket, spec, admission, register));
+  secure.on("connection", (socket) => secureHandshake(webSocketCarrier(socket), spec, admission, handlers));
   const { port } = http.address();
   const url = `ws://127.0.0.1:${port}`;
-  const advertiseUrl = remote.publicUrl?.replace(/\/+$/, "") ?? `http://${pickLanAddress(networkInterfaces()) ?? "127.0.0.1"}:${port}`;
+  const currentAdvertiseUrl = () => remote.publicUrl === undefined ? `http://${pickLanAddress(networkInterfaces()) ?? "127.0.0.1"}:${port}` : normalizeAdvertiseUrl(remote.publicUrl);
   return {
     url,
-    advertiseUrl,
+    get advertiseUrl() {
+      return currentAdvertiseUrl();
+    },
     async close() {
       for (const socket of secure.clients)
         socket.terminate();
-      await new Promise((resolve6) => secure.close(() => resolve6()));
-      await new Promise((resolve6) => http.close(() => resolve6()));
+      await new Promise((resolve5) => secure.close(() => resolve5()));
+      await new Promise((resolve5) => http.close(() => resolve5()));
     }
   };
 }
@@ -3688,6 +4174,88 @@ function callsOf(message) {
   return calls.size === 0 ? undefined : calls;
 }
 
+class SignalClient {
+  devicePublicKey;
+  #connection;
+  #hooks;
+  #disposed = false;
+  constructor(connection, devicePublicKey, hooks) {
+    this.#connection = connection;
+    this.devicePublicKey = devicePublicKey;
+    this.#hooks = hooks;
+    connection.handle({
+      message: (text) => this.#receive(text),
+      closed: () => hooks.closed(this)
+    });
+    const rtc = hooks.rtcHello();
+    this.send({
+      type: "signalHello",
+      protocol: PROTOCOL,
+      ...rtc === undefined ? {} : { rtc }
+    });
+  }
+  send(frame) {
+    if (this.#disposed || !this.#connection.open)
+      return Promise.resolve();
+    return this.#connection.send(JSON.stringify(frame));
+  }
+  closeConnection(code, reason) {
+    this.#connection.close(code, reason);
+  }
+  dispose() {
+    this.#disposed = true;
+  }
+  #receive(text) {
+    let parsed;
+    try {
+      parsed = parseClientFrame(JSON.parse(text));
+    } catch {
+      this.#connection.close(INVALID_FRAME_CLOSE_CODE, "Invalid client frame");
+      return;
+    }
+    switch (parsed.kind) {
+      case "frame":
+        if (parsed.frame.type === "subscribe" || parsed.frame.type === "unsubscribe") {
+          this.send({ type: "ended", stream: parsed.frame.stream, reason: "Unsupported stream" });
+          return;
+        }
+        if (parsed.frame.method === "rtcOffer" || parsed.frame.method === "ping") {
+          this.#answer(parsed.frame.id, parsed.frame.method, parsed.frame.args);
+          return;
+        }
+        this.send({ type: "result", id: parsed.frame.id, ok: false, error: `Unsupported method: ${parsed.frame.method}` });
+        return;
+      case "unsupportedCall":
+        this.send({ type: "result", id: parsed.id, ok: false, error: `Unsupported method: ${parsed.method}` });
+        return;
+      case "unsupportedStream":
+        if (parsed.type === "subscribe") {
+          this.send({ type: "ended", stream: parsed.stream, reason: "Unsupported stream" });
+        }
+        return;
+      case "unknownType":
+        return;
+      case "malformed":
+        this.#connection.close(INVALID_FRAME_CLOSE_CODE, "Invalid client frame");
+        return;
+    }
+  }
+  async#answer(id, method, args) {
+    try {
+      let value;
+      if (method === "ping") {
+        value = { id: args.id };
+      } else {
+        const offer = args;
+        value = await this.#hooks.rtcOffer(this, this.devicePublicKey, offer.attempt, offer.sdp);
+      }
+      await this.send({ type: "result", id, ok: true, value });
+    } catch (error) {
+      await this.send({ type: "result", id, ok: false, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+}
+
 class GatewayClient {
   devicePublicKey;
   #connection;
@@ -3695,19 +4263,28 @@ class GatewayClient {
   #options;
   #files;
   #skills;
+  #imageVariants;
+  #providerCalls() {
+    const modelAuth = this.#options.modelAuth;
+    if (modelAuth === undefined)
+      throw new Error("Provider setup is not available on this host");
+    return modelAuth;
+  }
   #hostValues;
   #subscriptions = new Map;
   #disposed = false;
-  constructor(connection, options, conversations, files, skills, hooks) {
+  constructor(connection, options, conversations, files, skills, imageVariants, hooks) {
     this.#connection = connection;
     this.#options = options;
     this.#files = files;
     this.#skills = skills;
+    this.#imageVariants = imageVariants;
     this.#hostValues = {
       conversations,
       mcp: options.mcp ?? constantValue(null),
       models: options.modelAuth?.models ?? constantValue(options.modelSummaries()),
       auth: options.modelAuth?.auth ?? constantValue({ logins: [] }),
+      providers: options.modelAuth?.providers ?? constantValue({ providers: [], logins: [] }),
       settings: options.settings,
       agents: options.agents ?? constantValue({ roles: [], problems: [] })
     };
@@ -3743,6 +4320,7 @@ class GatewayClient {
       },
       closed: () => hooks.closed(this)
     });
+    const rtc = this.#hooks.rtcHello();
     this.send({
       type: "hello",
       protocol: PROTOCOL,
@@ -3754,7 +4332,9 @@ class GatewayClient {
         kind: doc.token.definition.kind,
         ...doc.presentation === undefined ? {} : { presentation: doc.presentation }
       })),
-      toolPresentations: options.toolPresentations ?? {}
+      toolPresentations: options.toolPresentations ?? {},
+      endpointSet: this.#hooks.endpointSet(),
+      ...rtc === undefined ? {} : { rtc }
     });
   }
   send(frame) {
@@ -3806,16 +4386,16 @@ class GatewayClient {
       return { stop: source.subscribe((value) => void send({ type: "snapshot", stream, value })) };
     }
     if (stream === "index") {
-      const watch2 = await this.#options.harness.watchDoc(IndexDoc, context3);
-      if (watch2 === undefined)
+      const watch = await this.#options.harness.watchDoc(IndexDoc, context3);
+      if (watch === undefined)
         throw new Error("Index document is missing");
-      return this.#forward(stream, watch2, send);
+      return this.#forward(stream, watch, send);
     }
     if (stream === "devices") {
-      const watch2 = await this.#options.harness.watchDoc(DevicesDoc, context3);
-      if (watch2 === undefined)
+      const watch = await this.#options.harness.watchDoc(DevicesDoc, context3);
+      if (watch === undefined)
         throw new Error("Devices document is missing");
-      return this.#forward(stream, watch2, send);
+      return this.#forward(stream, watch, send);
     }
     if (stream === "tasks")
       return this.#forward(stream, await this.#options.harness.watchTaskGraph(context3), send);
@@ -3837,8 +4417,8 @@ class GatewayClient {
     await this.#conversation(id);
     const { harness } = this.#options;
     let signalCreation;
-    const created = new Promise((resolve6) => {
-      signalCreation = resolve6;
+    const created = new Promise((resolve5) => {
+      signalCreation = resolve5;
     });
     let inner;
     let stopped = false;
@@ -3863,13 +4443,13 @@ class GatewayClient {
     created.then(async () => {
       if (stopped)
         return;
-      const watch2 = await harness.watchDoc(token, id, context3);
-      if (watch2 === undefined)
+      const watch = await harness.watchDoc(token, id, context3);
+      if (watch === undefined)
         return;
       if (stopped)
-        await watch2.stop();
+        await watch.stop();
       else {
-        inner = await this.#forward(stream, watch2, send);
+        inner = await this.#forward(stream, watch, send);
         if (stopped)
           await inner.stop();
       }
@@ -3886,23 +4466,23 @@ class GatewayClient {
       }
     };
   }
-  async#forward(stream, watch2, send, state) {
+  async#forward(stream, watch, send, state) {
     if (state?.images === undefined) {
-      await send({ type: "snapshot", stream, value: watch2.value });
-      watch2.start((_value, ops) => send({ type: "ops", stream, ops }));
-      return watch2;
+      await send({ type: "snapshot", stream, value: watch.value });
+      watch.start((_value, ops) => send({ type: "ops", stream, ops }));
+      return watch;
     }
     const images = state.images;
-    let before = watch2.value;
+    let before = watch.value;
     state.view = before;
     await send({ type: "snapshot", stream, value: await images.value(before) });
-    watch2.start(async (value, ops) => {
+    watch.start(async (value, ops) => {
       const sent = await images.ops(ops, before);
       before = value;
       state.view = before;
       return send({ type: "ops", stream, ops: sent });
     });
-    return watch2;
+    return watch;
   }
   #shownImage(ref) {
     for (const state of this.#subscriptions.values()) {
@@ -3926,19 +4506,22 @@ class GatewayClient {
     const files = await this.#attachmentStore().use(ids);
     return files === undefined ? undefined : attachmentBlock(files);
   }
-  #attached(images) {
-    const resolved = images?.map((image, index) => {
-      if ("data" in image)
+  #captureImages(images) {
+    const captured = images?.map((image) => ("data" in image) ? image : this.#shownImage(image.ref));
+    return () => {
+      const resolved = captured?.map((image, index) => {
+        if (image === undefined)
+          throw new Error(`Image ${index + 1} is no longer available`);
         return image;
-      const shown = this.#shownImage(image.ref);
-      if (shown === undefined)
-        throw new Error(`Image ${index + 1} is no longer available`);
-      return shown;
-    });
-    const problem = imageProblem(resolved ?? []);
-    if (problem !== undefined)
-      throw new Error(problem);
-    return resolved;
+      });
+      const problem = imageProblem(resolved ?? []);
+      if (problem !== undefined)
+        throw new Error(problem);
+      return resolved;
+    };
+  }
+  #attached(images) {
+    return this.#captureImages(images)();
   }
   async#unsubscribe(stream) {
     const subscription = this.#subscriptions.get(stream);
@@ -3951,6 +4534,9 @@ class GatewayClient {
       throw new Error(`Conversation ${id} does not exist`);
     return conversation;
   }
+  #submissionByRequest(conversationId, requestId) {
+    return this.#options.harness.commit((tx) => tx.submissionByRequest(conversationId, requestId), context3);
+  }
   async#compact(conversation, instructions) {
     const taskId = await conversation.compact(instructions, context3);
     this.#options.harness.waitForTask(taskId, context3).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
@@ -3973,23 +4559,39 @@ class GatewayClient {
         return null;
       case "submit": {
         const input = args;
-        const images = this.#attached(input.images);
-        const conversation2 = await this.#conversation(input.conversationId);
-        const attachments = await this.#attachmentText(input.attachments);
-        const text = await this.#expandSkills(input.text, { kind: "conversation", conversationId: conversation2.id }, input.skills);
-        const dismissed = await this.#dismissPendingQuestions(conversation2.id, context3);
-        const submission = await conversation2.submit({
-          type: "input",
-          content: messageContent(text, images, attachments),
-          whenBusy: dismissed ? "steer" : input.whenBusy,
-          requestId: input.requestId
-        }, context3);
-        submission.wait(context3).then((settled) => {
-          if (settled.status === "unanswered" && settled.reason !== "aborted") {
-            this.send({ type: "notice", level: "error", message: `No answer: ${settled.reason}` });
-          }
-        }, () => {});
-        return { submissionId: submission.id };
+        const images = this.#captureImages(input.images);
+        return await serializedSubmission(this.#options.harness, input.conversationId, input.requestId, async () => {
+          const existing = await this.#submissionByRequest(input.conversationId, input.requestId);
+          if (existing !== undefined)
+            return submitResult(existing);
+          const resolved = images();
+          const conversation2 = await this.#conversation(input.conversationId);
+          const attachments = await this.#attachmentText(input.attachments);
+          const text = await this.#expandSkills(input.text, { kind: "conversation", conversationId: conversation2.id }, input.skills);
+          const dismissed = await this.#dismissPendingQuestions(conversation2.id, context3);
+          const submission = await conversation2.submit({
+            type: "input",
+            content: messageContent(text, resolved, attachments),
+            whenBusy: dismissed ? "steer" : input.whenBusy,
+            requestId: input.requestId
+          }, context3);
+          let entry;
+          try {
+            const admitted = await this.#options.harness.submission(submission.id, context3);
+            entry = (await admitted?.status(context3))?.entry;
+          } catch {}
+          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, ...entry === undefined ? {} : { entry } };
+        });
+      }
+      case "submission": {
+        const input = args;
+        const record = await this.#submissionByRequest(input.conversationId, input.requestId);
+        return record === undefined ? null : submissionResult(record);
       }
       case "createConversation": {
         const create = args;
@@ -4032,6 +4634,12 @@ class GatewayClient {
         this.#hooks.closeDevice(publicKey);
         return null;
       }
+      case "rtcOffer": {
+        const { attempt, sdp } = args;
+        return this.#hooks.rtcOffer(this, this.devicePublicKey, attempt, sdp);
+      }
+      case "ping":
+        return { id: args.id };
       case "setPushToken": {
         const device = this.devicePublicKey;
         if (device === undefined)
@@ -4049,6 +4657,31 @@ class GatewayClient {
         await modelAuth.logout(args.providerId);
         return null;
       }
+      case "beginLogin": {
+        const { providerId, method: method2 } = args;
+        return { loginId: this.#providerCalls().beginLogin(providerId, method2) };
+      }
+      case "answerLogin": {
+        const { loginId, promptId, value } = args;
+        this.#providerCalls().answerLogin(loginId, promptId, value);
+        return null;
+      }
+      case "cancelLogin": {
+        this.#providerCalls().cancelLogin(args.loginId);
+        return null;
+      }
+      case "saveCustomProvider": {
+        const { provider, apiKey } = args;
+        await this.#providerCalls().saveCustomProvider(provider, apiKey);
+        return null;
+      }
+      case "removeCustomProvider": {
+        await this.#providerCalls().removeCustomProvider(args.providerId);
+        return null;
+      }
+      case "listEndpointModels": {
+        return { models: await this.#providerCalls().listEndpointModels(args) };
+      }
       case "updateSettings": {
         await this.#options.settings.update(args.patch);
         return null;
@@ -4075,7 +4708,7 @@ class GatewayClient {
         return null;
       }
       case "listFolders":
-        return listFolders(args.path, homedir2());
+        return listFolders(args.path, homedir());
       case "listFiles": {
         const input = args;
         return listFiles(this.#options.harness, this.#options.dataDir, this.#files, input.scope, input.query, context3);
@@ -4085,10 +4718,16 @@ class GatewayClient {
         return listSkills(this.#options.harness, this.#skills, input.scope, context3);
       }
       case "image": {
-        const image = this.#shownImage(args.ref);
+        const input = args;
+        const image = this.#shownImage(input.ref);
         if (image === undefined)
           throw new Error("Unknown image");
-        return image;
+        if (input.variant === undefined)
+          return image;
+        const derived = await this.#imageVariants.get(input.ref, input.variant, image);
+        if (this.#shownImage(input.ref) === undefined)
+          throw new Error("Unknown image");
+        return derived;
       }
       case "beginAttachment": {
         const input = args;
@@ -4282,73 +4921,577 @@ class GatewayClient {
       return text;
     let skills;
     try {
-      skills = await scopeSkills(this.#options.harness, this.#skills, scope, context3);
+      skills = await scopeSkills(this.#options.harness, this.#skills, scope, context3);
+    } catch (error) {
+      this.send({
+        type: "notice",
+        level: "warning",
+        message: `Skills were not expanded: ${error instanceof Error ? error.message : String(error)}`
+      });
+      return text;
+    }
+    const names = bound ?? mentionedSkillNames(text, skills.map((skill) => skill.name));
+    const expanded = await expandSkills(text, names, skills);
+    for (const name of expanded.missing) {
+      this.send({ type: "notice", level: "warning", message: `Skill "${name}" is not available here; sent without it` });
+    }
+    for (const failure of expanded.failures) {
+      this.send({
+        type: "notice",
+        level: "error",
+        message: `Could not read skill "${failure.name}" (${failure.filePath}): ${failure.message}`
+      });
+    }
+    return expanded.text;
+  }
+  async#dismissPendingQuestions(conversationId, context4) {
+    const questionDocs = this.#questionDocs();
+    const snapshots = await Promise.all(questionDocs.map((doc) => this.#options.harness.snapshot(doc.token, conversationId, context4)));
+    const pending = snapshots.some((value) => Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined));
+    if (!pending)
+      return false;
+    return await this.#options.harness.commit((tx) => dismissPendingQuestions(tx, questionDocs, conversationId), context4);
+  }
+  #questionDocs() {
+    return (this.#options.docs ?? []).filter((doc) => doc.presentation === "pinomad.question");
+  }
+  get #chatsPrefix() {
+    return join7(this.#options.dataDir, "chats") + sep5;
+  }
+  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, context4);
+    const record = checkoutAt(index?.checkouts, cwd);
+    if (record !== undefined) {
+      if (!await worktreeExists(record.path))
+        return { available: false, reason: "No changes yet" };
+      const [changes, branch2] = await Promise.all([changesOf(record.path, record.base), branchOf(record.path)]);
+      return { available: true, ...changes, branch: branch2 };
+    }
+    const [base, branch] = await Promise.all([gitBase(cwd), branchOf(cwd)]);
+    if (base === undefined)
+      return { available: false, reason: "Not in a git repository", branch };
+    return { available: true, ...await changesOf(base.repo, base.base), branch };
+  }
+  async dispose() {
+    if (this.#disposed)
+      return;
+    this.#disposed = true;
+    const subscriptions = [...this.#subscriptions.values()];
+    this.#subscriptions.clear();
+    for (const state of subscriptions)
+      await state.subscription?.stop();
+  }
+}
+
+// apps/host/src/host.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename3, join as join10, sep as sep6 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
+import { createRegistry, Harness } from "@earendil-works/pi-durable";
+import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
+
+// apps/host/src/mcp.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute as isAbsolute2, resolve as resolve5 } from "node:path";
+import {
+  McpAuthRequiredError,
+  McpClient,
+  McpHttpError,
+  StdioTransport,
+  StreamableHttpTransport,
+  toLlmContent
+} from "@earendil-works/pi-mcp";
+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 isObject2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function expand(value) {
+  let missing;
+  const expanded = value.replace(ENV_VAR, (_all, name) => {
+    const found = process.env[name];
+    if (found === undefined)
+      missing = name;
+    return found ?? "";
+  });
+  return missing === undefined ? expanded : { missing };
+}
+function expandAll(values, field, error) {
+  if (values === undefined)
+    return;
+  if (!isObject2(values)) {
+    error(`"${field}" must be an object of strings`);
+    return;
+  }
+  const expanded = {};
+  for (const [key, value] of Object.entries(values)) {
+    if (typeof value !== "string") {
+      error(`"${field}.${key}" must be a string`);
+      return;
+    }
+    const result2 = expand(value);
+    if (typeof result2 !== "string") {
+      error(`"${field}.${key}" references unset environment variable ${result2.missing}`);
+      return;
+    }
+    expanded[key] = result2;
+  }
+  return expanded;
+}
+function parseServer(name, raw, error) {
+  const fail = (message) => {
+    error(`${name}: ${message}`);
+    return;
+  };
+  if (!isObject2(raw))
+    return fail("server entry must be an object");
+  if (raw.enabled === false)
+    return { name, disabled: true };
+  const timeout = raw.timeout === undefined ? 60000 : typeof raw.timeout === "number" && raw.timeout > 0 ? raw.timeout * 1000 : undefined;
+  if (timeout === undefined)
+    return fail(`"timeout" must be a positive number of seconds`);
+  if (raw.exposure !== undefined && raw.exposure !== "codemode" && raw.exposure !== "direct") {
+    return fail(`"exposure" must be "codemode" or "direct"`);
+  }
+  if (raw.description !== undefined && typeof raw.description !== "string")
+    return fail(`"description" must be a string`);
+  const exposure = raw.exposure ?? "codemode";
+  const description = raw.description;
+  if (raw.command !== undefined || raw.type === "stdio") {
+    if (typeof raw.command !== "string" || raw.command === "")
+      return fail(`stdio server needs a "command"`);
+    if (raw.args !== undefined && (!Array.isArray(raw.args) || !raw.args.every((arg) => typeof arg === "string"))) {
+      return fail(`"args" must be an array of strings`);
+    }
+    if (raw.cwd !== undefined && typeof raw.cwd !== "string")
+      return fail(`"cwd" must be a string`);
+    const env = expandAll(raw.env, "env", (message) => error(`${name}: ${message}`));
+    if (raw.env !== undefined && env === undefined)
+      return;
+    const cwd = raw.cwd === undefined ? homedir2() : isAbsolute2(raw.cwd) ? raw.cwd : resolve5(homedir2(), raw.cwd);
+    return {
+      name,
+      spec: { kind: "stdio", command: raw.command, args: raw.args, env, cwd },
+      timeoutMs: timeout,
+      exposure,
+      ...description === undefined ? {} : { description }
+    };
+  }
+  if (raw.url !== undefined || raw.type === "http" || raw.type === "sse") {
+    if (typeof raw.url !== "string" || raw.url === "")
+      return fail(`HTTP server needs a "url"`);
+    const headers = expandAll(raw.headers, "headers", (message) => error(`${name}: ${message}`));
+    if (raw.headers !== undefined && headers === undefined)
+      return;
+    return {
+      name,
+      spec: { kind: "http", url: raw.url, headers },
+      timeoutMs: timeout,
+      exposure,
+      ...description === undefined ? {} : { description }
+    };
+  }
+  return fail(`needs "command" (stdio) or "url" (HTTP)`);
+}
+async function loadConfig(configPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile2(configPath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { errors: [], entries: [] };
+    return { errors: [`${configPath}: ${error instanceof Error ? error.message : String(error)}`], entries: [] };
+  }
+  if (!isObject2(parsed) || parsed.mcpServers !== undefined && !isObject2(parsed.mcpServers)) {
+    return { errors: [`${configPath}: "mcpServers" must be an object`], entries: [] };
+  }
+  const errors = [];
+  const entries = [];
+  for (const [name, raw] of Object.entries(parsed.mcpServers ?? {})) {
+    const entry = parseServer(name, raw, (message) => errors.push(message));
+    if (entry !== undefined)
+      entries.push(entry);
+  }
+  return { errors, entries };
+}
+var callName = (server, tool) => `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_]/g, "_").slice(0, 64);
+var callToolResultSchema = (tool) => ({
+  type: "object",
+  properties: {
+    content: { type: "array", items: { type: "object" } },
+    isError: { type: "boolean" },
+    _meta: { type: "object" },
+    structuredContent: tool.outputSchema ?? { type: "object" }
+  },
+  required: ["content"]
+});
+function mcpTool(client, timeoutMs, exposure, name, tool) {
+  return defineTool4({
+    name,
+    description: tool.description ?? tool.title ?? tool.name,
+    parameters: Type5.Unsafe({
+      ...tool.inputSchema,
+      type: "object",
+      properties: tool.inputSchema.properties ?? {}
+    }),
+    ...exposure === "direct" ? {} : { callers: ["tools"] },
+    structuredOutputSchema: Type5.Unsafe(callToolResultSchema(tool)),
+    execute: async (args, _api, context4) => {
+      const result2 = await client.callTool(tool.name, args, {
+        signal: context4.abortSignal ?? NEVER_ABORT,
+        timeoutMs
+      });
+      return { output: toLlmContent(result2), structuredOutput: result2, isError: result2.isError === true };
+    }
+  });
+}
+var NEVER_ABORT = new AbortController().signal;
+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 = [];
+  let closed = false;
+  const publish = () => {
+    const value = { configPath: options.configPath, errors, servers: [...servers.values()] };
+    for (const listener of listeners)
+      listener(value);
+  };
+  const install = () => {
+    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 });
+    publish();
+  };
+  const relist = async (name, client, timeoutMs, description) => {
+    const taken = new Set([...toolsets.entries()].flatMap(([other, tools2]) => other === name ? [] : tools2.map((tool) => tool.name)));
+    const tools = [];
+    const collisions = [];
+    for (const tool of await client.listTools()) {
+      const wire = callName(name, tool.name);
+      if (taken.has(wire)) {
+        collisions.push(`tool "${tool.name}" collides as ${wire}; skipped`);
+        continue;
+      }
+      taken.add(wire);
+      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();
+  };
+  const describeConnectError = (error, transport) => {
+    if (error instanceof McpAuthRequiredError || error instanceof McpHttpError && error.status === 401) {
+      return "requires sign-in (OAuth), not supported yet";
+    }
+    const base = error instanceof Error ? error.message : String(error);
+    const stderr = transport?.stderr.trim().split(`
+`).slice(-5).join(`
+`);
+    return stderr === undefined || stderr === "" ? base : `${base}
+${stderr}`;
+  };
+  const connect = async (name, spec, timeoutMs, description) => {
+    const client = new McpClient({ name: "pinomad", version: "0.0.0" });
+    live.add(client);
+    let stdio;
+    try {
+      const transport = spec.kind === "stdio" ? stdio = new StdioTransport({ command: spec.command, args: spec.args, cwd: spec.cwd, env: spec.env, stderr: "pipe" }) : new StreamableHttpTransport({ url: spec.url, headers: spec.headers });
+      await client.connect(transport);
+      if (closed)
+        return;
+      let lastError;
+      client.onError((error) => {
+        lastError = error.message;
+      });
+      client.onClose(() => {
+        if (!closed)
+          fail(name, `disconnected${lastError === undefined ? "" : `: ${lastError}`}`);
+      });
+      client.onNotification("notifications/tools/list_changed", () => {
+        relist(name, client, timeoutMs, description).catch((error) => {
+          fail(name, error instanceof Error ? error.message : String(error));
+        });
+      });
+      await relist(name, client, timeoutMs, description);
+    } catch (error) {
+      live.delete(client);
+      if (!closed)
+        fail(name, describeConnectError(error, stdio));
+      await client.close().catch(() => {});
+    }
+  };
+  const status = {
+    get value() {
+      return { configPath: options.configPath, errors, servers: [...servers.values()] };
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+  loadConfig(options.configPath).then((loaded) => {
+    if (closed)
+      return;
+    errors = loaded.errors;
+    for (const entry of loaded.entries) {
+      if (entry.disabled === true)
+        servers.set(entry.name, { name: entry.name, state: "disabled", tools: 0 });
+      else
+        servers.set(entry.name, { name: entry.name, state: "connecting", tools: 0 });
+    }
+    publish();
+    install();
+    for (const entry of loaded.entries) {
+      if (entry.disabled === true)
+        continue;
+      exposures.set(entry.name, entry.exposure);
+      connect(entry.name, entry.spec, entry.timeoutMs, entry.description);
+    }
+  });
+  return {
+    status,
+    async close() {
+      closed = true;
+      await Promise.all([...live].map((client) => client.close().catch(() => {})));
+    }
+  };
+}
+
+// apps/host/src/agent-roles.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync2, watch } from "node:fs";
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile3, rename, rm as rm2, writeFile } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import { 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/agent-roles.ts
+var KNOWN_FIELDS = new Set(["description", "model", "thinkingLevel"]);
+async function load(dir) {
+  const roles = [];
+  const problems = [];
+  const entries = await readdir2(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 readFile3(join8(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 rescanMs = options.rescanMs ?? 1000;
+  const published = new Published({ roles: [], problems: [] }, (a, b) => sameList(a.roles, b.roles, sameRole) && sameList(a.problems, b.problems, sameProblem));
+  let closed = false;
+  let reported = false;
+  let timer;
+  let queued = false;
+  let chain = Promise.resolve();
+  const loadOnce = async () => {
+    try {
+      published.set(await load(dir));
+      reported = false;
     } catch (error) {
-      this.send({
-        type: "notice",
-        level: "warning",
-        message: `Skills were not expanded: ${error instanceof Error ? error.message : String(error)}`
-      });
-      return text;
-    }
-    const names = bound ?? mentionedSkillNames(text, skills.map((skill) => skill.name));
-    const expanded = await expandSkills(text, names, skills);
-    for (const name of expanded.missing) {
-      this.send({ type: "notice", level: "warning", message: `Skill "${name}" is not available here; sent without it` });
+      if (!reported)
+        console.error(`agent-roles reload failed: ${error instanceof Error ? error.message : String(error)}`);
+      reported = true;
     }
-    for (const failure of expanded.failures) {
-      this.send({
-        type: "notice",
-        level: "error",
-        message: `Could not read skill "${failure.name}" (${failure.filePath}): ${failure.message}`
+  };
+  const reload = () => {
+    if (closed)
+      return Promise.resolve();
+    queued = true;
+    chain = chain.then(async () => {
+      if (!queued || closed)
+        return;
+      queued = false;
+      await loadOnce();
+    });
+    return chain;
+  };
+  const watcher = watch(dir, () => {
+    if (closed)
+      return;
+    clearTimeout(timer);
+    timer = setTimeout(() => void reload(), debounceMs);
+  });
+  watcher.on("error", (error) => {
+    if (!reported)
+      console.error(`agent-roles watch failed: ${error.message}`);
+    reported = true;
+    reload();
+  });
+  await reload();
+  const rescan = setInterval(() => void reload(), rescanMs);
+  let pending = Promise.resolve();
+  const enqueue = (operation) => {
+    const run2 = pending.then(operation, operation);
+    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 = join8(dir, `${role.name}.md`);
+      const exists = existsSync2(target);
+      if (mustExist && !exists)
+        throw new Error(`No such agent: "${role.name}"`);
+      if (!mustExist && exists)
+        throw new Error(`Agent "${role.name}" already exists`);
+      const temp = join8(dir, `.${role.name}.${randomBytes2(6).toString("hex")}.tmp`);
+      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 = join8(dir, `${name}.md`);
+        if (!existsSync2(target))
+          throw new Error(`No such agent: "${name}"`);
+        await rm2(target);
+        await reload();
       });
+    },
+    close() {
+      closed = true;
+      clearTimeout(timer);
+      clearInterval(rescan);
+      watcher.close();
     }
-    return expanded.text;
-  }
-  async#dismissPendingQuestions(conversationId, context4) {
-    const questionDocs = this.#questionDocs();
-    const snapshots = await Promise.all(questionDocs.map((doc) => this.#options.harness.snapshot(doc.token, conversationId, context4)));
-    const pending = snapshots.some((value) => Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined));
-    if (!pending)
-      return false;
-    return await this.#options.harness.commit((tx) => dismissPendingQuestions(tx, questionDocs, conversationId), context4);
-  }
-  #questionDocs() {
-    return (this.#options.docs ?? []).filter((doc) => doc.presentation === "pinomad.question");
-  }
-  get #chatsPrefix() {
-    return join8(this.#options.dataDir, "chats") + sep5;
-  }
-  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, context4);
-    const record = checkoutAt(index?.checkouts, cwd);
-    if (record !== undefined) {
-      if (!await worktreeExists(record.path))
-        return { available: false, reason: "No changes yet" };
-      const [changes, branch2] = await Promise.all([changesOf(record.path, record.base), branchOf(record.path)]);
-      return { available: true, ...changes, branch: branch2 };
-    }
-    const [base, branch] = await Promise.all([gitBase(cwd), branchOf(cwd)]);
-    if (base === undefined)
-      return { available: false, reason: "Not in a git repository", branch };
-    return { available: true, ...await changesOf(base.repo, base.base), branch };
-  }
-  async dispose() {
-    if (this.#disposed)
-      return;
-    this.#disposed = true;
-    const subscriptions = [...this.#subscriptions.values()];
-    this.#subscriptions.clear();
-    for (const state of subscriptions)
-      await state.subscription?.stop();
-  }
+  };
 }
 
+// apps/host/src/host.ts
+import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
+import lockfile from "proper-lockfile";
+
 // apps/host/src/attachments.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
 import {
@@ -4658,6 +5801,56 @@ class AttachmentStore {
   }
 }
 
+// apps/host/src/answer-timing.ts
+function withAnswerStart(message, answerStartedAt) {
+  const pinomad = message.pinomad;
+  return { ...message, pinomad: { ...pinomad, answerStartedAt } };
+}
+function stripPinomad(context4) {
+  let changed = false;
+  const messages = context4.messages.map((message) => {
+    if (message.role !== "assistant" || !("pinomad" in message))
+      return message;
+    const { pinomad: _pinomad, ...rest } = message;
+    changed = true;
+    return rest;
+  });
+  return changed ? { ...context4, messages } : context4;
+}
+function trackAnswerStart(stream) {
+  let answerStartedAt;
+  const annotate = (event) => {
+    if (event.type === "text_delta" && event.delta !== "") {
+      answerStartedAt ??= Date.now();
+    } else if (event.type === "text_end" && event.content !== "" && answerStartedAt === undefined) {
+      answerStartedAt = Date.now();
+    }
+    if (answerStartedAt === undefined)
+      return event;
+    if (event.type === "done")
+      return { ...event, message: withAnswerStart(event.message, answerStartedAt) };
+    if (event.type === "error")
+      return { ...event, error: withAnswerStart(event.error, answerStartedAt) };
+    return { ...event, partial: withAnswerStart(event.partial, answerStartedAt) };
+  };
+  const push = stream.push.bind(stream);
+  stream.push = (event) => push(annotate(event));
+  const end = stream.end.bind(stream);
+  stream.end = (result2) => end(result2 === undefined || answerStartedAt === undefined ? result2 : withAnswerStart(result2, answerStartedAt));
+  return stream;
+}
+function withAnswerTiming(models) {
+  const streamSimple = (model, context4, options) => trackAnswerStart(models.streamSimple(model, stripPinomad(context4), options));
+  return new Proxy(models, {
+    get(target, property) {
+      if (property === "streamSimple")
+        return streamSimple;
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
 // apps/host/src/host.ts
 var context4 = BACKGROUND_CONTEXT4;
 async function hostToken(dataDir) {
@@ -4672,6 +5865,8 @@ async function hostToken(dataDir) {
   }
 }
 async function openHost(options) {
+  if (options.remote?.publicUrl !== undefined)
+    validatePublicUrl(options.remote.publicUrl);
   await mkdir4(options.dataDir, { recursive: true });
   const stale = Math.max(2000, options.lockStaleMs ?? 1e4);
   const release = await lockfile.lock(options.dataDir, {
@@ -4687,6 +5882,7 @@ async function openHost(options) {
   let attachments;
   let extensions = [];
   try {
+    const models = withAnswerTiming(options.models);
     const token = await hostToken(options.dataDir);
     attachments = new AttachmentStore({ dir: join10(options.dataDir, "attachments") });
     await attachments.open();
@@ -4723,7 +5919,7 @@ async function openHost(options) {
     const environments = new Map;
     const chatsDir = join10(options.dataDir, "chats");
     harness = await Harness.open(await (options.openStorage ?? openNodeSqliteStorage)(join10(options.dataDir, "session.sqlite")), {
-      models: options.models,
+      models,
       registry,
       env: async (target) => {
         const cwd = target.cwd;
@@ -4761,8 +5957,9 @@ async function openHost(options) {
     const relayKey = options.relay === undefined ? undefined : await loadRelayKey(options.dataDir);
     const gateway = await startGateway({
       harness,
-      models: options.models,
+      models,
       modelSummaries: options.modelSummaries,
+      ...options.images === undefined ? {} : { images: options.images },
       session: { id: basename3(options.dataDir), directory: options.dataDir },
       dataDir: options.dataDir,
       attachments,
@@ -4785,6 +5982,7 @@ async function openHost(options) {
           ...options.push.timers === undefined ? {} : { timers: options.push.timers }
         }
       },
+      ...options.rtc === undefined ? {} : { rtc: options.rtc },
       secure: {
         hostKey,
         offers,
@@ -4823,7 +6021,15 @@ async function openHost(options) {
         });
         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.remote === undefined || hostKey === undefined ? {} : {
+        remote: {
+          url: gateway.remote.url,
+          get advertiseUrl() {
+            return 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 () => {
@@ -4920,8 +6126,10 @@ function startHostLogRotation(dataDir) {
 }
 
 // apps/host/src/model-auth.ts
-import { existsSync as existsSync3, watch as watch2 } from "node:fs";
-import { basename as basename4, dirname as dirname3 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir5, readFile as readFile6, rename as rename4, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+import { getBuiltinProviders } from "@earendil-works/pi-ai/providers/all";
 
 // apps/host/src/pi-setup.ts
 import { getSupportedThinkingLevels as getSupportedThinkingLevels2 } from "@earendil-works/pi-ai";
@@ -5036,72 +6244,386 @@ function modelSummaries(modelRuntime) {
 }
 
 // apps/host/src/model-auth.ts
-var sameModel = (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 BUILTIN = new Set(getBuiltinProviders());
+var CUSTOM_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var LOGIN_TIMEOUT_MS = 15 * 60000;
+var FINISHED_LOGIN_TTL_MS = 60000;
+var ENDPOINT_TIMEOUT_MS = 1e4;
+var sameModel = (a, b) => a.provider === b.provider && a.modelId === b.modelId && a.name === b.name && a.contextWindow === b.contextWindow && a.images === b.images && sameList(a.thinkingLevels, b.thinkingLevels, (x, y) => x === y);
 var sameLogin = (a, b) => a.providerId === b.providerId && a.name === b.name && a.kind === b.kind && a.subscription === b.subscription;
-async function 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 readModelsFile(path) {
+  let text;
+  try {
+    text = await readFile6(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { providers: {} };
+    throw error;
+  }
+  const parsed = JSON.parse(text);
+  return { ...parsed, providers: parsed.providers ?? {} };
 }
-async function watchModelAuth(modelRuntime, options) {
-  const debounceMs = options.debounceMs ?? 150;
-  const models = new Published(modelSummaries(modelRuntime), (a, b) => sameList(a, b, sameModel));
-  const auth = new Published(await storedLogins(modelRuntime), (a, b) => sameList(a.logins, b.logins, sameLogin));
-  const fileName = basename4(options.authPath);
-  let watcher;
-  let timer;
-  let reported = false;
+function customProviders(file) {
+  const custom = new Map;
+  for (const [id, entry] of Object.entries(file.providers)) {
+    if (BUILTIN.has(id) || !isCustomProviderApi(entry.api) || typeof entry.baseUrl !== "string")
+      continue;
+    const models = Array.isArray(entry.models) ? entry.models.flatMap((model) => typeof model?.id === "string" ? [model.id] : []) : [];
+    custom.set(id, {
+      name: typeof entry.name === "string" ? entry.name : id,
+      api: entry.api,
+      baseUrl: entry.baseUrl,
+      models
+    });
+  }
+  return custom;
+}
+var toLoginEvent = (event) => {
+  switch (event.type) {
+    case "device_code":
+      return {
+        type: "device_code",
+        userCode: event.userCode,
+        verificationUri: event.verificationUri,
+        ...event.expiresInSeconds === undefined ? {} : { expiresAt: Date.now() + event.expiresInSeconds * 1000 }
+      };
+    case "info":
+      return { type: "info", message: event.message, ...event.links === undefined ? {} : { links: event.links } };
+    case "auth_url":
+      return { type: "auth_url", url: event.url, ...event.instructions === undefined ? {} : { instructions: event.instructions } };
+    case "progress":
+      return { type: "progress", message: event.message };
+  }
+};
+var toLoginPrompt = (id, prompt) => {
+  const placeholder = "placeholder" in prompt && prompt.placeholder !== undefined ? { placeholder: prompt.placeholder } : {};
+  if (prompt.type === "select") {
+    return {
+      id,
+      type: "select",
+      message: prompt.message,
+      options: prompt.options.map((option) => ({
+        id: option.id,
+        label: option.label,
+        ...option.description === undefined ? {} : { description: option.description }
+      }))
+    };
+  }
+  return { id, type: prompt.type, message: prompt.message, ...placeholder };
+};
+async function openModelAuth(runtime, options) {
+  const loginTimeoutMs = options.loginTimeoutMs ?? LOGIN_TIMEOUT_MS;
+  const finishedLoginTtlMs = options.finishedLoginTtlMs ?? FINISHED_LOGIN_TTL_MS;
+  let custom = customProviders(await readModelsFile(options.modelsPath));
+  const logins = new Map;
+  const dropTimers = new Set;
   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 storedLogins = async () => {
+    const credentials = await runtime.listCredentials();
+    const list = credentials.map((credential) => ({
+      providerId: credential.providerId,
+      name: runtime.getProvider(credential.providerId)?.name ?? credential.providerId,
+      kind: credential.type,
+      subscription: runtime.isUsingSubscription(credential.providerId)
+    }));
+    list.sort((a, b) => a.providerId.localeCompare(b.providerId));
+    return { logins: list };
   };
-  const directory = dirname3(options.authPath);
-  if (existsSync3(directory)) {
-    watcher = watch2(directory, (_event, changed) => {
-      if (closed || changed !== null && changed !== fileName)
-        return;
-      clearTimeout(timer);
-      timer = setTimeout(() => void refresh(), debounceMs);
+  const catalog = (stored) => {
+    const byId = new Map(stored.logins.map((login) => [login.providerId, login]));
+    const infos = runtime.getProviders().map((provider) => {
+      const login = byId.get(provider.id);
+      const status = runtime.getProviderAuthStatus(provider.id);
+      const oauth = provider.auth.oauth;
+      const apiKey = provider.auth.apiKey?.login === undefined ? undefined : provider.auth.apiKey;
+      const endpoint = custom.get(provider.id);
+      return {
+        id: provider.id,
+        name: endpoint?.name ?? provider.name,
+        ...oauth === undefined ? {} : {
+          oauth: {
+            name: oauth.name,
+            subscription: oauth.isSubscription === true,
+            ...oauth.loginLabel === undefined ? {} : { loginLabel: oauth.loginLabel }
+          }
+        },
+        ...apiKey === undefined ? {} : { apiKey: { name: apiKey.name } },
+        ...login === undefined ? {} : { stored: { kind: login.kind, subscription: login.subscription } },
+        ...login === undefined && status.configured && status.source === "environment" && status.label !== undefined ? { ambient: status.label } : {},
+        ...endpoint === undefined ? {} : { custom: { api: endpoint.api, baseUrl: endpoint.baseUrl, models: endpoint.models } }
+      };
     });
-    watcher.on("error", (error) => {
-      if (!reported)
-        console.error(`model-auth watch failed: ${error.message}`);
-      reported = true;
+    return infos.sort((a, b) => Number(a.custom !== undefined) - Number(b.custom !== undefined) || a.name.localeCompare(b.name));
+  };
+  const flows = () => [...logins.values()].map((login) => login.flow);
+  const initialAuth = await storedLogins();
+  const models = new Published(modelSummaries(runtime), (a, b) => sameList(a, b, sameModel));
+  const auth = new Published(initialAuth, (a, b) => sameList(a.logins, b.logins, sameLogin));
+  const providers = new Published({ providers: catalog(initialAuth), logins: [] }, () => false);
+  const publishFlows = () => {
+    if (!closed)
+      providers.set({ providers: providers.value.providers, logins: flows() });
+  };
+  const republish = async () => {
+    const stored = await storedLogins();
+    models.set(modelSummaries(runtime));
+    auth.set(stored);
+    if (!closed)
+      providers.set({ providers: catalog(stored), logins: flows() });
+  };
+  const end = (login, state, error) => {
+    if (login.flow.state !== "running")
+      return;
+    clearTimeout(login.timer);
+    login.pending?.reject(new Error("Login ended"));
+    login.pending = undefined;
+    const { prompt: _, ...rest } = login.flow;
+    login.flow = { ...rest, state, ...error === undefined ? {} : { error } };
+    const drop = setTimeout(() => {
+      dropTimers.delete(drop);
+      logins.delete(login.flow.id);
+      publishFlows();
+    }, finishedLoginTtlMs);
+    dropTimers.add(drop);
+    publishFlows();
+  };
+  const updateModelsFile = async (change) => {
+    const file = await readModelsFile(options.modelsPath);
+    change(file);
+    const tmp = `${options.modelsPath}.tmp`;
+    await mkdir5(dirname3(options.modelsPath), { recursive: true });
+    await writeFile4(tmp, `${JSON.stringify(file, null, 2)}
+`, { mode: 384 });
+    await rename4(tmp, options.modelsPath);
+    custom = customProviders(file);
+  };
+  const storeKey = async (providerId, key) => {
+    await runtime.login(providerId, "api_key", {
+      prompt: async () => key,
+      notify: () => {}
     });
-  }
+  };
+  let tail = Promise.resolve();
+  const serial = (operation) => {
+    const next = tail.then(operation, operation);
+    tail = next.catch(() => {});
+    return next;
+  };
   return {
     models,
     auth,
+    providers,
     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));
+      await runtime.logout(providerId);
+      await republish();
+    },
+    beginLogin(providerId, method) {
+      const provider = runtime.getProvider(providerId);
+      if (provider === undefined)
+        throw new Error(`Unknown provider "${providerId}"`);
+      const offered = method === "oauth" ? provider.auth.oauth !== undefined : provider.auth.apiKey?.login !== undefined;
+      if (!offered)
+        throw new Error(`${provider.name} has no ${method === "oauth" ? "sign-in" : "API key"} login`);
+      if ([...logins.values()].some((login2) => login2.flow.providerId === providerId && login2.flow.state === "running")) {
+        throw new Error(`A login for ${provider.name} is already in progress`);
+      }
+      const id = randomUUID2();
+      const login = {
+        flow: { id, providerId, method, events: [], state: "running" },
+        controller: new AbortController,
+        nextPromptId: 1
+      };
+      logins.set(id, login);
+      login.timer = setTimeout(() => {
+        login.controller.abort();
+        end(login, "failed", "The login timed out");
+      }, loginTimeoutMs);
+      runtime.login(providerId, method, {
+        signal: login.controller.signal,
+        notify(event) {
+          if (login.flow.state !== "running")
+            return;
+          login.flow = { ...login.flow, events: [...login.flow.events, toLoginEvent(event)] };
+          publishFlows();
+        },
+        prompt(prompt) {
+          return new Promise((resolve7, reject) => {
+            if (login.flow.state !== "running") {
+              reject(new Error("Login ended"));
+              return;
+            }
+            const promptId = login.nextPromptId++;
+            login.pending = { id: promptId, resolve: resolve7, reject };
+            login.flow = { ...login.flow, prompt: toLoginPrompt(promptId, prompt) };
+            publishFlows();
+            prompt.signal?.addEventListener("abort", () => {
+              if (login.pending?.id !== promptId)
+                return;
+              login.pending = undefined;
+              const { prompt: _, ...rest } = login.flow;
+              login.flow = rest;
+              reject(new Error("Prompt withdrawn"));
+              publishFlows();
+            }, { once: true });
+          });
+        }
+      }, { agentName: "PiNomad", getDeviceId: options.installId }).then(async () => {
+        await republish();
+        end(login, "succeeded");
+      }, (error) => {
+        if (login.controller.signal.aborted)
+          return;
+        end(login, "failed", error instanceof Error ? error.message : String(error));
+      });
+      publishFlows();
+      return id;
+    },
+    answerLogin(loginId, promptId, value) {
+      const login = logins.get(loginId);
+      if (login === undefined || login.flow.state !== "running")
+        throw new Error("This login has ended");
+      const pending = login.pending;
+      if (pending === undefined || pending.id !== promptId)
+        throw new Error("This prompt has moved on");
+      login.pending = undefined;
+      const { prompt: _, ...rest } = login.flow;
+      login.flow = rest;
+      publishFlows();
+      pending.resolve(value);
+    },
+    cancelLogin(loginId) {
+      const login = logins.get(loginId);
+      if (login === undefined || login.flow.state !== "running")
+        return;
+      login.controller.abort();
+      end(login, "cancelled");
+    },
+    saveCustomProvider: (input, apiKey) => serial(async () => {
+      if (!CUSTOM_ID.test(input.id))
+        throw new Error("Use lowercase letters, digits and - for the endpoint id");
+      if (BUILTIN.has(input.id))
+        throw new Error(`"${input.id}" is a built-in provider; pick another id`);
+      const name = input.name.trim();
+      if (name === "")
+        throw new Error("Name the endpoint");
+      let url;
+      try {
+        url = new URL(input.baseUrl);
+      } catch {
+        throw new Error("Enter a full base URL, like http://localhost:11434/v1");
+      }
+      if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("Use an http:// or https:// base URL");
+      const ids = [...new Set(input.models.map((model) => model.trim()).filter((model) => model !== ""))];
+      if (ids.length === 0)
+        throw new Error("Add at least one model");
+      const key = typeof apiKey === "string" && apiKey !== "" ? apiKey : apiKey !== null && custom.has(input.id) ? (await runtime.getAuth(input.id))?.auth.apiKey : undefined;
+      const reported = new Map((await fetchEndpointModels(input.api, input.baseUrl, key).catch(() => [])).map((model) => [model.id, model]));
+      await updateModelsFile((file) => {
+        const previous = file.providers[input.id] ?? {};
+        const previousModels = new Map((Array.isArray(previous.models) ? previous.models : []).map((model) => [model.id, model]));
+        file.providers[input.id] = {
+          ...previous,
+          name,
+          api: input.api,
+          baseUrl: input.baseUrl,
+          models: ids.map((id) => ({ ...reported.get(id), ...previousModels.get(id) ?? { id } }))
+        };
+      });
+      await runtime.refresh({ providers: [input.id], allowNetwork: false });
+      if (typeof apiKey === "string" && apiKey !== "")
+        await storeKey(input.id, apiKey);
+      else if (apiKey === null && (await runtime.listCredentials()).some((c) => c.providerId === input.id)) {
+        await runtime.logout(input.id);
+      }
+      await republish();
+    }),
+    removeCustomProvider: (providerId) => serial(async () => {
+      if (!custom.has(providerId))
+        throw new Error(`No custom endpoint "${providerId}"`);
+      if ((await runtime.listCredentials()).some((c) => c.providerId === providerId))
+        await runtime.logout(providerId);
+      await updateModelsFile((file) => {
+        delete file.providers[providerId];
+      });
+      await runtime.refresh({ providers: [providerId], allowNetwork: false });
+      await republish();
+    }),
+    async listEndpointModels(input) {
+      let key = input.apiKey;
+      if (key === undefined && input.providerId !== undefined && custom.has(input.providerId)) {
+        key = (await runtime.getAuth(input.providerId))?.auth.apiKey;
+      }
+      return (await fetchEndpointModels(input.api, input.baseUrl, key)).map((model) => model.id);
     },
     close() {
       closed = true;
-      clearTimeout(timer);
-      watcher?.close();
+      for (const login of logins.values()) {
+        clearTimeout(login.timer);
+        if (login.flow.state === "running")
+          login.controller.abort();
+      }
+      for (const timer of dropTimers)
+        clearTimeout(timer);
     }
   };
 }
+async function fetchEndpointModels(api, baseUrl, key) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const url = new URL(api === "anthropic-messages" ? `${base}/v1/models` : `${base}/models`);
+  const headers = { accept: "application/json" };
+  if (api === "anthropic-messages") {
+    headers["anthropic-version"] = "2023-06-01";
+    if (key !== undefined)
+      headers["x-api-key"] = key;
+  } else if (api === "google-generative-ai") {
+    if (key !== undefined)
+      url.searchParams.set("key", key);
+  } else if (key !== undefined) {
+    headers.authorization = `Bearer ${key}`;
+  }
+  let response;
+  try {
+    response = await fetch(url, { headers, signal: AbortSignal.timeout(ENDPOINT_TIMEOUT_MS) });
+  } catch (error) {
+    const reason = error instanceof Error ? error.cause?.message ?? error.message : String(error);
+    throw new Error(`Couldn't reach ${url.host} from the host: ${reason}`);
+  }
+  if (!response.ok)
+    throw new Error(`${url.host} answered ${response.status} for /models`);
+  const body = await response.json();
+  const models = api === "google-generative-ai" ? (body.models ?? []).flatMap((model) => typeof model.name === "string" ? [
+    endpointModel(model.name.replace(/^models\//, ""), {
+      contextWindow: positive(model.inputTokenLimit),
+      maxTokens: positive(model.outputTokenLimit),
+      reasoning: model.thinking === true,
+      image: false
+    })
+  ] : []) : (body.data ?? []).flatMap((model) => typeof model.id === "string" ? [
+    endpointModel(model.id, {
+      contextWindow: positive(model.context_window) ?? positive(model.context_length) ?? positive(model.max_input_tokens),
+      maxTokens: positive(model.max_output_tokens),
+      reasoning: model.reasoning === true,
+      image: Array.isArray(model.modalities?.input) && model.modalities.input.includes("image")
+    })
+  ] : []);
+  if (models.length === 0)
+    throw new Error(`${url.host} listed no models`);
+  return models;
+}
+var positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+function endpointModel(id, reported) {
+  return {
+    id,
+    ...reported.contextWindow === undefined ? {} : { contextWindow: reported.contextWindow },
+    ...reported.maxTokens === undefined ? {} : { maxTokens: reported.maxTokens },
+    ...reported.reasoning ? { reasoning: true } : {},
+    ...reported.image ? { input: ["text", "image"] } : {}
+  };
+}
 
 // apps/host/src/main.ts
 import { getSupportedThinkingLevels as getSupportedThinkingLevels3 } from "@earendil-works/pi-ai";
@@ -5121,6 +6643,8 @@ async function main(argv) {
       relay: { type: "string" }
     }
   });
+  if (values["public-url"] !== undefined)
+    validatePublicUrl(values["public-url"]);
   const dataDir = resolve7(values["data-dir"] ?? DEFAULT_DATA_DIR);
   let relayOrigin;
   try {
@@ -5129,6 +6653,8 @@ async function main(argv) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
+  if (relayOrigin !== undefined)
+    validateRelayOrigin(relayOrigin);
   const agentsHome = join12(homedir3(), ".agents");
   const extensionsFor = (models, summaries, options2) => (host2) => [
     createContext({
@@ -5194,9 +6720,10 @@ async function main(argv) {
     };
   }
   async function piOptions() {
-    const modelRuntime = await ModelRuntime.create();
-    const modelAuth = await watchModelAuth(modelRuntime, { authPath: join12(getAgentDir(), "auth.json") });
-    const settingsManager = SettingsManager.create(process.cwd());
+    const modelsPath = join12(dataDir, "models.json");
+    const modelRuntime = await ModelRuntime.create({ authPath: join12(dataDir, "auth.json"), modelsPath });
+    const modelAuth = await openModelAuth(modelRuntime, { modelsPath, installId: await installId(dataDir) });
+    const settingsManager = SettingsManager.inMemory(await piSettings(join12(dataDir, "settings.json")));
     configureHarnessHttp(settingsManager);
     const summaries = () => modelAuth.models.value;
     const images = await createNodePhotonImages();
@@ -5205,6 +6732,7 @@ async function main(argv) {
       models: modelRuntime,
       modelSummaries: summaries,
       modelAuth,
+      images,
       extensions: extensionsFor(modelRuntime, summaries, { images }),
       settings: (store) => createHarnessSettings(settingsManager, store),
       push: {},
@@ -5256,6 +6784,34 @@ async function main(argv) {
     host.close().finally(() => process.exit(1));
   });
 }
+async function piSettings(path) {
+  let text;
+  try {
+    text = await readFile7(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return {};
+    throw error;
+  }
+  let block;
+  try {
+    block = JSON.parse(text).pi;
+  } catch {
+    return {};
+  }
+  return typeof block === "object" && block !== null && !Array.isArray(block) ? block : {};
+}
+async function installId(dataDir) {
+  const path = join12(dataDir, "install-id");
+  let id = (await readFile7(path, "utf8").catch(() => "")).trim();
+  if (id === "") {
+    id = randomUUID3();
+    await mkdir6(dataDir, { recursive: true });
+    await writeFile5(path, `${id}
+`, { mode: 384 });
+  }
+  return () => id;
+}
 if (false)
   ;
 export {