Function classifySufficiency

scripts/agent-eval/parse-run.mjs:853–922

(events)

 * `message.id`, and tool results as `tool_result` blocks in user messages.
 */
export function classifySufficiency(events) {
  // One action list PER THREAD: 'main', plus one per subagent (keyed by the
  // delegating tool_use id, which is what `parent_tool_use_id` carries).
  const threads = new Map();
  const nameById = new Map();
  const textById = new Map();    // explore tool_use_id -> response text
  for (const ev of events) {
    const content = ev?.message?.content;
    if (!Array.isArray(content)) continue;
    const thread = ev.parent_tool_use_id ?? 'main';
    if (ev.type === 'assistant') {
      if (!threads.has(thread)) threads.set(thread, []);
      const list = threads.get(thread);
      for (const b of content) {
        if (b.type !== 'tool_use') continue;
        nameById.set(b.id, b.name);
        // No message.id (never seen on a real log) degrades to "every call is
        // its own message", i.e. same-message calls read as reactions.
        list.push({ msgId: ev.message.id || `#${thread}-${list.length}`, id: b.id, name: b.name, input: b.input || {} });
      }
    } else if (ev.type === 'user') {
      for (const b of content) {
        if (b.type !== 'tool_result') continue;
        const name = nameById.get(b.tool_use_id) || '';
        if (/codegraph_explore/.test(name) && !b.is_error) textById.set(b.tool_use_id, textOf(b.content));
      }
    }
  }

  const calls = [];
  let errors = 0, concurrent = 0;
  // What a delegation really did: the subagent's first substantive call. A
  // nested delegation is skipped rather than followed, so a subagent that only
  // spawns another subagent leaves the call as "moved on".
  const throughDelegation = (action, returned, mentioned, earlier) => {
    const first = (threads.get(action.id) || []).find((x) => !TRANSPARENT_TOOLS.has(x.name) && !DELEGATION_TOOLS.has(x.name));
    if (!first) return { bucket: 'sufficient', next: action.name };
    const r = reactionOf(first, returned, mentioned, earlier);
    return { ...r, next: `${action.name} → ${r.next}` };
  };
  for (const [thread, actions] of threads) {
    const earlier = [];  // files previous explores in THIS thread already shipped
    for (let i = 0; i < actions.length; i++) {
      const a = actions[i];
      if (!/codegraph_explore/.test(a.name)) continue;
      const text = textById.get(a.id);
      // No response text = the call errored, or the run ended before it
      // returned. Nothing to judge the sufficiency of; count it and move on.
      if (text === undefined) { errors++; continue; }
      const returned = exploreReturnedFiles(text);
      const mentioned = text.match(PATH_TOKEN_RE) || [];
      let reaction = { bucket: 'sufficient', next: '(final answer)' };
      for (let j = i + 1; j < actions.length; j++) {
        const b = actions[j];
        if (b.msgId === a.msgId) { if (isFileAccess(b)) concurrent++; continue; }
        if (TRANSPARENT_TOOLS.has(b.name)) continue;
        reaction = DELEGATION_TOOLS.has(b.name)
          ? throughDelegation(b, returned, mentioned, earlier)