tryharness 0.7.22 → 0.7.25

package/lib/coordinator.mjs

@@ -11,14 +11,19 @@ import { MACHINE_RUNNERS, MEMBERS, nameOf } from "./members.mjs";
 
 const CODING = new Set(MACHINE_RUNNERS);
 // The agents with a read-only switch (runner.mjs, review in the roster): only they can be handed a review.
-const REVIEWERS = new Set(MEMBERS.filter((entry) => entry.review).map((entry) => entry.id));
+const REVIEWERS = new Set(
+  MEMBERS.filter((entry) => entry.review).map((entry) => entry.id)
+);
 const TRANSCRIPT_POSTS = 30;
 const QUIET_KINDS = new Set(["note", "held", "round"]);
 // The coordinator's own posts are Harness's; Harness's answer to work it was given is a result like any agent's.
-const ownPost = (thread, post) => post.author === thread.goal.facilitator && post.kind !== "result";
+const ownPost = (thread, post) =>
+  post.author === thread.goal.facilitator && post.kind !== "result";
 // Harness's part with no Harness window open waits on the board for one (daemon.mjs offerToServer); the thread goes on.
-const waitsForWindow = (run) => run.status === "open" && run.target_agent === "harness";
-const going = (run) => ["open", "claimed", "running"].includes(run.status) && !waitsForWindow(run);
+const waitsForWindow = (run) =>
+  run.status === "open" && run.target_agent === "harness";
+const going = (run) =>
+  ["open", "claimed", "running"].includes(run.status) && !waitsForWindow(run);
 
 // The privacy setting: the round's facts go to an agent on this machine with its tools off, which answers in the
 // same shape Harness does. Nothing reaches Harness's server.
@@ -32,69 +37,199 @@ If the same attempt or failure keeps coming back, say so in loop and ask the nex
 function localDecision(agent, facts) {
   return new Promise((resolve, reject) => {
     const prompt = `${LOCAL_PROMPT}\n\n${JSON.stringify(facts)}`;
-    const invocation = agent === "codex"
-      ? { command: "codex", args: ["exec", "--json", "--sandbox", "read-only", "--skip-git-repo-check", "-"], stdin: prompt }
-      : { command: "claude", args: ["-p", prompt, "--output-format", "json", "--tools", ""] };
+    const invocation =
+      agent === "codex"
+        ? {
+            command: "codex",
+            args: [
+              "exec",
+              "--json",
+              "--sandbox",
+              "read-only",
+              "--skip-git-repo-check",
+              "-",
+            ],
+            stdin: prompt,
+          }
+        : {
+            command: "claude",
+            args: ["-p", prompt, "--output-format", "json", "--tools", ""],
+          };
     let child;
-    try { child = spawn(invocation.command, invocation.args, { cwd: os.tmpdir() }); } catch (error) { reject(error); return; }
+    try {
+      child = spawn(invocation.command, invocation.args, { cwd: os.tmpdir() });
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    // An agent that exits before reading the prompt breaks the pipe; its exit code rejects below.
+    child.stdin.on("error", () => {});
     child.stdin.end(invocation.stdin ?? "");
     let out = "";
-    child.stdout.on("data", (chunk) => { out += chunk; });
+    child.stdout.on("data", (chunk) => {
+      out += chunk;
+    });
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code !== 0) { reject(new Error(`${agent} exited with code ${code}`)); return; }
+      if (code !== 0) {
+        reject(new Error(`${agent} exited with code ${code}`));
+        return;
+      }
       // Claude answers one JSON object with its text in `result`; Codex streams events, its words in agent_message.
       let text = "";
       for (const line of out.split("\n")) {
         try {
           const event = JSON.parse(line);
           if (typeof event.result === "string") text = event.result;
-          if (event.type === "item.completed" && event.item?.type === "agent_message") text = event.item.text;
+          if (
+            event.type === "item.completed" &&
+            event.item?.type === "agent_message"
+          )
+            text = event.item.text;
         } catch {}
       }
       const match = text.match(/\{[\s\S]*\}/);
-      try { resolve(JSON.parse(match ? match[0] : text)); } catch { reject(new Error(`${agent} did not answer in the agreed shape`)); }
+      try {
+        resolve(JSON.parse(match ? match[0] : text));
+      } catch {
+        reject(new Error(`${agent} did not answer in the agreed shape`));
+      }
     });
   });
 }
 
-export function createCoordinator({ store, mode, askHarness, connected, serverHas, roster, handOn, localAgents, pauseGoal, notifyBoard, searchContext, log }) {
+export function createCoordinator({
+  store,
+  mode,
+  askHarness,
+  connected,
+  serverHas,
+  roster,
+  handOn,
+  localAgents,
+  pauseGoal,
+  notifyBoard,
+  searchContext,
+  log,
+  frame = () => null,
+}) {
   const busy = new Set();
   const again = new Set();
-  const stateOf = (goalId) => JSON.parse(store.meta(`coordinator:${goalId}`) || '{"lastSeenSeq":0,"rounds":0,"withoutProgress":0,"lastRoundAt":null,"lastError":null}');
-  const saveState = (goalId, state) => store.meta(`coordinator:${goalId}`, JSON.stringify(state));
+  const stateOf = (goalId) =>
+    JSON.parse(
+      store.meta(`coordinator:${goalId}`) ||
+        '{"lastSeenSeq":0,"rounds":0,"withoutProgress":0,"lastRoundAt":null,"lastError":null}'
+    );
+  const saveState = (goalId, state) =>
+    store.meta(`coordinator:${goalId}`, JSON.stringify(state));
 
   // What this machine knows that the round needs, whole: the transcript, who can run, and progress since last time.
   const facts = async (thread, state) => {
-    const posts = store.roomPosts(thread.id, 0, 500).filter((post) => !QUIET_KINDS.has(post.kind));
-    const transcript = posts.slice(-TRANSCRIPT_POSTS).map((post) => ({ seq: post.seq, author: post.author, kind: post.kind, text: post.text }));
+    const posts = store
+      .roomPosts(thread.id, 0, 500)
+      .filter((post) => !QUIET_KINDS.has(post.kind));
+    const transcript = posts.slice(-TRANSCRIPT_POSTS).map((post) => ({
+      seq: post.seq,
+      author: post.author,
+      kind: post.kind,
+      text: post.text,
+    }));
     const runs = store.threadRuns(thread.id);
     const since = state.lastRoundAt ?? "";
-    const runsFinished = runs.filter((run) => run.reported_at && run.reported_at > since).length;
-    const newResults = posts.filter((post) => post.seq > state.lastSeenSeq && post.author !== "user" && !ownPost(thread, post)).length;
-    const failedJobs = runs.filter((run) => run.status === "failed").slice(-5).map((run) => ({ agent: run.target_agent || "agent", objective: run.objective.slice(0, 500), result: String(run.result || "").slice(0, 4_000) }));
+    const runsFinished = runs.filter(
+      (run) => run.reported_at && run.reported_at > since
+    ).length;
+    const newResults = posts.filter(
+      (post) =>
+        post.seq > state.lastSeenSeq &&
+        post.author !== "user" &&
+        !ownPost(thread, post)
+    ).length;
+    const failedJobs = runs
+      .filter((run) => run.status === "failed")
+      .slice(-5)
+      .map((run) => ({
+        agent: run.target_agent || "agent",
+        objective: run.objective.slice(0, 500),
+        result: String(run.result || "").slice(0, 4_000),
+      }));
     const waiting = runs.filter(waitsForWindow);
     // Every agent the person can ask, each with its card (cards.mjs); a coding agent only where the thread has a folder for it
     // to work in, and Harness not while its part here waits for a window.
-    const candidates = roster().filter((candidate) => (!CODING.has(candidate.id) || thread.goal.workspace) && !(candidate.id === "harness" && waiting.length));
+    // Each card's receipts go only to a Harness that takes them (the same release as frames); an older one would refuse the round.
+    const framesTaken = mode() === "local" || serverHas("swarm_frame");
+    const candidates = roster()
+      .filter(
+        (candidate) =>
+          (!CODING.has(candidate.id) || thread.goal.workspace) &&
+          !(candidate.id === "harness" && waiting.length)
+      )
+      .map((candidate) =>
+        framesTaken || !candidate.record?.checks
+          ? candidate
+          : { ...candidate, record: { ...candidate.record, checks: undefined } }
+      );
     // Earlier words close in meaning to the newest post that the transcript no longer carries, from this thread and the
     // person's sessions on this machine.
-    const newest = posts.filter((post) => post.seq > state.lastSeenSeq).map((post) => post.text).join("\n").slice(0, 2_000);
+    const newest = posts
+      .filter((post) => post.seq > state.lastSeenSeq)
+      .map((post) => post.text)
+      .join("\n")
+      .slice(0, 2_000);
     const shown = new Set(transcript.map((post) => post.text));
     let related = [];
     if (newest.trim()) {
-      const found = await searchContext(thread.id, newest, 6).catch(() => ({ entries: [] }));
-      related = found.entries.filter((entry) => !shown.has(entry.text)).slice(0, 4).map((entry) => ({ source: `this thread, ${entry.author}`, text: entry.text.slice(0, 4_000) }));
-      for (const hit of store.search({ query: newest.split(/\s+/).slice(0, 12).join(" "), limit: 3 })) {
-        if (hit.excerpt) related.push({ source: `${nameOf(hit.agent)} session "${String(hit.title || "").slice(0, 120)}"`, text: String(hit.excerpt).slice(0, 4_000) });
+      const found = await searchContext(thread.id, newest, 6).catch(() => ({
+        entries: [],
+      }));
+      related = found.entries
+        .filter((entry) => !shown.has(entry.text))
+        .slice(0, 4)
+        .map((entry) => ({
+          source: `this thread, ${entry.author}`,
+          text: entry.text.slice(0, 4_000),
+        }));
+      for (const hit of store.search({
+        query: newest.split(/\s+/).slice(0, 12).join(" "),
+        limit: 3,
+      })) {
+        if (hit.excerpt)
+          related.push({
+            source: `${nameOf(hit.agent)} session "${String(hit.title || "").slice(0, 120)}"`,
+            text: String(hit.excerpt).slice(0, 4_000),
+          });
       }
     }
+    // The thread's task frame (frames.mjs): each run's receipt, other threads in the repository, its state.
+    const framed = frame(thread.id);
     return {
-      thread: { id: thread.id, title: thread.objective, folder: thread.goal.workspace, agents: thread.goal.team.filter((agent) => agent !== thread.goal.facilitator) },
-      transcript, lastSeenSeq: state.lastSeenSeq, candidates,
-      progress: { runsFinished, newResults, stillRunning: runs.filter(going).length, roundsWithoutProgress: state.withoutProgress, failedJobs,
+      ...(framed ? { frame: framed } : {}),
+      thread: {
+        id: thread.id,
+        title: thread.objective,
+        folder: thread.goal.workspace,
+        agents: thread.goal.team.filter(
+          (agent) => agent !== thread.goal.facilitator
+        ),
+      },
+      transcript,
+      lastSeenSeq: state.lastSeenSeq,
+      candidates,
+      progress: {
+        runsFinished,
+        newResults,
+        stillRunning: runs.filter(going).length,
+        roundsWithoutProgress: state.withoutProgress,
+        failedJobs,
         // A Harness that does not know the field would refuse the round: it goes only to one that takes Harness's tasks.
-        ...(waiting.length && (mode() === "local" || serverHas("harness_task")) ? { waitingForWindow: waiting.slice(-10).map((run) => ({ objective: run.objective.slice(0, 500) })) } : {}) },
+        ...(waiting.length && (mode() === "local" || serverHas("harness_task"))
+          ? {
+              waitingForWindow: waiting
+                .slice(-10)
+                .map((run) => ({ objective: run.objective.slice(0, 500) })),
+            }
+          : {}),
+      },
       related: related.slice(0, 8),
     };
   };
@@ -102,16 +237,52 @@ export function createCoordinator({ store, mode, askHarness, connected, serverHa
   // Carry a decision out under the thread's rules. A brief from the coordinator is agent-written work inside the
   // thread, so it runs on the thread's authority the way a goal's work does; everything else only posts.
   const apply = (thread, decision, coordinator, candidates) => {
-    if (decision.openItem) store.roomPost({ goalId: thread.id, author: coordinator, kind: "open_item", text: String(decision.openItem).slice(0, 2_000) });
-    if (decision.action === "pause") { pauseGoal(thread.id, String(decision.text || "the coordinator could not go on without you").slice(0, 300)); return; }
-    if (decision.action === "ask_person" && decision.text) store.roomPost({ goalId: thread.id, author: coordinator, kind: "question", text: String(decision.text).slice(0, 4_000) });
-    if (decision.action === "hand_on" && candidates.some((candidate) => candidate.id === decision.agent) && decision.text) {
-      if (!thread.goal.team.includes(decision.agent)) store.setGoalTeam(thread.id, [...thread.goal.team, decision.agent]);
-      const review = decision.mode === "review" && REVIEWERS.has(decision.agent);
+    if (decision.openItem)
+      store.roomPost({
+        goalId: thread.id,
+        author: coordinator,
+        kind: "open_item",
+        text: String(decision.openItem).slice(0, 2_000),
+      });
+    if (decision.action === "pause") {
+      pauseGoal(
+        thread.id,
+        String(
+          decision.text || "the coordinator could not go on without you"
+        ).slice(0, 300)
+      );
+      return;
+    }
+    if (decision.action === "ask_person" && decision.text)
+      store.roomPost({
+        goalId: thread.id,
+        author: coordinator,
+        kind: "question",
+        text: String(decision.text).slice(0, 4_000),
+      });
+    if (
+      decision.action === "hand_on" &&
+      candidates.some((candidate) => candidate.id === decision.agent) &&
+      decision.text
+    ) {
+      if (!thread.goal.team.includes(decision.agent))
+        store.setGoalTeam(thread.id, [...thread.goal.team, decision.agent]);
+      const review =
+        decision.mode === "review" && REVIEWERS.has(decision.agent);
       const text = String(decision.text).slice(0, 4_000);
       // The brief is posted for everyone to read and the agent is woken here, so a review runs with its read-only switch.
-      store.roomPost({ goalId: thread.id, author: coordinator, kind: "post", text: `@${decision.agent} ${review ? "(review, no changes) " : ""}${text}` });
-      handOn(thread.id, decision.agent, `${coordinator} asked you: ${text.slice(0, 300)}`, { review, words: text });
+      store.roomPost({
+        goalId: thread.id,
+        author: coordinator,
+        kind: "post",
+        text: `@${decision.agent} ${review ? "(review, no changes) " : ""}${text}`,
+      });
+      handOn(
+        thread.id,
+        decision.agent,
+        `${coordinator} asked you: ${text.slice(0, 300)}`,
+        { review, words: text }
+      );
     }
     notifyBoard(store.getTask(thread.id));
   };
@@ -120,52 +291,106 @@ export function createCoordinator({ store, mode, askHarness, connected, serverHa
     const thread = store.getTask(goalId);
     if (!thread || thread.kind !== "goal" || thread.status !== "open") return;
     const state = stateOf(goalId);
-    const posts = store.roomPosts(goalId, state.lastSeenSeq, 500).filter((post) => !QUIET_KINDS.has(post.kind) && !ownPost(thread, post));
+    const posts = store
+      .roomPosts(goalId, state.lastSeenSeq, 500)
+      .filter((post) => !QUIET_KINDS.has(post.kind) && !ownPost(thread, post));
     const active = store.threadRuns(goalId).some(going);
     if (!posts.length || active) return;
     // A task's own room is coordinated once it becomes a conversation: someone posted in it, not only the task and its result.
-    if (store.meta(`task-room:${goalId}`) && !store.roomPosts(goalId, 0, 500).some((post) => post.kind === "post")) return;
+    if (
+      store.meta(`task-room:${goalId}`) &&
+      !store.roomPosts(goalId, 0, 500).some((post) => post.kind === "post")
+    )
+      return;
     // A thread started through Harness by an agent that runs elsewhere gets no rounds until the person sets a spend ceiling.
     if (store.meta(`hosted-thread:${goalId}`)) return;
     const local = mode() === "local";
     if (!local && !connected()) return;
-    const localAgent = local ? localAgents().find((agent) => agent === "claude-code" || agent === "codex") : null;
+    const localAgent = local
+      ? localAgents().find(
+          (agent) => agent === "claude-code" || agent === "codex"
+        )
+      : null;
     if (local && !localAgent) return;
     const gathered = await facts(thread, state);
-    const lastSeq = store.roomPosts(goalId, 0, 500).at(-1)?.seq ?? state.lastSeenSeq;
-    const progressed = gathered.progress.runsFinished > 0 || gathered.progress.newResults > 0;
+    const lastSeq =
+      store.roomPosts(goalId, 0, 500).at(-1)?.seq ?? state.lastSeenSeq;
+    const progressed =
+      gathered.progress.runsFinished > 0 || gathered.progress.newResults > 0;
     const startedAt = Date.now();
-    let decision = null, error = null;
+    let decision = null,
+      error = null;
     try {
       if (local) decision = await localDecision(localAgent, gathered);
       else {
         // No deadline of its own: the round ends when Harness answers or the connection drops.
         const reply = await askHarness("coordinate", gathered, null);
-        if (!reply.ok) throw new Error(reply.error || "Harness did not coordinate this round");
+        if (!reply.ok)
+          throw new Error(
+            reply.error || "Harness did not coordinate this round"
+          );
         decision = reply.result ?? reply;
       }
-    } catch (failure) { error = failure.message; }
-    const next = { ...state, lastSeenSeq: lastSeq, rounds: state.rounds + 1, withoutProgress: progressed ? 0 : state.withoutProgress + 1, lastRoundAt: new Date().toISOString(), lastError: error };
+    } catch (failure) {
+      error = failure.message;
+    }
+    const next = {
+      ...state,
+      lastSeenSeq: lastSeq,
+      rounds: state.rounds + 1,
+      withoutProgress: progressed ? 0 : state.withoutProgress + 1,
+      lastRoundAt: new Date().toISOString(),
+      lastError: error,
+    };
     saveState(goalId, next);
-    store.recordRound({ goalId, coordinator: local ? localAgent : "harness", action: decision?.action ?? null, agent: decision?.agent ?? null, loop: decision?.loop ?? null,
-      judgments: decision?.judgments ?? null, progress: gathered.progress, estimatedMicroUsd: decision?.estimatedMicroUsd ?? null, elapsedMs: Date.now() - startedAt, error });
+    store.recordRound({
+      goalId,
+      coordinator: local ? localAgent : "harness",
+      action: decision?.action ?? null,
+      agent: decision?.agent ?? null,
+      loop: decision?.loop ?? null,
+      judgments: decision?.judgments ?? null,
+      progress: gathered.progress,
+      estimatedMicroUsd: decision?.estimatedMicroUsd ?? null,
+      elapsedMs: Date.now() - startedAt,
+      error,
+    });
     if (error) {
       log(`coordinator round for ${goalId}: ${error}`);
-      if (error !== state.lastError) store.roomPost({ goalId, author: thread.goal.facilitator, kind: "note", text: `Harness could not coordinate: ${error}` });
+      if (error !== state.lastError)
+        store.roomPost({
+          goalId,
+          author: thread.goal.facilitator,
+          kind: "note",
+          text: `Harness could not coordinate: ${error}`,
+        });
       notifyBoard(store.getTask(goalId));
       return;
     }
-    apply(store.getTask(goalId), decision, thread.goal.facilitator, gathered.candidates);
+    apply(
+      store.getTask(goalId),
+      decision,
+      thread.goal.facilitator,
+      gathered.candidates
+    );
   };
 
   /** A thread changed: run a round once it is quiet; one at a time per thread, again if more came in meanwhile. */
   const poke = (goalId) => {
-    if (busy.has(goalId)) { again.add(goalId); return; }
+    if (busy.has(goalId)) {
+      again.add(goalId);
+      return;
+    }
     busy.add(goalId);
-    setImmediate(() => void round(goalId).catch((failure) => log(`coordinator ${goalId}: ${failure.message}`)).finally(() => {
-      busy.delete(goalId);
-      if (again.delete(goalId)) poke(goalId);
-    }));
+    setImmediate(
+      () =>
+        void round(goalId)
+          .catch((failure) => log(`coordinator ${goalId}: ${failure.message}`))
+          .finally(() => {
+            busy.delete(goalId);
+            if (again.delete(goalId)) poke(goalId);
+          })
+    );
   };
   return { poke, state: stateOf };
 }