tryharness 0.7.23 → 0.7.26

package/lib/context.mjs

@@ -1,9 +1,26 @@
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
-import { openAtlas, treeFiles, addFiles, embedMissing, searchFiles, ATLAS_VERSION } from "./atlas.mjs";
+import {
+  openAtlas,
+  treeFiles,
+  addFiles,
+  embedMissing,
+  searchFiles,
+  ATLAS_VERSION,
+} from "./atlas.mjs";
 import { readTrail, needs, trailFromTranscript } from "./trails.mjs";
-import { featureRows, swarmPrior, baselineScore, train, modelScore, recallAt, loadModel, saveModel, codeFiles } from "./learn.mjs";
+import {
+  featureRows,
+  swarmPrior,
+  baselineScore,
+  train,
+  modelScore,
+  recallAt,
+  loadModel,
+  saveModel,
+  codeFiles,
+} from "./learn.mjs";
 import { repositoryOf } from "./worktrees.mjs";
 import { createMediaIndex } from "./media.mjs";
 
@@ -28,48 +45,127 @@ const MEDIA_FLOOR = 0.7;
 const MEDIA_IN_PACK = 2;
 const MIN_TRAINING_RUNS = 30;
 
-const git = (cwd, args) => { const out = spawnSync("git", args, { cwd, encoding: "utf8", maxBuffer: 1 << 28 }); return out.status === 0 ? out.stdout : ""; };
-const commitBefore = (root, at) => git(root, ["rev-list", "-1", `--before=${new Date(at).toISOString()}`, "HEAD"]).trim() || null;
+const git = (cwd, args) => {
+  const out = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 1 << 28,
+  });
+  return out.status === 0 ? out.stdout : "";
+};
+const commitBefore = (root, at) =>
+  git(root, [
+    "rev-list",
+    "-1",
+    `--before=${new Date(at).toISOString()}`,
+    "HEAD",
+  ]).trim() || null;
 // Files changed in the two weeks before a commit, by how often; kept per commit, since a commit's history is fixed.
 const recentByCommit = new Map();
 export function recentChanges(root, commit = "HEAD") {
   const sha = git(root, ["rev-parse", commit]).trim();
   if (recentByCommit.has(sha)) return recentByCommit.get(sha);
   const counts = new Map();
-  const since = new Date((Number(git(root, ["show", "-s", "--format=%ct", sha]).trim()) - 14 * 86_400) * 1000).toISOString();
-  for (const file of git(root, ["log", `--since=${since}`, "--name-only", "--format=", sha]).split("\n")) if (file) counts.set(file, (counts.get(file) ?? 0) + 1);
+  const since = new Date(
+    (Number(git(root, ["show", "-s", "--format=%ct", sha]).trim()) -
+      14 * 86_400) *
+      1000
+  ).toISOString();
+  for (const file of git(root, [
+    "log",
+    `--since=${since}`,
+    "--name-only",
+    "--format=",
+    sha,
+  ]).split("\n"))
+    if (file) counts.set(file, (counts.get(file) ?? 0) + 1);
   if (recentByCommit.size > 500) recentByCommit.clear();
   recentByCommit.set(sha, counts);
   return counts;
 }
 const days = (ms) => Math.round(ms / 86_400_000);
-const AGENT_NAMES = { "claude-code": "Claude Code", codex: "Codex", pi: "Pi", opencode: "OpenCode" };
+const AGENT_NAMES = {
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  pi: "Pi",
+  opencode: "OpenCode",
+};
 
 /**
  * Ranks a snapshot's files for a request with every signal the engine has: [{ path, best, score, x }] best first.
  * history: earlier runs in this repository ({ at, edited, read }); model: the learned ranker or null for the default.
  */
-export async function rankFiles({ atlas, inference, query, scope, history = [], at = Date.now(), recent = new Map(), model = null, vectors = null, lane = "handoff", wordLimit }) {
-  const candidates = await searchFiles(atlas, inference, query, scope, { vectors, lane, wordLimit });
+export async function rankFiles({
+  atlas,
+  inference,
+  query,
+  scope,
+  history = [],
+  at = Date.now(),
+  recent = new Map(),
+  model = null,
+  vectors = null,
+  lane = "handoff",
+  wordLimit,
+}) {
+  const candidates = await searchFiles(atlas, inference, query, scope, {
+    vectors,
+    lane,
+    wordLimit,
+  });
   const topWords = Math.max(...candidates.map((c) => c.lexical), 0) || 1;
   const hybrid = (c) => c.dense + 0.25 * (c.lexical / topWords) + 0.2 * c.named;
   const byHybrid = [...candidates].sort((a, b) => hybrid(b) - hybrid(a));
   const prior = swarmPrior(history, at);
   // No cross-encoder pass: on the owner's own sessions it moved recall by under one point (context-recall v3).
-  const byDense = [...candidates].sort((a, b) => b.dense - a.dense).slice(0, POOL).map((c) => c.path);
-  const byWords = [...candidates].sort((a, b) => b.lexical - a.lexical).slice(0, POOL).map((c) => c.path);
-  const pool = new Set([...byDense, ...byWords, ...byHybrid.slice(0, POOL).map((c) => c.path), ...candidates.filter((c) => c.named > 0).map((c) => c.path),
-    ...[...prior.edits.entries()].sort((a, b) => b[1] - a[1]).slice(0, POOL).map(([file]) => file)]);
+  const byDense = [...candidates]
+    .sort((a, b) => b.dense - a.dense)
+    .slice(0, POOL)
+    .map((c) => c.path);
+  const byWords = [...candidates]
+    .sort((a, b) => b.lexical - a.lexical)
+    .slice(0, POOL)
+    .map((c) => c.path);
+  const pool = new Set([
+    ...byDense,
+    ...byWords,
+    ...byHybrid.slice(0, POOL).map((c) => c.path),
+    ...candidates.filter((c) => c.named > 0).map((c) => c.path),
+    ...[...prior.edits.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, POOL)
+      .map(([file]) => file),
+  ]);
   const best = new Map(candidates.map((c) => [c.path, c.best]));
-  const scored = featureRows(candidates.filter((c) => pool.has(c.path)), { prior, recent })
-    .map((row) => ({ ...row, best: best.get(row.path), score: model ? modelScore(model, row.x) : baselineScore(row.x) }));
+  const scored = featureRows(
+    candidates.filter((c) => pool.has(c.path)),
+    { prior, recent }
+  ).map((row) => ({
+    ...row,
+    best: best.get(row.path),
+    score: model ? modelScore(model, row.x) : baselineScore(row.x),
+  }));
   return scored.sort((a, b) => b.score - a.score);
 }
 
-export function createContextEngine({ store, inference, home, known, mediaFolders = () => [], mediaReady = () => false, log = () => {}, notify = () => {} }) {
+export function createContextEngine({
+  store,
+  inference,
+  home,
+  known,
+  mediaFolders = () => [],
+  mediaReady = () => false,
+  log = () => {},
+  notify = () => {},
+}) {
   const atlas = openAtlas(path.join(home, "atlas.db"));
   // Recordings and screenshots in folders the person added (media.mjs), once the image and audio part is here.
-  const media = createMediaIndex({ atlas, inference, folders: mediaFolders, log });
+  const media = createMediaIndex({
+    atlas,
+    inference,
+    folders: mediaFolders,
+    log,
+  });
   const modelPath = path.join(home, "ranker.json");
   let model = loadModel(modelPath);
   let refreshing = null;
@@ -79,8 +175,12 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
   /** The vectors for a scope's pieces, read from the atlas once and kept until packs stop for a while. */
   const vectorsFor = (scope) => {
     const wanted = new Set();
-    for (const row of scope) for (const hash of atlas.blob(row.blob) ?? []) if (!cached.has(hash)) wanted.add(hash);
-    if (wanted.size) for (const [hash, vector] of atlas.vectors(wanted, ATLAS_VERSION)) cached.set(hash, vector);
+    for (const row of scope)
+      for (const hash of atlas.blob(row.blob) ?? [])
+        if (!cached.has(hash)) wanted.add(hash);
+    if (wanted.size)
+      for (const [hash, vector] of atlas.vectors(wanted, ATLAS_VERSION))
+        cached.set(hash, vector);
     clearTimeout(dropCache);
     dropCache = setTimeout(() => cached.clear(), VECTORS_IDLE_MS);
     dropCache.unref?.();
@@ -91,12 +191,25 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
   const placeOf = (folder) => {
     const repo = repositoryOf(folder);
     if (!repo) return null;
-    const common = git(repo.root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]).trim();
-    const root = common && path.basename(common) === ".git" ? path.dirname(common) : repo.root;
+    const common = git(repo.root, [
+      "rev-parse",
+      "--path-format=absolute",
+      "--git-common-dir",
+    ]).trim();
+    const root =
+      common && path.basename(common) === ".git"
+        ? path.dirname(common)
+        : repo.root;
     return { root, top: repo.root };
   };
 
-  const roots = () => [...new Set(known().map((place) => placeOf(place.path)?.root).filter(Boolean))];
+  const roots = () => [
+    ...new Set(
+      known()
+        .map((place) => placeOf(place.path)?.root)
+        .filter(Boolean)
+    ),
+  ];
 
   /** Brings one checkout's files into the atlas; returns its files. Pieces are embedded later on the background lane. */
   const indexTree = (top, commit = null) => {
@@ -108,7 +221,9 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
   /** Records every coding session that ran in a known repository: what it was asked and what it needed. */
   const recordRuns = async () => {
     const rootList = roots();
-    const since = new Date(Date.now() - HISTORY_DAYS * 86_400_000).toISOString();
+    const since = new Date(
+      Date.now() - HISTORY_DAYS * 86_400_000
+    ).toISOString();
     const trees = new Map();
     let added = 0;
     for (const session of store.sessionSources({ since })) {
@@ -116,16 +231,50 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
       if (!place || !rootList.includes(place.root)) continue;
       // A session whose source file the agent has since deleted is read from the relay's own copy, once.
       let mtime = 0;
-      try { mtime = fs.statSync(session.source).mtimeMs; } catch {}
+      try {
+        mtime = fs.statSync(session.source).mtimeMs;
+      } catch {}
       if (atlas.runSeen(session.agent, session.session_id) === mtime) continue;
-      const trail = mtime ? await readTrail(session.agent, session.source)
-        : trailFromTranscript(session.agent, store.sessionTranscript(session.agent, session.session_id), { cwd: session.cwd, startedAt: Date.parse(session.started_at) || null });
+      const trail = mtime
+        ? await readTrail(session.agent, session.source)
+        : trailFromTranscript(
+            session.agent,
+            store.sessionTranscript(session.agent, session.session_id),
+            {
+              cwd: session.cwd,
+              startedAt: Date.parse(session.started_at) || null,
+            }
+          );
       if (!trail?.brief || trail.startedAt === null) continue;
       const commit = commitBefore(place.root, trail.startedAt);
       if (!commit) continue;
-      if (!trees.has(commit)) trees.set(commit, new Set(treeFiles(place.root, commit).map((row) => row.path)));
-      const need = needs({ ...trail, cwd: trail.cwd && placeOf(trail.cwd)?.top === place.top ? path.join(place.root, path.relative(place.top, trail.cwd)) : trail.cwd }, place.root, trees.get(commit));
-      atlas.putRun({ agent: session.agent, sessionId: session.session_id, root: place.root, at: trail.startedAt, brief: trail.brief, edited: need.edited, read: need.read, before: need.beforeFirstEdit, sourceMtime: mtime });
+      if (!trees.has(commit))
+        trees.set(
+          commit,
+          new Set(treeFiles(place.root, commit).map((row) => row.path))
+        );
+      const need = needs(
+        {
+          ...trail,
+          cwd:
+            trail.cwd && placeOf(trail.cwd)?.top === place.top
+              ? path.join(place.root, path.relative(place.top, trail.cwd))
+              : trail.cwd,
+        },
+        place.root,
+        trees.get(commit)
+      );
+      atlas.putRun({
+        agent: session.agent,
+        sessionId: session.session_id,
+        root: place.root,
+        at: trail.startedAt,
+        brief: trail.brief,
+        edited: need.edited,
+        read: need.read,
+        before: need.beforeFirstEdit,
+        sourceMtime: mtime,
+      });
       added += 1;
     }
     return added;
@@ -135,8 +284,17 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
     for (;;) {
       const rows = atlas.runsToEmbed(ATLAS_VERSION, 16);
       if (!rows.length) return;
-      const vectors = await inference.embed(rows.map((row) => ({ kind: "document", title: "none", text: row.brief })), { lane });
-      rows.forEach((row, i) => atlas.putRunVector(row.agent, row.session_id, ATLAS_VERSION, vectors[i]));
+      const vectors = await inference.embed(
+        rows.map((row) => ({
+          kind: "document",
+          title: "none",
+          text: row.brief,
+        })),
+        { lane }
+      );
+      rows.forEach((row, i) =>
+        atlas.putRunVector(row.agent, row.session_id, ATLAS_VERSION, vectors[i])
+      );
     }
   };
 
@@ -147,7 +305,8 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
       // A first pass over a repository waits for the charger; small catch-ups run on battery too unless it is low.
       if (power.paused()) return { skipped: "power" };
       const first = !atlas.roots().length;
-      if (first && !power.onCharger()) return { skipped: "waiting for the charger" };
+      if (first && !power.onCharger())
+        return { skipped: "waiting for the charger" };
       let files = 0;
       for (const root of roots()) {
         const rows = indexTree(root);
@@ -155,15 +314,30 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
         files += rows.length;
       }
       const runs = await recordRuns();
-      const pieces = await embedMissing(atlas, inference, { lane: "background" });
+      const pieces = await embedMissing(atlas, inference, {
+        lane: "background",
+      });
       await embedRuns("background");
-      const recorded = mediaReady() && mediaFolders().length && power.onCharger() ? await media.refresh({ lane: "background" }) : null;
+      const recorded =
+        mediaReady() && mediaFolders().length && power.onCharger()
+          ? await media.refresh({ lane: "background" })
+          : null;
       return { files, runs, pieces, ...(recorded ? { media: recorded } : {}) };
-    })().catch((error) => { log(`context engine: ${error.message}`); return { error: error.message }; }).finally(() => { refreshing = null; });
+    })()
+      .catch((error) => {
+        log(`context engine: ${error.message}`);
+        return { error: error.message };
+      })
+      .finally(() => {
+        refreshing = null;
+      });
     return refreshing;
   };
 
-  const historyFor = (root) => atlas.runs(root).map((run) => ({ at: run.at, edited: run.edited, read: run.read }));
+  const historyFor = (root) =>
+    atlas
+      .runs(root)
+      .map((run) => ({ at: run.at, edited: run.edited, read: run.read }));
 
   /**
    * The context pack for a brief going to a local agent working in folder: { files, earlier, text }. Files are the most
@@ -177,10 +351,21 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
     // A few changed pieces are embedded now; a repository the relay has not indexed yet is searched by words and names
     // this time while the background pass embeds it.
     const missing = atlas.missing(ATLAS_VERSION);
-    if (missing && missing <= 400) await embedMissing(atlas, inference, { lane });
+    if (missing && missing <= 400)
+      await embedMissing(atlas, inference, { lane });
     else if (missing) void refresh();
     const history = historyFor(place.root);
-    const ranked = await rankFiles({ atlas, inference, query: String(brief).slice(0, 4_000), scope, history, recent: recentChanges(place.top), model, lane, vectors: vectorsFor(scope) });
+    const ranked = await rankFiles({
+      atlas,
+      inference,
+      query: String(brief).slice(0, 4_000),
+      scope,
+      history,
+      recent: recentChanges(place.top),
+      model,
+      lane,
+      vectors: vectorsFor(scope),
+    });
     const prior = swarmPrior(history, Date.now());
     const files = ranked.slice(0, PACK_FILES).map((row) => {
       const piece = row.best ? atlas.piece(row.best) : null;
@@ -188,30 +373,86 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
       if (row.x.named) why.push("named in the request");
       if (row.x.lexical > 0.5) why.push("shares the request's words");
       if (prior.edits.has(row.path)) why.push("recently edited by your agents");
-      return { path: row.path, line: piece?.line ?? 1, why: why.join("; ") || "related by meaning" };
+      return {
+        path: row.path,
+        line: piece?.line ?? 1,
+        why: why.join("; ") || "related by meaning",
+      };
     });
-    const query = (await inference.embed([{ kind: "query", text: String(brief).slice(0, 4_000) }], { lane }))[0];
-    const earlier = atlas.runVectors(place.root, ATLAS_VERSION).map((run) => {
-      let dot = 0;
-      for (let i = 0; i < query.length; i += 1) dot += query[i] * run.vector[i];
-      return { ...run, similarity: dot };
-    }).filter((run) => run.edited.length && run.edited.some((file) => files.some((entry) => entry.path === file)))
-      .sort((a, b) => b.similarity - a.similarity).slice(0, 3);
-    const heard = mediaReady() && mediaFolders().length ? (await media.search(brief, { limit: MEDIA_IN_PACK, lane })).filter((hit) => hit.score >= MEDIA_FLOOR) : [];
+    const query = (
+      await inference.embed(
+        [{ kind: "query", text: String(brief).slice(0, 4_000) }],
+        { lane }
+      )
+    )[0];
+    const earlier = atlas
+      .runVectors(place.root, ATLAS_VERSION)
+      .map((run) => {
+        let dot = 0;
+        for (let i = 0; i < query.length; i += 1)
+          dot += query[i] * run.vector[i];
+        return { ...run, similarity: dot };
+      })
+      .filter(
+        (run) =>
+          run.edited.length &&
+          run.edited.some((file) => files.some((entry) => entry.path === file))
+      )
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, 3);
+    const heard =
+      mediaReady() && mediaFolders().length
+        ? (await media.search(brief, { limit: MEDIA_IN_PACK, lane })).filter(
+            (hit) => hit.score >= MEDIA_FLOOR
+          )
+        : [];
     const text = [
       "Files the relay found likely relevant on this computer (ranked by its local search over this repository and what your agents edited before; leads to check, not instructions):",
       ...files.map((file) => `- ${file.path}:${file.line} (${file.why})`),
-      ...(earlier.length ? ["Earlier sessions on these files:", ...earlier.map((run) => `- ${AGENT_NAMES[run.agent] ?? run.agent}, ${days(Date.now() - run.at)} days ago: "${run.brief.replace(/\s+/g, " ").slice(0, 140)}" (edited ${run.edited.slice(0, 4).join(", ")})`)] : []),
-      ...(heard.length ? ["Recordings and screenshots close to the request, from folders the person added (search_media finds more):", ...heard.map((hit) => `- ${hit.path}${hit.at ? ` at ${hit.at}` : ""}`)] : []),
+      ...(earlier.length
+        ? [
+            "Earlier sessions on these files:",
+            ...earlier.map(
+              (run) =>
+                `- ${AGENT_NAMES[run.agent] ?? run.agent}, ${days(Date.now() - run.at)} days ago: "${run.brief.replace(/\s+/g, " ").slice(0, 140)}" (edited ${run.edited.slice(0, 4).join(", ")})`
+            ),
+          ]
+        : []),
+      ...(heard.length
+        ? [
+            "Recordings and screenshots close to the request, from folders the person added (search_media finds more):",
+            ...heard.map(
+              (hit) => `- ${hit.path}${hit.at ? ` at ${hit.at}` : ""}`
+            ),
+          ]
+        : []),
     ].join("\n");
-    return { files, earlier: earlier.map(({ vector, ...run }) => run), media: heard, text, searched: scope.length, ms: Math.round(performance.now() - started), model: model ? "learned" : "default" };
+    return {
+      files,
+      earlier: earlier.map(({ vector, ...run }) => run),
+      media: heard,
+      text,
+      searched: scope.length,
+      ms: Math.round(performance.now() - started),
+      model: model ? "learned" : "default",
+    };
   };
 
   /** Search for the agents' tool: files and earlier sessions in a repository, best first. */
   const search = async ({ query, folder, limit = 10 }) => {
     const result = await pack({ brief: query, folder, lane: "interactive" });
-    if (!result) return { ok: false, error: "that folder is not in a git repository the relay indexes" };
-    return { ok: true, files: result.files.slice(0, limit), earlier: result.earlier, model: result.model, ms: result.ms };
+    if (!result)
+      return {
+        ok: false,
+        error: "that folder is not in a git repository the relay indexes",
+      };
+    return {
+      ok: true,
+      files: result.files.slice(0, limit),
+      earlier: result.earlier,
+      model: result.model,
+      ms: result.ms,
+    };
   };
 
   /**
@@ -220,56 +461,126 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
    */
   const learn = async ({ force = false } = {}) => {
     const last = Number(atlas.meta("learned_at") || 0);
-    if (!force && (Date.now() - last < LEARN_EVERY_MS || !inference.power.onCharger() || inference.power.paused())) return null;
+    if (
+      !force &&
+      (Date.now() - last < LEARN_EVERY_MS ||
+        !inference.power.onCharger() ||
+        inference.power.paused())
+    )
+      return null;
     await refresh();
     const report = { at: new Date().toISOString(), repositories: [] };
     const rows = [];
     for (const root of roots()) {
-      const runs = atlas.runs(root, Date.now() - HISTORY_DAYS * 86_400_000).filter((run) => run.edited.length);
+      const runs = atlas
+        .runs(root, Date.now() - HISTORY_DAYS * 86_400_000)
+        .filter((run) => run.edited.length);
       if (!runs.length) continue;
       const snapshots = new Map();
       for (const run of runs) {
         const commit = commitBefore(root, run.at);
         if (!commit) continue;
-        if (!snapshots.has(commit)) snapshots.set(commit, indexTree(root, commit));
+        if (!snapshots.has(commit))
+          snapshots.set(commit, indexTree(root, commit));
         rows.push({ root, run, commit });
       }
-      report.repositories.push({ root, runs: runs.length, snapshots: snapshots.size });
+      report.repositories.push({
+        root,
+        runs: runs.length,
+        snapshots: snapshots.size,
+      });
     }
     await embedMissing(atlas, inference, { lane: "background" });
     rows.sort((a, b) => a.run.at - b.run.at);
-    if (rows.length < MIN_TRAINING_RUNS) { atlas.meta("learned_at", Date.now()); return { ...report, kept: false, why: `only ${rows.length} runs so far` }; }
+    if (rows.length < MIN_TRAINING_RUNS) {
+      atlas.meta("learned_at", Date.now());
+      return { ...report, kept: false, why: `only ${rows.length} runs so far` };
+    }
     const featured = [];
     for (const { root, run, commit } of rows) {
       const history = historyFor(root).filter((other) => other.at < run.at);
-      const ranked = await rankFiles({ atlas, inference, query: run.brief, scope: treeFiles(root, commit), history, at: run.at, recent: recentChanges(root, commit), model: null, lane: "background" });
+      const ranked = await rankFiles({
+        atlas,
+        inference,
+        query: run.brief,
+        scope: treeFiles(root, commit),
+        history,
+        at: run.at,
+        recent: recentChanges(root, commit),
+        model: null,
+        lane: "background",
+      });
       featured.push({ run, ranked });
     }
     const cut = Math.floor(featured.length * (1 - HELD_OUT_SHARE));
-    const label = (run, row) => (codeFiles(run.edited).includes(row.path) ? 1 : 0);
-    const trainRows = featured.slice(0, cut).flatMap(({ run, ranked }) => ranked.map((row) => ({ x: row.x, y: label(run, row) })));
+    const label = (run, row) =>
+      codeFiles(run.edited).includes(row.path) ? 1 : 0;
+    const trainRows = featured
+      .slice(0, cut)
+      .flatMap(({ run, ranked }) =>
+        ranked.map((row) => ({ x: row.x, y: label(run, row) }))
+      );
     const candidate = train(trainRows);
-    const heldOut = featured.slice(cut).filter(({ run }) => codeFiles(run.edited).length);
-    const recall = (score) => heldOut.reduce((sum, { run, ranked }) => sum + recallAt([...ranked].sort((a, b) => score(b.x) - score(a.x)).map((row) => row.path), codeFiles(run.edited), 10), 0) / heldOut.length;
-    const result = { default: recall(baselineScore), current: model ? recall((x) => modelScore(model, x)) : null, candidate: recall((x) => modelScore(candidate, x)) };
+    const heldOut = featured
+      .slice(cut)
+      .filter(({ run }) => codeFiles(run.edited).length);
+    const recall = (score) =>
+      heldOut.reduce(
+        (sum, { run, ranked }) =>
+          sum +
+          recallAt(
+            [...ranked]
+              .sort((a, b) => score(b.x) - score(a.x))
+              .map((row) => row.path),
+            codeFiles(run.edited),
+            10
+          ),
+        0
+      ) / heldOut.length;
+    const result = {
+      default: recall(baselineScore),
+      current: model ? recall((x) => modelScore(model, x)) : null,
+      candidate: recall((x) => modelScore(candidate, x)),
+    };
     const bar = Math.max(result.default, result.current ?? 0);
     const kept = result.candidate > bar;
     if (kept) {
       // Retrained on every run before it ships; the held-out score is the one reported.
-      model = { ...train(featured.flatMap(({ run, ranked }) => ranked.map((row) => ({ x: row.x, y: label(run, row) })))), trainedAt: report.at, heldOut: result, runs: featured.length };
+      model = {
+        ...train(
+          featured.flatMap(({ run, ranked }) =>
+            ranked.map((row) => ({ x: row.x, y: label(run, row) }))
+          )
+        ),
+        trainedAt: report.at,
+        heldOut: result,
+        runs: featured.length,
+      };
       saveModel(modelPath, model);
     }
     atlas.meta("learned_at", Date.now());
-    const full = { ...report, runs: featured.length, heldOutRuns: heldOut.length, recallAt10: result, kept };
+    const full = {
+      ...report,
+      runs: featured.length,
+      heldOutRuns: heldOut.length,
+      recallAt10: result,
+      kept,
+    };
     atlas.meta("last_learning", JSON.stringify(full));
-    if (kept) notify(`Learned from ${featured.length} runs overnight: the files your agents went on to change are now in their briefs' top ten ${Math.round(result.candidate * 100)}% of the time (was ${Math.round(bar * 100)}%).`);
+    if (kept)
+      notify(
+        `Learned from ${featured.length} runs overnight: the files your agents went on to change are now in their briefs' top ten ${Math.round(result.candidate * 100)}% of the time (was ${Math.round(bar * 100)}%).`
+      );
     return full;
   };
 
   return {
     atlas,
     /** A folder's files as the atlas holds them now ([{ path, blob }]), indexed first; [] outside a repository. */
-    scope: (folder) => { const place = folder && placeOf(folder); return place ? indexTree(place.top) : []; },
+    scope: (folder) => {
+      const place = folder && placeOf(folder);
+      return place ? indexTree(place.top) : [];
+    },
     pack,
     search,
     /** Recordings' minutes and screenshots closest to a question, for an agent's search_media. */
@@ -277,14 +588,41 @@ export function createContextEngine({ store, inference, home, known, mediaFolder
     refreshMedia: () => media.refresh({ lane: "background" }),
     refresh,
     learn,
-    report: () => { try { return JSON.parse(atlas.meta("last_learning") || "null"); } catch { return null; } },
-    status: () => ({ roots: atlas.roots(), pieces: { waiting: atlas.missing(ATLAS_VERSION) }, media: media.status(), model: model ? { trainedAt: model.trainedAt, heldOut: model.heldOut, runs: model.runs } : null, device: inference.device() }),
+    report: () => {
+      try {
+        return JSON.parse(atlas.meta("last_learning") || "null");
+      } catch {
+        return null;
+      }
+    },
+    status: () => ({
+      roots: atlas.roots(),
+      pieces: { waiting: atlas.missing(ATLAS_VERSION) },
+      media: media.status(),
+      model: model
+        ? {
+            trainedAt: model.trainedAt,
+            heldOut: model.heldOut,
+            runs: model.runs,
+          }
+        : null,
+      device: inference.device(),
+    }),
     start() {
-      const tick = () => { void refresh().then(() => learn()).catch((error) => log(`context engine: ${error.message}`)); };
+      const tick = () => {
+        void refresh()
+          .then(() => learn())
+          .catch((error) => log(`context engine: ${error.message}`));
+      };
       setTimeout(tick, 60_000).unref?.();
       timer = setInterval(tick, REFRESH_MS);
       timer.unref?.();
     },
-    stop() { clearInterval(timer); clearTimeout(dropCache); cached.clear(); atlas.close(); },
+    stop() {
+      clearInterval(timer);
+      clearTimeout(dropCache);
+      cached.clear();
+      atlas.close();
+    },
   };
 }

package/lib/control-client.mjs

@@ -19,8 +19,11 @@ export function daemonRequest(message, timeoutMs = 5_000) {
       buffer += chunk;
       const newline = buffer.indexOf("\n");
       if (newline < 0) return;
-      try { finish(null, JSON.parse(buffer.slice(0, newline))); }
-      catch { finish(new Error("daemon returned invalid JSON")); }
+      try {
+        finish(null, JSON.parse(buffer.slice(0, newline)));
+      } catch {
+        finish(new Error("daemon returned invalid JSON"));
+      }
     });
     socket.on("timeout", () => finish(new Error("daemon request timed out")));
     socket.on("error", (error) => finish(error));