tryharness 0.7.8 → 0.7.10

package/lib/nudge.mjs

@@ -11,7 +11,13 @@ import { placeEnv } from "./places.mjs";
 // SessionStart hook (stdout lands in its context); the Pi extension and OpenCode plugin
 // build the same text in-process. Nothing waiting, or no daemon, prints nothing.
 
-export function nudgeText(agent, tasks, unread = [], goals = []) {
+// The swarm block (cards.mjs), when given, follows the queue: who else is in the person's swarm and what each is for.
+export function nudgeText(agent, tasks, unread = [], goals = [], swarm = "") {
+  const queue = queueText(agent, tasks, unread, goals);
+  return [queue, swarm].filter(Boolean).join("\n\n");
+}
+
+function queueText(agent, tasks, unread, goals) {
   const waiting = (tasks || []).filter((task) => task.status === "open" && (!task.target_agent || task.target_agent === agent));
   const held = (tasks || []).filter((task) => task.claimed_by === agent && (task.status === "claimed" || task.status === "needs_input"));
   if (!waiting.length && !held.length && !unread.length && !goals.length) return "";
@@ -38,31 +44,41 @@ export function queueDigest(agent, tasks, unread = [], goals = []) {
 
 export async function boardQueue(agent) {
   try {
-    const response = await daemonRequest({ command: "board.list", agent, unread: true }, 1_500);
-    return response?.ok ? { tasks: response.tasks, unread: response.unread || [], goals: response.goals || [] } : null;
+    const response = await daemonRequest({ command: "board.list", agent, unread: true, swarm: true }, 1_500);
+    return response?.ok ? { tasks: response.tasks, unread: response.unread || [], goals: response.goals || [], swarm: response.swarm || null } : null;
   } catch {
     return null;
   }
 }
 
-export async function boardNudge(agent) {
+// What this agent was last told, in the Harness home: the queue's digest and the swarm's.
+const toldFile = (agent, homeDir) => path.join(homeDir, `nudge-${agent}.json`);
+function lastTold(agent, homeDir) { try { return JSON.parse(fs.readFileSync(toldFile(agent, homeDir), "utf8")); } catch { return {}; } }
+function noteTold(agent, homeDir, told) { try { fs.writeFileSync(toldFile(agent, homeDir), JSON.stringify({ ...lastTold(agent, homeDir), ...told, at: new Date().toISOString() }), { mode: 0o600 }); } catch {} }
+
+/** What a session is told when it starts: its queue and the whole swarm. */
+export async function boardNudge(agent, homeDir = paths.home) {
   const queue = await boardQueue(agent);
-  return queue ? nudgeText(agent, queue.tasks, queue.unread, queue.goals) : "";
+  if (!queue) return "";
+  if (queue.swarm?.digest) noteTold(agent, homeDir, { swarm: queue.swarm.digest });
+  return nudgeText(agent, queue.tasks, queue.unread, queue.goals, queue.swarm?.text || "");
 }
 
 // Only what changed since this agent last saw its queue: a hook that runs on every prompt
-// prints once per change, never the same block again. The last digest lives in the Harness home.
+// prints once per change, never the same block again. The swarm is told again only when who is
+// in it, their facts or the person's notes changed, not each time an agent finishes something.
 export async function boardNudgeIfChanged(agent, homeDir = paths.home) {
   const queue = await boardQueue(agent);
   if (!queue) return "";
-  const { tasks, unread, goals } = queue;
+  const { tasks, unread, goals, swarm } = queue;
   const digest = queueDigest(agent, tasks, unread, goals);
-  const file = path.join(homeDir, `nudge-${agent}.json`);
-  let last = null;
-  try { last = JSON.parse(fs.readFileSync(file, "utf8")).digest; } catch {}
-  if (digest === last) return "";
-  try { fs.writeFileSync(file, JSON.stringify({ digest, at: new Date().toISOString() }), { mode: 0o600 }); } catch {}
-  return digest ? nudgeText(agent, tasks, unread, goals) : (last ? "Harness task board: nothing waits for you now." : "");
+  const last = lastTold(agent, homeDir);
+  const queueMoved = digest !== (last.digest ?? null);
+  const swarmMoved = Boolean(swarm?.digest) && swarm.digest !== last.swarm;
+  if (!queueMoved && !swarmMoved) return "";
+  noteTold(agent, homeDir, { digest, ...(swarm?.digest ? { swarm: swarm.digest } : {}) });
+  const told = !queueMoved ? "" : digest ? queueText(agent, tasks, unread, goals) : (last.digest ? "Harness task board: nothing waits for you now." : "");
+  return [told, swarmMoved ? swarm.text : ""].filter(Boolean).join("\n\n");
 }
 
 // The prompt hook also tells the daemon the person typed in this session: the agent process is the hook's parent, or

package/lib/paths.mjs

@@ -16,6 +16,7 @@ export const paths = {
   log: path.join(harnessHome, "daemon.log"),
   phoneIdentity: path.join(harnessHome, "phone-identity.json"),
   runs: path.join(harnessHome, "runs"),
+  files: path.join(harnessHome, "files"),
   runtime: path.join(harnessHome, "runtime"),
   models: path.join(harnessHome, "models"),
   legacyBridgeConfig: path.join(harnessHome, "bridge.json"),

package/lib/phones.mjs

@@ -23,7 +23,9 @@ const PHONE_COMMANDS = new Set([
   "board.thread.read", "board.thread.post", "board.thread.send", "board.thread.discard", "board.thread.auto", "board.thread.end",
   "board.goal.list", "board.goal.get", "board.goal.stop", "board.room.read",
   "board.swarm.list", "board.swarm.read", "board.swarm.start", "board.swarm.post", "board.swarm.stop", "board.swarm.stop_all", "board.swarm.resume", "board.swarm.folder", "board.swarm.coordinator",
-  "board.swarm.diff", "board.swarm.merge", "board.swarm.discard", "board.swarm.start_run",
+  "board.swarm.diff", "board.swarm.merge", "board.swarm.discard", "board.swarm.start_run", "board.swarm.agents", "board.swarm.note",
+  // The person's own running sessions, read and messaged as from the desktop app; never queued (a session may be gone).
+  "board.live", "board.live.read", "board.live.say",
 ]);
 // What the chat owner does on the board, in Harness's name (was src/server/mcp/board.ts HARNESS_COMMANDS).
 const HARNESS_COMMANDS = new Set([

package/lib/sealed.mjs

@@ -96,6 +96,15 @@ export async function openBound(key, bound, sealed) {
   const plain = await subtle.decrypt({ name: "AES-GCM", iv: fromB64u(sealed.iv), additionalData: encoder.encode(`HSC1|${bound}`) }, key, fromB64u(sealed.ct));
   return JSON.parse(decoder.decode(plain));
 }
+// A file's bytes, sealed as they are (no JSON or base64 inside): bound to its thread and file id like a message.
+export async function sealBytes(key, bound, bytes) {
+  const iv = webcrypto.getRandomValues(new Uint8Array(12));
+  const ct = await subtle.encrypt({ name: "AES-GCM", iv, additionalData: encoder.encode(`HSC1|${bound}`) }, key, bytes);
+  return { iv: b64u(iv), ct: b64u(new Uint8Array(ct)) };
+}
+export async function openBytes(key, bound, sealed) {
+  return Buffer.from(await subtle.decrypt({ name: "AES-GCM", iv: fromB64u(sealed.iv), additionalData: encoder.encode(`HSC1|${bound}`) }, key, fromB64u(sealed.ct)));
+}
 // What two people read to each other to check they hold each other's key: SHA-256 of the key, 20 hex digits in groups of four.
 export async function fingerprint(publicKey) {
   const digest = Buffer.from(await subtle.digest("SHA-256", fromB64u(publicKey))).toString("hex");

package/lib/store.mjs

@@ -3,7 +3,7 @@ import sqliteWasm from "node-sqlite3-wasm";
 import { parseSession } from "./parsers.mjs";
 import { provenanceFor } from "./provenance.mjs";
 
-const SCHEMA_VERSION = 9;
+const SCHEMA_VERSION = 10;
 const INDEX_FORMAT_VERSION = 2;
 const { Database } = sqliteWasm;
 
@@ -185,6 +185,20 @@ export function openStore(file) {
       version text not null,
       vector blob not null
     );
+    create table if not exists board_files (
+      id text primary key,
+      task_id text not null,
+      name text not null,
+      mime text not null,
+      bytes integer,
+      sha256 text,
+      author text not null,
+      cloud integer not null default 0,
+      remote_id text,
+      present integer not null default 0,
+      created_at text not null
+    );
+    create index if not exists board_files_task_idx on board_files(task_id, created_at);
   `);
   const sessionColumns = new Set(db.all("pragma table_info(sessions)").map((column) => column.name));
   if (!sessionColumns.has("parser_version")) {
@@ -689,6 +703,46 @@ export function openStore(file) {
     relayPeers() {
       return execute("all", "select handle, public_key, pinned_at from relay_peers order by pinned_at desc");
     },
+    // Files on a task. A file this machine has is present; one another person's computer is sending is named by its
+    // message first or arrives first, and is matched by the id that computer gave it (remote_id), never by ours.
+    addFile({ taskId, name, mime, bytes, sha256, author, cloud = false }) {
+      const id = randomUUID();
+      execute("run", `insert into board_files(id, task_id, name, mime, bytes, sha256, author, cloud, present, created_at) values(@id, @taskId, @name, @mime, @bytes, @sha256, @author, @cloud, 1, @now)`,
+        { id, taskId, name, mime, bytes, sha256, author, cloud: cloud ? 1 : 0, now: new Date().toISOString() });
+      execute("run", "update board_tasks set updated_at = ?, version = version + 1 where id = ?", new Date().toISOString(), taskId);
+      return this.file(id);
+    },
+    file(id) {
+      const row = execute("get", "select * from board_files where id = ?", String(id));
+      return row ? { ...row, bytes: row.bytes == null ? null : Number(row.bytes), cloud: Number(row.cloud) === 1, present: Number(row.present) === 1 } : null;
+    },
+    taskFiles(taskId) {
+      return execute("all", "select id from board_files where task_id = ? order by created_at asc", taskId).map((row) => this.file(row.id));
+    },
+    // The other computer's message names a file it sends: kept with the hash it promised, which its bytes must match.
+    expectFile({ taskId, remoteId, name, mime, sha256, author }) {
+      const known = execute("get", "select id, sha256, present from board_files where task_id = ? and remote_id = ?", taskId, remoteId);
+      if (known && Number(known.present) === 1 && known.sha256 !== sha256) return { ok: false, error: "a file arrived with other bytes than its message promised" };
+      if (known) {
+        execute("run", "update board_files set name = ?, mime = ?, sha256 = ?, author = ? where id = ?", name, mime, sha256, author, known.id);
+        return { ok: true, file: this.file(known.id) };
+      }
+      const id = randomUUID();
+      execute("run", `insert into board_files(id, task_id, name, mime, sha256, author, remote_id, present, created_at) values(@id, @taskId, @name, @mime, @sha256, @author, @remoteId, 0, @now)`,
+        { id, taskId, name, mime, sha256, author, remoteId, now: new Date().toISOString() });
+      return { ok: true, file: this.file(id) };
+    },
+    receiveFile({ taskId, remoteId, sha256, bytes, author }) {
+      const known = execute("get", "select id, sha256, present from board_files where task_id = ? and remote_id = ?", taskId, remoteId);
+      if (known && Number(known.present) === 1) return { ok: true, duplicate: true, file: this.file(known.id) };
+      if (known && known.sha256 && known.sha256 !== sha256) return { ok: false, error: "a file arrived with other bytes than its message promised" };
+      const id = known?.id || randomUUID();
+      if (known) execute("run", "update board_files set sha256 = ?, bytes = ?, present = 1 where id = ?", sha256, bytes, id);
+      else execute("run", `insert into board_files(id, task_id, name, mime, bytes, sha256, author, remote_id, present, created_at) values(@id, @taskId, 'file', 'application/octet-stream', @bytes, @sha256, @author, @remoteId, 1, @now)`,
+        { id, taskId, bytes, sha256, author, remoteId, now: new Date().toISOString() });
+      execute("run", "update board_tasks set updated_at = ?, version = version + 1 where id = ?", new Date().toISOString(), taskId);
+      return { ok: true, file: this.file(id) };
+    },
     getThread(taskId) {
       const row = execute("get", "select * from board_threads where task_id = ?", taskId);
       return row ? { ...row, auto_send: Number(row.auto_send) === 1 } : null;
@@ -713,11 +767,11 @@ export function openStore(file) {
       this.addContribution({ id: `msg:${id}`, taskId, kind: "message", author: sender, text, source: `message:${id}` });
       return { ok: true, message: this.threadMessages(taskId).find((message) => message.id === id) };
     },
-    postMessage({ id, taskId, sender, text, refs = [], flagReason = null }) {
+    postMessage({ id, taskId, sender, text, refs = [], flagReason = null, hold = false }) {
       const thread = this.getThread(taskId);
       if (!thread) return { ok: false, error: "no thread on this task" };
       if (thread.closed_at) return { ok: false, error: "the thread is closed" };
-      const state = flagReason ? "flagged" : thread.auto_send ? "sent" : "held";
+      const state = flagReason ? "flagged" : thread.auto_send && !hold ? "sent" : "held";
       const now = new Date().toISOString();
       execute("run", `insert into board_messages(id, task_id, seq, direction, sender, recipient, text, refs, state, flag_reason, created_at, sent_at)
         values(@id, @taskId, @seq, 'out', @sender, @recipient, @text, @refs, @state, @flagReason, @now, @sentAt)`,
@@ -819,6 +873,14 @@ export function openStore(file) {
     agentsSeen() {
       return execute("all", "select agent, last_seen_at from board_agents order by last_seen_at desc");
     },
+    // Each agent's work on the board, newest first, for its card (cards.mjs): what it holds and finished, and when it
+    // could start (the person's Start, else the post) and reported.
+    agentWork() {
+      return execute("all", `select coalesce(claimed_by, target_agent) as agent, status, target_agent is not null as targeted,
+        coalesce(run_authorized_at, created_at) as started_at, reported_at from board_tasks
+        where kind in ('task', 'wake') and removed_at is null and coalesce(claimed_by, target_agent) is not null
+        order by updated_at desc limit 5000`);
+    },
     listTasks({ agent, status, all = false, limit = 20 } = {}) {
       const clauses = ["b.removed_at is null"];
       const params = { limit: Math.max(1, Math.min(100, Number(limit) || 20)) };

package/lib/swarm.mjs

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { readRunSteps } from "./runner.mjs";
-import { member, nameOf } from "./members.mjs";
+import { nameOf, resolveMember } from "./members.mjs";
+import { setNote, swarmBlock, swarmCards, swarmDigest } from "./cards.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
@@ -11,9 +12,6 @@ import { member, nameOf } from "./members.mjs";
 
 const PROCESS_NAMES = { "claude-code": "claude", codex: "codex", pi: "pi", opencode: "opencode" };
 const SAY_LIMIT = 4_000;
-// How a member hears that work is waiting for it, by its roster wake.
-const ANSWERS = { run: "starts as soon as it may", email: "woken by email when work is posted", webhook: "woken when work is posted", "local-webhook": "woken when work is posted",
-  schedule: "picks work up on its own schedule", none: "only when the person next talks to it" };
 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.
@@ -155,10 +153,11 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
       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 }) };
     }
-    // Who can be asked, and how each answers: open to every caller, so an agent picks a name instead of guessing one.
+    // Who can be asked: every other agent's card (cards.mjs), and the same cards as the block an agent is told when its
+    // session starts. Open to every caller, so an agent picks a name instead of guessing one.
     if (command === "board.swarm.agents") {
-      const seen = new Map(store.agentsSeen().map((row) => [row.agent, row.last_seen_at]));
-      return { ok: true, agents: roster().filter((entry) => entry.id !== agent).map((entry) => ({ ...entry, name: nameOf(entry.id), answers: ANSWERS[member(entry.id)?.wake] ?? "when it next looks", lastSeen: seen.get(entry.id) ?? null })) };
+      const agents = swarmCards(store, roster().filter((entry) => entry.id !== agent));
+      return { ok: true, agents, text: swarmBlock(agents), digest: swarmDigest(agents) };
     }
     // Any of the person's agents may start a thread and stop one it started. The thread carries the agent's trust, so
     // nothing in it runs without the person's Start, and one started through Harness gets no coordinator rounds (they
@@ -186,6 +185,12 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
       return { ok: true, thread: summary(store.getTask(thread.id)) };
     }
     if (agent !== "user") return { ok: false, error: "only the person writes in, stops or resumes a thread they did not start; post in it with post_to_room" };
+    // The person's own note on one agent's card ("use it for reviews"), told to every other agent; no text clears it.
+    if (command === "board.swarm.note") {
+      const named = resolveMember(request.target);
+      if (!named.ok) return { ok: false, error: named.candidates.length ? `"${request.target}" could be ${named.candidates.join(" or ")}; name one` : `no agent called "${request.target}"` };
+      return { ok: true, agent: named.id, note: setNote(store, named.id, request.text) };
+    }
     // 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") {

package/lib/t3.mjs

@@ -0,0 +1,172 @@
+import http from "node:http";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { readJson, writeJsonAtomic } from "./files.mjs";
+import { paths } from "./paths.mjs";
+import { t3Home } from "./places.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
+// no T3 account. From then on a message the person sends a session running in T3 Code (from the desktop app or the
+// phone) goes into that session's T3 thread as T3 sends any message: started when the thread is idle, queued behind its
+// turn when it is busy. T3 shows it as sent by an agent through MCP. The key lives in ~/.harness/t3.json (0600), works
+// only on T3's /mcp on this computer's loopback, lasts 30 days, and is revoked in T3 under Settings → Connections.
+
+// T3's desktop app binds the first free port from 3773 up (T3 apps/server/src/auth/utils.ts).
+const FIRST_PORT = 3773;
+const PORTS = 20;
+// Its descriptor answered in at most 1.7 ms over 40 tries while T3 ran four busy sessions (October 12); a closed port
+// refuses in under 0.4 ms. The limit only keeps a port held by something else from stalling the search.
+const PROBE_MS = 1_000;
+const PROTOCOL = "2025-06-18";
+
+const b64u = (bytes) => Buffer.from(bytes).toString("base64url");
+const file = () => path.join(paths.home, "t3.json");
+
+class T3Error extends Error {
+  constructor(code, message) { super(message); this.code = code; }
+}
+
+/** This computer's T3 Code: its environment (from T3's own data folder) and the loopback address that answers as it. */
+export async function findT3(home = t3Home(), hint = null) {
+  let environmentId = "";
+  try { environmentId = fs.readFileSync(path.join(home, "environment-id"), "utf8").trim(); } catch { return null; }
+  const answers = async (origin) => {
+    try {
+      const response = await fetch(`${origin}/.well-known/t3/environment`, { signal: AbortSignal.timeout(PROBE_MS) });
+      return response.ok && (await response.json())?.environmentId === environmentId;
+    } catch { return false; }
+  };
+  if (hint && await answers(hint)) return { origin: hint, environmentId };
+  for (let port = FIRST_PORT; port < FIRST_PORT + PORTS; port++) {
+    const origin = `http://127.0.0.1:${port}`;
+    if (origin !== hint && await answers(origin)) return { origin, environmentId };
+  }
+  return null;
+}
+
+/** What Harness may do in T3 Code: "send", "read", "expired", or null before the person approves it. */
+export function t3Access() {
+  const saved = readJson(file(), null);
+  if (!saved?.token) return null;
+  if (!(Date.parse(saved.expiresAt) > Date.now())) return { state: "expired", at: saved.expiresAt };
+  return { state: String(saved.scope || "").split(" ").includes("orchestration:operate") ? "send" : "read", until: saved.expiresAt };
+}
+
+export function forgetT3() {
+  try { fs.rmSync(file()); } catch {}
+}
+
+const json = async (url, body) => {
+  const response = await fetch(url, body ? { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {});
+  const value = await response.json().catch(() => null);
+  if (!response.ok || !value) throw new T3Error("t3", value?.error_description || `T3 Code answered ${response.status}`);
+  return value;
+};
+
+const page = (title, words) => `<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${title}</title>`
+  + `<body style="font-family:-apple-system,system-ui,sans-serif;display:grid;place-items:center;min-height:90vh;margin:0"><main style="max-width:420px;padding:24px"><h1 style="font-size:20px">${title}</h1><p style="line-height:1.5">${words}</p></main>`;
+
+let pending = null;
+
+/**
+ * Starts the sign-in: registers Harness with this computer's T3 Code and returns the page where the person approves it.
+ * The approval comes back to a loopback address here, which keeps listening until it does or another sign-in starts.
+ */
+export async function startT3SignIn() {
+  const t3 = await findT3(t3Home(), readJson(file(), null)?.origin ?? null);
+  if (!t3) throw new T3Error("not_running", "T3 Code is not running on this computer. Open it, then try again.");
+  // T3 Code takes outside agents from its 0.0.46 builds on; an older one has no sign-in to offer.
+  const server = await json(`${t3.origin}/.well-known/oauth-authorization-server`).catch(() => {
+    throw new T3Error("too_old", "This T3 Code can't approve outside agents yet. Update it (0.0.46 or newer), then try again.");
+  });
+  pending?.close();
+  const listener = http.createServer();
+  pending = listener;
+  await new Promise((resolve, reject) => { listener.once("error", reject); listener.listen(0, "127.0.0.1", resolve); });
+  const redirect = `http://127.0.0.1:${listener.address().port}/t3/callback`;
+  const client = await json(server.registration_endpoint, { client_name: "Harness", redirect_uris: [redirect] });
+  const verifier = b64u(randomBytes(32));
+  const state = b64u(randomBytes(16));
+  const resource = `${t3.origin}/mcp`;
+  listener.on("request", async (request, response) => {
+    const url = new URL(request.url, redirect);
+    const answer = (status, title, words) => { response.writeHead(status, { "content-type": "text/html; charset=utf-8" }); response.end(page(title, words)); };
+    if (url.pathname !== "/t3/callback" || url.searchParams.get("state") !== state) return answer(400, "Not this sign-in", "This page is not the sign-in Harness started. Start it again from Harness.");
+    const done = () => { listener.close(); if (pending === listener) pending = null; };
+    if (url.searchParams.get("error")) { done(); return answer(200, "Harness was not approved", "Nothing changed. Harness keeps leaving your messages for T3 Code's sessions to pick up themselves."); }
+    if (url.searchParams.has("iss") && url.searchParams.get("iss") !== server.issuer) return answer(400, "Not this sign-in", "The approval came from another server.");
+    try {
+      const exchanged = await fetch(server.token_endpoint, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ grant_type: "authorization_code", code: url.searchParams.get("code") || "", redirect_uri: redirect, client_id: client.client_id, code_verifier: verifier, resource }) });
+      const token = await exchanged.json().catch(() => null);
+      if (!exchanged.ok || !token?.access_token) throw new Error(token?.error_description || `T3 Code answered ${exchanged.status}`);
+      writeJsonAtomic(file(), { origin: t3.origin, environmentId: t3.environmentId, clientId: client.client_id, token: token.access_token, scope: token.scope || "",
+        expiresAt: new Date(Date.now() + Number(token.expires_in || 0) * 1000).toISOString(), approvedAt: new Date().toISOString() });
+      done();
+      const send = t3Access()?.state === "send";
+      answer(200, send ? "Harness can send into T3 Code" : "Harness can read T3 Code", send
+        ? "Messages you send your T3 Code sessions from Harness, on this computer or your phone, now go straight into their threads. You can close this tab."
+        : "You approved read only, so messages still wait for your sessions to pick them up. To send into T3 Code's threads, approve Harness again with the access your threads run with.");
+    } catch (error) {
+      answer(502, "The sign-in did not finish", `${String(error.message).replace(/[<>&]/g, "")}. Start it again from Harness.`);
+    }
+  });
+  const url = `${server.authorization_endpoint}?${new URLSearchParams({ response_type: "code", client_id: client.client_id, redirect_uri: redirect,
+    code_challenge: b64u(createHash("sha256").update(verifier).digest()), code_challenge_method: "S256", state, resource })}`;
+  return { url };
+}
+
+/** One JSON-RPC message to T3's /mcp (Streamable HTTP): the answer comes as JSON or as a server-sent event. */
+async function rpc(origin, token, session, message) {
+  const response = await fetch(`${origin}/mcp`, { method: "POST", body: JSON.stringify({ jsonrpc: "2.0", ...message }), headers: {
+    authorization: `Bearer ${token}`, "content-type": "application/json", accept: "application/json, text/event-stream", "mcp-protocol-version": PROTOCOL,
+    ...(session ? { "mcp-session-id": session } : {}) } });
+  if (response.status === 401 || response.status === 403) throw new T3Error("expired", "T3 Code no longer accepts Harness's sign-in.");
+  if (!response.ok) throw new T3Error("t3", `T3 Code answered ${response.status}`);
+  const next = response.headers.get("mcp-session-id") || session;
+  if (message.id === undefined) return { session: next };
+  const text = await response.text();
+  const replies = (response.headers.get("content-type") || "").includes("text/event-stream")
+    ? text.split("\n").filter((line) => line.startsWith("data:")).map((line) => { try { return JSON.parse(line.slice(5)); } catch { return null; } })
+    : [JSON.parse(text)];
+  const reply = replies.find((entry) => entry?.id === message.id);
+  if (!reply) throw new T3Error("t3", "T3 Code sent no answer");
+  if (reply.error) throw new T3Error("t3", reply.error.message || "T3 Code refused");
+  return { session: next, result: reply.result };
+}
+
+async function callTool(origin, token, name, args) {
+  let { session } = await rpc(origin, token, null, { id: 1, method: "initialize", params: { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: { name: "Harness", version: "1" } } });
+  try {
+    ({ session } = await rpc(origin, token, session, { method: "notifications/initialized" }));
+    const { result } = await rpc(origin, token, session, { id: 2, method: "tools/call", params: { name, arguments: args } });
+    const words = (result?.content || []).map((part) => part?.text || "").join("\n").trim();
+    if (result?.isError) throw new T3Error("refused", words || "T3 Code refused");
+    if (result?.structuredContent) return result.structuredContent;
+    try { return JSON.parse(words); } catch { return {}; }
+  } finally {
+    if (session) fetch(`${origin}/mcp`, { method: "DELETE", headers: { authorization: `Bearer ${token}`, "mcp-session-id": session } }).catch(() => {});
+  }
+}
+
+/** Sends the person's words into a T3 Code thread: "started" or "queued" behind its turn. */
+export async function sendToT3(threadId, text) {
+  const saved = readJson(file(), null);
+  const access = t3Access();
+  if (!access) throw new T3Error("not_connected", "Harness is not approved in T3 Code yet.");
+  if (access.state === "expired") throw new T3Error("expired", "Harness's approval in T3 Code ran out.");
+  if (access.state !== "send") throw new T3Error("read_only", "Harness was approved in T3 Code to read only.");
+  // T3 may come back on another port after a restart: the saved address first, else the search again.
+  const t3 = await findT3(t3Home(), saved.origin);
+  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";
+  } catch (error) {
+    if (error.code === "expired") writeJsonAtomic(file(), { ...saved, expiresAt: new Date(0).toISOString() });
+    throw error;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.7.8",
+  "version": "0.7.10",
   "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"
@@ -36,8 +36,8 @@
     "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c"
   },
   "optionalDependencies": {
-    "tryharness-desktop-darwin-arm64": "0.7.8",
-    "tryharness-desktop-darwin-x64": "0.7.8",
+    "tryharness-desktop-darwin-arm64": "0.7.10",
+    "tryharness-desktop-darwin-x64": "0.7.10",
     "tryharness-desktop-linux-x64": "0.7.4",
     "tryharness-desktop-win32-x64": "0.7.4"
   }