pinomad 0.4.0 → 0.6.0

package/dist/{chunk-z5pmcscx.js → chunk-4btj08we.js}

@@ -1,32 +1,14 @@
 #!/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-fgx2sh7d.js";
-import {
-  HOST_SETTING_KEYS,
-  INVALID_FRAME_CLOSE_CODE,
-  PROTOCOL,
-  THINKING_LEVELS,
-  UNAUTHORIZED_CLOSE_CODE,
-  isQueueMode,
-  isThinkingLevel,
-  organize,
-  parseClientFrame
-} from "./chunk-myjp910s.js";
+  Published,
+  constantValue,
+  openHostSettings,
+  sameList,
+  settingsDefaults
+} from "./chunk-b1h374jr.js";
 import {
   DevicesDoc,
   RevocationsDoc,
@@ -34,24 +16,45 @@ import {
   ensureDevices,
   loadHostKey,
   loadRelayKey,
-  pairingOffers
-} from "./chunk-837gh8nr.js";
+  normalizeOrigin,
+  pairingOffers,
+  readServerBinding,
+  readServerConfig,
+  resolveRelayOrigin
+} from "./chunk-0xh6cy9v.js";
 import {
   SECURE_PROLOGUE,
   SecureSession,
   decodeClientHello,
   encodeHostHello,
+  relayWsBase,
   respondIK,
+  startRelayLink,
   toBase64Url
-} from "./chunk-7gmkgyaz.js";
+} from "./chunk-7qb9tq54.js";
+import {
+  packagedVersion,
+  webRoot
+} from "./chunk-c8nxym2z.js";
+import {
+  INVALID_FRAME_CLOSE_CODE,
+  PROTOCOL,
+  UNAUTHORIZED_CLOSE_CODE,
+  organize,
+  parseClientFrame
+} from "./chunk-n4tjhcb7.js";
+import {
+  THINKING_LEVELS,
+  isThinkingLevel
+} from "./chunk-znhn8af7.js";
 import {
   DEFAULT_DATA_DIR
-} from "./chunk-cjfmfyjb.js";
+} from "./chunk-ngf1zatm.js";
 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";
@@ -185,7 +188,7 @@ function result(questions, resolution) {
 var askUserQuestion = defineTool({
   name: "ask_user_question",
   callers: ["model"],
-  description: "Ask the user 1–4 multiple-choice questions when their decision is needed to proceed (ambiguous requirements, choosing between approaches, scope). Blocks until answered. The user can always type a custom answer, so never add an 'Other' option. Keep headers short.",
+  description: "Ask the user 1–4 multiple-choice questions when their decision is needed to proceed (ambiguous requirements, choosing between approaches, scope). Blocks until answered. The user can always type a custom answer, so never add an 'Other' option. Keep everything short: headers a word or two, option labels a few words. Usually leave option descriptions out; add one only when the label alone is ambiguous, as one line of at most ~60 characters.",
   parameters: Type2.Object({
     questions: Type2.Array(QuestionItemSchema, { minItems: 1, maxItems: 4 })
   }),
@@ -289,6 +292,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)
@@ -525,8 +529,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 { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+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";
@@ -541,7 +545,7 @@ import {
 } from "@earendil-works/pi-durable";
 
 // apps/host/src/checkout.ts
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { realpath, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -549,6 +553,42 @@ import { join as join2, relative, sep as sep2 } from "node:path";
 import { promisify } from "node:util";
 var run = promisify(execFile);
 var git = (dir, args, env) => run("git", ["-C", dir, ...args], env === undefined ? {} : { env: { ...process.env, ...env } });
+function gitCapped(dir, args, maxBytes, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", ["-C", dir, ...args], env === undefined ? {} : { env: { ...process.env, ...env } });
+    const chunks = [];
+    let size = 0;
+    let killed = false;
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      if (killed)
+        return;
+      chunks.push(chunk);
+      size += chunk.length;
+      if (size > maxBytes) {
+        killed = true;
+        child.kill();
+        child.stdout.destroy();
+        child.stderr.destroy();
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderr.length < 8192)
+        stderr += chunk.toString("utf8");
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      const stdout = Buffer.concat(chunks).toString("utf8");
+      if (killed)
+        resolve({ stdout, truncated: true });
+      else if (code === 0)
+        resolve({ stdout, truncated: false });
+      else
+        reject(Object.assign(new Error(`Command failed: git ${args.join(" ")}
+${stderr}`), { code, stderr }));
+    });
+  });
+}
 var worktreeRoot = (dataDir) => join2(dataDir, "worktrees");
 var worktreePath = (dataDir, id) => join2(worktreeRoot(dataDir), String(id));
 var worktreeBranch = (id, suffix) => `pinomad/${id}-${suffix}`;
@@ -568,6 +608,15 @@ async function gitBase(projectPath) {
     return;
   return { repo, subdir: relative(repo, projectPath), base };
 }
+async function branchOf(dir) {
+  const ref = await git(dir, ["symbolic-ref", "--quiet", "HEAD"]).then(({ stdout }) => stdout.trim(), () => {
+    return;
+  });
+  const prefix = "refs/heads/";
+  if (ref === undefined || !ref.startsWith(prefix))
+    return;
+  return ref.slice(prefix.length) || undefined;
+}
 var repoLocks = new Map;
 function locked(repo, work) {
   const next = (repoLocks.get(repo) ?? Promise.resolve()).then(work, work);
@@ -618,12 +667,11 @@ async function changesOf(dir, base, maxBytes = 1024 * 1024) {
   try {
     await git(dir, ["read-tree", "HEAD"], env);
     await git(dir, ["add", "-A"], env);
-    const { stdout } = await git(dir, ["diff", "--cached", "--no-color", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", base], env);
-    if (Buffer.byteLength(stdout) <= maxBytes)
+    const { stdout, truncated } = await gitCapped(dir, ["diff", "--cached", "--no-color", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", base], maxBytes, env);
+    if (!truncated && Buffer.byteLength(stdout) <= maxBytes)
       return { base, patch: stdout, truncated: false };
-    const cut = stdout.slice(0, maxBytes);
-    const patch = cut.slice(0, cut.lastIndexOf(`
-`) + 1);
+    const cut = Buffer.from(stdout, "utf8").subarray(0, maxBytes);
+    const patch = cut.subarray(0, cut.lastIndexOf(10) + 1).toString("utf8");
     return { base, patch, truncated: true };
   } finally {
     await rm(indexFile, { force: true });
@@ -686,7 +734,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) {
@@ -696,12 +760,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;
@@ -712,7 +788,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);
@@ -723,7 +800,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)
@@ -1164,39 +1247,6 @@ function agentRoleProblem(role) {
   return;
 }
 
-// apps/host/src/host-value.ts
-function constantValue(value) {
-  return {
-    value,
-    subscribe: () => () => {}
-  };
-}
-
-class Published {
-  #listeners = new Set;
-  #equal;
-  #value;
-  constructor(value, equal) {
-    this.#value = value;
-    this.#equal = equal;
-  }
-  get value() {
-    return this.#value;
-  }
-  subscribe(listener) {
-    this.#listeners.add(listener);
-    return () => this.#listeners.delete(listener);
-  }
-  set(next) {
-    if (this.#equal(this.#value, next))
-      return;
-    this.#value = next;
-    for (const listener of this.#listeners)
-      listener(next);
-  }
-}
-var sameList = (a, b, same) => a.length === b.length && a.every((entry, index) => same(entry, b[index]));
-
 // apps/host/src/agent-roles.ts
 var KNOWN_FIELDS = new Set(["description", "model", "thinkingLevel"]);
 async function load(dir) {
@@ -1350,114 +1400,6 @@ async function openAgentRoles(options) {
   };
 }
 
-// apps/host/src/host-settings.ts
-import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
-function settingsDefaults(settings) {
-  return {
-    ...settings.defaultModel === null ? {} : { model: settings.defaultModel },
-    ...settings.defaultThinkingLevel === null ? {} : { thinkingLevel: settings.defaultThinkingLevel }
-  };
-}
-var isModelRef = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.provider === "string" && value.provider !== "" && typeof value.modelId === "string" && value.modelId !== "";
-var fileValueError = (key, value, models) => {
-  switch (key) {
-    case "defaultModel":
-      if (!isModelRef(value))
-        return "malformed";
-      return models.some((each) => each.provider === value.provider && each.modelId === value.modelId) ? undefined : "unavailable";
-    case "defaultThinkingLevel":
-      return isThinkingLevel(value) ? undefined : "malformed";
-    case "steeringMode":
-    case "followUpMode":
-      return isQueueMode(value) ? undefined : "malformed";
-    case "acceptAccountDevices":
-      return typeof value === "boolean" ? undefined : "malformed";
-  }
-};
-var sameModel = (a, b) => a === b || a !== null && b !== null && a.provider === b.provider && a.modelId === b.modelId;
-var sameSettings = (a, b) => a.steeringMode === b.steeringMode && a.followUpMode === b.followUpMode && a.acceptAccountDevices === b.acceptAccountDevices && a.defaultThinkingLevel === b.defaultThinkingLevel && sameModel(a.defaultModel, b.defaultModel) && sameList(a.custom, b.custom, (x, y) => x === y);
-var parse = (path, text) => {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch (error) {
-    throw new Error(`Invalid settings file ${path}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error(`Invalid settings file ${path}: expected a JSON object`);
-  }
-  return parsed;
-};
-async function openHostSettings(options) {
-  let file = await readFile3(options.path, "utf8").then((text) => parse(options.path, text), (error) => {
-    if (error.code === "ENOENT")
-      return {};
-    throw new Error(`Cannot read settings file ${options.path}: ${error instanceof Error ? error.message : String(error)}`);
-  });
-  const warned = new Set;
-  const compute = () => {
-    const fileValues = {};
-    const custom = [];
-    for (const key of HOST_SETTING_KEYS) {
-      if (!Object.hasOwn(file, key))
-        continue;
-      const value = file[key];
-      const invalid = fileValueError(key, value, options.models.value);
-      if (invalid === "malformed" && !warned.has(key)) {
-        warned.add(key);
-        console.error(`${options.path}: ignoring invalid value for settings key "${key}": ${JSON.stringify(value)}`);
-      }
-      if (invalid !== undefined)
-        continue;
-      fileValues[key] = value;
-      custom.push(key);
-    }
-    const { fallback } = options;
-    return {
-      defaultModel: fileValues.defaultModel ?? fallback.defaultModel(),
-      defaultThinkingLevel: fileValues.defaultThinkingLevel ?? fallback.defaultThinkingLevel(),
-      steeringMode: fileValues.steeringMode ?? fallback.steeringMode(),
-      followUpMode: fileValues.followUpMode ?? fallback.followUpMode(),
-      acceptAccountDevices: fileValues.acceptAccountDevices ?? true,
-      custom
-    };
-  };
-  const published = new Published(compute(), sameSettings);
-  options.models.subscribe(() => published.set(compute()));
-  let tail = Promise.resolve();
-  const write = async (patch) => {
-    const model = patch.defaultModel;
-    if (model !== undefined && model !== null && !options.models.value.some((each) => each.provider === model.provider && each.modelId === model.modelId)) {
-      throw new Error(`Unknown model: ${model.provider}/${model.modelId}`);
-    }
-    const next = { ...file };
-    for (const key of HOST_SETTING_KEYS) {
-      const value = patch[key];
-      if (value === undefined)
-        continue;
-      if (value === null)
-        delete next[key];
-      else
-        next[key] = value;
-    }
-    const tmp = `${options.path}.tmp`;
-    await mkdir3(dirname2(options.path), { recursive: true });
-    await writeFile2(tmp, `${JSON.stringify(next, null, 2)}
-`, { mode: 384 });
-    await rename2(tmp, options.path);
-    file = next;
-    published.set(compute());
-  };
-  return {
-    get value() {
-      return published.value;
-    },
-    subscribe: (listener) => published.subscribe(listener),
-    update: (patch) => tail = tail.then(() => write(patch), () => write(patch))
-  };
-}
-
 // apps/host/src/host.ts
 import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
 import lockfile from "proper-lockfile";
@@ -1465,11 +1407,11 @@ 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 { 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, WebSocketServer } from "ws";
@@ -1516,6 +1458,273 @@ async function listFolders(path, home) {
   return { path: dir, home: await realpath3(home).catch(() => home), folders };
 }
 
+// apps/host/src/files.ts
+import { spawn as spawn2 } 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 = spawn2("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 = spawn2("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 = spawn2("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;
@@ -1660,6 +1869,7 @@ ${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";
 
@@ -1721,26 +1931,38 @@ function diffRunNotices(previous, organized) {
 var context2 = BACKGROUND_CONTEXT2;
 var PushDoc = defineDoc6({
   kind: "pinomad.push",
-  version: 1,
+  version: 2,
   scope: "session",
-  initial: () => ({ registrations: [] })
+  initial: () => ({ registrations: [] }),
+  migrate: () => ({ registrations: [] })
 });
-var PUSH_TOKEN_PATTERN = /^Expo(?:nent)?PushToken\[[^\]]+\]$/;
-var PUSH_TOKEN_MAX_LENGTH = 256;
+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 (token.length > PUSH_TOKEN_MAX_LENGTH) {
-    return `Push token is too long (${PUSH_TOKEN_MAX_LENGTH} characters at most)`;
+  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"';
   }
-  if (!PUSH_TOKEN_PATTERN.test(token))
-    return "Not an Expo push token";
+  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) {
+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)) {
@@ -1748,8 +1970,14 @@ async function setPushToken(harness, publicKey, token, context3) {
     }
     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() });
+    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) {
@@ -1763,38 +1991,43 @@ async function revokeDevice(harness, publicKey, context3) {
       revocations.revoked.push(publicKey);
   }, context3);
 }
-async function dropTokenIfCurrent(harness, token, 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);
+    push.registrations = push.registrations.filter((entry) => entry.token !== token || entry.environment !== environment || entry.updatedAt >= unregisteredAt);
   }, 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 TITLE_MAX_CHARS = 160;
 var MAX_ATTEMPTS = 4;
 var RETRY_BASE_MS = 5000;
-var RECEIPT_DELAY_MS = 15 * 60 * 1000;
+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 fetcher = options.fetch ?? fetch;
+  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;
-  const receiptTimers = new Set;
+  let inflight = 0;
+  const readyQueue = [];
+  let unavailableLogged = false;
   const generation = new Map;
   const update = () => {
     if (index === undefined)
@@ -1816,32 +2049,9 @@ async function attachPushSender(options) {
   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;
+    return doc?.registrations ?? [];
   };
-  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 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;
@@ -1852,7 +2062,7 @@ async function attachPushSender(options) {
       return named;
     if (notice.body !== "Finished" || disposed)
       return FALLBACK_TITLE;
-    return await new Promise((resolve3) => {
+    return await new Promise((resolve4) => {
       const waiters = titleWaiters.get(notice.id) ?? new Set;
       titleWaiters.set(notice.id, waiters);
       const settle = (title) => {
@@ -1860,7 +2070,7 @@ async function attachPushSender(options) {
         if (waiters.size === 0)
           titleWaiters.delete(notice.id);
         timers.clearTimeout(timer);
-        resolve3(title);
+        resolve4(title);
       };
       const timer = timers.setTimeout(() => settle(FALLBACK_TITLE), TITLE_WAIT_MS);
       waiters.add(settle);
@@ -1874,78 +2084,96 @@ async function attachPushSender(options) {
     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 (!(await registrations()).has(item.token) || !fresh(item))
+      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) || !(await registrations()).has(item.token) || !fresh(item))
+        if (disposed || !pending.has(item) || findRegistration(await registrations(), item) === undefined || !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));
+      if (inflight >= maxInflight) {
+        if (!item.queued) {
+          item.queued = true;
+          readyQueue.push(item);
+        }
         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;
+      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();
       }
-      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 (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;
       }
-      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)}`);
+      console.error(`push: send to ${tokenHint(item.token)} failed: ${error instanceof Error ? error.message : String(error)}`);
+      scheduleRetry(item);
     }
   };
   const enqueue = async (notice) => {
@@ -1953,15 +2181,20 @@ async function attachPushSender(options) {
       return;
     const itemGeneration = generation.get(notice.id) ?? 0;
     try {
-      const tokens = await registrations();
-      for (const token of tokens) {
+      const entries = await registrations();
+      const seen = new Set;
+      for (const entry of entries) {
         if (disposed)
           return;
-        if (pending.size >= MAX_PENDING) {
+        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, notice, generation: itemGeneration, attempts: 0 };
+        const item = { token: entry.token, environment: entry.environment, notice, generation: itemGeneration, attempts: 0, queued: false };
         pending.add(item);
         attempt(item);
       }
@@ -1991,18 +2224,19 @@ async function attachPushSender(options) {
     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();
+  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();
+    }
   };
 }
 
@@ -2049,18 +2283,12 @@ 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,
     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)
@@ -2069,8 +2297,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");
   });
@@ -2087,7 +2315,7 @@ async function startGateway(options) {
     if (joined?.source === "account") {
       broadcast("info", `New device "${joined.name}" joined through your account`);
     }
-    const client = new GatewayClient(connection, options, conversations, {
+    const client = new GatewayClient(connection, options, conversations, fileLister, {
       devicePublicKey,
       closed: (self) => {
         clients.delete(self);
@@ -2161,6 +2389,12 @@ async function startGateway(options) {
       signingKey: secure.relay.signingKey,
       noisePublicKey: secure.hostKey.publicKey,
       accept: (socket) => secureHandshake(socket, secure, admission, register),
+      hostName: {
+        get value() {
+          return options.settings.value.hostName;
+        },
+        subscribe: (listener) => options.settings.subscribe((settings) => listener(settings.hostName))
+      },
       accountOffer: async () => {
         if (!options.settings.value.acceptAccountDevices)
           return { ok: false, reason: "disabled" };
@@ -2177,7 +2411,8 @@ async function startGateway(options) {
       },
       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 {
@@ -2190,6 +2425,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 } },
@@ -2199,14 +2441,14 @@ async function startGateway(options) {
       await relay?.close();
       detachAutoTitle?.();
       detachSettingsWatch();
-      await detachPush?.();
+      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()));
     }
   };
 }
@@ -2215,7 +2457,7 @@ function tokenConnection(socket) {
     get open() {
       return socket.readyState === WebSocket.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket.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)));
@@ -2228,9 +2470,9 @@ function secureConnection(socket, session) {
     get open() {
       return socket.readyState === WebSocket.OPEN;
     },
-    send: (text) => socket.readyState === WebSocket.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) {
@@ -2349,8 +2591,8 @@ async function startRemote(options, admission, 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()));
     }
   };
 }
@@ -2361,6 +2603,7 @@ class ConversationList {
   #questionKinds;
   #records = new Map;
   #facts = new Map;
+  #roles = new Map;
   #index = new Map;
   #runEnd = new Set;
   #list = [];
@@ -2374,19 +2617,26 @@ class ConversationList {
     const list = new ConversationList(docs);
     const summaries = [];
     let cursor;
+    const records = [];
     do {
       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) {
@@ -2440,8 +2690,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;
@@ -2454,12 +2707,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;
@@ -2473,12 +2726,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();
@@ -2491,13 +2767,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);
@@ -2528,7 +2797,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;
@@ -2545,7 +2833,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 }
   };
 }
@@ -2601,12 +2889,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),
@@ -2741,8 +3031,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;
@@ -2833,8 +3123,9 @@ 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, context3);
+          ...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": {
@@ -2864,7 +3155,10 @@ class GatewayClient {
         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);
+        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": {
@@ -2901,6 +3195,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) {
@@ -3061,7 +3359,7 @@ class GatewayClient {
     }, context4);
   }
   get #chatsPrefix() {
-    return join6(this.#options.dataDir, "chats") + sep3;
+    return join7(this.#options.dataDir, "chats") + sep4;
   }
   async#changes(conversation, context4) {
     const cwd = (await conversation.agent(context4)).cwd;
@@ -3074,15 +3372,16 @@ class GatewayClient {
     if (record !== undefined) {
       if (!await worktreeExists(record.path))
         return { available: false, reason: "No changes yet" };
-      return { available: true, ...await changesOf(record.path, record.base) };
+      const [changes, branch2] = await Promise.all([changesOf(record.path, record.base), branchOf(record.path)]);
+      return { available: true, ...changes, branch: branch2 };
     }
-    const base = await gitBase(cwd);
+    const [base, branch] = await Promise.all([gitBase(cwd), branchOf(cwd)]);
     if (base === undefined)
-      return { available: false, reason: "Not in a git repository" };
-    return { available: true, ...await changesOf(base.repo, base.base) };
+      return { available: false, reason: "Not in a git repository", branch };
+    return { available: true, ...await changesOf(base.repo, base.base), branch };
   }
   async#agent(id) {
-    return await this.#options.harness.snapshot(AgentDoc3, id, context3) ?? {};
+    return await this.#options.harness.snapshot(AgentDoc4, id, context3) ?? {};
   }
   async dispose() {
     if (this.#disposed)
@@ -3098,18 +3397,18 @@ class GatewayClient {
 // apps/host/src/host.ts
 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();
+    return (await readFile3(path, "utf8")).trim();
   } catch {
     const token = randomBytes3(24).toString("base64url");
-    await writeFile3(path, `${token}
+    await writeFile2(path, `${token}
 `, { mode: 384 });
     return token;
   }
 }
 async function openHost(options) {
-  await mkdir4(options.dataDir, { recursive: true });
+  await mkdir3(options.dataDir, { recursive: true });
   const stale = Math.max(2000, options.lockStaleMs ?? 1e4);
   const release = await lockfile.lock(options.dataDir, {
     realpath: false,
@@ -3127,7 +3426,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)
@@ -3150,13 +3449,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) => {
@@ -3164,16 +3463,16 @@ async function openHost(options) {
         if (cwd === undefined)
           return;
         const worktrees = worktreeRoot(options.dataDir);
-        if (cwd === worktrees || cwd.startsWith(worktrees + sep4)) {
+        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);
-            await mkdir4(cwd, { recursive: true });
+            await mkdir3(cwd, { recursive: true });
           }
         }
         if (cwd.startsWith(`${chatsDir}/`))
-          await mkdir4(cwd, { recursive: true });
+          await mkdir3(cwd, { recursive: true });
         let env = environments.get(cwd);
         if (env === undefined) {
           env = new NodeExecutionEnv({ cwd });
@@ -3213,7 +3512,7 @@ async function openHost(options) {
       ...options.push === undefined ? {} : {
         push: {
           hostKey: toBase64Url(hostKey.publicKey),
-          ...options.push.fetch === undefined ? {} : { fetch: options.push.fetch },
+          ...options.push.transport === undefined ? {} : { transport: options.push.transport },
           ...options.push.timers === undefined ? {} : { timers: options.push.timers }
         }
       },
@@ -3289,7 +3588,7 @@ async function openHost(options) {
 
 // apps/host/src/model-auth.ts
 import { existsSync as existsSync2, watch as watch2 } from "node:fs";
-import { basename as basename3, dirname as dirname3 } from "node:path";
+import { basename as basename3, dirname as dirname2 } from "node:path";
 
 // apps/host/src/pi-setup.ts
 import { getSupportedThinkingLevels as getSupportedThinkingLevels2 } from "@earendil-works/pi-ai";
@@ -3404,7 +3703,7 @@ function modelSummaries(modelRuntime) {
 }
 
 // apps/host/src/model-auth.ts
-var sameModel2 = (a, b) => a.provider === b.provider && a.modelId === b.modelId && a.name === b.name && a.contextWindow === b.contextWindow && sameList(a.thinkingLevels, b.thinkingLevels, (x, y) => x === y);
+var sameModel = (a, b) => a.provider === b.provider && a.modelId === b.modelId && a.name === b.name && a.contextWindow === b.contextWindow && sameList(a.thinkingLevels, b.thinkingLevels, (x, y) => x === y);
 var sameLogin = (a, b) => a.providerId === b.providerId && a.name === b.name && a.kind === b.kind && a.subscription === b.subscription;
 async function storedLogins(modelRuntime) {
   const credentials = await modelRuntime.listCredentials();
@@ -3419,7 +3718,7 @@ async function storedLogins(modelRuntime) {
 }
 async function watchModelAuth(modelRuntime, options) {
   const debounceMs = options.debounceMs ?? 150;
-  const models = new Published(modelSummaries(modelRuntime), (a, b) => sameList(a, b, sameModel2));
+  const models = new Published(modelSummaries(modelRuntime), (a, b) => sameList(a, b, sameModel));
   const auth = new Published(await storedLogins(modelRuntime), (a, b) => sameList(a.logins, b.logins, sameLogin));
   const fileName = basename3(options.authPath);
   let watcher;
@@ -3438,7 +3737,7 @@ async function watchModelAuth(modelRuntime, options) {
       reported = true;
     }
   };
-  const directory = dirname3(options.authPath);
+  const directory = dirname2(options.authPath);
   if (existsSync2(directory)) {
     watcher = watch2(directory, (_event, changed) => {
       if (closed || changed !== null && changed !== fileName)
@@ -3489,7 +3788,7 @@ 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));
@@ -3499,7 +3798,7 @@ async function main(argv) {
   }
   const extensionsFor = (models, summaries, options2) => (host2) => [
     createContext({
-      agentsHome: join8(homedir3(), ".agents"),
+      agentsHome: join9(homedir3(), ".agents"),
       checkout: (input, context5) => checkoutInfo(host2.harness(), input, context5)
     }),
     createCoding(options2),
@@ -3517,7 +3816,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"]) },
@@ -3561,7 +3860,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;
@@ -3593,7 +3892,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,