tryharness 0.7.16 → 0.7.22

package/lib/folders.mjs

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { mainCheckout } from "./worktrees.mjs";
+import { nameOf } from "./members.mjs";
+import { paths } from "./paths.mjs";
+import { t3Projects } from "./places.mjs";
+
+// Where the person's threads work. The folder is the person's to choose, any folder on the computer: the composer offers
+// the folders they work in (T3 Code's projects, the folders their agents' sessions and threads ran in) and browses from
+// their home folder. With none chosen, Harness picks one from the message among those folders (src/server/swarm/folder.ts),
+// else the folder the agent last worked in. The home folder itself and hidden folders are never offered or picked, nor
+// Harness's and T3's own copies (their repository's checkout stands for them): work there is never what was meant (the
+// owner's October 13 thread ran Codex over their whole home folder).
+
+const CODING = new Set(["claude-code", "codex", "pi", "opencode"]);
+// Folders offered and sent to Jev: the most recently worked in. Browsing reaches any other.
+const OFFERED = 60;
+const LISTED = 200;
+const README_MAX = 100_000;
+const TOP_LEVEL_MAX = 2_000;
+const PICK_TTL_MS = 10 * 60_000;
+const README = /^readme(\.(md|markdown|txt|rst))?$/i;
+
+const realDir = (dir) => { try { return fs.realpathSync(dir); } catch { return null; } };
+export const isDir = (dir) => typeof dir === "string" && path.isAbsolute(dir) && fs.statSync(dir, { throwIfNoEntry: false })?.isDirectory() === true;
+
+const within = (dir, root) => { const rel = root ? path.relative(root, dir) : ".."; return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel)); };
+
+/** A folder Harness may offer or pick by itself: not the home folder or above it, not hidden, not Harness's own, not gone. */
+function offerable(dir) {
+  const real = realDir(dir);
+  if (!real || !isDir(real) || within(real, realDir(paths.home))) return false;
+  const home = realDir(os.homedir()) ?? os.homedir();
+  const rel = path.relative(home, real);
+  if (rel === "" || path.parse(real).root === real) return false;
+  if (!rel.startsWith("..") && !path.isAbsolute(rel)) return !rel.split(path.sep).some((part) => part.startsWith("."));
+  return !real.split(path.sep).some((part) => part.startsWith("."));
+}
+
+const git = (cwd, args) => { const found = spawnSync("git", args, { cwd, encoding: "utf8", timeout: 2_000 }); return found.status === 0 ? (found.stdout || "").trim() : ""; };
+
+/** What Jev reads of a folder: its name, repository, top level and README, whole. */
+function facts(place) {
+  let entries = [];
+  try { entries = fs.readdirSync(place.path, { withFileTypes: true }).filter((entry) => ![".git", ".DS_Store"].includes(entry.name)); } catch {}
+  const readme = entries.find((entry) => entry.isFile() && README.test(entry.name));
+  let text = null;
+  try { text = readme ? fs.readFileSync(path.join(place.path, readme.name), "utf8") : null; } catch {}
+  // A remote's address without any credentials in it.
+  const remote = git(place.path, ["remote", "get-url", "origin"]).replace(/\/\/[^@/]+@/, "//");
+  return {
+    path: place.path, name: place.name, repository: remote || null,
+    topLevel: entries.map((entry) => `${entry.name}${entry.isDirectory() ? "/" : ""}`).sort().slice(0, TOP_LEVEL_MAX),
+    readme: text && text.length <= README_MAX ? text : null,
+    agents: place.agents.map(nameOf), lastWorked: place.lastWorked,
+  };
+}
+
+export function createFolders({ store, askHarness, canAsk, privacy, log = () => {} }) {
+  /** The folders the person works in, most recently worked in first: { path, name, t3, agents, lastWorked }. */
+  const known = () => {
+    const byPath = new Map();
+    const add = (dir, agent, at) => {
+      const where = realDir(dir) && realDir(mainCheckout(realDir(dir)));
+      if (!where || !offerable(where)) return;
+      const place = byPath.get(where) ?? { path: where, name: path.basename(where), t3: false, agents: [], lastWorked: null };
+      if (agent && CODING.has(agent) && !place.agents.includes(agent)) place.agents.push(agent);
+      if (at && (!place.lastWorked || at > place.lastWorked)) place.lastWorked = at;
+      byPath.set(where, place);
+    };
+    for (const row of store.sessionFolders(300)) add(row.cwd, row.agent, row.at);
+    for (const thread of store.goals({ all: true })) if (thread.goal?.workspace) for (const agent of thread.goal.team) add(thread.goal.workspace, agent, thread.updated_at || thread.created_at);
+    const projects = t3Projects();
+    for (const dir of projects) add(dir, null, null);
+    for (const place of byPath.values()) place.t3 = projects.includes(place.path);
+    return [...byPath.values()].sort((a, b) => (b.lastWorked ?? "").localeCompare(a.lastWorked ?? "") || a.name.localeCompare(b.name)).slice(0, OFFERED);
+  };
+
+  /**
+   * Any folder on the computer, from a path the person types: a folder's own folders, or the folders beside a partly
+   * typed name that start with it. "~" is the home folder. Hidden folders show once their name is typed.
+   */
+  const browse = (typed) => {
+    const raw = String(typed ?? "").trim() || "~";
+    const expanded = raw === "~" ? os.homedir() : raw.startsWith("~/") ? path.join(os.homedir(), raw.slice(2)) : raw;
+    if (!path.isAbsolute(expanded)) return { ok: false, error: "type a full path, or start with ~" };
+    // "~" or a path ending in "/" lists that folder; anything else lists the folders beside it that start with its name.
+    const inside = raw === "~" || raw.endsWith("/");
+    const dir = path.resolve(inside ? expanded : path.dirname(expanded));
+    const start = inside ? "" : path.basename(expanded).toLowerCase();
+    if (!isDir(dir)) return { ok: false, error: `${dir} is not a folder on this computer` };
+    let entries = [];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (error) { return { ok: false, error: `${dir} can't be read: ${error.code || error.message}` }; }
+    const folders = entries
+      .filter((entry) => (entry.isDirectory() || (entry.isSymbolicLink() && isDir(path.join(dir, entry.name)))) && entry.name.toLowerCase().startsWith(start) && (start.startsWith(".") || !entry.name.startsWith(".")))
+      .map((entry) => ({ path: path.join(dir, entry.name), name: entry.name }))
+      .sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" })).slice(0, LISTED);
+    return { ok: true, dir, parent: path.dirname(dir) === dir ? null : path.dirname(dir), folders };
+  };
+
+  // A pick is asked once per message: the composer shows it, and the thread it starts uses it.
+  const picks = new Map();
+  const pickFromMessage = async (message, places) => {
+    const key = JSON.stringify([message, places.map((place) => place.path)]);
+    const cached = picks.get(key);
+    if (cached && cached.at > Date.now() - PICK_TTL_MS) return cached.pending;
+    const pending = askHarness("pick_folder", { message, folders: places.map(facts) }, null).then((reply) => {
+      if (!reply?.ok) throw new Error(reply?.error || "Harness did not pick a folder");
+      return places.some((place) => place.path === reply.folder) ? reply.folder : null;
+    });
+    picks.set(key, { at: Date.now(), pending });
+    for (const [old, entry] of picks) if (entry.at <= Date.now() - PICK_TTL_MS || picks.size > 50) picks.delete(old);
+    pending.catch(() => picks.delete(key));
+    return pending;
+  };
+
+  /**
+   * The folder for a thread the person starts without choosing one: { folder, by }, by "message" (Jev's pick from what
+   * they wrote), "last" (where one of its agents last worked) or null when there is none to suggest.
+   */
+  const suggest = async (text, agents) => {
+    const places = known();
+    const message = String(text).replace(/@([a-z][a-z0-9-]*)(:\S+)?\s*/g, "").trim();
+    if (message && places.length && canAsk() && !privacy()) {
+      try {
+        const folder = await pickFromMessage(message, places);
+        if (folder) return { folder, by: "message" };
+      } catch (error) { log(`folder pick: ${error.message}`); }
+    }
+    const coding = agents.filter((agent) => CODING.has(agent));
+    const last = places.filter((place) => place.lastWorked).find((place) => !coding.length || place.agents.some((agent) => coding.includes(agent)));
+    return last ? { folder: last.path, by: "last" } : { folder: null, by: null };
+  };
+
+  return { known, browse, suggest };
+}

package/lib/live.mjs

@@ -11,10 +11,10 @@ import { t3App, t3Link, t3Thread, t3Working } from "./places.mjs";
 // The person's own coding sessions running on this computer right now, each with the app it runs in: a terminal, an
 // editor or T3 Code, found by walking up the session's process tree to the first process inside an app bundle. A
 // session in T3 Code also gets the link that opens its thread there (T3's own prompt links, t3code://threads/…).
-// Only Claude Code and Codex: their hooks (nudge.mjs) are how a message from Harness reaches a session. Where each
-// session runs, and how it opens there again, is places.mjs.
+// Every coding agent here: its hooks (Claude Code, Codex), extension (pi) or plugin (OpenCode) run nudge.mjs, which is
+// how a message from Harness reaches a session. Where each session runs, and how it opens there again, is places.mjs.
 
-export const LIVE_AGENTS = ["claude-code", "codex"];
+export const LIVE_AGENTS = ["claude-code", "codex", "pi", "opencode"];
 const PLAIN_ID = /^[A-Za-z0-9._:-]{1,128}$/;
 
 /** Every process: its parent, its terminal (/dev/ttys003, or null) and its executable, by pid. */
@@ -91,9 +91,10 @@ export function sessionOfProcess(agent, pid, recent = []) {
 
 /**
  * The live sessions, newest first. `exclude` holds the pids of runs Harness started itself; `recent` is the session
- * index (Codex keeps no per-process record, so its session is the newest indexed one in the process's folder).
+ * index (Codex keeps no per-process record, so its session is the newest indexed one in the process's folder);
+ * `reported` holds the sessions that named their own process ({ agent, sessionId, folder, pid, comm, at }).
  */
-export function liveSessions({ exclude = new Set(), recent = [], table = processTable() } = {}) {
+export function liveSessions({ exclude = new Set(), recent = [], table = processTable(), reported = [] } = {}) {
   const sessions = [];
   const records = path.join(historyRoots("claude-code")[0], "..", "sessions");
   let files = [];
@@ -118,6 +119,13 @@ export function liveSessions({ exclude = new Set(), recent = [], table = process
   if (t3) for (const row of t3Working("codex")) {
     if (!sessions.some((session) => session.sessionId === row.sessionId)) sessions.push({ agent: "codex", sessionId: row.sessionId, folder: row.folder, pid: null, busy: true, at: row.at, host: { name: t3.name, app: t3.app }, t3Thread: row.thread });
   }
+  // A session that said which process it runs in when it started (pi's extension, OpenCode's plugin, any agent's hook):
+  // running while that process is, under the same name, so a reused process id is not taken for it.
+  for (const row of reported) {
+    const now = table.get(row.pid);
+    if (!now || exclude.has(row.pid) || path.basename(now.comm) !== path.basename(String(row.comm || "")) || sessions.some((session) => session.sessionId === row.sessionId)) continue;
+    sessions.push({ agent: row.agent, sessionId: row.sessionId, folder: row.folder || null, pid: row.pid, busy: null, at: row.at || 0 });
+  }
   return sessions.sort((a, b) => b.at - a.at).map((session) => {
     const tty = table.get(session.pid)?.tty ?? null;
     // Inside tmux the app is the terminal a tmux client shows the pane in.
@@ -170,6 +178,23 @@ export function sessionFile(agent, sessionId, folder, recent = []) {
   return null;
 }
 
+/** OpenCode's session as the person reads it: OpenCode keeps sessions in its own database, so `opencode export` reads it. */
+export function opencodeFeed(command, sessionId, limit = 80) {
+  if (!PLAIN_ID.test(String(sessionId))) return [];
+  const exported = spawnSync(command, ["export", String(sessionId)], { encoding: "utf8", timeout: 20_000, maxBuffer: 64 << 20, stdio: ["ignore", "pipe", "ignore"] });
+  let session;
+  try { session = JSON.parse(exported.stdout); } catch { return []; }
+  const items = [];
+  for (const message of Array.isArray(session?.messages) ? session.messages : []) {
+    const at = message.info?.time?.created ? new Date(message.info.time.created).toISOString() : null;
+    for (const part of Array.isArray(message.parts) ? message.parts : []) {
+      if (message.info?.role === "user") { if (part.type === "text" && !part.synthetic && !machinery(String(part.text || ""))) items.push({ kind: "you", text: String(part.text).trim(), at }); }
+      else items.push(...stepsOf({ type: part.type, part }).map((step) => ({ ...step, at })));
+    }
+  }
+  return items.slice(-limit);
+}
+
 /**
  * The end of a session as the person reads it, oldest first: what they asked ("you"), what the agent said ("say") and
  * the tools it used ("do"). Read from the last part of the session's own file, so a long session costs no more.

package/lib/mcp-stdio.mjs

@@ -38,6 +38,8 @@ const LOCAL_TOOLS = [
         parent_id: { type: "string", description: "the board task this one continues" },
         run_workspace: { type: "string", description: "the absolute directory a coding agent runs this task in, non-interactively, once the user authorizes it; the run's result and session come back on the task. Left out, a task for a coding agent runs in the folder you are working in" },
         in_session: { type: "boolean", description: "leave the task for the target to pick up in an open session instead of a run" },
+        model: { type: "string", description: "only when the user asked for one: the model the target coding agent runs with, an id from list_models, or auto to let Harness pick; left out, the agent runs on the user's choice for it" },
+        effort: { type: "string", description: "with model: one of the effort levels list_models gives for that model" },
         context_refs: { type: "array", items: { type: "object", properties: { kind: { type: "string" }, ref: { type: "string" }, note: { type: "string" } }, required: ["kind", "ref"], additionalProperties: false } },
       },
       required: ["objective"],
@@ -106,7 +108,7 @@ const LOCAL_TOOLS = [
   },
   {
     name: "post_to_room",
-    description: "Post in a goal's room for the whole team: a finding, partial work, a question or what you did. To ask another agent for help, put its name in ask (claude-code, codex, pi, opencode, grok-bot, openclaw, hermes, bankr, quotient, muse, or harness to have the thread coordinated), say exactly what you need, then stop: you are woken again when it answers you by name. When you answer someone who asked you, name them (@codex) and they are woken. Any other @name, like a thanks, wakes no one. Post results and sources, not secrets: anything that looks like a key is held. For work someone else should do, post_task with parent_id set to the goal id.",
+    description: "Post in a goal's room for the whole team: a finding, partial work, a question or what you did. To ask another agent for help, put its name in ask (claude-code, codex, pi, opencode, grok-bot, openclaw, hermes, bankr, quotient, muse, or harness to have the thread coordinated), say exactly what you need, then stop: you are woken again when it answers you by name. When you answer someone who asked you, name them (@codex) and they are woken. To have a coding agent run on a particular model, write it after the name, @codex:gpt-6-luna or @codex:gpt-6-luna/high with an effort, from list_models. Any other @name, like a thanks, wakes no one. Post results and sources, not secrets: anything that looks like a key is held. For work someone else should do, post_task with parent_id set to the goal id.",
     inputSchema: { type: "object", properties: { id: { type: "string", description: "the goal id" }, text: { type: "string" }, ask: { type: "array", items: { type: "string" }, description: "the agents you are asking for something; each is woken" }, share_with_guests: { type: "boolean", description: "also send it to the goal's invited guests (other people's agents); only what is fine for them to see" } }, required: ["id", "text"], additionalProperties: false },
   },
   {
@@ -123,6 +125,11 @@ const LOCAL_TOOLS = [
     description: "Every other agent in the user's swarm, each with its card: what it does and cannot do, where it runs, its model, whether it can review without changing files, how it answers (some start at once, some are woken, some only pick work up later, and some are not set up yet, so work for them waits), how its work on the board went, what it holds now, and the user's own note about it. Use it to pick who should get the work before post_task or start_thread instead of guessing a name.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
   },
+  {
+    name: "list_models",
+    description: "The models a coding agent on this machine (claude-code, codex, pi, opencode) can run with, as the agent itself lists them, with each model's effort levels, and the user's choice for it. Use it before naming a model in post_task (model, effort) or in a post (@codex:gpt-6-luna/high).",
+    inputSchema: { type: "object", properties: { agent: { type: "string", description: "claude-code, codex, pi or opencode; left out, every one installed here" } }, additionalProperties: false },
+  },
   {
     name: "start_thread",
     description: "Start a shared thread with one or more of the user's agents, named with @ in the message (for example \"@codex @grok-bot compare the two parsers\"). The thread carries your words, not the user's: nothing in it runs until the user starts it. Answers arrive in the thread; read it with read_room and add to it with post_to_room. Give a folder only when the work concerns one.",
@@ -137,6 +144,7 @@ const LOCAL_TOOLS = [
 
 const BOARD_CALLS = {
   list_agents: () => ({ command: "board.swarm.agents" }),
+  list_models: (args) => ({ command: "board.swarm.models", target: args.agent }),
   start_thread: (args) => ({ command: "board.swarm.start", text: args.text, folder: args.folder }),
   stop_thread: (args) => ({ command: "board.swarm.stop", id: String(args.id || "") }),
   read_room: (args) => ({ command: "board.room.read", id: String(args.id || ""), since: args.since }),
@@ -152,7 +160,7 @@ const BOARD_CALLS = {
   list_tasks: (args) => ({ command: "board.list", status: args.status, all: args.all === true }),
   get_task: (args) => ({ command: "board.get", id: String(args.id || "") }),
   wallet: (args) => ({ command: "board.wallet", action: args.action, hash: args.hash, chain: args.chain }),
-  post_task: (args) => ({ command: "board.post", objective: args.objective, brief: args.brief, targetAgent: args.target_agent, targetAgents: args.target_agents, parentId: args.parent_id, contextRefs: args.context_refs, runWorkspace: args.run_workspace, inSession: args.in_session === true, posterCwd: process.cwd(), posterPid: process.ppid }),
+  post_task: (args) => ({ command: "board.post", objective: args.objective, brief: args.brief, targetAgent: args.target_agent, targetAgents: args.target_agents, parentId: args.parent_id, contextRefs: args.context_refs, runWorkspace: args.run_workspace, inSession: args.in_session === true, model: args.model, effort: args.effort, posterCwd: process.cwd(), posterPid: process.ppid }),
   claim_task: (args) => ({ command: "board.claim", id: String(args.id || ""), expectedVersion: args.expected_version, leaseMinutes: args.lease_minutes, claimerPid: process.ppid }),
   report_task: (args) => args.status === "answered"
     ? { command: "board.answer", id: String(args.id || ""), answer: args.result, expectedVersion: args.expected_version }

package/lib/members.json

@@ -2,7 +2,7 @@
   "version": 1,
   "members": [
     { "id": "harness", "name": "Harness", "aliases": [], "road": "server", "home": "cloud", "runs": "server", "target": true, "wake": "run",
-      "about": "coordinates the thread and asks the person when only they can decide",
+      "about": "answers and researches with its own tools, and works in the person's browser while their Harness window is open; coordinates the thread and asks the person when only they can decide",
       "where": "on Harness's server", "limits": "Does not change files or run commands on this computer." },
     { "id": "claude-code", "name": "Claude Code", "aliases": ["claude code"], "road": "local", "home": "machine", "runs": "machine", "target": true, "wake": "run",
       "about": "reads and changes code in the thread's folder, runs commands and tests",

package/lib/models.mjs

@@ -0,0 +1,233 @@
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { agentEnvironment } from "./agentnode.mjs";
+import { nameOf } from "./members.mjs";
+import { trackHelper } from "./runner.mjs";
+
+// Which model and effort each coding agent runs with, owned by the relay. Every agent lists its own models (Codex,
+// Pi and OpenCode have a command for it; Claude Code has none, so its list is its own short names plus the Anthropic
+// models the others list here). A run uses, first: a model named for it (`@codex:gpt-6-luna/high` in a post, or
+// post_task's model); then the person's choice for the agent, which may be Auto (Harness's Jev picks from the list
+// against the person's routing words); else nothing, and the agent runs on its own settings. Every pick is checked
+// against the agent's list before a run starts.
+
+const CLAUDE_EFFORTS = ["low", "medium", "high", "xhigh", "max"]; // claude --help
+const PI_THINKING = ["off", "minimal", "low", "medium", "high", "xhigh", "max"]; // pi --help
+const CLAUDE_NAMES = ["fable", "opus", "sonnet", "haiku"];
+/**
+ * The routing words Auto goes by until the person writes their own. The first wording (owner, October 13), "The cheapest
+ * model that can do this work well; more effort only for hard work.", sent demanding work to cheap models (eval
+ * model-routing v1, 20261014-010225-80250750-357a).
+ */
+export const DEFAULT_ROUTING = "Match the model to the work: for easy work, the cheapest model that does it well; for demanding work, the most capable one. Pass over a model that keeps failing here. More effort only for hard work.";
+
+const tokens = (text) => {
+  const match = /^(\d+(?:\.\d+)?)([KM]?)$/i.exec(String(text || ""));
+  return match ? Math.round(Number(match[1]) * ({ k: 1e3, m: 1e6 }[match[2].toLowerCase()] ?? 1)) : null;
+};
+
+// One reader per agent's own list command, its output as the agent prints it today.
+const LISTS = {
+  codex: { command: "codex", args: ["debug", "models"], parse: (out) => JSON.parse(out).models.map((entry) => ({
+    id: entry.slug, about: entry.description || null, efforts: (entry.supported_reasoning_levels || []).map((level) => level.effort),
+    defaultEffort: entry.default_reasoning_level || null, context: entry.context_window || null })) },
+  // provider  model  context  max-out  thinking  images
+  pi: { command: "pi", args: ["--list-models"], parse: (out) => out.split("\n").map((line) => line.trim().split(/\s+/))
+    .filter((cells) => cells.length >= 5 && cells[0] !== "provider")
+    .map(([provider, model, context, , thinking]) => ({ id: `${provider}/${model}`, efforts: thinking === "yes" ? PI_THINKING : [], context: tokens(context) })) },
+  // Each model as "provider/id" on its own line, then its details as JSON.
+  opencode: { command: "opencode", args: ["models", "--verbose"], parse: (out) => {
+    const models = [];
+    let id = null, body = [];
+    const flush = () => {
+      if (!id) return;
+      const entry = JSON.parse(body.join("\n"));
+      models.push({ id, efforts: Object.keys(entry.variants || {}), context: entry.limit?.context ?? null,
+        ...(entry.cost && Number.isFinite(entry.cost.input) ? { price: { inputUsdPerMillion: entry.cost.input, outputUsdPerMillion: entry.cost.output } } : {}) });
+    };
+    for (const line of out.split("\n")) {
+      if (/^[^\s{}"]+\/\S+$/.test(line)) { flush(); id = line.trim(); body = []; } else if (id) body.push(line);
+    }
+    flush();
+    return models;
+  } },
+};
+
+function capture(command, args) {
+  return new Promise((resolve, reject) => {
+    const environment = agentEnvironment(command);
+    if (environment.error) { reject(new Error(environment.error)); return; }
+    let child;
+    try { child = spawn(command, args, { cwd: os.tmpdir(), env: environment.env }); } catch (error) { reject(error); return; }
+    child.stdin.end();
+    trackHelper(child);
+    let out = "", err = "";
+    child.stdout.on("data", (chunk) => { out += chunk; });
+    child.stderr.on("data", (chunk) => { err += chunk; });
+    child.on("error", reject);
+    child.on("close", (code) => code === 0 ? resolve(out) : reject(new Error(`${command} ${args.join(" ")} exited with code ${code}: ${err.trim().slice(0, 200)}`)));
+  });
+}
+
+const catalogKey = (agent) => `models:${agent}`;
+/** An agent's last listing: { at, models, error? }, error when its list command last failed. */
+export const listingOf = (store, agent) => { try { return JSON.parse(store.meta(catalogKey(agent)) || "null"); } catch { return null; } };
+/** An agent's models as it last listed them: [{ id, about?, efforts, defaultEffort?, context?, price? }]. */
+export const catalogOf = (store, agent) => listingOf(store, agent)?.models ?? [];
+
+/**
+ * Asks each installed agent for its models, all at once so one slow agent holds up no other, and keeps the lists; an
+ * agent whose command fails keeps its last list and the error.
+ */
+export async function refreshCatalogs(store, agents, log = () => {}) {
+  await Promise.all(agents.filter((name) => LISTS[name]).map(async (agent) => {
+    try {
+      const models = LISTS[agent].parse(await capture(LISTS[agent].command, LISTS[agent].args)).filter((entry) => entry.id);
+      store.meta(catalogKey(agent), JSON.stringify({ at: new Date().toISOString(), models }));
+    } catch (error) {
+      log(`model list for ${agent}: ${error.message}`);
+      store.meta(catalogKey(agent), JSON.stringify({ ...(listingOf(store, agent) ?? { models: [] }), error: error.message.slice(0, 300) }));
+    }
+  }));
+  if (agents.includes("claude-code")) {
+    const anthropic = [...new Set(["pi", "opencode"].flatMap((other) => catalogOf(store, other)).map((entry) => entry.id).filter((id) => id.startsWith("anthropic/")).map((id) => id.slice("anthropic/".length)))];
+    const models = [...CLAUDE_NAMES.map((name) => ({ id: name, about: `Claude Code's name for its newest ${name[0].toUpperCase()}${name.slice(1)} model.`, efforts: CLAUDE_EFFORTS })),
+      ...anthropic.sort().map((id) => ({ id, efforts: CLAUDE_EFFORTS }))];
+    store.meta(catalogKey("claude-code"), JSON.stringify({ at: new Date().toISOString(), models }));
+  }
+}
+
+/** One model in an agent's list, written as its id or, when only one model has it, the part after the provider. */
+function findModel(store, agent, written) {
+  const models = catalogOf(store, agent);
+  if (!models.length) return { error: `the relay has no model list for ${nameOf(agent)} yet` };
+  const wanted = String(written || "").trim().toLowerCase();
+  const exact = models.find((entry) => entry.id.toLowerCase() === wanted);
+  if (exact) return { entry: exact };
+  const tail = models.filter((entry) => entry.id.toLowerCase().split("/").pop() === wanted);
+  if (tail.length === 1) return { entry: tail[0] };
+  return { error: tail.length ? `"${written}" could be ${tail.map((entry) => entry.id).join(" or ")}; name one` : `"${written}" is not one of ${nameOf(agent)}'s models (npx tryharness agents models ${agent})` };
+}
+
+/** A model and effort for an agent, checked against its list: { ok, pick } with pick { model, effort } or { auto: true }. */
+export function resolvePick(store, agent, model, effort = null) {
+  if (String(model || "").trim().toLowerCase() === "auto") return { ok: true, pick: { auto: true } };
+  const found = findModel(store, agent, model);
+  if (found.error) return { ok: false, error: found.error };
+  const level = effort ? String(effort).trim().toLowerCase() : null;
+  if (level && !found.entry.efforts.includes(level)) {
+    return { ok: false, error: found.entry.efforts.length ? `${found.entry.id} takes effort ${found.entry.efforts.join(", ")}, not "${effort}"` : `${found.entry.id} has no effort setting in ${nameOf(agent)}` };
+  }
+  return { ok: true, pick: { model: found.entry.id, effort: level } };
+}
+
+/** A pick as written after an agent's name in a post, "model", "model/effort" or "auto". */
+export function resolveSpec(store, agent, spec) {
+  const whole = resolvePick(store, agent, spec);
+  if (whole.ok) return whole;
+  const cut = spec.lastIndexOf("/");
+  if (cut > 0) { const split = resolvePick(store, agent, spec.slice(0, cut), spec.slice(cut + 1)); if (split.ok) return split; }
+  return whole;
+}
+
+/** The agents whose model the relay sets. */
+export const PICKABLE = new Set(["claude-code", ...Object.keys(LISTS)]);
+const PICKED = /(?:^|\s)@([a-z][a-z0-9-]*):([^\s]+)/g;
+/** The picks a post names, `@codex:gpt-6-luna/high`, by agent: { picks: Map, error? }. Only agents in `agents` count. */
+export function picksIn(store, text, agents) {
+  const picks = new Map();
+  for (const match of String(text || "").matchAll(PICKED)) {
+    const agent = match[1] === "claude" ? "claude-code" : match[1];
+    if (!agents.includes(agent) || !PICKABLE.has(agent)) continue;
+    const spec = match[2].replace(/[.,;:!?)]+$/, "");
+    const resolved = resolveSpec(store, agent, spec);
+    if (!resolved.ok) return { picks, error: `@${match[1]}:${spec}: ${resolved.error}` };
+    picks.set(agent, resolved.pick);
+  }
+  return { picks };
+}
+
+const choiceKey = (agent) => `model-choice:${agent}`;
+/** The person's choice for an agent: { model, effort }, { auto: true }, or null for the agent's own settings. */
+export const choiceOf = (store, agent) => { try { return JSON.parse(store.meta(choiceKey(agent)) || "null"); } catch { return null; } };
+export function setChoice(store, agent, model, effort = null) {
+  if (!model || String(model).toLowerCase() === "default") { store.meta(choiceKey(agent), ""); return { ok: true, choice: null }; }
+  const resolved = resolvePick(store, agent, model, effort);
+  if (!resolved.ok) return resolved;
+  store.meta(choiceKey(agent), JSON.stringify(resolved.pick));
+  return { ok: true, choice: resolved.pick };
+}
+export const routingOf = (store) => store.meta("routing-note") || null;
+export const setRouting = (store, text) => { const note = String(text || "").replace(/\s+/g, " ").trim().slice(0, 1_000); store.meta("routing-note", note); return note || null; };
+
+/** A pick in words: "gpt-6-luna, effort high", "Auto". */
+export const describePick = (pick) => !pick ? null : pick.auto ? "Auto" : [pick.model, pick.effort && `effort ${pick.effort}`].filter(Boolean).join(", ");
+
+/** The pick named for one run (a post, post_task), kept with the run until it starts. */
+export const setRunPick = (store, runId, pick, by) => store.meta(`model:${runId}`, JSON.stringify({ ...pick, by }));
+const runPick = (store, runId) => { try { return JSON.parse(store.meta(`model:${runId}`) || "null"); } catch { return null; } };
+
+const median = (values) => { const sorted = values.filter(Number.isFinite).sort((a, b) => a - b); return sorted.length ? sorted[Math.floor(sorted.length / 2)] : null; };
+/** How each of an agent's models did on this board: finished, failed, and the median minutes and dollars of a finished run. */
+function recordByModel(store, agent) {
+  const byModel = new Map();
+  for (const row of store.modelWork(agent)) {
+    const entry = byModel.get(row.model) ?? { done: 0, failed: 0, minutes: [], cost: [] };
+    if (row.status === "done") {
+      entry.done++;
+      entry.minutes.push((Date.parse(row.reported_at) - Date.parse(row.started_at)) / 60_000);
+      entry.cost.push(Number(row.usage?.cost_usd));
+    } else if (row.status === "failed") entry.failed++;
+    byModel.set(row.model, entry);
+  }
+  return (model) => {
+    const entry = byModel.get(model);
+    if (!entry) return null;
+    const minutes = median(entry.minutes), cost = median(entry.cost);
+    return { done: entry.done, failed: entry.failed, medianMinutes: minutes === null ? null : Math.round(minutes * 10) / 10, medianCostUsd: cost === null ? null : Math.round(cost * 10_000) / 10_000 };
+  };
+}
+
+/** What Auto sends Harness for one run (src/server/swarm/route.ts): the work, the person's words, every listed model with its record here. */
+export const routeInput = ({ agent, work, transcript, routing, ownModel, models, record }) => ({
+  agent, name: nameOf(agent), work, transcript, routing: routing ?? DEFAULT_ROUTING, ownModel,
+  models: models.slice(0, 250).map((entry) => ({ ...entry, record: record(entry.id) })),
+});
+
+/**
+ * The model and effort a run starts with: { model, effort, by, note? }, or null for the agent's own settings. `by` says
+ * who chose: "you" (the person's post), another agent's id, "your choice" (the person's setting) or "auto".
+ * Auto asks Harness only when the person allows it (not the privacy setting) and Harness can answer.
+ */
+export function createModelRouter({ store, askHarness, canAsk, privacy, ownModel, workOf, log = () => {} }) {
+  return async function modelForRun(task, agent) {
+    const named = runPick(store, task.id);
+    const pick = named ?? (choiceOf(store, agent) ? { ...choiceOf(store, agent), by: "your choice" } : null);
+    if (!pick) return null;
+    const by = named ? (named.by === "user" ? "you" : named.by) : pick.by;
+    if (!pick.auto) {
+      // The list may have changed since the pick: a model the agent no longer lists runs on its own settings, said so.
+      const checked = resolvePick(store, agent, pick.model, pick.effort);
+      return checked.ok ? { ...checked.pick, by } : { model: null, effort: null, by, note: `${checked.error}; it ran on its own settings` };
+    }
+    const fallback = (note) => ({ model: null, effort: null, by: "auto", note });
+    if (privacy()) return fallback("Auto is off on the privacy setting; it ran on its own settings");
+    if (!canAsk()) return fallback("Harness could not pick a model just now; it ran on its own settings");
+    const models = catalogOf(store, agent);
+    if (!models.length) return fallback(`the relay has no model list for ${nameOf(agent)} yet; it ran on its own settings`);
+    try {
+      const reply = await askHarness("route_model", routeInput({ agent, ...workOf(task), routing: routingOf(store), ownModel: ownModel(agent), models, record: recordByModel(store, agent) }), null);
+      if (!reply.ok) throw new Error(reply.error || "Harness did not pick a model");
+      // The bridge hands back Harness's answer with its fields beside ok.
+      const picked = reply;
+      if (!picked.model) return fallback("Harness picked no model; it ran on its own settings");
+      const checked = resolvePick(store, agent, picked.model, picked.effort && models.find((entry) => entry.id === picked.model)?.efforts.includes(picked.effort) ? picked.effort : null);
+      if (!checked.ok) return fallback(`Auto picked ${picked.model}, which ${nameOf(agent)} does not list; it ran on its own settings`);
+      // Jev's confidence in the pick stays with the run, to see later how sure the picks that worked were.
+      return { ...checked.pick, by: "auto", judgments: picked.judgments ?? null, estimatedMicroUsd: picked.estimatedMicroUsd ?? null };
+    } catch (error) {
+      log(`auto model for ${task.id}: ${error.message}`);
+      return fallback(`Harness could not pick a model (${error.message}); it ran on its own settings`);
+    }
+  };
+}

package/lib/network.mjs

@@ -0,0 +1,118 @@
+// Swarms talking to swarms, on the person's computer: the one list every surface shows (the buddy's
+// Swarms tab, the dashboard, the PiP), built here from what Harness holds (who asked whom, and the
+// answer) and what only this computer holds (each thread's words, held replies, what the person has
+// read). A sealed request's subject is opened here, never at Harness. Only the person ("user") calls
+// these; another agent works a thread through board.thread.* on the task it holds.
+
+const SEEN = (id) => `relay_seen:${id}`;
+const AUTO_SEND_DEFAULT = "relay_auto_send_default";
+const DECISIONS = new Set(["accept", "decline", "block"]);
+const handleOf = (identity) => String(identity || "").split("/")[0].toLowerCase();
+const agentOf = (identity) => String(identity || "").split("/")[1] || "";
+
+export function createNetwork({ store, askHarness, relayRequest, openRelayRequest, fingerprint, myKey }) {
+  // Harness answers for the server's half; a refusal comes back as a plain error the person can read.
+  const harness = async (input) => {
+    const answer = await askHarness("relay_network", input);
+    if (!answer.ok) throw new Error(answer.error || "Harness refused the request");
+    const { ok: _ok, ...rest } = answer;
+    return rest;
+  };
+
+  // One row per request or thread, grouped by what it needs: the person (a request to answer, a held reply,
+  // a message from a person), nothing (open), the other side (a request not answered yet), or nobody (ended).
+  const conversations = async () => {
+    const server = await harness({ op: "threads" }).catch(() => null);
+    const local = new Map(store.relayThreads().map((row) => [row.task_id, row]));
+    const items = [];
+    for (const thread of server?.threads ?? []) {
+      const here = local.get(thread.id) || null;
+      local.delete(thread.id);
+      const peer = thread.role === "asker" ? thread.target : thread.asker;
+      let about = thread.about || here?.objective || "";
+      let keyPrint = null;
+      // A sealed request's subject: opened on this computer, with the other computer's key to compare.
+      if (thread.sealed && !about) {
+        const opened = await openRelayRequest({ sealed: thread.sealed, from: `${peer.handle}/${peer.agent}` }).catch(() => null);
+        if (opened) { about = opened.about; keyPrint = opened.fingerprint; }
+      }
+      items.push(item({ id: thread.id, role: thread.role, kind: thread.kind || (thread.target?.agent === "person" ? "person" : "agent"), status: thread.status, about,
+        peer: { handle: peer.handle, agent: peer.agent }, mine: thread.role === "asker" ? thread.asker.agent : thread.target.agent,
+        askerSince: thread.role === "target" ? thread.asker.since : null, sealed: Boolean(thread.sealed), fingerprint: keyPrint, createdAt: thread.createdAt, here }));
+    }
+    // Threads this computer holds that Harness no longer lists (older ones, or Harness out of reach).
+    for (const here of local.values()) {
+      items.push(item({ id: here.task_id, role: here.role, kind: agentOf(here.with_agent) === "person" ? "person" : "agent", status: here.closed_at ? "closed" : "accepted", about: here.objective,
+        peer: { handle: handleOf(here.with_agent), agent: agentOf(here.with_agent) }, mine: here.target_agent === "user" ? "person" : here.target_agent,
+        askerSince: null, sealed: false, fingerprint: null, createdAt: here.opened_at, here }));
+    }
+    items.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+    return { ok: true, connected: Boolean(server), items, needsYou: items.filter((entry) => entry.group === "needs_you").length };
+  };
+
+  const item = ({ id, role, kind, status, about, peer, mine, askerSince, sealed, fingerprint: keyPrint, createdAt, here }) => {
+    const seen = Number(store.meta(SEEN(id)) || 0);
+    const thread = here ? {
+      open: !here.closed_at, autoSend: here.auto_send, held: here.held, unread: here.last_in_seq > seen, messages: here.messages, outcome: here.outcome,
+      last: here.last ? { direction: here.last.direction, sender: here.last.sender, text: String(here.last.text || "").slice(0, 160), state: here.last.state, at: here.last.created_at } : null,
+    } : null;
+    const reason = role === "target" && status === "requested" ? "request"
+      : thread?.open && thread.held ? "held"
+      : thread?.open && kind === "person" && thread.unread ? "message"
+      : null;
+    const group = reason ? "needs_you"
+      : thread ? (thread.open ? "open" : "ended")
+      : status === "requested" ? "waiting"
+      : status === "accepted" || status === "accepted_pending" ? "open"
+      : "ended";
+    return { id, role, kind, status, about, peer, mine, askerSince, sealed, fingerprint: keyPrint, group, reason, thread, createdAt, updatedAt: here?.updated_at || createdAt };
+  };
+
+  // A refusal from Harness or the other computer comes back as the answer, in its own words.
+  const answered = (promise) => ({ pending: promise.catch((error) => ({ ok: false, error: error.message })) });
+  const command = (request, agent) => {
+    if (agent !== "user") return { ok: false, error: "only the person talks to other swarms from here" };
+    const id = String(request.id || "");
+    switch (request.command) {
+      case "board.relay.list":
+        return answered(conversations());
+      // The server's half of Swarms (card, search, contacts, blocks): what the dashboard asks Harness directly.
+      case "board.relay.network": {
+        const { command: _command, agent: _agent, ...input } = request;
+        if (input.op === "decide" || input.op === "threads") return { ok: false, error: "use board.relay.decide and board.relay.list" };
+        return answered(harness(input).then((answer) => ({ ok: true, ...answer })));
+      }
+      case "board.relay.decide":
+        if (!DECISIONS.has(String(request.decision))) return { ok: false, error: "decision is accept, decline or block" };
+        return answered(harness({ op: "decide", id, decision: String(request.decision) }).then((answer) => ({ ok: true, ...answer })));
+      // A request from this computer: to one of their listed agents from one of the person's, or to the person themselves.
+      case "board.relay.request": {
+        const handle = String(request.handle || "").toLowerCase().replace(/^@/, "");
+        const toAgent = String(request.toAgent || "person");
+        const fromAgent = toAgent === "person" ? "person" : String(request.fromAgent || "");
+        return answered(relayRequest({ to: `${handle}/${toAgent}`, fromAgent, about: request.about, brief: request.brief, refs: request.refs }).then((made) => ({ ok: true, ...made })));
+      }
+      case "board.relay.seen": {
+        const thread = store.getThread(id);
+        if (!thread) return { ok: false, error: "no thread on this task" };
+        const last = store.threadMessages(id).filter((message) => message.direction === "in").at(-1);
+        store.meta(SEEN(id), String(last?.seq ?? 0));
+        return { ok: true };
+      }
+      // Whether replies the person's agents write wait for the person on a new thread (the default) or send on their own.
+      case "board.relay.defaults":
+        if (typeof request.autoSend === "boolean") store.meta(AUTO_SEND_DEFAULT, request.autoSend ? "1" : "0");
+        return { ok: true, autoSend: store.meta(AUTO_SEND_DEFAULT) === "1" };
+      case "board.relay.peers":
+        return answered(Promise.all(store.relayPeers().map(async (peer) => ({ handle: peer.handle, pinnedAt: peer.pinned_at, fingerprint: await fingerprint(peer.public_key) })))
+          .then(async (peers) => ({ ok: true, peers, mine: myKey() ? await fingerprint(myKey()) : null })));
+      default:
+        return { ok: false, error: `unknown command ${request.command}` };
+    }
+  };
+
+  /** A thread just opened on this computer starts with the person's default for their agents' replies. */
+  const opened = (taskId) => { if (store.meta(AUTO_SEND_DEFAULT) === "1") store.setAutoSend(taskId, true); };
+
+  return { command, opened };
+}