tryharness 0.7.22 → 0.7.23

package/lib/trails.mjs

@@ -0,0 +1,177 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+
+// What a coding session actually did, read from the agent's own session file: the person's first request, every tool
+// call in order (the paths it named, the files it changed, commands with their exit codes) and the tokens each model
+// call used. This is the record the context engine learns from (what a run needed against what its brief carried) and
+// the evidence receipts check claims against. Read only; the parsers never decide anything about intent.
+
+const PATH_TOKEN = /(?:\.{0,2}\/)?[\w@+-][\w@+.-]*(?:\/[\w@+.-]+)+|[\w@+-][\w@+-]*\.[A-Za-z][A-Za-z0-9]{0,7}\b/g;
+const PATCH_FILE = /\*\*\* (?:Update|Add|Delete) File: ([^\n"\\]+)/g;
+const REDIRECT_FILE = /(?:^|[\s;&|])(?:>>?|tee(?:\s+-a)?)\s+(["']?)([^\s"'|;&<>]+)\1/g;
+const SED_INPLACE = /\bsed\s+(?:-[a-zA-Z]*i[a-zA-Z]*(?:\s+''|\s+"")?|--in-place)\b[^|;&]*?\s(["']?)([^\s"'|;&]+)\1\s*(?:$|[|;&])/gm;
+// Test runners by their command, for receipts: a command's own exit code is the evidence, never the agent's words.
+const TEST_COMMAND = /\b(?:npm(?:\s+run)?\s+(?:test|smoke|e2e|eval|lint|typecheck)|npx\s+(?:jest|vitest|tsx\s+tests\/|playwright\s+test)|jest|vitest|pytest|cargo\s+(?:test|check|clippy)|go\s+test|forge\s+test|bun\s+test|deno\s+test|swift\s+test|mvn\s+test|gradlew?\s+test|make\s+(?:test|check)|node\s+(?:--test\b|[\w./-]*\btests?\/)|tsc(?:\s|$))/;
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit", "edit", "write", "apply_patch"]);
+const BRIEF_SKIP = /^<(?:command-|local-command|system-reminder|task-notification|user-prompt-submit-hook)|^Caveat:/;
+
+const parseJson = (line) => { try { const value = JSON.parse(line); return value && typeof value === "object" ? value : null; } catch { return null; } };
+const textOf = (content) => typeof content === "string" ? content
+  : Array.isArray(content) ? content.map((part) => (typeof part?.text === "string" ? part.text : "")).filter(Boolean).join("\n") : "";
+const ms = (value) => { const at = typeof value === "number" ? value * (value < 1e12 ? 1000 : 1) : Date.parse(value); return Number.isFinite(at) ? at : null; };
+
+/** Path-like words in a tool call's input or output, as written (relative or absolute). */
+export function pathTokens(text) {
+  return [...new Set(String(text).match(PATH_TOKEN) || [])].map((token) => token.replace(/[.,:;)\]}'"`]+$/, "")).filter((token) => token.length > 2 && token.length < 300);
+}
+
+/** Files a tool call changed: edit tools' own paths, patch headers, sed -i, redirects and tee. */
+export function editedPaths(tool, input) {
+  const out = new Set();
+  if (EDIT_TOOLS.has(tool) && typeof input?.file_path === "string") out.add(input.file_path);
+  if (EDIT_TOOLS.has(tool) && typeof input === "string") { const found = input.match(/"(?:file_path|path)":"([^"]+)"/); if (found && !found[1].endsWith("…")) out.add(found[1]); }
+  if (EDIT_TOOLS.has(tool) && typeof input?.path === "string") out.add(input.path);
+  if (tool === "NotebookEdit" && typeof input?.notebook_path === "string") out.add(input.notebook_path);
+  const text = typeof input === "string" ? input : JSON.stringify(input ?? "").replace(/\\n/g, "\n").replace(/\\"/g, "\"");
+  for (const match of text.matchAll(PATCH_FILE)) out.add(match[1].trim());
+  for (const match of text.matchAll(SED_INPLACE)) out.add(match[2]);
+  for (const match of text.matchAll(REDIRECT_FILE)) if (!/^\/dev\/|^&\d$/.test(match[2])) out.add(match[2]);
+  return [...out];
+}
+
+export const isTestCommand = (command) => TEST_COMMAND.test(String(command));
+
+function exitCodeOf(text) {
+  const found = String(text).match(/"?exit_code"?\s*[:=]\s*(-?\d+)|Exit code:?\s*(-?\d+)|Process exited with code (-?\d+)/i);
+  return found ? Number(found[1] ?? found[2] ?? found[3]) : null;
+}
+
+/**
+ * A session's trail: { agent, sessionId, cwd, brief, startedAt, endedAt, calls, usage, turns }. A call is
+ * { at, tool, input (clipped text), named (path words), edited (paths), command, exitCode, error }; usage is one row
+ * per model call { at, input, cached, output }; turns are the person's messages and stops, { at, interrupted }. Claude Code and Codex are read in full; other agents fall back to none.
+ */
+export async function readTrail(agent, file) {
+  if (!["claude-code", "codex"].includes(agent) || !fs.existsSync(file)) return null;
+  const trail = { agent, sessionId: null, cwd: null, brief: null, startedAt: null, endedAt: null, calls: [], usage: [], turns: [] };
+  const byId = new Map();
+  const add = (at, tool, input, id) => {
+    const text = typeof input === "string" ? input : JSON.stringify(input ?? {});
+    const command = typeof input?.command === "string" ? input.command : Array.isArray(input?.command) ? input.command.join(" ") : typeof input?.cmd === "string" ? input.cmd
+      : [...text.matchAll(/cmd\s*:\s*"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1]).join("\n") || null;
+    const call = { at, tool, input: text.slice(0, 4_000), named: pathTokens(text), edited: editedPaths(tool, input), command, exitCode: null, error: false, output: "" };
+    trail.calls.push(call);
+    if (id) byId.set(id, call);
+  };
+  const result = (id, text, error) => {
+    const call = byId.get(id);
+    if (!call) return;
+    call.output = String(text).slice(0, 4_000);
+    call.named = [...new Set([...call.named, ...pathTokens(String(text).slice(0, 20_000))])];
+    call.exitCode = exitCodeOf(text);
+    call.error = Boolean(error) || (call.exitCode !== null && call.exitCode !== 0);
+  };
+  const lines = readline.createInterface({ input: fs.createReadStream(file, { encoding: "utf8" }), crlfDelay: Infinity });
+  for await (const line of lines) {
+    const row = parseJson(line);
+    if (!row) continue;
+    const at = ms(row.timestamp ?? row.payload?.timestamp);
+    if (at) { trail.startedAt ??= at; trail.endedAt = at; }
+    if (agent === "claude-code") {
+      trail.sessionId ??= row.sessionId ?? null;
+      trail.cwd ??= row.cwd ?? null;
+      const content = row.message?.content;
+      if (row.type === "user" && !row.isMeta) {
+        const words = (typeof content === "string" ? content : Array.isArray(content) && !content.some((part) => part?.type === "tool_result") ? textOf(content) : "").trim();
+        // The person's turns: each message starts one; Esc leaves "[Request interrupted by user...]" where it stopped one.
+        if (words.startsWith("[Request interrupted by user")) trail.turns.push({ at, interrupted: true });
+        else if (words && !BRIEF_SKIP.test(words)) { trail.turns.push({ at, interrupted: false }); trail.brief ??= words; }
+      }
+      if (Array.isArray(content)) for (const part of content) {
+        if (part?.type === "tool_use") add(at, part.name, part.input, part.id);
+        if (part?.type === "tool_result") result(part.tool_use_id, textOf(part.content) || JSON.stringify(row.toolUseResult ?? ""), part.is_error);
+      }
+      const usage = row.type === "assistant" ? row.message?.usage : null;
+      if (usage) trail.usage.push({ at, input: (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0), cached: usage.cache_read_input_tokens || 0, output: usage.output_tokens || 0 });
+    } else {
+      const payload = row.payload ?? {};
+      if (row.type === "session_meta") { trail.sessionId ??= payload.id ?? null; trail.cwd ??= payload.cwd ?? null; }
+      if (row.type === "response_item" && payload.type === "message" && payload.role === "user") {
+        const words = textOf(payload.content).trim();
+        if (words && !/^<(?:environment_context|user_instructions|permissions|turn_aborted)/.test(words) && !words.startsWith("# AGENTS.md")) { trail.turns.push({ at, interrupted: false }); trail.brief ??= words; }
+      }
+      if (row.type === "event_msg" && payload.type === "turn_aborted" && payload.reason === "interrupted") trail.turns.push({ at, interrupted: true });
+      if (row.type === "response_item" && ["function_call", "custom_tool_call", "local_shell_call"].includes(payload.type)) {
+        const input = payload.input ?? parseJson(payload.arguments) ?? payload.arguments ?? payload.action;
+        add(at, payload.name ?? payload.type, input, payload.call_id);
+      }
+      if (row.type === "response_item" && ["function_call_output", "custom_tool_call_output"].includes(payload.type)) {
+        const text = typeof payload.output === "string" ? payload.output : textOf(payload.output) || JSON.stringify(payload.output ?? "");
+        result(payload.call_id, text, false);
+      }
+      if (row.type === "token_usage_record" && payload.usage) trail.usage.push({ at, input: payload.usage.input_tokens || 0, cached: payload.usage.cached_input_tokens || 0, output: payload.usage.output_tokens || 0 });
+    }
+  }
+  return trail;
+}
+
+const RESULT_EDIT = /(?:The file (\S+) has been (?:updated|created)|File created successfully at: (\S+?)[\s)\]])/g;
+
+/**
+ * A trail rebuilt from the relay's own copy of a session (store.mjs keeps every message with tool calls clipped), for
+ * sessions whose source file the agent has since deleted. It has the brief, the calls with the paths they named and the
+ * files they changed (the edit tools' own confirmations carry the whole path), but no token counts or timestamps.
+ */
+export function trailFromTranscript(agent, transcript, { cwd = null, startedAt = null } = {}) {
+  const trail = { agent, sessionId: null, cwd, brief: null, startedAt, endedAt: startedAt, calls: [], usage: [] };
+  for (const block of String(transcript).split(/\n\n(?=(?:User|Agent): )/)) {
+    const user = block.startsWith("User: ");
+    const text = block.replace(/^(?:User|Agent): /, "");
+    if (user && !trail.brief && !text.startsWith("[tool result") && !BRIEF_SKIP.test(text.trim()) && !text.includes("<local-command-caveat>")) trail.brief = text.trim();
+    for (const match of text.matchAll(/\[tool: (\S+) ([\s\S]*?)\](?=\n|$)/g)) {
+      trail.calls.push({ at: null, tool: match[1], input: match[2], named: pathTokens(match[2]), edited: editedPaths(match[1], match[2]).filter((file) => !file.endsWith("…")), command: null, exitCode: null, error: false, output: "" });
+    }
+    if (user && text.startsWith("[tool result")) {
+      const last = trail.calls.at(-1);
+      if (!last) continue;
+      last.named = [...new Set([...last.named, ...pathTokens(text)])];
+      for (const match of text.matchAll(RESULT_EDIT)) last.edited = [...new Set([...last.edited, match[1] || match[2]])];
+    }
+  }
+  return trail;
+}
+
+/** A path as written in a call, made relative to root when it lies inside it; null when it points elsewhere. */
+export function insideRoot(token, root, cwd = root) {
+  const absolute = path.isAbsolute(token) ? token : path.resolve(cwd || root, token);
+  const rel = path.relative(root, absolute);
+  return rel && !rel.startsWith("..") && !path.isAbsolute(rel) ? rel.split(path.sep).join("/") : null;
+}
+
+/**
+ * What a trail shows a run needed, against the files that existed: { edited, read, firstEditAt, beforeFirstEdit }.
+ * `read` is every existing file the run named before its first edit (opened, listed, grepped into); `beforeFirstEdit`
+ * counts the calls and tokens spent before that edit, which is what a better brief can save.
+ */
+export function needs(trail, root, files) {
+  const known = (token) => { const rel = insideRoot(token, root, trail.cwd); return rel && files.has(rel) ? rel : null; };
+  const edited = new Set();
+  const read = new Set();
+  let firstEditAt = null;
+  let editing = false;
+  let callsBefore = 0;
+  for (const call of trail.calls) {
+    const changed = call.edited.map(known).filter(Boolean);
+    if (changed.length && !editing) { editing = true; firstEditAt = call.at; }
+    for (const file of changed) edited.add(file);
+    if (!editing) { callsBefore += 1; for (const token of call.named) { const file = known(token); if (file) read.add(file); } }
+  }
+  const before = trail.usage.filter((row) => !editing || firstEditAt === null || (row.at ?? 0) < firstEditAt);
+  return {
+    edited: [...edited], read: [...read], firstEditAt,
+    beforeFirstEdit: { calls: callsBefore, modelCalls: before.length, inputTokens: before.reduce((sum, row) => sum + row.input, 0),
+      uncachedInputTokens: before.reduce((sum, row) => sum + Math.max(0, row.input - row.cached), 0), outputTokens: before.reduce((sum, row) => sum + row.output, 0),
+      ms: firstEditAt !== null && trail.startedAt !== null ? firstEditAt - trail.startedAt : null },
+  };
+}

package/lib/watches.mjs

@@ -0,0 +1,163 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+
+// Watches: something the person wants kept an eye on, read by a command on this computer on a schedule (a log, a status
+// command, a balance), and said out loud only when it is off. Each check reads one number from the command's output (a
+// field like "ageSeconds" or the count of lines matching a pattern like "critical") and compares it with a limit the
+// watch names, or, without one, with its own usual range once it has enough history. A falling number with a floor gets
+// a run-out estimate. Plain arithmetic, no model. An agent may suggest a watch; it runs only once the person starts it.
+// The October 13 keeper outage is why: its own health job logged "no recent successful keeper run" every 5 minutes for
+// 41 hours and nobody saw it.
+
+const HISTORY = 500;
+const USUAL_AFTER = 12;
+const MIN_EVERY_SECONDS = 5;
+const RUN_OUT_HOURS = 24;
+
+const median = (values) => { const sorted = [...values].sort((a, b) => a - b); const mid = sorted.length >> 1; return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2; };
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * The number a check reads from output: how many lines hold a phrase (count), seconds since a named field's last
+ * timestamp (age: unix seconds, milliseconds or an ISO date), a named field's last value (field), or the last number in
+ * it. null when absent.
+ */
+export function readNumber(output, measure, now = Date.now()) {
+  const text = String(output ?? "");
+  if (measure.count) return text.split("\n").filter((line) => line.toLowerCase().includes(String(measure.count).toLowerCase())).length;
+  if (measure.age) {
+    const found = [...text.matchAll(new RegExp(`["']?${escape(measure.age)}["']?\\s*[:=]\\s*"?([0-9][0-9:.TZ+-]*)`, "g"))].at(-1)?.[1];
+    if (!found) return null;
+    const at = /^\d+(?:\.\d+)?$/.test(found) ? Number(found) * (Number(found) < 1e12 ? 1000 : 1) : Date.parse(found);
+    return Number.isFinite(at) ? Math.max(0, Math.round((now - at) / 1000)) : null;
+  }
+  if (measure.field) {
+    const found = [...text.matchAll(new RegExp(`["']?${escape(measure.field)}["']?\\s*[:=]\\s*"?(-?\\d+(?:\\.\\d+)?)`, "g"))].at(-1);
+    return found ? Number(found[1]) : null;
+  }
+  const found = text.match(/-?\d+(?:\.\d+)?(?=\D*$)/);
+  return found ? Number(found[0]) : null;
+}
+
+/**
+ * Whether the newest sample is off, and why: past a limit the watch names, outside its usual range (median and spread of
+ * its history, once it has some), or, falling toward its floor, due to cross it within a day. null when it is fine.
+ */
+export function offPattern(samples, { above = null, below = null } = {}) {
+  const values = samples.map((sample) => sample.value).filter((value) => value !== null && Number.isFinite(value));
+  const latest = samples.at(-1);
+  if (!latest || latest.value === null) return latest?.error ? { kind: "failed", text: `its check failed: ${latest.error}` } : null;
+  if (above !== null && latest.value > above) return { kind: "limit", text: `is ${latest.value}, above ${above}` };
+  if (below !== null && latest.value < below) return { kind: "limit", text: `is ${latest.value}, below ${below}` };
+  if (below !== null && samples.length >= 4) {
+    // Falling toward the floor: a straight line through the recent samples, and when it reaches it.
+    const recent = samples.slice(-12).filter((sample) => sample.value !== null);
+    const t0 = recent[0].at;
+    const xs = recent.map((sample) => (sample.at - t0) / 3_600_000), ys = recent.map((sample) => sample.value);
+    const mx = xs.reduce((a, b) => a + b, 0) / xs.length, my = ys.reduce((a, b) => a + b, 0) / ys.length;
+    const slope = xs.reduce((sum, x, i) => sum + (x - mx) * (ys[i] - my), 0) / (xs.reduce((sum, x) => sum + (x - mx) ** 2, 0) || 1);
+    if (slope < 0) {
+      const hours = (latest.value - below) / -slope;
+      if (hours <= RUN_OUT_HOURS) return { kind: "run-out", text: `is falling by ${Math.abs(slope).toPrecision(2)} an hour and reaches ${below} in about ${hours < 1 ? `${Math.max(1, Math.round(hours * 60))} minutes` : `${Math.round(hours)} hour${Math.round(hours) === 1 ? "" : "s"}`}` };
+    }
+  }
+  if (above === null && below === null && values.length > USUAL_AFTER) {
+    const history = values.slice(0, -1).slice(-100);
+    const middle = median(history);
+    // A number that takes two values (a sawtooth, a flag) has no median deviation; the mean deviation stands in.
+    const deviations = history.map((value) => Math.abs(value - middle));
+    const spread = median(deviations) || deviations.reduce((a, b) => a + b, 0) / deviations.length || Math.max(1e-9, Math.abs(middle) * 0.05);
+    if (Math.abs(latest.value - middle) > 6 * spread) return { kind: "unusual", text: `is ${latest.value}; it is usually about ${Number(middle.toPrecision(4))}` };
+  }
+  return null;
+}
+
+/** Runs a check's command in its folder; its output, or an error. A check never runs longer than its own interval. */
+function runCheck(watch, shell = process.env.SHELL || "/bin/sh") {
+  return new Promise((resolve) => {
+    const started = performance.now();
+    let out = "", err = "", done = false;
+    const child = spawn(shell, ["-lc", watch.command], { cwd: watch.folder || undefined, stdio: ["ignore", "pipe", "pipe"] });
+    const timer = setTimeout(() => { child.kill("SIGKILL"); finish(null, `it took longer than its ${watch.everySeconds} s interval`); }, watch.everySeconds * 1000);
+    const finish = (output, error) => { if (done) return; done = true; clearTimeout(timer); resolve({ output, error, ms: Math.round(performance.now() - started) }); };
+    child.stdout.on("data", (chunk) => { out = (out + chunk).slice(-200_000); });
+    child.stderr.on("data", (chunk) => { err = (err + chunk).slice(-4_000); });
+    child.on("error", (error) => finish(null, error.message));
+    child.on("close", (code) => finish(code === 0 || out ? out : null, code === 0 || out ? null : (err.trim().split("\n").at(-1) || `it exited with code ${code}`)));
+  });
+}
+
+export function createWatches({ store, notify = () => {}, log = () => {}, run = runCheck }) {
+  const list = () => { try { return JSON.parse(store.meta("watches") || "[]"); } catch { return []; } };
+  const save = (watches) => store.meta("watches", JSON.stringify(watches));
+  const samplesOf = (id) => { try { return JSON.parse(store.meta(`watch-samples:${id}`) || "[]"); } catch { return []; } };
+  const timers = new Map();
+
+  const check = async (id) => {
+    const watch = list().find((entry) => entry.id === id);
+    if (!watch || watch.state !== "on") return null;
+    const result = await run(watch);
+    const value = result.output === null ? null : readNumber(result.output, watch.measure);
+    const samples = [...samplesOf(id), { at: Date.now(), value, ms: result.ms, ...(result.error ? { error: result.error.slice(0, 300) } : value === null ? { error: "its output had no number to read" } : {}) }].slice(-HISTORY);
+    store.meta(`watch-samples:${id}`, JSON.stringify(samples));
+    const off = offPattern(samples, watch.measure);
+    const current = list().find((entry) => entry.id === id);
+    if (!current) return null;
+    // Said once when it goes off and once when it is back; not on every check while it stays off.
+    if (off && !current.off) {
+      const alert = { at: new Date().toISOString(), text: `${current.name} ${off.text}.`, kind: off.kind };
+      save(list().map((entry) => (entry.id === id ? { ...entry, off: alert } : entry)));
+      store.meta("watch-alerts", JSON.stringify([...(JSON.parse(store.meta("watch-alerts") || "[]")), { watch: id, ...alert }].slice(-200)));
+      notify(alert.text, { watch: current, alert });
+      log(`watch ${current.name}: ${off.text}`);
+    } else if (!off && current.off) {
+      save(list().map((entry) => (entry.id === id ? { ...entry, off: null } : entry)));
+      notify(`${current.name} is back to normal.`, { watch: current, alert: null });
+    }
+    return { value, off, ms: result.ms };
+  };
+
+  const schedule = (watch) => {
+    clearTimeout(timers.get(watch.id));
+    if (watch.state !== "on") { timers.delete(watch.id); return; }
+    const tick = () => { void check(watch.id).catch((error) => log(`watch ${watch.name}: ${error.message}`)).finally(() => { if (timers.has(watch.id)) timers.set(watch.id, setTimeout(tick, watch.everySeconds * 1000).unref?.() ?? null); }); };
+    timers.set(watch.id, setTimeout(tick, 0));
+  };
+
+  return {
+    list: () => list().map((watch) => ({ ...watch, samples: samplesOf(watch.id).slice(-20) })),
+    alerts: (since = "") => { try { return JSON.parse(store.meta("watch-alerts") || "[]").filter((alert) => alert.at > since); } catch { return []; } },
+    /** A new watch: the person's starts at once; an agent's waits for the person's start. */
+    add({ name, command, folder = null, everySeconds = 300, measure = {}, by = "user" }) {
+      if (!String(name || "").trim() || !String(command || "").trim()) return { ok: false, error: "a watch needs a name and a command to read" };
+      const every = Math.max(MIN_EVERY_SECONDS, Math.round(Number(everySeconds) || 300));
+      const clean = {
+        ...(measure.field ? { field: String(measure.field).slice(0, 100) } : {}), ...(measure.count ? { count: String(measure.count).slice(0, 100) } : {}), ...(measure.age ? { age: String(measure.age).slice(0, 100) } : {}),
+        above: Number.isFinite(Number(measure.above)) && measure.above !== null && measure.above !== "" ? Number(measure.above) : null,
+        below: Number.isFinite(Number(measure.below)) && measure.below !== null && measure.below !== "" ? Number(measure.below) : null,
+      };
+      const watch = { id: randomUUID(), name: String(name).trim().slice(0, 120), command: String(command).slice(0, 2_000), folder, everySeconds: every, measure: clean, by, state: by === "user" ? "on" : "suggested", off: null, createdAt: new Date().toISOString() };
+      save([...list(), watch]);
+      if (watch.state === "on") schedule(watch);
+      return { ok: true, watch };
+    },
+    start(id) {
+      const watch = list().find((entry) => entry.id === id);
+      if (!watch) return { ok: false, error: "no such watch" };
+      const on = { ...watch, state: "on" };
+      save(list().map((entry) => (entry.id === id ? on : entry)));
+      schedule(on);
+      return { ok: true, watch: on };
+    },
+    remove(id) {
+      if (!list().some((entry) => entry.id === id)) return { ok: false, error: "no such watch" };
+      clearTimeout(timers.get(id)); timers.delete(id);
+      save(list().filter((entry) => entry.id !== id));
+      store.meta(`watch-samples:${id}`, "[]");
+      return { ok: true };
+    },
+    check,
+    resume() { for (const watch of list()) if (watch.state === "on") schedule(watch); },
+    stop() { for (const timer of timers.values()) clearTimeout(timer); timers.clear(); },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.7.22",
+  "version": "0.7.23",
   "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"
@@ -32,15 +32,17 @@
     "@clack/core": "0.5.0",
     "@clack/prompts": "0.11.0",
     "@huggingface/tokenizers": "^0.1.3",
+    "jpeg-js": "0.4.4",
     "node-sqlite3-wasm": "0.8.60",
-    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c",
+    "onnxruntime-node": "1.24.3",
     "picocolors": "^1.1.1",
+    "pngjs": "7.0.0",
     "qr": "0.4.2",
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "tryharness-desktop-darwin-arm64": "0.7.22",
-    "tryharness-desktop-darwin-x64": "0.7.22",
+    "tryharness-desktop-darwin-arm64": "0.7.23",
+    "tryharness-desktop-darwin-x64": "0.7.23",
     "tryharness-desktop-linux-x64": "0.7.4",
     "tryharness-desktop-win32-x64": "0.7.4"
   }

package/lib/embedder.mjs

@@ -1,156 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { ensureDir } from "./files.mjs";
-
-// The daemon's own embedder for the context space: the same model, quantization, pooling
-// and normalization as the browser (src/shared/memory/embeddingService.ts), so the two
-// sides describe the same space under the same version key. It runs on onnxruntime-web's
-// Node build (wasm, no native addon) with the same tokenizer library transformers.js uses,
-// and mirrors transformers' feature-extraction pipeline step by step: tokenize with special
-// tokens, truncate to the model's 512, pad to the batch, take the [CLS] vector, L2-normalize.
-// Weights are downloaded into the Harness home during setup, never fetched from a browser.
-
-export const EMBEDDING_MODEL = "Xenova/bge-base-en-v1.5";
-export const EMBEDDING_DIMENSIONS = 768;
-export const EMBEDDING_VERSION = "bge-base-en-v1.5:q8:cls:l2:asymmetric:v1";
-const QUERY_PREFIX = "Represent this sentence for searching relevant passages: ";
-const MODEL_FILES = ["config.json", "tokenizer.json", "tokenizer_config.json", "onnx/model_quantized.onnx"];
-const REMOTE = `https://huggingface.co/${EMBEDDING_MODEL}/resolve/main/`;
-// One text per run: a q8 model quantizes per batch tensor, so the same text in different company
-// differs in the last decimals (transformers.js shows the same, cosine 0.992 alone versus batched).
-// Entries arrive one at a time and a vector must not depend on its neighbours, so no batching.
-const BATCH = 1;
-
-export function modelDirectory(modelsDir) {
-  return path.join(modelsDir, ...EMBEDDING_MODEL.split("/"));
-}
-
-/** True when every model file is present and non-empty. */
-export function modelPresent(modelsDir) {
-  const dir = modelDirectory(modelsDir);
-  return MODEL_FILES.every((file) => {
-    try { return fs.statSync(path.join(dir, file)).size > 0; } catch { return false; }
-  });
-}
-
-async function download(url, target, { fetchImpl, log }) {
-  const partial = `${target}.partial`;
-  ensureDir(path.dirname(target));
-  let have = 0;
-  try { have = fs.statSync(partial).size; } catch {}
-  const headers = have > 0 ? { range: `bytes=${have}-` } : {};
-  const response = await fetchImpl(url, { headers, redirect: "follow" });
-  if (response.status === 416) { fs.renameSync(partial, target); return; }
-  if (!response.ok) throw new Error(`download of ${path.basename(target)} failed: HTTP ${response.status}`);
-  const resumed = response.status === 206;
-  const total = Number(response.headers.get("content-length") || 0) + (resumed ? have : 0);
-  const out = fs.createWriteStream(partial, { flags: resumed ? "a" : "w" });
-  let done = resumed ? have : 0;
-  let shown = -1;
-  const name = path.basename(target);
-  for await (const chunk of response.body) {
-    if (!out.write(chunk)) await new Promise((resolve) => out.once("drain", resolve));
-    done += chunk.length;
-    const percent = total ? Math.floor((done / total) * 10) * 10 : -1;
-    if (percent !== shown && percent >= 0) { shown = percent; log?.(`embedder: ${name} ${percent}%`); }
-  }
-  await new Promise((resolve, reject) => { out.end(); out.on("finish", resolve); out.on("error", reject); });
-  if (total && done !== total) throw new Error(`download of ${name} stopped at ${done} of ${total} bytes; run setup again to resume`);
-  fs.renameSync(partial, target);
-}
-
-/** Downloads any missing model file into modelsDir. Idempotent; a partial file resumes. */
-export async function ensureModel({ modelsDir, log = () => {}, fetchImpl = fetch } = {}) {
-  const dir = modelDirectory(modelsDir);
-  const missing = MODEL_FILES.filter((file) => { try { return fs.statSync(path.join(dir, file)).size === 0; } catch { return true; } });
-  if (!missing.length) return { downloaded: [], present: true };
-  log(`embedder: downloading ${EMBEDDING_MODEL} (${missing.length} file${missing.length === 1 ? "" : "s"}, about 110 MB) into ${modelsDir}`);
-  for (const file of missing) await download(REMOTE + file, path.join(dir, file), { fetchImpl, log });
-  log("embedder: ready");
-  return { downloaded: missing, present: true };
-}
-
-function truncate(encoded, maxLength) {
-  for (const key of Object.keys(encoded)) encoded[key] = encoded[key].slice(0, maxLength);
-}
-
-function pad(encoded, maxLength, padId) {
-  for (const key of Object.keys(encoded)) {
-    const fill = key === "input_ids" ? padId : 0;
-    while (encoded[key].length < maxLength) encoded[key].push(fill);
-  }
-}
-
-/**
- * A lazily loaded embedder over local files only. Loading the session takes about half a
- * second and inference runs on the calling thread (onnxruntime-web's Node build has no
- * worker), so each short text holds the event loop for a few tens of milliseconds;
- * callers embed in the background, never inside a request the person is waiting on.
- */
-export function createEmbedder({ modelsDir }) {
-  const dir = modelDirectory(modelsDir);
-  let loading = null;
-  const load = () => {
-    if (loading) return loading;
-    loading = (async () => {
-      if (!modelPresent(modelsDir)) throw new Error(`the embedding model is not present in ${modelsDir}; run npx tryharness to download it`);
-      const [{ Tokenizer }, ort] = await Promise.all([import("@huggingface/tokenizers"), import("onnxruntime-web")]);
-      const tokenizerJson = JSON.parse(fs.readFileSync(path.join(dir, "tokenizer.json"), "utf8"));
-      const tokenizerConfig = JSON.parse(fs.readFileSync(path.join(dir, "tokenizer_config.json"), "utf8"));
-      const modelConfig = JSON.parse(fs.readFileSync(path.join(dir, "config.json"), "utf8"));
-      const tokenizer = new Tokenizer(tokenizerJson, tokenizerConfig);
-      ort.env.wasm.numThreads = 1;
-      const session = await ort.InferenceSession.create(path.join(dir, "onnx", "model_quantized.onnx"), { executionProviders: ["wasm"] });
-      return {
-        ort, tokenizer, session,
-        maxLength: Number(tokenizerConfig.model_max_length) || 512,
-        padId: Number(modelConfig.pad_token_id ?? 0),
-        wantsTypeIds: session.inputNames.includes("token_type_ids"),
-      };
-    })();
-    loading.catch(() => { loading = null; });
-    return loading;
-  };
-
-  const embedBatch = async (texts) => {
-    const { ort, tokenizer, session, maxLength, padId, wantsTypeIds } = await load();
-    const encoded = texts.map((text) => {
-      const { ids, attention_mask, token_type_ids } = tokenizer.encode(text, { add_special_tokens: true, return_token_type_ids: true });
-      return { input_ids: [...ids], attention_mask: [...attention_mask], ...(wantsTypeIds ? { token_type_ids: [...(token_type_ids || ids.map(() => 0))] } : {}) };
-    });
-    const width = Math.min(Math.max(...encoded.map((e) => e.input_ids.length)), maxLength);
-    for (const e of encoded) {
-      if (e.input_ids.length > width) truncate(e, width);
-      else if (e.input_ids.length < width) pad(e, width, padId);
-    }
-    const tensor = (key) => new ort.Tensor("int64", BigInt64Array.from(encoded.flatMap((e) => e[key].map((v) => BigInt(v)))), [texts.length, width]);
-    const feeds = { input_ids: tensor("input_ids"), attention_mask: tensor("attention_mask"), ...(wantsTypeIds ? { token_type_ids: tensor("token_type_ids") } : {}) };
-    const outputs = await session.run(feeds);
-    const hidden = outputs.last_hidden_state;
-    const [, seq, dims] = hidden.dims;
-    const data = hidden.data;
-    return texts.map((_, row) => {
-      const start = row * seq * dims;
-      const vector = new Float32Array(dims);
-      let norm = 0;
-      for (let i = 0; i < dims; i += 1) { vector[i] = data[start + i]; norm += vector[i] * vector[i]; }
-      norm = Math.sqrt(norm) || 1;
-      for (let i = 0; i < dims; i += 1) vector[i] /= norm;
-      return vector;
-    });
-  };
-
-  return {
-    version: EMBEDDING_VERSION,
-    dimensions: EMBEDDING_DIMENSIONS,
-    ready: () => load().then(() => true),
-    async embedDocuments(texts) {
-      const out = [];
-      for (let i = 0; i < texts.length; i += BATCH) out.push(...(await embedBatch(texts.slice(i, i + BATCH))));
-      return out;
-    },
-    async embedQuery(text) {
-      return (await embedBatch([QUERY_PREFIX + text]))[0];
-    },
-  };
-}