@arjunkhera/atlas 0.0.0 → 0.2.0

package/work/lib/client.mjs

@@ -0,0 +1,214 @@
+const DEFAULT_PAGE_SIZE = 200;
+const SEARCH_LIMIT = 50;
+const MAX_PAGES = 100;
+const MAX_ROWS = 20_000;
+const REQUEST_TIMEOUT_MS = 15_000;
+const MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+const MAX_SEARCH_REQUESTS = 64;
+const MAX_SEARCH_DEPTH = 24;
+
+export class EngramHttpError extends Error {
+  constructor(message, { status, method, path, body } = {}) {
+    super(message);
+    this.name = 'EngramHttpError';
+    this.status = status;
+    this.method = method;
+    this.path = path;
+    this.body = body;
+  }
+}
+
+function cleanBaseUrl(value) {
+  const url = new URL(value);
+  const loopback = url.hostname === 'localhost' || url.hostname === '127.0.0.1' || url.hostname === '::1';
+  if (url.protocol !== 'https:' && !(url.protocol === 'http:' && loopback)) throw new TypeError('baseUrl must use https, except for loopback development');
+  if (url.username || url.password || url.pathname !== '/' || url.search || url.hash) throw new TypeError('baseUrl must contain only the service origin');
+  return url.origin;
+}
+
+function redact(value, token) {
+  let text = String(value ?? '');
+  if (token) text = text.split(token).join('[REDACTED]');
+  return text.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [REDACTED]');
+}
+
+function queryPath(path, query = {}) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined && value !== null && value !== '') search.set(key, String(value));
+  }
+  const suffix = search.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+export function createEngramClient({ baseUrl, token, fetchImpl = globalThis.fetch } = {}) {
+  if (typeof token !== 'string' || token.length === 0) throw new TypeError('token is required');
+  if (typeof fetchImpl !== 'function') throw new TypeError('fetchImpl must be a function');
+  const origin = cleanBaseUrl(baseUrl);
+
+  async function request(method, path, { body, query } = {}) {
+    const relative = queryPath(path, query);
+    let response;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      response = await fetchImpl(`${origin}${relative}`, {
+        method,
+        redirect: 'error',
+        signal: controller.signal,
+        headers: {
+          accept: 'application/json',
+          authorization: `Bearer ${token}`,
+          ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+        },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+      });
+    } catch (error) {
+      throw new EngramHttpError(`Engram ${method} ${relative} failed: ${redact(error?.message, token)}`, {
+        method, path: relative,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+
+    let bodyTimer;
+    let text;
+    try {
+      text = await Promise.race([
+        response.text(),
+        new Promise((_, reject) => {
+          bodyTimer = setTimeout(() => {
+            controller.abort();
+            reject(new EngramHttpError(`Engram ${method} ${relative} response timed out`, { status: response.status, method, path: relative }));
+          }, REQUEST_TIMEOUT_MS);
+        }),
+      ]);
+    } finally {
+      clearTimeout(bodyTimer);
+    }
+    if (new TextEncoder().encode(text).byteLength > MAX_RESPONSE_BYTES) {
+      throw new EngramHttpError(`Engram ${method} ${relative} response exceeded ${MAX_RESPONSE_BYTES} bytes`, { status: response.status, method, path: relative });
+    }
+    let payload = null;
+    if (text) {
+      try { payload = JSON.parse(text); } catch { payload = text; }
+    }
+    if (!response.ok) {
+      const serverMessage = payload && typeof payload === 'object'
+        ? payload.message ?? payload.error ?? response.statusText
+        : payload ?? response.statusText;
+      throw new EngramHttpError(
+        `Engram ${method} ${relative} returned ${response.status}: ${redact(serverMessage, token)}`,
+        { status: response.status, method, path: relative },
+      );
+    }
+    return payload;
+  }
+
+  const getEntity = (id) => request('GET', `/v1/entities/${encodeURIComponent(id)}`);
+  const listEntities = (query = {}) => request('GET', '/v1/entities', { query });
+  const searchEntities = (query) => request('GET', '/v1/search', { query });
+  const listEdges = (id, query = {}) => request('GET', `/v1/entities/${encodeURIComponent(id)}/edges`, { query });
+
+  async function collectOffsetPages(load, key, query, maximum) {
+    const result = [];
+    let offset = 0;
+    for (let pageNumber = 0; pageNumber < MAX_PAGES; pageNumber += 1) {
+      const page = await load({ ...query, limit: maximum, offset });
+      if (!page || typeof page !== 'object' || !Array.isArray(page[key]) || !Number.isFinite(Number(page.total))) {
+        throw new Error(`Engram returned an invalid ${key} page`);
+      }
+      const rows = page[key];
+      result.push(...rows);
+      if (result.length > MAX_ROWS) throw new Error(`${key} pagination exceeded the ${MAX_ROWS}-row safety bound`);
+      const total = Number(page?.total);
+      if (!Number.isFinite(total) || result.length >= total) return result;
+      if (rows.length === 0) throw new Error(`${key} pagination stopped before reported total`);
+      offset += rows.length;
+    }
+    throw new Error(`${key} pagination exceeded the ${MAX_PAGES}-page safety bound`);
+  }
+
+  const listAllEntities = (query = {}) => collectOffsetPages(listEntities, 'entities', query, DEFAULT_PAGE_SIZE);
+  const listAllEdges = (id, query = {}) => collectOffsetPages((q) => listEdges(id, q), 'edges', query, 100);
+
+  async function searchAllEntities(query) {
+    const normalized = { ...query };
+    if (normalized.q === undefined && normalized.query !== undefined) normalized.q = normalized.query;
+    delete normalized.query;
+    let searchRequests = 0;
+    const hitById = new Map();
+
+    function readPage(page) {
+      if (!page || typeof page !== 'object' || !Array.isArray(page.results)
+        || !Number.isFinite(Number(page.total)) || !Number.isFinite(Number(page.total_candidates))) {
+        throw new Error('Engram returned an invalid search page');
+      }
+      for (const hit of page.results) {
+        if (!hit || typeof hit.id !== 'string' || !hit.id) throw new Error('Engram returned a search hit without an id');
+        hitById.set(hit.id, hit);
+      }
+      return page.results.length < SEARCH_LIMIT && Number(page.total_candidates) <= page.results.length;
+    }
+
+    async function searchWindow(window, inventory, depth) {
+      if (depth > MAX_SEARCH_DEPTH || ++searchRequests > MAX_SEARCH_REQUESTS) {
+        throw new Error('Engram search partition exceeded its safety bound');
+      }
+      const page = await searchEntities({ ...normalized, ...window, limit: SEARCH_LIMIT });
+      if (readPage(page)) return;
+      if (inventory.length < 2) throw new Error('Engram search result is incomplete and its date window cannot be split');
+
+      const times = inventory.map((entity) => Date.parse(entity.created_at)).sort((a, b) => a - b);
+      if (times.some((time) => !Number.isFinite(time))) throw new Error('Engram search inventory contains an invalid created_at');
+      const candidates = [...new Set(times)].map((pivot) => {
+        const left = inventory.filter((entity) => Date.parse(entity.created_at) < pivot + 1);
+        const right = inventory.filter((entity) => Date.parse(entity.created_at) > pivot - 1);
+        return { pivot, left, right, size: Math.max(left.length, right.length) };
+      }).filter(({ left, right }) => left.length < inventory.length && right.length < inventory.length);
+      candidates.sort((a, b) => a.size - b.size);
+      const split = candidates[0];
+      if (!split) throw new Error('Engram search result is incomplete and entities share an unsplittable timestamp');
+
+      const leftBefore = new Date(split.pivot + 1).toISOString();
+      const rightAfter = new Date(split.pivot - 1).toISOString();
+      await searchWindow({ ...window, before: leftBefore }, split.left, depth + 1);
+      await searchWindow({ ...window, after: rightAfter }, split.right, depth + 1);
+    }
+
+    const first = await searchEntities({ ...normalized, limit: SEARCH_LIMIT });
+    searchRequests += 1;
+    if (!readPage(first)) {
+      const inventoryQuery = { type: normalized.type, state: normalized.state ?? 'active' };
+      const inventory = (await listAllEntities(inventoryQuery)).filter((entity) => {
+        const created = Date.parse(entity.created_at);
+        return Number.isFinite(created)
+          && (normalized.after === undefined || created > Date.parse(normalized.after))
+          && (normalized.before === undefined || created < Date.parse(normalized.before));
+      });
+      await searchWindow({}, inventory, 1);
+    }
+    return Promise.all([...hitById.keys()].map((id) => getEntity(id)));
+  }
+
+  return Object.freeze({
+    request,
+    getEntity,
+    listEntities,
+    listAllEntities,
+    searchEntities,
+    searchAllEntities,
+    listEdges,
+    listAllEdges,
+    listTypes: () => request('GET', '/v1/types'),
+    getPublisher: () => request('GET', '/v1/forge/publisher'),
+    getForgeArtifact: (handle, name) => request('GET', `/v1/forge/artifacts/${encodeURIComponent(handle)}/${encodeURIComponent(name)}`),
+    getForgeVersion: (handle, name, version) => request('GET', `/v1/forge/artifacts/${encodeURIComponent(handle)}/${encodeURIComponent(name)}/versions/${encodeURIComponent(version)}`),
+    createForgeArtifact: (body) => request('POST', '/v1/forge/artifacts', { body }),
+    publishForgeVersion: (handle, name, body) => request('POST', `/v1/forge/artifacts/${encodeURIComponent(handle)}/${encodeURIComponent(name)}/versions`, { body }),
+    registerTypes: (handle, name, version) => request('POST', `/v1/forge/artifacts/${encodeURIComponent(handle)}/${encodeURIComponent(name)}/versions/${encodeURIComponent(version)}/register-types`),
+    createEntity: (body) => request('POST', '/v1/entities', { body }),
+    updateEntity: (id, body) => request('PATCH', `/v1/entities/${encodeURIComponent(id)}`, { body }),
+    createEdge: (body) => request('POST', '/v1/edges', { body }),
+  });
+}

package/work/lib/code-read.mjs

@@ -0,0 +1,238 @@
+// Atlas M1 slice L4: the code read by sub-agents.
+// Design: the Atlas M1 study, page four (the code half
+// of "where are we with X"), D3 rule 4, D6 finding R12, and the frozen L4
+// paragraph of the lock block.
+//
+// Three rules hold this file together:
+//   1. Every claim cites a path and a line. A finding with no citation is
+//      refused, so no claim can enter an answer without a place to check it.
+//   2. The never-read paths are refused wherever this code can see them: in
+//      the brief the sub-agent is given, in the digest it returns, and in the
+//      resolver that opens files afterwards.
+//   3. Nothing from a never-quoted path is ever pasted, and every string is
+//      scrubbed by pattern before it reaches a record, a view or an artifact.
+import protectedPaths from '../protected-paths.json' with { type: 'json' };
+import { refuse, text, stringList, sha256 } from './verb-fields.mjs';
+import { scrubSecrets } from './questions.mjs';
+
+export const NEVER_READ = Object.freeze([...protectedPaths.never_read]);
+export const NEVER_QUOTE = Object.freeze([...protectedPaths.never_quote]);
+export const LIMIT_KINDS = Object.freeze(['cap', 'flag', 'skipped', 'untested', 'other']);
+
+const MAX_FILES_READ = 400;
+const MAX_FINDINGS = 64;
+const MAX_UNKNOWNS = 32;
+const MAX_STATEMENT = 1000;
+const MAX_QUOTE = 400;
+const MAX_LINE = 2_000_000;
+const COMMIT = /^[0-9a-f]{7,40}$/;
+
+// One repo-relative path, as a citation may spell it. An absolute path, a
+// parent step or a URL is refused: a citation must name a file inside the repo
+// it claims to have read, or a reviewer cannot resolve it.
+export function repoPath(value, name = 'path') {
+  const raw = text(value, name, { max: 400 }).trim().replace(/\\/g, '/');
+  if (/^[a-z][a-z0-9+.-]*:/i.test(raw)) refuse(`${name} must be a path inside the repo, not a URL: ${raw}`);
+  if (raw.startsWith('/')) refuse(`${name} must be relative to the repo root, not absolute: ${raw}`);
+  const parts = raw.split('/').filter((part) => part !== '' && part !== '.');
+  if (!parts.length) refuse(`${name} must name a file in the repo`);
+  if (parts.includes('..')) refuse(`${name} must stay inside the repo: ${raw}`);
+  return parts.join('/');
+}
+
+const quote = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const globSource = (part) => part.split('*').map(quote).join('[^/]*');
+const globPattern = (rule) => new RegExp(`^${globSource(rule)}$`);
+
+// A rule matches a path when it names the whole path, a directory on it, or a
+// file on it. "deploy/" catches deploy/app.ts at any depth; ".env*" catches
+// .env.local wherever it sits; "docs/references" catches the directory and
+// everything under it; "test/*.integration.test.ts" catches one under test/ at
+// any depth.
+//
+// The comparison is case-insensitive, and deliberately. This Mac's filesystem
+// opens `.CLAUDE/settings.json` and `.claude/settings.json` as one file, so a
+// case-exact rule would let a capital letter walk a never-read path past the
+// door (review H1).
+function ruleMatches(rule, path) {
+  const lower = path.toLowerCase();
+  const segments = lower.split('/');
+  const bare = (rule.endsWith('/') ? rule.slice(0, -1) : rule).toLowerCase();
+  if (!bare.includes('/') && bare.includes('*')) {
+    const pattern = globPattern(bare);
+    return pattern.test(lower) || segments.some((segment) => pattern.test(segment));
+  }
+  if (bare.includes('/')) {
+    // A multi-part rule matches from the repo root or from any directory on the
+    // path, so a nested package cannot hide a never-quoted file. Its last part
+    // may also sit deeper: test/sub/api.integration.test.ts is an integration
+    // test, whatever directory holds it (review H1).
+    const parts = bare.split('/');
+    const head = parts.slice(0, -1).map(globSource).join('/');
+    const tail = globSource(parts.at(-1));
+    return new RegExp(`(?:^|/)${head}/(?:[^/]+/)*${tail}(?:/|$)`).test(lower);
+  }
+  return segments.includes(bare);
+}
+
+export const neverReadRule = (path) => NEVER_READ.find((rule) => ruleMatches(rule, path)) ?? null;
+export const neverQuoteRule = (path) => NEVER_QUOTE.find((rule) => ruleMatches(rule, path)) ?? null;
+
+export function requireReadable(path, name = 'path') {
+  const clean = repoPath(path, name);
+  const rule = neverReadRule(clean);
+  if (rule) refuse(`${name} ${clean} is a never-read path (rule "${rule}"); the code read must not open it, and no answer may cite it`);
+  return clean;
+}
+
+// The brief a sub-agent is given for one repo. The rules live here, not in each
+// session's prose, so every code read is briefed the same way and the evidence
+// shows exactly what the reader was told (D6 R3, R12).
+export function codeReadBrief({ capability, repo, commit, root, focus = [], defaultBranch } = {}) {
+  const name = text(capability, 'capability', { max: 200 });
+  const repoId = text(repo, 'repo', { max: 200 });
+  const where = root ? `worktree: ${root}` : `checkout of ${repoId} at the tip of ${defaultBranch || 'the default branch'}`;
+  const lines = [
+    `# Code read — ${name} in ${repoId}`,
+    '',
+    where,
+    ...(commit ? [`commit: ${commit}`] : []),
+    '',
+    '## What to return',
+    '',
+    'Return one JSON object and nothing else:',
+    '',
+    '```json',
+    '{',
+    `  "repo": "${repoId}",`,
+    `  "commit": "${commit || '<the commit you read>'}",`,
+    `  "capability": "${name}",`,
+    '  "files_read": ["path/you/opened.ts"],',
+    '  "supports": [{ "name": "what works", "statement": "one sentence", "path": "src/x.ts", "line": 42 }],',
+    '  "limits": [{ "name": "the limit", "kind": "cap|flag|skipped|untested|other", "statement": "one sentence", "path": "src/x.ts", "line": 88 }],',
+    '  "unknowns": ["what you could not settle, and where you looked"]',
+    '}',
+    '```',
+    '',
+    '## The rules',
+    '',
+    '1. Every claim carries a path and a line. No location, no claim.',
+    '2. List every file you opened in `files_read`. Every citation must name a file on that list.',
+    `3. The never-read paths. Never read these with any tool: ${NEVER_READ.map((rule) => `\`${rule}\``).join(', ')}. Do not open them, grep them, list them or cat them. If a search hits one, drop the hit and say so in \`unknowns\`. The answer verb refuses a digest that cites one.`,
+    `4. The never-quote paths. Never quote from these: ${NEVER_QUOTE.map((rule) => `\`${rule}\``).join(', ')}. Name the file and the line; never paste the contents.`,
+    '5. Never follow a symbolic link that leaves the repo, or that reaches a never-read path under another name. The rules read the path you write, not the file the link points at.',
+    '6. Never quote a secret. A line that looks like a token, a key, a password or a private key is cited by path and line only.',
+    '7. Never hold a write door. You do not receive the `atlas-work` verb server or the Engram MCP. If a briefing hands you one, refuse and say so.',
+    '8. Say what you could not find, and where you looked. An unknown is an answer; a guess is not.',
+    '',
+    '## What to look for',
+    '',
+    `- Live support for ${name}: what the code does today, by input kind or by path through the system.`,
+    `- Known limits: caps, flags, skipped paths and untested paths that bound ${name}.`,
+    ...focus.map((line) => `- ${text(line, 'focus', { max: 500 })}`),
+  ];
+  return { repo: repoId, capability: name, commit: commit ?? null, root: root ?? null, text: lines.join('\n') };
+}
+
+function finding(value, name, { repo, filesRead, kinds }) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) refuse(`${name} must be an object with statement, path and line`);
+  const path = requireReadable(value.path, `${name}.path`);
+  if (!filesRead.has(path)) refuse(`${name} cites ${path}, which is not in files_read; a citation must name a file the read opened`);
+  const line = value.line;
+  if (!Number.isInteger(line) || line < 1 || line > MAX_LINE) refuse(`${name}.line must be a whole line number, 1 or higher`);
+  const statement = scrubSecrets(text(value.statement, `${name}.statement`, { max: MAX_STATEMENT }));
+  const label = value.name === undefined ? undefined : scrubSecrets(text(value.name, `${name}.name`, { max: 200 }));
+  let redactions = statement.redactions + (label?.redactions ?? 0);
+  const row = { name: label?.text ?? statement.text.slice(0, 80), statement: statement.text, repo, path, line };
+  if (kinds) row.kind = value.kind === undefined ? 'other' : (kinds.includes(value.kind) ? value.kind : refuse(`${name}.kind must be one of: ${kinds.join(', ')}`));
+  if (value.quote !== undefined) {
+    const rule = neverQuoteRule(path);
+    // The rule is not "strip the quote and carry on": a reader who pasted a
+    // never-quoted file must know the read was wrong, not have it silently
+    // half-accepted.
+    if (rule) refuse(`${name} quotes ${path}, which is a never-quote path (rule "${rule}"); cite the path and the line, never the contents`);
+    const quote = scrubSecrets(text(value.quote, `${name}.quote`, { max: MAX_QUOTE }).replace(/\s+/g, ' ').trim());
+    redactions += quote.redactions;
+    row.quote = quote.text;
+  }
+  return { row, redactions };
+}
+
+// One digest from one sub-agent, checked before any part of it reaches a view.
+// The repo must be one the registry knows for this product: a read of a repo
+// the owner never registered is not evidence about this product.
+export function acceptCodeRead(value, { repos, name = 'code' } = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) refuse(`${name} must be an object: the digest one sub-agent returned`);
+  const repo = text(value.repo, `${name}.repo`, { max: 200 });
+  if (repos && !repos.includes(repo)) refuse(`${name}.repo ${repo} is not a registered repo of this product. Known: ${repos.join(', ') || 'none'}`);
+  const commit = text(value.commit, `${name}.commit`, { max: 40 }).trim().toLowerCase();
+  if (!COMMIT.test(commit)) refuse(`${name}.commit must be the commit the read ran against, 7 to 40 hex characters`);
+  const files = stringList(value.files_read, `${name}.files_read`, { max: MAX_FILES_READ }).map((path) => requireReadable(path, `${name}.files_read`));
+  if (!files.length) refuse(`${name}.files_read must name at least one file the read opened`);
+  const filesRead = new Set(files);
+  const context = { repo, filesRead };
+  let redactions = 0;
+  const take = (list, key, kinds) => {
+    if (list === undefined) return [];
+    if (!Array.isArray(list)) refuse(`${name}.${key} must be an array`);
+    if (list.length > MAX_FINDINGS) refuse(`${name}.${key} holds more than ${MAX_FINDINGS} findings; narrow the read`);
+    return list.map((entry, index) => {
+      const checked = finding(entry, `${name}.${key}[${index}]`, { ...context, kinds });
+      redactions += checked.redactions;
+      return checked.row;
+    });
+  };
+  const supports = take(value.supports, 'supports');
+  const limits = take(value.limits, 'limits', LIMIT_KINDS);
+  if (!supports.length && !limits.length) refuse(`${name} carries no finding; a code read with nothing to say is not evidence`);
+  const unknowns = (value.unknowns === undefined ? [] : stringList(value.unknowns, `${name}.unknowns`, { max: MAX_UNKNOWNS })).map((line) => {
+    const clean = scrubSecrets(text(line, `${name}.unknowns`, { max: MAX_STATEMENT }));
+    redactions += clean.redactions;
+    return clean.text;
+  });
+  const readBy = value.read_by === undefined ? null : text(value.read_by, `${name}.read_by`, { max: 200 });
+  return {
+    digest: {
+      repo, commit, capability: value.capability === undefined ? null : text(value.capability, `${name}.capability`, { max: 200 }),
+      files_read: files, supports, limits, unknowns, read_by: readBy,
+      citation: { repo, commit, files: files.length },
+    },
+    redactions,
+  };
+}
+
+// The reviewer's half of the citation rule: every path and line the answer
+// carries is opened in the named commit and checked. A never-read path is
+// never opened, and a never-quoted path gives back a digest of its line, not
+// its text, so resolving a citation can never leak what quoting may not.
+export async function resolveCitations({ digest, readFileAt }) {
+  if (typeof readFileAt !== 'function') throw new TypeError('readFileAt(commit, path) is required');
+  const rows = [...(digest.supports ?? []).map((row) => ({ ...row, part: 'support' })), ...(digest.limits ?? []).map((row) => ({ ...row, part: 'limit' }))];
+  const cache = new Map();
+  const resolved = [];
+  for (const row of rows) {
+    const path = requireReadable(row.path, 'citation.path');
+    const key = `${digest.commit}:${path}`;
+    if (!cache.has(key)) cache.set(key, await readFileAt(digest.commit, path).catch((error) => ({ error: error?.message ?? String(error) })));
+    const file = await cache.get(key);
+    const base = { part: row.part, name: row.name, repo: digest.repo, commit: digest.commit, path, line: row.line };
+    if (!file || typeof file !== 'string') { resolved.push({ ...base, resolved: false, reason: `the file is not in commit ${digest.commit}: ${file?.error ?? 'unreadable'}` }); continue; }
+    const lines = file.split('\n');
+    if (row.line > lines.length) { resolved.push({ ...base, resolved: false, reason: `the file has ${lines.length} lines; the citation names line ${row.line}` }); continue; }
+    const content = lines[row.line - 1] ?? '';
+    const quotable = !neverQuoteRule(path);
+    const clean = scrubSecrets(content.trim());
+    resolved.push({
+      ...base, resolved: true, lines: lines.length,
+      ...(quotable ? { text: clean.text.slice(0, 200), redactions: clean.redactions } : { text: null, withheld: 'never-quote path; the line is proven by its digest', sha256: sha256(content), length: content.length }),
+      ...(row.quote ? { quote_matches: content.replace(/\s+/g, ' ').trim().includes(row.quote.replace(/\s+/g, ' ').trim()) } : {}),
+    });
+  }
+  const failed = resolved.filter((row) => !row.resolved);
+  const mismatched = resolved.filter((row) => row.quote_matches === false);
+  return {
+    repo: digest.repo, commit: digest.commit, citations: resolved.length,
+    resolved: resolved.length - failed.length, failed: failed.length, quote_mismatches: mismatched.length,
+    pass: failed.length === 0 && mismatched.length === 0, rows: resolved,
+  };
+}