tryharness 0.7.22 → 0.7.25

package/lib/swarm.mjs

@@ -4,15 +4,35 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { readRunSteps } from "./runner.mjs";
 import { nameOf, resolveMember } from "./members.mjs";
-import { modelOf, setNote, swarmBlock, swarmCards, swarmDigest } from "./cards.mjs";
-import { DEFAULT_ROUTING, PICKABLE, choiceOf, listingOf, picksIn, routingOf, setChoice, setRouting } from "./models.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.
 
-export 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;
 
@@ -20,7 +40,9 @@ const UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 export function nativeSessionId(agent, sessionId) {
   const bare = String(sessionId).replace(/\.jsonl$/, "");
   // 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;
+  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.
@@ -33,12 +55,18 @@ export function agentProcessCwds(exclude = new Set()) {
   for (const line of ps.stdout.split("\n")) {
     const match = line.trim().match(/^(\d+)\s+(.+)$/);
     if (!match || exclude.has(Number(match[1]))) continue;
-    const agent = Object.keys(PROCESS_NAMES).find((name) => path.basename(match[2]) === PROCESS_NAMES[name]);
+    const agent = Object.keys(PROCESS_NAMES).find(
+      (name) => path.basename(match[2]) === PROCESS_NAMES[name]
+    );
     if (agent) byPid.set(match[1], agent);
   }
   const cwds = new Map();
   if (!byPid.size) return cwds;
-  const lsof = spawnSync("lsof", ["-a", "-d", "cwd", "-Fn", "-p", [...byPid.keys()].join(",")], { encoding: "utf8" });
+  const lsof = spawnSync(
+    "lsof",
+    ["-a", "-d", "cwd", "-Fn", "-p", [...byPid.keys()].join(",")],
+    { encoding: "utf8" }
+  );
   if (lsof.status !== 0 && !lsof.stdout) return null;
   let pid = null;
   for (const line of lsof.stdout.split("\n")) {
@@ -52,10 +80,39 @@ 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, 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);
+export function createSwarm({
+  store,
+  roomAgents,
+  mentionsIn,
+  wakeFor,
+  notifyBoard,
+  goalCommand,
+  stopThreadRuns,
+  runLog,
+  runningPids,
+  provenanceFor,
+  defaults,
+  coordinator,
+  worktrees,
+  roster,
+  authorizeRun,
+  pickable,
+  listModels,
+  folders,
+  runsIn,
+  threadFiles = () => ({ files: [], rendering: [] }),
+  whyWaiting = () => null,
+}) {
+  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);
 
   // Who a message is for: the agents it names, else the only agent in the thread, else whoever coordinates.
   const addressed = (thread, text) => {
@@ -67,15 +124,33 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
 
   // What the thread waits on the person for, if anything: a pause, an agent's question, a run's question.
   const waitingOn = (thread, posts, runs) => {
-    if (thread.status === "paused") return { kind: "paused", text: thread.goal.paused_reason || "Paused." };
-    const asking = runs.find((run) => run.status === "needs_input" && run.holder === "user");
-    if (asking) return { kind: "question", agent: asking.claimed_by || asking.target_agent, text: asking.result || "" };
+    if (thread.status === "paused")
+      return { kind: "paused", text: thread.goal.paused_reason || "Paused." };
+    const asking = runs.find(
+      (run) => run.status === "needs_input" && run.holder === "user"
+    );
+    if (asking)
+      return {
+        kind: "question",
+        agent: asking.claimed_by || asking.target_agent,
+        text: asking.result || "",
+      };
     // Work another agent asked for that only the person's Start lets run (docs/member-runs.md).
     const held = runs.find(awaitingStart);
-    if (held) return { kind: "start", agent: held.target_agent, runId: held.id, text: `${nameOf(held.target_agent)} waits for your Start` };
+    if (held)
+      return {
+        kind: "start",
+        agent: held.target_agent,
+        runId: held.id,
+        text: `${nameOf(held.target_agent)} waits for your Start`,
+      };
     const lastMine = posts.findLastIndex((post) => post.author === "user");
-    const question = posts.slice(lastMine + 1).findLast((post) => post.kind === "question");
-    return question ? { kind: "question", agent: question.author, text: question.text } : null;
+    const question = posts
+      .slice(lastMine + 1)
+      .findLast((post) => post.kind === "question");
+    return question
+      ? { kind: "question", agent: question.author, text: question.text }
+      : null;
   };
 
   const summary = (thread) => {
@@ -85,17 +160,64 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
     const live = runs.find((run) => run.status === "running");
     const step = live ? readRunSteps(runLog(live.id), 1)[0] : null;
     return {
-      id: thread.id, title: thread.objective, status: thread.status, agents: agentsOf(thread), coordinator: thread.goal.facilitator,
+      id: thread.id,
+      title: thread.objective,
+      status: thread.status,
+      agents: agentsOf(thread),
+      coordinator: thread.goal.facilitator,
       // The task this room was opened for, when it is a task's own room.
       root: store.meta(`task-room:${thread.id}`) || null,
-      folder: thread.goal.workspace, working: [...new Set(runs.filter((run) => ["claimed", "running"].includes(run.status)).map((run) => run.target_agent))],
-      queued: [...new Set(runs.filter((run) => run.status === "open").map((run) => run.target_agent))],
-      step: step ? { agent: live.claimed_by || live.target_agent, kind: step.kind, text: step.text.split("\n")[0].slice(0, 200) } : null,
-      waiting: waitingOn(thread, posts, runs), last: last ? { author: last.author, kind: last.kind, text: last.text.slice(0, 280), at: last.created_at, mentions: last.mentions } : null,
-      posts: thread.goal.posts, spend: thread.goal.spend, createdAt: thread.created_at, updatedAt: last?.created_at ?? thread.updated_at,
+      folder: thread.goal.workspace,
+      working: [
+        ...new Set(
+          runs
+            .filter((run) => ["claimed", "running"].includes(run.status))
+            .map((run) => run.target_agent)
+        ),
+      ],
+      queued: [
+        ...new Set(
+          runs
+            .filter((run) => run.status === "open")
+            .map((run) => run.target_agent)
+        ),
+      ],
+      // Why each agent given work here has not started, in a sentence: every surface says it the same way.
+      waits: runs
+        .map((run) => ({
+          agent: run.target_agent,
+          text: whyWaiting(thread.id, run),
+        }))
+        .filter((wait) => wait.text),
+      step: step
+        ? {
+            agent: live.claimed_by || live.target_agent,
+            kind: step.kind,
+            text: step.text.split("\n")[0].slice(0, 200),
+          }
+        : null,
+      waiting: waitingOn(thread, posts, runs),
+      last: last
+        ? {
+            author: last.author,
+            kind: last.kind,
+            text: last.text.slice(0, 280),
+            at: last.created_at,
+            mentions: last.mentions,
+          }
+        : null,
+      posts: thread.goal.posts,
+      spend: thread.goal.spend,
+      createdAt: thread.created_at,
+      updatedAt: last?.created_at ?? thread.updated_at,
       // Parts the swarm moved past: never silent, one tap sends one back.
-      openItems: posts.filter((post) => post.kind === "open_item").map((post) => ({ seq: post.seq, text: post.text })),
-      coordination: { mode: coordinator.mode(), rounds: coordinator.state(thread.id).rounds },
+      openItems: posts
+        .filter((post) => post.kind === "open_item")
+        .map((post) => ({ seq: post.seq, text: post.text })),
+      coordination: {
+        mode: coordinator.mode(),
+        rounds: coordinator.state(thread.id).rounds,
+      },
       changes: worktrees.summary(thread.id),
     };
   };
@@ -104,33 +226,94 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
   const sessions = () => {
     const live = agentProcessCwds(new Set(runningPids()));
     const newestIn = new Set();
-    return store.recentSessions(30).filter((session) => PROCESS_NAMES[session.agent] && !store.threadForSession(session.agent, nativeSessionId(session.agent, session.session_id))).map((session) => {
-      const key = `${session.agent}:${session.cwd}`;
-      const newest = !newestIn.has(key);
-      newestIn.add(key);
-      const open = live === null || (newest && Boolean(live.get(session.agent)?.has(session.cwd)));
-      return { agent: session.agent, sessionId: session.session_id, title: session.title, folder: session.cwd, startedAt: session.started_at, endedAt: session.ended_at, messages: session.message_count, open };
-    });
+    return store
+      .recentSessions(30)
+      .filter(
+        (session) =>
+          PROCESS_NAMES[session.agent] &&
+          !store.threadForSession(
+            session.agent,
+            nativeSessionId(session.agent, session.session_id)
+          )
+      )
+      .map((session) => {
+        const key = `${session.agent}:${session.cwd}`;
+        const newest = !newestIn.has(key);
+        newestIn.add(key);
+        const open =
+          live === null ||
+          (newest && Boolean(live.get(session.agent)?.has(session.cwd)));
+        return {
+          agent: session.agent,
+          sessionId: session.session_id,
+          title: session.title,
+          folder: session.cwd,
+          startedAt: session.started_at,
+          endedAt: session.ended_at,
+          messages: session.message_count,
+          open,
+        };
+      });
   };
 
-  const sessionOpen = (agent, sessionId) => sessions().find((session) => session.agent === agent && session.sessionId === sessionId)?.open ?? false;
+  const sessionOpen = (agent, sessionId) =>
+    sessions().find(
+      (session) => session.agent === agent && session.sessionId === sessionId
+    )?.open ?? false;
 
   // 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 recipient = (request) =>
+    request.to == null || request.to === ""
+      ? null
+      : roomAgents.includes(String(request.to))
+        ? String(request.to)
+        : false;
 
   // 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]);
+  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) })) : [] });
+  // `lastWorked`: where its agent last worked, when Harness picked another folder from the message, for the person to take.
+  const placeOf = (folder, team, by, lastWorked = null) => ({
+    ok: true,
+    folder,
+    name: folder ? path.basename(folder) : null,
+    by,
+    lastWorked: lastWorked
+      ? { folder: lastWorked, name: path.basename(lastWorked) }
+      : null,
+    runs: folder
+      ? team
+          .filter((name) => PROCESS_NAMES[name])
+          .map((name) => ({ agent: name, ...runsIn(name, folder) }))
+      : [],
+  });
 
-  const read = (thread) => {
+  const read = (thread, hostedCaller = false) => {
     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, model: run.run_model,
-      steps: readRunSteps(runLog(run.id), 300).map((step) => ({ ...step, text: step.text.slice(0, SAY_LIMIT) })),
+      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,
+      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 };
+    return {
+      ok: true,
+      thread: summary(thread),
+      posts: store.roomPosts(thread.id, 0, 500),
+      runs,
+      ...threadFiles(thread, hostedCaller),
+    };
   };
 
   // `to`: the one agent the person wrote to (the desktop's agent list), so their words go as written, with no @name.
@@ -138,191 +321,467 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
     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]);
+    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]);
     if (thread.status !== "open") {
       store.setGoalState(thread.id, { status: "open" });
-      store.roomPost({ goalId: thread.id, author: "user", kind: "note", text: "Picked up again by you." });
+      store.roomPost({
+        goalId: thread.id,
+        author: "user",
+        kind: "note",
+        text: "Picked up again by you.",
+      });
     }
     const current = store.getTask(thread.id);
-    return goalCommand({ command: "board.room.post", id: thread.id, text, mentions: to ? [to] : addressed(current, text) }, "user");
+    return goalCommand(
+      {
+        command: "board.room.post",
+        id: thread.id,
+        text,
+        mentions: to ? [to] : addressed(current, text),
+      },
+      "user"
+    );
   };
 
   return function swarmCommand(request, agent) {
     const command = String(request.command);
     if (command === "board.swarm.list") {
-      if (agent !== "user" && agent !== "harness") return { ok: false, error: "only the person and Harness read the swarm" };
-      return { ok: true, threads: store.goals({ all: request.all === true }).map(summary), sessions: request.sessions === false ? [] : sessions(), agents: roster() };
+      if (agent !== "user" && agent !== "harness")
+        return {
+          ok: false,
+          error: "only the person and Harness read the swarm",
+        };
+      return {
+        ok: true,
+        threads: store.goals({ all: request.all === true }).map(summary),
+        sessions: request.sessions === false ? [] : sessions(),
+        agents: roster(),
+      };
     }
     // The swarm's shared memory, for any of the person's agents: what any agent wrote in any thread, and the coding
     // sessions on this machine. A caller limited to its own threads (a hosted agent while the machine is sealed) gets only those.
     if (command === "board.swarm.search") {
-      const query = String(request.query || "").trim().slice(0, 500);
+      const query = String(request.query || "")
+        .trim()
+        .slice(0, 500);
       if (!query) return { ok: false, error: "search needs a query" };
-      const mine = request.teamOnly ? store.goals({ all: true }).filter((thread) => thread.goal.team.includes(agent)).map((thread) => thread.id) : null;
-      return { ok: true, threads: store.searchThreads(query, { goalIds: mine, k: 8 }), sessions: request.teamOnly ? [] : store.search({ query, limit: 5 }) };
+      const mine = request.teamOnly
+        ? store
+            .goals({ all: true })
+            .filter((thread) => thread.goal.team.includes(agent))
+            .map((thread) => thread.id)
+        : null;
+      return {
+        ok: true,
+        threads: store.searchThreads(query, { goalIds: mine, k: 8 }),
+        sessions: request.teamOnly ? [] : store.search({ query, limit: 5 }),
+      };
     }
     // Who can be asked: every other agent's card (cards.mjs), and the same cards as the block an agent is told when its
     // session starts. Open to every caller, so an agent picks a name instead of guessing one.
     if (command === "board.swarm.agents") {
-      const agents = swarmCards(store, roster().filter((entry) => entry.id !== agent));
-      return { ok: true, agents, text: swarmBlock(agents), digest: swarmDigest(agents) };
+      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}"` };
+      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();
+      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.
     if (agent !== "user" && command === "board.swarm.start") {
-      const text = String(request.text || "").trim().slice(0, 20_000);
+      const text = String(request.text || "")
+        .trim()
+        .slice(0, 20_000);
       if (!text) return { ok: false, error: "a thread starts with a message" };
       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` };
+      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+)?\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 (!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+)?\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) });
+      const first = store.roomPost({
+        goalId: thread.id,
+        author: agent,
+        kind: "post",
+        text,
+        mentions: addressed(store.getTask(thread.id), text),
+      });
       wakeFor(thread.id, first, agent);
       notifyBoard(store.getTask(thread.id));
-      return { ok: true, thread: summary(store.getTask(thread.id)), note: "Agents here run only after the person's Start; read the thread with read_room and add to it with post_to_room." };
+      return {
+        ok: true,
+        thread: summary(store.getTask(thread.id)),
+        note: "Agents here run only after the person's Start; read the thread with read_room and add to it with post_to_room.",
+      };
     }
     if (agent !== "user" && command === "board.swarm.stop") {
       const thread = store.getTask(String(request.id || ""));
-      if (!thread || thread.kind !== "goal" || thread.origin_agent !== agent) return { ok: false, error: "thread not found" };
-      if (thread.status !== "open") return { ok: false, error: `the thread is ${thread.status}` };
+      if (!thread || thread.kind !== "goal" || thread.origin_agent !== agent)
+        return { ok: false, error: "thread not found" };
+      if (thread.status !== "open")
+        return { ok: false, error: `the thread is ${thread.status}` };
       stopThreadRuns(thread.id);
       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" };
+    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.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)) : [])])];
+      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` };
+        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)) };
+      return {
+        pending: folders
+          .suggest(text, team)
+          .then(({ folder, by, lastWorked }) =>
+            placeOf(folder, team, by, lastWorked)
+          ),
+      };
     }
     // 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) };
+      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}"` };
+      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 };
+    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.rounds")
+      return {
+        ok: true,
+        rounds: store.rounds(
+          request.id ? String(request.id) : null,
+          request.limit
+        ),
+      };
     if (command === "board.swarm.coordinator") {
-      if (request.mode === "harness" || request.mode === "local") coordinator.setMode(request.mode);
+      if (request.mode === "harness" || request.mode === "local")
+        coordinator.setMode(request.mode);
       return { ok: true, mode: coordinator.mode() };
     }
     if (command === "board.swarm.stop_all") {
-      const stopped = store.goals().filter((thread) => thread.status === "open").map((thread) => { stopThreadRuns(thread.id); return thread.id; });
+      const stopped = store
+        .goals()
+        .filter((thread) => thread.status === "open")
+        .map((thread) => {
+          stopThreadRuns(thread.id);
+          return thread.id;
+        });
       return { ok: true, stopped };
     }
     if (command === "board.swarm.start") {
-      const text = String(request.text || "").trim().slice(0, 20_000);
+      const text = String(request.text || "")
+        .trim()
+        .slice(0, 20_000);
       if (!text) return { ok: false, error: "a thread starts with a message" };
-      const from = request.continueSession && typeof request.continueSession === "object" ? request.continueSession : null;
+      const from =
+        request.continueSession && typeof request.continueSession === "object"
+          ? request.continueSession
+          : null;
       let folder = request.folder ? String(request.folder) : null;
-      if (folder && !isDir(folder)) return { ok: false, error: `${folder} is not an absolute path to a folder` };
+      if (folder && !isDir(folder))
+        return {
+          ok: false,
+          error: `${folder} is not an absolute path to a folder`,
+        };
       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] : [])]);
+      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" };
+        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",
+          };
         const session = store.read({ agent: agentName, sessionId });
         if (!session) return { ok: false, error: "session not found" };
-        const already = store.threadForSession(agentName, nativeSessionId(agentName, sessionId));
+        const already = store.threadForSession(
+          agentName,
+          nativeSessionId(agentName, sessionId)
+        );
         if (already) return post(store.getTask(already), text);
-        if (sessionOpen(agentName, sessionId)) return { ok: false, error: "that session is still open in a terminal; it continues here once it is closed there" };
+        if (sessionOpen(agentName, sessionId))
+          return {
+            ok: false,
+            error:
+              "that session is still open in a terminal; it continues here once it is closed there",
+          };
         team.add(agentName);
         folder ??= isDir(session.cwd) ? session.cwd : null;
       }
       // 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 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) });
+        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)) };
+      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" };
-    if (command === "board.swarm.read") return read(thread);
-    if (command === "board.swarm.diff") return worktrees.diff(thread.id, request.runId ? String(request.runId) : null);
+    if (!thread || thread.kind !== "goal")
+      return { ok: false, error: "thread not found" };
+    if (command === "board.swarm.read")
+      return read(thread, request.hostedCaller === true);
+    if (command === "board.swarm.diff")
+      return worktrees.diff(
+        thread.id,
+        request.runId ? String(request.runId) : null
+      );
     if (command === "board.swarm.merge" || command === "board.swarm.discard") {
       // Both change the person's repository, so both wait for the person, and never while an agent is changing files.
-      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 done = command === "board.swarm.merge" ? worktrees.merge(thread.id, thread.objective) : worktrees.discard(thread.id);
-      if (done.ok) store.roomPost({ goalId: thread.id, author: "user", kind: "note", text: command === "board.swarm.merge" ? `Merged into ${done.into}.` : "Discarded this thread's changes." });
-      else if (done.conflict) store.roomPost({ goalId: thread.id, author: thread.goal.facilitator, kind: "question", text: `${done.error[0].toUpperCase()}${done.error.slice(1)}. Resolve it in your checkout, or ask an agent here to bring the thread's branch up to date first.` });
+      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 done =
+        command === "board.swarm.merge"
+          ? worktrees.merge(thread.id, thread.objective)
+          : worktrees.discard(thread.id);
+      if (done.ok)
+        store.roomPost({
+          goalId: thread.id,
+          author: "user",
+          kind: "note",
+          text:
+            command === "board.swarm.merge"
+              ? `Merged into ${done.into}.`
+              : "Discarded this thread's changes.",
+        });
+      else if (done.conflict)
+        store.roomPost({
+          goalId: thread.id,
+          author: thread.goal.facilitator,
+          kind: "question",
+          text: `${done.error[0].toUpperCase()}${done.error.slice(1)}. Resolve it in your checkout, or ask an agent here to bring the thread's branch up to date first.`,
+        });
       notifyBoard(store.getTask(thread.id));
-      return done.ok ? { ok: true, thread: summary(store.getTask(thread.id)) } : done;
+      return done.ok
+        ? { ok: true, thread: summary(store.getTask(thread.id)) }
+        : done;
     }
     // The person's Start for one run in the thread that waits for it.
     if (command === "board.swarm.start_run") {
-      const run = store.threadRuns(thread.id).find((candidate) => candidate.id === String(request.runId || ""));
-      if (!run || !awaitingStart(run)) return { ok: false, error: "that run is not waiting for a Start" };
+      const run = store
+        .threadRuns(thread.id)
+        .find((candidate) => candidate.id === String(request.runId || ""));
+      if (!run || !awaitingStart(run))
+        return { ok: false, error: "that run is not waiting for a Start" };
       const started = authorizeRun(run.id);
-      return started?.ok === false ? started : { ok: true, thread: summary(store.getTask(thread.id)) };
+      return started?.ok === false
+        ? started
+        : { ok: true, thread: summary(store.getTask(thread.id)) };
     }
     if (command === "board.swarm.post") {
-      const text = String(request.text || "").trim().slice(0, 20_000);
+      const text = String(request.text || "")
+        .trim()
+        .slice(0, 20_000);
       if (!text) return { ok: false, error: "a message needs text" };
       const to = recipient(request);
-      if (to === false) return { ok: false, error: `${request.to} can't be written to in a thread` };
+      if (to === false)
+        return {
+          ok: false,
+          error: `${request.to} can't be written to in a thread`,
+        };
       const posted = post(thread, text, to);
-      return posted.ok ? { ...posted, thread: summary(store.getTask(thread.id)) } : posted;
+      return posted.ok
+        ? { ...posted, thread: summary(store.getTask(thread.id)) }
+        : posted;
     }
     if (command === "board.swarm.stop") {
-      if (thread.status !== "open") return { ok: false, error: `the thread is ${thread.status}` };
+      if (thread.status !== "open")
+        return { ok: false, error: `the thread is ${thread.status}` };
       stopThreadRuns(thread.id);
       return { ok: true, thread: summary(store.getTask(thread.id)) };
     }
     if (command === "board.swarm.resume") {
-      if (thread.status !== "paused") return { ok: false, error: `the thread is ${thread.status}` };
+      if (thread.status !== "paused")
+        return { ok: false, error: `the thread is ${thread.status}` };
       store.setGoalState(thread.id, { status: "open" });
-      store.roomPost({ goalId: thread.id, author: "user", kind: "note", text: "Resumed by you." });
+      store.roomPost({
+        goalId: thread.id,
+        author: "user",
+        kind: "note",
+        text: "Resumed by you.",
+      });
       notifyBoard(store.getTask(thread.id));
       return { ok: true, thread: summary(store.getTask(thread.id)) };
     }
@@ -330,16 +789,38 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
     // 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 a folder on this computer` };
+      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" };
+      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}.` });
+      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)) };
     }