pinomad 0.3.0 → 0.4.0

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

@@ -1,11 +1,21 @@
 #!/usr/bin/env node
+import {
+  normalizeOrigin,
+  readServerBinding,
+  readServerConfig,
+  resolveRelayOrigin
+} from "./chunk-302y6by9.js";
 import {
   serveWebClient
 } from "./chunk-r6w5aqkw.js";
+import {
+  relayWsBase,
+  startRelayLink
+} from "./chunk-knaw1a9g.js";
 import {
   packagedVersion,
   webRoot
-} from "./chunk-3tf23vjq.js";
+} from "./chunk-fgx2sh7d.js";
 import {
   HOST_SETTING_KEYS,
   INVALID_FRAME_CLOSE_CODE,
@@ -14,31 +24,26 @@ import {
   UNAUTHORIZED_CLOSE_CODE,
   isQueueMode,
   isThinkingLevel,
+  organize,
   parseClientFrame
-} from "./chunk-c155p0t0.js";
+} from "./chunk-myjp910s.js";
 import {
   DevicesDoc,
+  RevocationsDoc,
+  admitDevice,
   ensureDevices,
-  isRegistered,
   loadHostKey,
   loadRelayKey,
-  pairingOffers,
-  registerDevice,
-  revokeDevice
-} from "./chunk-fxaewke2.js";
+  pairingOffers
+} from "./chunk-837gh8nr.js";
 import {
-  RELAY_CLOSE,
   SECURE_PROLOGUE,
   SecureSession,
   decodeClientHello,
-  decodeRelayToHost,
   encodeHostHello,
-  encodeRelayFrame,
-  relayHostId,
   respondIK,
-  signRelayChallenge,
   toBase64Url
-} from "./chunk-z4x88s0q.js";
+} from "./chunk-7gmkgyaz.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-cjfmfyjb.js";
@@ -522,7 +527,7 @@ var todo = {
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
 import { basename as basename2, join as join7, sep as sep4 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
+import { 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";
 
@@ -1366,10 +1371,12 @@ var fileValueError = (key, value, models) => {
     case "steeringMode":
     case "followUpMode":
       return isQueueMode(value) ? undefined : "malformed";
+    case "acceptAccountDevices":
+      return typeof value === "boolean" ? undefined : "malformed";
   }
 };
 var sameModel = (a, b) => a === b || a !== null && b !== null && a.provider === b.provider && a.modelId === b.modelId;
-var sameSettings = (a, b) => a.steeringMode === b.steeringMode && a.followUpMode === b.followUpMode && a.defaultThinkingLevel === b.defaultThinkingLevel && sameModel(a.defaultModel, b.defaultModel) && sameList(a.custom, b.custom, (x, y) => x === y);
+var sameSettings = (a, b) => a.steeringMode === b.steeringMode && a.followUpMode === b.followUpMode && a.acceptAccountDevices === b.acceptAccountDevices && a.defaultThinkingLevel === b.defaultThinkingLevel && sameModel(a.defaultModel, b.defaultModel) && sameList(a.custom, b.custom, (x, y) => x === y);
 var parse = (path, text) => {
   let parsed;
   try {
@@ -1412,6 +1419,7 @@ async function openHostSettings(options) {
       defaultThinkingLevel: fileValues.defaultThinkingLevel ?? fallback.defaultThinkingLevel(),
       steeringMode: fileValues.steeringMode ?? fallback.steeringMode(),
       followUpMode: fileValues.followUpMode ?? fallback.followUpMode(),
+      acceptAccountDevices: fileValues.acceptAccountDevices ?? true,
       custom
     };
   };
@@ -1458,13 +1466,13 @@ import lockfile from "proper-lockfile";
 import { createServer } from "node:http";
 import { homedir as homedir2, networkInterfaces } from "node:os";
 import { join as join6, sep as sep3 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
 import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
   AgentDoc as AgentDoc3,
   LiveDoc
 } from "@earendil-works/pi-durable";
-import { WebSocket as WebSocket2, WebSocketServer } from "ws";
+import { WebSocket, WebSocketServer } from "ws";
 import { Value as Value2 } from "typebox/value";
 
 // apps/host/src/folders.ts
@@ -1651,6 +1659,353 @@ ${answer}`}`,
   });
 }
 
+// apps/host/src/push.ts
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
+import { defineDoc as defineDoc6 } from "@earendil-works/pi-durable";
+
+// packages/client/src/family.ts
+var SUBAGENT_TASK_PREFIX = /^\s*in the working directory\s+\S+,\s*/i;
+function displayName(summary) {
+  if (summary === undefined)
+    return "Conversation";
+  if (summary.kind !== "subagent")
+    return summary.title ?? "New conversation";
+  if (summary.label !== undefined)
+    return summary.label;
+  const title = summary.title?.replace(SUBAGENT_TASK_PREFIX, "").trim();
+  return title === undefined || title === "" ? "Subagent" : title;
+}
+
+// packages/client/src/run-notifications.ts
+var everySummary = (organized) => {
+  const summaries = [];
+  const visit = (node) => {
+    summaries.push(node.summary);
+    for (const child of node.children)
+      visit(child);
+  };
+  for (const root of [...organized.chats, ...organized.projects.flatMap((entry) => entry.conversations)])
+    visit(root);
+  return summaries;
+};
+function diffRunNotices(previous, organized) {
+  const notices = [];
+  const changed = [];
+  const baseline = new Map;
+  for (const summary of everySummary(organized)) {
+    baseline.set(summary.id, summary.status);
+    if (previous === undefined)
+      continue;
+    const before = previous.get(summary.id);
+    if (before !== summary.status)
+      changed.push(summary.id);
+    if (summary.status === "needs-answer" && before !== "needs-answer") {
+      notices.push({ id: summary.id, title: displayName(summary), body: "Waiting for your answer" });
+      continue;
+    }
+    const runEnded = before === "running" || before === "needs-answer";
+    if (runEnded && (summary.status === undefined || summary.status === "failed") && summary.kind !== "subagent") {
+      notices.push({ id: summary.id, title: displayName(summary), body: summary.status === "failed" ? "Failed" : "Finished" });
+    }
+  }
+  if (previous !== undefined) {
+    for (const gone of previous.keys()) {
+      if (!baseline.has(gone))
+        changed.push(gone);
+    }
+  }
+  return { notices, changed, baseline };
+}
+
+// apps/host/src/push.ts
+var context2 = BACKGROUND_CONTEXT2;
+var PushDoc = defineDoc6({
+  kind: "pinomad.push",
+  version: 1,
+  scope: "session",
+  initial: () => ({ registrations: [] })
+});
+var PUSH_TOKEN_PATTERN = /^Expo(?:nent)?PushToken\[[^\]]+\]$/;
+var PUSH_TOKEN_MAX_LENGTH = 256;
+function pushTokenProblem(token) {
+  if (token === null)
+    return;
+  if (token.length > PUSH_TOKEN_MAX_LENGTH) {
+    return `Push token is too long (${PUSH_TOKEN_MAX_LENGTH} characters at most)`;
+  }
+  if (!PUSH_TOKEN_PATTERN.test(token))
+    return "Not an Expo push token";
+  return;
+}
+async function setPushToken(harness, publicKey, token, context3) {
+  const problem = pushTokenProblem(token);
+  if (problem !== undefined)
+    throw new Error(problem);
+  await harness.commit(async (tx) => {
+    const devices = await tx.doc(DevicesDoc);
+    if (!devices.devices.some((entry) => entry.publicKey === publicKey)) {
+      throw new Error("Device is not paired");
+    }
+    const push = await tx.doc(PushDoc);
+    push.registrations = push.registrations.filter((entry) => entry.publicKey !== publicKey);
+    if (token !== null)
+      push.registrations.push({ publicKey, token, updatedAt: Date.now() });
+  }, context3);
+}
+async function revokeDevice(harness, publicKey, context3) {
+  await harness.commit(async (tx) => {
+    const devices = await tx.doc(DevicesDoc);
+    devices.devices = devices.devices.filter((entry) => entry.publicKey !== publicKey);
+    const push = await tx.doc(PushDoc);
+    push.registrations = push.registrations.filter((entry) => entry.publicKey !== publicKey);
+    const revocations = await tx.doc(RevocationsDoc);
+    if (!revocations.revoked.includes(publicKey))
+      revocations.revoked.push(publicKey);
+  }, context3);
+}
+async function dropTokenIfCurrent(harness, token, context3) {
+  await harness.commit(async (tx) => {
+    const push = await tx.doc(PushDoc);
+    push.registrations = push.registrations.filter((entry) => entry.token !== token);
+  }, context3);
+}
+var EXPO_SEND_URL = "https://exp.host/--/api/v2/push/send";
+var EXPO_RECEIPTS_URL = "https://exp.host/--/api/v2/push/getReceipts";
+var FALLBACK_TITLE = "PiNomad conversation";
+var TITLE_WAIT_MS = 15000;
+var TTL_SECONDS = 3600;
+var REQUEST_TIMEOUT_MS = 1e4;
+var MAX_ATTEMPTS = 4;
+var RETRY_BASE_MS = 5000;
+var RECEIPT_DELAY_MS = 15 * 60 * 1000;
+var MAX_PENDING = 128;
+var realTimers = {
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+var tokenHint = (token) => `…${token.slice(-6)}`;
+async function attachPushSender(options) {
+  const { harness, conversations } = options;
+  const fetcher = options.fetch ?? fetch;
+  const timers = options.timers ?? realTimers;
+  const indexWatch = await harness.watchDoc(IndexDoc, context2);
+  let index = indexWatch?.value ?? undefined;
+  let baseline;
+  let disposed = false;
+  const pending = new Set;
+  const titleWaiters = new Map;
+  const receiptTimers = new Set;
+  const generation = new Map;
+  const update = () => {
+    if (index === undefined)
+      return;
+    const organized = organize(index, conversations.value);
+    if (baseline === undefined) {
+      baseline = diffRunNotices(undefined, organized).baseline;
+      for (const id of baseline.keys())
+        generation.set(id, 0);
+      return;
+    }
+    const diff = diffRunNotices(baseline, organized);
+    baseline = diff.baseline;
+    for (const id of diff.changed)
+      generation.set(id, (generation.get(id) ?? 0) + 1);
+    for (const notice of diff.notices)
+      enqueue(notice);
+  };
+  const fresh = (item) => baseline?.has(item.notice.id) === true && generation.get(item.notice.id) === item.generation;
+  const registrations = async () => {
+    const doc = await harness.snapshot(PushDoc, context2);
+    return new Set((doc?.registrations ?? []).map((entry) => entry.token));
+  };
+  const post = async (url, payload) => {
+    const response = await fetcher(url, {
+      method: "POST",
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    return { status: response.status, body: await response.json() };
+  };
+  const ticketOf = (body) => {
+    const data = body?.data;
+    const ticket = Array.isArray(data) ? data[0] : data;
+    return ticket !== null && typeof ticket === "object" ? ticket : undefined;
+  };
+  const message = (item, title) => ({
+    to: item.token,
+    title,
+    body: item.notice.body,
+    sound: "default",
+    ttl: TTL_SECONDS,
+    data: { hostKey: options.hostKey, conversationId: item.notice.id },
+    threadId: `${options.hostKey}:${item.notice.id}`,
+    collapseId: `${options.hostKey}:${item.notice.id}`
+  });
+  const namedTitle = async (id) => {
+    const doc = await harness.snapshot(TitleDoc, id, context2);
+    return typeof doc?.title === "string" && doc.title !== "" ? doc.title : undefined;
+  };
+  const titleFor = async (notice) => {
+    const named = await namedTitle(notice.id);
+    if (named !== undefined)
+      return named;
+    if (notice.body !== "Finished" || disposed)
+      return FALLBACK_TITLE;
+    return await new Promise((resolve3) => {
+      const waiters = titleWaiters.get(notice.id) ?? new Set;
+      titleWaiters.set(notice.id, waiters);
+      const settle = (title) => {
+        waiters.delete(settle);
+        if (waiters.size === 0)
+          titleWaiters.delete(notice.id);
+        timers.clearTimeout(timer);
+        resolve3(title);
+      };
+      const timer = timers.setTimeout(() => settle(FALLBACK_TITLE), TITLE_WAIT_MS);
+      waiters.add(settle);
+      namedTitle(notice.id).then((title) => {
+        if (title !== undefined)
+          settle(title);
+      });
+    });
+  };
+  const drop = (item) => {
+    pending.delete(item);
+    if (item.timer !== undefined)
+      timers.clearTimeout(item.timer);
+  };
+  const attempt = async (item) => {
+    if (disposed || !pending.has(item))
+      return;
+    try {
+      if (!(await registrations()).has(item.token) || !fresh(item))
+        return drop(item);
+      if (item.title === undefined) {
+        item.title = await titleFor(item.notice);
+        if (disposed || !pending.has(item) || !(await registrations()).has(item.token) || !fresh(item))
+          return drop(item);
+      }
+      const { status, body } = await post(EXPO_SEND_URL, message(item, item.title));
+      const ticket = ticketOf(body);
+      if (ticket?.details?.error === "DeviceNotRegistered") {
+        drop(item);
+        console.error(`push: token ${tokenHint(item.token)} is not registered (ticket)`);
+        await dropTokenIfCurrent(harness, item.token, context2);
+        return;
+      }
+      if (status >= 200 && status < 300 && ticket?.status === "ok") {
+        drop(item);
+        if (typeof ticket.id === "string")
+          scheduleReceiptCheck(item.token, ticket.id);
+        return;
+      }
+      if ((status === 429 || status >= 500) && item.attempts + 1 < MAX_ATTEMPTS) {
+        item.attempts += 1;
+        item.timer = timers.setTimeout(() => void attempt(item), RETRY_BASE_MS * 2 ** (item.attempts - 1));
+        return;
+      }
+      console.error(`push: send to ${tokenHint(item.token)} failed permanently (HTTP ${status})`);
+      drop(item);
+    } catch (error) {
+      if (item.attempts + 1 < MAX_ATTEMPTS) {
+        item.attempts += 1;
+        item.timer = timers.setTimeout(() => void attempt(item), RETRY_BASE_MS * 2 ** (item.attempts - 1));
+        return;
+      }
+      console.error(`push: send to ${tokenHint(item.token)} gave up: ${error instanceof Error ? error.message : String(error)}`);
+      drop(item);
+    }
+  };
+  const scheduleReceiptCheck = (token, ticketId) => {
+    const timer = timers.setTimeout(() => {
+      receiptTimers.delete(timer);
+      checkReceipt(token, ticketId);
+    }, RECEIPT_DELAY_MS);
+    receiptTimers.add(timer);
+    while (receiptTimers.size > MAX_PENDING) {
+      const oldest = receiptTimers.values().next().value;
+      receiptTimers.delete(oldest);
+      timers.clearTimeout(oldest);
+    }
+  };
+  const checkReceipt = async (token, ticketId) => {
+    if (disposed)
+      return;
+    try {
+      const { status, body } = await post(EXPO_RECEIPTS_URL, { ids: [ticketId] });
+      const receipt = status >= 200 && status < 300 ? body?.data?.[ticketId] : undefined;
+      if (receipt === undefined || disposed)
+        return;
+      if (receipt.status === "error" && receipt.details?.error === "DeviceNotRegistered") {
+        console.error(`push: token ${tokenHint(token)} is not registered (receipt)`);
+        await dropTokenIfCurrent(harness, token, context2);
+        return;
+      }
+      if (receipt.status === "error")
+        console.error(`push: receipt ${ticketId} reports ${receipt.details?.error ?? "error"}`);
+    } catch (error) {
+      console.error(`push: receipt check ${ticketId} failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  const enqueue = async (notice) => {
+    if (disposed)
+      return;
+    const itemGeneration = generation.get(notice.id) ?? 0;
+    try {
+      const tokens = await registrations();
+      for (const token of tokens) {
+        if (disposed)
+          return;
+        if (pending.size >= MAX_PENDING) {
+          const [oldest] = pending;
+          drop(oldest);
+        }
+        const item = { token, notice, generation: itemGeneration, attempts: 0 };
+        pending.add(item);
+        attempt(item);
+      }
+    } catch (error) {
+      console.error(`push: could not read registrations: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  const unsubscribeConversations = conversations.subscribe(() => update());
+  const unsubscribeCommits = harness.subscribeCommits((publication) => {
+    for (const change of publication.changes) {
+      if (change.type !== "document" || change.record.kind !== TitleDoc.definition.kind)
+        continue;
+      const id = change.conversationId;
+      if (id === undefined)
+        continue;
+      const title = change.value?.title;
+      if (typeof title !== "string" || title === "")
+        continue;
+      const waiters = titleWaiters.get(id);
+      titleWaiters.delete(id);
+      for (const settle of waiters ?? [])
+        settle(title);
+    }
+  });
+  indexWatch?.start(async (value) => {
+    index = value ?? undefined;
+    update();
+  });
+  update();
+  return async () => {
+    disposed = true;
+    unsubscribeConversations();
+    unsubscribeCommits();
+    await indexWatch?.stop();
+    for (const item of pending)
+      drop(item);
+    pending.clear();
+    titleWaiters.clear();
+    for (const timer of receiptTimers)
+      timers.clearTimeout(timer);
+    receiptTimers.clear();
+  };
+}
+
 // packages/protocol/src/tool-target.ts
 var TARGET_KEYS = [
   "path",
@@ -1678,154 +2033,8 @@ function toolTarget(args) {
   return;
 }
 
-// apps/host/src/relay-link.ts
-import { WebSocket } from "ws";
-function relayWsBase(origin) {
-  const normalized = origin.replace(/\/+$/, "");
-  if (normalized.startsWith("https://"))
-    return `wss://${normalized.slice("https://".length)}`;
-  if (normalized.startsWith("http://"))
-    return `ws://${normalized.slice("http://".length)}`;
-  throw new Error(`relay origin must be an http(s) URL: ${origin}`);
-}
-var REJECTION_REASONS = {
-  [RELAY_CLOSE.badSignature]: () => `the relay rejected this host's registration signature — a version mismatch?`,
-  [RELAY_CLOSE.hostNotAllowed]: (hostId) => `the relay does not allow this host; add --allow-host ${hostId} to the relay's arguments`,
-  [RELAY_CLOSE.replaced]: () => `the relay replaced this control connection — another process registered the same hostId`
-};
-function startRelayLink(options) {
-  const origin = options.origin.replace(/\/+$/, "");
-  const wsBase = relayWsBase(origin);
-  const hostId = relayHostId(options.signingKey.publicKey);
-  const minDelay = options.reconnectDelayMs?.min ?? 1000;
-  const maxDelay = options.reconnectDelayMs?.max ?? 30000;
-  const maxPendingAccepts = options.maxPendingAccepts ?? 16;
-  let state = { status: "connecting" };
-  let stopped = false;
-  let control;
-  let delay = minDelay;
-  let retryTimer;
-  let pendingAccepts = 0;
-  function setState(next) {
-    const changed = state.status !== next.status || state.status === "rejected" && next.status === "rejected" && state.reason !== next.reason;
-    state = next;
-    if (changed)
-      options.onStateChange?.(next);
-  }
-  const watched = new Set;
-  const ponged = new WeakMap;
-  const pingIntervalMs = options.pingIntervalMs ?? 30000;
-  const pingTimer = setInterval(() => {
-    for (const socket of watched) {
-      if (socket.readyState !== WebSocket.OPEN)
-        continue;
-      if (ponged.get(socket) === true) {
-        ponged.set(socket, false);
-        socket.ping();
-      } else {
-        socket.terminate();
-      }
-    }
-  }, pingIntervalMs);
-  function watch2(socket) {
-    watched.add(socket);
-    ponged.set(socket, true);
-    socket.on("pong", () => ponged.set(socket, true));
-    socket.once("close", () => watched.delete(socket));
-    socket.on("error", () => socket.terminate());
-  }
-  function connectControl() {
-    if (stopped)
-      return;
-    const socket = new WebSocket(`${wsBase}/host`, { handshakeTimeout: pingIntervalMs });
-    control = socket;
-    watch2(socket);
-    socket.on("message", onControlMessage);
-    socket.once("close", onControlClosed);
-  }
-  function reconnect(at) {
-    if (stopped || retryTimer !== undefined)
-      return;
-    retryTimer = setTimeout(() => {
-      retryTimer = undefined;
-      connectControl();
-    }, at);
-  }
-  function onControlMessage(data, isBinary) {
-    let frame;
-    try {
-      if (isBinary)
-        throw new Error("binary control frame");
-      frame = decodeRelayToHost(data.toString());
-    } catch {
-      control?.close();
-      return;
-    }
-    switch (frame.t) {
-      case "challenge":
-        control?.send(encodeRelayFrame({
-          t: "register",
-          hostId,
-          signature: signRelayChallenge(options.signingKey.secretKey, { relayOrigin: origin, hostId, nonce: frame.nonce })
-        }));
-        break;
-      case "registered":
-        delay = minDelay;
-        setState({ status: "registered" });
-        break;
-      case "incoming": {
-        if (pendingAccepts >= maxPendingAccepts)
-          break;
-        pendingAccepts += 1;
-        const data2 = new WebSocket(`${wsBase}/accept/${frame.connId}`, { handshakeTimeout: pingIntervalMs });
-        watch2(data2);
-        const release = () => {
-          pendingAccepts -= 1;
-          clearTimeout(ageOut);
-          data2.off("close", release);
-        };
-        const ageOut = setTimeout(release, 1e4);
-        data2.once("close", release);
-        options.accept(data2);
-        break;
-      }
-    }
-  }
-  function onControlClosed(code) {
-    control = undefined;
-    if (stopped)
-      return;
-    const rejection = REJECTION_REASONS[code];
-    if (rejection !== undefined) {
-      const reason = `relay ${origin}: ${rejection(hostId)} (${code})`;
-      setState({ status: "rejected", reason });
-      delay = maxDelay;
-      reconnect(maxDelay);
-      return;
-    }
-    setState({ status: "connecting" });
-    reconnect(delay);
-    delay = Math.min(maxDelay, delay * 2);
-  }
-  connectControl();
-  return {
-    hostId,
-    origin,
-    state: () => state,
-    close() {
-      stopped = true;
-      if (retryTimer !== undefined)
-        clearTimeout(retryTimer);
-      clearInterval(pingTimer);
-      for (const socket of watched)
-        socket.terminate();
-      return Promise.resolve();
-    }
-  };
-}
-
 // apps/host/src/gateway.ts
-var context2 = BACKGROUND_CONTEXT2;
+var context3 = BACKGROUND_CONTEXT3;
 var forkTails = new WeakMap;
 function serializedFork(harness, work) {
   const next = (forkTails.get(harness) ?? Promise.resolve()).then(work, work);
@@ -1845,6 +2054,13 @@ async function startGateway(options) {
     models: options.models,
     settings: options.settings
   });
+  const detachPush = options.push === undefined ? undefined : await attachPushSender({
+    harness: options.harness,
+    conversations,
+    hostKey: options.push.hostKey,
+    ...options.push.fetch === undefined ? {} : { fetch: options.push.fetch },
+    ...options.push.timers === undefined ? {} : { timers: options.push.timers }
+  });
   const http = createServer((request, response) => {
     serveWebClient(request, response, options.webRoot).catch(() => {
       if (!response.headersSent)
@@ -1867,7 +2083,10 @@ async function startGateway(options) {
   };
   let remote;
   let relay;
-  const register = (connection, devicePublicKey) => {
+  const register = (connection, devicePublicKey, joined) => {
+    if (joined?.source === "account") {
+      broadcast("info", `New device "${joined.name}" joined through your account`);
+    }
     const client = new GatewayClient(connection, options, conversations, {
       devicePublicKey,
       closed: (self) => {
@@ -1884,20 +2103,30 @@ async function startGateway(options) {
         const spec = options.secure;
         if (spec === undefined)
           return;
-        const { secret, expiresAt } = spec.offers.create();
-        const pair = `pair=${toBase64Url(spec.hostKey.publicKey)}.${secret}`;
+        const pair = (secret2) => `pair=${toBase64Url(spec.hostKey.publicKey)}.${secret2}`;
         if (relay !== undefined) {
+          const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
           const target2 = `${relayWsBase(relay.origin)}/c/${relay.hostId}`;
-          return { url: `${relay.origin}/#${pair}&url=${encodeURIComponent(target2)}`, expiresAt };
+          return { url: `${relay.origin}/#${pair(secret2)}&url=${encodeURIComponent(target2)}`, expiresAt: expiresAt2 };
+        }
+        if (remote !== undefined) {
+          const { secret: secret2, expiresAt: expiresAt2 } = spec.offers.create("qr");
+          return { url: `${remote.advertiseUrl}/#${pair(secret2)}`, expiresAt: expiresAt2 };
         }
-        if (remote !== undefined)
-          return { url: `${remote.advertiseUrl}/#${pair}`, expiresAt };
+        const { secret, expiresAt } = spec.offers.create("local");
         const target = `ws://127.0.0.1:${port}${LOOPBACK_SECURE_PATH}`;
-        return { url: `http://127.0.0.1:${port}/#${pair}&url=${encodeURIComponent(target)}`, expiresAt };
+        return { url: `http://127.0.0.1:${port}/#${pair(secret)}&url=${encodeURIComponent(target)}`, expiresAt };
       }
     });
     clients.add(client);
   };
+  const admission = {
+    harness: options.harness,
+    acceptAccountDevices: () => options.settings.value.acceptAccountDevices,
+    serverBinding: async () => await readServerBinding(options.dataDir).catch(() => {
+      return;
+    })
+  };
   server.on("connection", (socket, request) => {
     socket.on("error", () => socket.terminate());
     const url = new URL(request.url ?? "/", "ws://127.0.0.1");
@@ -1907,7 +2136,7 @@ async function startGateway(options) {
         socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
         return;
       }
-      secureHandshake(socket, secure2, options.harness, register);
+      secureHandshake(socket, secure2, admission, register);
       return;
     }
     const token = url.searchParams.get("token");
@@ -1918,14 +2147,34 @@ async function startGateway(options) {
     }
     register(tokenConnection(socket));
   });
-  remote = await startRemote(options, register);
+  remote = await startRemote(options, admission, register);
   const secure = options.secure;
+  const detachSettingsWatch = options.settings.subscribe((settings) => {
+    if (!settings.acceptAccountDevices)
+      secure?.offers.revokeAccount();
+  });
   if (secure?.relay !== undefined) {
+    const relayOrigin = secure.relay.origin;
     let link;
     link = startRelayLink({
-      origin: secure.relay.origin,
+      origin: relayOrigin,
       signingKey: secure.relay.signingKey,
-      accept: (socket) => secureHandshake(socket, secure, options.harness, register),
+      noisePublicKey: secure.hostKey.publicKey,
+      accept: (socket) => secureHandshake(socket, secure, admission, register),
+      accountOffer: async () => {
+        if (!options.settings.value.acceptAccountDevices)
+          return { ok: false, reason: "disabled" };
+        const config = await readServerConfig(options.dataDir).catch(() => {
+          return;
+        });
+        if (config?.binding === undefined)
+          return { ok: false, reason: "not_joined" };
+        if (normalizeOrigin(config.origin) !== normalizeOrigin(relayOrigin)) {
+          return { ok: false, reason: "rebinding" };
+        }
+        const { secret, expiresAt } = secure.offers.createAccount(config.binding);
+        return { ok: true, secret, expiresAt };
+      },
       onStateChange: (state) => {
         if (state.status === "registered") {
           console.log(JSON.stringify({ event: "relay", status: "registered", origin: link.origin, hostId: link.hostId }));
@@ -1949,6 +2198,8 @@ async function startGateway(options) {
     async close() {
       await relay?.close();
       detachAutoTitle?.();
+      detachSettingsWatch();
+      await detachPush?.();
       conversations.dispose();
       await Promise.all([...clients].map((client) => client.dispose()));
       for (const socket of server.clients)
@@ -1962,9 +2213,9 @@ async function startGateway(options) {
 function tokenConnection(socket) {
   return {
     get open() {
-      return socket.readyState === WebSocket2.OPEN;
+      return socket.readyState === WebSocket.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket2.OPEN ? new Promise((resolve3) => socket.send(text, () => resolve3())) : Promise.resolve(),
+    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve3) => socket.send(text, () => resolve3())) : Promise.resolve(),
     close: (code, reason) => socket.close(code, reason),
     handle(handlers) {
       socket.on("message", (data) => handlers.message(String(data)));
@@ -1975,9 +2226,9 @@ function tokenConnection(socket) {
 function secureConnection(socket, session) {
   return {
     get open() {
-      return socket.readyState === WebSocket2.OPEN;
+      return socket.readyState === WebSocket.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket2.OPEN ? new Promise((resolve3) => {
+    send: (text) => socket.readyState === WebSocket.OPEN ? new Promise((resolve3) => {
       const chunks = session.seal(text);
       chunks.forEach((chunk, index) => socket.send(chunk, index === chunks.length - 1 ? () => resolve3() : undefined));
     }) : Promise.resolve(),
@@ -2012,7 +2263,7 @@ function pickLanAddress(interfaces) {
   }
   return fallback;
 }
-function secureHandshake(socket, secure, harness, register) {
+function secureHandshake(socket, secure, policy, register) {
   socket.on("error", () => socket.terminate());
   const responder = respondIK({ prologue: SECURE_PROLOGUE, static: secure.hostKey });
   let settled = false;
@@ -2034,7 +2285,7 @@ function secureHandshake(socket, secure, harness, register) {
       clearTimeout(timeout);
       const session = new SecureSession(admitted.result);
       socket.send(admitted.message);
-      register(secureConnection(socket, session), admitted.deviceKey);
+      register(secureConnection(socket, session), admitted.deviceKey, admitted.joined);
     }).catch(() => socket.close(1011, "handshake failed"));
     async function admit() {
       const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
@@ -2049,19 +2300,28 @@ function secureHandshake(socket, secure, harness, register) {
         return;
       }
       const deviceKey = toBase64Url(remoteStatic);
-      if (!await isRegistered(harness, deviceKey, context2)) {
-        if (hello.pair === undefined || !secure.offers.consume(hello.pair.secret)) {
-          socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
-          return;
-        }
-        await registerDevice(harness, { publicKey: deviceKey, name: hello.pair.name }, context2);
+      const decision = await admitDevice(policy.harness, {
+        publicKey: deviceKey,
+        ...hello.pair === undefined ? {} : { pair: hello.pair },
+        offers: secure.offers,
+        acceptAccountDevices: policy.acceptAccountDevices,
+        serverBinding: policy.serverBinding
+      }, context3);
+      if (decision.outcome === "refused") {
+        socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
+        return;
       }
       const { message, result: result2 } = responder.writeMessage2(encodeHostHello({ v: 1 }));
-      return { result: result2, message, deviceKey };
+      return {
+        result: result2,
+        message,
+        deviceKey,
+        ...decision.outcome === "admitted" ? { joined: decision.entry } : {}
+      };
     }
   });
 }
-async function startRemote(options, register) {
+async function startRemote(options, admission, register) {
   const spec = options.secure;
   const remote = spec?.lan;
   if (spec === undefined || remote === undefined)
@@ -2074,7 +2334,7 @@ async function startRemote(options, register) {
     });
   });
   const secure = new WebSocketServer({ server: http });
-  secure.on("connection", (socket) => secureHandshake(socket, spec, options.harness, register));
+  secure.on("connection", (socket) => secureHandshake(socket, spec, admission, register));
   await new Promise((resolveListen, reject) => {
     http.once("listening", resolveListen);
     http.once("error", reject);
@@ -2115,7 +2375,7 @@ class ConversationList {
     const summaries = [];
     let cursor;
     do {
-      const page = await harness.commit((tx) => tx.scanConversations({}, 256, cursor), context2);
+      const page = await harness.commit((tx) => tx.scanConversations({}, 256, cursor), context3);
       for (const record of page.items) {
         list.#records.set(record.id, record);
         const facts = await list.#load(harness, record);
@@ -2132,23 +2392,23 @@ class ConversationList {
   async#load(harness, record) {
     const history = await historyFacts(harness, record.id);
     const facts = { pending: new Set, ...history };
-    const live = await harness.snapshot(LiveDoc, record.id, context2);
+    const live = await harness.snapshot(LiveDoc, record.id, context3);
     facts.running = live?.run !== undefined;
     facts.tools = live?.tools;
     for (const token of this.#questionTokens) {
-      const value = await harness.snapshot(token, record.id, context2);
+      const value = await harness.snapshot(token, record.id, context3);
       if (Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined)) {
         facts.pending.add(token.definition.kind);
       }
     }
     if (record.owner !== undefined) {
-      const subagent = await harness.snapshot(SubagentDoc, record.id, context2);
+      const subagent = await harness.snapshot(SubagentDoc, record.id, context3);
       if (typeof subagent?.label === "string" && subagent.label !== "")
         facts.label = subagent.label;
       if (typeof subagent?.role === "string" && subagent.role !== "")
         facts.role = subagent.role;
     }
-    const named = (await harness.snapshot(TitleDoc, record.id, context2))?.title;
+    const named = (await harness.snapshot(TitleDoc, record.id, context3))?.title;
     if (typeof named === "string" && named !== "")
       facts.named = named;
     return facts;
@@ -2301,12 +2561,12 @@ function titleOf(entry) {
   return title === "" ? {} : { title };
 }
 async function historyFacts(harness, id) {
-  const conversation = await harness.conversation(id, context2);
+  const conversation = await harness.conversation(id, context3);
   let first;
   let newest;
   let cursor;
   do {
-    const page = await conversation.entries({}, 256, cursor, context2);
+    const page = await conversation.entries({}, 256, cursor, context3);
     first = page.items.findLast((entry) => entry.kind === "pi.user" && entry.conversationId === id && titleOf(entry).title !== undefined) ?? first;
     newest ??= page.items.find((entry) => entry.conversationId === id && (entry.kind === "pi.user" || entry.kind === "pi.assistant"));
     cursor = page.next;
@@ -2450,25 +2710,25 @@ class GatewayClient {
       return { stop: source.subscribe((value) => void send({ type: "snapshot", stream, value })) };
     }
     if (stream === "index") {
-      const watch2 = await this.#options.harness.watchDoc(IndexDoc, context2);
+      const watch2 = await this.#options.harness.watchDoc(IndexDoc, context3);
       if (watch2 === undefined)
         throw new Error("Index document is missing");
       return this.#forward(stream, watch2, send);
     }
     if (stream === "devices") {
-      const watch2 = await this.#options.harness.watchDoc(DevicesDoc, context2);
+      const watch2 = await this.#options.harness.watchDoc(DevicesDoc, context3);
       if (watch2 === undefined)
         throw new Error("Devices document is missing");
       return this.#forward(stream, watch2, send);
     }
     if (stream === "tasks")
-      return this.#forward(stream, await this.#options.harness.watchTaskGraph(context2), send);
+      return this.#forward(stream, await this.#options.harness.watchTaskGraph(context3), send);
     if (stream.startsWith("doc:")) {
       const at = stream.lastIndexOf(":");
       return this.#openDoc(stream, stream.slice("doc:".length, at), Number(stream.slice(at + 1)), send);
     }
     const conversation = await this.#conversation(Number(stream.slice("conversation:".length)));
-    return this.#forward(stream, await conversation.watch(context2), send);
+    return this.#forward(stream, await conversation.watch(context3), send);
   }
   #hostValue(stream) {
     return Object.hasOwn(this.#hostValues, stream) ? this.#hostValues[stream] : undefined;
@@ -2494,7 +2754,7 @@ class GatewayClient {
       setImmediate(() => signalCreation());
     });
     try {
-      const existing = await harness.watchDoc(token, id, context2);
+      const existing = await harness.watchDoc(token, id, context3);
       if (existing !== undefined) {
         unsubscribe();
         return this.#forward(stream, existing, send);
@@ -2507,7 +2767,7 @@ class GatewayClient {
     created.then(async () => {
       if (stopped)
         return;
-      const watch2 = await harness.watchDoc(token, id, context2);
+      const watch2 = await harness.watchDoc(token, id, context3);
       if (watch2 === undefined)
         return;
       if (stopped)
@@ -2541,7 +2801,7 @@ class GatewayClient {
     await subscription?.subscription?.stop();
   }
   async#conversation(id) {
-    const conversation = await this.#options.harness.conversation(id, context2);
+    const conversation = await this.#options.harness.conversation(id, context3);
     if (conversation === undefined)
       throw new Error(`Conversation ${id} does not exist`);
     return conversation;
@@ -2557,9 +2817,9 @@ class GatewayClient {
   async#call(method, args) {
     switch (method) {
       case "addProject":
-        return addProject(this.#options.harness, args.path, context2);
+        return addProject(this.#options.harness, args.path, context3);
       case "removeProject":
-        await removeProject(this.#options.harness, args.path, context2);
+        await removeProject(this.#options.harness, args.path, context3);
         return null;
       case "createConversation": {
         const create = args;
@@ -2574,14 +2834,14 @@ class GatewayClient {
           ...create.checkout === undefined ? {} : { checkout: create.checkout },
           ...create.model === undefined ? {} : { model: create.model },
           ...create.thinkingLevel === undefined ? {} : { thinkingLevel: create.thinkingLevel }
-        }, settingsDefaults(this.#options.settings.value), this.#options.models, context2);
+        }, settingsDefaults(this.#options.settings.value), this.#options.models, context3);
         return { conversationId };
       }
       case "archive": {
         const input = args;
-        await archive(this.#options.harness, input.conversationId, input.archived, context2);
+        await archive(this.#options.harness, input.conversationId, input.archived, context3);
         if (input.archived) {
-          const kept = await cleanupArchivedWorktrees(this.#options.harness, input.conversationId, context2);
+          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}` });
           }
@@ -2596,10 +2856,17 @@ class GatewayClient {
       }
       case "revokeDevice": {
         const { publicKey } = args;
-        await revokeDevice(this.#options.harness, publicKey, context2);
+        await revokeDevice(this.#options.harness, publicKey, context3);
         this.#hooks.closeDevice(publicKey);
         return null;
       }
+      case "setPushToken": {
+        const device = this.devicePublicKey;
+        if (device === undefined)
+          throw new Error("Push tokens register over the secure channel only");
+        await setPushToken(this.#options.harness, device, args.token, context3);
+        return null;
+      }
       case "logout": {
         const modelAuth = this.#options.modelAuth;
         if (modelAuth === undefined)
@@ -2642,9 +2909,9 @@ class GatewayClient {
         const problem = imageProblem(images ?? []);
         if (problem !== undefined)
           throw new Error(problem);
-        const dismissed = await this.#dismissPendingQuestions(conversation.id, context2);
-        const submission = await conversation.submit({ type: "input", content: messageContent(text, images), whenBusy: dismissed ? "steer" : whenBusy, requestId }, context2);
-        submission.wait(context2).then((settled) => {
+        const dismissed = await this.#dismissPendingQuestions(conversation.id, context3);
+        const submission = await conversation.submit({ type: "input", content: messageContent(text, images), whenBusy: dismissed ? "steer" : whenBusy, requestId }, context3);
+        submission.wait(context3).then((settled) => {
           if (settled.status === "unanswered" && settled.reason !== "aborted") {
             this.send({ type: "notice", level: "error", message: `No answer: ${settled.reason}` });
           }
@@ -2668,16 +2935,16 @@ class GatewayClient {
           const doc = await tx.doc(TitleDoc, conversation.id);
           doc.title = trimmed;
           doc.source = "manual";
-        }, context2);
+        }, context3);
         return null;
       }
       case "abort":
-        await conversation.abort(context2);
+        await conversation.abort(context3);
         return null;
       case "compact": {
         const { instructions } = args;
-        const taskId = await conversation.compact(instructions, context2);
-        this.#options.harness.waitForTask(taskId, context2).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
+        const taskId = await conversation.compact(instructions, context3);
+        this.#options.harness.waitForTask(taskId, context3).then((receipt) => void this.send({ type: "notice", level: "info", message: `Compaction ${receipt.state.outcome.status}.` }), () => {});
         return { taskId };
       }
       case "setModel": {
@@ -2686,7 +2953,7 @@ class GatewayClient {
         if (model === undefined)
           throw new Error(`Unknown model: ${ref.provider}/${ref.modelId}`);
         const thinking = (await this.#agent(conversation.id)).thinkingLevel ?? "off";
-        await conversation.configure({ model: ref, thinkingLevel: clampThinkingLevel3(model, thinking) }, context2);
+        await conversation.configure({ model: ref, thinkingLevel: clampThinkingLevel3(model, thinking) }, context3);
         return null;
       }
       case "setThinkingLevel": {
@@ -2698,7 +2965,7 @@ class GatewayClient {
         if (!getSupportedThinkingLevels(model).includes(level)) {
           throw new Error(`Thinking level ${level} is not supported by ${agent.model.provider}/${agent.model.modelId}`);
         }
-        await conversation.configure({ thinkingLevel: level }, context2);
+        await conversation.configure({ thinkingLevel: level }, context3);
         return null;
       }
       case "fork": {
@@ -2722,13 +2989,13 @@ class GatewayClient {
               }
               cursor = page.next;
             } while (cursor !== undefined);
-          }, context2);
-          const agent = await conversation.agent(context2);
+          }, context3);
+          const agent = await conversation.agent(context3);
           const remove = agent.tools.filter((tool) => removeTools.includes(tool.name));
           const fork = await conversation.fork(at, {
             ownership: { kind: "ownerless" },
             ...remove.length === 0 ? {} : { agent: { tools: { remove } } }
-          }, context2);
+          }, context3);
           return { conversationId: fork.id };
         });
       }
@@ -2764,16 +3031,16 @@ class GatewayClient {
           }
           request.resolution = { outcome: "answered", answers, at: Date.now() };
           return { first: true };
-        }, context2);
+        }, context3);
       }
       case "changes": {
-        return await this.#changes(conversation, context2);
+        return await this.#changes(conversation, context3);
       }
     }
   }
-  async#dismissPendingQuestions(conversationId, context3) {
+  async#dismissPendingQuestions(conversationId, context4) {
     const questionDocs = (this.#options.docs ?? []).filter((doc) => doc.presentation === "pinomad.question");
-    const snapshots = await Promise.all(questionDocs.map((doc) => this.#options.harness.snapshot(doc.token, conversationId, context3)));
+    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;
@@ -2791,18 +3058,18 @@ class GatewayClient {
         }
       }
       return dismissed;
-    }, context3);
+    }, context4);
   }
   get #chatsPrefix() {
     return join6(this.#options.dataDir, "chats") + sep3;
   }
-  async#changes(conversation, context3) {
-    const cwd = (await conversation.agent(context3)).cwd;
+  async#changes(conversation, context4) {
+    const cwd = (await conversation.agent(context4)).cwd;
     if (cwd === undefined)
       return { available: false, reason: "No working directory" };
     if (cwd.startsWith(this.#chatsPrefix))
       return { available: false, reason: "Chat conversations have no repository" };
-    const index = await this.#options.harness.snapshot(IndexDoc, context3);
+    const index = await this.#options.harness.snapshot(IndexDoc, context4);
     const record = checkoutAt(index?.checkouts, cwd);
     if (record !== undefined) {
       if (!await worktreeExists(record.path))
@@ -2815,7 +3082,7 @@ class GatewayClient {
     return { available: true, ...await changesOf(base.repo, base.base) };
   }
   async#agent(id) {
-    return await this.#options.harness.snapshot(AgentDoc3, id, context2) ?? {};
+    return await this.#options.harness.snapshot(AgentDoc3, id, context3) ?? {};
   }
   async dispose() {
     if (this.#disposed)
@@ -2829,7 +3096,7 @@ class GatewayClient {
 }
 
 // apps/host/src/host.ts
-var context3 = BACKGROUND_CONTEXT3;
+var context4 = BACKGROUND_CONTEXT4;
 async function hostToken(dataDir) {
   const path = join7(dataDir, "token");
   try {
@@ -2898,7 +3165,7 @@ async function openHost(options) {
           return;
         const worktrees = worktreeRoot(options.dataDir);
         if (cwd === worktrees || cwd.startsWith(worktrees + sep4)) {
-          const index = await target.read.snapshot(IndexDoc, context3);
+          const index = await target.read.snapshot(IndexDoc, context4);
           const record = checkoutAt(index?.checkouts, cwd);
           if (record !== undefined) {
             await ensureWorktree(record);
@@ -2918,11 +3185,11 @@ async function openHost(options) {
         settings: typeof options.settings === "function" ? options.settings(hostSettings) : options.settings
       },
       onReport: (error) => report(error)
-    }, context3);
-    await ensureIndex(harness, context3);
-    await ensureDevices(harness, context3);
+    }, context4);
+    await ensureIndex(harness, context4);
+    await ensureDevices(harness, context4);
     for (const path of options.projects ?? [])
-      await addProject(harness, path, context3);
+      await addProject(harness, path, context4);
     const hostKey = await loadHostKey(options.dataDir);
     const offers = pairingOffers(options.remote?.pairingTtlMs);
     const relayKey = options.relay === undefined ? undefined : await loadRelayKey(options.dataDir);
@@ -2943,6 +3210,13 @@ async function openHost(options) {
       ...options.modelAuth === undefined ? {} : { modelAuth: options.modelAuth },
       ...options.webRoot === undefined ? {} : { webRoot: options.webRoot },
       ...options.autoTitle === undefined ? {} : { autoTitle: options.autoTitle },
+      ...options.push === undefined ? {} : {
+        push: {
+          hostKey: toBase64Url(hostKey.publicKey),
+          ...options.push.fetch === undefined ? {} : { fetch: options.push.fetch },
+          ...options.push.timers === undefined ? {} : { timers: options.push.timers }
+        }
+      },
       secure: {
         hostKey,
         offers,
@@ -2975,19 +3249,25 @@ async function openHost(options) {
       harness,
       closed: opened.closed,
       settings: hostSettings,
+      createAccountOffer: async () => {
+        const binding = await readServerBinding(options.dataDir).catch(() => {
+          return;
+        });
+        return binding === undefined ? undefined : offers.createAccount(binding);
+      },
       ...gateway.remote === undefined || hostKey === undefined ? {} : { remote: { url: gateway.remote.url, advertiseUrl: gateway.remote.advertiseUrl, hostKey: hostKey.publicKey } },
       ...gateway.relay === undefined ? {} : { relay: { origin: gateway.relay.origin, hostId: gateway.relay.hostId, state: () => gateway.relay.state() } },
       close() {
         closing ??= (async () => {
           try {
             await gateway.close();
-            await opened.close(context3);
+            await opened.close(context4);
             await mcp?.close();
             agentRoles?.close();
             for (const each of extensions)
               await each.close?.();
             options.modelAuth?.close();
-            await Promise.all([...environments.values()].map((env) => env.cleanup(context3)));
+            await Promise.all([...environments.values()].map((env) => env.cleanup(context4)));
           } finally {
             await release();
           }
@@ -3001,7 +3281,7 @@ async function openHost(options) {
     for (const each of extensions)
       await each.close?.().catch(() => {});
     await mcp?.close().catch(() => {});
-    await harness?.close(context3).catch(() => {});
+    await harness?.close(context4).catch(() => {});
     await release().catch(() => {});
     throw error;
   }
@@ -3210,10 +3490,17 @@ async function main(argv) {
     }
   });
   const dataDir = resolve3(values["data-dir"] ?? DEFAULT_DATA_DIR);
+  let relayOrigin;
+  try {
+    relayOrigin = resolveRelayOrigin(values.relay, await readServerConfig(dataDir));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
   const extensionsFor = (models, summaries, options2) => (host2) => [
     createContext({
       agentsHome: join8(homedir3(), ".agents"),
-      checkout: (input, context4) => checkoutInfo(host2.harness(), input, context4)
+      checkout: (input, context5) => checkoutInfo(host2.harness(), input, context5)
     }),
     createCoding(options2),
     todo,
@@ -3240,7 +3527,7 @@ async function main(argv) {
         ...values["public-url"] === undefined ? {} : { publicUrl: values["public-url"] }
       }
     },
-    ...values.relay === undefined ? {} : { relay: { origin: values.relay } }
+    ...relayOrigin === undefined ? {} : { relay: { origin: relayOrigin } }
   };
   function fauxOptions(responses) {
     const faux = fauxProvider({ tokensPerSecond: Number(values["faux-tps"]), tokenSize: { min: 1, max: 1 } });
@@ -3286,6 +3573,7 @@ async function main(argv) {
       modelAuth,
       extensions: extensionsFor(modelRuntime, summaries, { images }),
       settings: (store) => createHarnessSettings(settingsManager, store),
+      push: {},
       settingsFallback: {
         defaultModel: () => {
           const model2 = defaultModel(settingsManager, modelRuntime);