tryharness 0.7.16 → 0.7.18

package/lib/daemon.mjs

@@ -601,13 +601,15 @@ export async function startDaemon() {
   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.
+  // 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)?.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));
+    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.
@@ -1030,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") {

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
@@ -226,7 +227,9 @@ const realDir = (dir) => { try { return fs.realpathSync(dir); } catch { return n
 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 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;

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/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 }) {
@@ -132,12 +147,13 @@ export function createWorktrees({ store, root }) {
 
   /**
    * 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.
+   * 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.path) return { type: "existing_worktree", worktreePath: current.path, ...(current.branch ? { branch: current.branch } : {}) };
+    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;
@@ -147,7 +163,7 @@ export function createWorktrees({ store, root }) {
   /** The thread works in T3 Code from now on; `where` and `branch` once T3 has made its checkout. */
   const inT3 = (threadId, where = null, branch = null) => {
     const current = get(threadId);
-    if (current?.state !== "t3" || (where && where !== current.path)) save(threadId, { state: "t3", path: where ?? current?.path ?? null, branch: branch ?? current?.branch ?? null });
+    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.16",
+  "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.16",
-    "tryharness-desktop-darwin-x64": "0.7.16",
+    "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"
   }