simt-dev 0.2.1 → 0.3.0

package/src/measure/loaderView.mjs

@@ -0,0 +1,435 @@
+// One reader's view of one repository: which files it loads before the first message,
+// in what order, and what the cap leaves out.
+//
+// This is the consumer R14 was built for. Before the loader table, `simt tokens` counted
+// the files a surface WRITES — which is why it recursed six levels into `.agents/rules/`
+// and reported bytes Antigravity never reads, and why it could not see a repository that
+// is inside 32 KiB in every file and past it once Codex merges the chain.
+//
+// What it deliberately does not do:
+//
+//   1. Walk the user's home. A reader's global instructions are the reader's, not the
+//      repository's, and a per-repository report that carried them would change because
+//      somebody installed something. `scopes` reports that a user scope exists; the bytes
+//      are the repository's.
+//   2. Decide whether a file matches. `frontmatter` in the table is an equality filter
+//      on parsed frontmatter, which is all any of these vendors document. Cursor's
+//      `alwaysApply: true` and Antigravity's `trigger: always_on` are exactly that.
+//   3. Expand imports. Claude's `@path` and Antigravity's `@[label](path)` are recorded
+//      with their depth, and `imports` reports what the reader would pull in — a
+//      measurement of the syntax, not a recursive parse of the file that would need a
+//      frontmatter-aware Markdown parser this package does not have (ADR-012).
+
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+
+import { LOADERS, caps } from '../projection/loaders.mjs';
+import { extractFrontmatter } from '../projection/targets.mjs';
+import { BYTES_PER_TOKEN } from './context.mjs';
+
+/**
+ * The longest directory walk any of these readers documents.
+ *
+ * A bound, not a guess about nesting: a stray `node_modules` inside a tool-owned
+ * directory must not turn a byte count into an unbounded walk.
+ */
+const MAX_DEPTH = 8;
+
+/** UTF-8 byte length. `String.length` counts UTF-16 units and undercounts every
+ *  non-ASCII character, and a rule file with an em dash in it is ordinary. */
+function bytes(text) {
+  return Buffer.byteLength(text);
+}
+
+/** Frontmatter as a flat object. One block, no nesting — all a rule file carries. */
+function frontmatter(text) {
+  const block = extractFrontmatter(text);
+  const out = {};
+  if (!block) return out;
+  for (const line of block.split('\n').slice(1)) {
+    if (line.trim() === '---') break;
+    const at = line.indexOf(':');
+    if (at < 1) continue;
+    out[line.slice(0, at).trim()] = line
+      .slice(at + 1)
+      .trim()
+      .replace(/^["']|["']$/g, '');
+  }
+  return out;
+}
+
+/**
+ * Files under a directory in a stable order.
+ *
+ * `depth` bounds the recursion. Nothing here filters dotfiles: a reader that documented
+ * ignoring them is not one whose docs were read, and a `.md` inside `.agents/rules/` is
+ * a rule.
+ */
+async function filesUnder(dir, depth = 0, prefix = '') {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of [...entries].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
+    const rel = prefix === '' ? entry.name : `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      if (depth >= MAX_DEPTH) continue;
+      out.push(...(await filesUnder(join(dir, entry.name), depth + 1, rel)));
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+  return out;
+}
+
+async function readText(path) {
+  try {
+    return await readFile(path, 'utf8');
+  } catch {
+    // Absence is the expected answer for a reader configured in a repository that has
+    // not written the file yet, and a permission error is not a byte count either.
+    return null;
+  }
+}
+
+async function exists(root, rel) {
+  try {
+    return (await stat(join(root, rel))).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolve one `start` entry into the repository files it loads.
+ *
+ * `chain` is the case that needs care and gets it: Codex takes at most one file per
+ * directory in precedence order, and the entries are the precedence list. Each entry is
+ * resolved separately and the first one present wins per directory, which is the rule as
+ * documented rather than as inferred — but the entries carry the same root, so the merge
+ * is over the same directory set and the winner is the entry order in the table.
+ *
+ * Returns `[]` for an entry whose documented precondition fails: `absent` names paths
+ * that must not exist, so `CLAUDE.md` beside `AGENTS.md` is exactly what makes Claude
+ * Code skip the latter.
+ */
+async function resolveEntry(root, entry) {
+  if (entry.scope !== 'project' || !entry.atStart) return [];
+  if (entry.absent && (await Promise.all(entry.absent.map((p) => exists(root, p)))).some(Boolean)) {
+    return [];
+  }
+
+  const hit = async (rel, note) => {
+    const text = await readText(join(root, rel));
+    if (text === null) return [];
+    if (entry.frontmatter) {
+      const meta = frontmatter(text);
+      const matches = Object.entries(entry.frontmatter).every(([k, v]) => meta[k] === v);
+      if (!matches) return [];
+    }
+    return [{ file: rel, text, note: note ?? null }];
+  };
+
+  switch (entry.tree) {
+    case 'single':
+      return hit(entry.path);
+    case 'chain': {
+      // The repository root is the only directory measured: these readers walk between
+      // the project root and the working directory, and a repository's own files are
+      // what it controls. A nested AGENTS.md is picked up by the nested reads below.
+      return hit(entry.path);
+    }
+    case 'flat': {
+      const out = [];
+      for (const rel of await filesUnder(join(root, entry.dir))) {
+        if (rel.includes('/')) continue;
+        if (entry.suffix && !rel.endsWith(entry.suffix)) continue;
+        out.push(...(await hit(`${entry.dir}/${rel}`)));
+      }
+      return out;
+    }
+    case 'nested': {
+      const out = [];
+      for (const rel of await filesUnder(join(root, entry.dir))) {
+        if (entry.suffix && !rel.endsWith(entry.suffix)) continue;
+        out.push(...(await hit(`${entry.dir}/${rel}`)));
+      }
+      return out;
+    }
+    default:
+      return [];
+  }
+}
+
+/** One measured file: what it weighs, what it costs a turn, and what the caps did to it. */
+function rowFor(found, entry, channel) {
+  return {
+    file: found.file,
+    scope: entry.scope,
+    channel,
+    bytes: bytes(found.text),
+    // A skill's frontmatter is what costs a turn; its body is opened later. Charging the
+    // body here is the error the `metadata` flag exists to prevent.
+    countedBytes: entry.metadata ? bytes(skillHead(found.text)) : bytes(found.text),
+    overCap: false,
+    beyondCap: false,
+    why: entry.why,
+  };
+}
+
+/**
+ * What one reader loads from one repository, at session start.
+ *
+ * `chainBytes` is the sum in load order, and `cap` is what that reader does to it: a
+ * chain-scoped cap truncates the chain, a file-scoped cap truncates each file. Both
+ * report `droppedBytes`, because "over the limit" without "by how much and which file"
+ * is the number that started this slice.
+ *
+ * `overCap` on a row means THIS FILE is truncated; `beyondCap` means the chain stopped
+ * before reaching it. They are different failures with the same visible symptom, and the
+ * one that costs a repository its deepest instructions is the second.
+ */
+export async function viewOf(root, row, options = {}) {
+  const cwd = options.cwd ? relative(root, options.cwd).split(sep).join('/') : '';
+  const files = [];
+
+  // The chain is walked directory by directory — project root down to the working
+  // directory, which is the order Codex and Antigravity document and the reverse of what
+  // a reader that walks *up* from the working directory sees. Inside one directory the
+  // entries are the precedence list and the first one present wins: two AGENTS.md files
+  // in the same directory are one of them not loaded, not both concatenated.
+  //
+  // With no `cwd` this is the root alone, which is the honest default: a repository's
+  // own root document is what the tool can measure without knowing where the agent is
+  // standing, and `--at` is how a reader asks about a subdirectory.
+  const chainEntries = row.start.filter((e) => e.tree === 'chain');
+  const parts = cwd === '' || cwd.startsWith('..') ? [] : cwd.split('/').filter(Boolean);
+  const dirs = ['', ...parts.map((_, i) => parts.slice(0, i + 1).join('/'))];
+  for (const dir of dirs) {
+    // `first` is Codex and Claude: one file per directory, precedence order.
+    // `all` is DeepSeek: every candidate loads, and a later file whose trimmed
+    // text matches an earlier one in the SAME directory is the duplicate the
+    // vendor collapses. The set resets per directory because a nested file that
+    // happens to match the root is a different scope, not a duplicate.
+    const mergeAll = row.chainMerge === 'all';
+    const trimmed = new Set();
+    let taken = false;
+    for (const entry of chainEntries) {
+      if (taken && !mergeAll) break;
+      const scoped = {
+        ...entry,
+        path: dir === '' ? entry.path : `${dir}/${entry.path}`,
+        absent: entry.absent?.map((p) => join(dir, p)),
+      };
+      const found = await resolveEntry(root, scoped);
+      if (found.length === 0) continue;
+      if (row.dedupe === 'trim') {
+        const key = found[0].text.trim();
+        if (trimmed.has(key)) continue;
+        trimmed.add(key);
+      }
+      if (!mergeAll) taken = true;
+      files.push(rowFor(found[0], entry, 'documents'));
+      if (row.imports?.syntax === '@path' && row.imports.depth > 0) {
+        for (const imp of await expandClaudeImports(root, found[0].file, found[0].text, row.imports.depth)) {
+          files.push(rowFor(imp, { scope: 'project', why: row.imports.why }, 'imports'));
+        }
+      }
+    }
+  }
+
+  for (const entry of row.start) {
+    if (entry.tree === 'chain') continue;
+    for (const found of await resolveEntry(root, entry)) {
+      // Claude Code treats `paths:` in `.claude/rules/*.md` frontmatter as path-scoped,
+      // not session-start.
+      if (row.id === 'claude' && entry.dir === '.claude/rules' && frontmatter(found.text).paths) continue;
+      files.push(
+        rowFor(found, entry, entry.metadata ? 'skills' : entry.tree === 'single' ? 'documents' : 'rules'),
+      );
+    }
+  }
+
+  // One skill id is one cost. OpenCode v2 registers .claude, then .agents, then
+  // .opencode, and the later source supplies the skill. Counting every copy would
+  // bill a turn for a body the reader replaced.
+  const skillsById = new Map();
+  const measured = [];
+  for (const file of files) {
+    if (file.channel !== 'skills') {
+      measured.push(file);
+      continue;
+    }
+    const id = file.file.split('/').at(-2) ?? file.file;
+    skillsById.set(id, file);
+  }
+  measured.push(...skillsById.values());
+  files.length = 0;
+  files.push(...measured);
+
+  const limits = caps(row);
+  const chainCap = limits.find((c) => c.scope === 'chain') ?? null;
+  // A token budget is a budget, but it is not a byte count: 20,000 tokens is 80,000
+  // bytes at the four-bytes-per-token approximation, and comparing raw bytes to it
+  // would trip on a repository that has not come close. So the token figure is
+  // converted here and reported in the unit it was documented in.
+  const tokenCap = limits.find((c) => c.scope === 'tokens') ?? null;
+  const tokenCapBytes = tokenCap ? tokenCap.bytes * BYTES_PER_TOKEN : null;
+  const fileCap = limits.find((c) => c.scope === 'file') ?? null;
+
+  // Both caps are checked, not either-or: Antigravity has a per-file byte cap and an
+  // aggregate token budget, and a rule can trip the first without tripping the second.
+  // Which one fired is reported separately, because the remedy differs.
+  let running = 0;
+  for (const file of files) {
+    running += file.countedBytes;
+    if (fileCap && file.countedBytes > fileCap.bytes) file.overCap = true;
+  }
+  if (chainCap?.drop === 'broader') {
+    // DeepSeek keeps the most specific files. Broader files are omitted whole;
+    // only the most specific file may be cut, and the rendered total stays inside
+    // the cap. A source already over the per-file cap is ignored before this.
+    const eligible = files.filter((f) => f.channel === 'documents' && !f.overCap);
+    let sum = eligible.reduce((n, f) => n + f.countedBytes, 0);
+    for (let i = 0; i < eligible.length && sum > chainCap.bytes; i += 1) {
+      const file = eligible[i];
+      const last = i === eligible.length - 1;
+      if (!last) {
+        file.beyondCap = true;
+        sum -= file.countedBytes;
+        continue;
+      }
+      file.truncated = true;
+      file.keptBytes = chainCap.bytes - (sum - file.countedBytes);
+    }
+  } else if (chainCap) {
+    let chainRunning = 0;
+    for (const file of files) {
+      if (file.overCap) continue;
+      chainRunning += file.countedBytes;
+      if (chainRunning > chainCap.bytes) file.beyondCap = true;
+    }
+  }
+  const contributed = (file) => {
+    if (file.beyondCap) return 0;
+    if (file.truncated) return file.keptBytes ?? 0;
+    if (file.overCap) return file.keptBytes ?? 0;
+    return file.countedBytes;
+  };
+  const totalBytes = files.reduce((n, file) => n + contributed(file), 0);
+
+  return {
+    reader: row.id,
+    label: row.label,
+    root,
+    order: row.order,
+    nested: row.nested,
+    imports: row.imports,
+    files,
+    totalBytes,
+    droppedBytes: files.reduce((n, f) => {
+      if (!f.beyondCap && !f.overCap && !f.truncated) return n;
+      return n + f.countedBytes - (f.truncated || f.overCap ? (f.keptBytes ?? 0) : 0);
+    }, 0),
+    // Reported, not measured: the user's global instructions are the reader's bytes.
+    // A per-repository total that included them would change when the reader installed
+    // something, which is the reason `--user` is a flag on `harness detect` and not a
+    // default anywhere in this tool.
+    userScope: row.start.filter((e) => e.scope === 'user').map((e) => e.path),
+    cap: chainCap
+      ? {
+          bytes: chainCap.bytes,
+          scope: chainCap.scope,
+          appliesTo: chainCap.appliesTo,
+          config: chainCap.config,
+          why: chainCap.why,
+          totalBytes: running,
+          over: running > chainCap.bytes,
+        }
+      : null,
+    budget: tokenCap
+      ? {
+          tokens: tokenCap.bytes,
+          bytes: tokenCapBytes,
+          appliesTo: tokenCap.appliesTo,
+          config: tokenCap.config ?? null,
+          why: tokenCap.why,
+          over: running > tokenCapBytes,
+        }
+      : null,
+    perFileCap: fileCap
+      ? {
+          bytes: fileCap.bytes,
+          appliesTo: fileCap.appliesTo,
+          config: fileCap.config,
+          why: fileCap.why,
+          over: files.some((f) => f.overCap),
+        }
+      : null,
+    skills: row.skills,
+    hooks: row.hooks,
+    mcp: row.mcp,
+    verified: row.verified,
+    note: row.note ?? null,
+  };
+}
+
+/** Name and description, which is what a reader loads before it opens a skill body. */
+function skillHead(text) {
+  const meta = frontmatter(text);
+  const name = meta.name ?? '';
+  const description = meta.description ?? '';
+  if (description) return `${name}\n${description}`;
+  return name;
+}
+
+/**
+ * Expand Claude Code `@path/to/import` directives up to `maxDepth` hops.
+ *
+ * Follows the documented parser rules on `claude.imports`:
+ *   - skips fenced code blocks and inline code spans;
+ *   - skips quoted `@path` tokens and `@[label](path)` links;
+ *   - resolves relative to the importing file's directory;
+ *   - refuses paths outside the repository root (Claude Code prompts for approval
+ *     before reading outside the working directory, so those bytes are not automatic).
+ */
+export async function expandClaudeImports(
+  root,
+  fromRel,
+  text,
+  maxDepth = 4,
+  seen = new Set([fromRel]),
+  depth = 0,
+) {
+  if (depth >= maxDepth) return [];
+  const absRoot = resolve(root);
+  const stripped = text
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/~~~[\s\S]*?~~~/g, '')
+    .replace(/`[^`\n]*`/g, '');
+
+  const out = [];
+  const baseDir = dirname(join(absRoot, fromRel));
+  for (const match of stripped.matchAll(/(?:^|(?<=[\s(]))@([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)(?=$|[\s),.;:!?\])])/gm)) {
+    const rawTarget = match[1];
+    const absTarget = resolve(baseDir, rawTarget);
+    const rel = relative(absRoot, absTarget).split(sep).join('/');
+    if (rel === '' || rel.startsWith('..') || seen.has(rel)) continue;
+    const body = await readText(absTarget);
+    if (body === null) continue;
+    seen.add(rel);
+    out.push({ file: rel, text: body });
+    out.push(...(await expandClaudeImports(absRoot, rel, body, maxDepth, seen, depth + 1)));
+  }
+  return out;
+}
+
+/** Every reader's view of one repository, in table order. */
+export async function viewAll(root, rows = LOADERS, options = {}) {
+  const out = [];
+  for (const row of rows) out.push(await viewOf(root, row, options));
+  return out;
+}

package/src/measure/session.mjs

@@ -0,0 +1,267 @@
+// Local session transcript attribution for `simt tokens --session <path>` (R06, ADR-075).
+//
+// Splits a recorded Claude Code or Codex JSONL/JSON session transcript into `rules`,
+// `fileReads` and `toolOutput` using only the local file on disk. Remote URLs are
+// refused before any socket or filesystem call so session contents never leave the
+// machine.
+
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { tokens } from './context.mjs';
+
+const RULE_PATH_RE =
+  /(?:^|\/)(?:AGENTS(?:\.override)?\.md|CLAUDE(?:\.local)?\.md|GEMINI\.md|SKILL\.md|\.cursor\/rules\/|\.claude\/rules\/|\.agents\/rules\/|\.github\/(?:copilot-instructions\.md|instructions\/)|\.simt-dev\/profiles\/)/;
+
+const FILE_READ_TOOLS = new Set(['Read', 'read_file', 'NotebookRead', 'view_file', 'read']);
+
+function bytes(text) {
+  return Buffer.byteLength(text);
+}
+
+function isRulePath(path) {
+  return typeof path === 'string' && RULE_PATH_RE.test(path.replace(/\\/g, '/'));
+}
+
+function textOfContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (typeof item === 'string') return item;
+        if (typeof item?.text === 'string') return item.text;
+        if (typeof item?.content === 'string') return item.content;
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  if (content && typeof content === 'object') {
+    if (typeof content.text === 'string') return content.text;
+    if (typeof content.output === 'string') return content.output;
+    if (typeof content.content === 'string') return textOfContent(content.content);
+  }
+  return '';
+}
+
+/**
+ * Split a local Claude Code or Codex session transcript into `rules`, `fileReads` and
+ * `toolOutput` (R06, ADR-075).
+ */
+export async function measureSession(transcriptPath) {
+  if (typeof transcriptPath !== 'string' || transcriptPath.trim() === '') {
+    return {
+      ok: false,
+      error: '--session requires a local transcript path',
+      remedy: 'pass a local JSONL or JSON transcript path: simt tokens --session <path>',
+    };
+  }
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(transcriptPath.trim())) {
+    return {
+      ok: false,
+      error: `${transcriptPath}: remote URLs are refused; session transcripts are read locally only (ADR-075)`,
+      remedy: 'pass a local file path on this machine: simt tokens --session ./session.jsonl',
+    };
+  }
+
+  const resolvedPath = resolve(transcriptPath);
+  let raw;
+  try {
+    raw = await readFile(resolvedPath, 'utf8');
+  } catch (err) {
+    return {
+      ok: false,
+      error: `${resolvedPath}: cannot read session transcript (${err.code ?? err.message})`,
+      remedy: 'pass a readable local JSONL or JSON transcript file to --session <path>',
+    };
+  }
+
+  let records = [];
+  const trimmed = raw.trim();
+  if (trimmed.length > 0) {
+    try {
+      if (trimmed.startsWith('[')) {
+        records = JSON.parse(trimmed);
+      } else {
+        records = trimmed
+          .split('\n')
+          .map((line) => line.trim())
+          .filter(Boolean)
+          .map((line) => JSON.parse(line));
+      }
+    } catch (err) {
+      return {
+        ok: false,
+        error: `${resolvedPath}: invalid JSON/JSONL session transcript (${err.message})`,
+        remedy: 'pass a valid Claude Code or Codex JSONL transcript file to --session <path>',
+      };
+    }
+  }
+
+  const callsById = new Map();
+  for (const rec of records) {
+    const msg = rec?.message ?? rec?.payload ?? rec;
+    const content = msg?.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block?.type === 'tool_use' && block.id) {
+          const input = block.input ?? {};
+          const path = input.file_path ?? input.path ?? input.notebook_path ?? null;
+          callsById.set(block.id, { name: block.name, path });
+        }
+      }
+    }
+    if ((rec?.type === 'function_call' || msg?.type === 'function_call') && (rec.call_id ?? msg.call_id)) {
+      const id = rec.call_id ?? msg.call_id;
+      const name = rec.name ?? msg.name ?? '';
+      let args = {};
+      try {
+        args =
+          typeof (rec.arguments ?? msg.arguments) === 'string'
+            ? JSON.parse(rec.arguments ?? msg.arguments)
+            : (rec.arguments ?? msg.arguments ?? {});
+      } catch {
+        args = {};
+      }
+      const path = args.file_path ?? args.path ?? args.file ?? null;
+      callsById.set(id, { name, path });
+    }
+  }
+
+  const buckets = {
+    rules: { bytes: 0, items: 0 },
+    fileReads: { bytes: 0, items: 0 },
+    toolOutput: { bytes: 0, items: 0 },
+  };
+
+  const credit = (bucket, text) => {
+    const n = bytes(text);
+    if (n <= 0) return;
+    buckets[bucket].bytes += n;
+    buckets[bucket].items += 1;
+  };
+
+  for (const rec of records) {
+    if (!rec || typeof rec !== 'object') continue;
+
+    const explicitKind = rec.category ?? rec.kind;
+    if (explicitKind === 'rules' || explicitKind === 'rule') {
+      credit('rules', textOfContent(rec.text ?? rec.content ?? rec.output ?? ''));
+      continue;
+    }
+    if (explicitKind === 'file_read' || explicitKind === 'fileRead') {
+      const target = rec.path ?? rec.file ?? null;
+      credit(isRulePath(target) ? 'rules' : 'fileReads', textOfContent(rec.text ?? rec.content ?? rec.output ?? ''));
+      continue;
+    }
+    if (explicitKind === 'tool_output' || explicitKind === 'toolOutput') {
+      credit('toolOutput', textOfContent(rec.text ?? rec.content ?? rec.output ?? ''));
+      continue;
+    }
+
+    const msg = rec.message ?? rec.payload ?? rec;
+    const role = msg.role ?? rec.role;
+    const type = msg.type ?? rec.type;
+
+    if (
+      role === 'system' ||
+      role === 'developer' ||
+      type === 'system' ||
+      type === 'user_instructions' ||
+      type === 'instructions'
+    ) {
+      credit('rules', textOfContent(msg.content ?? msg.text ?? msg.instructions ?? ''));
+      continue;
+    }
+
+    if (type === 'session_meta' && (msg.instructions || msg.base_instructions)) {
+      credit('rules', textOfContent(msg.instructions ?? msg.base_instructions));
+      continue;
+    }
+
+    if (type === 'function_call_output' || type === 'custom_tool_call_output' || type === 'local_shell_call_output') {
+      const call = callsById.get(msg.call_id ?? rec.call_id);
+      const outText = textOfContent(msg.output ?? rec.output ?? '');
+      if (call && isRulePath(call.path)) credit('rules', outText);
+      else if (call && FILE_READ_TOOLS.has(call.name)) credit('fileReads', outText);
+      else credit('toolOutput', outText);
+      continue;
+    }
+
+    if (role === 'tool' || type === 'tool_result') {
+      const call = callsById.get(msg.tool_use_id ?? rec.tool_use_id ?? msg.call_id);
+      const target = msg.path ?? rec.path ?? call?.path ?? null;
+      const outText = textOfContent(msg.content ?? msg.output ?? '');
+      if (isRulePath(target)) credit('rules', outText);
+      else if ((call && FILE_READ_TOOLS.has(call.name)) || FILE_READ_TOOLS.has(msg.name ?? rec.name)) {
+        credit('fileReads', outText);
+      } else {
+        credit('toolOutput', outText);
+      }
+      continue;
+    }
+
+    const content = msg.content;
+    if (typeof content === 'string') {
+      for (const m of content.matchAll(
+        /<(?:user_instructions|instructions|system-reminder)>([\s\S]*?)<\/(?:user_instructions|instructions|system-reminder)>/g,
+      )) {
+        credit('rules', m[1]);
+      }
+      continue;
+    }
+
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (!block || typeof block !== 'object') continue;
+        if (block.type === 'tool_result') {
+          const call = callsById.get(block.tool_use_id);
+          const target = block.path ?? call?.path ?? null;
+          const outText = textOfContent(block.content ?? block.output ?? '');
+          if (isRulePath(target)) credit('rules', outText);
+          else if ((call && FILE_READ_TOOLS.has(call.name)) || FILE_READ_TOOLS.has(block.name)) {
+            credit('fileReads', outText);
+          } else {
+            credit('toolOutput', outText);
+          }
+        } else if (typeof block.text === 'string') {
+          for (const m of block.text.matchAll(
+            /<(?:user_instructions|instructions|system-reminder)>([\s\S]*?)<\/(?:user_instructions|instructions|system-reminder)>/g,
+          )) {
+            credit('rules', m[1]);
+          }
+        }
+      }
+    }
+  }
+
+  const totalBytes = buckets.rules.bytes + buckets.fileReads.bytes + buckets.toolOutput.bytes;
+  const share = (n) => (totalBytes === 0 ? 0 : Math.round((n / totalBytes) * 100));
+
+  return {
+    ok: true,
+    path: resolvedPath,
+    rules: {
+      bytes: buckets.rules.bytes,
+      tokens: tokens(buckets.rules.bytes),
+      share: share(buckets.rules.bytes),
+      items: buckets.rules.items,
+    },
+    fileReads: {
+      bytes: buckets.fileReads.bytes,
+      tokens: tokens(buckets.fileReads.bytes),
+      share: share(buckets.fileReads.bytes),
+      items: buckets.fileReads.items,
+    },
+    toolOutput: {
+      bytes: buckets.toolOutput.bytes,
+      tokens: tokens(buckets.toolOutput.bytes),
+      share: share(buckets.toolOutput.bytes),
+      items: buckets.toolOutput.items,
+    },
+    total: {
+      bytes: totalBytes,
+      tokens: tokens(totalBytes),
+    },
+  };
+}