tryharness 0.7.18 → 0.7.23

package/lib/personal.mjs

@@ -0,0 +1,39 @@
+// Personal details in text: an email, a phone number, a wallet address, an amount of money. The same patterns cover
+// screenshots read by OCR (redact.mjs) and the words of the relay's decision-only requests to Harness (firewall.mjs).
+
+// Wallet addresses: Ethereum-style 0x and 40 hex (OCR reads some 0s as Os), the shortened 0x1234…abcd form apps show,
+// bech32 (bc1…), and base58 strings long and mixed enough to be addresses or keys rather than words or identifiers
+// (Solana, Bitcoin legacy, base58 private keys), one misread character allowed. Hex alone is a hash, not an address,
+// and a sha512-… integrity string is a hash in base64. OCR often runs a label into the value ("addressbc1q…"), so the
+// prefixed forms need no boundary before them.
+export const EVM = /[0O][xX][0-9a-fA-FOo]{38,42}(?![\w])/g;
+export const EVM_SHORT = /0[xX][0-9a-fA-F]{3,8}(?:…|\.{2,3})[0-9a-fA-F]{3,8}(?![\w])/g;
+export const BECH32 = /(?:bc1|tb1|ltc1)[a-zA-Z0-9]{20,90}(?![\w])/g;
+export const BASE58ISH = /(?<![\w])[0-9A-Za-z]{25,90}(?![\w])/g;
+export const base58 = (token) => (token.match(/[0OIl]/g) || []).length <= 1 && (token.match(/\d/g) || []).length >= 2 && (token.match(/[A-Z]/g) || []).length >= 3 && (token.match(/[a-z]/g) || []).length >= 3 && /[g-zG-Z]/.test(token);
+// Money: an amount with a currency sign or code (a lone digit after $ is a shell variable, not money).
+const CODES = "USD|USDC|USDT|EUR|GBP|JPY|CHF|CAD|AUD|ETH|WETH|stETH|BTC|WBTC|cbBTC|SOL|DAI|BNB|MATIC|POL|ARB|OP|AVAX|DOGE|XRP|ADA|DOT|LINK|UNI|AAVE|DEGEN";
+const AMOUNT = "\\d{1,3}(?:[,']\\d{3})+(?:[.,]\\d+)?|\\d+(?:[.,]\\d+)?";
+export const MONEY = new RegExp(`(?<![\\w$€£¥])(?:[-+−]\\s?)?(?:(?:US)?[$€£¥₹₩₿Ξ]\\s?(?:${AMOUNT})(?:\\s?[KMBkmb](?![A-Za-z]))?|(?:${AMOUNT})(?:\\s?[KMBkmb](?=\\s?(?:${CODES})))?\\s?(?:(?:${CODES})(?![A-Za-z])|[€£₿Ξ]))`, "g");
+export const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}/g;
+// Phone numbers: digit groups joined by single spaces, dots or dashes, with an optional +country code and (area code);
+// 10 to 15 digits (8 with a country code). Dates, times, IP addresses and version numbers do not qualify.
+export const PHONE = /(?<![\w.+/:#-])(?:\+\d{1,3}[ .-]?)?(?:\(\d{1,4}\)[ .-]?)?\d{2,5}(?:[ .-]\d{2,6}){1,4}(?![\w])/g;
+export const phoneLike = (text) => {
+  const digits = text.replace(/\D/g, "").length;
+  return digits <= 15 && digits >= (text.startsWith("+") ? 8 : 10) && !/^\d{4}[-.]\d{1,2}[-.]\d{1,2}/.test(text) && !/^\d{1,3}(?:\.\d{1,3}){3}$/.test(text);
+};
+/** Personal details in plain text: [{ start, end, kind }] (kind: wallet, email, phone, money), longest first where they overlap. */
+export function personalSpans(text) {
+  const value = String(text);
+  const found = [];
+  const take = (pattern, kind, keep = () => true) => { for (const m of value.matchAll(pattern)) if (keep(m[0], value.slice(0, m.index))) found.push({ start: m.index, end: m.index + m[0].length, kind }); };
+  take(EVM, "wallet"); take(EVM_SHORT, "wallet"); take(BECH32, "wallet");
+  take(BASE58ISH, "wallet", (token, before) => base58(token) && !/sha\d+[-:][A-Za-z0-9+/]*$/i.test(before));
+  take(EMAIL, "email", (token, before) => !/^git@/i.test(token) && !/:\/\/\S*$/.test(before));
+  take(PHONE, "phone", phoneLike);
+  take(MONEY, "money", (token) => !/^[-+−]?\s?(?:US)?[$€£¥₹₩₿Ξ]\s?\d$/.test(token));
+  const kept = [];
+  for (const span of found.sort((a, b) => (b.end - b.start) - (a.end - a.start))) if (!kept.some((other) => other.start < span.end && span.start < other.end)) kept.push(span);
+  return kept.sort((a, b) => a.start - b.start);
+}

package/lib/phones.mjs

@@ -22,8 +22,12 @@ const PHONE_COMMANDS = new Set([
   "board.list", "board.get", "board.children", "board.agents", "board.post", "board.run", "board.release", "board.answer", "board.remove",
   "board.thread.read", "board.thread.post", "board.thread.send", "board.thread.discard", "board.thread.auto", "board.thread.end",
   "board.goal.list", "board.goal.get", "board.goal.stop", "board.room.read",
+  // A thread's files: shown, opened and downloaded, and shared or kept on this computer, by the person.
+  "board.file.get", "board.file.share",
   "board.swarm.list", "board.swarm.read", "board.swarm.start", "board.swarm.post", "board.swarm.stop", "board.swarm.stop_all", "board.swarm.resume", "board.swarm.folder", "board.swarm.coordinator",
   "board.swarm.diff", "board.swarm.merge", "board.swarm.discard", "board.swarm.start_run", "board.swarm.agents", "board.swarm.note",
+  // Where a thread works: the folders offered, any folder browsed to, and where a message would work (folders.mjs).
+  "board.swarm.places", "board.swarm.browse", "board.swarm.place",
   // The person's own running sessions, read and messaged as from the desktop app; never queued (a session may be gone).
   "board.live", "board.live.read", "board.live.say",
 ]);
@@ -33,7 +37,9 @@ const HARNESS_COMMANDS = new Set([
   "board.goal.create", "board.goal.get", "board.goal.list", "board.goal.finish", "board.room.read", "board.room.post", "board.room.search", "board.children", "board.agents",
   "board.swarm.list", "board.swarm.read", "board.swarm.diff",
 ]);
-const BROWSER_PERSON_COMMANDS = new Set([...PHONE_COMMANDS, "board.goal.resume", "board.standing", "board.standing.check", "board.standing.off"]);
+// Swarms talking to swarms (network.mjs), from the Harness window: the person's own, never Harness's.
+const RELAY_PERSON_COMMANDS = ["board.relay.list", "board.relay.network", "board.relay.decide", "board.relay.request", "board.relay.seen", "board.relay.defaults", "board.relay.peers"];
+const BROWSER_PERSON_COMMANDS = new Set([...PHONE_COMMANDS, "board.goal.resume", "board.standing", "board.standing.check", "board.standing.off", ...RELAY_PERSON_COMMANDS]);
 const BROWSER_READS = new Set(["sessions.search", "sessions.read", "sessions.raw", "tasks.status", "relay.request", "relay.open"]);
 
 export async function createPhoneDesk({ store, identityFile, boardCommand, reads = {}, version, onMessage = () => {}, machine = () => null }) {
@@ -145,10 +151,33 @@ export async function createPhoneDesk({ store, identityFile, boardCommand, reads
   // Harness's bridge message: a pairing or a sealed call. Everything returned is safe to pass through Harness.
   const handle = async (input) => (input?.kind === "pair" ? pair(input) : input?.kind === "call" ? call(input.envelope) : { ok: false, error: "unknown sealed request" });
 
+  // The other way round: this computer asking the person's own Harness window for what only the window holds (its
+  // screen history). The question is sealed to every browser linked here ("d2b") under one fresh request id; Harness
+  // hands the envelopes to the window that is open (`carry`, the bridge's leg), only a browser holding one of these
+  // links can open its envelope, and its answer comes back sealed ("b2d") for this request id alone. Harness sees which
+  // devices, sizes and timing, never the question or the answer.
+  const ask = async (call, carry) => {
+    const browsers = store.phones().filter((device) => device.kind === "browser" && !device.revoked_at).slice(0, 8).map((device) => store.getPhone(device.id));
+    if (!browsers.length) return { ok: false, code: "unpaired", error: "no Harness window is linked to this computer: the person links one with npx tryharness link" };
+    const requestId = b64u(randomBytes(16));
+    const ts = Date.now();
+    const envelopes = await Promise.all(browsers.map(async (device) => seal(await keyFor(device), "d2b", device.id, requestId, { ts, call })));
+    const reply = await carry(envelopes);
+    if (reply?.window === "closed") return { ok: false, code: "closed", error: "the person's Harness window isn't open: ask them to open Harness, then try again" };
+    if (reply?.window !== "open") return { ok: false, error: reply?.error || "Harness could not carry the question" };
+    if (!reply.ok || !reply.envelope) return { ok: false, code: reply.code, error: reply.code === "window" ? `the open Harness window could not answer: ${reply.error}` : reply.error };
+    const device = browsers.find((item) => item.id === reply.envelope.deviceId);
+    if (!device || reply.envelope.requestId !== requestId) return { ok: false, code: "unreadable", error: "the answer was for another question" };
+    let answer;
+    try { answer = await open(await keyFor(device), "b2d", reply.envelope); } catch { return { ok: false, code: "unreadable", error: "the answer could not be opened: it did not come from a window linked to this computer" }; }
+    store.touchPhone(device.id);
+    return answer;
+  };
+
   const revoke = (id) => {
     keys.delete(String(id));
     return store.revokePhone(String(id));
   };
 
-  return { offer, handle, revoke, list: () => store.phones(), publicKey: identity.publicKey, identity };
+  return { offer, handle, ask, revoke, list: () => store.phones(), publicKey: identity.publicKey, identity };
 }

package/lib/places.mjs

@@ -3,6 +3,8 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
+import { paths } from "./paths.mjs";
+import { agentEnvironment } from "./agentnode.mjs";
 import { mainCheckout } from "./worktrees.mjs";
 
 // Where a coding session runs, and how it opens there again. A session's place comes from its own environment: the
@@ -168,6 +170,43 @@ export function resumeLine(agent, sessionId, folder = null) {
   return `${folder && path.isAbsolute(folder) ? `cd ${quote(folder)} && ` : ""}${resume} ${sessionId}`;
 }
 
+/** Whether an editor runs a workspace's tasks when its window opens: it asks the person once, unless they turned that off. */
+export function editorRunsOpenTasks(editorId) {
+  const editor = editorById(editorId);
+  if (!editor) return false;
+  let settings = "";
+  try { settings = fs.readFileSync(path.join(editorData(editor), "User", "settings.json"), "utf8"); } catch { return true; }
+  return !/"task\.allowAutomaticTasks"\s*:\s*"off"/.test(settings);
+}
+
+/**
+ * A session to resume in an editor's own terminal: a workspace on the folder the editor opens around it (`window`), whose
+ * task resumes the session in a terminal when the window opens (runOn folderOpen; the editor asks once to trust the folder
+ * and to allow such tasks). Through the person's login shell, so the agent runs with their own setup. The file lives in
+ * Harness's folder, never in the person's; its path, or null when the agent has no resume command.
+ */
+export function editorSessionWorkspace(agent, sessionId, folder, window = folder) {
+  const resume = AGENTS[agent]?.resume;
+  if (!resume || !PLAIN_ID.test(String(sessionId || "")) || !folder || !path.isAbsolute(folder)) return null;
+  // Through the person's login shell (VS Code's default terminal on Windows), with a Node the agent accepts first.
+  const shell = process.platform === "win32" ? null : process.env.SHELL || os.userInfo().shell || "/bin/sh";
+  const { bin } = agentEnvironment(AGENTS[agent].command);
+  const name = `${path.basename(window || folder)} - ${agent} ${String(sessionId).replace(/^ses_/, "").slice(0, 8)}`.replace(/[^A-Za-z0-9 ._-]/g, "-");
+  const file = path.join(paths.home, "editor", `${name}.code-workspace`);
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(file, JSON.stringify({
+    folders: [{ path: window || folder }],
+    tasks: { version: "2.0.0", tasks: [{
+      label: `${agent} session ${sessionId}`, type: "shell", command: `${resume} ${sessionId}`,
+      options: { cwd: folder, ...(shell ? { shell: { executable: shell, args: ["-l", "-i", "-c"] } } : {}), ...(bin ? { env: { PATH: `${bin}${path.delimiter}\${env:PATH}` } } : {}) },
+      runOptions: { runOn: "folderOpen" },
+      presentation: { reveal: "always", focus: true, panel: "dedicated", clear: true },
+      problemMatcher: [],
+    }] },
+  }, null, 2), { mode: 0o600 });
+  return file;
+}
+
 /** A session in its agent's own panel in an editor (Claude Code's, OpenAI's Codex extension), when it is installed there. */
 export function panelLink(agent, editorId, sessionId) {
   const panel = AGENTS[agent]?.panel;
@@ -235,6 +274,28 @@ export function t3Project(folder, home = t3Home()) {
   return found ? { id: found[0], root: realDir(found[1]) } : null;
 }
 
+/**
+ * T3 Code's thread for a folder, so T3 opens on the right workspace: the newest one in that worktree, else the newest
+ * working in its project's own folder when the folder is that, else the newest in its project.
+ */
+export function t3ThreadIn(folder, home = t3Home()) {
+  const dir = folder ? realDir(folder) : null;
+  if (!dir || !t3Tables(home).has("orchestration_v2_projection_threads")) return null;
+  const project = t3Project(folder, home);
+  const rows = (t3Query(home, "select thread_id || char(9) || coalesce(project_id, '') || char(9) || coalesce(json_extract(payload_json, '$.worktreePath'), '') from orchestration_v2_projection_threads where deleted_at is null and archived_at is null order by updated_at desc;") || "")
+    .split("\n").map((line) => line.split("\t")).filter(([id]) => id);
+  const inProject = project ? rows.filter(([, id]) => id === project.id) : [];
+  const found = rows.find(([, , tree]) => tree && realDir(tree) === dir)
+    ?? (dir === project?.root ? inProject.find(([, , tree]) => !tree) : null) ?? inProject[0];
+  return found?.[0] ?? null;
+}
+
+/** Every folder T3 Code has a project for. */
+export function t3Projects(home = t3Home()) {
+  if (!t3Tables(home).has("projection_projects")) return [];
+  return (t3Query(home, "select workspace_root from projection_projects where deleted_at is null;") || "").split("\n").map(realDir).filter(Boolean);
+}
+
 /** The model (and its options) the person last ran an agent with in T3 Code, as T3 records each thread's choice. */
 export function t3Model(agent, home = t3Home()) {
   const provider = t3Provider(agent);

package/lib/receipts.mjs

@@ -0,0 +1,42 @@
+import { insideRoot, isTestCommand } from "./trails.mjs";
+
+// Receipts for agents' work: what a run's own session file shows it did after its last change, never what it says it
+// did. A run that changed files and then ran its tests with a zero exit is "tested"; one whose last test after its last
+// change failed is "tests failing"; one that changed files and ran no test after the change is "not tested after its
+// last change". The words come from code over the transcript, so an agent cannot talk its way to "tested". Changes are
+// code changes inside the run's folder: notes, docs and files elsewhere (an agent's own memory) do not need tests.
+
+const DOC = /\.(?:md|mdx|txt|rst)$/i;
+
+/** { verdict, changed, lastChangeAt, tests: [{ command, ok, at, afterChange }] } for a trail (trails.mjs). */
+export function receipt(trail, { root = trail?.cwd } = {}) {
+  const calls = trail?.calls ?? [];
+  const code = (call) => call.edited.map((token) => (root ? insideRoot(token, root, trail.cwd) : token)).filter((file) => file && !DOC.test(file));
+  let lastChange = -1;
+  calls.forEach((call, i) => { if (code(call).length) lastChange = i; });
+  const changed = [...new Set(calls.flatMap(code))];
+  const tests = calls.map((call, i) => ({ call, i })).filter(({ call }) => call.command && isTestCommand(call.command))
+    .map(({ call, i }) => ({ command: call.command.split("\n")[0].slice(0, 200), ok: !call.error, at: call.at, afterChange: i > lastChange }));
+  const after = tests.filter((test) => test.afterChange);
+  const verdict = !changed.length ? "no changes" : !after.length ? "not tested after its last change" : after.at(-1).ok ? "tested" : "tests failing";
+  // The same test failing again and again is the clearest sign of a run going round in circles.
+  let repeated = 0;
+  let streak = 0;
+  tests.forEach((test, i) => { streak = !test.ok && i > 0 && !tests[i - 1].ok && tests[i - 1].command === test.command ? streak + 1 : test.ok ? 0 : 1; repeated = Math.max(repeated, streak); });
+  return { verdict, changed, lastChangeAt: lastChange >= 0 ? calls[lastChange].at : null, tests: after.length ? after : tests.slice(-3), repeatedFailures: repeated };
+}
+
+/** The line the thread shows for a receipt. */
+export function receiptLine(agentName, result) {
+  const line = verdictLine(agentName, result);
+  return result.repeatedFailures >= 3 ? `${line} The same test failed ${result.repeatedFailures} times in a row during the run.` : line;
+}
+
+function verdictLine(agentName, result) {
+  const files = `${result.changed.length} file${result.changed.length === 1 ? "" : "s"}`;
+  if (result.verdict === "no changes") return `Receipt: ${agentName} changed no files in this run.`;
+  const last = result.tests.filter((test) => test.afterChange).at(-1);
+  if (result.verdict === "tested") return `Receipt: ${agentName} changed ${files}, then ran \`${last.command}\` and it passed.`;
+  if (result.verdict === "tests failing") return `Receipt: ${agentName} changed ${files}; its last test after the change, \`${last.command}\`, failed.`;
+  return `Receipt: ${agentName} changed ${files} and ran no tests after its last change.`;
+}

package/lib/redact.mjs

@@ -0,0 +1,334 @@
+import fs from "node:fs";
+import pngjs from "pngjs";
+import { decodeImage, imageKind } from "./ocr.mjs";
+import { secretReason } from "./secrets.mjs";
+import { BASE58ISH, BECH32, EMAIL, EVM, EVM_SHORT, MONEY, PHONE, base58, phoneLike } from "./personal.mjs";
+
+// What an image loses before it leaves the computer for an agent on Harness's side (daemon.mjs, board.file.get): the
+// text in it is read here (ocr.mjs) and every key or password (the handoff firewall's own detection, firewall.mjs),
+// wallet address, private key, seed phrase, amount of money, email address and phone number is covered by a solid box
+// labelled with what was there. A box, not a fill from the surroundings: the reading agent sees that something was
+// removed, and nothing of it is left to reconstruct. Only that part of a line is covered, from where its characters were
+// read, with a margin so no character of it stays legible. The person and the agents on this computer keep the original.
+
+// Bump when what is found or how it is drawn changes: covered copies are kept under this version.
+export const REDACTION_VERSION = 1;
+
+const LABELS = { credential: "key hidden", "private-key": "key hidden", seed: "seed phrase hidden", wallet: "address hidden", money: "amount hidden", email: "email hidden", phone: "phone hidden" };
+const NAMES = {
+  credential: ["a key or password", "keys or passwords"], "private-key": ["a private key", "private keys"], seed: ["a seed phrase", "seed phrases"],
+  wallet: ["a wallet address", "wallet addresses"], money: ["an amount of money", "amounts of money"], email: ["an email address", "email addresses"], phone: ["a phone number", "phone numbers"],
+};
+// When finds of about the same length overlap, the stronger kind names the box (sensitiveSpans).
+const RANK = ["seed", "private-key", "wallet", "credential", "email", "phone", "money"];
+
+// The firewall takes any 64-hex value for a private key. On a screen most are file digests, and a row says which: a
+// sha256: prefix, the "<hex>  <file>" line shasum prints, or a digest or checksum label, with no key named on the row.
+// On such a row nothing is taken for a key on the strength of that value (the firewall may name another token on it).
+const digestRow = (row) => !/private|secret|\bkey\b|wallet|seed|mnemonic/i.test(row) && [...row.matchAll(/(?<![0-9a-fA-F])(?:0x)?[0-9a-fA-F]{64}(?![0-9a-fA-F])/g)]
+  .some((m) => /sha-?(?:256|384|512)[:=]\s*$/i.test(row.slice(0, m.index)) || /^\s+\S+\.\w{1,6}\b/.test(row.slice(m.index + m[0].length)) || /\bsha-?(?:256|384|512)\b|\bdigests?\b|\bchecksums?\b/i.test(row));
+
+// Seed phrases (BIP-39, bip39-english.txt: the official English list, MIT, sha256 2f5eed53…dbda): a run of at least
+// SEED_RUN whitespace-separated list words, nearly all different, in lower or upper case (a capital allowed on the
+// first), with numbering between them however OCR read it ("5.", "5frost", ". tomato"). Words read with one wrong
+// letter still count. Over 2,326 of this repository's text and code files, the only run of eight or more such words was
+// a real test phrase (October 14), so nine is far from prose and below every phrase length.
+const SEED_RUN = 9;
+let wordlist = null;
+const bip39 = () => (wordlist ||= new Set(fs.readFileSync(new URL("./bip39-english.txt", import.meta.url), "utf8").split("\n").map((word) => word.trim()).filter(Boolean)));
+const nearWord = (word) => {
+  const list = bip39();
+  if (list.has(word)) return true;
+  if (word.length < 4) return false;
+  for (const candidate of list) {
+    if (candidate[0] !== word[0] || Math.abs(candidate.length - word.length) > 1) continue;
+    let i = 0, j = 0, edits = 0;
+    while (i < word.length && j < candidate.length && edits <= 1) {
+      if (word[i] === candidate[j]) { i += 1; j += 1; continue; }
+      edits += 1;
+      if (word.length > candidate.length) i += 1; else if (word.length < candidate.length) j += 1; else { i += 1; j += 1; }
+    }
+    if (edits + (word.length - i) + (candidate.length - j) <= 1) return true;
+  }
+  return false;
+};
+
+/** Lines on one visual row joined left to right (two spaces apart, so no pattern runs across boxes), with each line's offset. */
+function rowsOf(lines) {
+  const rows = [];
+  for (const line of [...lines].sort((a, b) => (a.box[1] + a.box[3]) - (b.box[1] + b.box[3]))) {
+    const [, y0, , y1] = line.box;
+    const row = rows.find((each) => Math.min(each.y1, y1) - Math.max(each.y0, y0) >= 0.5 * Math.min(each.y1 - each.y0, y1 - y0));
+    if (row) { row.lines.push(line); row.y0 = Math.min(row.y0, y0); row.y1 = Math.max(row.y1, y1); } else rows.push({ y0, y1, lines: [line] });
+  }
+  return rows.sort((a, b) => a.y0 - b.y0).map((row) => {
+    let text = "";
+    const parts = row.lines.sort((a, b) => a.box[0] - b.box[0]).map((line) => { const at = text ? text.length + 2 : 0; text = text ? `${text}  ${line.text}` : line.text; return { line, at }; });
+    return { text, parts };
+  });
+}
+
+// A value wrapped inside its box (a key in a narrow card): a line ending in a long unbroken token, last on its row and
+// the widest line starting at its left edge nearby, with the line right below starting at that edge and going on in the
+// same kind of characters (hex after hex, lower case after bech32, a digit somewhere after anything else). Read as one
+// line (a dotted name is a file or host, not a value cut short); only finds that cross the break count on it.
+function wrapsOf(lines, rows) {
+  const out = [];
+  const lastOnRow = new Set(rows.map((row) => row.parts.at(-1).line)), firstOnRow = new Set(rows.map((row) => row.parts[0].line));
+  for (const a of lines) {
+    const tail = a.text.match(/\S{16,}$/)?.[0];
+    if (!tail || /\./.test(tail.slice(-16)) || !lastOnRow.has(a)) continue;
+    const h = a.box[3] - a.box[1], char = (a.box[2] - a.box[0]) / a.text.length;
+    const column = lines.filter((each) => Math.abs(each.box[0] - a.box[0]) <= 1.5 * char && Math.abs(each.box[1] - a.box[1]) <= 10 * h);
+    if (column.some((each) => each.box[2] > a.box[2] + 1.5 * char)) continue;
+    const goesOn = /^(?:0x)?[0-9a-fA-F]+$/.test(tail) ? /^[0-9a-fA-F]+$/ : /^[a-z0-9]+$/.test(tail.slice(-16)) ? /^[a-z0-9]+$/ : /^(?=\D*\d)[A-Za-z0-9+/=_-]+$/;
+    const b = column.find((each) => each !== a && firstOnRow.has(each) && each.box[1] - a.box[3] >= -0.3 * h && each.box[1] - a.box[3] <= 0.8 * h
+      && Math.abs(each.box[3] - each.box[1] - h) <= 0.35 * h && goesOn.test(each.text.split(/\s/)[0]));
+    if (b) out.push({ text: a.text + b.text, parts: [{ line: a, at: 0 }, { line: b, at: a.text.length }], cut: a.text.length });
+  }
+  return out;
+}
+
+// A word that names a password or key (not "monkey", "keyboard", "passed" or "author"); a lowercase name of a word,
+// digits and dashes (a pod, image or package: keeper-api-7d9f8c6b5d-x2k9p, ami-0c55b159cbfafe1f0), which the credential
+// model alone sometimes takes for a secret; a value that mixes at least three kinds of character, as passwords do.
+const NAMES_A_SECRET = /passw|passphrase|\bpass\b|secret|(?:\b|_|api)keys?\b|key_|token|credential|\bauth(?:orization|[_-]?token)?\b|pwd|\bpin\b/i;
+const nameLike = (text) => /^[a-z0-9]+(?:[-._][a-z0-9]+)+$/.test(text) && text.split(/[-._]/).some((part) => /^[a-z]{3,}$/.test(part));
+const secretish = (text) => Boolean(secretReason(text)) || (text.length >= 8 && [/[a-z]/, /[A-Z]/, /\d/, /[^A-Za-z0-9]/].filter((re) => re.test(text)).length >= 3);
+// Tokens with a known key shape on their own (secrets.mjs), wherever the firewall's pick on the line fell; a NAME=
+// before one is not part of it (OCR may read its first letter as a digit).
+const shaped = (text) => [...text.matchAll(/\S+/g)].flatMap((m) => {
+  const token = m[0].replace(/^\w[\w.-]*=/, "").replace(/^["'`(<[{]+|["'`)>\]},;.]+$/g, "");
+  const start = m.index + m[0].lastIndexOf(token);
+  return token.length >= 12 && secretReason(token) ? [{ start, end: start + token.length, reason: secretReason(token) }] : [];
+});
+
+// A value read with the label that names it: alone on the line under a short label ("Secret access key", then the
+// key), or in a later cell of a table row whose earlier cell names it ("DEPLOY_TOKEN", then the token).
+function labelsOf(rows) {
+  const out = [];
+  const pair = (name, value) => out.push({ text: `${name}: ${value.text}`, parts: [{ line: value, at: name.length + 2 }], cut: name.length + 2 });
+  rows.forEach((row, i) => {
+    const next = rows[i + 1];
+    if (next && row.parts.length === 1 && next.parts.length === 1) {
+      const label = row.parts[0].line, value = next.parts[0].line, h = label.box[3] - label.box[1];
+      if (label.text.length <= 40 && NAMES_A_SECRET.test(label.text) && Math.abs(value.box[0] - label.box[0]) <= h && value.box[1] - label.box[3] <= 1.2 * h && /^\S{8,}$/.test(value.text)) pair(label.text, value);
+    }
+    row.parts.forEach(({ line }, j) => {
+      const name = line.text.split(/\s+/).find((word) => word.length <= 40 && NAMES_A_SECRET.test(word));
+      if (name) for (const { line: value } of row.parts.slice(j + 1)) if (/^\S{8,}$/.test(value.text)) pair(name, value);
+    });
+  });
+  return out;
+}
+
+const matches = (re, text, keep = () => true) => [...text.matchAll(re)].filter((m) => keep(m[0], text.slice(0, m.index))).map((m) => ({ start: m.index, end: m.index + m[0].length }));
+
+// OCR reads some small lower-case letters as their capitals ("pasSword"), and the credential model leans on such words
+// (0.53 for that line, 0.99 spelled right), so it reads rows with those capitals lowered inside otherwise lower-case
+// words. The length is the same, so what it finds maps back as it is.
+const uncased = (text) => text.replace(/\b[a-z][a-zA-Z]{2,}\b/g, (word) => (/^[a-zCOSUVWXZ]+$/.test(word) ? word.toLowerCase() : word));
+
+// Keys and passwords: the firewall's patterns and credential model per row. A row can hold more than one, and the
+// firewall names one per line, so a row is asked again with what was found blanked, up to three times; a later find
+// counts only if it has a known key shape or mixes upper and lower case letters and digits (not the host or path left
+// beside a password).
+const keyLike = (text) => Boolean(secretReason(text)) || (text.length >= 16 && /[a-z]/.test(text) && /[A-Z]/.test(text) && /\d/.test(text));
+async function credentials(rows, firewall, lane) {
+  const found = [];
+  let asking = rows.map((row, index) => ({ index, text: row.text }));
+  for (let round = 0; round < 3 && asking.length; round += 1) {
+    const spans = await firewall.secrets(asking.map((each) => uncased(each.text)).join("\n"), { lane });
+    const next = new Map();
+    let offset = 0;
+    const starts = asking.map((each) => { const at = offset; offset += each.text.length + 1; return at; });
+    for (const span of spans) {
+      const which = starts.findLastIndex((at) => at <= span.start);
+      const row = asking[which], start = span.start - starts[which], end = Math.min(span.end - starts[which], row.text.length);
+      if (end <= start || found.some((each) => each.row === row.index && each.start < end && start < each.end)) continue;
+      const text = rows[row.index].text, value = row.text.slice(start, end);
+      if ((/32-byte hex key/.test(span.reason) && digestRow(text)) || (round > 0 && !keyLike(value))) continue;
+      if (span.reason === "a credential" && nameLike(value) && !NAMES_A_SECRET.test(text) && !/:\/\/[^\s:@/]+:$/.test(text.slice(0, start))) continue;
+      next.set(row.index, (next.get(row.index) ?? row.text).slice(0, start) + " ".repeat(end - start) + (next.get(row.index) ?? row.text).slice(end));
+      found.push({ row: row.index, start, end, kind: /private key|32-byte hex key/.test(span.reason) ? "private-key" : /seed phrase/.test(span.reason) ? "seed" : "credential" });
+    }
+    asking = [...next].map(([index, text]) => ({ index, text }));
+  }
+  return found;
+}
+
+/** Everything but seed phrases on rows: [{ row, start, end, kind }]. */
+async function rowSpans(rows, firewall, lane) {
+  const found = [];
+  rows.forEach((row, i) => {
+    const add = (spans, kind) => { for (const span of spans) found.push({ row: i, ...span, kind }); };
+    add([...matches(EVM, row.text), ...matches(EVM_SHORT, row.text), ...matches(BECH32, row.text)], "wallet");
+    // Base58 of 50 characters or more is a private key (WIF, Solana's 64-byte keys), shorter an address.
+    for (const span of matches(BASE58ISH, row.text, (token, before) => base58(token) && !/sha\d+[-:][A-Za-z0-9+/]*$/i.test(before))) add([span], span.end - span.start >= 50 ? "private-key" : "wallet");
+    // Not git@host, and not the user:password@host part of a URL.
+    add(matches(EMAIL, row.text, (text, before) => !/^git@/i.test(text) && !/:\/\/\S*$/.test(before)), "email");
+    add(matches(PHONE, row.text, phoneLike), "phone");
+    add(matches(MONEY, row.text, (text) => !/^[-+−]?\s?(?:US)?[$€£¥₹₩₿Ξ]\s?\d$/.test(text)), "money");
+    for (const span of shaped(row.text)) {
+      const key = /private key|32-byte hex key/.test(span.reason);
+      if (!(key && digestRow(row.text))) add([span], key ? "private-key" : "credential");
+    }
+  });
+  return [...found, ...await credentials(rows, firewall, lane)];
+}
+
+// Seed phrase runs over every line in reading order; numbering between words is skipped, anything else ends a run.
+function seedRuns(rows) {
+  const tokens = [];
+  for (const row of rows) for (const { line } of row.parts) {
+    for (const m of line.text.matchAll(/\S+/g)) {
+      if (/^\d{0,2}[.):]?$/.test(m[0])) continue;
+      const word = m[0].match(/^(\d{0,2}[.):]?)([A-Za-z]{3,8})$/);
+      tokens.push(word && nearWord(word[2].toLowerCase()) ? { line, start: m.index + word[1].length, end: m.index + m[0].length, word: word[2] } : null);
+    }
+  }
+  const runs = [];
+  let run = [];
+  const close = () => {
+    while (run.length > 1 && /^[A-Z][a-z]/.test(run.at(-1).word)) run.pop();
+    const distinct = new Set(run.map((each) => each.word.toLowerCase())).size;
+    if (Math.min(run.length, distinct + 1) >= SEED_RUN && !run.slice(1).some((each) => /^[A-Z][a-z]/.test(each.word))) runs.push(run);
+    run = [];
+  };
+  for (const token of tokens) { if (token) run.push(token); else close(); }
+  close();
+  return runs;
+}
+
+/** The sensitive spans in what OCR read: [{ line, start, end, kind, item }], one item per thing found. */
+export async function sensitiveSpans(lines, { firewall, lane = "handoff" }) {
+  const rows = rowsOf(lines), wraps = wrapsOf(lines, rows);
+  const found = [];
+  let item = 0;
+  // A span of a row becomes a span of each line it crosses.
+  const place = (row, start, end, kind) => {
+    const id = item++;
+    for (const { line, at } of row.parts) {
+      const from = Math.max(start, at) - at, to = Math.min(end, at + line.text.length) - at;
+      if (to > from) found.push({ line, start: from, end: to, kind, item: id });
+    }
+  };
+  for (const span of await rowSpans(rows, firewall, lane)) place(rows[span.row], span.start, span.end, span.kind);
+  if (wraps.length) for (const span of await rowSpans(wraps, firewall, lane)) if (span.start < wraps[span.row].cut && wraps[span.row].cut < span.end) place(wraps[span.row], span.start, span.end, span.kind);
+  const labels = labelsOf(rows);
+  // Only a value like a password or a known key counts there ("production" beside DEPLOY_TOKEN does not).
+  if (labels.length) for (const span of await credentials(labels, firewall, lane)) if (span.start >= labels[span.row].cut && secretish(labels[span.row].text.slice(span.start, span.end))) place(labels[span.row], span.start, span.end, span.kind);
+  for (const run of seedRuns(rows)) { const id = item++; for (const token of run) found.push({ line: token.line, start: token.start, end: token.end, kind: "seed", item: id }); }
+  // Two-factor recovery and backup codes each work as a password, and look like nothing else: after a heading that names
+  // them, every code-shaped token (letters and digits, in dashed groups or 8 to 16 long) is covered, row by row, until a
+  // row holds none (eval image-redaction: the credential model scored them 0.03 to 0.05).
+  for (const [index, row] of rows.entries()) {
+    if (!/\b(?:recovery|backup)\s+codes?\b/i.test(row.text)) continue;
+    for (let next = index + 1, seen = false; next < Math.min(rows.length, index + 8); next += 1) {
+      const codes = [...rows[next].text.matchAll(/\b(?=[a-z0-9-]*\d)(?=[a-z0-9-]*[a-z])(?:[a-z0-9]{3,8}(?:-[a-z0-9]{3,8})+|[a-z0-9]{8,16})\b/gi)];
+      if (!codes.length) { if (seen) break; continue; }
+      seen = true;
+      for (const code of codes) place(rows[next], code.index, code.index + code[0].length, "credential");
+    }
+  }
+  // Overlapping spans on a line merge, named by the longer find (a key holding an address-like stretch is a key), the
+  // stronger kind when about as long.
+  const merged = [];
+  for (const span of found.sort((a, b) => a.start - b.start)) {
+    const same = merged.find((each) => each.line === span.line && each.start < span.end && span.start < each.end);
+    if (!same) { merged.push({ ...span, length: span.end - span.start }); continue; }
+    const length = span.end - span.start;
+    if (length > same.length + 2 || (Math.abs(length - same.length) <= 2 && RANK.indexOf(span.kind) < RANK.indexOf(same.kind))) Object.assign(same, { kind: span.kind, item: span.item, length });
+    same.start = Math.min(same.start, span.start); same.end = Math.max(same.end, span.end);
+  }
+  return merged.map(({ length, ...span }) => span);
+}
+
+/**
+ * The box covering characters start..end of a line: from halfway between neighbouring characters (all of a space beside
+ * it, where OCR places the space unevenly), with half a character's margin, so no part of a covered character shows.
+ */
+function boxFor({ line, start, end }, width, height) {
+  const { box: [x0, y0, x1, y1], chars, text } = line;
+  const n = text.length;
+  const known = chars?.length === n;
+  const edge = (k, side) => {
+    if (k <= 0) return x0;
+    if (k >= n) return x1;
+    if (!known) return x0 + ((x1 - x0) * k) / n;
+    if (side === "start" && /\s/.test(text[k - 1])) return chars[k - 1][0];
+    if (side === "end" && /\s/.test(text[k])) return chars[k][1];
+    return (chars[k - 1][1] + chars[k][0]) / 2;
+  };
+  const pad = Math.max(2, ((x1 - x0) / Math.max(1, n)) * 0.5), lift = (y1 - y0) * 0.08;
+  return [Math.max(0, Math.floor(edge(start, "start") - pad)), Math.max(0, Math.floor(y0 - lift)), Math.min(width, Math.ceil(edge(end, "end") + pad)), Math.min(height, Math.ceil(y1 + lift))];
+}
+
+// A 5x7 pixel font with only the letters the labels use.
+const GLYPHS = {
+  a: ".....|.....|.###.|....#|.####|#...#|.####", d: "....#|....#|.####|#...#|#...#|#...#|.####", e: ".....|.....|.###.|#...#|#####|#....|.###.",
+  h: "#....|#....|#.##.|##..#|#...#|#...#|#...#", i: "..#..|.....|.##..|..#..|..#..|..#..|.###.", k: "#....|#....|#..#.|#.#..|##...|#.#..|#..#.",
+  l: ".##..|..#..|..#..|..#..|..#..|..#..|.###.", m: ".....|.....|##.#.|#.#.#|#.#.#|#.#.#|#.#.#", n: ".....|.....|#.##.|##..#|#...#|#...#|#...#",
+  o: ".....|.....|.###.|#...#|#...#|#...#|.###.", p: ".....|.....|####.|#...#|####.|#....|#....", r: ".....|.....|#.##.|##..#|#....|#....|#....",
+  s: ".....|.....|.####|#....|.###.|....#|####.", t: ".#...|.#...|####.|.#...|.#...|.#..#|..##.", u: ".....|.....|#...#|#...#|#...#|#..##|.##.#",
+  y: ".....|.....|#...#|#...#|.####|....#|.###.", " ": ".....|.....|.....|.....|.....|.....|.....",
+};
+// Dark boxes on light screens and light ones on dark screens, so the box itself is always seen.
+const DARK = [28, 28, 30], LIGHT = [214, 214, 218];
+
+function paint(image, [x0, y0, x1, y1], label) {
+  const { data, width } = image;
+  let sum = 0;
+  for (let y = y0; y < y1; y += 1) for (let x = x0; x < x1; x += 1) { const p = (y * width + x) * 4; sum += 0.3 * data[p] + 0.59 * data[p + 1] + 0.11 * data[p + 2]; }
+  const [FILL, INK] = sum / Math.max(1, (x1 - x0) * (y1 - y0)) < 110 ? [LIGHT, DARK] : [DARK, LIGHT];
+  for (let y = y0; y < y1; y += 1) for (let x = x0; x < x1; x += 1) { const p = (y * width + x) * 4; data[p] = FILL[0]; data[p + 1] = FILL[1]; data[p + 2] = FILL[2]; data[p + 3] = 255; }
+  // The longest label that fits, at the largest whole scale up to about half the box's height; none if nothing fits.
+  for (const text of [label, "hidden"]) {
+    for (let scale = Math.max(1, Math.floor(((y1 - y0) * 0.55) / 7)); scale >= 1; scale -= 1) {
+      const w = (text.length * 6 - 1) * scale, h = 7 * scale;
+      if (w > x1 - x0 - 2 * scale || h > y1 - y0) continue;
+      const left = x0 + Math.floor((x1 - x0 - w) / 2), top = y0 + Math.floor((y1 - y0 - h) / 2);
+      [...text].forEach((ch, i) => GLYPHS[ch].split("|").forEach((row, gy) => [...row].forEach((on, gx) => {
+        if (on !== "#") return;
+        for (let dy = 0; dy < scale; dy += 1) for (let dx = 0; dx < scale; dx += 1) {
+          const p = ((top + gy * scale + dy) * width + left + (i * 6 + gx) * scale + dx) * 4;
+          data[p] = INK[0]; data[p + 1] = INK[1]; data[p + 2] = INK[2];
+        }
+      })));
+      return;
+    }
+  }
+}
+
+/** "a key or password, a wallet address and 2 amounts of money" for what redactImage covered. */
+export function describeMasked(masked) {
+  const items = new Map();
+  for (const entry of masked) items.set(entry.item, entry.kind);
+  const counts = new Map();
+  for (const kind of items.values()) counts.set(kind, (counts.get(kind) ?? 0) + 1);
+  const parts = RANK.filter((kind) => counts.has(kind)).map((kind) => (counts.get(kind) === 1 ? NAMES[kind][0] : `${counts.get(kind)} ${NAMES[kind][1]}`));
+  return { count: items.size, text: parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}` : parts[0] ?? "" };
+}
+
+/**
+ * The image with what must not leave the computer covered: { bytes, mime, masked: [{ kind, box, label, item }], ms },
+ * the original bytes when nothing was found, or { refused } when it cannot be checked (a format other than PNG or JPEG,
+ * an animated PNG, a broken or oversized image).
+ */
+export async function redactImage({ bytes, mime }, { ocr, firewall, lane = "handoff" }) {
+  const started = performance.now();
+  const buffer = Buffer.from(bytes);
+  const kind = imageKind(buffer);
+  if (!kind) return { refused: `only PNG and JPEG images can be checked for private details, and this one is ${String(mime || "of another type").replace(/^image\//, "").toUpperCase()}` };
+  if (kind === "png" && buffer.includes("acTL")) return { refused: "animated images cannot be checked for private details" };
+  let image;
+  try { image = decodeImage(buffer); } catch (error) { return { refused: `the image could not be read (${error.message})` }; }
+  const read = await ocr.read(image, { lane });
+  const masked = (await sensitiveSpans(read.lines, { firewall, lane })).map((span) => ({ kind: span.kind, box: boxFor(span, image.width, image.height), label: LABELS[span.kind], item: span.item }));
+  if (!masked.length) return { bytes: buffer, mime, masked, ms: Math.round(performance.now() - started) };
+  for (const entry of masked) paint(image, entry.box, entry.label);
+  let opaque = true;
+  for (let p = 3; p < image.data.length && opaque; p += 4) opaque = image.data[p] === 255;
+  const png = pngjs.PNG.sync.write({ width: image.width, height: image.height, data: Buffer.from(image.data.buffer, image.data.byteOffset, image.data.byteLength) }, { colorType: opaque ? 2 : 6, inputHasAlpha: true });
+  return { bytes: png, mime: "image/png", masked, ms: Math.round(performance.now() - started) };
+}