tryharness 0.7.13 → 0.7.18

package/cli.mjs

@@ -16,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" });
@@ -167,7 +167,12 @@ async function connect() {
   } catch (error) {
     ui.warn(`Browser not connected (${error.message}). Run: npx tryharness link`);
   }
-  if (!has("--no-desktop")) { const shown = desktop(); (shown.ok ? ui.success : ui.info)(shown.text); }
+  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);
+  }
   // 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.
   if (modelPresent(paths.models)) ui.success("Embedder ready");
@@ -186,14 +191,14 @@ async function connect() {
   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() {
+async function desktop() {
   if (!canShowDesktop({})) return { ok: false, text: "Desktop app skipped (no screen on this login)" };
-  const source = desktopSource({ sourceRoot: SOURCE_ROOT });
-  if (!source) return { ok: false, text: `No desktop app for ${process.platform} ${process.arch} yet` };
   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 });
     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) {
@@ -721,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") { const shown = desktop(); console.log(shown.text); if (!shown.ok) 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,33 @@ 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 in Harness's own copy moves into T3 on its next turn, in that same checkout (a git
+  // worktree of T3's project, which T3 takes as it is); one 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);
+    if (tree?.state === "t3") return true;
+    if (tree && !(tree.state === "open" && fs.existsSync(tree.path))) return false;
+    return 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 +645,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 +955,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.
@@ -999,9 +1032,10 @@ export async function startDaemon() {
       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.
+      // and the session can still be resumed in a terminal instead. Until Harness may send into T3, its threads run in
+      // that copy: approving it is what moves them into T3 (inT3).
       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."
+        ? `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.${t3Access()?.state === "send" ? "" : " Approve Harness in T3 Code and this thread's next turns run there, where Open finds them."}`
         : "T3 Code doesn't list this session, so it is in front as it is." };
     }
     if (place.kind === "editor") {
@@ -1046,6 +1080,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 +1446,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 +1455,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 +1492,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 +1862,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/places.mjs

@@ -3,6 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
+import { mainCheckout } from "./worktrees.mjs";
 
 // Where a coding session runs, and how it opens there again. A session's place comes from its own environment: the
 // Harness piece inside the agent sends it when the session starts (the Claude Code and Codex hooks, nudge.mjs; the
@@ -154,6 +155,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 +199,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 +208,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 +221,51 @@ 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 root = top.status === 0 ? top.stdout.trim() : null;
+  // A worktree of a project's checkout (a thread's copy here, T3's own) is that project's, as T3 counts it.
+  const wanted = new Set([realDir(folder), root && realDir(root), root && realDir(mainCheckout(root))].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/swarm.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { readRunSteps } from "./runner.mjs";
+import { mainCheckout } from "./worktrees.mjs";
 import { nameOf, resolveMember } from "./members.mjs";
 import { setNote, swarmBlock, swarmCards, swarmDigest } from "./cards.mjs";
 
@@ -221,9 +222,11 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
         team.add(agentName);
         folder ??= isDir(session.cwd) ? session.cwd : null;
       }
-      // Where the work happens: the named agent's last folder, else the latest coding session's on this computer.
-      folder ??= [...team].map((name) => PROCESS_NAMES[name] ? lastFolder(name) : null).find(Boolean)
+      // Where the work happens: the named agent's last folder, else the latest coding session's on this computer; one in
+      // a worktree (a thread's copy here, T3 Code's) is the repository's own checkout, where the person works.
+      const last = [...team].map((name) => PROCESS_NAMES[name] ? lastFolder(name) : null).find(Boolean)
         ?? store.recentSessions(100).find((session) => PROCESS_NAMES[session.agent] && isDir(session.cwd))?.cwd ?? null;
+      folder ??= last ? mainCheckout(last) : null;
       const objective = text.split("\n").map((line) => line.trim()).find(Boolean).replace(/@([a-z][a-z0-9-]*)\s*/g, "").slice(0, 120) || text.slice(0, 120);
       const thread = store.createGoal({ objective, originAgent: "user", provenance: provenanceFor("user"), team: [...team, "harness"], facilitator: "harness", workspace: folder ? path.resolve(folder) : null, maxPosts: defaults.maxPosts, maxWakes: defaults.maxWakes });
       if (from) { store.setGoalSession(thread.id, String(from.agent), nativeSessionId(String(from.agent), String(from.sessionId))); worktrees.inPlace(thread.id); }

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/worktrees.mjs

@@ -24,6 +24,21 @@ export function repositoryOf(folder) {
   return { root: fs.realpathSync(top.out), inside: path.relative(fs.realpathSync(top.out), fs.realpathSync(folder)) };
 }
 
+/**
+ * The folder a linked git worktree stands for: the same place in its repository's main checkout. A thread's copy here,
+ * T3 Code's and the person's own are all worktrees of the checkout the person works in (T3 counts their history as
+ * that checkout's too). Any other folder is itself.
+ */
+export function mainCheckout(folder) {
+  if (!folder || !fs.existsSync(folder)) return folder;
+  const found = git(folder, ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"]);
+  const [top, common] = found.ok ? found.out.split("\n") : [];
+  if (!top || !common || path.basename(common) !== ".git") return folder;
+  const main = path.dirname(common);
+  if (!fs.existsSync(main) || fs.realpathSync(main) === fs.realpathSync(top)) return folder;
+  return path.join(main, path.relative(fs.realpathSync(top), fs.realpathSync(folder)));
+}
+
 const slug = (text) => String(text).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32) || "thread";
 
 export function createWorktrees({ store, root }) {
@@ -37,6 +52,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 +102,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 +145,26 @@ 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, or the thread's own copy when it worked here before; else a new one on its own
+   * branch from what the person has checked out (as folderFor's), or T3's project folder when the thread's folder is in
+   * no repository.
+   */
+  const t3Workspace = (thread) => {
+    const current = get(thread.id);
+    if ((current?.state === "t3" || current?.state === "open") && current.path) return { type: "existing_worktree", worktreePath: current.path, ...(current.branch ? { branch: current.branch } : {}) };
+    const repo = repositoryOf(thread.goal.workspace);
+    if (!repo) return { type: "root" };
+    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, { ...current, 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.13",
+  "version": "0.7.18",
   "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"
@@ -39,8 +39,8 @@
     "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.17",
+    "tryharness-desktop-darwin-x64": "0.7.17",
     "tryharness-desktop-linux-x64": "0.7.4",
     "tryharness-desktop-win32-x64": "0.7.4"
   }