kenaz 0.0.0-stage → 0.3.2

package/core/.formation/tools/post-complete/subagent-transcript-stats.test.js

@@ -0,0 +1,680 @@
+'use strict';
+/**
+ * subagent-transcript-stats.test.js — TASK_2078
+ *
+ * Fixtures are shaped like the real files (verified live 2026-09-27, session
+ * 75239ce3): meta.json { description: '[TASK_9001] Formation unit/do
+ * sub-agent', ... }, jsonl lines with timestamp/promptId/message.content.
+ * Every fixture lives under a throwaway mkdtemp config dir — never touches
+ * the real ~/.claude directory.
+ *
+ * Run: node --test .formation/tools/post-complete/subagent-transcript-stats.test.js
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  deriveSubagentStats,
+  _descriptionCarriesTaskTag,
+  classifyCoordinatorMessage,
+} = require('./subagent-transcript-stats');
+
+const tmpRoots = [];
+test.after(() => {
+  for (const t of tmpRoots) {
+    try { fs.rmSync(t, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }); }
+    catch { /* Windows lock — tmpdir leak acceptable in fixture */ }
+  }
+});
+
+function makeTmpConfigDir() {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'sats2078-')));
+  tmpRoots.push(dir);
+  return dir;
+}
+
+function slugFor(projectRoot) {
+  return String(projectRoot).replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+/**
+ * Writes one fixture subagent transcript (meta.json + jsonl) under
+ * <configDir>/projects/<slugDirName>/<sessionId>/subagents/.
+ * `slugDirName` defaults to the real slug of projectRoot; tests pass a
+ * different case to exercise case-insensitive matching.
+ */
+function writeFixture(configDir, { projectRoot, slugDirName, sessionId, agentId, description, lines }) {
+  const dirName = slugDirName || slugFor(projectRoot);
+  const subagentsDir = path.join(configDir, 'projects', dirName, sessionId, 'subagents');
+  fs.mkdirSync(subagentsDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(subagentsDir, `agent-${agentId}.meta.json`),
+    JSON.stringify({ description, agentType: 'general-purpose', model: 'sonnet' }),
+    'utf8'
+  );
+  const body = lines.map((l) => (typeof l === 'string' ? l : JSON.stringify(l))).join('\n') + '\n';
+  fs.writeFileSync(path.join(subagentsDir, `agent-${agentId}.jsonl`), body, 'utf8');
+  return subagentsDir;
+}
+
+function userLine(ts, promptId, text) {
+  return { type: 'user', timestamp: ts, promptId, message: { role: 'user', content: text || 'hi' } };
+}
+function toolUseLine(ts, name) {
+  return {
+    type: 'assistant',
+    timestamp: ts,
+    message: { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_x', name, input: {} }] },
+  };
+}
+
+// ── TASK_2097 fixtures ──────────────────────────────────────────────────
+// These three shapes are anonymised excerpts of the exact real shapes that
+// broke the two naive counting rules Ansuz tried first (see real transcripts
+// under <configDir>/projects/.../subagents/, TASK_2078 and TASK_2081):
+//
+// 1) toolResultLine: a `type:"user"` tool_result line carrying a NEW
+//    promptId (real shape: agent-a467182ba8933f825.jsonl line 101 — a
+//    Bash tool_result on its own promptId, no coordinator involved at all).
+//    Breaks ">= 2 promptId groups" as a corrections signal.
+// 2) systemReminderLine: a `type:"user"`, isMeta text line whose content IS
+//    a <system-reminder> block (real shape: agent-a96a7da588c0755db.jsonl
+//    line 4, the harness's own SubagentHandback reminder). Breaks
+//    "text-bearing user lines" as a corrections signal.
+// 3) coordinatorAttachmentLine: a `type:"attachment"` line (a queued_command
+//    delivered mid-run, origin.kind:"coordinator") whose `rendered[0].content`
+//    carries the "The coordinator sent a message while you were working:"
+//    marker (real shape: agent-afc51fb05fdf617f2.jsonl line 518, TASK_2088 R2b).
+//    This is a genuine correction, but arrives as a non-"user" line — the
+//    naive rules above both missed it too.
+function toolResultLine(ts, promptId, output) {
+  return {
+    parentUuid: 'p', isSidechain: true, promptId, agentId: 'test',
+    type: 'user',
+    timestamp: ts,
+    message: { role: 'user', content: [{ tool_use_id: 'toolu_tr', type: 'tool_result', content: output || 'ok' }] },
+  };
+}
+function systemReminderLine(ts, promptId, text) {
+  return {
+    parentUuid: 'p', isSidechain: true, promptId, agentId: 'test',
+    type: 'user',
+    isMeta: true,
+    timestamp: ts,
+    message: { role: 'user', content: `<system-reminder>\n${text}\n</system-reminder>` },
+  };
+}
+function coordinatorAttachmentLine(ts, messageText) {
+  return {
+    parentUuid: 'p', isSidechain: true, agentId: 'test',
+    attachment: { type: 'queued_command', prompt: messageText, origin: { kind: 'coordinator' }, isMeta: true },
+    type: 'attachment',
+    timestamp: ts,
+    rendered: [{
+      content: `<system-reminder>\nThe coordinator sent a message while you were working:\n${messageText}\n\nAddress this before completing your current task.\n</system-reminder>`,
+    }],
+  };
+}
+function coordinatorUserLine(ts, promptId, messageText) {
+  return {
+    parentUuid: 'p', isSidechain: true, promptId, agentId: 'test',
+    type: 'user',
+    isMeta: true,
+    timestamp: ts,
+    message: {
+      role: 'user',
+      content: `The coordinator sent a message while you were working:\n${messageText}\n\nAddress this before completing your current task.`,
+    },
+  };
+}
+
+test('_descriptionCarriesTaskTag: exact match', () => {
+  assert.equal(_descriptionCarriesTaskTag('[TASK_9001] Formation unit/do sub-agent', 'TASK_9001'), true);
+});
+
+test('_descriptionCarriesTaskTag: digit-boundary rejects shorter-id prefix match (TASK_900 vs [TASK_9001])', () => {
+  assert.equal(_descriptionCarriesTaskTag('[TASK_9001] Formation unit/do sub-agent', 'TASK_900'), false);
+});
+
+test('_descriptionCarriesTaskTag: negative control ([TASK_9002] does not match TASK_9001)', () => {
+  assert.equal(_descriptionCarriesTaskTag('[TASK_9002] Formation unit/do sub-agent', 'TASK_9001'), false);
+});
+
+test('single spawn: metrics exact', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-single';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'aaa111',
+    description: '[TASK_9001] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:02.000Z', 'Edit'),
+      toolUseLine('2026-01-01T00:00:05.000Z', 'Bash'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9001', projectRoot, { configDir });
+  assert.ok(result, 'expected a non-null result');
+  assert.equal(result.source, 'transcript');
+  assert.equal(result.spawns, 1);
+  assert.equal(result.duration_ms, 5000); // 00:00:05 - 00:00:00
+  assert.equal(result.tool_uses, 2); // Edit + Bash
+  assert.equal(result.first_edit_s, 2); // Edit at +2s from first line
+});
+
+test('two promptId groups with a 3h gap: idle gap excluded from duration_ms', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-gap';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'bbb222',
+    description: '[TASK_9010] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:10.000Z', 'Bash'), // p1 group: 10s span
+      // SendMessage follow-up 3 hours later -> new promptId, new group
+      userLine('2026-01-01T03:00:00.000Z', 'p2'),
+      toolUseLine('2026-01-01T03:00:20.000Z', 'Edit'), // p2 group: 20s span
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9010', projectRoot, { configDir });
+  assert.ok(result);
+  // 10s (p1) + 20s (p2) = 30s -- NOT ~3h05m if the idle gap were counted.
+  assert.equal(result.duration_ms, 30000);
+  assert.equal(result.tool_uses, 2);
+  // first_edit_s is wall-clock from the very first line, unaffected by the
+  // duration_ms idle-gap exclusion (the Edit is the p2 tool_use, at +3h20s).
+  assert.equal(result.first_edit_s, 3 * 3600 + 20);
+});
+
+test('two spawns for the same task are summed; first_edit_s comes from the earliest spawn', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-multi';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'ccc333',
+    description: '[TASK_9020] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:03.000Z', 'Write'), // first_edit_s = 3
+      toolUseLine('2026-01-01T00:00:08.000Z', 'Bash'),
+    ],
+  });
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-b', // re-dispatch / follow-up agent, later session
+    agentId: 'ddd444',
+    description: '[TASK_9020] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-02T00:00:00.000Z', 'p2'),
+      toolUseLine('2026-01-02T00:00:04.000Z', 'MultiEdit'), // later spawn's own edit -- ignored for first_edit_s
+      toolUseLine('2026-01-02T00:00:06.000Z', 'Bash'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9020', projectRoot, { configDir });
+  assert.ok(result);
+  assert.equal(result.spawns, 2);
+  assert.equal(result.duration_ms, 8000 + 6000); // 8s (spawn 1) + 6s (spawn 2)
+  assert.equal(result.tool_uses, 4); // 2 + 2
+  assert.equal(result.first_edit_s, 3); // from the earlier spawn (sess-a), not the later one
+});
+
+test('malformed jsonl line is skipped, not fatal', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-malformed';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'eee555',
+    description: '[TASK_9030] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      'not valid json {{{',
+      toolUseLine('2026-01-01T00:00:04.000Z', 'Edit'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9030', projectRoot, { configDir });
+  assert.ok(result, 'malformed line must not make the whole derivation fail');
+  assert.equal(result.duration_ms, 4000);
+  assert.equal(result.tool_uses, 1);
+  assert.equal(result.first_edit_s, 4);
+});
+
+// ── TASK_2097: corrections counting rule ────────────────────────────────
+test('corrections: 0 for a transcript with only the two false-positive shapes (new-promptId tool_result + system-reminder text line)', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-corr-zero';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'corr001',
+    description: '[TASK_9080] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1', 'do the task'),
+      toolResultLine('2026-01-01T00:00:02.000Z', 'p2', 'file contents here'), // new promptId, no coordinator
+      systemReminderLine('2026-01-01T00:00:03.000Z', 'p2', 'Your final report is delivered through SubagentHandback: when your work is complete, call SubagentHandback(...).'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9080', projectRoot, { configDir });
+  assert.ok(result);
+  assert.equal(result.corrections, 0);
+  assert.deepEqual(result.correction_heads, []);
+});
+
+test('corrections: 1 for one coordinator message delivered as a mid-run attachment line', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-corr-one';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'corr002',
+    description: '[TASK_9081] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1', 'do the task'),
+      toolUseLine('2026-01-01T00:00:01.000Z', 'Bash'),
+      coordinatorAttachmentLine('2026-01-01T00:00:05.000Z', 'Ansuz: fix the off-by-one in foo.js before landing.'),
+      toolUseLine('2026-01-01T00:00:06.000Z', 'Edit'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9081', projectRoot, { configDir });
+  assert.ok(result);
+  assert.equal(result.corrections, 1);
+  assert.equal(result.correction_heads.length, 1);
+  assert.ok(result.correction_heads[0].startsWith('Ansuz: fix the off-by-one in foo.js'));
+});
+
+test('corrections: same message seen twice (attachment render + later formal user turn) dedupes to 1', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-corr-dedup';
+  // Message body is deliberately longer than CORRECTION_HEAD_LEN (120 chars,
+  // like every real correction message seen in practice) so the head is cut
+  // from the message body itself, before either wrapper's own trailing
+  // template text (`</system-reminder>` vs the bare string end) diverges.
+  const message = 'Ansuz: same defect, please fix it now — this exact message is delivered twice on purpose to exercise the dedup path, once as a mid-run attachment and once as a formal user turn.';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'corr003',
+    description: '[TASK_9082] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1', 'do the task'),
+      coordinatorAttachmentLine('2026-01-01T00:00:02.000Z', message),
+      coordinatorUserLine('2026-01-01T00:00:02.500Z', 'p2', message),
+      toolUseLine('2026-01-01T00:00:04.000Z', 'Edit'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9082', projectRoot, { configDir });
+  assert.ok(result);
+  assert.equal(result.corrections, 1, 'identical message delivered twice must dedupe to one correction');
+  assert.equal(result.correction_heads.length, 1);
+});
+
+test('missing config/session dir -> null (no throw)', () => {
+  const configDir = makeTmpConfigDir(); // empty -- no projects/ dir at all
+  const result = deriveSubagentStats('TASK_9040', 'C:\\Users\\test\\proj-missing', { configDir });
+  assert.equal(result, null);
+});
+
+test('case-insensitive project slug directory match', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-CaseTest';
+  const realSlug = slugFor(projectRoot);
+  writeFixture(configDir, {
+    projectRoot,
+    slugDirName: realSlug.toLowerCase(), // on-disk dir uses a different case
+    sessionId: 'sess-a',
+    agentId: 'fff666',
+    description: '[TASK_9050] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:01.000Z', 'Bash'),
+    ],
+  });
+  assert.notEqual(realSlug, realSlug.toLowerCase(), 'sanity: slug must actually contain uppercase to test case-insensitivity');
+
+  const result = deriveSubagentStats('TASK_9050', projectRoot, { configDir });
+  assert.ok(result, 'expected case-insensitive slug dir match to still resolve');
+  assert.equal(result.spawns, 1);
+});
+
+test('TASK_900 does not match a [TASK_9001] description (digit-boundary, end to end)', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-boundary';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'ggg777',
+    description: '[TASK_9001] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:01.000Z', 'Bash'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_900', projectRoot, { configDir });
+  assert.equal(result, null);
+});
+
+test('negative control: querying TASK_9001 against a transcript tagged [TASK_9002] yields null', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-negctrl';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'hhh888',
+    description: '[TASK_9002] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:01.000Z', 'Bash'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9001', projectRoot, { configDir });
+  assert.equal(result, null);
+});
+
+test('session dir older than maxAgeDays is skipped', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-aged';
+  const subagentsDir = writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-old',
+    agentId: 'iii999',
+    description: '[TASK_9060] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:01.000Z', 'Bash'),
+    ],
+  });
+  const sessionDir = path.dirname(subagentsDir);
+  const oldTime = new Date('2020-01-01T00:00:00.000Z');
+  fs.utimesSync(sessionDir, oldTime, oldTime);
+
+  const now = Date.parse('2026-06-01T00:00:00.000Z');
+  const result = deriveSubagentStats('TASK_9060', projectRoot, { configDir, now, maxAgeDays: 30 });
+  assert.equal(result, null, 'session dir last modified in 2020 must be excluded under a 30-day window in mid-2026');
+});
+
+// ── R3: post-complete.js appendPhase9OutcomeLog precedence (A3) ────────────
+// Requiring post-complete.js wires initGitMerge(deps) as a load-time side
+// effect (same pattern task2029.test.js already relies on); harmless here
+// since these tests only call appendPhase9OutcomeLog, never any git path.
+const { appendPhase9OutcomeLog } = require('../post-complete');
+
+function withConfigDir(configDir, fn) {
+  const prev = process.env.CLAUDE_CONFIG_DIR;
+  process.env.CLAUDE_CONFIG_DIR = configDir;
+  try { return fn(); }
+  finally {
+    if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+    else process.env.CLAUDE_CONFIG_DIR = prev;
+  }
+}
+
+function lastOutcomeRecord(projectRoot) {
+  const file = path.join(projectRoot, '.kenaz', 'specialist', 'phase9_dispatch_outcomes.jsonl');
+  const lines = fs.readFileSync(file, 'utf8').trim().split('\n');
+  return JSON.parse(lines[lines.length - 1]);
+}
+
+test('appendPhase9OutcomeLog: agent_result wins field-by-field, transcript fills only what agent_result lacks -> mixed', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'sats2078-proj-')));
+  tmpRoots.push(projectRoot);
+  const specialistDir = path.join(projectRoot, '.kenaz', 'specialist');
+  fs.mkdirSync(specialistDir, { recursive: true });
+  // agent_result carries turns + duration_ms only -- tool_uses/first_edit_s must come from the transcript.
+  fs.writeFileSync(
+    path.join(specialistDir, 'agent_result_TASK_9070.json'),
+    JSON.stringify({ turns: 7, duration_ms: 111 }),
+    'utf8'
+  );
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'mix001',
+    description: '[TASK_9070] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:05.000Z', 'Edit'),
+      toolUseLine('2026-01-01T00:00:09.000Z', 'Bash'),
+    ],
+  });
+
+  withConfigDir(configDir, () => appendPhase9OutcomeLog('TASK_9070', true, projectRoot));
+
+  const record = lastOutcomeRecord(projectRoot);
+  assert.equal(record.turns, 7, 'agent_result-only field preserved');
+  assert.equal(record.duration_ms, 111, 'agent_result wins over the transcript-derived 9000');
+  assert.equal(record.tool_uses, 2, 'filled in from the transcript');
+  assert.equal(record.first_edit_s, 5, 'filled in from the transcript');
+  assert.equal(record.timing_source, 'mixed');
+  assert.equal(record.spawns, 1);
+});
+
+test('appendPhase9OutcomeLog: agent_result carries every field -> agent_result, no transcript read needed', () => {
+  const configDir = makeTmpConfigDir(); // no fixture written -- transcript lookup would return null anyway
+  const projectRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'sats2078-proj-')));
+  tmpRoots.push(projectRoot);
+  const specialistDir = path.join(projectRoot, '.kenaz', 'specialist');
+  fs.mkdirSync(specialistDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(specialistDir, 'agent_result_TASK_9071.json'),
+    JSON.stringify({ turns: 3, duration_ms: 222, tool_uses: 9, first_edit_s: 1.5 }),
+    'utf8'
+  );
+
+  withConfigDir(configDir, () => appendPhase9OutcomeLog('TASK_9071', true, projectRoot));
+
+  const record = lastOutcomeRecord(projectRoot);
+  assert.equal(record.duration_ms, 222);
+  assert.equal(record.tool_uses, 9);
+  assert.equal(record.first_edit_s, 1.5);
+  assert.equal(record.timing_source, 'agent_result');
+  assert.equal(record.spawns, undefined, 'spawns is transcript-only metadata');
+});
+
+test('appendPhase9OutcomeLog: no agent_result file -> pure transcript fallback', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'sats2078-proj-')));
+  tmpRoots.push(projectRoot);
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'trs001',
+    description: '[TASK_9072] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      toolUseLine('2026-01-01T00:00:06.000Z', 'Write'),
+    ],
+  });
+
+  withConfigDir(configDir, () => appendPhase9OutcomeLog('TASK_9072', true, projectRoot));
+
+  const record = lastOutcomeRecord(projectRoot);
+  assert.equal(record.duration_ms, 6000);
+  assert.equal(record.tool_uses, 1);
+  assert.equal(record.first_edit_s, 6);
+  assert.equal(record.timing_source, 'transcript');
+  assert.equal(record.spawns, 1);
+});
+
+// ── TASK_2097: corrections/correction_heads have no agent_result counterpart,
+// so they must be recorded from the transcript even when agent_result already
+// covers every timing field (the `stillMissing` gate must not skip them).
+test('appendPhase9OutcomeLog: corrections recorded from transcript even when agent_result covers every timing field', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'sats2078-proj-')));
+  tmpRoots.push(projectRoot);
+  const specialistDir = path.join(projectRoot, '.kenaz', 'specialist');
+  fs.mkdirSync(specialistDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(specialistDir, 'agent_result_TASK_9083.json'),
+    JSON.stringify({ turns: 3, duration_ms: 222, tool_uses: 9, first_edit_s: 1.5 }),
+    'utf8'
+  );
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'corr004',
+    description: '[TASK_9083] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1'),
+      coordinatorAttachmentLine('2026-01-01T00:00:02.000Z', 'Ansuz: one blocking defect before landing, described at length here so the head is stable and comfortably past 120 chars in the fixture.'),
+    ],
+  });
+
+  withConfigDir(configDir, () => appendPhase9OutcomeLog('TASK_9083', true, projectRoot));
+
+  const record = lastOutcomeRecord(projectRoot);
+  // Timing fields come entirely from agent_result -- unaffected.
+  assert.equal(record.duration_ms, 222);
+  assert.equal(record.timing_source, 'agent_result');
+  // corrections/correction_heads still come from the transcript.
+  assert.equal(record.corrections, 1);
+  assert.equal(record.correction_heads.length, 1);
+  assert.ok(record.correction_heads[0].startsWith('Ansuz: one blocking defect'));
+  assert.equal(record.spawns, 1, 'spawns is filled from the corrections-only transcript read too');
+});
+
+test('appendPhase9OutcomeLog: correction_heads truncated to 10 even when more corrections exist', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'sats2078-proj-')));
+  tmpRoots.push(projectRoot);
+  const lines = [userLine('2026-01-01T00:00:00.000Z', 'p1')];
+  for (let i = 0; i < 12; i++) {
+    lines.push(coordinatorAttachmentLine(
+      `2026-01-01T00:${String(i + 1).padStart(2, '0')}:00.000Z`,
+      `Ansuz: correction number ${i} — a distinct message padded well past 120 characters so its head never collides with any other correction number in this loop.`
+    ));
+  }
+
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'corr005',
+    description: '[TASK_9084] Formation unit/do sub-agent',
+    lines,
+  });
+
+  withConfigDir(configDir, () => appendPhase9OutcomeLog('TASK_9084', true, projectRoot));
+
+  const record = lastOutcomeRecord(projectRoot);
+  assert.equal(record.corrections, 12, 'the true count is preserved even though heads are capped');
+  assert.equal(record.correction_heads.length, 10, 'correction_heads is capped at 10');
+});
+
+// ── TASK_2109: correction vs information classification ────────────────────
+// R3 known-answer check. Each entry below is a lightly-trimmed excerpt of a
+// REAL coordinator message read (read-only) from
+// ~/.claude/projects/C--Users-user-Documents-GitHub-KenazAI/{804ea3d7-...,
+// eac5e162-...}/subagents/agent-*.jsonl on 2026-09-28, hand-labeled by
+// reading the full message and asking "does this send work back (defect /
+// unmet requirement / scope expansion) or is it FYI context the coordinator
+// says needs no rework?". 10 of 11 real messages found across those two
+// sessions were unambiguous corrections; TASK_2093 is the one real
+// informational example on record (an upstream research note the coordinator
+// explicitly says needs no reply) — trimmed here to keep the "no reply
+// needed" phrase past char 120, matching its real position in the live
+// message, so this test also exercises full-body (not head-truncated)
+// scanning.
+const KNOWN_ANSWER_MESSAGES = [
+  { source: 'TASK_1909', expected: 'correction', text:
+    'Good work, and thank you for correcting the card\'s line attribution. I\'m merging this, but one thing needs to go in the same commit first. The TASK_1521 Hebbian co-recall block is still ungated. Please make it symmetric with what you already did: 1. Extract the Hebbian block into a helper. 2. Gate the in-recall_with_mode_impl call on the same log_usage signal. 3. Call it once from hybrid_recall_with_outcome. Address this before completing your current task.' },
+  { source: 'TASK_1913', expected: 'correction', text:
+    'Merged your commit and the compile gate passed. But the original symptom is unchanged, and your own new instrumentation is what proved it. rune_candidates is 0 at limit=5. UNEXPLAINED — this is the question. Find it before designing anything. Measure, do not reason from the code alone. Then fix the real truncation point.' },
+  { source: 'TASK_2082', expected: 'correction', text:
+    'Ansuz review of TASK_2082 (eb7c3be5d): tests green (11/11, 51/51), but two defects before I can land it. Same worktree/branch, commit as a second commit, same hard rules.' },
+  { source: 'TASK_2088-R2b', expected: 'correction', text:
+    'Ansuz, new live evidence for TASK_2088 R2 (same file, same scope — please fold it in, as an extra requirement R2b): After I renamed the damaged graph away the first index round did NOT take the fallback path. R2b: the full-index fallback must key on schema presence, not file existence.' },
+  { source: 'TASK_2088-compile', expected: 'correction', text:
+    'Ansuz: I extracted the compile error you could not see (thanks for flagging the tooling gap — carding it separately). Fix without adding Debug to production types. Scan your other new tests for the same pattern and fix them the same way. Commit as a third commit on the same branch.' },
+  { source: 'TASK_2088-verify5', expected: 'correction', text:
+    'Ansuz verify of ansuz-wt-804ea3d7-17652: task_2088 filter 7/7 once, but full synapse:: failed 1 of 5 runs, on YOUR test. Apply the same save_reconcile_summary pre-seed to project A, commit as a 5th commit. Report the commit sha and which tests you changed.' },
+  { source: 'TASK_2088-30run', expected: 'correction', text:
+    'Ansuz 30-run full synapse:: loop on dde1dcf5e: 28/30. Your own 7 tests passed every run. Two failures in OTHER tests, signatures never seen in 68 runs on main. Task: find the actual mechanism for each from the logs + code, not by guess. Fix test isolation in the minimal way. Commit as a further commit.' },
+  { source: 'TASK_2092', expected: 'correction', text:
+    'Ansuz review of ansuz-wt-804ea3d7-6924: one blocking defect before landing. If rebuild_graph PANICS, nothing clears IS_INDEXING. Fix: make the early set a RAII guard whose Drop clears IS_INDEXING, created right before rebuild_graph.' },
+  { source: 'TASK_2093', expected: 'information', text:
+    'Ansuz, context for your OOM probe (R2): web research found the probable mechanism. LadybugDB PR #1019: Column::checkpointColumnChunkOutOfPlace calls setToInMemory on the PERSISTENT segment before resize/finalize/flush. Backport is carded as TASK_2096. Implications for you: (1) the failure you want is an allocation failure during an out-of-place checkpoint rewrite; (2) make the OOM probe runnable before AND after TASK_2096. No reply needed; continue your task.' },
+  { source: 'TASK_2099', expected: 'correction', text:
+    'Ansuz review of TASK_2099: the detector math is proven - good work. But as you flagged, in PRODUCTION the precursor would never see the two precursor events. I will not land an inert detector (same failure class as TASK_2086). Scope is expanded to finish the wiring (confirmed call sites on main): 1. index.rs:1929 ...' },
+  { source: 'TASK_2102', expected: 'correction', text:
+    'TASK_2102 round 2: your probes reproduced the production OOM on a HEALTHY graph — now sweep the checkpoint frequency. Correction first (my error, not yours): graph_backup_1790540662 was the graph quarantined in the SECOND damage incident. I reran your 4 probes myself. Results (recorded on the card): ...' },
+];
+
+test('classifyCoordinatorMessage: known-answer table (11 real coordinator messages, 2 live sessions) — 100% agreement', () => {
+  const disagreements = [];
+  for (const { source, expected, text } of KNOWN_ANSWER_MESSAGES) {
+    const got = classifyCoordinatorMessage(text);
+    if (got !== expected) disagreements.push({ source, expected, got });
+  }
+  assert.deepEqual(disagreements, [], `classifier disagreed with hand label on: ${JSON.stringify(disagreements)}`);
+});
+
+test('classifyCoordinatorMessage: TASK_2093 information signal sits past CORRECTION_HEAD_LEN (120 chars) — must classify from the full body, not the truncated head', () => {
+  const msg = KNOWN_ANSWER_MESSAGES.find((m) => m.source === 'TASK_2093');
+  assert.ok(msg.text.indexOf('No reply needed') > 120, 'sanity: the signal must actually be past char 120 in this fixture');
+  assert.equal(classifyCoordinatorMessage(msg.text), 'information');
+  // Negative control: classifying only the truncated head (what the old,
+  // head-only extraction path would have seen) loses the signal and falls
+  // back to the 'correction' default — proving the full-body scan matters.
+  const headOnly = msg.text.slice(0, 120);
+  assert.equal(classifyCoordinatorMessage(headOnly), 'correction', 'head-only text lacks the signal and must NOT be classified information');
+});
+
+test('negative control: a classifier forced to always return \'correction\' fails the known-answer table', () => {
+  const alwaysCorrection = () => 'correction';
+  const disagreements = KNOWN_ANSWER_MESSAGES.filter((m) => alwaysCorrection(m.text) !== m.expected);
+  assert.equal(disagreements.length, 1, 'forcing corrections should misclassify exactly the one real informational message (TASK_2093)');
+  // This assertion is itself the negative control: it demonstrates the
+  // known-answer table has discriminating power (a degenerate classifier
+  // does NOT pass it), unlike classifyCoordinatorMessage which agrees 11/11.
+  assert.notDeepEqual(
+    KNOWN_ANSWER_MESSAGES.map((m) => alwaysCorrection(m.text)),
+    KNOWN_ANSWER_MESSAGES.map((m) => classifyCoordinatorMessage(m.text)),
+    'a forced-correction classifier must disagree with the real classifier on this table'
+  );
+});
+
+test('deriveSubagentStats: informational message is tracked separately from corrections, not counted toward corrections', () => {
+  const configDir = makeTmpConfigDir();
+  const projectRoot = 'C:\\Users\\test\\proj-corr-info-split';
+  const infoMsg = 'For your awareness: the upstream service was flaky earlier today; no action needed on your end, continue your task as planned regardless of any transient errors you may have already seen in the logs before this note arrived which is now well past the head truncation length.';
+  const correctionMsg = 'Ansuz: please fix the null check in bar.js before landing — this is a real defect blocking merge and is unrelated to the informational note above in every way that matters here.';
+  writeFixture(configDir, {
+    projectRoot,
+    sessionId: 'sess-a',
+    agentId: 'corr006',
+    description: '[TASK_9085] Formation unit/do sub-agent',
+    lines: [
+      userLine('2026-01-01T00:00:00.000Z', 'p1', 'do the task'),
+      coordinatorAttachmentLine('2026-01-01T00:00:02.000Z', infoMsg),
+      coordinatorAttachmentLine('2026-01-01T00:00:03.000Z', correctionMsg),
+      toolUseLine('2026-01-01T00:00:04.000Z', 'Edit'),
+    ],
+  });
+
+  const result = deriveSubagentStats('TASK_9085', projectRoot, { configDir });
+  assert.ok(result);
+  assert.equal(result.corrections, 1, 'only the real defect message counts as a correction');
+  assert.equal(result.informational, 1, 'the FYI message is tracked, not dropped');
+  assert.equal(result.correction_heads.length, 1);
+  assert.equal(result.informational_heads.length, 1);
+  assert.ok(result.correction_heads[0].startsWith('Ansuz: please fix the null check'));
+  assert.ok(result.informational_heads[0].startsWith('For your awareness'));
+});