Function computeAllocation

scripts/agent-eval/parse-run.mjs:565–651

(exploreTexts, answerText)

 * the common shape where call 1 is on target and call 3 is pure noise.
 */
export function computeAllocation(exploreTexts, answerText) {
  const calls = exploreTexts.map(parseExploreCall).filter((c) => c.files.length);
  const extensions = new Set();
  for (const c of calls) {
    for (const f of c.files) {
      const dot = f.path.lastIndexOf('.');
      if (dot > 0) extensions.add(f.path.slice(dot + 1).toLowerCase());
    }
  }
  const cited = answerCitations(answerText, extensions);

  // symbol -> the returned files whose header lists it as DEFINED. A `variable`
  // is usually an import binding (`var compileETag = require('./utils')…`), so
  // when the same name is also a real definition somewhere in the envelope, the
  // definition wins and the aliasing file is not credited.
  const symbolFiles = new Map();
  for (const c of calls) {
    for (const f of c.files) {
      for (const s of f.symbols) {
        if (!symbolFiles.has(s.name)) symbolFiles.set(s.name, { strong: new Set(), weak: new Set() });
        const owners = symbolFiles.get(s.name);
        (s.kind === 'variable' || s.kind === 'constant' ? owners.weak : owners.strong).add(f.path);
      }
    }
  }
  const ownersOf = (name) => {
    const o = symbolFiles.get(name);
    return o ? (o.strong.size ? o.strong : o.weak) : null;
  };

  // `lib/response.js` is cited by `lib/response.js`, by `response.js`, and by an
  // absolute path ending in it — samePath already encodes exactly that.
  const viaPath = (path) => cited.paths.some((p) => samePath(path, p));
  const viaSymbol = (path) => {
    for (const s of cited.symbols) {
      const owners = ownersOf(s);
      if (owners && owners.size < SYMBOL_AMBIGUITY_LIMIT && owners.has(path)) return s;
    }
    return null;
  };

  const verdict = new Map();  // path -> { via, symbol }
  const judge = (path) => {
    if (!verdict.has(path)) {
      if (viaPath(path)) verdict.set(path, { via: 'path' });
      else {
        const s = viaSymbol(path);
        verdict.set(path, s ? { via: 'symbol', symbol: s } : { via: null });
      }
    }
    return verdict.get(path);
  };

  const perCall = calls.map((c, i) => {
    const files = c.files.map((f) => ({ ...f, ...judge(f.path) }));
    const used = files.filter((f) => f.via).reduce((s, f) => s + f.chars, 0);
    const usedPath = files.filter((f) => f.via === 'path').reduce((s, f) => s + f.chars, 0);
    return {