pinomad 0.11.0 → 0.13.0

package/dist/{chunk-67gq282t.js → chunk-53xv3fny.js}

@@ -5,7 +5,7 @@ import {
   openHostSettings,
   sameList,
   settingsDefaults
-} from "./chunk-44pnts98.js";
+} from "./chunk-563fnad9.js";
 import {
   DevicesDoc,
   RevocationsDoc,
@@ -16,19 +16,21 @@ import {
   pairingOffers
 } from "./chunk-t91zt5f0.js";
 import {
+  REMOVAL_NOTICE_FILE,
+  markRemoved,
   normalizeOrigin,
   readServerBinding,
   readServerConfig,
   resolveRelayOrigin
-} from "./chunk-etf7ef97.js";
+} from "./chunk-nq57fdnq.js";
 import {
   serveWebClient
-} from "./chunk-wb10efyq.js";
+} from "./chunk-445cevpm.js";
 import {
   relayHostId,
   relayWsBase,
   startRelayLink
-} from "./chunk-y127fe1a.js";
+} from "./chunk-g3ahp7b9.js";
 import {
   ATTACHMENT_TTL_MS,
   INVALID_FRAME_CLOSE_CODE,
@@ -36,6 +38,7 @@ import {
   MAX_ATTACHMENT_NAME_LENGTH,
   MAX_PENDING_ATTACHMENTS,
   MAX_PENDING_ATTACHMENT_BYTES,
+  MAX_TRANSCRIPT_PAGE,
   PROTOCOL,
   RTC_DATA_CHANNEL_LABEL,
   RTC_DEFAULT_STUN,
@@ -54,7 +57,7 @@ import {
   rtcCandidateType,
   sdpCandidates,
   withRtcCandidates
-} from "./chunk-xqycs43g.js";
+} from "./chunk-kmzzjv53.js";
 import {
   ENDPOINT_SET_SCHEMA_VERSION,
   MAX_HOST_ENDPOINT_URL_LENGTH,
@@ -77,13 +80,13 @@ import {
 import {
   packagedVersion,
   webRoot
-} from "./chunk-sd5fkxjj.js";
+} from "./chunk-s0h7c7da.js";
 import {
   __require
 } from "./chunk-df32avw6.js";
 
 // apps/host/src/main.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } 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";
@@ -176,8 +179,10 @@ var QuestionWait = defineTask({
             resolve(initial);
             return;
           }
-          watch.start(async (value) => {
-            const found = resolutionOf(value, task.input.requestId);
+          watch.start(async (call) => {
+            if (call.kind !== "value")
+              return;
+            const found = resolutionOf(call.value, task.input.requestId);
             if (found !== undefined)
               resolve(found);
           });
@@ -712,11 +717,7 @@ async function checkoutInfo(harness, input, context) {
     }
   };
 }
-async function cleanupArchivedWorktrees(harness, rootId, context) {
-  const index = await harness.snapshot(IndexDoc, context);
-  const checkouts = index?.checkouts ?? [];
-  if (checkouts.length === 0)
-    return [];
+async function conversationSubtree(harness, rootId, context) {
   const all = [];
   let cursor;
   do {
@@ -743,6 +744,27 @@ async function cleanupArchivedWorktrees(harness, rootId, context) {
       }
     }
   }
+  return subtree;
+}
+async function familyRoot(harness, id, context) {
+  let current = id;
+  const seen = new Set;
+  while (!seen.has(current)) {
+    seen.add(current);
+    const record = await harness.commit((tx) => tx.conversation(current), context);
+    const parent = record?.parent?.conversationId ?? record?.owner?.conversationId;
+    if (parent === undefined)
+      return current;
+    current = parent;
+  }
+  return current;
+}
+async function cleanupArchivedWorktrees(harness, rootId, context) {
+  const index = await harness.snapshot(IndexDoc, context);
+  const checkouts = index?.checkouts ?? [];
+  if (checkouts.length === 0)
+    return [];
+  const subtree = await conversationSubtree(harness, rootId, context);
   const kept = [];
   for (const record of checkouts.filter((checkout) => subtree.has(checkout.conversationId))) {
     const reason = await removeWorktree(record);
@@ -1451,6 +1473,7 @@ var todo = {
 };
 
 // apps/host/src/gateway.ts
+import { stat as stat6 } from "node:fs/promises";
 import { createServer } from "node:http";
 import { homedir, networkInterfaces } from "node:os";
 import { join as join7, sep as sep5 } from "node:path";
@@ -2056,6 +2079,329 @@ function dataChannelCarrier(channel, timers, log, onClosed) {
   };
 }
 
+// apps/host/src/terminals.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { userInfo } from "node:os";
+var TERMINAL_LIMIT = 8;
+var BUFFER_SIZE = 512 * 1024;
+var FLUSH_MS = 8;
+var MAX_CHUNK = 16 * 1024;
+var MAX_TITLE = 1024;
+var TITLE = /\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
+
+class Terminals {
+  #options;
+  #limit;
+  #terminals = new Map;
+  #numbers = new Map;
+  #watchers = new Map;
+  constructor(options) {
+    this.#options = options;
+    this.#limit = options.limit ?? TERMINAL_LIMIT;
+  }
+  get limit() {
+    return this.#limit;
+  }
+  list(owner) {
+    const terminals = [...this.#terminals.values()].filter((terminal) => terminal.owner === owner).map(info);
+    return { owner, limit: this.#limit, terminals };
+  }
+  watch(owner, listener) {
+    let set = this.#watchers.get(owner);
+    if (set === undefined)
+      this.#watchers.set(owner, set = new Set);
+    set.add(listener);
+    listener(this.list(owner));
+    return () => {
+      set.delete(listener);
+      if (set.size === 0)
+        this.#watchers.delete(owner);
+    };
+  }
+  open(owner, cwd, size) {
+    const count = [...this.#terminals.values()].filter((terminal2) => terminal2.owner === owner).length;
+    if (count >= this.#limit)
+      throw new Error(`Terminal limit reached (${this.#limit})`);
+    const number = (this.#numbers.get(owner) ?? 0) + 1;
+    this.#numbers.set(owner, number);
+    const terminal = {
+      id: randomUUID2(),
+      owner,
+      cwd,
+      number,
+      pty: undefined,
+      generation: 0,
+      cols: size.cols,
+      rows: size.rows,
+      title: undefined,
+      rename: undefined,
+      exit: undefined,
+      buffer: "",
+      start: 0,
+      pending: "",
+      flushTimer: undefined,
+      titleCarry: "",
+      viewers: new Set
+    };
+    this.#terminals.set(terminal.id, terminal);
+    try {
+      this.#start(terminal);
+    } catch (error) {
+      this.#terminals.delete(terminal.id);
+      throw error;
+    }
+    this.#changed(owner);
+    return terminal.id;
+  }
+  input(id, data, size) {
+    const terminal = this.#get(id);
+    if (size !== undefined)
+      this.#resize(terminal, size);
+    terminal.pty?.write(data);
+  }
+  resize(id, size) {
+    this.#resize(this.#get(id), size);
+  }
+  rename(id, name) {
+    const terminal = this.#get(id);
+    const trimmed = name?.trim();
+    terminal.rename = trimmed === undefined || trimmed === "" ? undefined : trimmed;
+    this.#changed(terminal.owner);
+  }
+  restart(id, size) {
+    const terminal = this.#get(id);
+    this.#stop(terminal);
+    terminal.start += terminal.buffer.length + terminal.pending.length + 1;
+    terminal.buffer = "";
+    terminal.pending = "";
+    terminal.titleCarry = "";
+    terminal.title = undefined;
+    terminal.exit = undefined;
+    terminal.cols = size.cols;
+    terminal.rows = size.rows;
+    for (const viewer of terminal.viewers)
+      viewer.position = undefined;
+    try {
+      this.#start(terminal);
+    } catch (error) {
+      terminal.exit = { code: null };
+      this.#changed(terminal.owner);
+      throw error;
+    }
+    this.#changed(terminal.owner);
+  }
+  close(id) {
+    const terminal = this.#get(id);
+    this.#remove(terminal);
+    this.#changed(terminal.owner);
+  }
+  closeOwners(owners) {
+    for (const owner of new Set(owners)) {
+      const owned = [...this.#terminals.values()].filter((terminal) => terminal.owner === owner);
+      if (owned.length === 0)
+        continue;
+      for (const terminal of owned)
+        this.#remove(terminal);
+      this.#changed(owner);
+    }
+  }
+  closeAll() {
+    this.closeOwners([...this.#terminals.values()].map((terminal) => terminal.owner));
+  }
+  attach(id, since, sink) {
+    const terminal = this.#get(id);
+    const end = terminal.start + terminal.buffer.length;
+    const position = since !== undefined && since >= terminal.start && since <= end ? since : undefined;
+    const viewer = { sink, position, sending: false };
+    terminal.viewers.add(viewer);
+    this.#pump(terminal, viewer);
+    return () => {
+      terminal.viewers.delete(viewer);
+    };
+  }
+  #get(id) {
+    const terminal = this.#terminals.get(id);
+    if (terminal === undefined)
+      throw new Error("Unknown terminal");
+    return terminal;
+  }
+  #start(terminal) {
+    const generation = ++terminal.generation;
+    const { shell, env } = this.#options;
+    const pty = this.#options.spawn(shell.file, [...shell.args], {
+      name: "xterm-256color",
+      cols: terminal.cols,
+      rows: terminal.rows,
+      cwd: terminal.cwd,
+      env: { ...env, TERM: "xterm-256color", COLORTERM: "truecolor" }
+    });
+    terminal.pty = pty;
+    pty.onData((data) => {
+      if (terminal.generation !== generation)
+        return;
+      terminal.pending += data;
+      if (terminal.pending.length >= (this.#options.maxChunk ?? MAX_CHUNK))
+        this.#flush(terminal);
+      else
+        terminal.flushTimer ??= setTimeout(() => this.#flush(terminal), this.#options.flushMs ?? FLUSH_MS);
+    });
+    pty.onExit(({ exitCode, signal }) => {
+      if (terminal.generation !== generation || !this.#terminals.has(terminal.id))
+        return;
+      this.#flush(terminal);
+      terminal.pty = undefined;
+      terminal.exit = signal === undefined || signal === 0 ? { code: exitCode } : { code: exitCode, signal };
+      this.#changed(terminal.owner);
+    });
+  }
+  #stop(terminal) {
+    if (terminal.flushTimer !== undefined)
+      clearTimeout(terminal.flushTimer);
+    terminal.flushTimer = undefined;
+    terminal.generation++;
+    const pty = terminal.pty;
+    terminal.pty = undefined;
+    try {
+      pty?.kill();
+    } catch {}
+  }
+  #remove(terminal) {
+    this.#stop(terminal);
+    this.#terminals.delete(terminal.id);
+    for (const viewer of terminal.viewers)
+      viewer.sink.ended("Terminal closed");
+    terminal.viewers.clear();
+  }
+  #resize(terminal, size) {
+    if (terminal.cols === size.cols && terminal.rows === size.rows)
+      return;
+    terminal.cols = size.cols;
+    terminal.rows = size.rows;
+    try {
+      terminal.pty?.resize(size.cols, size.rows);
+    } catch {}
+    this.#changed(terminal.owner);
+  }
+  #flush(terminal) {
+    if (terminal.flushTimer !== undefined)
+      clearTimeout(terminal.flushTimer);
+    terminal.flushTimer = undefined;
+    const data = terminal.pending;
+    if (data === "")
+      return;
+    terminal.pending = "";
+    terminal.buffer += data;
+    const bufferSize = this.#options.bufferSize ?? BUFFER_SIZE;
+    if (terminal.buffer.length > bufferSize) {
+      let cut = terminal.buffer.length - bufferSize;
+      const line = terminal.buffer.indexOf(`
+`, cut);
+      if (line !== -1 && line - cut < 1024)
+        cut = line + 1;
+      terminal.buffer = terminal.buffer.slice(cut);
+      terminal.start += cut;
+    }
+    if (this.#readTitle(terminal, data))
+      this.#changed(terminal.owner);
+    for (const viewer of terminal.viewers)
+      this.#pump(terminal, viewer);
+  }
+  #readTitle(terminal, data) {
+    const text = terminal.titleCarry + data;
+    let title;
+    let consumed = 0;
+    for (const match of text.matchAll(TITLE)) {
+      title = match[1];
+      consumed = match.index + match[0].length;
+    }
+    const open = text.lastIndexOf("\x1B]");
+    terminal.titleCarry = open >= consumed && text.length - open <= MAX_TITLE ? text.slice(open) : "";
+    if (title === undefined || title === terminal.title)
+      return false;
+    terminal.title = title;
+    return terminal.rename === undefined;
+  }
+  async#pump(terminal, viewer) {
+    if (viewer.sending)
+      return;
+    viewer.sending = true;
+    try {
+      const maxChunk = this.#options.maxChunk ?? MAX_CHUNK;
+      while (terminal.viewers.has(viewer)) {
+        const end = terminal.start + terminal.buffer.length;
+        const reset = viewer.position === undefined || viewer.position < terminal.start;
+        const from = reset ? terminal.start : viewer.position;
+        if (!reset && from >= end)
+          return;
+        let to = reset ? end : Math.min(end, from + maxChunk);
+        if (to < end && isHighSurrogate(terminal.buffer.charCodeAt(to - terminal.start - 1)))
+          to--;
+        const data = terminal.buffer.slice(from - terminal.start, to - terminal.start);
+        viewer.position = to;
+        await viewer.sink.output(reset ? { seq: to, data, reset: true } : { seq: to, data });
+      }
+    } finally {
+      viewer.sending = false;
+    }
+  }
+  #changed(owner) {
+    const watchers = this.#watchers.get(owner);
+    if (watchers === undefined)
+      return;
+    const list = this.list(owner);
+    for (const watcher of watchers)
+      watcher(list);
+  }
+}
+async function startTerminals(options = {}) {
+  let spawn3 = options.spawn;
+  if (spawn3 === undefined) {
+    try {
+      const loaded = options.load === undefined ? await import("@lydell/node-pty") : await options.load();
+      if (typeof loaded.spawn !== "function")
+        throw new Error("the module has no spawn()");
+      spawn3 = loaded.spawn;
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      (options.diagnostic ?? console.error)(`Terminals unavailable: cannot load @lydell/node-pty on ${process.platform} (${process.arch}); missing @lydell/node-pty-${process.platform}-${process.arch}. Install without --omit=optional; the host continues without hello.terminals. (${detail})`);
+      return;
+    }
+  }
+  return new Terminals({ ...options, spawn: spawn3, shell: options.shell ?? loginShell(), env: options.env ?? shellEnv(process.env) });
+}
+function loginShell() {
+  let file = process.env.SHELL;
+  if (file === undefined || file === "") {
+    try {
+      file = userInfo().shell ?? undefined;
+    } catch {
+      file = undefined;
+    }
+  }
+  return { file: file === undefined || file === "" ? "/bin/sh" : file, args: ["-l"] };
+}
+function shellEnv(env) {
+  const result2 = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== undefined && !key.startsWith("PINOMAD_"))
+      result2[key] = value;
+  }
+  return result2;
+}
+function info(terminal) {
+  return {
+    id: terminal.id,
+    name: terminal.rename ?? terminal.title ?? `Terminal ${terminal.number}`,
+    renamed: terminal.rename !== undefined,
+    cols: terminal.cols,
+    rows: terminal.rows,
+    ...terminal.exit === undefined ? {} : { exit: terminal.exit }
+  };
+}
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+
 // apps/host/src/folders.ts
 import { readdir, realpath as realpath5, stat as stat5 } from "node:fs/promises";
 import { isAbsolute, join as join6 } from "node:path";
@@ -3186,24 +3532,29 @@ async function attachPushSender(options) {
     }
   };
   const unsubscribeConversations = conversations.subscribe(() => update());
-  const unsubscribeCommits = harness.subscribeCommits((publication) => {
-    for (const change of publication.changes) {
-      if (change.type !== "document" || change.record.kind !== TitleDoc.definition.kind)
-        continue;
-      const id = change.conversationId;
-      if (id === undefined)
-        continue;
-      const title = change.value?.title;
-      if (typeof title !== "string" || title === "")
-        continue;
-      const waiters = titleWaiters.get(id);
-      titleWaiters.delete(id);
-      for (const settle of waiters ?? [])
-        settle(title);
-    }
+  const commits = harness.observeCommits({
+    advance: (publication) => {
+      for (const change of publication.changes) {
+        if (change.type !== "document" || change.kind !== "change" || change.record.kind !== TitleDoc.definition.kind)
+          continue;
+        const id = change.conversationId;
+        if (id === undefined)
+          continue;
+        const title = change.value.title;
+        if (typeof title !== "string" || title === "")
+          continue;
+        const waiters = titleWaiters.get(id);
+        titleWaiters.delete(id);
+        for (const settle of waiters ?? [])
+          settle(title);
+      }
+    },
+    end: () => {}
   });
-  indexWatch?.start(async (value) => {
-    index = value ?? undefined;
+  indexWatch?.start(async (call) => {
+    if (call.kind !== "value")
+      return;
+    index = call.value;
     update();
   });
   update();
@@ -3212,7 +3563,7 @@ async function attachPushSender(options) {
     async close() {
       disposed = true;
       unsubscribeConversations();
-      unsubscribeCommits();
+      commits.detach();
       await indexWatch?.stop();
       for (const item of pending)
         drop(item);
@@ -3351,6 +3702,7 @@ async function startGateway(options) {
   const clients = new Set;
   let rtc;
   const rtcHello = () => rtc?.hello();
+  const terminals = await startTerminals(options.terminals);
   const broadcast = (level, message) => {
     for (const client of clients)
       client.send({ type: "notice", level, message });
@@ -3365,10 +3717,12 @@ async function startGateway(options) {
     }
     rtc?.closeDevice(publicKey);
   };
+  const reachableRelay = () => relay?.state().status === "removed" ? undefined : relay;
   const currentAdvertisement = () => {
     const advertiseUrl = remote?.advertiseUrl;
+    const relay2 = reachableRelay();
     const endpoints = remoteEndpointCandidates({
-      ...relay === undefined ? {} : { relay: { origin: relay.origin, hostId: relay.hostId } },
+      ...relay2 === undefined ? {} : { relay: { origin: relay2.origin, hostId: relay2.hostId } },
       ...advertiseUrl === undefined ? {} : { direct: { advertiseUrl } }
     });
     return { endpoints, ...advertiseUrl === undefined ? {} : { advertiseUrl } };
@@ -3385,6 +3739,7 @@ async function startGateway(options) {
     const client = new GatewayClient(connection, options, conversations, fileLister, skillLister, imageVariants, {
       devicePublicKey,
       rtcHello,
+      terminals,
       closed: (self) => {
         clients.delete(self);
         connections.delete(self);
@@ -3405,11 +3760,12 @@ async function startGateway(options) {
         const fragment = (secret2, target2, endpointSet2) => `${pair(secret2)}&url=${encodeURIComponent(target2)}${endpointSet2 === undefined ? "" : `&endpointSet=${encodeEndpointSetParam(endpointSet2)}`}`;
         const advertisement = currentAdvertisement();
         const endpointSet = checkedEndpointSet(advertisement.endpoints);
+        const relay2 = reachableRelay();
         const relayReachable = endpointSet.endpoints.some((endpoint) => endpoint.role === "relay");
-        if (relayReachable && relay !== undefined) {
+        if (relayReachable && relay2 !== undefined) {
           const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
           return {
-            url: `${relay.origin}/#${fragment(secret2, relaySocketTarget(relay.origin, relay.hostId), endpointSet)}`,
+            url: `${relay2.origin}/#${fragment(secret2, relaySocketTarget(relay2.origin, relay2.hostId), endpointSet)}`,
             expiresAt: expiresAt2
           };
         }
@@ -3422,10 +3778,10 @@ async function startGateway(options) {
           const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
           return { url: `${advertise}/#${fragment(secret2, direct.url, endpointSet)}`, expiresAt: expiresAt2 };
         }
-        if (relay !== undefined) {
+        if (relay2 !== undefined) {
           const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
           return {
-            url: `${relay.origin}/#${fragment(secret2, relaySocketTarget(relay.origin, relay.hostId))}`,
+            url: `${relay2.origin}/#${fragment(secret2, relaySocketTarget(relay2.origin, relay2.hostId))}`,
             expiresAt: expiresAt2
           };
         }
@@ -3519,6 +3875,10 @@ async function startGateway(options) {
   });
   if (secure?.relay !== undefined) {
     const relayOrigin = secure.relay.origin;
+    const startConfig = await readServerConfig(options.dataDir).catch(() => {
+      return;
+    });
+    const linkJoin = startConfig !== undefined && normalizeOrigin(startConfig.origin) === normalizeOrigin(relayOrigin) ? startConfig : undefined;
     const currentBinding = async () => {
       const config = await readServerConfig(options.dataDir).catch(() => {
         return;
@@ -3572,6 +3932,16 @@ async function startGateway(options) {
           console.log(JSON.stringify({ event: "relay", status: "registered", origin: link.origin, hostId: link.hostId, push }));
         } else if (state.status === "connecting") {
           console.log(JSON.stringify({ event: "relay", status: "connecting", origin: link.origin }));
+        } else if (state.status === "removed") {
+          broadcast("warning", state.reason);
+          console.error(state.reason);
+          markRemoved(options.dataDir, {
+            origin: relayOrigin,
+            ...linkJoin?.binding === undefined ? {} : { binding: linkJoin.binding },
+            ...linkJoin?.username === undefined ? {} : { username: linkJoin.username }
+          }).catch((error) => {
+            console.error(`could not write ${REMOVAL_NOTICE_FILE}: ${error instanceof Error ? error.message : String(error)}`);
+          });
         } else {
           broadcast("warning", state.reason);
           console.error(state.reason);
@@ -3606,6 +3976,7 @@ async function startGateway(options) {
       detachSettingsWatch();
       await detachPush?.close();
       conversations.dispose();
+      terminals?.closeAll();
       await rtc?.close();
       await Promise.all([...connections].map((connection) => connection.dispose()));
       for (const socket of server.clients)
@@ -3908,12 +4279,16 @@ class ConversationList {
   #list = [];
   #unsubscribe = () => {};
   #notifying = false;
+  #harness;
+  #live = new Map;
+  #disposed = false;
   constructor(docs) {
     this.#questionTokens = (docs ?? []).filter((doc) => doc.presentation === "pinomad.question").map((doc) => doc.token);
     this.#questionKinds = new Set(this.#questionTokens.map((token) => token.definition.kind));
   }
   static async open(harness, docs) {
     const list = new ConversationList(docs);
+    list.#harness = harness;
     const summaries = [];
     let cursor;
     const records = [];
@@ -3932,10 +4307,13 @@ class ConversationList {
       summaries.push(list.#summaryOf(record));
     }
     list.#list = summaries;
-    list.#unsubscribe = harness.subscribeCommits((publication) => list.#observe(publication));
+    const observation = harness.observeCommits({ advance: (publication) => list.#observe(publication), end: () => {} });
+    list.#unsubscribe = () => observation.detach();
     const touched = new Set;
     list.#reindex(await harness.snapshot(IndexDoc, context3), touched);
     list.#refreshSummaries(touched);
+    for (const [id, facts] of list.#facts)
+      list.#followLive(id, facts.running === true);
     return list;
   }
   async#load(harness, record) {
@@ -3956,6 +4334,7 @@ class ConversationList {
         facts.label = subagent.label;
       if (typeof subagent?.role === "string" && subagent.role !== "")
         facts.role = subagent.role;
+      facts.model = modelRefOf(subagent?.model);
     }
     facts.agent = roleNameOf(await harness.snapshot(RoleDoc, record.id, context3));
     const named = (await harness.snapshot(TitleDoc, record.id, context3))?.title;
@@ -3990,22 +4369,23 @@ class ConversationList {
         facts.calls = entry.kind === "pi.assistant" ? callsOf(message) : undefined;
       } else if (change.type === "document") {
         const id = change.conversationId;
+        const value = change.kind === "change" ? change.value : null;
         if (id === undefined) {
           if (change.record.kind === IndexDoc.definition.kind)
-            this.#reindex(change.value, touched);
+            this.#reindex(value, touched);
           continue;
         }
         const facts = this.#fact(id);
         if (change.record.kind === "pi.live") {
-          const live = change.value;
+          const live = value;
           const wasRunning = facts.running === true;
           facts.running = live?.run !== undefined;
           facts.tools = live?.tools;
           touched.add(id);
+          this.#followLive(id, facts.running);
           if (wasRunning && !facts.running && this.#records.get(id)?.owner === undefined)
             ended.add(id);
         } else if (this.#questionKinds.has(change.record.kind)) {
-          const value = change.value;
           const pending = Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined);
           const next = new Set(facts.pending);
           if (pending)
@@ -4015,15 +4395,16 @@ class ConversationList {
           facts.pending = next;
           touched.add(id);
         } else if (change.record.kind === RoleDoc.definition.kind) {
-          facts.agent = roleNameOf(change.value);
+          facts.agent = roleNameOf(value);
           touched.add(id);
         } else if (change.record.kind === SubagentDoc.definition.kind) {
-          const value = change.value;
-          facts.label = typeof value?.label === "string" && value.label !== "" ? value.label : undefined;
-          facts.role = typeof value?.role === "string" && value.role !== "" ? value.role : undefined;
+          const subagent = value;
+          facts.label = typeof subagent?.label === "string" && subagent.label !== "" ? subagent.label : undefined;
+          facts.role = typeof subagent?.role === "string" && subagent.role !== "" ? subagent.role : undefined;
+          facts.model = modelRefOf(subagent?.model);
           touched.add(id);
         } else if (change.record.kind === TitleDoc.definition.kind) {
-          const named = change.value?.title;
+          const named = value?.title;
           facts.named = typeof named === "string" && named !== "" ? named : undefined;
           touched.add(id);
         }
@@ -4098,9 +4479,51 @@ class ConversationList {
         listener(this.#list);
     });
   }
+  #followLive(id, running) {
+    if (!running || this.#disposed) {
+      const watch = this.#live.get(id);
+      this.#live.delete(id);
+      watch?.stop();
+      return;
+    }
+    if (this.#live.has(id))
+      return;
+    this.#live.set(id, undefined);
+    setImmediate(() => {
+      this.#harness.watchDoc(LiveDoc, id, context3).then(async (watch) => {
+        if (watch === undefined)
+          return;
+        if (this.#live.get(id) !== undefined || !this.#live.has(id)) {
+          await watch.stop();
+          return;
+        }
+        this.#live.set(id, watch);
+        const apply = (live) => {
+          const facts = this.#fact(id);
+          if (live.run === undefined)
+            return;
+          facts.tools = live.tools;
+          this.#refreshSummaries(new Set([id]));
+        };
+        apply(watch.value);
+        watch.start(async (call) => {
+          if (call.kind === "value")
+            apply(call.value);
+        });
+      }, (error) => {
+        if (this.#live.get(id) === undefined)
+          this.#live.delete(id);
+        console.error(`conversation ${id}: could not follow pi.live: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    });
+  }
   dispose() {
+    this.#disposed = true;
     this.#unsubscribe();
     this.#listeners.clear();
+    for (const watch of this.#live.values())
+      watch?.stop();
+    this.#live.clear();
   }
 }
 function roleNameOf(value) {
@@ -4108,6 +4531,14 @@ function roleNameOf(value) {
     return;
   return typeof value.name === "string" ? value.name : value.name === null ? null : undefined;
 }
+function modelRefOf(value) {
+  if (typeof value !== "string")
+    return;
+  const slash = value.indexOf("/");
+  if (slash <= 0 || slash === value.length - 1)
+    return;
+  return { provider: value.slice(0, slash), modelId: value.slice(slash + 1) };
+}
 function rolesOf(index) {
   const roles = new Map;
   for (const entry of index?.conversations ?? []) {
@@ -4138,6 +4569,8 @@ function summaryOf(record, facts, role, currentAgent) {
   return {
     id: record.id,
     kind: record.owner !== undefined ? "subagent" : record.parent !== undefined ? "fork" : "conversation",
+    ...record.owner === undefined ? {} : { lifecycle: "foreground" },
+    ...facts.model === undefined ? {} : { model: facts.model },
     ...parent === undefined ? {} : { parent },
     ...record.parent === undefined ? {} : { forkedAt: String(record.parent.at) },
     ...(facts.named ?? facts.title) === undefined ? {} : { title: facts.named ?? facts.title },
@@ -4150,7 +4583,7 @@ function summaryOf(record, facts, role, currentAgent) {
   };
 }
 function sameSummary(a, b) {
-  return a.id === b.id && a.kind === b.kind && a.parent === b.parent && a.forkedAt === b.forkedAt && a.title === b.title && a.status === b.status && a.updatedAt === b.updatedAt && a.label === b.label && a.role === b.role && a.currentAgent === b.currentAgent && a.activity?.tool === b.activity?.tool && a.activity?.target === b.activity?.target;
+  return a.id === b.id && a.kind === b.kind && a.lifecycle === b.lifecycle && a.model?.provider === b.model?.provider && a.model?.modelId === b.model?.modelId && a.parent === b.parent && a.forkedAt === b.forkedAt && a.title === b.title && a.status === b.status && a.updatedAt === b.updatedAt && a.label === b.label && a.role === b.role && a.currentAgent === b.currentAgent && a.activity?.tool === b.activity?.tool && a.activity?.target === b.activity?.target;
 }
 function titleOf(entry) {
   const message = entry?.model?.[0];
@@ -4159,6 +4592,38 @@ function titleOf(entry) {
   const title = stripUserBlocks(message.content).text.replace(/\s+/g, " ").trim();
   return title === "" ? {} : { title };
 }
+var WHOLE_TRANSCRIPT = { min: Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER };
+var TURN_STARTS = new Set(["pi.user", "pi.compaction", "pi.reset"]);
+async function turnPage(conversation, before, limit) {
+  const want = Math.min(limit, MAX_TRANSCRIPT_PAGE);
+  const done = (taken2) => taken2.length >= MAX_TRANSCRIPT_PAGE || taken2.length >= want && TURN_STARTS.has(taken2.at(-1).kind);
+  const query = { order: "descending", ...before === undefined ? {} : { maxEntryId: before } };
+  const taken = [];
+  let cursor;
+  for (;; ) {
+    const page = await conversation.entries(query, Math.max(want + 1 - taken.length, 64), cursor, context3);
+    for (const entry of page.items) {
+      if (done(taken))
+        return { entries: taken.reverse(), before: entry.id };
+      taken.push(entry);
+    }
+    if (page.next === undefined)
+      return { entries: taken.reverse() };
+    cursor = page.next;
+  }
+}
+async function viewWindow(conversation, window) {
+  if (window === undefined)
+    return WHOLE_TRANSCRIPT;
+  const from = window.from ?? await startOf(conversation, window.limit);
+  return from === undefined ? WHOLE_TRANSCRIPT : { ...WHOLE_TRANSCRIPT, from };
+}
+async function startOf(conversation, limit) {
+  const page = await turnPage(conversation, undefined, limit);
+  return page.before === undefined ? undefined : page.entries[0].id;
+}
+var shownOps = (call) => isGone(call) ? [["r", null]] : call.ops;
+var isGone = (call) => call.retired && !call.ops.some((op) => op[0] === "r");
 async function historyFacts(harness, id) {
   const conversation = await harness.conversation(id, context3);
   let first;
@@ -4293,6 +4758,7 @@ class GatewayClient {
   }
   #hostValues;
   #subscriptions = new Map;
+  #terminalSizes = new Map;
   #disposed = false;
   constructor(connection, options, conversations, files, skills, imageVariants, hooks) {
     this.#connection = connection;
@@ -4355,7 +4821,8 @@ class GatewayClient {
       })),
       toolPresentations: options.toolPresentations ?? {},
       endpointSet: this.#hooks.endpointSet(),
-      ...rtc === undefined ? {} : { rtc }
+      ...rtc === undefined ? {} : { rtc },
+      ...this.#hooks.terminals === undefined ? {} : { terminals: { limit: this.#hooks.terminals.limit } }
     });
   }
   send(frame) {
@@ -4368,15 +4835,19 @@ class GatewayClient {
   }
   async#receive(frame) {
     if (frame.type === "subscribe")
-      await this.#subscribe(frame.stream, frame.images === "ref");
+      await this.#subscribe(frame.stream, frame.images === "ref", frame.since, frame.window);
     else if (frame.type === "unsubscribe")
       await this.#unsubscribe(frame.stream);
     else
       await this.#answer(frame.id, frame.method, frame.args);
   }
-  async#subscribe(stream, imageRefs) {
+  async#subscribe(stream, imageRefs, since, window) {
     const previous = this.#subscriptions.get(stream);
-    const state = imageRefs && stream.startsWith("conversation:") ? { images: new ImageRefs } : {};
+    const state = {
+      ...imageRefs && stream.startsWith("conversation:") ? { images: new ImageRefs } : {},
+      ...since === undefined ? {} : { since },
+      ...window === undefined ? {} : { window }
+    };
     this.#subscriptions.set(stream, state);
     const current = () => !this.#disposed && this.#subscriptions.get(stream) === state;
     const send = (frame) => current() ? this.send(frame) : Promise.resolve();
@@ -4420,12 +4891,30 @@ class GatewayClient {
     }
     if (stream === "tasks")
       return this.#forward(stream, await this.#options.harness.watchTaskGraph(context3), send);
+    if (stream.startsWith("terminals:")) {
+      const terminals = this.#terminals();
+      const conversation2 = await this.#conversation(Number(stream.slice("terminals:".length)));
+      const { owner } = await this.#terminalOwner(conversation2);
+      return { stop: terminals.watch(owner, (value) => void send({ type: "snapshot", stream, value })) };
+    }
+    if (stream.startsWith("terminal:")) {
+      const terminalStream = stream;
+      const detach = this.#terminals().attach(terminalStream.slice("terminal:".length), state?.since, {
+        output: (frame) => send({ type: "output", stream: terminalStream, ...frame }),
+        ended: (reason) => {
+          send({ type: "ended", stream, reason });
+          if (this.#subscriptions.get(stream) === state)
+            this.#subscriptions.delete(stream);
+        }
+      });
+      return { stop: detach };
+    }
     if (stream.startsWith("doc:")) {
       const at = stream.lastIndexOf(":");
       return this.#openDoc(stream, stream.slice("doc:".length, at), Number(stream.slice(at + 1)), send);
     }
     const conversation = await this.#conversation(Number(stream.slice("conversation:".length)));
-    return this.#forward(stream, await conversation.watch(context3), send, state);
+    return this.#forward(stream, await conversation.watch(context3, await viewWindow(conversation, state?.window)), send, state);
   }
   #hostValue(stream) {
     return Object.hasOwn(this.#hostValues, stream) ? this.#hostValues[stream] : undefined;
@@ -4443,13 +4932,17 @@ class GatewayClient {
     });
     let inner;
     let stopped = false;
-    const unsubscribe = harness.subscribeCommits((publication) => {
-      const matches = publication.changes.some((change) => (change.type === "document" || change.type === "document.copy") && change.record.kind === kind && change.conversationId === id);
-      if (!matches)
-        return;
-      unsubscribe();
-      setImmediate(() => signalCreation());
+    const observation = harness.observeCommits({
+      advance: (publication) => {
+        const matches = publication.changes.some((change) => (change.type === "document" || change.type === "document.copy") && change.record.kind === kind && change.conversationId === id);
+        if (!matches)
+          return;
+        unsubscribe();
+        setImmediate(() => signalCreation());
+      },
+      end: () => {}
     });
+    const unsubscribe = () => observation.detach();
     try {
       const existing = await harness.watchDoc(token, id, context3);
       if (existing !== undefined) {
@@ -4490,16 +4983,19 @@ class GatewayClient {
   async#forward(stream, watch, send, state) {
     if (state?.images === undefined) {
       await send({ type: "snapshot", stream, value: watch.value });
-      watch.start((_value, ops) => send({ type: "ops", stream, ops }));
+      watch.start((call) => call.kind === "value" ? send({ type: "ops", stream, ops: shownOps(call) }) : Promise.resolve());
       return watch;
     }
     const images = state.images;
     let before = watch.value;
     state.view = before;
     await send({ type: "snapshot", stream, value: await images.value(before) });
-    watch.start(async (value, ops) => {
+    watch.start(async (call) => {
+      if (call.kind !== "value")
+        return;
+      const ops = shownOps(call);
       const sent = await images.ops(ops, before);
-      before = value;
+      before = isGone(call) ? null : call.value;
       state.view = before;
       return send({ type: "ops", stream, ops: sent });
     });
@@ -4509,7 +5005,7 @@ class GatewayClient {
     for (const state of this.#subscriptions.values()) {
       if (state.images === undefined || state.view === undefined)
         continue;
-      const image = state.images.image(state.view, ref);
+      const image = state.images.image(state.view, ref) ?? (state.earlier === undefined ? undefined : state.images.image({ entries: state.earlier }, ref));
       if (image !== undefined)
         return image;
     }
@@ -4569,10 +5065,43 @@ class GatewayClient {
       await this.send({ type: "result", id, ok: true, value: value ?? null });
     } catch (error) {
       await this.send({ type: "result", id, ok: false, error: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    const device = this.devicePublicKey;
+    if (method === "revokeDevice" && device !== undefined && args.publicKey === device) {
+      this.#hooks.closeDevice(device);
     }
   }
   async#call(method, args) {
     switch (method) {
+      case "terminalInput": {
+        const input = args;
+        this.#terminals().input(input.terminalId, input.data, this.#terminalSizes.get(input.terminalId));
+        return null;
+      }
+      case "resizeTerminal": {
+        const input = args;
+        const size = { cols: input.cols, rows: input.rows };
+        this.#terminals().resize(input.terminalId, size);
+        this.#terminalSizes.set(input.terminalId, size);
+        return null;
+      }
+      case "renameTerminal": {
+        const input = args;
+        this.#terminals().rename(input.terminalId, input.name);
+        return null;
+      }
+      case "restartTerminal": {
+        const input = args;
+        const size = { cols: input.cols, rows: input.rows };
+        this.#terminals().restart(input.terminalId, size);
+        this.#terminalSizes.set(input.terminalId, size);
+        return null;
+      }
+      case "closeTerminal":
+        this.#terminals().close(args.terminalId);
+        this.#terminalSizes.delete(args.terminalId);
+        return null;
       case "addProject":
         return addProject(this.#options.harness, args.path, context3);
       case "removeProject":
@@ -4636,6 +5165,7 @@ class GatewayClient {
         const input = args;
         await archive(this.#options.harness, input.conversationId, input.archived, context3);
         if (input.archived) {
+          this.#hooks.terminals?.closeOwners(await conversationSubtree(this.#options.harness, input.conversationId, context3));
           const kept = await cleanupArchivedWorktrees(this.#options.harness, input.conversationId, context3);
           for (const { record, reason } of kept) {
             await this.send({ type: "notice", level: "warning", message: `Kept worktree ${record.path} (branch ${record.branch}): ${reason}` });
@@ -4652,7 +5182,8 @@ class GatewayClient {
       case "revokeDevice": {
         const { publicKey } = args;
         await revokeDevice(this.#options.harness, publicKey, context3);
-        this.#hooks.closeDevice(publicKey);
+        if (publicKey !== this.devicePublicKey)
+          this.#hooks.closeDevice(publicKey);
         return null;
       }
       case "rtcOffer": {
@@ -4738,6 +5269,26 @@ class GatewayClient {
         const input = args;
         return listSkills(this.#options.harness, this.#skills, input.scope, context3);
       }
+      case "earlierEntries": {
+        const { conversationId, before, limit } = args;
+        const stream = `conversation:${conversationId}`;
+        const state = this.#subscriptions.get(stream);
+        if (state === undefined)
+          throw new Error(`Not subscribed to conversation ${conversationId}`);
+        const replaced = () => this.#subscriptions.get(stream) !== state;
+        const resubscribed = () => new Error(`Conversation ${conversationId} was resubscribed while its page loaded`);
+        const page = await turnPage(await this.#conversation(conversationId), before, limit);
+        if (replaced())
+          throw resubscribed();
+        if (state.images === undefined)
+          return page;
+        const raw = page.entries;
+        const { entries } = await state.images.value({ entries: raw });
+        if (replaced())
+          throw resubscribed();
+        state.earlier = [...state.earlier ?? [], ...raw];
+        return { ...page, entries };
+      }
       case "image": {
         const input = args;
         const image = this.#shownImage(input.ref);
@@ -4799,6 +5350,37 @@ class GatewayClient {
           return { outcome: "steered" };
         }, context3);
       }
+      case "reorderQueued": {
+        const { conversationId, submissionId, before } = args;
+        return await this.#options.harness.commit(async (tx) => {
+          const queuedState = async (id) => {
+            const record = await tx.submission(id);
+            if (record === undefined)
+              throw new Error(`Submission ${id} does not exist`);
+            assertQueuedInput(record, conversationId);
+            if (record.entry !== undefined)
+              return "sent";
+            return record.status === "queued" ? "queued" : "unavailable";
+          };
+          const moved = await queuedState(submissionId);
+          if (moved !== "queued")
+            return { outcome: moved };
+          if (before !== undefined && await queuedState(before) !== "queued") {
+            return { outcome: "unavailable" };
+          }
+          if (before === submissionId)
+            return { outcome: "moved" };
+          const items = (await tx.doc(InboxDoc, conversationId)).items;
+          const from = items.findIndex((candidate) => candidate.id === submissionId);
+          if (from < 0 || before !== undefined && !items.some((candidate) => candidate.id === before)) {
+            return { outcome: "unavailable" };
+          }
+          const [item] = items.splice(from, 1);
+          const to = before === undefined ? items.findLastIndex((candidate) => candidate.mode !== "write") + 1 : items.findIndex((candidate) => candidate.id === before);
+          items.splice(to, 0, item);
+          return { outcome: "moved" };
+        }, context3);
+      }
       case "renameConversation": {
         const { title } = args;
         const trimmed = title.trim();
@@ -4935,8 +5517,34 @@ class GatewayClient {
       case "changes": {
         return await this.#changes(conversation, context3);
       }
+      case "openTerminal": {
+        const input = args;
+        const terminals = this.#terminals();
+        const { owner, cwd, record } = await this.#terminalOwner(conversation);
+        const ready = record === undefined || await worktreeSettled(record);
+        if (!ready || !await stat6(cwd).then((info2) => info2.isDirectory(), () => false)) {
+          throw new Error(`The checkout is unavailable: ${cwd}`);
+        }
+        const size = { cols: input.cols, rows: input.rows };
+        const terminalId = terminals.open(owner, cwd, size);
+        this.#terminalSizes.set(terminalId, size);
+        return { terminalId };
+      }
     }
   }
+  #terminals() {
+    if (this.#hooks.terminals === undefined)
+      throw new Error("Terminals are unavailable on this host");
+    return this.#hooks.terminals;
+  }
+  async#terminalOwner(conversation) {
+    const cwd = (await conversation.agent(context3)).cwd;
+    if (cwd === undefined)
+      throw new Error("No working directory");
+    const record = checkoutAt((await this.#options.harness.snapshot(IndexDoc, context3))?.checkouts, cwd);
+    const owner = record?.conversationId ?? await familyRoot(this.#options.harness, conversation.id, context3);
+    return { owner, cwd, record };
+  }
   async#expandSkills(text, scope, bound) {
     if (bound === undefined ? !text.includes("$") : bound.length === 0)
       return text;
@@ -5524,7 +6132,7 @@ import {
   readdir as readdir3,
   rename as rename2,
   rm as rm3,
-  stat as stat6,
+  stat as stat7,
   writeFile as writeFile2
 } from "node:fs/promises";
 import { basename as basename2, join as join9, resolve as resolve6 } from "node:path";
@@ -5713,7 +6321,7 @@ class AttachmentStore {
         throw new Error(problem);
       const decoded = base64DecodedLength(data);
       const path = this.#dataPath(meta);
-      const received = (await stat6(path)).size;
+      const received = (await stat7(path)).size;
       if (received === meta.size) {
         await chmod(path, 292);
         await this.#writeMeta({ ...meta, state: "complete" });
@@ -5756,13 +6364,13 @@ class AttachmentStore {
         if (meta.state === "uploading")
           throw new Error(`Attachment ${index + 1} is still uploading`);
         const path = this.#dataPath(meta);
-        let info;
+        let info2;
         try {
-          info = await lstat(path);
+          info2 = await lstat(path);
         } catch {
           throw new Error(`Attachment ${index + 1} is unavailable; attach it again`);
         }
-        if (!info.isFile() || info.size !== meta.size) {
+        if (!info2.isFile() || info2.size !== meta.size) {
           throw new Error(`Attachment ${index + 1} is unavailable; attach it again`);
         }
         checked.push({ meta, path });
@@ -5805,7 +6413,7 @@ class AttachmentStore {
         } else {
           this.#pending.delete(entry.name);
           try {
-            if (now - (await stat6(directory)).mtimeMs <= this.#ttlMs)
+            if (now - (await stat7(directory)).mtimeMs <= this.#ttlMs)
               continue;
           } catch {
             continue;
@@ -6004,6 +6612,7 @@ async function openHost(options) {
         }
       },
       ...options.rtc === undefined ? {} : { rtc: options.rtc },
+      ...options.terminals === undefined ? {} : { terminals: options.terminals },
       secure: {
         hostKey,
         offers,
@@ -6085,7 +6694,7 @@ async function openHost(options) {
 }
 
 // apps/host/src/service/log-rotation.ts
-import { copyFile, rename as rename3, rm as rm4, stat as stat7, truncate } from "node:fs/promises";
+import { copyFile, rename as rename3, rm as rm4, stat as stat8, truncate } from "node:fs/promises";
 import { join as join11 } from "node:path";
 var HOST_LOG_MAX_BYTES = 10 * 1024 * 1024;
 var HOST_LOG_HISTORY = 3;
@@ -6099,7 +6708,7 @@ async function rotateHostLog(dataDir, copy = copyFile) {
   await rm4(temp, { force: true });
   let size;
   try {
-    size = (await stat7(log)).size;
+    size = (await stat8(log)).size;
   } catch (error) {
     if (isMissing(error))
       return false;
@@ -6147,7 +6756,7 @@ function startHostLogRotation(dataDir) {
 }
 
 // apps/host/src/model-auth.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } 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";
@@ -6430,6 +7039,45 @@ async function openModelAuth(runtime, options) {
     tail = next.catch(() => {});
     return next;
   };
+  const opened = await readModelsFile(options.modelsPath);
+  Promise.all([...custom].flatMap(([id, endpoint]) => {
+    const entries = opened.providers[id]?.models;
+    if (!Array.isArray(entries) || !entries.some(lacksLimits))
+      return [];
+    return [
+      (async () => {
+        const key = (await runtime.getAuth(id))?.auth.apiKey;
+        const listed = await fetchEndpointModels(endpoint.api, endpoint.baseUrl, key).catch(() => []);
+        return { id, endpoint, listed: new Map(listed.map((model) => [model.id, model])) };
+      })()
+    ];
+  })).then((answers) => serial(async () => {
+    if (closed)
+      return;
+    const filled = new Set;
+    const fill = (target) => {
+      for (const { id, endpoint, listed } of answers) {
+        const entry = target.providers[id];
+        if (entry?.api !== endpoint.api || entry.baseUrl !== endpoint.baseUrl || !Array.isArray(entry.models))
+          continue;
+        for (const model of entry.models) {
+          const limits = listed.get(model.id);
+          for (const field of LIMITS) {
+            if (field in model || limits?.[field] === undefined)
+              continue;
+            model[field] = limits[field];
+            filled.add(id);
+          }
+        }
+      }
+    };
+    fill(await readModelsFile(options.modelsPath));
+    if (filled.size === 0)
+      return;
+    await updateModelsFile(fill);
+    await runtime.refresh({ providers: [...filled], allowNetwork: false });
+    await republish();
+  }));
   return {
     models,
     auth,
@@ -6451,7 +7099,7 @@ async function openModelAuth(runtime, options) {
       if ([...logins.values()].some((login2) => login2.flow.providerId === providerId && login2.flow.state === "running")) {
         throw new Error(`A login for ${provider.name} is already in progress`);
       }
-      const id = randomUUID2();
+      const id = randomUUID3();
       const login = {
         flow: { id, providerId, method, events: [], state: "running" },
         controller: new AbortController,
@@ -6635,6 +7283,8 @@ async function fetchEndpointModels(api, baseUrl, key) {
     throw new Error(`${url.host} listed no models`);
   return models;
 }
+var LIMITS = ["contextWindow", "maxTokens"];
+var lacksLimits = (model) => typeof model === "object" && model !== null && LIMITS.some((field) => !(field in model));
 var positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
 function endpointModel(id, reported) {
   return {
@@ -6795,7 +7445,7 @@ async function main(argv) {
   process.on("SIGINT", stop);
   process.on("SIGTERM", stop);
   host.closed.then((end) => {
-    if (end.reason !== "failed" || stopping)
+    if (end.kind !== "failed" || stopping)
       return;
     stopping = true;
     stopLogRotation();
@@ -6826,7 +7476,7 @@ async function installId(dataDir) {
   const path = join12(dataDir, "install-id");
   let id = (await readFile7(path, "utf8").catch(() => "")).trim();
   if (id === "") {
-    id = randomUUID3();
+    id = randomUUID4();
     await mkdir6(dataDir, { recursive: true });
     await writeFile5(path, `${id}
 `, { mode: 384 });