tryharness 0.7.10 → 0.7.16

package/cli.mjs

@@ -5,7 +5,9 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { configureAgents, AGENTS, MCP_CLIENTS, detectMcpClients, mcpClientSnippet, removeAgentConfigurations } from "./lib/adapters.mjs";
-import { setupSwarm, testAgent } from "./lib/onboard.mjs";
+import { banner, setupSwarm, testAgent } from "./lib/onboard.mjs";
+import { createUi } from "./lib/ui.mjs";
+import pc from "picocolors";
 import { removeLocalWakes } from "./lib/wakes.mjs";
 import { detectAgents } from "./lib/commands.mjs";
 import { daemonRequest } from "./lib/control-client.mjs";
@@ -14,7 +16,7 @@ import { paths } from "./lib/paths.mjs";
 import { currentRuntime, installRuntime } from "./lib/runtime-install.mjs";
 import { ensureModel, modelPresent } from "./lib/embedder.mjs";
 import { installService, serviceInfo, uninstallService } from "./lib/service.mjs";
-import { canShowDesktop, desktopSource, desktopTarget, installDesktop, openDesktop, retireDesktop } from "./lib/desktop.mjs";
+import { canShowDesktop, openDesktop, retireDesktop, setupDesktop } from "./lib/desktop.mjs";
 
 const SOURCE_ROOT = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE = readJson(path.join(SOURCE_ROOT, "package.json"), { version: "0.4.3" });
@@ -66,7 +68,7 @@ async function validateConnection(config) {
   } catch { return false; }
 }
 
-async function pair(pairOrigin, agents) {
+async function pair(pairOrigin, agents, ui) {
   const response = await fetch(pairOrigin + "/api/pair/start", {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -75,9 +77,9 @@ async function pair(pairOrigin, agents) {
   });
   if (!response.ok) throw new Error(`pairing unavailable (HTTP ${response.status})`);
   const { pairId, code } = await response.json();
-  console.log(`\n  Your code:  ${code}\n`);
-  console.log("In Harness: Settings -> Connections -> Connect a machine -> enter the code.");
-  console.log("Waiting for approval (expires in 10 minutes)...");
+  ui.note(`${pc.bold(code)}\n\n${pc.dim("In Harness: Settings → Connections → Connect a machine, then enter this code.")}`, "Pair this computer");
+  const spin = ui.spinner();
+  spin.start("Waiting for your approval (the code works for 10 minutes)");
   return new Promise((resolve, reject) => {
     fetch(pairOrigin + "/api/pair/wait/" + pairId, { headers: { accept: "text/event-stream" } }).then(async (waitResponse) => {
       if (!waitResponse.ok || !waitResponse.body) throw new Error("pairing stream failed");
@@ -100,7 +102,7 @@ async function pair(pairOrigin, agents) {
       }
       reject(new Error("pairing stream ended without approval"));
     }).catch(reject);
-  });
+  }).then((token) => { spin.stop("Paired with Harness"); return token; }, (error) => { spin.stop("Pairing did not finish", 2); throw error; });
 }
 
 async function waitForDaemon(timeoutMs = 12_000) {
@@ -126,72 +128,81 @@ async function connect() {
   const requested = argv.flatMap((value, index) => value === "--agent" && argv[index + 1] ? [argv[index + 1]] : []);
   for (const agent of requested) if (!AGENTS.includes(agent)) throw new Error(`unknown agent '${agent}'`);
   const selected = requested.length ? installed.filter((agent) => requested.includes(agent)) : installed;
-  console.log(`Harness setup ${VERSION}`);
-  console.log("detected: " + (installed.join(", ") || "no supported coding agents"));
+  const ui = createUi();
+  console.log(`\n${banner(VERSION)}\n`);
+  ui.intro(`${pc.bgCyan(pc.black(" tryharness "))}  Setting up Harness on this computer`);
+  ui.step(installed.length ? `Found ${installed.join(", ")}` : "No supported coding agents found");
 
   const pairOrigin = origin();
   let config = readJson(paths.config, {});
   const reusable = !has("--reconnect") && config.origin === pairOrigin && await validateConnection(config);
-  if (reusable) console.log("pairing: already connected");
+  if (reusable) ui.success(`Connected to Harness ${pc.dim(`· ${new URL(pairOrigin).host}`)}`);
   else {
-    const token = await pair(pairOrigin, selected);
+    const token = await pair(pairOrigin, selected, ui);
     config = { ...config, origin: pairOrigin, token };
     writeJsonAtomic(paths.config, config);
-    console.log("pairing: approved");
   }
 
   // The persistent runtime is version-pinned; neither MCP clients nor the login service
   // point into npm's temporary npx cache.
+  const spin = ui.spinner();
+  spin.start("Installing the Harness runtime and connecting your agents");
   const runtimeRoot = installRuntime({ sourceRoot: SOURCE_ROOT, version: VERSION });
   const states = configureAgents({ runtimeRoot, selected });
   const stateMap = Object.fromEntries(states.map((state) => [state.agent, state]));
   config = { ...readJson(paths.config, config), version: VERSION, runtimeRoot, agentStates: stateMap };
   writeJsonAtomic(paths.config, config);
   const service = installService({ runtimeRoot });
-  const ready = await waitForDaemon();
-  console.log(`daemon: ready via ${service.manager} and connected to Harness`);
-  await setupSwarm({ runtimeRoot, states, daemonRequest });
+  spin.message("Starting the daemon");
+  try { await waitForDaemon(); } catch (error) { spin.stop("The daemon did not connect to Harness", 2); throw error; }
+  spin.stop(`Daemon running ${pc.dim(`· ${service.manager}, connected to Harness`)}`);
+  await setupSwarm({ runtimeRoot, states, daemonRequest, ui });
   try {
     const devices = await daemonRequest({ command: "phone.list" });
     if (devices.ok && !devices.phones.some((device) => device.kind === "browser" && !device.revoked_at)) {
-      console.log("browser: connecting it to this computer end to end");
-      await link({ quiet: true });
-    } else if (devices.ok) console.log("browser: connected end to end");
+      const offer = await browserLink();
+      ui.info(offer.opened ? "Opened Harness in your browser to connect it to this computer end to end. The link works once, for 10 minutes."
+        : `Open this in the browser you use Harness in. It works once, for 10 minutes, and is the pairing secret:\n${offer.url}`);
+    } else if (devices.ok) ui.success("Browser connected end to end");
   } catch (error) {
-    console.log(`browser: not connected (${error.message}); run npx tryharness link`);
+    ui.warn(`Browser not connected (${error.message}). Run: npx tryharness link`);
+  }
+  if (!has("--no-desktop")) {
+    const spin = ui.spinner();
+    spin.start("Getting the newest desktop app");
+    const shown = await desktop();
+    spin.stop(shown.text, shown.ok ? 0 : 2);
   }
-  if (!has("--no-desktop")) desktop();
   // The context space's embedder lives with the daemon and comes down with setup, so the machine
   // can search a task by meaning before the first task exists. About 110 MB, once.
-  try {
-    if (modelPresent(paths.models)) console.log("embedder: ready");
-    else { console.log("embedder: downloading (about 110 MB, once)"); await ensureModel({ modelsDir: paths.models, log: (line) => console.log(`  ${line}`) }); console.log("embedder: ready"); }
-  } catch (error) {
-    console.log(`embedder: not downloaded (${error.message}); task search uses words until the next setup run`);
+  if (modelPresent(paths.models)) ui.success("Embedder ready");
+  else {
+    const download = ui.spinner();
+    download.start("Downloading the embedder (about 110 MB, once)");
+    try { await ensureModel({ modelsDir: paths.models, log: (line) => download.message(`Downloading the embedder · ${line.slice(0, 30)}`) }); download.stop("Embedder ready"); }
+    catch (error) { download.stop(`Embedder not downloaded (${error.message}). Task search uses words until the next setup run`, 2); }
   }
   const failed = states.filter((state) => selected.includes(state.agent) && state.installed && !state.configured);
   if (failed.length) {
     throw new Error(`setup is incomplete for ${failed.map((state) => state.agent).join(", ")}. Nothing was hidden; run npx tryharness doctor after fixing the reported CLI error, then rerun setup.`);
   }
-  console.log("history: indexing locally in the background");
-  console.log("runs: your coding agents start the tasks you ask for in folders they have worked in, up to 10 a day each, without a Start; tasks another agent wrote wait for you. Change it: npx tryharness board standing");
-  console.log("Done. You can close this terminal.");
+  ui.info("History indexes locally in the background");
+  ui.info(`Your coding agents start the tasks you ask for in folders they have worked in, up to 10 a day each, without a Start. Tasks another agent wrote wait for you.\n${pc.dim("Change it: npx tryharness board standing")}`);
+  ui.outro("Done. You can close this terminal.");
 }
 
-// The desktop app: installed from this machine's platform package and opened. Never fatal; the
+// The desktop app: the newest build for this machine, installed and opened. Never fatal; the
 // daemon works without it.
-function desktop() {
-  if (!canShowDesktop({})) { console.log("desktop: skipped (no screen on this login)"); return false; }
-  const source = desktopSource({ sourceRoot: SOURCE_ROOT });
-  if (!source) { console.log(`desktop: no app for ${process.platform} ${process.arch} yet`); return false; }
+async function desktop() {
+  if (!canShowDesktop({})) return { ok: false, text: "Desktop app skipped (no screen on this login)" };
   try {
-    const { target, updated } = installDesktop({ source, target: desktopTarget({ source }) });
+    const installed = await setupDesktop({ sourceRoot: SOURCE_ROOT });
+    if (!installed) return { ok: false, text: `No desktop app for ${process.platform} ${process.arch} yet` };
+    const { target, updated } = installed;
     openDesktop({ target });
-    console.log(`desktop: ${updated ? "installed and opened" : "opened"}. The Harness mark is at the top right of your screen; it starts when you log in.`);
-    return true;
+    return { ok: true, text: `Desktop app ${updated ? "installed and opened" : "opened"}. The Harness mark is at the top right of your screen; it starts when you log in.` };
   } catch (error) {
-    console.log(`desktop: not opened (${error.message})`);
-    return false;
+    return { ok: false, text: `Desktop app not opened (${error.message})` };
   }
 }
 
@@ -611,7 +622,10 @@ async function agents() {
     console.log(response.note ? `Every agent now reads this on ${response.agent}'s card: ${response.note}` : `${response.agent}'s card has no note now.`);
     return;
   }
-  await setupSwarm({ runtimeRoot: config.runtimeRoot, states: Object.values(config.agentStates || {}), daemonRequest, only: sub === "setup" ? agent || null : null });
+  const ui = createUi(), only = sub === "setup" ? agent || null : null;
+  ui.intro(`${pc.bgCyan(pc.black(" tryharness "))}  ${only ? `Setting up ${only}` : "Your swarm"}`);
+  await setupSwarm({ runtimeRoot: config.runtimeRoot, states: Object.values(config.agentStates || {}), daemonRequest, ui, only });
+  ui.outro("Done.");
 }
 
 async function phone() {
@@ -654,14 +668,15 @@ function openUrl(url) {
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   try { spawn(command, args, { detached: true, stdio: "ignore" }).on("error", () => {}).unref(); return true; } catch { return false; }
 }
-async function link({ quiet = false } = {}) {
+async function browserLink() {
   const response = await daemonRequest({ command: "phone.offer", kind: "browser" });
   if (!response.ok) throw new Error(response.error || "the daemon could not make a link");
-  const opened = !has("--print") && openUrl(response.url);
-  if (!quiet || !opened) {
-    console.log(opened ? "Opened Harness in your browser to connect it to this computer end to end. The link works once, for 10 minutes." : `Open this in the browser you use Harness in. It works once, for 10 minutes, and is the pairing secret:\n\n${response.url}`);
-    console.log("Harness then carries what your browser and this computer say to each other sealed, and cannot read it.");
-  }
+  return { url: response.url, opened: !has("--print") && openUrl(response.url) };
+}
+async function link() {
+  const { url, opened } = await browserLink();
+  console.log(opened ? "Opened Harness in your browser to connect it to this computer end to end. The link works once, for 10 minutes." : `Open this in the browser you use Harness in. It works once, for 10 minutes, and is the pairing secret:\n\n${url}`);
+  console.log("Harness then carries what your browser and this computer say to each other sealed, and cannot read it.");
 }
 
 // Approving Harness in T3 Code (lib/t3.mjs): then what you send your T3 Code sessions from Harness, in the desktop app or
@@ -711,7 +726,7 @@ try {
   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; }
+  else if (command === "desktop") { const shown = await desktop(); console.log(shown.text); if (!shown.ok) process.exitCode = 1; }
   else if (command === "logs") logs();
   else if (command === "disconnect") await disconnect();
   else if (command === "daemon") { const { startDaemon } = await import("./lib/daemon.mjs"); await startDaemon(); }

package/lib/daemon.mjs

@@ -28,10 +28,10 @@ import { fingerprint, openBound, openBytes, relayKey, sealBound, sealBytes } fro
 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 { EDITOR_IDS, agentCommand, editorFolder, editorInstall, editorName, editorTerminalStarts, openEditorFolder, panelLink, placeEnv, placeFrom, placeKey, processEnv, resumeLine, t3App, t3Link, t3Model, t3Open, t3OpensLinks, t3Project, t3Provider, t3Runs, t3Thread } from "./places.mjs";
 import { detectAgentApps, detectMcpClients } from "./adapters.mjs";
 import { cardLine, swarmBlock, swarmCards, swarmDigest } from "./cards.mjs";
-import { forgetT3, sendToT3, startT3SignIn, t3Access } from "./t3.mjs";
+import { forgetT3, handedToT3, runInT3, 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).
@@ -599,6 +599,31 @@ export async function startDaemon() {
     return !root || Boolean(store.getTask(root)?.run_authorized_at);
   };
   const roomDigest = (goalId, limit = 30) => store.roomPosts(goalId).slice(-limit).map((post) => `[${post.seq}] ${post.author}${post.kind !== "post" ? ` (${post.kind})` : ""}: ${post.text.slice(0, 1_200)}`).join("\n");
+  // A thread's coding agent works in T3 Code when the person uses it there: its home is T3, Harness may send into T3,
+  // T3 is open with a project for the thread's folder, and the agent has run in T3 before (its model there is the
+  // person's last choice). A thread already in Harness's own copy, or carrying on a session in place, stays there; one
+  // in T3 stays in T3, and a turn T3 can't take then fails saying why. Reviews keep the agent's read-only switch here.
+  const inT3 = (thread, agent, review) => {
+    if (review || !t3Provider(agent) || !thread.goal.workspace) return false;
+    const tree = worktrees.get(thread.id)?.state ?? null;
+    if (tree === "t3") return true;
+    return tree === null && t3Access()?.state === "send" && homeOf(agent)?.kind === "t3" && t3Open() && Boolean(t3Project(thread.goal.workspace)) && Boolean(t3Model(agent));
+  };
+  // A turn T3 carries out (t3.mjs runInT3): into the agent's T3 thread in this thread, else a new one in T3's project
+  // for the folder, on the thread's T3 checkout. The thread works in T3 from its first launch.
+  const t3Turn = (task, agent) => {
+    const thread = store.getTask(task.parent_id);
+    const key = `t3-thread:${thread.id}:${agent}`;
+    const model = t3Model(agent);
+    const project = t3Project(thread.goal.workspace);
+    return {
+      threadId: store.meta(key) || null,
+      title: thread.objective.slice(0, 120),
+      launch: { ...(project ? { projectId: project.id } : {}), ...(model ? { modelSelection: model } : {}), workspaceStrategy: worktrees.t3Workspace(thread) },
+      onThread: (threadId) => { store.meta(key, threadId); worktrees.inT3(thread.id); },
+      onWorktree: (where, branch) => worktrees.inT3(thread.id, where, branch),
+    };
+  };
   // Wake one teammate. A coding agent here gets a run in the goal's folder that resumes its last session on this goal;
   // Harness and agents that cannot be started here learn of it through the board change and their own reads.
   const pendingWakes = new Map();
@@ -618,10 +643,13 @@ export async function startDaemon() {
     if (store.openWake(goalId, agent)) { pendingWakes.set(`${goalId}:${agent}`, { reason, byPerson: byPerson || Boolean(pendingWakes.get(`${goalId}:${agent}`)?.byPerson) }); return; }
     if (store.wakeCount(goalId, agent) >= goal.max_wakes) { pauseGoal(goalId, `${agent} was woken ${goal.max_wakes} times`); return; }
     const brief = swarmBrief(task, agent, reason, { review });
-    // A coding thread in a repository works in its own worktree, so threads never share a checkout.
-    let folder;
-    try { folder = worktrees.folderFor(task); } catch (error) { store.roomPost({ goalId, author: "harness", kind: "note", text: `${agent} cannot start: ${error.message}` }); notifyBoard(store.getTask(goalId)); return; }
+    // A coding thread in a repository works in its own worktree, so threads never share a checkout; one whose agents the
+    // person uses in T3 Code works in T3 (inT3), where T3 makes and keeps the checkout.
+    const t3 = inT3(task, agent, review);
+    let folder = goal.workspace;
+    if (!t3) try { folder = worktrees.folderFor(task); } catch (error) { store.roomPost({ goalId, author: "harness", kind: "note", text: `${agent} cannot start: ${error.message}` }); notifyBoard(store.getTask(goalId)); return; }
     const wake = store.postTask({ objective: `Room: ${task.objective}`.slice(0, 500), brief, originAgent: "harness", provenance: { trust: "agent", chain: ["room"] }, targetAgent: agent, parentId: goalId, runWorkspace: folder, kind: "wake" });
+    if (t3) store.meta(`t3-run:${wake.id}`, "1");
     // A review runs with the agent's own read-only switch (runner.mjs); only Claude Code and Codex have one.
     if (review) store.meta(`review:${wake.id}`, "1");
     if (threadMayRun(task)) {
@@ -925,7 +953,10 @@ export async function startDaemon() {
       return title && !title.startsWith("<") ? title : null;
     };
     const linksOk = t3LinksOk();
+    const handed = handedToT3();
     const sessions = liveSessions({ exclude: new Set(runningPids()), recent })
+      // A T3 thread running a turn Harness handed it is Harness's run, shown in its thread.
+      .filter((session) => !handed.has(session.t3Thread))
       // 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.
@@ -1046,6 +1077,11 @@ export async function startDaemon() {
   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);
+    // A T3 Code thread itself (a turn Harness handed to T3) opens there, wherever the agent usually works.
+    if (sessionId && t3Thread(sessionId) === sessionId) {
+      const plan = placePlan(agentId, usable({ kind: "t3", name: "T3 Code" }), sessionId, folder, act);
+      if (plan) return plan;
+    }
     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 };
@@ -1407,6 +1443,8 @@ export async function startDaemon() {
     const text = `${defaults.map((rule) => rule.agent).join(", ")} now ${one ? "starts" : "start"} the tasks you ask for in folders ${one ? "it has" : "they have"} worked in, up to ${defaults[0].daily_cap} a day${one ? "" : " each"}, without a Start. Change it: npx tryharness board standing`;
     log(text); notifyDesktop(text); store.meta("standing_announced", new Date().toISOString());
   }
+  // Where a run works, one at a time: its folder, or for a turn T3 Code carries out, its thread (T3 keeps the checkout).
+  const slotOf = (task) => (store.meta(`t3-run:${task.id}`) === "1" ? `t3:${task.parent_id}` : task.run_workspace ? path.resolve(task.run_workspace) : task.target_agent);
   // Lid-Closed Mode holds new runs while the Mac runs warm with the lid closed; running ones go on.
   let runsHeld = false;
   const runBoard = () => {
@@ -1414,7 +1452,7 @@ export async function startDaemon() {
     // One run per folder at a time: each thread's worktree is its own folder, so threads run side by side.
     for (const task of store.runnableTasks(installedAgents)) {
       const agent = task.target_agent;
-      const slot = task.run_workspace ? path.resolve(task.run_workspace) : agent;
+      const slot = slotOf(task);
       if (activeRuns.has(slot)) continue;
       const claimed = store.claimTask(task.id, agent, task.version, null);
       if (!claimed.ok) continue;
@@ -1451,15 +1489,16 @@ export async function startDaemon() {
     const readOnly = store.meta(`review:${task.id}`) === "1";
     // Another agent's words on a goal's authority, not the person's tap: restricted (docs/member-runs.md).
     const restricted = task.trust !== "user" && task.run_authorized_by === "goal" && store.meta(`person-wake:${task.id}`) !== "1";
-    startTask({ runId: task.id, agent, title: task.objective.slice(0, 120), brief: resumeSession && again && !wake ? again : [again, brief].filter(Boolean).join("\n\n"), cwd: task.run_workspace, ...(stoppedFor ? { again: true } : {}), ...(resumeSession ? { resumeSession } : {}), ...(readOnly ? { readOnly } : {}), ...(restricted ? { restricted } : {}) }, (kind, text, extra) => {
-      // The agent's session in a thread is resumed when the thread calls on it again.
-      if (kind === "session" && text) { store.setRunSession(task.id, text); if (wake || room?.kind === "goal") store.setGoalSession(task.parent_id, agent, text); notifyBoard(store.getTask(task.id)); }
+    const t3 = wake && store.meta(`t3-run:${task.id}`) === "1" ? t3Turn(task, agent) : null;
+    startTask({ runId: task.id, agent, title: task.objective.slice(0, 120), brief: resumeSession && again && !wake ? again : [again, brief].filter(Boolean).join("\n\n"), cwd: task.run_workspace, ...(stoppedFor ? { again: true } : {}), ...(resumeSession && !t3 ? { resumeSession } : {}), ...(readOnly ? { readOnly } : {}), ...(restricted ? { restricted } : {}), ...(t3 ? { t3 } : {}) }, (kind, text, extra) => {
+      // The agent's session in a thread is resumed when the thread calls on it again; in T3 it is the agent's T3 thread.
+      if (kind === "session" && text) { store.setRunSession(task.id, text); if (!t3 && (wake || room?.kind === "goal")) store.setGoalSession(task.parent_id, agent, text); notifyBoard(store.getTask(task.id)); }
       // A step the agent took: whoever has the thread open reads it again, at most once a second per run.
       if (kind === "progress" && Date.now() - (lastStepNotice.get(task.id) ?? 0) >= 1_000) { lastStepNotice.set(task.id, Date.now()); notifyBoard(store.getTask(task.id)); }
       if (kind === "accepted" && stoppedFor) store.meta(`requeued:${task.id}`, "");
       if (kind === "done" || kind === "failed") {
         lastStepNotice.delete(task.id);
-        activeRuns.delete(task.run_workspace ? path.resolve(task.run_workspace) : agent);
+        activeRuns.delete(slotOf(task));
         const reason = interrupting.get(task.id);
         interrupting.delete(task.id);
         if (kind === "failed" && reason && store.requeueRun(task.id).ok) {
@@ -1820,7 +1859,8 @@ export async function startDaemon() {
     const observe = (stream, raw) => {
       try { fs.appendFileSync(files.log, stream === "stderr" ? `\n[stderr] ${raw}` : raw, { mode: 0o600 }); } catch {}
     };
-    runAgentTask(message, emit, observe);
+    if (message.t3) runInT3({ runId: message.runId, brief: message.brief, cwd: message.cwd, ...message.t3 }, emit, observe);
+    else runAgentTask(message, emit, observe);
   };
   // Drops the connection and dials again in about a second, whatever the backoff had grown to.
   const reconnectNow = (reason) => {

package/lib/desktop.mjs

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -7,12 +8,75 @@ import { run } from "./commands.mjs";
 import { ensureDir, readJson, writeJsonAtomic } from "./files.mjs";
 import { paths } from "./paths.mjs";
 
-// The desktop app ships as one optional npm package per platform (tryharness-desktop-<os>-<cpu>),
-// so `npx tryharness` brings the build for this machine and nothing else. Setup copies it out of
-// npm's temporary cache to a place it keeps, opens it, and the app registers itself to start at
-// login from there.
+// The desktop app ships as one npm package per platform (tryharness-desktop-<os>-<cpu>), an optional
+// dependency of tryharness, so `npx tryharness` brings the build for this machine and nothing else.
+// Setup installs the newest build there is: npx may run a tryharness it cached before a newer app was
+// published, so setup also asks npm, and never puts an older build over a newer one. It copies the app
+// to a place it keeps, opens it, and the app registers itself to start at login from there.
 
+const REGISTRY = "https://registry.npmjs.org";
 const marker = () => path.join(paths.home, "desktop.json");
+const downloads = () => path.join(paths.home, "desktop-download");
+
+/** Whether version `a` is newer than `b`: x.y.z, a prerelease (0.7.13-local.ab12) before its release. */
+export function newerVersion(a, b) {
+  const parse = (v) => /^(\d+)\.(\d+)\.(\d+)(-.+)?$/.exec(String(v ?? ""));
+  const x = parse(a), y = parse(b);
+  if (!x || !y) return Boolean(x);
+  for (let i = 1; i <= 3; i++) if (Number(x[i]) !== Number(y[i])) return Number(x[i]) > Number(y[i]);
+  return !x[4] && Boolean(y[4]);
+}
+
+/**
+ * This machine's desktop package as npm has it now, downloaded when it is newer than `than` and unpacked under
+ * Harness's home. The download must match the checksum npm publishes for it. Null when there is nothing newer,
+ * nothing for this machine, or npm cannot be reached: setup goes on with what it has.
+ */
+export async function latestDesktop({ than, platform = process.platform, arch = process.arch, registry = REGISTRY }) {
+  try {
+    const response = await fetch(`${registry}/${desktopPackageName(platform, arch)}/latest`);
+    if (!response.ok) return null;
+    const meta = await response.json();
+    const tarball = String(meta.dist?.tarball ?? "");
+    if (!meta.harnessDesktop || !newerVersion(meta.version, than) || !tarball.startsWith(`${registry}/`)) return null;
+    const download = await fetch(tarball);
+    if (!download.ok) return null;
+    const bytes = Buffer.from(await download.arrayBuffer());
+    const [algorithm, digest] = String(meta.dist.integrity ?? "").split(/-(.*)/s);
+    if (algorithm !== "sha512" || createHash("sha512").update(bytes).digest("base64") !== digest) return null;
+    fs.rmSync(downloads(), { recursive: true, force: true });
+    ensureDir(downloads());
+    const file = path.join(downloads(), "package.tgz");
+    fs.writeFileSync(file, bytes);
+    if (!run("tar", ["-xzf", file, "-C", downloads()]).ok) return null;
+    const app = path.join(downloads(), "package", String(meta.harnessDesktop));
+    return fs.existsSync(app) ? { app, version: String(meta.version) } : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Setup's desktop app: the newest of the one npx brought, the one on npm and the one installed, never an older build
+ * over a newer one (a local build stays). Where it is and whether it changed, or null when this machine has none.
+ * HARNESS_DESKTOP_APP installs that app as it is.
+ */
+export async function setupDesktop({ sourceRoot, env = process.env, platform = process.platform, arch = process.arch, registry = REGISTRY, execute = run }) {
+  const bundled = desktopSource({ sourceRoot, env, platform, arch });
+  const install = (source) => installDesktop({ source, target: desktopTarget({ source, env, platform }), platform, execute });
+  if (env.HARNESS_DESKTOP_APP) return bundled && install(bundled);
+  const installed = readJson(marker(), {});
+  const have = installed.path && fs.existsSync(installed.path) ? installed : null;
+  const than = newerVersion(have?.version, bundled?.version) ? have.version : bundled?.version ?? have?.version;
+  const latest = await latestDesktop({ than, platform, arch, registry });
+  const source = latest ?? bundled;
+  try {
+    if (have && (!source || newerVersion(have.version, source.version))) return { target: have.path, updated: false };
+    return source && install(source);
+  } finally {
+    if (latest) fs.rmSync(downloads(), { recursive: true, force: true });
+  }
+}
 
 export function desktopPackageName(platform = process.platform, arch = process.arch) {
   return `tryharness-desktop-${platform}-${arch}`;

package/lib/live.mjs

@@ -6,7 +6,7 @@ import { readJson } from "./files.mjs";
 import { historyRoots } from "./paths.mjs";
 import { PS } from "./nudge.mjs";
 import { stepsOf } from "./runner.mjs";
-import { t3Link, t3Thread } from "./places.mjs";
+import { t3App, t3Link, t3Thread, t3Working } from "./places.mjs";
 
 // The person's own coding sessions running on this computer right now, each with the app it runs in: a terminal, an
 // editor or T3 Code, found by walking up the session's process tree to the first process inside an app bundle. A
@@ -113,12 +113,17 @@ export function liveSessions({ exclude = new Set(), recent = [], table = process
     const id = String(session?.session_id || "").replace(/\.jsonl$/, "").match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)?.[0];
     if (id && !sessions.some((row) => row.sessionId === id)) sessions.push({ agent: "codex", sessionId: id, folder: session.cwd, pid, busy: null, at: Date.parse(session.started_at) || 0 });
   }
+  // Codex in T3 Code runs on that shared server too, so no process says which T3 thread it works in: T3's own record does.
+  const t3 = t3App();
+  if (t3) for (const row of t3Working("codex")) {
+    if (!sessions.some((session) => session.sessionId === row.sessionId)) sessions.push({ agent: "codex", sessionId: row.sessionId, folder: row.folder, pid: null, busy: true, at: row.at, host: { name: t3.name, app: t3.app }, t3Thread: row.thread });
+  }
   return sessions.sort((a, b) => b.at - a.at).map((session) => {
     const tty = table.get(session.pid)?.tty ?? null;
     // Inside tmux the app is the terminal a tmux client shows the pane in.
     const tmux = underTmux(table, session.pid) && tty ? tmuxPlace(table, tty) : null;
-    const host = tmux?.client?.host ?? hostApp(table, session.pid);
-    const t3 = host && /^T3 Code\b/.test(host.name) ? t3Link(t3Thread(session.sessionId)) : null;
+    const host = session.host ?? tmux?.client?.host ?? hostApp(table, session.pid);
+    const t3 = host && /^T3 Code\b/.test(host.name) ? t3Link(session.t3Thread ?? t3Thread(session.sessionId)) : null;
     return { ...session, tty, tmux: tmux?.target ?? null, host, t3 };
   });
 }

package/lib/onboard.mjs

@@ -1,22 +1,37 @@
 import { spawnSync } from "node:child_process";
-import readline from "node:readline";
+import pc from "picocolors";
 import { detectLocalAgents, setupHermes, setupOpenClaw, localWakes } from "./wakes.mjs";
+import { columns, createUi, wrap } from "./ui.mjs";
 
-// "Your swarm" in setup: every agent class with how Harness reaches it, the recommended way already chosen, the steps
-// numbered, and a real test at the end that passes only when the agent claims and reports a task. Also reachable on its
-// own as `npx tryharness agents`. Without a terminal to answer in, it only says what is set up and how to finish.
+// "Your swarm" in setup: every agent class with how Harness reaches it, the recommended way already chosen, and a real
+// test at the end that passes only when the agent claims and reports a task. Also reachable on its own as
+// `npx tryharness agents`. Without a terminal to answer in, it only says what is set up and how to finish.
 
 const SETUP = { openclaw: setupOpenClaw, hermes: setupHermes };
 const LABEL = { openclaw: "OpenClaw", hermes: "Hermes", "grok-bot": "Grok Bot" };
-const MEASURED = "measured on a real Grok: about 23s by email, 17s by webhook";
+const later = (agent) => `Later: ${pc.cyan(`npx tryharness agents setup ${agent}`)}`;
 
-export function createPrompter({ input = process.stdin, output = process.stdout } = {}) {
-  const ask = (question, { hidden = false } = {}) => new Promise((resolve) => {
-    const rl = readline.createInterface({ input, output, terminal: true });
-    if (hidden) rl._writeToOutput = (text) => { if (text.includes(question)) output.write(text); };
-    rl.question(question, (answer) => { rl.close(); if (hidden) output.write("\n"); resolve(answer.trim()); });
-  });
-  return { ask };
+// The Harness mark (src/main/home/landing/walkthrough/BrandMark.tsx) in box characters: dim corners, the bright one in
+// Harness teal, the wordmark beside it. Plain when the output is not a terminal or NO_COLOR is set.
+export function banner(version, { color = pc.isColorSupported } = {}) {
+  const c = pc.createColors(color), teal = (text) => (color ? `\x1b[38;5;36m${text}\x1b[39m` : text);
+  const rows = [
+    [c.dim("┌───"), "           ", teal("───┐")],
+    [c.dim("│"), "                 ", teal("│")],
+    [""],
+    ["      ", c.dim("┌──"), teal("───┐")],
+    ["      ", c.dim("│"), "     ", teal("│")],
+    ["      ", c.dim("└─────┘")],
+    [""],
+    [c.dim("│"), "                 ", c.dim("│")],
+    [c.dim("└───"), "           ", c.dim("───┘")],
+  ];
+  const side = { 3: c.bold("harness relay"), 4: "your personal swarm", 5: c.dim(`setup ${version}`) };
+  return rows.map((parts, index) => {
+    const line = parts.join("");
+    const width = line.replace(/\x1b\[[0-9;]*m/g, "").length;
+    return side[index] ? `  ${line}${" ".repeat(23 - width)}${side[index]}` : `  ${line}`.trimEnd();
+  }).join("\n");
 }
 
 const copy = (text) => {
@@ -26,106 +41,141 @@ const copy = (text) => {
 };
 
 /** Post a setup check for the agent and wait for its report: the same path real work takes. */
-export async function testAgent({ agent, daemonRequest, out = console.log, waitMs = 10 * 60_000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+export async function testAgent({ agent, daemonRequest, ui = createUi(), waitMs = 10 * 60_000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+  const name = LABEL[agent] || agent;
   const posted = await daemonRequest({ command: "board.post", agent: "user", objective: "Setup check from Harness: reply ready", brief: "Harness is checking that it can wake you. Claim this task and report it done with the single word: ready. Do nothing else.", targetAgent: agent });
-  if (!posted?.ok) { out(`    ! the test task could not be posted: ${posted?.error || "no answer"}`); return false; }
-  const started = Date.now();
-  out(`    Test sent. Waiting for ${LABEL[agent] || agent} to answer (Ctrl-C stops waiting; the test task stays on your board).`);
+  if (!posted?.ok) { ui.warn(`The test task could not be posted: ${posted?.error || "no answer"}`); return false; }
+  const started = Date.now(), spin = ui.spinner();
+  spin.start(`Waiting for ${name} to answer a test task`);
   while (Date.now() - started < waitMs) {
     await sleep(2_000);
     const task = (await daemonRequest({ command: "board.get", agent: "user", id: posted.task.id }).catch(() => null))?.task;
-    if (task?.status === "done") { out(`    ✓ ${LABEL[agent] || agent} answered in ${Math.round((Date.now() - started) / 1000)}s. Ready.`); return true; }
-    if (task && ["failed", "needs_input"].includes(task.status)) { out(`    ! ${LABEL[agent] || agent} answered but the task is ${task.status}: ${task.result || ""}`); return false; }
+    if (task?.status === "done") { spin.stop(`${name} answered in ${Math.round((Date.now() - started) / 1000)}s. Ready.`); return true; }
+    if (task && ["failed", "needs_input"].includes(task.status)) { spin.stop(`${name} answered, but the task is ${task.status}${task.result ? `: ${task.result}` : ""}`, 2); return false; }
   }
-  out(`    ! No answer after ${Math.round(waitMs / 60_000)} minutes. Check that the agent is running, then: npx tryharness agents test ${agent}`);
+  spin.stop(`No answer after ${Math.round(waitMs / 60_000)} minutes. Check that ${name} is running, then: npx tryharness agents test ${agent}`, 2);
   return false;
 }
 
-async function setupLocal({ entry, runtimeRoot, prompter, daemonRequest, out }) {
+async function setupLocal({ entry, runtimeRoot, ui, daemonRequest }) {
   const name = LABEL[entry.agent];
+  const run = async () => {
+    const result = SETUP[entry.agent]({ runtimeRoot });
+    if (!result.ok) { ui.warn(result.detail); return; }
+    ui.success(result.detail);
+    await testAgent({ agent: entry.agent, daemonRequest, ui });
+  };
   if (localWakes()[entry.agent]) {
     const health = (await daemonRequest({ command: "wake.local" }).catch(() => null))?.agents?.[entry.agent];
-    if (!health || health.answering) { out(`  ✓ ${name}: woken on this computer by its own webhook`); return; }
-    out(`  ! ${name}: not answering wakes (${health.lastFailure}). Check that it is running.`);
-    if (!prompter || /^n/i.test(await prompter.ask(`    Set ${name} up again? [Y/n] `))) { out(`    Later: npx tryharness agents setup ${entry.agent}`); return; }
-    const result = SETUP[entry.agent]({ runtimeRoot });
-    out(`    ${result.ok ? "✓" : "!"} ${result.detail}`);
-    if (result.ok) await testAgent({ agent: entry.agent, daemonRequest, out });
+    if (!health || health.answering) { ui.success(`${name} is woken on this computer by its own webhook`); return; }
+    ui.warn(`${name} is not answering wakes (${health.lastFailure}). Check that it is running.`);
+    if (!ui.interactive || !(await ui.confirm({ message: `Set ${name} up again?`, initialValue: true }))) { ui.info(later(entry.agent)); return; }
+    await run();
     return;
   }
-  if (!prompter) { out(`  ! ${name}: found. Set it up with: npx tryharness agents setup ${entry.agent}`); return; }
-  out(`  ${name} found. Harness wakes it with a webhook on this computer (recommended, nothing to copy).`);
-  out(`    This adds Harness to ${name}'s MCP servers and turns on its webhook with a key made here${entry.agent === "openclaw" ? ", then restarts its gateway" : ""}.`);
-  if (/^n/i.test(await prompter.ask(`    Set up ${name} now? [Y/n] `))) { out(`    Skipped. Later: npx tryharness agents setup ${entry.agent}`); return; }
-  const result = SETUP[entry.agent]({ runtimeRoot });
-  out(`    ${result.ok ? "✓" : "!"} ${result.detail}`);
-  if (result.ok) await testAgent({ agent: entry.agent, daemonRequest, out });
+  if (!ui.interactive) { ui.info(`${name} found. ${later(entry.agent)}`); return; }
+  ui.step(`${name} found on this computer\n${pc.dim(`Harness adds itself to ${name}'s MCP servers and turns on its webhook with a key made here${entry.agent === "openclaw" ? ", then restarts its gateway" : ""}. Nothing to copy.`)}`);
+  if (!(await ui.confirm({ message: `Set up ${name} now?`, initialValue: true }))) { ui.info(`Skipped. ${later(entry.agent)}`); return; }
+  await run();
+}
+
+async function waitFor(check, waitMs = 10 * 60_000, everyMs = 3_000) {
+  const end = Date.now() + waitMs;
+  while (Date.now() < end) {
+    if (await check()) return true;
+    await new Promise((r) => setTimeout(r, everyMs));
+  }
+  return false;
 }
 
-async function setupGrok({ prompter, daemonRequest, out, clipboard }) {
-  const listed = await daemonRequest({ command: "wake.server", input: { action: "list" } }).catch((error) => ({ ok: false, error: error.message }));
-  if (!listed.ok) { out(`  ! Grok Bot: Harness could not be reached (${listed.error}). Later: npx tryharness agents setup grok-bot`); return; }
+async function setupGrok({ ui, daemonRequest, clipboard }) {
+  const list = () => daemonRequest({ command: "wake.server", input: { action: "list" } });
+  const listed = await list().catch((error) => ({ ok: false, error: error.message }));
+  if (!listed.ok) { ui.warn(`Harness could not be reached (${listed.error}). ${later("grok-bot")}`); return; }
   const current = (listed.wakes || []).find((wake) => wake.agent === "grok-bot");
   if (current) {
     const how = current.channel === "email" ? `email at ${current.address}` : "its webhook";
-    if (current.answering) { out(`  ✓ Grok Bot: woken by ${how}`); return; }
-    out(`  ! Grok Bot: not answering wakes by ${how} (${current.last_failure}).`);
-    if (!prompter || /^n/i.test(await prompter.ask("    Set it up again? [Y/n] "))) { out("    Later: npx tryharness agents setup grok-bot"); return; }
+    if (current.answering) { ui.success(`Grok Bot is woken by ${how}`); return; }
+    ui.warn(`Grok Bot is not answering wakes by ${how} (${current.last_failure})`);
+    if (!ui.interactive || !(await ui.confirm({ message: "Set it up again?", initialValue: true }))) { ui.info(later("grok-bot")); return; }
   }
-  if (!prompter) { out("  Grok Bot: not set up. Set it up with: npx tryharness agents setup grok-bot"); return; }
-  out(`  Grok Bot. How should Harness wake it? (${MEASURED})`);
-  out("    1) Email     nothing to copy back                          (recommended)");
-  out("    2) Webhook   a little faster; you paste its URL and key here");
-  out("    3) Not now");
-  const choice = (await prompter.ask("    Choose [1]: ")) || "1";
-  if (choice === "3") { out("    Skipped. Later: npx tryharness agents setup grok-bot"); return; }
-  const channel = choice === "2" ? "webhook" : "email";
+  if (!ui.interactive) { ui.info(`Grok Bot is not set up. ${later("grok-bot")}`); return; }
+  const channel = await ui.select({
+    message: "How should Harness wake Grok Bot?",
+    initialValue: "email",
+    options: [
+      { value: "email", label: "Email", hint: "recommended · about 23s · nothing to copy back" },
+      { value: "webhook", label: "Webhook", hint: "about 17s · you paste its URL and key here" },
+      { value: "skip", label: "Not now" },
+    ],
+  });
+  if (!channel || channel === "skip") { ui.info(`Skipped. ${later("grok-bot")}`); return; }
   const message = listed.messages?.["grok-bot"]?.[channel];
-  if (!message) { out("    ! Harness did not send the setup message; update tryharness and try again."); return; }
+  if (!message) { ui.warn("Harness did not send the setup message. Update tryharness and try again."); return; }
+  const setup = (listed.setup || []).find((entry) => entry.agent === "grok-bot");
+  const connected = Boolean(setup) && !setup.missing?.includes("connection");
   const copied = clipboard(message);
-  out(`    1. ${copied ? "This message is on your clipboard. Paste it into Grok:" : "Paste this message into Grok:"}`);
-  out(message.split("\n").map((line) => `       ${line}`).join("\n"));
-  out("    2. Grok opens Harness's approval page. Name the connection Grok Bot and approve.");
+  ui.note(wrap(message, Math.max(40, columns() - 8)).join("\n"), copied ? "Paste this into Grok · it is on your clipboard" : "Paste this into Grok");
+  if (connected) ui.success(`Grok is already connected to Harness as Grok Bot${setup.old_approval ? `\n${pc.dim("approved before it could register its own address, so it gives you its address instead")}` : ""}`);
+  else ui.info("Grok opens Harness's approval page. Name the connection Grok Bot and approve it.");
+
+  const save = async (input, done) => {
+    const saved = await daemonRequest({ command: "wake.server", input: { action: "save", agent: "grok-bot", ...input } });
+    if (!saved.ok) { ui.warn(`${saved.error}. Try again: npx tryharness agents setup grok-bot`); return false; }
+    ui.success(done(saved));
+    return true;
+  };
   if (channel === "webhook") {
-    out("    3. In Grok, open Routines, then Harness wake, and copy its webhook URL and key.");
-    const address = await prompter.ask("       Webhook URL: ");
-    const key = await prompter.ask("       Key (hidden): ", { hidden: true });
-    const saved = await daemonRequest({ command: "wake.server", input: { action: "save", agent: "grok-bot", channel: "webhook", address, key } });
-    if (!saved.ok) { out(`    ! ${saved.error}. Try again: npx tryharness agents setup grok-bot`); return; }
-    out("    ✓ Saved. The key is stored sealed on Harness and is never shown again.");
+    ui.info("In Grok, open Routines, then Harness wake, and copy its webhook URL and key.");
+    const address = await ui.text({ message: "Grok's webhook URL", placeholder: "https://", validate: (value) => (/^https:\/\/\S+$/.test(value.trim()) ? undefined : "Paste the https URL from Grok's routine") });
+    if (!address) { ui.info(`Skipped. ${later("grok-bot")}`); return; }
+    const key = await ui.password({ message: "Its key", validate: (value) => (value.trim() ? undefined : "Paste the key from Grok's routine") });
+    if (!key) { ui.info(`Skipped. ${later("grok-bot")}`); return; }
+    if (!(await save({ channel: "webhook", address: address.trim(), key }, () => "Saved. The key is stored sealed on Harness and never shown again."))) return;
   } else {
-    out("    3. Grok registers its own address with Harness. Waiting for it (Ctrl-C stops waiting)...");
-    const registered = await waitFor(async () => ((await daemonRequest({ command: "wake.server", input: { action: "list" } }).catch(() => null))?.wakes || []).some((wake) => wake.agent === "grok-bot"));
-    if (!registered) { out("    Not registered yet. When Grok has done it: npx tryharness agents test grok-bot"); return; }
-    out("    ✓ Grok registered its address.");
+    const ownAddress = (value) => (/^[^\s@]+@mail\.grokbot\.com$/i.test(value.trim()) ? undefined : "Grok's address ends in @mail.grokbot.com");
+    let address = "";
+    if (setup?.old_approval) {
+      address = await ui.text({ message: "Grok's email address", placeholder: "name@mail.grokbot.com", validate: ownAddress }) ?? "";
+      if (!address) { ui.info(`Skipped. ${later("grok-bot")}`); return; }
+    } else {
+      // Grok registers its own address; the person may type the one Grok gives instead, and the prompt closes when it registers.
+      let settled = false;
+      const registered = waitFor(async () => settled || ((await list().catch(() => null))?.wakes || []).some((wake) => wake.agent === "grok-bot"))
+        .then((ok) => (ok ? { ok, line: "Grok registered its address" } : { ok, line: "Grok has not registered yet. When it has: npx tryharness agents test grok-bot" }));
+      const answer = await ui.waitOrType({ message: "Waiting for Grok to register its address", placeholder: "or type the address Grok gives you", until: registered });
+      let outcome = answer.done;
+      if (answer.cancelled) { settled = true; ui.info(`Stopped waiting. ${later("grok-bot")}`); return; }
+      if (answer.value && ownAddress(answer.value)) { settled = true; ui.warn(`${ownAddress(answer.value)}. ${later("grok-bot")}`); return; }
+      if (answer.value) address = answer.value;
+      else if (!outcome) {
+        const spin = ui.spinner();
+        spin.start("Waiting for Grok to register its address");
+        outcome = await registered;
+        spin.stop(outcome.line, outcome.ok ? 0 : 2);
+      }
+      settled = true;
+      if (outcome && !outcome.ok) return;
+    }
+    if (address && !(await save({ channel: "email", address: address.trim() }, (saved) => `Saved. Harness wakes Grok at ${saved.wake?.address ?? address.trim()}`))) return;
   }
-  await testAgent({ agent: "grok-bot", daemonRequest, out });
-}
-
-async function waitFor(check, waitMs = 10 * 60_000, everyMs = 3_000) {
-  const end = Date.now() + waitMs;
-  while (Date.now() < end) {
-    if (await check()) return true;
-    await new Promise((r) => setTimeout(r, everyMs));
-  }
-  return false;
+  await testAgent({ agent: "grok-bot", daemonRequest, ui });
 }
 
 /** The whole "Your swarm" step. `only` limits it to one agent (npx tryharness agents setup <agent>). */
-export async function setupSwarm({ runtimeRoot, states = [], daemonRequest, prompter = process.stdin.isTTY ? createPrompter() : null, out = console.log, only = null, clipboard = copy }) {
+export async function setupSwarm({ runtimeRoot, states = [], daemonRequest, ui = createUi(), only = null, clipboard = copy }) {
   const want = (agent) => !only || only === agent;
-  out("\nYour swarm");
-  if (!only) {
-    out("  On this computer: Harness starts them when work is posted");
-    for (const state of states) out(`    ${!state.installed ? "–" : state.configured ? "✓" : "!"} ${state.agent}: ${state.detail}`);
+  if (!only && states.length) {
+    const width = Math.max(...states.map((state) => state.agent.length));
+    const rows = states.map((state) => `${!state.installed ? pc.dim("–") : state.configured ? pc.green("✓") : pc.yellow("!")} ${state.agent.padEnd(width)}  ${pc.dim(state.detail)}`);
+    ui.step(`Coding agents on this computer ${pc.dim("· Harness starts them when work is posted")}\n${rows.join("\n")}`);
   }
   const local = detectLocalAgents().filter((entry) => entry.found && want(entry.agent));
-  if (local.length) out("  Agent apps on this computer: woken by a webhook Harness sets up");
-  for (const entry of local) await setupLocal({ entry, runtimeRoot, prompter, daemonRequest, out });
-  if (only && LABEL[only] && only !== "grok-bot" && !local.length) out(`  ${LABEL[only]} was not found on this computer.`);
+  for (const entry of local) await setupLocal({ entry, runtimeRoot, ui, daemonRequest });
+  if (only && LABEL[only] && only !== "grok-bot" && !local.length) ui.warn(`${LABEL[only]} was not found on this computer.`);
   if (want("grok-bot")) {
-    out("  Cloud agents: woken by email or webhook");
-    await setupGrok({ prompter, daemonRequest, out, clipboard });
+    ui.step(`Grok Bot ${pc.dim("· runs in its own cloud, woken by email or webhook")}`);
+    await setupGrok({ ui, daemonRequest, clipboard });
   }
-  if (!only) out("  Built in: Bankr and Quotient run on Harness, nothing to set up");
+  if (!only) ui.info(`Bankr and Quotient run on Harness ${pc.dim("· nothing to set up")}`);
 }

package/lib/places.mjs

@@ -154,6 +154,8 @@ const AGENTS = {
   opencode: { command: "opencode", resume: "opencode --session" },
 };
 export const agentCommand = (agent) => AGENTS[agent]?.command ?? null;
+/** An agent's provider in T3 Code ("claudeAgent", "codex"); null for an agent T3 does not run. */
+export const t3Provider = (agent) => AGENTS[agent]?.t3 ?? null;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const PLAIN_ID = /^[A-Za-z0-9._:-]{1,128}$/;
 const quote = (text) => `'${String(text).replace(/'/g, `'\\''`)}'`;
@@ -196,7 +198,8 @@ const t3Tables = (home) => new Set((t3Query(home, "select name from sqlite_maste
 
 /**
  * The T3 Code thread that has a provider session: the thread T3 ran it in (nightlies record the session on the thread's
- * provider thread; 0.0.45 in provider_session_runtime), else T3's import of it.
+ * provider thread; 0.0.45 in provider_session_runtime), else T3's import of it. A T3 thread's own id (a turn Harness
+ * handed to T3, t3.mjs runInT3) is that thread.
  */
 export function t3Thread(sessionId, home = t3Home()) {
   if (!PLAIN_ID.test(String(sessionId || ""))) return null;
@@ -204,7 +207,7 @@ export function t3Thread(sessionId, home = t3Home()) {
   // The id is checked above: letters, digits and . _ : - only.
   const parts = [];
   if (tables.has("orchestration_v2_projection_provider_threads")) parts.push(`select thread_id, updated_at as at from orchestration_v2_projection_provider_threads where thread_id is not null and json_extract(payload_json, '$.nativeThreadRef.nativeId') = '${sessionId}'`);
-  if (tables.has("orchestration_v2_projection_threads")) parts.push(`select thread_id, updated_at as at from orchestration_v2_projection_threads where deleted_at is null and thread_id in ('import:claudeAgent:${sessionId}', 'import:codex:${sessionId}')`);
+  if (tables.has("orchestration_v2_projection_threads")) parts.push(`select thread_id, updated_at as at from orchestration_v2_projection_threads where deleted_at is null and thread_id in ('${sessionId}', 'import:claudeAgent:${sessionId}', 'import:codex:${sessionId}')`);
   else if (tables.has("provider_session_runtime")) parts.push(`select thread_id, last_seen_at as at from provider_session_runtime where thread_id like '%:${sessionId}' or json_extract(resume_cursor_json, '$.resume') = '${sessionId}'`);
   if (!parts.length) return null;
   return t3Query(home, `select thread_id from (${parts.join(" union all ")}) order by at desc limit 1;`) || null;
@@ -217,6 +220,49 @@ export function t3Link(threadId, home = t3Home()) {
   return threadId && PLAIN_ID.test(environment) ? `t3code://threads/${environment}/${encodeURIComponent(threadId)}` : null;
 }
 
+const realDir = (dir) => { try { return fs.realpathSync(dir); } catch { return null; } };
+
+/** The T3 Code project for a folder: the one T3 opened on the folder itself or on the repository it is in. */
+export function t3Project(folder, home = t3Home()) {
+  if (!folder || !t3Tables(home).has("projection_projects")) return null;
+  const top = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: folder, encoding: "utf8" });
+  const wanted = new Set([realDir(folder), top.status === 0 ? realDir(top.stdout.trim()) : null].filter(Boolean));
+  const rows = (t3Query(home, "select project_id || char(9) || workspace_root from projection_projects where deleted_at is null;") || "").split("\n").map((line) => line.split("\t"));
+  const found = rows.find(([id, root]) => id && root && wanted.has(realDir(root)));
+  return found ? { id: found[0], root: realDir(found[1]) } : null;
+}
+
+/** 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);
+  if (!provider || !t3Tables(home).has("orchestration_v2_projection_threads")) return null;
+  const raw = t3Query(home, `select json_extract(payload_json, '$.modelSelection') from orchestration_v2_projection_threads where deleted_at is null and json_extract(payload_json, '$.modelSelection.instanceId') = '${provider}' order by updated_at desc limit 1;`);
+  try { const model = JSON.parse(raw || "null"); return typeof model?.model === "string" ? model : null; } catch { return null; }
+}
+
+/**
+ * The threads T3 Code is running a turn in right now for an agent: the thread, the agent's own session id there, and
+ * its folder (the thread's worktree, else its project's). Codex in T3 runs on Codex's shared background server, outside
+ * T3's app, so this is how its running sessions there are found.
+ */
+export function t3Working(agent, home = t3Home()) {
+  const provider = t3Provider(agent);
+  const tables = t3Tables(home);
+  if (!provider || !tables.has("orchestration_v2_projection_provider_threads") || !tables.has("orchestration_v2_projection_threads")) return [];
+  const projects = tables.has("projection_projects");
+  const rows = t3Query(home, `select p.thread_id || char(9) || json_extract(p.payload_json, '$.nativeThreadRef.nativeId') || char(9) || coalesce(json_extract(t.payload_json, '$.worktreePath'), ${projects ? "r.workspace_root, " : ""}'') || char(9) || p.updated_at
+    from orchestration_v2_projection_provider_threads p join orchestration_v2_projection_threads t on t.thread_id = p.thread_id${projects ? " left join projection_projects r on r.project_id = t.project_id" : ""}
+    where p.provider = '${provider}' and p.status = 'active' and t.deleted_at is null;`);
+  return (rows || "").split("\n").map((line) => line.split("\t")).filter(([thread, session]) => thread && PLAIN_ID.test(session || ""))
+    .map(([thread, session, folder, at]) => ({ thread, sessionId: session, folder: folder || null, at: Date.parse(at) || 0 }));
+}
+
+/** True while T3 Code is open on this computer. */
+export function t3Open() {
+  const running = spawnSync(PS, ["-axo", "comm="], { encoding: "utf8", maxBuffer: 16 << 20 }).stdout || "";
+  return /\/T3 Code\b[^/\n]*\.app\/Contents\/MacOS\//.test(running);
+}
+
 /** How many threads the person ran an agent in T3 Code since a time: threads T3 itself ran (an import it never ran is not use). */
 export function t3Runs(agent, sinceIso, home = t3Home()) {
   const provider = AGENTS[agent]?.t3;

package/lib/runner.mjs

@@ -14,6 +14,13 @@ export function stopAgentTask(runId) {
   return true;
 }
 
+/** A run another app carries out (T3 Code, t3.mjs): Stop reaches it through `stop`. Returns its release. */
+export function trackRun(runId, stop) {
+  const entry = { pid: null, kill: stop };
+  children.set(runId, entry);
+  return () => { if (children.get(runId) === entry) children.delete(runId); };
+}
+
 /** 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);
@@ -105,6 +112,8 @@ const brief = (input) => {
 };
 export function stepsOf(event) {
   if (!event || typeof event !== "object") return [];
+  // A step as Harness writes it for a run another app carries out (t3.mjs).
+  if (event.type === "harness.step" && (event.kind === "say" || event.kind === "do") && typeof event.text === "string") return [{ kind: event.kind, text: event.text }];
   if (event.type === "assistant" && Array.isArray(event.message?.content)) {
     return event.message.content.flatMap((block) => block.type === "text" && block.text?.trim() ? [{ kind: "say", text: block.text.trim() }]
       : block.type === "tool_use" ? [{ kind: "do", text: `${block.name}: ${brief(block.input)}` }] : []);

package/lib/runtime-install.mjs

@@ -76,7 +76,7 @@ export function installRuntime({ sourceRoot, version }) {
       if (!fs.existsSync(source)) continue;
       fs.cpSync(source, path.join(staging, entry), { recursive: true, force: true });
     }
-    copyDependencyClosure(sourceRoot, staging, ["node-sqlite3-wasm", "ws", "onnxruntime-web", "@huggingface/tokenizers"]);
+    copyDependencyClosure(sourceRoot, staging, ["node-sqlite3-wasm", "ws", "onnxruntime-web", "@huggingface/tokenizers", "@clack/prompts", "@clack/core", "picocolors"]);
     fs.writeFileSync(path.join(staging, ".ready"), version + "\n", { mode: 0o600 });
     ensureDir(path.dirname(release));
     fs.rmSync(release, { recursive: true, force: true });

package/lib/t3.mjs

@@ -5,6 +5,7 @@ import path from "node:path";
 import { readJson, writeJsonAtomic } from "./files.mjs";
 import { paths } from "./paths.mjs";
 import { t3Home } from "./places.mjs";
+import { trackRun } from "./runner.mjs";
 
 // T3 Code's door for agents it did not start (its /mcp; T3's docs/user/outside-agents.md). Harness signs in once and the
 // person approves it inside T3, choosing what it may do; T3 asks for a pairing code from its Settings → Connections, and
@@ -151,8 +152,8 @@ async function callTool(origin, token, name, args) {
   }
 }
 
-/** Sends the person's words into a T3 Code thread: "started" or "queued" behind its turn. */
-export async function sendToT3(threadId, text) {
+/** One of T3's tools, as Harness was approved to use them, at T3's current address. */
+async function t3Tool(name, args) {
   const saved = readJson(file(), null);
   const access = t3Access();
   if (!access) throw new T3Error("not_connected", "Harness is not approved in T3 Code yet.");
@@ -163,10 +164,101 @@ export async function sendToT3(threadId, text) {
   if (!t3 || t3.environmentId !== saved.environmentId) throw new T3Error("not_running", "T3 Code is not running on this computer.");
   if (t3.origin !== saved.origin) writeJsonAtomic(file(), { ...saved, origin: t3.origin });
   try {
-    const sent = await callTool(t3.origin, saved.token, "t3_thread_send", { threadId, message: text, mode: "queue", clientRequestId: randomUUID() });
-    return sent.delivery === "queued" ? "queued" : "started";
+    return await callTool(t3.origin, saved.token, name, args);
   } catch (error) {
     if (error.code === "expired") writeJsonAtomic(file(), { ...saved, expiresAt: new Date(0).toISOString() });
     throw error;
   }
 }
+
+/** Sends the person's words into a T3 Code thread: "started" or "queued" behind its turn. */
+export async function sendToT3(threadId, text) {
+  const sent = await t3Tool("t3_thread_send", { threadId, message: text, mode: "queue", clientRequestId: randomUUID() });
+  return sent.delivery === "queued" ? "queued" : "started";
+}
+
+// ── A thread's turn, carried out by T3 Code ──────────────────────────────────
+
+// How often a turn handed to T3 is read back for its steps and its end: as often as the buddy reads a session's feed.
+const READ_MS = 2_000;
+const SETTLED = new Set(["completed", "failed", "cancelled", "interrupted"]);
+const ENDED = new Set(["interrupted", "failed", "cancelled", "rolled_back"]);
+const handed = new Map();
+
+/** The T3 threads running a turn Harness handed them: Harness's runs, not the person's own sessions. */
+export const handedToT3 = () => new Set(handed.values());
+
+/** One item of a T3 thread as a step on the board: its words, or what it did in a line. */
+function stepOf(item) {
+  const text = String(item.text || "").trim();
+  if (item.type === "assistant_message") return text ? { kind: "say", text } : null;
+  if (item.type === "command_execution") return { kind: "do", text: `ran: ${(item.title === "Workspace ready" ? item.title : text.split("\n")[0].replace(/^\$\s*/, "")).slice(0, 200)}` };
+  if (item.type === "web_search") return { kind: "do", text: "searched the web" };
+  if (["user_message", "reasoning", "checkpoint"].includes(item.type)) return null;
+  return { kind: "do", text: `${item.title || String(item.type).replace(/_/g, " ")}`.slice(0, 200) };
+}
+
+/**
+ * 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,
+ * 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.
+ */
+export function runInT3(run, emit, observe) {
+  let threadId = run.threadId ?? null, runId = null, cursor = null, timer = null, stopped = false, last = "";
+  const seen = new Set();
+  const interrupt = () => t3Tool("t3_thread_interrupt", { threadId, ...(runId ? { runId } : {}), reason: "Stopped from Harness.", clientRequestId: `${run.runId}:stop` }).catch(() => {});
+  const release = trackRun(run.runId, () => { stopped = true; if (threadId) void interrupt(); });
+  const finish = (kind, text) => { clearTimeout(timer); handed.delete(run.runId); release(); emit(kind, text.slice(0, 20_000), { usage: null }); };
+  const read = async () => {
+    try {
+      let page, after = cursor, settled = true;
+      do {
+        page = await t3Tool("t3_thread_read", { threadId, view: "activity", limit: 100, maxCharsPerItem: 20_000, runLimit: 5, ...(after === null ? {} : { afterPosition: after }) });
+        for (const item of page.items ?? []) {
+          if (item.runId === runId && SETTLED.has(item.status) && !seen.has(item.itemId)) {
+            seen.add(item.itemId);
+            const step = stepOf(item);
+            if (step) {
+              if (step.kind === "say") last = step.text;
+              observe("stdout", `${JSON.stringify({ type: "harness.step", ...step })}\n`);
+              emit("progress", step.text.slice(0, 200), { step });
+            }
+          }
+          // Read again from the first item still going; everything before it is settled.
+          settled &&= SETTLED.has(item.status);
+          if (settled) cursor = item.position;
+        }
+        after = page.nextPosition ?? after;
+      } while (page.hasMore && page.items?.length);
+      if (page.thread?.worktreePath) run.onWorktree?.(page.thread.worktreePath, page.thread.branch ?? null);
+      const status = (page.recentRuns ?? []).find((entry) => entry.runId === runId)?.status;
+      if (status === "completed") return finish("done", last || "The run finished in T3 Code; its changes are in T3's checkout.");
+      if (ENDED.has(status)) return finish("failed", stopped ? "Stopped." : `T3 Code ended the turn (${status})${last ? `: ${last}` : "."}`);
+    } catch (error) {
+      if (["expired", "not_connected", "read_only"].includes(error.code)) return finish("failed", `${error.message} The turn may still be going in T3 Code.`);
+      // T3 restarting or busy: read again next time.
+    }
+    timer = setTimeout(() => void read(), READ_MS);
+  };
+  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 });
+        threadId = launched.threadId;
+        runId = launched.runId ?? null;
+        run.onThread?.(threadId);
+      }
+      if (!threadId || !runId) throw new T3Error("t3", "T3 Code did not say which thread and turn it started");
+      handed.set(run.runId, threadId);
+      emit("session", threadId, { cwd: run.cwd });
+      if (stopped) await interrupt();
+      void read();
+    } catch (error) {
+      finish("failed", `T3 Code did not take it: ${error.message}`);
+    }
+  })();
+}

package/lib/ui.mjs

@@ -0,0 +1,111 @@
+import * as p from "@clack/prompts";
+import { TextPrompt } from "@clack/core";
+import pc from "picocolors";
+
+// Setup's terminal interface, in the style of @clack/prompts (the skills installer's): a rail of steps, arrow-key
+// menus, spinners while waiting. createUi draws it; scriptedUi answers from a list and keeps what a person would have
+// seen, for tests. Prompts return null when the person cancels (Ctrl-C), so setup can skip that part and go on.
+
+const unicode = process.platform !== "win32" || Boolean(process.env.WT_SESSION) || process.env.TERM_PROGRAM === "vscode";
+const glyph = (fancy, plain) => (unicode ? fancy : plain);
+const BAR = glyph("│", "|"), END = glyph("└", "—"), ACTIVE = glyph("◆", "*"), DONE = glyph("◇", "o"), STOP = glyph("■", "x"), WARN = glyph("▲", "!");
+
+const visible = (text) => text.replace(/\x1b\[[0-9;]*m/g, "").length;
+
+/** Lines of text wrapped to a width, each keeping its own indent. */
+export function wrap(text, width) {
+  return text.split("\n").flatMap((line) => {
+    if (!line.trim()) return [""];
+    const indent = " ".repeat(line.length - line.trimStart().length), room = Math.max(20, width - indent.length), rows = [];
+    let row = "";
+    for (const word of line.trim().split(" ")) {
+      if (row && visible(row) + 1 + visible(word) > room) { rows.push(row); row = word; } else row = row ? `${row} ${word}` : word;
+    }
+    return [...rows, row].map((part) => `${indent}${part}`);
+  });
+}
+
+export const columns = () => process.stdout.columns || 100;
+
+// A text prompt Harness can close: shown while something else may finish first (Grok registering itself). `until`
+// resolves to { ok, line }; the prompt then closes with that line. Returns { value } when the person types and presses
+// Enter, { done } when `until` won, or { cancelled: true }.
+async function waitOrType({ message, placeholder, until }) {
+  const stop = new AbortController();
+  let done = null;
+  void until.then((result) => { done = result; stop.abort(); });
+  const value = await new TextPrompt({
+    placeholder,
+    signal: stop.signal,
+    render() {
+      const head = (symbol) => `${pc.gray(BAR)}\n${symbol}  ${message}\n`;
+      if (this.state === "submit") return `${head(pc.green(DONE))}${pc.gray(BAR)}  ${pc.dim(this.value || "keep waiting")}`;
+      if (this.state === "cancel" && done) return `${pc.gray(BAR)}\n${done.ok ? pc.green(DONE) : pc.yellow(WARN)}  ${done.line}`;
+      if (this.state === "cancel") return `${head(pc.red(STOP))}${pc.gray(BAR)}  ${pc.dim("stopped")}`;
+      const shown = this.value ? this.valueWithCursor : `${pc.inverse(placeholder[0])}${pc.dim(placeholder.slice(1))}`;
+      return `${head(pc.cyan(ACTIVE))}${pc.cyan(BAR)}  ${shown}\n${pc.cyan(END)}\n`;
+    },
+  }).prompt();
+  if (done) return { done };
+  if (p.isCancel(value)) return { cancelled: true };
+  return { value: String(value ?? "").trim() };
+}
+
+export function createUi({ interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) } = {}) {
+  const answer = (value) => (p.isCancel(value) ? null : value);
+  // clack does not wrap; a long line would run back to the left edge, off the rail.
+  const fit = (text) => wrap(text, columns() - 4).join("\n");
+  return {
+    interactive,
+    intro: (title) => p.intro(title),
+    outro: (text) => p.outro(text),
+    step: (text) => p.log.step(fit(text)),
+    success: (text) => p.log.success(fit(text)),
+    info: (text) => p.log.info(fit(text)),
+    warn: (text) => p.log.warn(fit(text)),
+    message: (text) => p.log.message(fit(text)),
+    note: (text, title) => p.note(text, title),
+    select: async (opts) => answer(await p.select(opts)),
+    text: async (opts) => answer(await p.text(opts)),
+    password: async (opts) => answer(await p.password(opts)),
+    confirm: async (opts) => answer(await p.confirm(opts)),
+    // clack's spinner stops on Ctrl-C but keeps the process alive; setup ends there instead. Without a terminal (piped
+    // or logged) it is two plain lines, not animation frames.
+    spinner: () => {
+      if (!process.stdout.isTTY) return { start: (text) => p.log.message(fit(text)), message: () => {}, stop: (text, code) => (code ? p.log.warn : p.log.step)(fit(text)) };
+      const spin = p.spinner(), quit = () => process.exit(130);
+      return {
+        start: (text) => { spin.start(text); process.once("SIGINT", quit); },
+        message: (text) => spin.message(text),
+        stop: (text, code) => { process.removeListener("SIGINT", quit); spin.stop(text, code); },
+      };
+    },
+    waitOrType,
+  };
+}
+
+/** The same interface answered from `answers` in order (undefined takes the default); `lines` is what was shown. */
+export function scriptedUi(answers = [], lines = []) {
+  const say = (symbol) => (text) => { lines.push(...`${symbol} ${text}`.split("\n")); };
+  const next = (fallback) => { const value = answers.shift(); return value === undefined ? fallback : value; };
+  const ask = async (opts) => { lines.push(`? ${opts.message}`); const value = next(null); if (value !== null) lines.push(`  ${value}`); return value; };
+  return {
+    interactive: true,
+    lines,
+    intro: say("┌"), outro: say("└"), step: say("◇"), success: say("◆"), info: say("●"), warn: say("▲"), message: say("│"),
+    note: (text, title) => { lines.push(`[${title}]`, ...text.split("\n")); },
+    select: async (opts) => { lines.push(`? ${opts.message}`, ...opts.options.map((option) => `  ${option.label}${option.hint ? ` (${option.hint})` : ""}`)); return next(opts.initialValue ?? opts.options[0].value); },
+    text: ask,
+    password: async (opts) => { lines.push(`? ${opts.message}`); return next(null); },
+    confirm: async (opts) => { lines.push(`? ${opts.message}`); return next(opts.initialValue ?? true); },
+    spinner: () => ({ start: say("◒"), message: () => {}, stop: (text, code = 0) => say(code ? "▲" : "◇")(text) }),
+    waitOrType: async ({ message, until }) => {
+      lines.push(`? ${message}`);
+      const value = next("");
+      if (value) return { value };
+      const done = await until;
+      lines.push(`${done.ok ? "◇" : "▲"} ${done.line}`);
+      return { done };
+    },
+  };
+}

package/lib/worktrees.mjs

@@ -37,6 +37,7 @@ export function createWorktrees({ store, root }) {
     if (!folder) return null;
     const current = get(thread.id);
     if (current?.state === "in_place") return folder;
+    if (current?.state === "t3") return current.path && fs.existsSync(current.path) ? current.path : folder;
     if (current && current.state === "open" && fs.existsSync(current.path)) return path.join(current.path, current.inside);
     const repo = repositoryOf(folder);
     if (!repo) return folder;
@@ -86,7 +87,8 @@ export function createWorktrees({ store, root }) {
 
   const summary = (threadId) => {
     const tree = get(threadId);
-    if (!tree || tree.state === "in_place") return null;
+    // A thread T3 Code works in keeps its changes in T3's own checkout, where T3 shows and merges them.
+    if (!tree || tree.state === "in_place" || tree.state === "t3") return null;
     const files = tree.state === "open" && fs.existsSync(tree.path) ? stat(tree.path, `${tree.base}..HEAD`).length : 0;
     return { state: tree.state, branch: tree.branch, repo: tree.repo, files };
   };
@@ -128,5 +130,25 @@ export function createWorktrees({ store, root }) {
   /** 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" });
 
-  return { folderFor, commitTurn, diff, summary, merge, discard, inPlace, get };
+  /**
+   * 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; before that, 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 === "t3" && 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" };
+    const branch = git(repo.root, ["rev-parse", "--abbrev-ref", "HEAD"]).out;
+    return { type: "worktree", baseRef: branch && branch !== "HEAD" ? branch : git(repo.root, ["rev-parse", "HEAD"]).out,
+      branch: `harness/${slug(thread.objective)}-${thread.id.slice(0, 8)}`, startFromOrigin: false };
+  };
+  /** 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, { state: "t3", path: where ?? current?.path ?? null, branch: branch ?? current?.branch ?? null });
+  };
+
+  return { folderFor, commitTurn, diff, summary, merge, discard, inPlace, t3Workspace, inT3, get };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.7.10",
+  "version": "0.7.16",
   "description": "Harness Relay: the daemon that turns the agents on this machine into your personal swarm. Memory, history, and work handed between any of them.",
   "bin": {
     "tryharness": "cli.mjs"
@@ -29,15 +29,18 @@
   "homepage": "https://tryharness.ai",
   "license": "MIT",
   "dependencies": {
+    "@clack/core": "0.5.0",
+    "@clack/prompts": "0.11.0",
+    "@huggingface/tokenizers": "^0.1.3",
     "node-sqlite3-wasm": "0.8.60",
+    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c",
+    "picocolors": "^1.1.1",
     "qr": "0.4.2",
-    "ws": "^8.18.3",
-    "@huggingface/tokenizers": "^0.1.3",
-    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c"
+    "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "tryharness-desktop-darwin-arm64": "0.7.10",
-    "tryharness-desktop-darwin-x64": "0.7.10",
+    "tryharness-desktop-darwin-arm64": "0.7.16",
+    "tryharness-desktop-darwin-x64": "0.7.16",
     "tryharness-desktop-linux-x64": "0.7.4",
     "tryharness-desktop-win32-x64": "0.7.4"
   }