My Nightly Subagents Ran, and I Couldn't Retrace Them — Trimming the Logs That --forward-subagent-text Unleashed

// filter-subagent-log.mjs
// Usage: claude -p "..." --output-format stream-json --forward-subagent-text \
//          | node filter-subagent-log.mjs --run-id 2026-07-17-nightly
import { createInterface } from 'node:readline';
import { createWriteStream, mkdirSync, rmSync } from 'node:fs';
 
const runId = process.argv[process.argv.indexOf('--run-id') + 1] ?? String(Date.now());
const dir = `./logs/${runId}`;
mkdirSync(dir, { recursive: true });
 
const out = {
  skeleton: createWriteStream(`${dir}/skeleton.jsonl`),
  body: createWriteStream(`${dir}/body.jsonl`),
  thinking: createWriteStream(`${dir}/thinking.jsonl`),
};
 
const HEAD = 400;   // characters kept from the start of body text
const TAIL = 200;   // characters kept from the end
 
// Drop the middle, but say how much was dropped
function clip(text) {
  if (typeof text !== 'string' || text.length <= HEAD + TAIL) return text;
  const dropped = text.length - HEAD - TAIL;
  return `${text.slice(0, HEAD)}\n…[${dropped} chars clipped]…\n${text.slice(-TAIL)}`;
}
 
// Skeleton types are never trimmed
const SKELETON_TYPES = new Set([
  'system', 'result', 'tool_use', 'tool_result', 'subagent_start', 'subagent_stop',
]);
 
let failed = false;
const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
 
for await (const line of rl) {
  if (!line.trim()) continue;
  let ev;
  try {
    ev = JSON.parse(line);
  } catch {
    // A broken line is exactly what you want later — send it to the skeleton raw
    out.skeleton.write(JSON.stringify({ type: 'parse_error', raw: line.slice(0, 500) }) + '\n');
    continue;
  }
 
  if (ev.type === 'result' && ev.subtype !== 'success') failed = true;
  if (ev.is_error === true) failed = true;
 
  if (SKELETON_TYPES.has(ev.type)) {
    out.skeleton.write(JSON.stringify(ev) + '\n');
    continue;
  }
 
  const blocks = ev.message?.content ?? [];
  for (const b of blocks) {
    const base = {
      ts: ev.timestamp ?? new Date().toISOString(),
      session_id: ev.session_id,
      parent_tool_use_id: ev.parent_tool_use_id ?? null,
    };
    if (b.type === 'thinking') {
      out.thinking.write(JSON.stringify({ ...base, thinking: b.thinking }) + '\n');
    } else if (b.type === 'text') {
      out.body.write(JSON.stringify({ ...base, text: clip(b.text) }) + '\n');
    }
  }
}
 
// Decide the fate of thinking once the exit status is known
for (const s of Object.values(out)) s.end();
if (!failed) {
  rmSync(`${dir}/thinking.jsonl`, { force: true });
  console.error(`[log] ${runId}: success — thinking discarded`);
} else {
  console.error(`[log] ${runId}: failed — thinking retained`);
}

# List the parent's Task calls from the skeleton
jq -r 'select(.type=="tool_use" and .name=="Task")
       | [.id, (.input.description // "-")] | @tsv' logs/$RUN/skeleton.jsonl
 
# Follow one subagent's body text in order
jq -r --arg id "$TOOL_USE_ID" \
   'select(.parent_tool_use_id==$id) | "\(.ts) \(.text)"' logs/$RUN/body.jsonl

// Attach orphaned lines to the most recent parent Task call
function attachFallbackParent(events) {
  let lastTaskId = null;
  return events.map((ev) => {
    if (ev.type === 'tool_use' && ev.name === 'Task') lastTaskId = ev.id;
    if (ev.parent_tool_use_id == null && lastTaskId) {
      return { ...ev, parent_tool_use_id: lastTaskId, parent_inferred: true };
    }
    return ev;
  });
}

# First pass: skeleton only. On failure, retry with thinking to reproduce
claude -p "$PROMPT" --output-format stream-json > run1.jsonl || \
claude -p "$PROMPT" --output-format stream-json --forward-subagent-text > run2.jsonl