tryharness 0.7.23 → 0.7.26

package/lib/t3.mjs

@@ -26,23 +26,39 @@ 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; }
+  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; }
+  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; }
+      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 };
+  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 };
+    if (origin !== hint && (await answers(origin)))
+      return { origin, environmentId };
   }
   return null;
 }
@@ -51,23 +67,47 @@ export async function findT3(home = t3Home(), hint = null) {
 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 };
+  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 {}
+  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 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}`);
+  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>`;
+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;
 
@@ -77,78 +117,215 @@ let pending = null;
  */
 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.");
+  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.");
+  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); });
+  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 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.");
+    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 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() });
+      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.");
+      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.`);
+      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 })}`;
+  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 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; } })
+  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");
+  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" } } });
+  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");
+    ({ 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 {}; }
+    try {
+      return JSON.parse(words);
+    } catch {
+      return {};
+    }
   } finally {
-    if (session) fetch(`${origin}/mcp`, { method: "DELETE", headers: { authorization: `Bearer ${token}`, "mcp-session-id": session } }).catch(() => {});
+    if (session)
+      fetch(`${origin}/mcp`, {
+        method: "DELETE",
+        headers: {
+          authorization: `Bearer ${token}`,
+          "mcp-session-id": session,
+        },
+      }).catch(() => {});
   }
 }
 
@@ -156,24 +333,47 @@ async function callTool(origin, token, name, args) {
 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.");
-  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.");
+  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 });
+  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 {
     return await callTool(t3.origin, saved.token, name, args);
   } catch (error) {
-    if (error.code === "expired") writeJsonAtomic(file(), { ...saved, expiresAt: new Date(0).toISOString() });
+    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() });
+  const sent = await t3Tool("t3_thread_send", {
+    threadId,
+    message: text,
+    mode: "queue",
+    clientRequestId: randomUUID(),
+  });
   return sent.delivery === "queued" ? "queued" : "started";
 }
 
@@ -184,6 +384,18 @@ 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 turns handed to T3 that words can still reach while they run, by Harness's run id.
+const steerable = new Map();
+
+/**
+ * The person's words into a turn handed to T3 while it runs: T3 steers them in at the agent's next step, or restarts
+ * the turn with them for an agent that cannot take words mid-turn. "steered" or "restarted"; null when that run has
+ * no turn going, so the words wait for its next turn.
+ */
+export async function steerT3Run(runId, text) {
+  const steer = steerable.get(runId);
+  return steer ? steer(text) : null;
+}
 
 /** 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());
@@ -191,11 +403,21 @@ 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) };
+  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),
+  };
 }
 
 /**
@@ -206,23 +428,60 @@ function stepOf(item) {
  * 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 = "";
+  let threadId = run.threadId ?? null,
+    runId = null,
+    cursor = null,
+    timer = null,
+    stopped = false,
+    steering = 0,
+    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 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);
+    steerable.delete(run.runId);
+    release();
+    emit(kind, text.slice(0, 20_000), { usage: null });
+  };
   const read = async () => {
     try {
-      let page, after = cursor, settled = true;
+      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 }) });
+        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)) {
+          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`);
+              observe(
+                "stdout",
+                `${JSON.stringify({ type: "harness.step", ...step })}\n`
+              );
               emit("progress", step.text.slice(0, 200), { step });
             }
           }
@@ -232,30 +491,92 @@ export function runInT3(run, emit, observe) {
         }
         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}` : "."}`);
+      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."
+        );
+      // A turn restarted with the person's words ends as the next one starts: that one is followed instead.
+      if (ENDED.has(status) && !steering)
+        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.`);
+      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);
   };
+  // T3 refuses words for a thread with no turn it can steer, so they never start a turn Harness would not follow.
+  steerable.set(run.runId, async (text) => {
+    if (!threadId || !runId || stopped) return null;
+    steering++;
+    try {
+      const sent = await t3Tool("t3_thread_send", {
+        threadId,
+        message: text,
+        mode: "steer",
+        clientRequestId: randomUUID(),
+      });
+      if (sent.delivery !== "steered" && sent.delivery !== "restarted")
+        return null;
+      // A restart goes on as a new run: follow that one to its end.
+      if (sent.runId) runId = sent.runId;
+      return sent.delivery;
+    } catch {
+      return null;
+    } finally {
+      steering--;
+    }
+  });
   emit("accepted");
   void (async () => {
     try {
       // A model the relay chose for this turn (models.mjs) is the thread's selection from this turn on.
       if (threadId) {
-        if (run.model) await t3Tool("t3_thread_configure", { threadId, modelSelection: run.model });
-        runId = (await t3Tool("t3_thread_send", { threadId, message: run.brief, mode: "queue", clientRequestId: run.runId })).runId ?? null;
+        if (run.model)
+          await t3Tool("t3_thread_configure", {
+            threadId,
+            modelSelection: run.model,
+          });
+        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, ...(run.model ? { modelSelection: run.model } : {}) });
+        const launched = await t3Tool("t3_thread_launch", {
+          title: run.title,
+          message: run.brief,
+          ...run.launch,
+          ...(run.model ? { modelSelection: run.model } : {}),
+        });
         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");
+      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();