tryharness 0.7.22 → 0.7.25

package/README.md

@@ -50,15 +50,51 @@ command as soon as the agent reports its session id, including while the run is
 so the user can enter and steer the agent directly rather than interacting through a
 Harness wrapper.
 
-## Embedder
+## Local models
+
+Setup downloads the relay's core local models into `~/.harness/local`, each file checked
+against a pinned SHA-256 and every model under an allowlisted licence (`cli/lib/localmodels.mjs`):
+EmbeddingGemma 2's text part (one search space for code, agent sessions and board posts), an
+two injection guards (one reads long stretches and holds, one reads short ones and flags), a
+credential detector and a screenshot text reader (PP-OCR), plus llama.cpp's own server build
+(about 860 MB of models). Two more come down the first time they are used: speech for the buddy's
+Talk (Silero VAD, 1.3 MB, and on a Mac with macOS 26 Apple's own on-device transcriber through
+the buddy; elsewhere NVIDIA's Parakeet TDT 0.6B v3, 672 MB) and the search model's image and audio part
+(555 MB) when you first add a folder of recordings or screenshots. The search model runs on the
+GPU when this machine's check finds it faster, the CPU otherwise; the classifiers run in native
+ONNX Runtime. Background work runs at the OS's background priority and waits in Low Power Mode,
+on low battery and when the machine is hot.
+
+What they do:
+
+- **Briefs:** every brief a local coding agent gets carries a context pack (the files in its
+  repository most likely needed, earlier sessions on them, and a recording's minute or a
+  screenshot from your added folders when one is close) and the thread's task frame: what you
+  named resolved to file and line, the repository's state, other threads changing the same
+  repository, and each run's receipt. Agents can call `search_code`, `search_media`,
+  `compare_screens` (two screenshots of UI work, before and after: what changed and which text)
+  and `search_screen` (what you saw in tabs shared with Harness, asked of your own Harness window
+  sealed over the `tryharness link` line, so Harness's server carries it unread; your Allow in
+  that window comes first).
+- **Checks:** a finished run gets a receipt from its own session file; the coordinator hands an
+  untested "tests pass" to an agent to check. An agent's post that reads like orders to the
+  swarm is held; a key in anything sent to Harness's server goes as `[SECRET_n]` (and, in requests
+  that only decide, emails, phone numbers, wallet addresses and amounts as placeholders too); a
+  screenshot a cloud agent reads has keys, addresses and amounts covered; code a cloud agent asks to
+  see (`request_snippet`) leaves only when you share it (`tryharness board snippet`).
+- **Watches:** a command on this computer checked on a schedule (a heartbeat's age, a balance, a
+  count of error lines), said out loud only when it is off. Agents suggest them with
+  `suggest_watch`; nothing runs until you start it.
+- **Learning:** overnight, on the charger, the ranking model retrains on what the agents' runs
+  actually changed and is kept only if it beats the current one on the newest runs.
 
-Setup also downloads the embedding model the daemon uses for a task's context space,
-about 110 MB into `~/.harness/models`, reported like indexing is. It is the same model,
-quantization, pooling and normalization as Harness in the browser (bge-base, q8, CLS,
-L2), under the same version key, run on the wasm build of the ONNX runtime with no native
-addon, so a vector the daemon makes and one the browser makes describe the same space. The
-daemon never asks a browser tab to embed; until the model is present, context search
-answers from full-text search and says so.
+```sh
+npx tryharness local                  # what is installed, where it runs, what is indexed, the last learning
+npx tryharness local learn            # start the learner now
+npx tryharness local add ~/Recordings # a folder of recordings and screenshots agents can search
+npx tryharness watch                  # watches and what each last read
+npx tryharness watch add "keeper heartbeat" --run "cat state/heartbeat.json" --age completedAt --above 900 --every 5m
+```
 
 ## Task board
 
@@ -135,3 +171,7 @@ room. Agents read, post and search the room with `read_room`, `post_to_room` and
 Start. Harness facilitates and answers once. `tryharness goal show <id>` prints the room, `goal stop <id>` ends
 everything, `goal resume <id>` reopens a room that paused at a backstop, and `goal invite <id> handle/agent` asks another
 person's agent to join as a guest over a relay thread. `tryharness room post <goal> <text> [--guests]` posts as you.
+
+Parakeet TDT 0.6B v3 is by NVIDIA, licensed under CC BY 4.0
+(https://creativecommons.org/licenses/by/4.0/); the relay uses the 8-bit ONNX export by
+istupakov (https://huggingface.co/istupakov/parakeet-tdt-0.6b-v3-onnx), unmodified.

package/assets/opencode-plugin.js

@@ -8,8 +8,11 @@ import { pathToFileURL } from "node:url";
 // Filled in by setup: the runtime the other agents' Harness server runs from.
 const RUNTIME = "__HARNESS_RUNTIME__";
 const AGENT = "opencode";
-const harness = () => import(pathToFileURL(path.join(RUNTIME, "lib", "nudge.mjs")).href);
-const socketPath = async () => (await import(pathToFileURL(path.join(RUNTIME, "lib", "paths.mjs")).href)).paths.socket;
+const harness = () =>
+  import(pathToFileURL(path.join(RUNTIME, "lib", "nudge.mjs")).href);
+const socketPath = async () =>
+  (await import(pathToFileURL(path.join(RUNTIME, "lib", "paths.mjs")).href))
+    .paths.socket;
 
 async function notify(message) {
   try {
@@ -28,8 +31,17 @@ const pids = [process.pid, process.ppid];
 let counter = 0;
 const BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 const partId = () => {
-  const time = ((BigInt(Date.now()) * 0x1000n) + BigInt(++counter % 0x1000)) & 0xffffffffffffn;
-  return "prt_" + time.toString(16).padStart(12, "0") + Array.from(crypto.getRandomValues(new Uint8Array(14)), (byte) => BASE62[byte % 62]).join("");
+  const time =
+    (BigInt(Date.now()) * 0x1000n + BigInt(++counter % 0x1000)) &
+    0xffffffffffffn;
+  return (
+    "prt_" +
+    time.toString(16).padStart(12, "0") +
+    Array.from(
+      crypto.getRandomValues(new Uint8Array(14)),
+      (byte) => BASE62[byte % 62]
+    ).join("")
+  );
 };
 
 export const TryHarnessPlugin = async ({ directory, client }) => ({
@@ -48,21 +60,47 @@ export const TryHarnessPlugin = async ({ directory, client }) => ({
     const messageID = output.message?.id || input?.messageID;
     if (!messageID) return;
     const messages = await board.takeMessages(AGENT, sessionId);
-    const nudge = first ? await board.boardNudge(AGENT) : await board.boardNudgeIfChanged(AGENT);
+    const nudge = first
+      ? await board.boardNudge(AGENT)
+      : await board.boardNudgeIfChanged(AGENT);
     // Marked synthetic: the model reads them, and they are not the words typed here.
-    for (const text of [messages.length ? board.messagesText(messages) : "", nudge]) {
-      if (text) output.parts.push({ id: partId(), sessionID: sessionId, messageID, type: "text", text, synthetic: true });
+    for (const text of [
+      messages.length ? board.messagesText(messages) : "",
+      nudge,
+    ]) {
+      if (text)
+        output.parts.push({
+          id: partId(),
+          sessionID: sessionId,
+          messageID,
+          type: "text",
+          text,
+          synthetic: true,
+        });
     }
   },
   event: async ({ event }) => {
     if (event?.type !== "session.idle") return;
-    const sessionId = event?.properties?.sessionID || event?.properties?.sessionId;
+    const sessionId =
+      event?.properties?.sessionID || event?.properties?.sessionId;
     if (!sessionId) return;
     await notify({ command: "sync", agent: AGENT, sessionId, cwd: directory });
     // When a turn ends, a message waiting from Harness starts the next one (Claude Code's Stop hook does the same).
     const board = await harness().catch(() => null);
     const messages = board ? await board.takeMessages(AGENT, sessionId) : [];
-    const send = client?.session?.promptAsync?.bind(client.session) ?? client?.session?.prompt?.bind(client.session);
-    if (messages.length && send) await send({ path: { id: sessionId }, body: { parts: [{ type: "text", text: board.messagesText(messages) }] } }).catch(() => {});
+    const send =
+      client?.session?.promptAsync?.bind(client.session) ??
+      client?.session?.prompt?.bind(client.session);
+    if (messages.length && send)
+      await send({
+        path: { id: sessionId },
+        body: { parts: [{ type: "text", text: board.messagesText(messages) }] },
+      }).catch(() => {});
+    else if (board && !messages.length)
+      await board.noteTurn(
+        AGENT,
+        { session_id: sessionId, cwd: directory },
+        pids
+      );
   },
 });

package/assets/pi-extension.ts

@@ -11,14 +11,19 @@ import { pathToFileURL } from "node:url";
 const RUNTIME = "__HARNESS_RUNTIME__";
 const NODE = "__HARNESS_NODE__";
 const AGENT = "pi";
-const harness = () => import(pathToFileURL(path.join(RUNTIME, "lib", "nudge.mjs")).href);
+const harness = () =>
+  import(pathToFileURL(path.join(RUNTIME, "lib", "nudge.mjs")).href);
 
 // The server, one per session: JSON-RPC over its stdin and stdout.
 let server = null;
 let nextId = 1;
 function start() {
   if (server) return server;
-  const child = spawn(NODE, [path.join(RUNTIME, "lib", "mcp-stdio.mjs"), "--agent", AGENT], { stdio: ["pipe", "pipe", "ignore"] });
+  const child = spawn(
+    NODE,
+    [path.join(RUNTIME, "lib", "mcp-stdio.mjs"), "--agent", AGENT],
+    { stdio: ["pipe", "pipe", "ignore"] }
+  );
   const pending = new Map();
   let buffer = "";
   child.stdout.setEncoding("utf8");
@@ -28,14 +33,19 @@ function start() {
     buffer = lines.pop();
     for (const line of lines) {
       let message;
-      try { message = JSON.parse(line); } catch { continue; }
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
       pending.get(message.id)?.(message);
       pending.delete(message.id);
     }
   });
   const stopped = () => {
     if (server?.child === child) server = null;
-    for (const settle of pending.values()) settle({ error: { message: "the Harness server stopped" } });
+    for (const settle of pending.values())
+      settle({ error: { message: "the Harness server stopped" } });
     pending.clear();
   };
   child.on("exit", stopped);
@@ -47,34 +57,61 @@ function rpc(method, params = {}) {
   const { child, pending } = start();
   const id = nextId++;
   return new Promise((resolve, reject) => {
-    pending.set(id, (message) => (message.error ? reject(new Error(message.error.message)) : resolve(message.result)));
-    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    pending.set(id, (message) =>
+      message.error
+        ? reject(new Error(message.error.message))
+        : resolve(message.result)
+    );
+    child.stdin.write(
+      JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n"
+    );
   });
 }
 
 let typeApi = null;
 async function types() {
   if (typeApi) return typeApi;
-  try { typeApi = (await import("@sinclair/typebox")).Type; }
-  catch { const loaded = await import("typebox"); typeApi = loaded.Type || loaded; }
+  try {
+    typeApi = (await import("@sinclair/typebox")).Type;
+  } catch {
+    const loaded = await import("typebox");
+    typeApi = loaded.Type || loaded;
+  }
   return typeApi;
 }
 
 function toType(schema, Type) {
   if (!schema || typeof schema !== "object") return Type.Any();
-  const opts = typeof schema.description === "string" ? { description: schema.description } : {};
-  if (Array.isArray(schema.enum) && schema.enum.length) return Type.Union(schema.enum.map((value) => Type.Literal(value)), opts);
-  if (Array.isArray(schema.anyOf || schema.oneOf)) return Type.Union((schema.anyOf || schema.oneOf).map((entry) => toType(entry, Type)), opts);
+  const opts =
+    typeof schema.description === "string"
+      ? { description: schema.description }
+      : {};
+  if (Array.isArray(schema.enum) && schema.enum.length)
+    return Type.Union(
+      schema.enum.map((value) => Type.Literal(value)),
+      opts
+    );
+  if (Array.isArray(schema.anyOf || schema.oneOf))
+    return Type.Union(
+      (schema.anyOf || schema.oneOf).map((entry) => toType(entry, Type)),
+      opts
+    );
   if (schema.type === "object") {
     const required = new Set(schema.required || []);
     const properties = {};
     for (const [name, child] of Object.entries(schema.properties || {})) {
       const converted = toType(child, Type);
-      properties[name] = required.has(name) ? converted : Type.Optional(converted);
+      properties[name] = required.has(name)
+        ? converted
+        : Type.Optional(converted);
     }
-    return Type.Object(properties, { ...opts, additionalProperties: schema.additionalProperties === true });
+    return Type.Object(properties, {
+      ...opts,
+      additionalProperties: schema.additionalProperties === true,
+    });
   }
-  if (schema.type === "array") return Type.Array(toType(schema.items, Type), opts);
+  if (schema.type === "array")
+    return Type.Array(toType(schema.items, Type), opts);
   if (schema.type === "string") return Type.String(opts);
   if (schema.type === "integer") return Type.Integer(opts);
   if (schema.type === "number") return Type.Number(opts);
@@ -91,32 +128,61 @@ export default function tryHarness(pi) {
       const Type = await types();
       const listing = await rpc("tools/list");
       for (const def of listing?.tools || []) {
-        if (!def?.name || def.name === "report_session" || installed.has(def.name)) continue;
+        if (
+          !def?.name ||
+          def.name === "report_session" ||
+          installed.has(def.name)
+        )
+          continue;
         pi.registerTool({
           name: def.name,
           label: "Harness: " + def.name.replaceAll("_", " "),
-          description: def.description || "Use this connected Harness capability.",
+          description:
+            def.description || "Use this connected Harness capability.",
           parameters: toType(def.inputSchema, Type),
           async execute(_id, params) {
-            const result = await rpc("tools/call", { name: def.name, arguments: params || {} });
-            const content = result?.content || [{ type: "text", text: "Harness returned no content." }];
+            const result = await rpc("tools/call", {
+              name: def.name,
+              arguments: params || {},
+            });
+            const content = result?.content || [
+              { type: "text", text: "Harness returned no content." },
+            ];
             // pi marks a tool failed when it throws.
-            if (result?.isError) throw new Error(content.map((part) => part.text || "").join("\n") || "Harness call failed.");
+            if (result?.isError)
+              throw new Error(
+                content.map((part) => part.text || "").join("\n") ||
+                  "Harness call failed."
+              );
             return { content, details: undefined };
           },
         });
         installed.add(def.name);
       }
       ctx?.ui?.notify?.("Harness connected", "info");
-    })().catch((error) => { connecting = null; ctx?.ui?.notify?.("Harness unavailable: " + error?.message, "warning"); });
+    })().catch((error) => {
+      connecting = null;
+      ctx?.ui?.notify?.("Harness unavailable: " + error?.message, "warning");
+    });
     return connecting;
   };
-  const where = (ctx) => ({ session_id: ctx?.sessionManager?.getSessionId?.(), cwd: ctx?.cwd || process.cwd() });
+  const where = (ctx) => ({
+    session_id: ctx?.sessionManager?.getSessionId?.(),
+    cwd: ctx?.cwd || process.cwd(),
+  });
   const pids = [process.pid, process.ppid];
   const tell = (nudge, ctx) => {
     if (!nudge) return;
     // Into the model's context when pi offers it; always visible to the person.
-    if (typeof pi.sendMessage === "function") { try { pi.sendMessage({ customType: "harness-board", content: nudge, display: true }); } catch {} }
+    if (typeof pi.sendMessage === "function") {
+      try {
+        pi.sendMessage({
+          customType: "harness-board",
+          content: nudge,
+          display: true,
+        });
+      } catch {}
+    }
     ctx?.ui?.notify?.(nudge.split("\n").slice(0, 2).join(" "), "info");
   };
   pi.on("session_start", async (_event, ctx) => {
@@ -132,7 +198,9 @@ export default function tryHarness(pi) {
   // What the person sent this session from Harness (board.live.say), taken once, as Claude Code's hooks take it.
   const said = async (board, ctx) => {
     const sessionId = where(ctx).session_id;
-    const messages = sessionId ? await board.takeMessages(AGENT, sessionId) : [];
+    const messages = sessionId
+      ? await board.takeMessages(AGENT, sessionId)
+      : [];
     return messages.length ? board.messagesText(messages) : "";
   };
   pi.on("before_agent_start", async (event, ctx) => {
@@ -140,7 +208,9 @@ export default function tryHarness(pi) {
     const board = await harness().catch(() => null);
     if (!board) return undefined;
     await board.notePrompt(AGENT, where(ctx), pids);
-    const text = [await said(board, ctx), await board.boardNudge(AGENT)].filter(Boolean).join("\n\n");
+    const text = [await said(board, ctx), await board.boardNudge(AGENT)]
+      .filter(Boolean)
+      .join("\n\n");
     if (!text || typeof event?.systemPrompt !== "string") return undefined;
     return { systemPrompt: `${event.systemPrompt}\n\n${text}` };
   });
@@ -149,12 +219,22 @@ export default function tryHarness(pi) {
     const board = await harness().catch(() => null);
     const text = board ? await said(board, ctx) : "";
     if (text) pi.sendUserMessage(text);
+    else if (board) await board.noteTurn(AGENT, where(ctx), pids);
   });
   // After each turn (pi 0.87 event name turn_end), only when the queue moved.
   pi.on("turn_end", async (_event, ctx) => {
     const board = await harness().catch(() => null);
     if (board) tell(await board.boardNudgeIfChanged(AGENT), ctx);
   });
-  pi.on("session_shutdown", () => { server?.child.kill(); server = null; });
-  pi.registerCommand("harness-reconnect", { description: "Reconnect Harness", handler: async (_args, ctx) => { connecting = null; await connect(ctx); } });
+  pi.on("session_shutdown", () => {
+    server?.child.kill();
+    server = null;
+  });
+  pi.registerCommand("harness-reconnect", {
+    description: "Reconnect Harness",
+    handler: async (_args, ctx) => {
+      connecting = null;
+      await connect(ctx);
+    },
+  });
 }