tryharness 0.7.7 → 0.7.9

package/assets/opencode-plugin.js

@@ -54,11 +54,22 @@ function notify(message) {
   } catch {}
 }
 
+// Where a session runs, as opencode's own environment says (Harness's places.mjs reads it): once per session.
+const PLACE_ENV = ["__CFBundleIdentifier", "TERM_PROGRAM", "TMUX", "TMUX_PANE", "WEZTERM_PANE", "KITTY_WINDOW_ID", "KITTY_LISTEN_ON", "WT_SESSION", "VSCODE_GIT_ASKPASS_NODE"];
+const placed = new Set();
+function notePlace(sessionId, directory) {
+  if (placed.has(sessionId)) return;
+  placed.add(sessionId);
+  const env = Object.fromEntries(PLACE_ENV.filter((name) => process.env[name]).map((name) => [name, process.env[name]]));
+  notify({ command: "board.live.place", agent: "opencode", sessionId, folder: directory, pids: [process.pid, process.ppid], env });
+}
+
 export const TryHarnessPlugin = async ({ directory }) => ({
   // Every message of a session carries the board nudge as an extra text part when the queue changed since the last one.
   "chat.message": async (input, output) => {
     const sessionId = input?.sessionID || input?.sessionId;
     if (!sessionId || !Array.isArray(output?.parts)) return;
+    notePlace(sessionId, directory);
     const nudge = await boardNudge(sessionId);
     if (nudge) output.parts.push({ type: "text", text: nudge });
   },

package/assets/pi-extension.ts

@@ -134,6 +134,14 @@ export default function tryHarness(pi) {
     ctx?.ui?.notify?.(nudge.split("\n").slice(0, 2).join(" "), "info");
   };
   pi.on("session_start", async (_event, ctx) => tell(await boardNudge(false), ctx));
+  // Where the session runs, as pi's own environment says (Harness's places.mjs reads it).
+  pi.on("session_start", (_event, ctx) => {
+    const sessionId = ctx?.sessionManager?.getSessionId?.();
+    if (!sessionId) return;
+    const names = ["__CFBundleIdentifier", "TERM_PROGRAM", "TMUX", "TMUX_PANE", "WEZTERM_PANE", "KITTY_WINDOW_ID", "KITTY_LISTEN_ON", "WT_SESSION", "VSCODE_GIT_ASKPASS_NODE"];
+    const env = Object.fromEntries(names.filter((name) => process.env[name]).map((name) => [name, process.env[name]]));
+    void daemon({ command: "board.live.place", agent: "pi", sessionId, folder: ctx?.cwd || process.cwd(), pids: [process.pid, process.ppid], env });
+  });
   // Into the model's own context: pi lets an extension return the system prompt it should use
   // (pi 0.87: before_agent_start -> { systemPrompt }). The queue is appended, never substituted.
   pi.on("before_agent_start", async (event) => {

package/cli.mjs

@@ -649,8 +649,33 @@ async function link({ quiet = false } = {}) {
   }
 }
 
+// Approving Harness in T3 Code (lib/t3.mjs): then what you send your T3 Code sessions from Harness, in the desktop app or
+// on your phone, goes straight into their threads. No T3 account; T3's page asks for a pairing code from its settings.
+const t3Words = (access) => !access ? "Harness is not approved in T3 Code. Messages to its sessions wait for them to pick them up (run: tryharness t3)."
+  : access.state === "send" ? `Harness sends your messages into T3 Code's threads, until ${access.until.slice(0, 10)}.`
+    : access.state === "read" ? "Harness was approved in T3 Code to read only, so messages still wait for its sessions to pick them up. Approve it again with the access your threads run with: tryharness t3"
+      : "Harness's approval in T3 Code ran out. Approve it again: tryharness t3";
+async function t3() {
+  const sub = argv[0] || "connect";
+  if (sub === "status") { console.log(t3Words((await daemonRequest({ command: "t3.status" })).t3)); return; }
+  if (sub === "forget") { await daemonRequest({ command: "t3.forget" }); console.log("Harness forgot its approval. To end it in T3 Code as well: Settings → Connections."); return; }
+  if (sub !== "connect") throw new Error("usage: tryharness t3 [connect [--print] | status | forget]");
+  const before = (await daemonRequest({ command: "t3.status" })).t3;
+  const started = await daemonRequest({ command: "t3.connect" }, 20_000);
+  if (!started.ok) throw new Error(started.error || "the daemon could not start the approval");
+  const opened = !has("--print") && openUrl(started.url);
+  console.log(opened ? "T3 Code's approval page is open in your browser." : `Open this in a browser on this computer:\n\n${started.url}\n`);
+  console.log("There, enter a pairing code from T3 Code (Settings → Connections), then choose what Harness may do. To message threads that run in Full access, choose Full access.");
+  console.log("Waiting for your approval (Ctrl-C stops waiting; an approval still counts).");
+  for (;;) {
+    await sleep(1_000);
+    const now = (await daemonRequest({ command: "t3.status" })).t3;
+    if (now && JSON.stringify(now) !== JSON.stringify(before)) { console.log(t3Words(now)); return; }
+  }
+}
+
 function help() {
-  console.log(`tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness desktop         open the Harness desktop app (setup opens it too; --no-desktop skips it)\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\n  tryharness sync [--agent]  rescan local coding history in the background\n  tryharness task <id> --follow\n                             follow a delegated agent run in this terminal\n  tryharness board [--all]   list open work on the machine's task board\n  tryharness board post --for <agent> --objective <text> [--file <brief.md>]\n  tryharness board show <id>\n  tryharness board post --for codex --objective <text> --run --workspace <dir>\n                             the daemon runs it and reports back on the task\n  tryharness board run <id>  authorize a run an agent asked for\n  tryharness board release <id>\n  tryharness board agents    when each agent last read the board\n  tryharness board --watch   follow the board in this terminal\n  tryharness notify on|off   desktop notifications for what waits on you\n  tryharness board send <task> <message>   send a held reply to another person's agent\n  tryharness board auto <task> on|off      auto-send replies on that thread\n  tryharness board end <task> --outcome <text>\n  tryharness board context <task> <query>  search everything written about a task\n  tryharness goal set --objective <text> [--team a,b] [--workspace <dir>]   a goal your agents work together in one room\n  tryharness goal [list | show <id> | stop <id> | resume <id>]\n  tryharness room <goal> | room post <goal> <text> [--ask agent,agent]\n  tryharness swarm rounds [<thread>]   what the coordinator saw, chose and cost each round\n  tryharness swarm coordinator [harness|local]   who coordinates your threads\n  tryharness connect <handle/agent> --about <text>   ask another person's agent to work an issue with yours, sealed to their computer\n  tryharness peers           the keys of other people's computers this one has worked with, to compare\n  tryharness agents          how Harness wakes each of your agents, and set up the rest\n  tryharness agents setup <agent> | agents test <agent>\n  tryharness mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness link            connect the browser you use Harness in to this computer, end to end (--print shows the link)\n  tryharness phone pair      show a QR code that pairs your phone with this computer\n  tryharness phone list | revoke <id>\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
+  console.log(`tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness desktop         open the Harness desktop app (setup opens it too; --no-desktop skips it)\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\n  tryharness sync [--agent]  rescan local coding history in the background\n  tryharness task <id> --follow\n                             follow a delegated agent run in this terminal\n  tryharness board [--all]   list open work on the machine's task board\n  tryharness board post --for <agent> --objective <text> [--file <brief.md>]\n  tryharness board show <id>\n  tryharness board post --for codex --objective <text> --run --workspace <dir>\n                             the daemon runs it and reports back on the task\n  tryharness board run <id>  authorize a run an agent asked for\n  tryharness board release <id>\n  tryharness board agents    when each agent last read the board\n  tryharness board --watch   follow the board in this terminal\n  tryharness notify on|off   desktop notifications for what waits on you\n  tryharness board send <task> <message>   send a held reply to another person's agent\n  tryharness board auto <task> on|off      auto-send replies on that thread\n  tryharness board end <task> --outcome <text>\n  tryharness board context <task> <query>  search everything written about a task\n  tryharness goal set --objective <text> [--team a,b] [--workspace <dir>]   a goal your agents work together in one room\n  tryharness goal [list | show <id> | stop <id> | resume <id>]\n  tryharness room <goal> | room post <goal> <text> [--ask agent,agent]\n  tryharness swarm rounds [<thread>]   what the coordinator saw, chose and cost each round\n  tryharness swarm coordinator [harness|local]   who coordinates your threads\n  tryharness connect <handle/agent> --about <text>   ask another person's agent to work an issue with yours, sealed to their computer\n  tryharness peers           the keys of other people's computers this one has worked with, to compare\n  tryharness agents          how Harness wakes each of your agents, and set up the rest\n  tryharness agents setup <agent> | agents test <agent>\n  tryharness mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness link            connect the browser you use Harness in to this computer, end to end (--print shows the link)\n  tryharness phone pair      show a QR code that pairs your phone with this computer\n  tryharness phone list | revoke <id>\n  tryharness t3              approve Harness in T3 Code once, so your messages go into its threads (t3 status | t3 forget)\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
 }
 
 try {
@@ -668,6 +693,7 @@ try {
   else if (command === "phone") await phone();
   else if (command === "agents") await agents();
   else if (command === "link") await link();
+  else if (command === "t3") await t3();
   else if (command === "peers") await peers();
   else if (command === "connect") await connectAgent();
   else if (command === "desktop") { if (!desktop()) process.exitCode = 1; }

package/lib/adapters.mjs

@@ -60,11 +60,14 @@ export function installClaudeSessionHook({ runtimeRoot, homeDir = os.homedir(),
   // Mid-session: on every prompt, one line only when the queue changed since the session last saw it.
   const prompts = (Array.isArray(hooks.UserPromptSubmit) ? hooks.UserPromptSubmit : []).filter((entry) => !isHarnessHook(entry));
   prompts.push({ hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent claude-code --if-changed`, timeout: 10 }] });
+  // When a turn ends: a message the person sent this session from Harness keeps it going.
+  const stops = (Array.isArray(hooks.Stop) ? hooks.Stop : []).filter((entry) => !isHarnessHook(entry));
+  stops.push({ hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent claude-code --stop`, timeout: 10 }] });
   ensureDir(path.dirname(file));
-  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: starts, UserPromptSubmit: prompts } }, null, 2) + "\n");
+  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: starts, UserPromptSubmit: prompts, Stop: stops } }, null, 2) + "\n");
 }
 
-// Codex reads the same hook shape from ~/.codex/hooks.json (SessionStart and UserPromptSubmit,
+// Codex reads the same hook shape from ~/.codex/hooks.json (SessionStart, UserPromptSubmit and Stop,
 // stdout added as developer context). Codex asks the person to trust a new or changed hook once,
 // with /hooks in its TUI, before it runs; setup says so.
 export function codexHooksPath(homeDir = os.homedir()) {
@@ -80,8 +83,10 @@ export function installCodexHooks({ runtimeRoot, homeDir = os.homedir(), nodePat
   starts.push({ matcher: "startup|resume", hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent codex`, statusMessage: "Reading the Harness board", timeout: 10 }] });
   const prompts = (Array.isArray(hooks.UserPromptSubmit) ? hooks.UserPromptSubmit : []).filter((entry) => !isHarnessHook(entry));
   prompts.push({ hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent codex --if-changed`, timeout: 10 }] });
+  const stops = (Array.isArray(hooks.Stop) ? hooks.Stop : []).filter((entry) => !isHarnessHook(entry));
+  stops.push({ hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent codex --stop`, timeout: 10 }] });
   ensureDir(path.dirname(file));
-  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: starts, UserPromptSubmit: prompts } }, null, 2) + "\n");
+  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: starts, UserPromptSubmit: prompts, Stop: stops } }, null, 2) + "\n");
 }
 
 export function removeCodexHooks(homeDir = os.homedir()) {
@@ -89,7 +94,7 @@ export function removeCodexHooks(homeDir = os.homedir()) {
   const settings = readJson(file, null);
   if (!settings?.hooks) return;
   const hooks = { ...settings.hooks };
-  for (const event of ["SessionStart", "UserPromptSubmit"]) {
+  for (const event of ["SessionStart", "UserPromptSubmit", "Stop"]) {
     if (Array.isArray(hooks[event])) hooks[event] = hooks[event].filter((entry) => !isHarnessHook(entry));
   }
   fs.writeFileSync(file, JSON.stringify({ ...settings, hooks }, null, 2) + "\n");
@@ -100,7 +105,7 @@ export function removeClaudeSessionHook(homeDir = os.homedir()) {
   const settings = readJson(file, null);
   if (!settings?.hooks) return;
   const hooks = { ...settings.hooks };
-  for (const event of ["SessionStart", "UserPromptSubmit"]) {
+  for (const event of ["SessionStart", "UserPromptSubmit", "Stop"]) {
     if (Array.isArray(hooks[event])) hooks[event] = hooks[event].filter((entry) => !isHarnessHook(entry));
   }
   fs.writeFileSync(file, JSON.stringify({ ...settings, hooks }, null, 2) + "\n");

package/lib/daemon.mjs

@@ -13,7 +13,7 @@ import { parseSessionFile } from "./parsers.mjs";
 import { historyRoots, paths } from "./paths.mjs";
 import { openStore } from "./store.mjs";
 import { readRunSteps, runAgentTask, runningPids, stopAgentTask } from "./runner.mjs";
-import { createSwarm } from "./swarm.mjs";
+import { createSwarm, nativeSessionId } from "./swarm.mjs";
 import { createCoordinator } from "./coordinator.mjs";
 import { createWorktrees } from "./worktrees.mjs";
 import { notificationFor, notifyDesktop } from "./notify.mjs";
@@ -27,6 +27,10 @@ import { ASKED_BY_TASK, CLOUD_HOMED, MACHINE_RUNNERS, TARGETS, aboutOf, member,
 import { fingerprint, openBound, relayKey, sealBound } from "./sealed.mjs";
 import { claudeMemNotes } from "./claudemem.mjs";
 import { machineActivity } from "./activity.mjs";
+import { LIVE_AGENTS, focusTerminal, hostApp, liveSessions, processTable, sessionFeed, sessionFile, sessionOfProcess, workingDirectories } from "./live.mjs";
+import { EDITOR_IDS, agentCommand, editorFolder, editorInstall, editorName, editorTerminalStarts, openEditorFolder, panelLink, placeEnv, placeFrom, placeKey, processEnv, resumeLine, t3App, t3Link, t3OpensLinks, t3Runs, t3Thread } from "./places.mjs";
+import { detectMcpClients } from "./adapters.mjs";
+import { forgetT3, sendToT3, startT3SignIn, t3Access } from "./t3.mjs";
 
 // What may be referenced on a thread with another person (the server's rule, src/server/relay/refs.ts, kept
 // here since a sealed request is opened only on the machines).
@@ -775,6 +779,276 @@ export async function startDaemon() {
     authorizeRun: (id) => boardCommand({ command: "board.run", agent: "user", id }),
   });
 
+  // The person's own sessions running now (live.mjs), and what they sent one from Harness: it waits here until that
+  // session's hook takes it (nudge.mjs), when the agent stops or the person next types there.
+  const saidKey = (agent, sessionId) => `said:${agent}:${sessionId}`;
+  const said = (agent, sessionId) => { try { return JSON.parse(store.meta(saidKey(agent, sessionId)) || "[]"); } catch { return []; } };
+  const CODING_AGENTS = ["claude-code", "codex", "pi", "opencode"];
+  const SESSION_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+  const folderOf = (request) => (typeof request.folder === "string" && path.isAbsolute(request.folder) ? request.folder : null);
+
+  // Where each of the person's sessions runs (places.mjs), recorded when it starts: its hook, plugin or extension sends
+  // its environment (board.live.place), else it is read here from the running process. Thirty days of them, per agent.
+  const PLACE_MS = 30 * 24 * 3600_000;
+  const placeCache = new Map();
+  const placesOf = (agentId) => {
+    if (!placeCache.has(agentId)) {
+      let found = {};
+      try { found = JSON.parse(store.meta(`places:${agentId}`) || "{}"); } catch {}
+      placeCache.set(agentId, found);
+    }
+    return placeCache.get(agentId);
+  };
+  const placedAgents = () => { try { return JSON.parse(store.meta("places:agents") || "[]"); } catch { return []; } };
+  const notePlace = (agentId, sessionId, place) => {
+    if (!place || !SESSION_ID.test(sessionId)) return;
+    const places = placesOf(agentId);
+    const now = Date.now();
+    const before = places[sessionId];
+    const next = { ...place, at: before?.at ?? now, seen: now };
+    // The same place, already seen today: nothing worth a write.
+    if (before && JSON.stringify({ ...before, seen: 0 }) === JSON.stringify({ ...next, seen: 0 }) && now - before.seen < 24 * 3600_000) return;
+    const kept = Object.fromEntries(Object.entries({ ...places, [sessionId]: next }).filter(([, entry]) => now - (entry.seen || 0) < PLACE_MS)
+      .sort((a, b) => b[1].seen - a[1].seen).slice(0, 400));
+    placeCache.set(agentId, kept);
+    store.meta(`places:${agentId}`, JSON.stringify(kept));
+    if (!placedAgents().includes(agentId)) store.meta("places:agents", JSON.stringify([...placedAgents(), agentId].slice(-50)));
+  };
+  /** A run Harness started itself (in its own folders, or a process it runs) is not where the person works. */
+  const harnessRun = (folder, pids = []) => Boolean(folder && folder.startsWith(paths.home + path.sep)) || pids.some((pid) => runningPids().includes(pid));
+  // A session says where it runs: its environment, and the agent's process (the hook's parent), read here for the app up
+  // its process tree and its terminal. Codex's terminals share one background server, started from wherever Codex first
+  // ran: a session there has no app or terminal of its own, and is placed by the Codex terminal working in its folder.
+  const placeOfReport = (agentId, folder, request) => {
+    const table = processTable();
+    const pids = (Array.isArray(request.pids) ? request.pids : []).filter((pid) => Number.isInteger(pid) && pid > 1 && table.has(pid)).slice(0, 2);
+    if (harnessRun(folder, pids)) return null;
+    let env = placeEnv(request.env);
+    let host = pids.map((pid) => hostApp(table, pid)).find(Boolean) ?? null;
+    let tty = pids.map((pid) => table.get(pid)?.tty).find(Boolean) ?? null;
+    if (agentId === "codex" && pids.length && !host && !tty) {
+      const clients = [...table].filter(([, row]) => path.basename(row.comm) === "codex" && row.tty).map(([pid]) => pid);
+      const cwds = workingDirectories(clients);
+      const client = clients.filter((pid) => folder && cwds.get(pid) === folder).sort((a, b) => b - a)[0];
+      if (!client) return null;
+      env = processEnv(client);
+      host = hostApp(table, client);
+      tty = table.get(client).tty;
+    }
+    return placeFrom({ env, host, tty, folder });
+  };
+  // A custom harness may say how one of its sessions opens again: a page it serves on this computer, or a command to type.
+  const reopenOf = (value) => {
+    if (!value || typeof value !== "object") return null;
+    const link = typeof value.link === "string" && value.link.length <= 2048 && /^http:\/\/(127\.0\.0\.1|localhost)(:\d{1,5})?\/\S*$/.test(value.link) ? value.link : null;
+    const command = typeof value.command === "string" && value.command.trim() && value.command.length <= 500 && !/[\0-\x1f]/.test(value.command) ? value.command.trim() : null;
+    return link || command ? { link, command } : null;
+  };
+
+  const liveNow = () => {
+    const recent = store.recentSessions(200);
+    // With the title the index gives it (its first request), when the index has it yet.
+    const titleOf = (session) => {
+      const title = recent.find((row) => row.agent === session.agent && String(row.session_id).includes(session.sessionId))?.title || null;
+      // A session opened with a slash command starts with the agent's own markup, not the person's words.
+      return title && !title.startsWith("<") ? title : null;
+    };
+    const linksOk = t3LinksOk();
+    const sessions = liveSessions({ exclude: new Set(runningPids()), recent })
+      // A T3 Code that cannot open links is brought forward instead, and messages reach its sessions through their hooks.
+      .map((session) => ({ ...session, t3: linksOk ? session.t3 : null, title: titleOf(session), waiting: said(session.agent, session.sessionId).length }));
+    // A running session no hook placed (it started before Harness was set up, or its agent has none): read from its process.
+    for (const session of sessions) {
+      if (placesOf(session.agent)[session.sessionId]) continue;
+      const env = { ...processEnv(session.pid), ...(session.entrypoint ? { CLAUDE_CODE_ENTRYPOINT: session.entrypoint } : {}) };
+      notePlace(session.agent, session.sessionId, placeFrom({ env, host: session.host, tty: session.tty, folder: session.folder }));
+    }
+    return sessions;
+  };
+
+  // An agent's home: the place most of its sessions started in over the last thirty days (ties: the latest), where its
+  // sessions open when they are not running.
+  let seeded = { at: 0, homes: {} };
+  /** Before any session was recorded: what this computer already shows, threads run in T3 Code and the agent started in an editor's terminal. */
+  const seedHome = (agentId) => {
+    if (Date.now() - seeded.at > 10 * 60_000) seeded = { at: Date.now(), homes: {} };
+    if (agentId in seeded.homes) return seeded.homes[agentId];
+    const command = agentCommand(agentId);
+    const seeds = [{ count: t3App() ? t3Runs(agentId, new Date(Date.now() - PLACE_MS).toISOString()) : 0, place: { kind: "t3", name: "T3 Code" } },
+      ...(command ? EDITOR_IDS.map((id) => ({ count: editorTerminalStarts(id, command), place: { kind: "editor", editor: id, name: editorName(id), surface: "terminal" } })) : [])];
+    return (seeded.homes[agentId] = seeds.filter((seed) => seed.count > 0).sort((a, b) => b.count - a.count)[0]?.place ?? null);
+  };
+  /** A place with the app that opens it now (T3's running build, an editor's install); null when it is not on this computer. */
+  const usable = (place) => {
+    if (!place) return null;
+    if (place.kind === "t3") { const t3 = t3App(); return t3 ? { ...place, app: t3.app } : null; }
+    if (place.kind === "editor" && !(place.cli && fs.existsSync(place.cli))) {
+      const install = editorInstall(place.editor, place.app || "");
+      return install ? { ...place, ...install } : place.app ? place : null;
+    }
+    return place;
+  };
+  const homeOf = (agentId) => {
+    const tally = new Map();
+    for (const place of Object.values(placesOf(agentId))) {
+      if (!place?.kind || place.kind === "unknown") continue;
+      const entry = tally.get(placeKey(place)) ?? { place, count: 0 };
+      entry.count += 1;
+      if ((place.seen || 0) >= (entry.place.seen || 0)) entry.place = place;
+      tally.set(placeKey(place), entry);
+    }
+    const best = [...tally.values()].sort((a, b) => b.count - a.count || (b.place.seen || 0) - (a.place.seen || 0))[0]?.place;
+    return usable(best ?? seedHome(agentId));
+  };
+  /** Where each agent lives, for Open's labels: coding agents' homes, and Grok Bot's own app. */
+  const homes = () => {
+    const found = {};
+    for (const id of new Set([...CODING_AGENTS, ...placedAgents()])) {
+      const home = homeOf(id);
+      if (home) found[id] = { name: home.name, app: home.app ?? null, kind: home.kind };
+    }
+    const grok = detectMcpClients().find((client) => client.client === "grok-bot" && client.path);
+    if (grok) found["grok-bot"] = { name: "Grok Bot", app: grok.path, kind: "app" };
+    return found;
+  };
+  const t3LinksOk = () => { const t3 = t3App(); return Boolean(t3 && t3OpensLinks(t3.app)); };
+  const T3_OLD = "This T3 Code can't be opened at a thread from another app, so it is in front as it is. T3's nightly builds open the exact thread.";
+  /** The person's own sessions, not the runs Harness starts in its own folders (their worktrees are not the person's). */
+  const ownSession = (row) => !String(row.cwd || "").startsWith(paths.home + path.sep);
+  const short = (name) => String(name || "").replace(/ \(.*\)$/, "");
+
+  /** How a session opens in one place (or the agent itself, with no session); null when that place cannot show it. */
+  const placePlan = (agentId, place, sessionId, folder, act) => {
+    if (!place) return null;
+    const name = short(place.name);
+    if (place.kind === "t3") {
+      if (!place.app) return null;
+      const thread = sessionId ? t3Thread(sessionId) : null;
+      if (thread && t3OpensLinks(place.app)) return { opensIn: "T3 Code", link: t3Link(thread) };
+      if (thread || !sessionId) return { opensIn: "T3 Code", app: place.app, ...(thread ? { note: T3_OLD } : {}) };
+      // A session T3 never had (a run Harness started in its own folder, say): T3 comes forward as it is, saying so,
+      // and the session can still be resumed in a terminal instead.
+      return { opensIn: "T3 Code", app: place.app, resumable: true, note: harnessRun(folder)
+        ? "This run happened in Harness's own copy of the repo, which T3 Code doesn't list, so T3 Code is in front as it is."
+        : "T3 Code doesn't list this session, so it is in front as it is." };
+    }
+    if (place.kind === "editor") {
+      // Its window first (the folder the editor has open around the session's), so a panel link lands there.
+      const window = editorFolder(place.editor, folder);
+      if (act && window) openEditorFolder(place, window);
+      const link = sessionId ? panelLink(agentId, place.editor, sessionId) : null;
+      if (link) return { opensIn: name, link };
+      if (!place.app) return null;
+      // An editor's terminal takes no command from another app: the session's own command is copied to paste there.
+      const line = sessionId ? resumeLine(agentId, sessionId, folder) : null;
+      return { opensIn: name, app: place.app, ...(line ? { copy: line, note: `${name} is up${window ? ` on ${path.basename(window)}` : ""}. The command that resumes this session is copied: paste it in a terminal there.` } : {}) };
+    }
+    if (place.kind === "codex-app") return agentId === "codex" && sessionId ? { opensIn: "Codex", link: `codex://threads/${sessionId}` } : place.app ? { opensIn: "Codex", app: place.app } : null;
+    if (place.kind === "terminal") return CODING_AGENTS.includes(agentId) ? { opensIn: name, resume: { agent: agentId, session: sessionId ?? null, cwd: folder ?? null, app: place.app ?? null } } : null;
+    return place.app ? { opensIn: name, app: place.app } : null;
+  };
+  /** A running session, where it runs: its T3 thread, its panel, its editor's window, its terminal pane and tab. */
+  const runningPlan = (live, act) => {
+    const place = placesOf(live.agent)[live.sessionId] ?? null;
+    if ((live.host && /^T3 Code\b/.test(live.host.name)) || place?.kind === "t3") {
+      if (live.t3) return { opensIn: "T3 Code", link: live.t3 };
+      return { opensIn: "T3 Code", app: live.host?.app ?? t3App()?.app ?? null, tty: null, ...(t3Thread(live.sessionId) ? { note: T3_OLD } : {}) };
+    }
+    if (place?.kind === "editor") {
+      const link = place.surface === "panel" ? panelLink(live.agent, place.editor, live.sessionId) : null;
+      if (link) return { opensIn: short(place.name), link };
+      // A session in the editor's terminal: its window. Which terminal tab shows, only the editor itself can pick.
+      if (act) openEditorFolder(usable(place), editorFolder(place.editor, live.folder));
+      return { opensIn: short(place.name), app: place.app ?? live.host?.app ?? null };
+    }
+    if (place?.kind === "codex-app" && live.agent === "codex") return { opensIn: "Codex", link: `codex://threads/${live.sessionId}` };
+    const opensIn = live.host ? short(live.host.name) : null;
+    return { opensIn, ...(act ? focusTerminal(live, place) : live.host ? { app: live.host.app, tty: live.tty } : {}) };
+  };
+  /**
+   * How a session opens, or the agent itself with no session: what the app does next (views/ui.ts openPlace). A running
+   * session opens where it runs; one that ended opens in the agent's home, else where it ran, else a terminal resumes
+   * it. `act`: the daemon's part happens now (a pane selected, an editor's window brought up); without it, this is only
+   * where it would open, for Open's label.
+   */
+  const openPlan = (agentId, sessionId, folder, act) => {
+    const live = sessionId ? liveNow().find((row) => row.agent === agentId && row.sessionId === sessionId) ?? null : null;
+    if (live) return runningPlan(live, act);
+    const own = sessionId ? placesOf(agentId)[sessionId] ?? null : null;
+    const where = folder ?? own?.folder ?? null;
+    if (own?.reopen?.link) return { opensIn: short(own.name) || nameOf(agentId), link: own.reopen.link };
+    const plan = placePlan(agentId, homeOf(agentId), sessionId, where, act) ?? placePlan(agentId, usable(own), sessionId, where, act);
+    if (plan) return plan;
+    if (CODING_AGENTS.includes(agentId)) return { opensIn: "Terminal", resume: { agent: agentId, session: sessionId, cwd: where, app: null } };
+    const command = own?.reopen?.command;
+    return command ? { opensIn: null, copy: command, note: "The command that opens this session again is copied: paste it in a terminal." } : { opensIn: null };
+  };
+
+  const liveCommand = (request, agent) => {
+    const sessionId = String(request.sessionId || "");
+    if (request.command === "board.live.take") {
+      if (!LIVE_AGENTS.includes(agent) || !sessionId) return { ok: false, error: "only a session's own agent takes its messages" };
+      const messages = said(agent, sessionId);
+      if (messages.length) store.meta(saidKey(agent, sessionId), "[]");
+      return { ok: true, messages };
+    }
+    // A session says where it runs (its hook, plugin or extension, or a custom harness, as it starts).
+    if (request.command === "board.live.place") {
+      if (agent === "user") return { ok: false, error: "a session reports its own place" };
+      if (!SESSION_ID.test(sessionId)) return { ok: false, error: "a place needs the session's id" };
+      const folder = folderOf(request);
+      const place = placeOfReport(agent, folder, request);
+      const reopen = reopenOf(request.reopen);
+      if (place || (reopen && !harnessRun(folder))) notePlace(agent, sessionId, { ...(place ?? { kind: "unknown", name: nameOf(agent), folder }), ...(reopen ? { reopen } : {}) });
+      return { ok: true };
+    }
+    if (agent !== "user") return { ok: false, error: "only the person reads or messages their sessions" };
+    if (request.command === "board.live") {
+      // Each coding agent's newest session too, so one not running now still opens where it last worked.
+      const last = {};
+      for (const row of store.recentSessions(200)) {
+        if (!LIVE_AGENTS.includes(row.agent) || last[row.agent] || !ownSession(row)) continue;
+        last[row.agent] = { sessionId: nativeSessionId(row.agent, row.session_id), folder: row.cwd || null };
+      }
+      return { ok: true, sessions: liveNow(), last, homes: homes(), t3: t3Access() };
+    }
+    // A session's latest messages and steps, from its own file (running or not).
+    if (request.command === "board.live.read") {
+      const agentId = String(request.to || "");
+      if (!LIVE_AGENTS.includes(agentId) && agentId !== "pi") return { ok: false, error: "only a coding agent's session can be read here" };
+      const file = sessionFile(agentId, sessionId, folderOf(request), store.recentSessions(200));
+      if (!file) return { ok: true, items: [] };
+      return { ok: true, items: sessionFeed(agentId, file, Math.min(200, Number(request.limit) || 80)) };
+    }
+    // Where a session (or, with none, the agent) opens, for Open's label: nothing happens yet.
+    if (request.command === "board.live.where" || request.command === "board.live.focus") {
+      const agentId = String(request.to || "");
+      if (!validAgent(agentId) || (sessionId && !SESSION_ID.test(sessionId))) return { ok: false, error: "that session can't be opened" };
+      // Open itself: the daemon's part happens now, and the app does the rest.
+      return { ok: true, ...openPlan(agentId, sessionId || null, folderOf(request), request.command === "board.live.focus") };
+    }
+    if (request.command === "board.live.say") {
+      const text = String(request.text || "").trim().slice(0, 20_000);
+      if (!text) return { ok: false, error: "a message needs text" };
+      const session = liveNow().find((row) => row.agent === request.to && row.sessionId === sessionId);
+      if (!session) return { ok: false, error: "that session is not running any more" };
+      // Kept until the session's own hook takes it: when its turn ends, or the person next types there.
+      const keep = (t3) => {
+        const messages = [...said(session.agent, sessionId), { text, at: new Date().toISOString() }];
+        store.meta(saidKey(session.agent, sessionId), JSON.stringify(messages));
+        return { ok: true, sent: "hooks", session: { ...session, waiting: messages.length }, ...(t3 ? { t3 } : {}) };
+      };
+      // A session in T3 Code, once the person approved Harness there: into its T3 thread, as T3 sends any message.
+      const thread = session.host && /^T3 Code\b/.test(session.host.name) ? t3Thread(sessionId) : null;
+      if (!thread) return keep(null);
+      const access = t3Access();
+      if (access?.state !== "send") return keep(!access ? "not_connected" : access.state === "read" ? "read_only" : access.state);
+      return { pending: sendToT3(thread, text).then((delivery) => ({ ok: true, sent: "t3", delivery, session }),
+        (error) => { log(`T3 Code did not take a message: ${error.message}`); return keep(error.code || "failed"); }) };
+    }
+    return { ok: false, error: `unknown command ${request.command}` };
+  };
+
   // Lid-Closed Mode's Standby: when anything last came in (a phone message, a wake, a new task).
   let listenerAt = Date.now();
   const touchListener = () => { listenerAt = Date.now(); };
@@ -791,8 +1065,11 @@ export async function startDaemon() {
     if (String(request.command).startsWith("board.swarm.")) return swarmCommand(request, agent);
     if (request.command === "board.prompted") {
       for (const pid of Array.isArray(request.pids) ? request.pids.slice(0, 2) : []) if (Number.isInteger(pid) && pid > 1) promptedBy.set(pid, agent);
+      // A session that started before its hook said where it runs says so on its next prompt.
+      if (request.sessionId && !placesOf(agent)[String(request.sessionId)]) liveCommand({ ...request, command: "board.live.place" }, agent);
       return { ok: true };
     }
+    if (String(request.command).startsWith("board.live")) return liveCommand(request, agent);
     if (request.command === "board.post" && request.thread && typeof request.thread === "object" && !request.thread[OPENED]
       && (request.thread.sealed || (request.thread.role === "asker" && store.meta(`relay_pending:${String(request.id || "")}`)))) {
       return { pending: openThreadPost(request).then((prepared) => {
@@ -966,7 +1243,13 @@ export async function startDaemon() {
     }
     else if (request.command === "board.agents") return { ok: true, agents: store.agentsSeen(), running: [...activeRuns.values()].map(({ agent: runAgent, id: taskId }) => ({ agent: runAgent, id: taskId })) };
     else if (["board.claim", "board.report", "board.answer", "board.release"].includes(request.command) && !store.getTask(id) && state.connected) return forwardToHarness(request);
-    else if (request.command === "board.claim") outcome = store.claimTask(id, agent, expected, Number.isInteger(request.leaseMinutes) ? request.leaseMinutes : 60);
+    else if (request.command === "board.claim") {
+      outcome = store.claimTask(id, agent, expected, Number.isInteger(request.leaseMinutes) ? request.leaseMinutes : 60);
+      // The person's own session that took it, so the task opens there (its MCP server is a child of that session).
+      const claimed = outcome?.ok ? store.getTask(id) : null;
+      const session = claimed && !claimed.session_id && LIVE_AGENTS.includes(agent) ? sessionOfProcess(agent, request.claimerPid, store.recentSessions(200)) : null;
+      if (session) { store.setRunSession(id, session); outcome = { ...outcome, task: store.getTask(id) }; }
+    }
     else if (request.command === "board.report") outcome = store.reportTask(id, agent, { status: String(request.status || ""), result: String(request.result || "").slice(0, 200_000) }, expected);
     else if (request.command === "board.answer") outcome = store.answerTask(id, agent, String(request.answer || "").slice(0, 20_000), expected);
     else if (request.command === "board.release") outcome = store.releaseTask(id, agent, expected);
@@ -1307,6 +1590,10 @@ export async function startDaemon() {
       else if (request.command === "phone.list") reply({ ok: true, phones: phones.list() });
       else if (request.command === "phone.revoke") reply(phones.revoke(request.id));
       else if (request.command === "wake.local") reply({ ok: true, agents: localWaker.status() });
+      // Approving Harness in T3 Code: the page to approve it on, for the desktop app or the CLI to open.
+      else if (request.command === "t3.connect") startT3SignIn().then((started) => reply({ ok: true, ...started }), (error) => reply({ ok: false, error: error.message }));
+      else if (request.command === "t3.status") reply({ ok: true, t3: t3Access() });
+      else if (request.command === "t3.forget") { forgetT3(); reply({ ok: true }); }
       // How Harness wakes the agents it keeps on the server (Grok Bot): read and saved there, never here.
       else if (request.command === "wake.server") askHarness("wake", request.input || {}).then(reply, (error) => reply({ ok: false, error: error.message }));
       // Whether agent work is going on here, for the desktop app deciding when the Mac may sleep.