pinomad 0.3.0 → 0.5.0

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

@@ -2,43 +2,44 @@
 import {
   serveWebClient
 } from "./chunk-r6w5aqkw.js";
-import {
-  packagedVersion,
-  webRoot
-} from "./chunk-3tf23vjq.js";
-import {
-  HOST_SETTING_KEYS,
-  INVALID_FRAME_CLOSE_CODE,
-  PROTOCOL,
-  THINKING_LEVELS,
-  UNAUTHORIZED_CLOSE_CODE,
-  isQueueMode,
-  isThinkingLevel,
-  parseClientFrame
-} from "./chunk-c155p0t0.js";
 import {
   DevicesDoc,
+  RevocationsDoc,
+  admitDevice,
   ensureDevices,
-  isRegistered,
   loadHostKey,
   loadRelayKey,
+  normalizeOrigin,
   pairingOffers,
-  registerDevice,
-  revokeDevice
-} from "./chunk-fxaewke2.js";
+  readServerBinding,
+  readServerConfig,
+  resolveRelayOrigin
+} from "./chunk-ebfaf3k2.js";
 import {
-  RELAY_CLOSE,
   SECURE_PROLOGUE,
   SecureSession,
   decodeClientHello,
-  decodeRelayToHost,
   encodeHostHello,
-  encodeRelayFrame,
-  relayHostId,
+  relayWsBase,
   respondIK,
-  signRelayChallenge,
+  startRelayLink,
   toBase64Url
-} from "./chunk-z4x88s0q.js";
+} from "./chunk-kmbh44dt.js";
+import {
+  packagedVersion,
+  webRoot
+} from "./chunk-1d9sppj0.js";
+import {
+  HOST_SETTING_KEYS,
+  INVALID_FRAME_CLOSE_CODE,
+  PROTOCOL,
+  THINKING_LEVELS,
+  UNAUTHORIZED_CLOSE_CODE,
+  isQueueMode,
+  isThinkingLevel,
+  organize,
+  parseClientFrame
+} from "./chunk-hsp12cjt.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-cjfmfyjb.js";
@@ -46,7 +47,7 @@ import"./chunk-df32avw6.js";
 
 // apps/host/src/main.ts
 import { homedir as homedir3 } from "node:os";
-import { join as join8, resolve as resolve3 } from "node:path";
+import { join as join9, resolve as resolve4 } from "node:path";
 import { parseArgs } from "node:util";
 import { createModels } from "@earendil-works/pi-ai/models";
 import { fauxAssistantMessage, fauxProvider } from "@earendil-works/pi-ai/providers/faux";
@@ -284,6 +285,7 @@ function createContext(options) {
           ].join(`
 `);
         }),
+        section("file_references", () => "When the user writes @./path in their message, it is a project file the user references; the path is relative to your current working directory. Its contents are not expanded for you — read the file yourself if the task needs them.", { tag: false }),
         section("project_context", async (input, context) => {
           const cwd = input.agent.cwd;
           if (cwd === undefined)
@@ -521,8 +523,8 @@ var todo = {
 // apps/host/src/host.ts
 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 { basename as basename2, join as join8, sep as sep5 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
 import { createRegistry, Harness } from "@earendil-works/pi-durable";
 import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
 
@@ -681,7 +683,23 @@ class DuplicateRequest extends Error {
     this.conversationId = conversationId;
   }
 }
-async function createConversation(harness, dataDir, input, defaults, models, context) {
+function requireRole(agents, name) {
+  const found = agents.roles.find((role) => role.name === name);
+  if (found !== undefined)
+    return found;
+  const broken = agents.problems.find((problem) => problem.file === `${name}.md`);
+  if (broken !== undefined)
+    throw new Error(`Agent "${name}" failed to load: ${broken.reason}`);
+  const defined = agents.roles.map((role) => role.name).join(", ");
+  throw new Error(defined === "" ? `Unknown agent "${name}"` : `Unknown agent "${name}". Available agents: ${defined}`);
+}
+function roleModelRef(role) {
+  if (role.model === undefined)
+    return;
+  const slash = role.model.indexOf("/");
+  return { provider: role.model.slice(0, slash), modelId: role.model.slice(slash + 1) };
+}
+async function createConversation(harness, dataDir, input, defaults, models, modelSummaries, agents, context) {
   const index = await harness.snapshot(IndexDoc, context);
   const prior = index?.conversations.find((entry) => entry.requestId === input.requestId);
   if (prior !== undefined) {
@@ -691,12 +709,24 @@ async function createConversation(harness, dataDir, input, defaults, models, con
     }
     return prior.id;
   }
-  const modelRef = input.model ?? defaults.model;
+  const role = input.agent === undefined ? undefined : requireRole(agents, input.agent);
+  const roleModel = role === undefined ? undefined : roleModelRef(role);
+  const modelRef = input.model ?? roleModel ?? defaults.model;
   const model = modelRef === undefined ? undefined : models.getModel(modelRef.provider, modelRef.modelId);
   if (input.model !== undefined && model === undefined) {
     throw new Error(`Unknown model: ${input.model.provider}/${input.model.modelId}`);
   }
-  const thinkingLevel = model === undefined ? input.thinkingLevel ?? defaults.thinkingLevel : clampThinkingLevel2(model, input.thinkingLevel ?? defaults.thinkingLevel ?? "off");
+  if (role !== undefined) {
+    const listed = modelSummaries().map((m) => `${m.provider}/${m.modelId}`).join(", ");
+    const suffix2 = listed === "" ? "" : `. Available models: ${listed}`;
+    if (modelRef === undefined) {
+      throw new Error(`Agent "${role.name}" has no model: the role pins none and the host has no default${suffix2}`);
+    }
+    if (model === undefined || !modelSummaries().some((m) => m.provider === modelRef.provider && m.modelId === modelRef.modelId)) {
+      throw new Error(`Model ${modelRef.provider}/${modelRef.modelId} is not available${suffix2}`);
+    }
+  }
+  const thinkingLevel = model === undefined ? input.thinkingLevel ?? role?.thinkingLevel ?? defaults.thinkingLevel : clampThinkingLevel2(model, input.thinkingLevel ?? role?.thinkingLevel ?? defaults.thinkingLevel ?? "off");
   const home = input.home;
   const projectPath = home.kind === "project" ? await normalizePath(home.path).catch(() => home.path) : undefined;
   const repo = home.kind === "project" && input.checkout !== "project" && projectPath !== undefined ? await gitBase(projectPath) : undefined;
@@ -707,7 +737,8 @@ async function createConversation(harness, dataDir, input, defaults, models, con
       agent: {
         ...projectPath === undefined || repo !== undefined ? {} : { cwd: projectPath },
         ...modelRef === undefined ? {} : { model: modelRef },
-        ...thinkingLevel === undefined ? {} : { thinkingLevel }
+        ...thinkingLevel === undefined ? {} : { thinkingLevel },
+        ...role === undefined || role.prompt === "" ? {} : { instructions: role.prompt }
       },
       init: async (tx, id) => {
         const doc = await tx.doc(IndexDoc);
@@ -718,7 +749,13 @@ async function createConversation(harness, dataDir, input, defaults, models, con
           throw new Error(`Unknown project: ${home.path}`);
         }
         const stored = home.kind === "chat" ? { kind: "chat" } : { kind: "project", path: projectPath };
-        doc.conversations.push({ id, home: stored, createdAt: Date.now(), requestId: input.requestId });
+        doc.conversations.push({
+          id,
+          home: stored,
+          createdAt: Date.now(),
+          requestId: input.requestId,
+          ...role === undefined ? {} : { role: role.name }
+        });
         if (repo !== undefined && suffix !== undefined) {
           const path = worktreePath(dataDir, id);
           if (doc.checkouts === undefined)
@@ -1366,10 +1403,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 +1451,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
     };
   };
@@ -1457,14 +1497,14 @@ import lockfile from "proper-lockfile";
 // apps/host/src/gateway.ts
 import { createServer } from "node:http";
 import { homedir as homedir2, networkInterfaces } from "node:os";
-import { join as join6, sep as sep3 } from "node:path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
+import { join as join7, sep as sep4 } from "node:path";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
 import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
-  AgentDoc as AgentDoc3,
+  AgentDoc as AgentDoc4,
   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
@@ -1508,6 +1548,273 @@ async function listFolders(path, home) {
   return { path: dir, home: await realpath3(home).catch(() => home), folders };
 }
 
+// apps/host/src/files.ts
+import { spawn } from "node:child_process";
+import { opendir, realpath as realpath4, stat as stat4 } from "node:fs/promises";
+import { join as join6, resolve as resolve3, sep as sep3 } from "node:path";
+import { AgentDoc as AgentDoc3 } from "@earendil-works/pi-durable";
+var CACHE_TTL_MS = 3000;
+var MAX_CACHED_ROOTS = 64;
+var MAX_CONCURRENT_SCANS = 4;
+var SCAN_BUDGET_MS = 5000;
+var MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+var MAX_WALK_ENTRIES = 20000;
+var MAX_RESULTS = 50;
+var UNUSABLE_PATH = /[\s`\x00-\x1f\x7f-\x9f]/;
+function createCandidateLister(enumerate, options = {}) {
+  const now = options.now ?? Date.now;
+  const ttlMs = options.ttlMs ?? CACHE_TTL_MS;
+  const maxConcurrent = options.maxConcurrent ?? MAX_CONCURRENT_SCANS;
+  const maxCached = options.maxCached ?? MAX_CACHED_ROOTS;
+  const cache = new Map;
+  const inflight = new Map;
+  let running = 0;
+  const waiting = [];
+  return (root, mode) => {
+    const key = `${mode}${root}`;
+    const hit = cache.get(key);
+    if (hit !== undefined) {
+      if (hit.expiresAt > now())
+        return Promise.resolve(hit.value);
+      cache.delete(key);
+    }
+    const pending = inflight.get(key);
+    if (pending !== undefined)
+      return pending;
+    const scan = (async () => {
+      if (running >= maxConcurrent)
+        await new Promise((release) => waiting.push(release));
+      running += 1;
+      try {
+        return await enumerate(root, mode);
+      } finally {
+        running -= 1;
+        waiting.shift()?.();
+      }
+    })();
+    inflight.set(key, scan);
+    scan.then((value) => {
+      const at = now();
+      for (const [cached, entry] of cache) {
+        if (entry.expiresAt <= at)
+          cache.delete(cached);
+      }
+      while (cache.size >= maxCached)
+        cache.delete(cache.keys().next().value);
+      cache.set(key, { value, expiresAt: at + ttlMs });
+    }, () => {});
+    return scan.finally(() => inflight.delete(key));
+  };
+}
+function gitLines(cwd, args, limits) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn("git", ["-C", cwd, ...args], { stdio: ["ignore", "pipe", "pipe"] });
+    const chunks = [];
+    let bytes = 0;
+    let truncated = false;
+    let settled = false;
+    const kill = (markTruncated) => {
+      truncated ||= markTruncated;
+      child.kill("SIGKILL");
+    };
+    const timer = setTimeout(() => kill(true), Math.max(0, limits.deadline - limits.now()));
+    const finish = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (error !== undefined) {
+        rejectPromise(error);
+        return;
+      }
+      const output = Buffer.concat(chunks).toString("utf8");
+      const parts = output.split("\x00");
+      if (truncated)
+        parts.pop();
+      resolvePromise({ lines: parts.filter((part) => part !== ""), truncated });
+    };
+    child.stdout.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > limits.maxBytes) {
+        kill(true);
+        return;
+      }
+      chunks.push(chunk);
+      if (limits.now() > limits.deadline)
+        kill(true);
+    });
+    child.on("error", (error) => finish(error));
+    child.stderr.resume();
+    child.on("close", (code) => {
+      if (code === 0 || truncated) {
+        finish(undefined);
+      } else {
+        finish(new Error(`git ${args.join(" ")} exited with code ${code}`));
+      }
+    });
+  });
+}
+async function inWorkTree(root) {
+  return await new Promise((resolvePromise) => {
+    const child = spawn("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    child.stdout.on("data", (chunk) => out += chunk.toString("utf8"));
+    child.on("error", () => resolvePromise(false));
+    child.on("close", (code) => resolvePromise(code === 0 && out.trim() === "true"));
+  });
+}
+async function hasHead(root) {
+  return await new Promise((resolvePromise) => {
+    const child = spawn("git", ["-C", root, "rev-parse", "--verify", "-q", "HEAD"], { stdio: ["ignore", "ignore", "ignore"] });
+    child.on("error", () => resolvePromise(false));
+    child.on("close", (code) => resolvePromise(code === 0));
+  });
+}
+var STAGED_RECORD = /^([0-7]{6}) [0-9a-f]{40,64} [0-7]\t/;
+async function gitWorkingFiles(root, limits) {
+  const listing = await gitLines(root, ["ls-files", "-z", "-s", "--cached", "--others", "--exclude-standard"], limits);
+  const deleted = await gitLines(root, ["ls-files", "-z", "--deleted"], limits);
+  const gone = new Set(deleted.lines);
+  const files = new Set;
+  for (const line of listing.lines) {
+    const staged = STAGED_RECORD.exec(line);
+    const path = staged === null ? line : line.slice(staged[0].length);
+    if (staged !== null && staged[1] === "160000")
+      continue;
+    if (path === "" || path.endsWith("/") || gone.has(path))
+      continue;
+    files.add(path);
+  }
+  return { files: [...files], truncated: listing.truncated || deleted.truncated };
+}
+async function gitHeadFiles(root, limits) {
+  const listing = await gitLines(root, ["ls-tree", "-r", "-z", "HEAD"], limits);
+  const files = [];
+  for (const line of listing.lines) {
+    const tab = line.indexOf("\t");
+    if (tab === -1)
+      continue;
+    const kind = line.slice(0, tab).split(" ")[1];
+    if (kind === "blob")
+      files.push(line.slice(tab + 1));
+  }
+  return { files, truncated: listing.truncated };
+}
+async function walkFiles(root, limits) {
+  const files = [];
+  let entries = 0;
+  let truncated = false;
+  const dirs = [{ dir: root, prefix: "" }];
+  while (dirs.length > 0) {
+    if (limits.now() > limits.deadline) {
+      truncated = true;
+      break;
+    }
+    const { dir, prefix } = dirs.pop();
+    let handle;
+    try {
+      handle = await opendir(dir);
+    } catch (error) {
+      if (prefix === "")
+        throw error;
+      truncated = true;
+      continue;
+    }
+    for await (const entry of handle) {
+      if (entries++ >= limits.maxEntries || limits.now() > limits.deadline) {
+        truncated = true;
+        break;
+      }
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+          continue;
+        dirs.push({ dir: join6(dir, entry.name), prefix: `${prefix}${entry.name}/` });
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        files.push(`${prefix}${entry.name}`);
+      }
+    }
+    if (truncated)
+      break;
+  }
+  return { files, truncated };
+}
+async function enumerateRoot(root, mode, limits = {}) {
+  const now = limits.now ?? Date.now;
+  const bounded = {
+    now,
+    deadline: now() + (limits.budgetMs ?? SCAN_BUDGET_MS),
+    maxBytes: limits.maxBytes ?? MAX_OUTPUT_BYTES,
+    maxEntries: limits.maxEntries ?? MAX_WALK_ENTRIES
+  };
+  if (!await inWorkTree(root)) {
+    return walkFiles(root, bounded);
+  }
+  if (mode === "head" && !await hasHead(root)) {
+    return walkFiles(root, bounded);
+  }
+  return mode === "head" ? gitHeadFiles(root, bounded) : gitWorkingFiles(root, bounded);
+}
+function matchFiles(candidates, query, max = MAX_RESULTS) {
+  const usable = candidates.filter((path) => !UNUSABLE_PATH.test(path));
+  if (query === "") {
+    const sorted = [...usable].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    return { files: sorted.slice(0, max), truncated: sorted.length > max };
+  }
+  const needle = query.toLowerCase();
+  const tiers = [[], [], []];
+  for (const path of usable) {
+    const base = path.slice(path.lastIndexOf("/") + 1).toLowerCase();
+    const lower = path.toLowerCase();
+    if (base.startsWith(needle))
+      tiers[0].push(path);
+    else if (base.includes(needle))
+      tiers[1].push(path);
+    else if (lower.includes(needle))
+      tiers[2].push(path);
+  }
+  const shorter = (a, b) => a.length - b.length || (a < b ? -1 : a > b ? 1 : 0);
+  const matched = [...tiers[0].sort(shorter), ...tiers[1].sort(shorter), ...tiers[2].sort(shorter)];
+  return { files: matched.slice(0, max), truncated: matched.length > max };
+}
+async function listFiles(harness, dataDir, enumerate, scope, query, context) {
+  let root;
+  let mode = "live";
+  if (scope.kind === "conversation") {
+    const agent = await harness.snapshot(AgentDoc3, scope.conversationId, context);
+    if (agent === undefined)
+      throw new Error(`Conversation ${scope.conversationId} does not exist`);
+    const cwd = agent.cwd;
+    if (cwd === undefined)
+      throw new Error(`Conversation ${scope.conversationId} has no checkout`);
+    if (cwd.startsWith(join6(dataDir, "chats") + sep3))
+      return { files: [], truncated: false };
+    const info = await stat4(cwd).catch(() => {
+      return;
+    });
+    if (info === undefined || !info.isDirectory()) {
+      throw new Error(`Conversation ${scope.conversationId}'s checkout is unavailable: ${cwd}`);
+    }
+    root = cwd;
+  } else {
+    const normalized = await realpath4(resolve3(scope.path)).catch(() => resolve3(scope.path));
+    const index = await harness.snapshot(IndexDoc, context);
+    if (!index?.projects.some((project) => project.path === normalized)) {
+      throw new Error(`Unknown project: ${scope.path}`);
+    }
+    const info = await stat4(normalized).catch(() => {
+      return;
+    });
+    if (info === undefined || !info.isDirectory()) {
+      throw new Error(`Not a directory: ${normalized}`);
+    }
+    root = normalized;
+    mode = scope.checkout === "worktree" ? "head" : "live";
+  }
+  const candidates = await enumerate(root, mode);
+  const matched = matchFiles(candidates.files, query);
+  return { files: matched.files, truncated: matched.truncated || candidates.truncated };
+}
+
 // packages/protocol/src/images.ts
 var IMAGE_MIME_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
 var MAX_IMAGES_PER_MESSAGE = 4;
@@ -1651,6 +1958,378 @@ ${answer}`}`,
   });
 }
 
+// apps/host/src/push.ts
+import { createHash } from "node:crypto";
+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: 2,
+  scope: "session",
+  initial: () => ({ registrations: [] }),
+  migrate: () => ({ registrations: [] })
+});
+var APNS_TOKEN_PATTERN = /^(?:[0-9a-f]{2})+$/;
+var APNS_TOKEN_MAX_CHARS = 256;
+var isApnsEnvironment = (value) => value === "production" || value === "development";
+function pushTokenProblem(token) {
+  if (token === null)
+    return;
+  if (typeof token === "string") {
+    return "Push notifications no longer go through Expo — register the device's APNs token instead";
+  }
+  if (!isApnsEnvironment(token.environment)) {
+    return 'environment must be "production" or "development"';
+  }
+  const apns = token.apns.toLowerCase();
+  if (apns.length > APNS_TOKEN_MAX_CHARS) {
+    return `APNs token is too long (${APNS_TOKEN_MAX_CHARS} characters at most)`;
+  }
+  if (!APNS_TOKEN_PATTERN.test(apns))
+    return "Not an APNs device token (expected hex)";
+  return;
+}
+async function setPushToken(harness, publicKey, token, context3, joined) {
+  const problem = pushTokenProblem(token);
+  if (problem !== undefined)
+    throw new Error(problem);
+  if (token !== null && typeof token !== "string" && !await joined()) {
+    throw new Error("Push notifications need the host joined to an account (`pinomad join`)");
+  }
+  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 && typeof token !== "string") {
+      push.registrations.push({
+        publicKey,
+        token: token.apns.toLowerCase(),
+        environment: token.environment,
+        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 dropStaleRegistration(harness, token, environment, unregisteredAt, context3) {
+  await harness.commit(async (tx) => {
+    const push = await tx.doc(PushDoc);
+    push.registrations = push.registrations.filter((entry) => entry.token !== token || entry.environment !== environment || entry.updatedAt >= unregisteredAt);
+  }, context3);
+}
+var FALLBACK_TITLE = "PiNomad conversation";
+var TITLE_WAIT_MS = 15000;
+var TITLE_MAX_CHARS = 160;
+var MAX_ATTEMPTS = 4;
+var RETRY_BASE_MS = 5000;
+var MAX_INFLIGHT = 8;
+var MAX_PENDING = 128;
+var UNAVAILABLE_TRANSPORT = {
+  send: () => Promise.resolve({ result: "unavailable", reason: "no server connection" })
+};
+var realTimers = {
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+var tokenHint = (token) => `…${token.slice(-6)}`;
+var collapseId = (hostKey, id) => createHash("sha256").update(`${hostKey}:${id}`).digest("hex").slice(0, 32);
+async function attachPushSender(options) {
+  const { harness, conversations } = options;
+  const transport = options.transport ?? UNAVAILABLE_TRANSPORT;
+  const timers = options.timers ?? realTimers;
+  const maxPending = options.limits?.maxPending ?? MAX_PENDING;
+  const maxInflight = options.limits?.maxInflight ?? MAX_INFLIGHT;
+  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;
+  let inflight = 0;
+  const readyQueue = [];
+  let unavailableLogged = false;
+  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 doc?.registrations ?? [];
+  };
+  const findRegistration = (entries, item) => entries.find((entry) => entry.token === item.token && entry.environment === item.environment);
+  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((resolve4) => {
+      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);
+        resolve4(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 queuedAt = readyQueue.indexOf(item);
+    if (queuedAt >= 0)
+      readyQueue.splice(queuedAt, 1);
+  };
+  const pump = () => {
+    while (inflight < maxInflight) {
+      const next = readyQueue.shift();
+      if (next === undefined)
+        return;
+      next.queued = false;
+      attempt(next);
+    }
+  };
+  const scheduleRetry = (item, retryAfterMs) => {
+    if (item.attempts + 1 >= MAX_ATTEMPTS) {
+      console.error(`push: send to ${tokenHint(item.token)} gave up`);
+      drop(item);
+      return;
+    }
+    const delayMs = retryAfterMs ?? RETRY_BASE_MS * 2 ** item.attempts;
+    item.attempts += 1;
+    item.timer = timers.setTimeout(() => void attempt(item), delayMs);
+  };
+  const attempt = async (item) => {
+    if (disposed || !pending.has(item))
+      return;
+    try {
+      if (findRegistration(await registrations(), item) === undefined || !fresh(item))
+        return drop(item);
+      if (item.title === undefined) {
+        item.title = await titleFor(item.notice);
+        if (disposed || !pending.has(item) || findRegistration(await registrations(), item) === undefined || !fresh(item)) {
+          return drop(item);
+        }
+      }
+      if (inflight >= maxInflight) {
+        if (!item.queued) {
+          item.queued = true;
+          readyQueue.push(item);
+        }
+        return;
+      }
+      inflight += 1;
+      let verdict;
+      try {
+        verdict = await transport.send({
+          token: item.token,
+          environment: item.environment,
+          notification: {
+            title: item.title.slice(0, TITLE_MAX_CHARS),
+            body: item.notice.body,
+            collapseId: collapseId(options.hostKey, item.notice.id),
+            hostKey: options.hostKey,
+            conversationId: item.notice.id
+          }
+        });
+      } catch {
+        verdict = { result: "retry", reason: "transport error" };
+      } finally {
+        inflight -= 1;
+        pump();
+      }
+      if (disposed || !pending.has(item))
+        return drop(item);
+      switch (verdict.result) {
+        case "accepted":
+          drop(item);
+          return;
+        case "unregistered":
+          drop(item);
+          await dropStaleRegistration(harness, item.token, item.environment, verdict.unregisteredAt, context2);
+          return;
+        case "retry":
+          scheduleRetry(item, verdict.retryAfterMs);
+          return;
+        case "rejected":
+          console.error(`push: send to ${tokenHint(item.token)} rejected: ${verdict.reason}`);
+          drop(item);
+          return;
+        case "unavailable":
+          if (!unavailableLogged) {
+            unavailableLogged = true;
+            console.error(`push: ${verdict.reason} — notifications are not being delivered`);
+          }
+          drop(item);
+          return;
+      }
+    } catch (error) {
+      console.error(`push: send to ${tokenHint(item.token)} failed: ${error instanceof Error ? error.message : String(error)}`);
+      scheduleRetry(item);
+    }
+  };
+  const enqueue = async (notice) => {
+    if (disposed)
+      return;
+    const itemGeneration = generation.get(notice.id) ?? 0;
+    try {
+      const entries = await registrations();
+      const seen = new Set;
+      for (const entry of entries) {
+        if (disposed)
+          return;
+        const identity = `${entry.environment}:${entry.token}`;
+        if (seen.has(identity))
+          continue;
+        seen.add(identity);
+        if (pending.size >= maxPending) {
+          const [oldest] = pending;
+          drop(oldest);
+        }
+        const item = { token: entry.token, environment: entry.environment, notice, generation: itemGeneration, attempts: 0, queued: false };
+        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 {
+    stats: () => ({ pending: pending.size, queued: readyQueue.length }),
+    async close() {
+      disposed = true;
+      unsubscribeConversations();
+      unsubscribeCommits();
+      await indexWatch?.stop();
+      for (const item of pending)
+        drop(item);
+      pending.clear();
+      readyQueue.length = 0;
+      titleWaiters.clear();
+    }
+  };
+}
+
 // packages/protocol/src/tool-target.ts
 var TARGET_KEYS = [
   "path",
@@ -1678,154 +2357,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);
@@ -1840,6 +2373,7 @@ function serializedFork(harness, work) {
 var LOOPBACK_SECURE_PATH = "/secure";
 async function startGateway(options) {
   const conversations = await ConversationList.open(options.harness, options.docs);
+  const fileLister = createCandidateLister(enumerateRoot);
   const detachAutoTitle = options.autoTitle === false ? undefined : attachAutoTitle(conversations, {
     harness: options.harness,
     models: options.models,
@@ -1853,8 +2387,8 @@ async function startGateway(options) {
     });
   });
   const server = new WebSocketServer({ server: http });
-  await new Promise((resolve3, reject) => {
-    http.once("listening", resolve3);
+  await new Promise((resolve4, reject) => {
+    http.once("listening", resolve4);
     http.once("error", reject);
     http.listen(options.port, "127.0.0.1");
   });
@@ -1867,8 +2401,11 @@ async function startGateway(options) {
   };
   let remote;
   let relay;
-  const register = (connection, devicePublicKey) => {
-    const client = new GatewayClient(connection, options, conversations, {
+  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, fileLister, {
       devicePublicKey,
       closed: (self) => {
         clients.delete(self);
@@ -1884,20 +2421,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 +2454,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,17 +2465,38 @@ 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 }));
+          const push = state.push === undefined ? "undeclared" : state.push.length === 0 ? "none" : state.push.join(",");
+          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 {
@@ -1941,6 +2509,13 @@ async function startGateway(options) {
     });
     relay = link;
   }
+  const detachPush = options.push === undefined ? undefined : await attachPushSender({
+    harness: options.harness,
+    conversations,
+    hostKey: options.push.hostKey,
+    ...options.push.transport === undefined ? relay === undefined ? {} : { transport: { send: (request) => relay.sendPush(request) } } : { transport: options.push.transport },
+    ...options.push.timers === undefined ? {} : { timers: options.push.timers }
+  });
   return {
     url: `ws://127.0.0.1:${port}`,
     ...remote === undefined ? {} : { remote: { url: remote.url, advertiseUrl: remote.advertiseUrl } },
@@ -1949,22 +2524,24 @@ async function startGateway(options) {
     async close() {
       await relay?.close();
       detachAutoTitle?.();
+      detachSettingsWatch();
+      await detachPush?.close();
       conversations.dispose();
       await Promise.all([...clients].map((client) => client.dispose()));
       for (const socket of server.clients)
         socket.terminate();
       await remote?.close();
-      await new Promise((resolve3) => server.close(() => resolve3()));
-      await new Promise((resolve3) => http.close(() => resolve3()));
+      await new Promise((resolve4) => server.close(() => resolve4()));
+      await new Promise((resolve4) => http.close(() => resolve4()));
     }
   };
 }
 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((resolve4) => socket.send(text, () => resolve4())) : Promise.resolve(),
     close: (code, reason) => socket.close(code, reason),
     handle(handlers) {
       socket.on("message", (data) => handlers.message(String(data)));
@@ -1975,11 +2552,11 @@ 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((resolve4) => {
       const chunks = session.seal(text);
-      chunks.forEach((chunk, index) => socket.send(chunk, index === chunks.length - 1 ? () => resolve3() : undefined));
+      chunks.forEach((chunk, index) => socket.send(chunk, index === chunks.length - 1 ? () => resolve4() : undefined));
     }) : Promise.resolve(),
     close: (code, reason) => socket.close(code, reason),
     handle(handlers) {
@@ -2012,7 +2589,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 +2611,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 +2626,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 +2660,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);
@@ -2089,8 +2675,8 @@ async function startRemote(options, register) {
     async close() {
       for (const socket of secure.clients)
         socket.terminate();
-      await new Promise((resolve3) => secure.close(() => resolve3()));
-      await new Promise((resolve3) => http.close(() => resolve3()));
+      await new Promise((resolve4) => secure.close(() => resolve4()));
+      await new Promise((resolve4) => http.close(() => resolve4()));
     }
   };
 }
@@ -2101,6 +2687,7 @@ class ConversationList {
   #questionKinds;
   #records = new Map;
   #facts = new Map;
+  #roles = new Map;
   #index = new Map;
   #runEnd = new Set;
   #list = [];
@@ -2114,41 +2701,48 @@ class ConversationList {
     const list = new ConversationList(docs);
     const summaries = [];
     let cursor;
+    const records = [];
     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);
-        list.#facts.set(record.id, facts);
-        list.#index.set(record.id, summaries.length);
-        summaries.push(summaryOf(record, facts));
+        list.#facts.set(record.id, await list.#load(harness, record));
+        records.push(record);
       }
       cursor = page.next;
     } while (cursor !== undefined);
+    list.#roles = rolesOf(await harness.snapshot(IndexDoc, context3));
+    for (const record of records) {
+      list.#index.set(record.id, summaries.length);
+      summaries.push(list.#summaryOf(record));
+    }
     list.#list = summaries;
     list.#unsubscribe = harness.subscribeCommits((publication) => list.#observe(publication));
+    const touched = new Set;
+    list.#reindex(await harness.snapshot(IndexDoc, context3), touched);
+    list.#refreshSummaries(touched);
     return list;
   }
   async#load(harness, record) {
     const history = await historyFacts(harness, record.id);
     const facts = { pending: new Set, ...history };
-    const live = await harness.snapshot(LiveDoc, record.id, context2);
+    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;
@@ -2180,8 +2774,11 @@ class ConversationList {
         facts.calls = entry.kind === "pi.assistant" ? callsOf(message) : undefined;
       } else if (change.type === "document") {
         const id = change.conversationId;
-        if (id === undefined)
+        if (id === undefined) {
+          if (change.record.kind === IndexDoc.definition.kind)
+            this.#reindex(change.value, touched);
           continue;
+        }
         const facts = this.#fact(id);
         if (change.record.kind === "pi.live") {
           const live = change.value;
@@ -2194,12 +2791,12 @@ class ConversationList {
         } else if (this.#questionKinds.has(change.record.kind)) {
           const value = change.value;
           const pending = Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined);
-          const next2 = new Set(facts.pending);
+          const next = new Set(facts.pending);
           if (pending)
-            next2.add(change.record.kind);
+            next.add(change.record.kind);
           else
-            next2.delete(change.record.kind);
-          facts.pending = next2;
+            next.delete(change.record.kind);
+          facts.pending = next;
           touched.add(id);
         } else if (change.record.kind === SubagentDoc.definition.kind) {
           const value = change.value;
@@ -2213,12 +2810,35 @@ class ConversationList {
         }
       }
     }
+    this.#refreshSummaries(touched);
+    for (const id of ended)
+      for (const listener of this.#runEnd)
+        listener(id);
+  }
+  onRunEnd(listener) {
+    this.#runEnd.add(listener);
+    return () => this.#runEnd.delete(listener);
+  }
+  #reindex(index, touched) {
+    const next = rolesOf(index);
+    for (const record of this.#records.values()) {
+      if (record.owner === undefined && topLevelRole(record, this.#records, this.#roles) !== topLevelRole(record, this.#records, next)) {
+        touched.add(record.id);
+      }
+    }
+    this.#roles = next;
+  }
+  #summaryOf(record) {
+    const facts = this.#fact(record.id);
+    return summaryOf(record, facts, record.owner === undefined ? topLevelRole(record, this.#records, this.#roles) : facts.role);
+  }
+  #refreshSummaries(touched) {
     let next;
     for (const id of touched) {
       const record = this.#records.get(id);
       if (record === undefined)
         continue;
-      const summary = summaryOf(record, this.#fact(id));
+      const summary = this.#summaryOf(record);
       const index = this.#index.get(id);
       if (index === undefined) {
         next ??= this.#list.slice();
@@ -2231,13 +2851,6 @@ class ConversationList {
     }
     if (next !== undefined)
       this.#set(next);
-    for (const id of ended)
-      for (const listener of this.#runEnd)
-        listener(id);
-  }
-  onRunEnd(listener) {
-    this.#runEnd.add(listener);
-    return () => this.#runEnd.delete(listener);
   }
   #fact(id) {
     let facts = this.#facts.get(id);
@@ -2268,7 +2881,26 @@ class ConversationList {
     this.#listeners.clear();
   }
 }
-function summaryOf(record, facts) {
+function rolesOf(index) {
+  const roles = new Map;
+  for (const entry of index?.conversations ?? []) {
+    if (typeof entry.role === "string" && entry.role !== "")
+      roles.set(entry.id, entry.role);
+  }
+  return roles;
+}
+function topLevelRole(record, records, roles) {
+  let current = record;
+  const seen = new Set;
+  while (current !== undefined && !seen.has(current.id)) {
+    seen.add(current.id);
+    if (current.parent === undefined)
+      return roles.get(current.id);
+    current = records.get(current.parent.conversationId);
+  }
+  return;
+}
+function summaryOf(record, facts, role) {
   const parent = record.parent?.conversationId ?? record.owner?.conversationId;
   const status = facts.pending.size > 0 ? "needs-answer" : facts.running === true ? "running" : facts.failed === true ? "failed" : undefined;
   const runningSlot = facts.running === true ? facts.tools?.find((slot) => slot.status === "running") : undefined;
@@ -2285,7 +2917,7 @@ function summaryOf(record, facts) {
     ...status === undefined ? {} : { status },
     ...facts.updatedAt === undefined ? {} : { updatedAt: facts.updatedAt },
     ...facts.label === undefined ? {} : { label: facts.label },
-    ...facts.role === undefined ? {} : { role: facts.role },
+    ...role === undefined ? {} : { role },
     ...activity === undefined ? {} : { activity }
   };
 }
@@ -2301,12 +2933,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;
@@ -2341,12 +2973,14 @@ class GatewayClient {
   #connection;
   #hooks;
   #options;
+  #files;
   #hostValues;
   #subscriptions = new Map;
   #disposed = false;
-  constructor(connection, options, conversations, hooks) {
+  constructor(connection, options, conversations, files, hooks) {
     this.#connection = connection;
     this.#options = options;
+    this.#files = files;
     this.#hostValues = {
       conversations,
       mcp: options.mcp ?? constantValue(null),
@@ -2450,25 +3084,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;
@@ -2481,8 +3115,8 @@ class GatewayClient {
     await this.#conversation(id);
     const { harness } = this.#options;
     let signalCreation;
-    const created = new Promise((resolve3) => {
-      signalCreation = resolve3;
+    const created = new Promise((resolve4) => {
+      signalCreation = resolve4;
     });
     let inner;
     let stopped = false;
@@ -2494,7 +3128,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 +3141,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 +3175,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 +3191,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;
@@ -2573,15 +3207,16 @@ class GatewayClient {
           ...create.images === undefined ? {} : { images: create.images },
           ...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);
+          ...create.thinkingLevel === undefined ? {} : { thinkingLevel: create.thinkingLevel },
+          ...create.agent === undefined ? {} : { agent: create.agent }
+        }, settingsDefaults(this.#options.settings.value), this.#options.models, this.#options.modelSummaries, this.#options.agents?.value ?? { roles: [], problems: [] }, 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 +3231,20 @@ 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");
+        const joined = async () => await readServerConfig(this.#options.dataDir).catch(() => {
+          return;
+        }) !== undefined;
+        await setPushToken(this.#options.harness, device, args.token, context3, joined);
+        return null;
+      }
       case "logout": {
         const modelAuth = this.#options.modelAuth;
         if (modelAuth === undefined)
@@ -2634,6 +3279,10 @@ class GatewayClient {
       }
       case "listFolders":
         return listFolders(args.path, homedir2());
+      case "listFiles": {
+        const input = args;
+        return listFiles(this.#options.harness, this.#options.dataDir, this.#files, input.scope, input.query, context3);
+      }
     }
     const conversation = await this.#conversation(args.conversationId);
     switch (method) {
@@ -2642,9 +3291,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 +3317,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 +3335,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 +3347,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 +3371,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 +3413,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 +3440,18 @@ class GatewayClient {
         }
       }
       return dismissed;
-    }, context3);
+    }, context4);
   }
   get #chatsPrefix() {
-    return join6(this.#options.dataDir, "chats") + sep3;
+    return join7(this.#options.dataDir, "chats") + sep4;
   }
-  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 +3464,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(AgentDoc4, id, context3) ?? {};
   }
   async dispose() {
     if (this.#disposed)
@@ -2829,9 +3478,9 @@ class GatewayClient {
 }
 
 // apps/host/src/host.ts
-var context3 = BACKGROUND_CONTEXT3;
+var context4 = BACKGROUND_CONTEXT4;
 async function hostToken(dataDir) {
-  const path = join7(dataDir, "token");
+  const path = join8(dataDir, "token");
   try {
     return (await readFile4(path, "utf8")).trim();
   } catch {
@@ -2860,7 +3509,7 @@ async function openHost(options) {
     const reports = [];
     let report = (error) => void reports.push(error);
     const registry = createRegistry();
-    agentRoles = await openAgentRoles({ dir: join7(options.dataDir, "agents") });
+    agentRoles = await openAgentRoles({ dir: join8(options.dataDir, "agents") });
     extensions = typeof options.extensions === "function" ? options.extensions({
       harness: () => {
         if (harness === undefined)
@@ -2883,13 +3532,13 @@ async function openHost(options) {
       }
     });
     const hostSettings = await openHostSettings({
-      path: join7(options.dataDir, "settings.json"),
+      path: join8(options.dataDir, "settings.json"),
       fallback: options.settingsFallback,
       models: options.modelAuth?.models ?? constantValue(options.modelSummaries())
     });
     const environments = new Map;
-    const chatsDir = join7(options.dataDir, "chats");
-    harness = await Harness.open(await (options.openStorage ?? openNodeSqliteStorage)(join7(options.dataDir, "session.sqlite")), {
+    const chatsDir = join8(options.dataDir, "chats");
+    harness = await Harness.open(await (options.openStorage ?? openNodeSqliteStorage)(join8(options.dataDir, "session.sqlite")), {
       models: options.models,
       registry,
       env: async (target) => {
@@ -2897,8 +3546,8 @@ async function openHost(options) {
         if (cwd === undefined)
           return;
         const worktrees = worktreeRoot(options.dataDir);
-        if (cwd === worktrees || cwd.startsWith(worktrees + sep4)) {
-          const index = await target.read.snapshot(IndexDoc, context3);
+        if (cwd === worktrees || cwd.startsWith(worktrees + sep5)) {
+          const index = await target.read.snapshot(IndexDoc, context4);
           const record = checkoutAt(index?.checkouts, cwd);
           if (record !== undefined) {
             await ensureWorktree(record);
@@ -2918,11 +3567,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 +3592,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.transport === undefined ? {} : { transport: options.push.transport },
+          ...options.push.timers === undefined ? {} : { timers: options.push.timers }
+        }
+      },
       secure: {
         hostKey,
         offers,
@@ -2975,19 +3631,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 +3663,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;
   }
@@ -3209,11 +3871,18 @@ async function main(argv) {
       relay: { type: "string" }
     }
   });
-  const dataDir = resolve3(values["data-dir"] ?? DEFAULT_DATA_DIR);
+  const dataDir = resolve4(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)
+      agentsHome: join9(homedir3(), ".agents"),
+      checkout: (input, context5) => checkoutInfo(host2.harness(), input, context5)
     }),
     createCoding(options2),
     todo,
@@ -3230,7 +3899,7 @@ async function main(argv) {
     dataDir,
     projects: values.project ?? [],
     port: Number(values.port),
-    mcpConfig: join8(homedir3(), ".agents", "mcp.json"),
+    mcpConfig: join9(homedir3(), ".agents", "mcp.json"),
     browserOrigins: values["browser-origin"] ?? ["http://127.0.0.1:5199"],
     webRoot,
     ...values["lock-stale-ms"] === undefined ? {} : { lockStaleMs: Number(values["lock-stale-ms"]) },
@@ -3240,7 +3909,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 } });
@@ -3274,7 +3943,7 @@ async function main(argv) {
   }
   async function piOptions() {
     const modelRuntime = await ModelRuntime.create();
-    const modelAuth = await watchModelAuth(modelRuntime, { authPath: join8(getAgentDir(), "auth.json") });
+    const modelAuth = await watchModelAuth(modelRuntime, { authPath: join9(getAgentDir(), "auth.json") });
     const settingsManager = SettingsManager.create(process.cwd());
     configureHarnessHttp(settingsManager);
     const summaries = () => modelAuth.models.value;
@@ -3286,6 +3955,7 @@ async function main(argv) {
       modelAuth,
       extensions: extensionsFor(modelRuntime, summaries, { images }),
       settings: (store) => createHarnessSettings(settingsManager, store),
+      push: {},
       settingsFallback: {
         defaultModel: () => {
           const model2 = defaultModel(settingsManager, modelRuntime);
@@ -3305,7 +3975,7 @@ async function main(argv) {
   console.log(JSON.stringify({
     event: "ready",
     url: host.url,
-    tokenFile: join8(dataDir, "token"),
+    tokenFile: join9(dataDir, "token"),
     dataDir,
     model,
     web,