tryharness 0.7.4 → 0.7.6

package/lib/swarm.mjs

@@ -0,0 +1,224 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { readRunSteps } from "./runner.mjs";
+
+// The person's swarm as threads. A thread is a goal under the hood: its room is the transcript, its team the agents in
+// it, its folder where coding agents work, and it runs on its own authority. A message the person sends wakes the
+// agents it names (or the only agent in the thread), each resuming its own session; their runs' steps are read back
+// from the run logs. The person's own terminal sessions are listed too and continue in a thread once idle.
+
+const PROCESS_NAMES = { "claude-code": "claude", codex: "codex", pi: "pi", opencode: "opencode" };
+const SAY_LIMIT = 4_000;
+const UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+
+// The id an agent resumes a session by: the index keys sessions by their file name.
+export function nativeSessionId(agent, sessionId) {
+  const bare = String(sessionId).replace(/\.jsonl$/, "");
+  return agent === "codex" ? bare.match(UUID)?.[0] ?? bare : bare;
+}
+
+// The folder each running coding agent works in, by agent, leaving out the runs the daemon started itself.
+// Null when the machine cannot say, and every session then counts as open in a terminal.
+export function agentProcessCwds(exclude = new Set()) {
+  if (process.platform === "win32") return null;
+  const ps = spawnSync("ps", ["-axo", "pid=,comm="], { encoding: "utf8" });
+  if (ps.status !== 0) return null;
+  const byPid = new Map();
+  for (const line of ps.stdout.split("\n")) {
+    const match = line.trim().match(/^(\d+)\s+(.+)$/);
+    if (!match || exclude.has(Number(match[1]))) continue;
+    const agent = Object.keys(PROCESS_NAMES).find((name) => path.basename(match[2]) === PROCESS_NAMES[name]);
+    if (agent) byPid.set(match[1], agent);
+  }
+  const cwds = new Map();
+  if (!byPid.size) return cwds;
+  const lsof = spawnSync("lsof", ["-a", "-d", "cwd", "-Fn", "-p", [...byPid.keys()].join(",")], { encoding: "utf8" });
+  if (lsof.status !== 0 && !lsof.stdout) return null;
+  let pid = null;
+  for (const line of lsof.stdout.split("\n")) {
+    if (line.startsWith("p")) pid = line.slice(1);
+    else if (line.startsWith("n") && byPid.has(pid)) {
+      const agent = byPid.get(pid);
+      if (!cwds.has(agent)) cwds.set(agent, new Set());
+      cwds.get(agent).add(line.slice(1));
+    }
+  }
+  return cwds;
+}
+
+export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoard, goalCommand, stopThreadRuns, runLog, runningPids, provenanceFor, defaults, coordinator, worktrees, roster }) {
+  const isDir = (folder) => typeof folder === "string" && path.isAbsolute(folder) && fs.statSync(folder, { throwIfNoEntry: false })?.isDirectory();
+  const agentsOf = (thread) => thread.goal.team.filter((agent) => agent !== thread.goal.facilitator);
+
+  // Who a message is for: the agents it names, else the only agent in the thread, else whoever coordinates.
+  const addressed = (thread, text) => {
+    const named = mentionsIn(text, thread.goal.team);
+    if (named.length) return named;
+    const agents = agentsOf(thread);
+    return agents.length === 1 ? agents : [thread.goal.facilitator];
+  };
+
+  // What the thread waits on the person for, if anything: a pause, an agent's question, a run's question.
+  const waitingOn = (thread, posts, runs) => {
+    if (thread.status === "paused") return { kind: "paused", text: thread.goal.paused_reason || "Paused." };
+    const asking = runs.find((run) => run.status === "needs_input" && run.holder === "user");
+    if (asking) return { kind: "question", agent: asking.claimed_by || asking.target_agent, text: asking.result || "" };
+    const lastMine = posts.findLastIndex((post) => post.author === "user");
+    const question = posts.slice(lastMine + 1).findLast((post) => post.kind === "question");
+    return question ? { kind: "question", agent: question.author, text: question.text } : null;
+  };
+
+  const summary = (thread) => {
+    const posts = store.roomPosts(thread.id, 0, 500);
+    const runs = store.threadRuns(thread.id);
+    const last = posts.at(-1);
+    const live = runs.find((run) => run.status === "running");
+    const step = live ? readRunSteps(runLog(live.id), 1)[0] : null;
+    return {
+      id: thread.id, title: thread.objective, status: thread.status, agents: agentsOf(thread), coordinator: thread.goal.facilitator,
+      folder: thread.goal.workspace, working: [...new Set(runs.filter((run) => ["claimed", "running"].includes(run.status)).map((run) => run.target_agent))],
+      queued: [...new Set(runs.filter((run) => run.status === "open").map((run) => run.target_agent))],
+      step: step ? { agent: live.claimed_by || live.target_agent, kind: step.kind, text: step.text.split("\n")[0].slice(0, 200) } : null,
+      waiting: waitingOn(thread, posts, runs), last: last ? { author: last.author, kind: last.kind, text: last.text.slice(0, 280), at: last.created_at } : null,
+      posts: thread.goal.posts, spend: thread.goal.spend, createdAt: thread.created_at, updatedAt: last?.created_at ?? thread.updated_at,
+      // Parts the swarm moved past: never silent, one tap sends one back.
+      openItems: posts.filter((post) => post.kind === "open_item").map((post) => ({ seq: post.seq, text: post.text })),
+      coordination: { mode: coordinator.mode(), rounds: coordinator.state(thread.id).rounds },
+      changes: worktrees.summary(thread.id),
+    };
+  };
+
+  // The person's terminal sessions not yet in a thread, newest first, each saying whether it is still open there.
+  const sessions = () => {
+    const live = agentProcessCwds(new Set(runningPids()));
+    const newestIn = new Set();
+    return store.recentSessions(30).filter((session) => PROCESS_NAMES[session.agent] && !store.threadForSession(session.agent, nativeSessionId(session.agent, session.session_id))).map((session) => {
+      const key = `${session.agent}:${session.cwd}`;
+      const newest = !newestIn.has(key);
+      newestIn.add(key);
+      const open = live === null || (newest && Boolean(live.get(session.agent)?.has(session.cwd)));
+      return { agent: session.agent, sessionId: session.session_id, title: session.title, folder: session.cwd, startedAt: session.started_at, endedAt: session.ended_at, messages: session.message_count, open };
+    });
+  };
+
+  const sessionOpen = (agent, sessionId) => sessions().find((session) => session.agent === agent && session.sessionId === sessionId)?.open ?? false;
+
+  const lastFolder = (agent) => store.recentSessions(100).find((session) => session.agent === agent && isDir(session.cwd))?.cwd ?? null;
+
+  const read = (thread) => {
+    const runs = store.threadRuns(thread.id).map((run) => ({
+      id: run.id, agent: run.claimed_by || run.target_agent, kind: run.kind, status: run.status, startedAt: run.created_at, endedAt: run.reported_at,
+      sessionId: run.session_id, folder: run.run_workspace, usage: run.usage,
+      steps: readRunSteps(runLog(run.id), 300).map((step) => ({ ...step, text: step.text.slice(0, SAY_LIMIT) })),
+    }));
+    return { ok: true, thread: summary(thread), posts: store.roomPosts(thread.id, 0, 500), runs };
+  };
+
+  const post = (thread, text) => {
+    // A new name in the person's message joins the thread.
+    const joining = mentionsIn(text, roomAgents).filter((agent) => !thread.goal.team.includes(agent));
+    if (joining.length) store.setGoalTeam(thread.id, [...thread.goal.team, ...joining]);
+    if (thread.status !== "open") {
+      store.setGoalState(thread.id, { status: "open" });
+      store.roomPost({ goalId: thread.id, author: "user", kind: "note", text: "Picked up again by you." });
+    }
+    const current = store.getTask(thread.id);
+    return goalCommand({ command: "board.room.post", id: thread.id, text, mentions: addressed(current, text) }, "user");
+  };
+
+  return function swarmCommand(request, agent) {
+    const command = String(request.command);
+    if (command === "board.swarm.list") {
+      if (agent !== "user" && agent !== "harness") return { ok: false, error: "only the person and Harness read the swarm" };
+      return { ok: true, threads: store.goals({ all: request.all === true }).map(summary), sessions: request.sessions === false ? [] : sessions(), agents: roster() };
+    }
+    // The swarm's shared memory, for any of the person's agents: what any agent wrote in any thread, and the coding
+    // sessions on this machine. A caller limited to its own threads (a hosted agent while the machine is sealed) gets only those.
+    if (command === "board.swarm.search") {
+      const query = String(request.query || "").trim().slice(0, 500);
+      if (!query) return { ok: false, error: "search needs a query" };
+      const mine = request.teamOnly ? store.goals({ all: true }).filter((thread) => thread.goal.team.includes(agent)).map((thread) => thread.id) : null;
+      return { ok: true, threads: store.searchThreads(query, { goalIds: mine, k: 8 }), sessions: request.teamOnly ? [] : store.search({ query, limit: 5 }) };
+    }
+    if (agent !== "user") return { ok: false, error: "only the person starts, writes in, stops or resumes a thread" };
+    // The coordinator's record: what each round saw, chose and cost. The evidence for its limits.
+    if (command === "board.swarm.rounds") return { ok: true, rounds: store.rounds(request.id ? String(request.id) : null, request.limit) };
+    if (command === "board.swarm.coordinator") {
+      if (request.mode === "harness" || request.mode === "local") coordinator.setMode(request.mode);
+      return { ok: true, mode: coordinator.mode() };
+    }
+    if (command === "board.swarm.stop_all") {
+      const stopped = store.goals().filter((thread) => thread.status === "open").map((thread) => { stopThreadRuns(thread.id); return thread.id; });
+      return { ok: true, stopped };
+    }
+    if (command === "board.swarm.start") {
+      const text = String(request.text || "").trim().slice(0, 20_000);
+      if (!text) return { ok: false, error: "a thread starts with a message" };
+      const from = request.continueSession && typeof request.continueSession === "object" ? request.continueSession : null;
+      let folder = request.folder ? String(request.folder) : null;
+      if (folder && !isDir(folder)) return { ok: false, error: `${folder} is not an absolute path to a folder` };
+      const team = new Set(mentionsIn(text, roomAgents));
+      if (from) {
+        const agentName = String(from.agent || ""), sessionId = String(from.sessionId || "");
+        if (!PROCESS_NAMES[agentName]) return { ok: false, error: "only a coding agent's session continues in a thread" };
+        const session = store.read({ agent: agentName, sessionId });
+        if (!session) return { ok: false, error: "session not found" };
+        const already = store.threadForSession(agentName, nativeSessionId(agentName, sessionId));
+        if (already) return post(store.getTask(already), text);
+        if (sessionOpen(agentName, sessionId)) return { ok: false, error: "that session is still open in a terminal; it continues here once it is closed there" };
+        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)
+        ?? store.recentSessions(100).find((session) => PROCESS_NAMES[session.agent] && isDir(session.cwd))?.cwd ?? 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); }
+      const opened = store.getTask(thread.id);
+      const first = store.roomPost({ goalId: thread.id, author: "user", kind: "post", text, mentions: addressed(opened, text) });
+      wakeFor(thread.id, first, "user");
+      notifyBoard(store.getTask(thread.id));
+      return { ok: true, thread: summary(store.getTask(thread.id)) };
+    }
+    const thread = store.getTask(String(request.id || ""));
+    if (!thread || thread.kind !== "goal") return { ok: false, error: "thread not found" };
+    if (command === "board.swarm.read") return read(thread);
+    if (command === "board.swarm.diff") return worktrees.diff(thread.id, request.runId ? String(request.runId) : null);
+    if (command === "board.swarm.merge" || command === "board.swarm.discard") {
+      // Both change the person's repository, so both wait for the person, and never while an agent is changing files.
+      if (store.threadRuns(thread.id).some((run) => ["open", "claimed", "running"].includes(run.status))) return { ok: false, error: "an agent is still working in this thread; stop it or wait for it first" };
+      const done = command === "board.swarm.merge" ? worktrees.merge(thread.id, thread.objective) : worktrees.discard(thread.id);
+      if (done.ok) store.roomPost({ goalId: thread.id, author: "user", kind: "note", text: command === "board.swarm.merge" ? `Merged into ${done.into}.` : "Discarded this thread's changes." });
+      else if (done.conflict) store.roomPost({ goalId: thread.id, author: thread.goal.facilitator, kind: "question", text: `${done.error[0].toUpperCase()}${done.error.slice(1)}. Resolve it in your checkout, or ask an agent here to bring the thread's branch up to date first.` });
+      notifyBoard(store.getTask(thread.id));
+      return done.ok ? { ok: true, thread: summary(store.getTask(thread.id)) } : done;
+    }
+    if (command === "board.swarm.post") {
+      const text = String(request.text || "").trim().slice(0, 20_000);
+      if (!text) return { ok: false, error: "a message needs text" };
+      const posted = post(thread, text);
+      return posted.ok ? { ...posted, thread: summary(store.getTask(thread.id)) } : posted;
+    }
+    if (command === "board.swarm.stop") {
+      if (thread.status !== "open") return { ok: false, error: `the thread is ${thread.status}` };
+      stopThreadRuns(thread.id);
+      return { ok: true, thread: summary(store.getTask(thread.id)) };
+    }
+    if (command === "board.swarm.resume") {
+      if (thread.status !== "paused") return { ok: false, error: `the thread is ${thread.status}` };
+      store.setGoalState(thread.id, { status: "open" });
+      store.roomPost({ goalId: thread.id, author: "user", kind: "note", text: "Resumed by you." });
+      notifyBoard(store.getTask(thread.id));
+      return { ok: true, thread: summary(store.getTask(thread.id)) };
+    }
+    if (command === "board.swarm.folder") {
+      const folder = String(request.folder || "");
+      if (!isDir(folder)) return { ok: false, error: `${folder} is not an absolute path to a folder` };
+      store.setGoalFolder(thread.id, path.resolve(folder));
+      return { ok: true, thread: summary(store.getTask(thread.id)) };
+    }
+    return { ok: false, error: "unknown command" };
+  };
+}

package/lib/worktrees.mjs

@@ -0,0 +1,132 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+// A coding thread's own copy of the person's repository: a git worktree on its own branch, so several threads work
+// at once without touching each other's files or the person's checkout. Each agent turn is committed on the branch,
+// which gives every turn its diff; merge and discard are the person's, never the swarm's.
+
+const IDENTITY = ["-c", "user.name=Harness", "-c", "user.email=harness@localhost"];
+const PATCH_LIMIT = 200_000;
+
+function git(cwd, args) {
+  const result = spawnSync("git", [...IDENTITY, ...args], { cwd, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+  return { ok: result.status === 0, out: (result.stdout || "").trim(), err: (result.stderr || "").trim() };
+}
+
+/** The repository a folder is in, and the folder's place inside it; null when it is not in one. */
+export function repositoryOf(folder) {
+  if (!folder || !fs.existsSync(folder)) return null;
+  const top = git(folder, ["rev-parse", "--show-toplevel"]);
+  if (!top.ok || !top.out) return null;
+  const head = git(folder, ["rev-parse", "--verify", "HEAD"]);
+  if (!head.ok) return null;
+  return { root: fs.realpathSync(top.out), inside: path.relative(fs.realpathSync(top.out), 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 }) {
+  const key = (threadId) => `worktree:${threadId}`;
+  const get = (threadId) => { const raw = store.meta(key(threadId)); return raw ? JSON.parse(raw) : null; };
+  const save = (threadId, value) => store.meta(key(threadId), value ? JSON.stringify(value) : "null");
+
+  /** Where a thread's coding runs work: its worktree when the folder is in a repository, else the folder itself. */
+  const folderFor = (thread) => {
+    const folder = thread.goal.workspace;
+    if (!folder) return null;
+    const current = get(thread.id);
+    if (current?.state === "in_place") return 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;
+    const where = path.join(root, thread.id);
+    const branch = `harness/${slug(thread.objective)}-${thread.id.slice(0, 8)}`;
+    const base = git(repo.root, ["rev-parse", "HEAD"]).out;
+    fs.mkdirSync(root, { recursive: true });
+    const added = git(repo.root, ["worktree", "add", "-b", branch, where, base]);
+    if (!added.ok) throw new Error(`could not make the thread's copy of ${repo.root}: ${added.err}`);
+    save(thread.id, { state: "open", repo: repo.root, inside: repo.inside, path: where, branch, base });
+    return path.join(where, repo.inside);
+  };
+
+  /** Commits what a turn changed on the thread's branch; the commit is that turn's diff. Null when nothing changed. */
+  const commitTurn = (threadId, runId, message) => {
+    const tree = get(threadId);
+    if (!tree || tree.state !== "open" || !fs.existsSync(tree.path)) return null;
+    git(tree.path, ["add", "-A"]);
+    if (git(tree.path, ["diff", "--cached", "--quiet"]).ok) return null;
+    const committed = git(tree.path, ["commit", "-q", "-m", String(message).slice(0, 200)]);
+    if (!committed.ok) return null;
+    const sha = git(tree.path, ["rev-parse", "HEAD"]).out;
+    store.meta(`turn:${runId}`, sha);
+    return sha;
+  };
+
+  const stat = (cwd, range) => {
+    const out = git(cwd, ["diff", "--numstat", range]).out;
+    const files = out ? out.split("\n").map((line) => { const [added, removed, file] = line.split("\t"); return { file, added: Number(added) || 0, removed: Number(removed) || 0 }; }) : [];
+    return files;
+  };
+
+  /** What a thread changed: everything since it began, or one turn's commit. */
+  const diff = (threadId, runId = null) => {
+    const tree = get(threadId);
+    if (!tree) return { ok: false, error: "this thread has no copy of a repository" };
+    const cwd = fs.existsSync(tree.path) ? tree.path : tree.repo;
+    let range;
+    if (runId) {
+      const sha = store.meta(`turn:${runId}`);
+      if (!sha) return { ok: true, files: [], patch: "" };
+      range = `${sha}~1..${sha}`;
+    } else range = `${tree.base}..${tree.state === "open" ? "HEAD" : tree.branch}`;
+    const patch = git(cwd, ["diff", range]).out;
+    return { ok: true, files: stat(cwd, range), patch: patch.length > PATCH_LIMIT ? `${patch.slice(0, PATCH_LIMIT)}\n… (cut here; the rest is on branch ${tree.branch})` : patch, branch: tree.branch, state: tree.state };
+  };
+
+  const summary = (threadId) => {
+    const tree = get(threadId);
+    if (!tree || tree.state === "in_place") 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 };
+  };
+
+  const retire = (tree) => {
+    git(tree.repo, ["worktree", "remove", "--force", tree.path]);
+    git(tree.repo, ["worktree", "prune"]);
+  };
+
+  /** Brings the thread's branch into the branch the person has checked out. A conflict is undone and reported. */
+  const merge = (threadId, title) => {
+    const tree = get(threadId);
+    if (!tree || tree.state !== "open") return { ok: false, error: "there is nothing of this thread's to merge" };
+    if (!stat(tree.path, `${tree.base}..HEAD`).length) return { ok: false, error: "this thread has not changed anything" };
+    const into = git(tree.repo, ["rev-parse", "--abbrev-ref", "HEAD"]).out;
+    const merged = git(tree.repo, ["merge", "--no-ff", "-m", `Merge ${tree.branch}: ${String(title).slice(0, 120)}`, tree.branch]);
+    if (!merged.ok) {
+      const conflicts = git(tree.repo, ["diff", "--name-only", "--diff-filter=U"]).out.split("\n").filter(Boolean);
+      git(tree.repo, ["merge", "--abort"]);
+      return { ok: false, conflict: true, files: conflicts, error: conflicts.length
+        ? `merging into ${into} conflicts in ${conflicts.join(", ")}; nothing was merged`
+        : `git would not merge into ${into}: ${merged.err.split("\n")[0]}; nothing was merged` };
+    }
+    retire(tree);
+    git(tree.repo, ["branch", "-d", tree.branch]);
+    save(threadId, { ...tree, state: "merged", into, mergedAt: new Date().toISOString() });
+    return { ok: true, into };
+  };
+
+  const discard = (threadId) => {
+    const tree = get(threadId);
+    if (!tree || tree.state !== "open") return { ok: false, error: "there is nothing of this thread's to discard" };
+    retire(tree);
+    git(tree.repo, ["branch", "-D", tree.branch]);
+    save(threadId, { ...tree, state: "discarded" });
+    return { ok: true };
+  };
+
+  /** 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 };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "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"
@@ -30,6 +30,7 @@
   "license": "MIT",
   "dependencies": {
     "node-sqlite3-wasm": "0.8.60",
+    "qr": "0.4.2",
     "ws": "^8.18.3",
     "@huggingface/tokenizers": "^0.1.3",
     "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c"