tryharness 0.7.18 → 0.7.22

package/lib/nudge.mjs

@@ -9,7 +9,7 @@ import { placeEnv } from "./places.mjs";
 // The session-start nudge: what an interactive agent is told when a session opens, so work
 // waiting on the board is not silent until someone asks. Claude Code runs this as a
 // SessionStart hook (stdout lands in its context); the Pi extension and OpenCode plugin
-// build the same text in-process. Nothing waiting, or no daemon, prints nothing.
+// import this file from the runtime and call the same functions. Nothing waiting, or no daemon, prints nothing.
 
 // The swarm block (cards.mjs), when given, follows the queue: who else is in the person's swarm and what each is for.
 export function nudgeText(agent, tasks, unread = [], goals = [], swarm = "") {
@@ -94,14 +94,15 @@ function agentPids() {
 // Where the session runs, as its own environment says (the agent's, which the hook shares): places.mjs reads it.
 const placeOf = (input) => ({ sessionId: input?.session_id, folder: input?.cwd || process.cwd(), env: placeEnv(process.env) });
 
-export async function notePrompt(agent, input = null) {
-  try { await daemonRequest({ command: "board.prompted", agent, pids: agentPids(), ...(input?.session_id ? placeOf(input) : {}) }, 1_500); } catch {}
+// An extension or plugin running inside the agent passes its own process ids.
+export async function notePrompt(agent, input = null, pids = agentPids()) {
+  try { await daemonRequest({ command: "board.prompted", agent, pids, ...(input?.session_id ? placeOf(input) : {}) }, 1_500); } catch {}
 }
 
 /** A session starting says where it runs. */
-export async function notePlace(agent, input) {
+export async function notePlace(agent, input, pids = agentPids()) {
   if (!input?.session_id) return;
-  try { await daemonRequest({ command: "board.live.place", agent, pids: agentPids(), ...placeOf(input) }, 1_500); } catch {}
+  try { await daemonRequest({ command: "board.live.place", agent, pids, ...placeOf(input) }, 1_500); } catch {}
 }
 
 // What the person sent this session from Harness (daemon board.live.say), taken once.

package/lib/phones.mjs

@@ -24,6 +24,8 @@ const PHONE_COMMANDS = new Set([
   "board.goal.list", "board.goal.get", "board.goal.stop", "board.room.read",
   "board.swarm.list", "board.swarm.read", "board.swarm.start", "board.swarm.post", "board.swarm.stop", "board.swarm.stop_all", "board.swarm.resume", "board.swarm.folder", "board.swarm.coordinator",
   "board.swarm.diff", "board.swarm.merge", "board.swarm.discard", "board.swarm.start_run", "board.swarm.agents", "board.swarm.note",
+  // Where a thread works: the folders offered, any folder browsed to, and where a message would work (folders.mjs).
+  "board.swarm.places", "board.swarm.browse", "board.swarm.place",
   // The person's own running sessions, read and messaged as from the desktop app; never queued (a session may be gone).
   "board.live", "board.live.read", "board.live.say",
 ]);
@@ -33,7 +35,9 @@ const HARNESS_COMMANDS = new Set([
   "board.goal.create", "board.goal.get", "board.goal.list", "board.goal.finish", "board.room.read", "board.room.post", "board.room.search", "board.children", "board.agents",
   "board.swarm.list", "board.swarm.read", "board.swarm.diff",
 ]);
-const BROWSER_PERSON_COMMANDS = new Set([...PHONE_COMMANDS, "board.goal.resume", "board.standing", "board.standing.check", "board.standing.off"]);
+// Swarms talking to swarms (network.mjs), from the Harness window: the person's own, never Harness's.
+const RELAY_PERSON_COMMANDS = ["board.relay.list", "board.relay.network", "board.relay.decide", "board.relay.request", "board.relay.seen", "board.relay.defaults", "board.relay.peers"];
+const BROWSER_PERSON_COMMANDS = new Set([...PHONE_COMMANDS, "board.goal.resume", "board.standing", "board.standing.check", "board.standing.off", ...RELAY_PERSON_COMMANDS]);
 const BROWSER_READS = new Set(["sessions.search", "sessions.read", "sessions.raw", "tasks.status", "relay.request", "relay.open"]);
 
 export async function createPhoneDesk({ store, identityFile, boardCommand, reads = {}, version, onMessage = () => {}, machine = () => null }) {

package/lib/places.mjs

@@ -3,6 +3,8 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
+import { paths } from "./paths.mjs";
+import { agentEnvironment } from "./agentnode.mjs";
 import { mainCheckout } from "./worktrees.mjs";
 
 // Where a coding session runs, and how it opens there again. A session's place comes from its own environment: the
@@ -168,6 +170,43 @@ export function resumeLine(agent, sessionId, folder = null) {
   return `${folder && path.isAbsolute(folder) ? `cd ${quote(folder)} && ` : ""}${resume} ${sessionId}`;
 }
 
+/** Whether an editor runs a workspace's tasks when its window opens: it asks the person once, unless they turned that off. */
+export function editorRunsOpenTasks(editorId) {
+  const editor = editorById(editorId);
+  if (!editor) return false;
+  let settings = "";
+  try { settings = fs.readFileSync(path.join(editorData(editor), "User", "settings.json"), "utf8"); } catch { return true; }
+  return !/"task\.allowAutomaticTasks"\s*:\s*"off"/.test(settings);
+}
+
+/**
+ * A session to resume in an editor's own terminal: a workspace on the folder the editor opens around it (`window`), whose
+ * task resumes the session in a terminal when the window opens (runOn folderOpen; the editor asks once to trust the folder
+ * and to allow such tasks). Through the person's login shell, so the agent runs with their own setup. The file lives in
+ * Harness's folder, never in the person's; its path, or null when the agent has no resume command.
+ */
+export function editorSessionWorkspace(agent, sessionId, folder, window = folder) {
+  const resume = AGENTS[agent]?.resume;
+  if (!resume || !PLAIN_ID.test(String(sessionId || "")) || !folder || !path.isAbsolute(folder)) return null;
+  // Through the person's login shell (VS Code's default terminal on Windows), with a Node the agent accepts first.
+  const shell = process.platform === "win32" ? null : process.env.SHELL || os.userInfo().shell || "/bin/sh";
+  const { bin } = agentEnvironment(AGENTS[agent].command);
+  const name = `${path.basename(window || folder)} - ${agent} ${String(sessionId).replace(/^ses_/, "").slice(0, 8)}`.replace(/[^A-Za-z0-9 ._-]/g, "-");
+  const file = path.join(paths.home, "editor", `${name}.code-workspace`);
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(file, JSON.stringify({
+    folders: [{ path: window || folder }],
+    tasks: { version: "2.0.0", tasks: [{
+      label: `${agent} session ${sessionId}`, type: "shell", command: `${resume} ${sessionId}`,
+      options: { cwd: folder, ...(shell ? { shell: { executable: shell, args: ["-l", "-i", "-c"] } } : {}), ...(bin ? { env: { PATH: `${bin}${path.delimiter}\${env:PATH}` } } : {}) },
+      runOptions: { runOn: "folderOpen" },
+      presentation: { reveal: "always", focus: true, panel: "dedicated", clear: true },
+      problemMatcher: [],
+    }] },
+  }, null, 2), { mode: 0o600 });
+  return file;
+}
+
 /** A session in its agent's own panel in an editor (Claude Code's, OpenAI's Codex extension), when it is installed there. */
 export function panelLink(agent, editorId, sessionId) {
   const panel = AGENTS[agent]?.panel;
@@ -235,6 +274,12 @@ export function t3Project(folder, home = t3Home()) {
   return found ? { id: found[0], root: realDir(found[1]) } : null;
 }
 
+/** Every folder T3 Code has a project for. */
+export function t3Projects(home = t3Home()) {
+  if (!t3Tables(home).has("projection_projects")) return [];
+  return (t3Query(home, "select workspace_root from projection_projects where deleted_at is null;") || "").split("\n").map(realDir).filter(Boolean);
+}
+
 /** The model (and its options) the person last ran an agent with in T3 Code, as T3 records each thread's choice. */
 export function t3Model(agent, home = t3Home()) {
   const provider = t3Provider(agent);

package/lib/runner.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { agentEnvironment } from "./agentnode.mjs";
 
 const running = new Set();
 const children = new Map();
@@ -21,6 +22,13 @@ export function trackRun(runId, stop) {
   return () => { if (children.get(runId) === entry) children.delete(runId); };
 }
 
+/** A short command the daemon runs itself (an agent listing its models): while it runs, not the person's session either. */
+export function trackHelper(child) {
+  const id = `helper:${child.pid}`;
+  children.set(id, child);
+  child.on("close", () => children.delete(id));
+}
+
 /** The process ids of the runs in progress, so they are not mistaken for the person's own sessions. */
 export function runningPids() {
   return [...children.values()].map((child) => child.pid).filter(Boolean);
@@ -48,12 +56,21 @@ export const restrictedMcpConfig = () => ({ mcpServers: { harness: { command: pr
 const restrictedClaude = (task) => ["--permission-mode", "dontAsk", "--allowedTools", task.readOnly ? "mcp__harness" : "Edit Write mcp__harness",
   "--setting-sources", "user", "--settings", JSON.stringify(RESTRICTED_CLAUDE_SETTINGS), "--strict-mcp-config", "--mcp-config", JSON.stringify(restrictedMcpConfig())];
 
+// The model and effort the relay chose for the run (models.mjs), in each agent's own flags; none leaves its settings as they are.
+const MODEL_FLAGS = {
+  "claude-code": { model: (id) => ["--model", id], effort: (level) => ["--effort", level] },
+  codex: { model: (id) => ["-m", id], effort: (level) => ["-c", `model_reasoning_effort="${level}"`] },
+  pi: { model: (id) => ["--model", id], effort: (level) => ["--thinking", level] },
+  opencode: { model: (id) => ["-m", id], effort: (level) => ["--variant", level] },
+};
+const modelFlags = ({ agent, model, effort }) => [...(model ? MODEL_FLAGS[agent]?.model(model) ?? [] : []), ...(effort ? MODEL_FLAGS[agent]?.effort(effort) ?? [] : [])];
+
 export function agentInvocation(task) {
   if (task.agent === "claude-code") {
     return {
       command: "claude",
       // A review reads and reports: plan mode lets Claude Code read and run read-only tools but never edit.
-      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.restricted ? restrictedClaude(task) : task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
+      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.restricted ? restrictedClaude(task) : task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...modelFlags(task), ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
     };
   }
   // Only Claude Code has a restricted mode; any other agent's restricted run is refused here, whatever let it start.
@@ -61,15 +78,15 @@ export function agentInvocation(task) {
   if (task.agent === "codex") {
     return {
       command: "codex",
-      args: ["exec", ...(task.resumeSession ? ["resume", task.resumeSession] : []), "--json", ...(task.readOnly ? ["-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"'] : ["--dangerously-bypass-approvals-and-sandbox"]), "--skip-git-repo-check", "-"],
+      args: ["exec", ...(task.resumeSession ? ["resume", task.resumeSession] : []), "--json", ...modelFlags(task), ...(task.readOnly ? ["-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"'] : ["--dangerously-bypass-approvals-and-sandbox"]), "--skip-git-repo-check", "-"],
       stdin: task.brief,
     };
   }
   // Pi has no permission prompts. --approve trusts project-local configuration for
   // this non-interactive run; its complete built-in tool set remains enabled.
-  if (task.agent === "pi") return { command: "pi", args: ["--mode", "json", "--approve", "-p", task.brief] };
+  if (task.agent === "pi") return { command: "pi", args: ["--mode", "json", "--approve", ...modelFlags(task), "-p", task.brief] };
   if (task.agent === "opencode") {
-    return { command: "opencode", args: ["run", "--format", "json", "--auto", ...(task.resumeSession ? ["--session", task.resumeSession] : ["--title", task.title]), "--", task.brief] };
+    return { command: "opencode", args: ["run", "--format", "json", "--auto", ...modelFlags(task), ...(task.resumeSession ? ["--session", task.resumeSession] : ["--title", task.title]), "--", task.brief] };
   }
   throw new Error(`Unsupported agent: ${task.agent}`);
 }
@@ -160,9 +177,13 @@ export function runAgentTask(task, emit, observe = () => {}) {
   }
   let cwd;
   let invocation;
+  let environment;
   try {
     cwd = resolveWorkingDirectory(task.cwd);
     invocation = agentInvocation(task);
+    // A Node agent runs on a Node it accepts, whichever Node Harness itself runs on.
+    environment = agentEnvironment(invocation.command);
+    if (environment.error) throw new Error(environment.error);
   } catch (error) {
     emit("failed", error.message);
     return;
@@ -170,7 +191,7 @@ export function runAgentTask(task, emit, observe = () => {}) {
   emit("accepted");
   let child;
   try {
-    child = spawn(invocation.command, invocation.args, { cwd });
+    child = spawn(invocation.command, invocation.args, { cwd, env: environment.env });
     child.stdin.end(invocation.stdin);
   } catch (error) {
     running.delete(slot);
@@ -181,6 +202,7 @@ export function runAgentTask(task, emit, observe = () => {}) {
   children.set(task.runId, child);
 
   let resultText = "";
+  let modelError = "";
   let tail = "";
   let buffer = "";
   let sessionReported = false;
@@ -205,6 +227,12 @@ export function runAgentTask(task, emit, observe = () => {}) {
       if (event.type === "result" && typeof event.result === "string") resultText = event.result;
       if (event.type === "item.completed" && event.item?.type === "agent_message" && typeof event.item.text === "string") resultText = event.item.text;
       if (["text", "message.part.updated"].includes(event.type) && typeof event.part?.text === "string") resultText = event.part.text;
+      // Pi: its last words are its answer; when its model call fails, Pi still exits 0 with the error on the message.
+      if (event.type === "message_end" && event.message?.role === "assistant") {
+        const said = (Array.isArray(event.message.content) ? event.message.content : []).filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+        if (said) resultText = said;
+        modelError = event.message.stopReason === "error" ? String(event.message.errorMessage || "no error message") : "";
+      }
       for (const step of stepsOf(event)) emit("progress", step.text.slice(0, 200), { step });
     }
   });
@@ -216,7 +244,8 @@ export function runAgentTask(task, emit, observe = () => {}) {
   child.on("close", (code) => {
     running.delete(slot);
     children.delete(task.runId);
-    if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000), { usage: usage.result() });
+    if (code === 0 && modelError) emit("failed", `${task.agent} stopped on an error from its model: ${modelError}`.slice(0, 4_000), { usage: usage.result() });
+    else if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000), { usage: usage.result() });
     else emit("failed", (`${task.agent} exited with code ${code}.\n${tail}`).slice(0, 4_000), { usage: usage.result() });
   });
   child.on("error", (error) => {

package/lib/store.mjs

@@ -78,6 +78,7 @@ export function openStore(file) {
       trust text not null default 'agent',
       origin_chain text not null default '[]',
       usage text,
+      run_model text,
       removed_at text,
       created_at text not null,
       updated_at text not null
@@ -223,6 +224,7 @@ export function openStore(file) {
   }
   if (!boardColumns.has("kind") && boardColumns.size) db.exec("alter table board_tasks add column kind text not null default 'task'");
   if (!boardColumns.has("usage") && boardColumns.size) db.exec("alter table board_tasks add column usage text");
+  if (!boardColumns.has("run_model") && boardColumns.size) db.exec("alter table board_tasks add column run_model text");
   if (!boardColumns.has("removed_at") && boardColumns.size) db.exec("alter table board_tasks add column removed_at text");
   if (!boardColumns.has("trust") && boardColumns.size) db.exec("alter table board_tasks add column trust text not null default 'agent'; alter table board_tasks add column origin_chain text not null default '[]'");
 
@@ -559,9 +561,9 @@ export function openStore(file) {
     },
     // A thread's runs (wakes and jobs), oldest first, for its transcript.
     threadRuns(goalId) {
-      return execute("all", `select id, kind, objective, target_agent, claimed_by, status, holder, result, session_id, run_workspace, run_authorized_at, usage, created_at, updated_at, reported_at
+      return execute("all", `select id, kind, objective, target_agent, claimed_by, status, holder, result, session_id, run_workspace, run_authorized_at, usage, run_model, created_at, updated_at, reported_at
         from board_tasks where parent_id = ? and kind in ('wake', 'task') order by created_at asc`, goalId)
-        .map((row) => ({ ...row, usage: row.usage ? JSON.parse(row.usage) : null }));
+        .map((row) => ({ ...row, usage: row.usage ? JSON.parse(row.usage) : null, run_model: row.run_model ? JSON.parse(row.run_model) : null }));
     },
     // The coding sessions on this machine, newest first: the person's own and the ones runs started.
     recentSessions(limit = 30) {
@@ -569,6 +571,11 @@ export function openStore(file) {
         order by coalesce(ended_at, started_at, indexed_at) desc limit ?`, Math.max(1, Math.min(100, Number(limit) || 30)))
         .map((row) => ({ ...row, message_count: Number(row.message_count) }));
     },
+    // Each folder an agent's sessions ran in, with its latest, newest first.
+    sessionFolders(limit = 300) {
+      return execute("all", `select agent, cwd, max(coalesce(ended_at, started_at, indexed_at)) as at from sessions where cwd is not null
+        group by agent, cwd order by at desc limit ?`, Math.max(1, Math.min(1000, Number(limit) || 300)));
+    },
     // The thread that already carries a session, if any.
     threadForSession(agent, sessionId) {
       const row = execute("all", "select goal_id, sessions from board_goals").find((entry) => JSON.parse(entry.sessions || "{}")[agent] === sessionId);
@@ -605,6 +612,16 @@ export function openStore(file) {
     setRunUsage(id, usage) {
       execute("run", "update board_tasks set usage = ? where id = ?", JSON.stringify(usage), id);
     },
+    // The model and effort a run started with and who chose them (models.mjs); null fields: the agent's own settings.
+    setRunModel(id, choice) {
+      execute("run", "update board_tasks set run_model = ? where id = ?", JSON.stringify(choice), id);
+    },
+    // An agent's finished runs by the model they ran on, for Auto's record of each model.
+    modelWork(agent) {
+      return execute("all", `select json_extract(run_model, '$.model') as model, status, coalesce(run_authorized_at, created_at) as started_at, reported_at, usage from board_tasks
+        where coalesce(claimed_by, target_agent) = ? and json_extract(run_model, '$.model') is not null and status in ('done', 'failed') order by updated_at desc limit 2000`, agent)
+        .map((row) => ({ ...row, usage: row.usage ? JSON.parse(row.usage) : null }));
+    },
     setRunSession(id, sessionId) {
       execute("run", "update board_tasks set session_id = ?, updated_at = ? where id = ?", sessionId, new Date().toISOString(), id);
     },
@@ -750,6 +767,18 @@ export function openStore(file) {
     threadMessages(taskId) {
       return execute("all", "select * from board_messages where task_id = ? order by seq asc", taskId).map((row) => ({ ...row, seq: Number(row.seq), refs: JSON.parse(row.refs || "[]") }));
     },
+    // Every thread with another person's swarm, newest first, with what the Swarms list shows of each (network.mjs).
+    relayThreads(limit = 200) {
+      return execute("all", `select th.task_id, th.with_agent, th.role, th.auto_send, th.opened_at, th.closed_at, th.outcome, b.objective, b.target_agent, b.status, b.updated_at,
+          (select count(*) from board_messages m where m.task_id = th.task_id and m.state in ('held', 'flagged')) as held,
+          (select coalesce(max(seq), 0) from board_messages m where m.task_id = th.task_id and m.direction = 'in') as last_in_seq,
+          (select count(*) from board_messages m where m.task_id = th.task_id) as messages
+        from board_threads th join board_tasks b on b.id = th.task_id order by b.updated_at desc limit ?`, limit)
+        .map((row) => {
+          const last = execute("get", "select direction, sender, text, state, created_at, seq from board_messages where task_id = ? order by seq desc limit 1", row.task_id) || null;
+          return { ...row, auto_send: Number(row.auto_send) === 1, held: Number(row.held), last_in_seq: Number(row.last_in_seq), messages: Number(row.messages), last: last ? { ...last, seq: Number(last.seq) } : null };
+        });
+    },
     nextSeq(taskId) {
       const row = execute("get", "select coalesce(max(seq), 0) as seq from board_messages where task_id = ?", taskId);
       return Number(row.seq) + 1;
@@ -917,7 +946,7 @@ export function openStore(file) {
     getTask(id) {
       const row = execute("get", "select * from board_tasks where id = ?", id);
       if (!row) return null;
-      const task = { ...row, version: Number(row.version), context_refs: JSON.parse(row.context_refs || "[]"), origin_chain: JSON.parse(row.origin_chain || "[]"), usage: row.usage ? JSON.parse(row.usage) : null, stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < new Date().toISOString() };
+      const task = { ...row, version: Number(row.version), context_refs: JSON.parse(row.context_refs || "[]"), origin_chain: JSON.parse(row.origin_chain || "[]"), usage: row.usage ? JSON.parse(row.usage) : null, run_model: row.run_model ? JSON.parse(row.run_model) : null, stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < new Date().toISOString() };
       if (row.kind === "goal") return { ...task, goal: this.goal(id) };
       return row.kind === "group" ? { ...task, children: this.children(id) } : task;
     },

package/lib/swarm.mjs

@@ -1,24 +1,26 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { readRunSteps } from "./runner.mjs";
-import { mainCheckout } from "./worktrees.mjs";
 import { nameOf, resolveMember } from "./members.mjs";
-import { setNote, swarmBlock, swarmCards, swarmDigest } from "./cards.mjs";
+import { modelOf, setNote, swarmBlock, swarmCards, swarmDigest } from "./cards.mjs";
+import { DEFAULT_ROUTING, PICKABLE, choiceOf, listingOf, picksIn, routingOf, setChoice, setRouting } from "./models.mjs";
 
 // The person's swarm as threads. A thread is a goal under the hood: its room is the transcript, its team the agents in
 // it, its folder where coding agents work, and it runs on its own authority. A message the person sends wakes the
 // agents it names (or the only agent in the thread), each resuming its own session; their runs' steps are read back
 // from the run logs. The person's own terminal sessions are listed too and continue in a thread once idle.
 
-const PROCESS_NAMES = { "claude-code": "claude", codex: "codex", pi: "pi", opencode: "opencode" };
+export const PROCESS_NAMES = { "claude-code": "claude", codex: "codex", pi: "pi", opencode: "opencode" };
 const SAY_LIMIT = 4_000;
 const UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 
 // The id an agent resumes a session by: the index keys sessions by their file name.
 export function nativeSessionId(agent, sessionId) {
   const bare = String(sessionId).replace(/\.jsonl$/, "");
-  return agent === "codex" ? bare.match(UUID)?.[0] ?? bare : bare;
+  // Codex and pi name a session's file by its time and id; the id is what resumes it.
+  return agent === "codex" || agent === "pi" ? bare.match(UUID)?.[0] ?? bare : bare;
 }
 
 // The folder each running coding agent works in, by agent, leaving out the runs the daemon started itself.
@@ -50,7 +52,7 @@ export function agentProcessCwds(exclude = new Set()) {
   return cwds;
 }
 
-export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoard, goalCommand, stopThreadRuns, runLog, runningPids, provenanceFor, defaults, coordinator, worktrees, roster, authorizeRun }) {
+export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoard, goalCommand, stopThreadRuns, runLog, runningPids, provenanceFor, defaults, coordinator, worktrees, roster, authorizeRun, pickable, listModels, folders, runsIn }) {
   const awaitingStart = (run) => run.status === "open" && Boolean(run.run_workspace) && !run.run_authorized_at;
   const isDir = (folder) => typeof folder === "string" && path.isAbsolute(folder) && fs.statSync(folder, { throwIfNoEntry: false })?.isDirectory();
   const agentsOf = (thread) => thread.goal.team.filter((agent) => agent !== thread.goal.facilitator);
@@ -116,12 +118,16 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
   // The agent a request names in `to`: null for none, false for one no thread can have.
   const recipient = (request) => (request.to == null || request.to === "" ? null : roomAgents.includes(String(request.to)) ? String(request.to) : false);
 
-  const lastFolder = (agent) => store.recentSessions(100).find((session) => session.agent === agent && isDir(session.cwd))?.cwd ?? null;
+  // A thread needs a folder when a coding agent is in it, or when no one is named and the coordinator picks who works.
+  const needsFolder = (team) => !team.length || team.some((name) => PROCESS_NAMES[name]);
+  // Where each coding agent in a thread would run its turn there: in T3 Code, or here, and why not T3 when the person uses it there.
+  const placeOf = (folder, team, by) => ({ ok: true, folder, name: folder ? path.basename(folder) : null, by,
+    runs: folder ? team.filter((name) => PROCESS_NAMES[name]).map((name) => ({ agent: name, ...runsIn(name, folder) })) : [] });
 
   const read = (thread) => {
     const runs = store.threadRuns(thread.id).map((run) => ({
       id: run.id, agent: run.claimed_by || run.target_agent, kind: run.kind, status: run.status, awaitingStart: awaitingStart(run), startedAt: run.created_at, endedAt: run.reported_at,
-      sessionId: run.session_id, folder: run.run_workspace, usage: run.usage,
+      sessionId: run.session_id, folder: run.run_workspace, usage: run.usage, model: run.run_model,
       steps: readRunSteps(runLog(run.id), 300).map((step) => ({ ...step, text: step.text.slice(0, SAY_LIMIT) })),
     }));
     return { ok: true, thread: summary(thread), posts: store.roomPosts(thread.id, 0, 500), runs };
@@ -129,6 +135,8 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
 
   // `to`: the one agent the person wrote to (the desktop's agent list), so their words go as written, with no @name.
   const post = (thread, text, to = null) => {
+    const picked = picksIn(store, text, roomAgents);
+    if (picked.error) return { ok: false, error: picked.error };
     // A new name in the person's message joins the thread.
     const joining = [...new Set([...mentionsIn(text, roomAgents), ...(to ? [to] : [])])].filter((agent) => !thread.goal.team.includes(agent));
     if (joining.length) store.setGoalTeam(thread.id, [...thread.goal.team, ...joining]);
@@ -160,6 +168,19 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
       const agents = swarmCards(store, roster().filter((entry) => entry.id !== agent));
       return { ok: true, agents, text: swarmBlock(agents), digest: swarmDigest(agents) };
     }
+    // Each coding agent's models as it lists them, the person's choice for it and their routing words (models.mjs). Open
+    // to every caller, so an agent names a model that exists: post_task's model, or `@codex:model/effort` in a post.
+    if (command === "board.swarm.models") {
+      const named = request.target ? resolveMember(request.target) : null;
+      if (named && !named.ok) return { ok: false, error: `no agent called "${request.target}"` };
+      const ids = pickable().filter((id) => !named || id === named.id);
+      if (named && !ids.length) return { ok: false, error: `the relay sets the model of ${[...PICKABLE].join(", ")} when they are installed here, not ${nameOf(named.id)}` };
+      const listing = () => ({ ok: true, routing: routingOf(store), defaultRouting: DEFAULT_ROUTING, agents: ids.map((id) => {
+        const listed = listingOf(store, id);
+        return { id, name: nameOf(id), choice: choiceOf(store, id), ownModel: modelOf(id), listedAt: listed?.at ?? null, ...(listed?.error ? { error: listed.error } : {}), models: listed?.models ?? [] };
+      }) });
+      return request.refresh === true && agent === "user" ? { pending: listModels().then(listing) } : listing();
+    }
     // Any of the person's agents may start a thread and stop one it started. The thread carries the agent's trust, so
     // nothing in it runs without the person's Start, and one started through Harness gets no coordinator rounds (they
     // are paid) until the person sets a spend ceiling.
@@ -169,8 +190,10 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
       const folder = request.folder ? String(request.folder) : null;
       if (folder && !isDir(folder)) return { ok: false, error: `${folder} is not an absolute path to a folder` };
       const team = new Set(mentionsIn(text, roomAgents));
+      const picked = picksIn(store, text, roomAgents);
+      if (picked.error) return { ok: false, error: picked.error };
       if (!team.size) return { ok: false, error: `name who the thread is for with @, one of: ${roomAgents.filter((name) => name !== agent && name !== "harness").join(", ")}` };
-      const objective = text.split("\n").map((line) => line.trim()).find(Boolean).replace(/@([a-z][a-z0-9-]*)\s*/g, "").slice(0, 120) || text.slice(0, 120);
+      const objective = text.split("\n").map((line) => line.trim()).find(Boolean).replace(/@([a-z][a-z0-9-]*)(:\S+)?\s*/g, "").slice(0, 120) || text.slice(0, 120);
       const thread = store.createGoal({ objective, originAgent: agent, provenance: provenanceFor(agent), team: [...team, agent, "harness"], facilitator: "harness", workspace: folder ? path.resolve(folder) : null, maxPosts: defaults.maxPosts, maxWakes: defaults.maxWakes });
       if (request.hostedCaller) store.meta(`hosted-thread:${thread.id}`, "1");
       const first = store.roomPost({ goalId: thread.id, author: agent, kind: "post", text, mentions: addressed(store.getTask(thread.id), text) });
@@ -186,12 +209,37 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
       return { ok: true, thread: summary(store.getTask(thread.id)) };
     }
     if (agent !== "user") return { ok: false, error: "only the person writes in, stops or resumes a thread they did not start; post in it with post_to_room" };
+    // Where a thread works, for the composer (folders.mjs): the folders the person works in, any folder on the computer
+    // from a typed path, and where a message would work: the folder chosen (`folder`) or the one Harness suggests, and
+    // where each coding agent named in it (`text`, `to`, `agents`) runs its turns there.
+    if (command === "board.swarm.places") return { ok: true, places: folders.known(), home: os.homedir() };
+    if (command === "board.swarm.browse") return folders.browse(request.path);
+    if (command === "board.swarm.place") {
+      const text = String(request.text || "").slice(0, 20_000);
+      const to = recipient(request);
+      const team = [...new Set([...mentionsIn(text, roomAgents), ...(to ? [to] : []), ...(Array.isArray(request.agents) ? request.agents.map(String).filter((name) => roomAgents.includes(name)) : [])])];
+      if (request.folder) {
+        const folder = String(request.folder);
+        return isDir(folder) ? placeOf(path.resolve(folder), team, "you") : { ok: false, error: `${folder} is not a folder on this computer` };
+      }
+      if (!needsFolder(team)) return placeOf(null, team, null);
+      return { pending: folders.suggest(text, team).then(({ folder, by }) => placeOf(folder, team, by)) };
+    }
     // The person's own note on one agent's card ("use it for reviews"), told to every other agent; no text clears it.
     if (command === "board.swarm.note") {
       const named = resolveMember(request.target);
       if (!named.ok) return { ok: false, error: named.candidates.length ? `"${request.target}" could be ${named.candidates.join(" or ")}; name one` : `no agent called "${request.target}"` };
       return { ok: true, agent: named.id, note: setNote(store, named.id, request.text) };
     }
+    // The person's choice of model and effort for one agent: a model it lists, "auto", or "default" for its own settings.
+    if (command === "board.swarm.model") {
+      const named = resolveMember(request.target);
+      if (!named.ok || !PICKABLE.has(named.id)) return { ok: false, error: `the relay sets the model of ${[...PICKABLE].join(", ")}, not "${request.target}"` };
+      const set = setChoice(store, named.id, request.model, request.effort);
+      return set.ok ? { ok: true, agent: named.id, choice: set.choice } : set;
+    }
+    // The person's words on how Auto picks models for swarm work; no text goes back to the default words.
+    if (command === "board.swarm.routing") return { ok: true, routing: setRouting(store, request.text), defaultRouting: DEFAULT_ROUTING };
     // The coordinator's record: what each round saw, chose and cost. The evidence for its limits.
     if (command === "board.swarm.rounds") return { ok: true, rounds: store.rounds(request.id ? String(request.id) : null, request.limit) };
     if (command === "board.swarm.coordinator") {
@@ -211,6 +259,8 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
       const to = recipient(request);
       if (to === false) return { ok: false, error: `${request.to} can't be written to in a thread` };
       const team = new Set([...mentionsIn(text, roomAgents), ...(to ? [to] : [])]);
+      const picked = picksIn(store, text, roomAgents);
+      if (picked.error) return { ok: false, error: picked.error };
       if (from) {
         const agentName = String(from.agent || ""), sessionId = String(from.sessionId || "");
         if (!PROCESS_NAMES[agentName]) return { ok: false, error: "only a coding agent's session continues in a thread" };
@@ -222,19 +272,19 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
         team.add(agentName);
         folder ??= isDir(session.cwd) ? session.cwd : null;
       }
-      // Where the work happens: the named agent's last folder, else the latest coding session's on this computer; one in
-      // a worktree (a thread's copy here, T3 Code's) is the repository's own checkout, where the person works.
-      const last = [...team].map((name) => PROCESS_NAMES[name] ? lastFolder(name) : null).find(Boolean)
-        ?? store.recentSessions(100).find((session) => PROCESS_NAMES[session.agent] && isDir(session.cwd))?.cwd ?? null;
-      folder ??= last ? mainCheckout(last) : null;
-      const objective = text.split("\n").map((line) => line.trim()).find(Boolean).replace(/@([a-z][a-z0-9-]*)\s*/g, "").slice(0, 120) || text.slice(0, 120);
-      const thread = store.createGoal({ objective, originAgent: "user", provenance: provenanceFor("user"), team: [...team, "harness"], facilitator: "harness", workspace: folder ? path.resolve(folder) : null, maxPosts: defaults.maxPosts, maxWakes: defaults.maxWakes });
-      if (from) { store.setGoalSession(thread.id, String(from.agent), nativeSessionId(String(from.agent), String(from.sessionId))); worktrees.inPlace(thread.id); }
-      const opened = store.getTask(thread.id);
-      const first = store.roomPost({ goalId: thread.id, author: "user", kind: "post", text, mentions: addressed(opened, text) });
-      wakeFor(thread.id, first, "user");
-      notifyBoard(store.getTask(thread.id));
-      return { ok: true, thread: summary(store.getTask(thread.id)) };
+      // Where the work happens: the folder the person chose, else one picked from what they wrote, else where its agent
+      // last worked (folders.mjs); never the home folder or a hidden one.
+      const begin = (where) => {
+        const objective = text.split("\n").map((line) => line.trim()).find(Boolean).replace(/@([a-z][a-z0-9-]*)(:\S+)?\s*/g, "").slice(0, 120) || text.slice(0, 120);
+        const thread = store.createGoal({ objective, originAgent: "user", provenance: provenanceFor("user"), team: [...new Set([...team, "harness"])], facilitator: "harness", workspace: where ? path.resolve(where) : null, maxPosts: defaults.maxPosts, maxWakes: defaults.maxWakes });
+        if (from) { store.setGoalSession(thread.id, String(from.agent), nativeSessionId(String(from.agent), String(from.sessionId))); worktrees.inPlace(thread.id); }
+        const opened = store.getTask(thread.id);
+        const first = store.roomPost({ goalId: thread.id, author: "user", kind: "post", text, mentions: addressed(opened, text) });
+        wakeFor(thread.id, first, "user");
+        notifyBoard(store.getTask(thread.id));
+        return { ok: true, thread: summary(store.getTask(thread.id)) };
+      };
+      return folder || !needsFolder([...team]) ? begin(folder) : { pending: folders.suggest(text, [...team]).then((suggested) => begin(suggested.folder)) };
     }
     const thread = store.getTask(String(request.id || ""));
     if (!thread || thread.kind !== "goal") return { ok: false, error: "thread not found" };
@@ -276,10 +326,21 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
       notifyBoard(store.getTask(thread.id));
       return { ok: true, thread: summary(store.getTask(thread.id)) };
     }
+    // The person moves the thread to another folder between turns. Each agent starts a new session there, as a session
+    // and a T3 thread belong to the folder they ran in.
     if (command === "board.swarm.folder") {
       const folder = String(request.folder || "");
-      if (!isDir(folder)) return { ok: false, error: `${folder} is not an absolute path to a folder` };
-      store.setGoalFolder(thread.id, path.resolve(folder));
+      if (!isDir(folder)) return { ok: false, error: `${folder} is not a folder on this computer` };
+      const where = path.resolve(folder);
+      if (where === thread.goal.workspace) return { ok: true, thread: summary(thread) };
+      if (store.threadRuns(thread.id).some((run) => ["open", "claimed", "running"].includes(run.status))) return { ok: false, error: "an agent is still working in this thread; stop it or wait for it first" };
+      const moved = worktrees.moved(thread.id);
+      if (!moved.ok) return moved;
+      store.setGoalFolder(thread.id, where);
+      for (const name of Object.keys(thread.goal.sessions || {})) store.setGoalSession(thread.id, name, null);
+      for (const name of thread.goal.team) if (store.meta(`t3-thread:${thread.id}:${name}`)) store.meta(`t3-thread:${thread.id}:${name}`, "");
+      store.roomPost({ goalId: thread.id, author: "user", kind: "note", text: `Now working in ${where}.` });
+      notifyBoard(store.getTask(thread.id));
       return { ok: true, thread: summary(store.getTask(thread.id)) };
     }
     return { ok: false, error: "unknown command" };

package/lib/t3.mjs

@@ -201,7 +201,7 @@ function stepOf(item) {
 /**
  * A coding agent's turn in a Harness thread, carried out by T3 Code, so the person finds it in T3 like any thread there.
  * The agent's first turn launches its own T3 thread (`launch`: T3's project, workspace and the model the person last
- * chose for the agent there; T3 applies the mode the person approved Harness with); later turns go into that thread,
+ * chose for the agent there, unless the relay chose one, `model`; T3 applies the mode the person approved Harness with); later turns go into that thread,
  * queued behind whatever it is doing. It reports as runner.mjs does: accepted, its session (the T3 thread, which is
  * how Open finds it), each step, then done with the agent's last words or failed; Stop interrupts it in T3.
  */
@@ -245,9 +245,12 @@ export function runInT3(run, emit, observe) {
   emit("accepted");
   void (async () => {
     try {
-      if (threadId) runId = (await t3Tool("t3_thread_send", { threadId, message: run.brief, mode: "queue", clientRequestId: run.runId })).runId ?? null;
-      else {
-        const launched = await t3Tool("t3_thread_launch", { title: run.title, message: run.brief, ...run.launch });
+      // A model the relay chose for this turn (models.mjs) is the thread's selection from this turn on.
+      if (threadId) {
+        if (run.model) await t3Tool("t3_thread_configure", { threadId, modelSelection: run.model });
+        runId = (await t3Tool("t3_thread_send", { threadId, message: run.brief, mode: "queue", clientRequestId: run.runId })).runId ?? null;
+      } else {
+        const launched = await t3Tool("t3_thread_launch", { title: run.title, message: run.brief, ...run.launch, ...(run.model ? { modelSelection: run.model } : {}) });
         threadId = launched.threadId;
         runId = launched.runId ?? null;
         run.onThread?.(threadId);

package/lib/worktrees.mjs

@@ -142,17 +142,33 @@ export function createWorktrees({ store, root }) {
     return { ok: true };
   };
 
+  /**
+   * The thread's folder changed: its copy of the old repository goes when nothing in it is the person's yet, and the
+   * next turn makes whatever the new folder needs. Changes not yet merged or discarded keep it where it is.
+   */
+  const moved = (threadId) => {
+    const tree = get(threadId);
+    if (tree?.state === "open" && fs.existsSync(tree.path)) {
+      if (stat(tree.path, `${tree.base}..HEAD`).length) return { ok: false, error: `this thread changed files on ${tree.branch}; merge or discard them first` };
+      retire(tree);
+      git(tree.repo, ["branch", "-D", tree.branch]);
+    }
+    if (tree) save(threadId, null);
+    return { ok: true };
+  };
+
   /** A thread that carries on a session from a terminal works where that session did: agents find sessions by folder. */
   const inPlace = (threadId) => save(threadId, { state: "in_place" });
 
   /**
    * Where T3 Code runs a thread's agents (t3.mjs runInT3): the checkout T3 made for the thread's first agent, shared by
-   * the rest as its own worktree is, or the thread's own copy when it worked here before; else a new one on its own
-   * branch from what the person has checked out (as folderFor's), or T3's project folder when the thread's folder is in
-   * no repository.
+   * the rest as its own worktree is, or the thread's own copy when it worked here before; a task's room that works in
+   * place, T3's project checkout itself; else a new one on its own branch from what the person has checked out (as
+   * folderFor's), or T3's project folder when the thread's folder is in no repository.
    */
   const t3Workspace = (thread) => {
     const current = get(thread.id);
+    if (current?.state === "in_place" || current?.inPlace) return { type: "root" };
     if ((current?.state === "t3" || current?.state === "open") && current.path) return { type: "existing_worktree", worktreePath: current.path, ...(current.branch ? { branch: current.branch } : {}) };
     const repo = repositoryOf(thread.goal.workspace);
     if (!repo) return { type: "root" };
@@ -163,8 +179,8 @@ export function createWorktrees({ store, root }) {
   /** The thread works in T3 Code from now on; `where` and `branch` once T3 has made its checkout. */
   const inT3 = (threadId, where = null, branch = null) => {
     const current = get(threadId);
-    if (current?.state !== "t3" || (where && where !== current.path)) save(threadId, { ...current, state: "t3", path: where ?? current?.path ?? null, branch: branch ?? current?.branch ?? null });
+    if (current?.state !== "t3" || (where && where !== current.path)) save(threadId, { ...current, ...(current?.state === "in_place" ? { inPlace: true } : {}), state: "t3", path: where ?? current?.path ?? null, branch: branch ?? current?.branch ?? null });
   };
 
-  return { folderFor, commitTurn, diff, summary, merge, discard, inPlace, t3Workspace, inT3, get };
+  return { folderFor, commitTurn, diff, summary, merge, discard, moved, inPlace, t3Workspace, inT3, get };
 }