turntax 0.1.0 → 0.2.0

package/README.md

@@ -1,111 +1,138 @@
-# turntax
-
-Coding agents re-send their instruction files with every turn. `turntax` measures that fixed per-turn cost for a repository, per tool and per model, and shows where to cut it.
-
-```bash
-npx turntax
-```
-
-It reads the files each agent actually loads (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, `.cursor/rules`, `.github/copilot-instructions.md`, Windsurf rules, skills) and applies each tool's documented loading rules: what is sent on every turn, what loads only when the agent works in a folder or touches a matching file, and what is ignored.
-
-```text
-tool          always  o200k/turn  on-demand  model              tokens/turn  counted by                                100 turns  cached
-Claude Code   4       272         53         Claude Sonnet 5.5  -            needs --claude-api and ANTHROPIC_API_KEY  -          -
-OpenAI Codex  1       63          0          GPT-6.1 Sol        63           estimate (o200k_base proxy)               $0.01      $0.0006
-Cursor        4       297         37         Claude Sonnet 5.5  -            needs --claude-api and ANTHROPIC_API_KEY  -          -
-                                             GPT-6.1 Sol        297          estimate (o200k_base proxy)               $0.06      $0.0030
-
-Advice (savings are estimates in o200k tokens per turn)
-  HIGH duplicate CLAUDE.md, AGENTS.md [saves ~48 tokens/turn]
-    3 identical lines are loaded twice every turn by cursor. Keep them in one file.
-  HIGH contradiction AGENTS.md, CLAUDE.md [saves ~11 tokens/turn]
-    Conflicting package manager: "Always use npm ..." (AGENTS.md:3) vs "Always use pnpm ..." (CLAUDE.md:5).
-  MEDIUM scopable-section CLAUDE.md:11 [saves ~128 tokens/turn]
-    Section "API package" is mostly about packages/api/. Move it to packages/api/AGENTS.md ...
-```
-
-(Output for [`test/fixtures/mixed`](test/fixtures/mixed).)
-
-## What it counts, and how
-
-| Model family | How tokens are counted | Label |
-| --- | --- | --- |
-| OpenAI GPT-5.x, gpt-oss | Offline with `o200k_base` (the encoding OpenAI's tiktoken maps them to) | exact |
-| OpenAI GPT-6.x | Offline with `o200k_base`; OpenAI has not published a newer encoding | estimate |
-| Claude | Only Anthropic's `count_tokens` API, with your key and `--claude-api` | API count |
-| Gemini | Only Google's `countTokens` API, with your key and `--gemini-api` | API count |
-
-Claude's tokenizer is not public, and Anthropic's docs note that newer Claude models produce noticeably more tokens than older ones for the same text. `turntax` never shows an OpenAI count as a Claude or Gemini number: without a key those rows say "needs API key". The `o200k` column is a labelled reference count for every file.
-
-Cost per N turns = tokens per turn × N × input price. The "cached" column assumes every turn reads the context from the prompt cache. Prices come from a dated table with a source link per model (`turntax --list-models`); pass `--prices my-prices.json` to use your own.
-
-See [docs/how-it-counts.md](docs/how-it-counts.md) for the loading rules per tool and their sources.
-
-## Advice
-
-All checks are deterministic. Each one shows an estimated saving in o200k tokens per turn.
-
-- **duplicate**: identical lines in two files. A per-turn saving only when one tool loads both; otherwise flagged as drift risk.
-- **contradiction**: conflicting rules reaching the same agent (package manager, indentation, quotes, semicolons).
-- **scopable-section**: a section mostly about one directory that could load only there (nested file, path-scoped rule, `applyTo`).
-- **oversized-section**: a large always-loaded section that could become an on-demand skill.
-- **size-limit**: documented limits (CLAUDE.md under 200 lines, Codex's 32 KiB cut-off, Windsurf's 12,000 characters, Cursor's 500 lines).
-- **misconfigured**: files a tool ignores, such as `.md` files in `.cursor/rules` or Windsurf rules without a `trigger`.
-- **stale-reference**: referenced files or `npm run` scripts that no longer exist.
-- **non-english**: non-English sections. The token multiplier is measured only against an English version you supply (`--english CLAUDE.md=CLAUDE.en.md`) or, if you opt in, a Claude translation (`--translate`).
-
-## Options
-
-```text
-turntax [path]
-  --tools claude-code,codex,gemini-cli,cursor,copilot,windsurf
-  --models <ids>            see --list-models (default: claude-sonnet-5.5, gpt-6.1-sol, gemini-3.8-flash)
-  --turns <n>               cost projection (default 100)
-  --json | --md | --badge   output format (default: terminal table)
-  --out <file>              write the output to a file
-  --max-tokens <n>          exit 1 when any tool loads more than n o200k tokens per turn (CI gate)
-  --claude-api              exact Claude counts (ANTHROPIC_API_KEY)
-  --gemini-api              Gemini counts (GEMINI_API_KEY)
-  --english <file=en>       measure a language multiplier against your English version
-  --translate               opt-in Claude translation for that measurement (needs --claude-api)
-  --prices <file.json>      your own price table
-  --section-tokens <n>      threshold for oversized sections (default 600)
-```
-
-## Privacy
-
-Offline by default: no network calls, no telemetry. File contents are sent only when you pass `--claude-api`, `--gemini-api` or `--translate`, and only to that vendor's API. Keys are read from environment variables and sent only in request headers.
-
-## Web page
-
-[`web/`](web) is a static page that runs the same engine in the browser with the offline tokenizer only. Drop a repository folder or paste files; nothing is uploaded.
-
-Try it: https://torutdev.github.io/turntax/
-
-```bash
-npm run build:web
-```
-
-## Badge
-
-```bash
-npx turntax --badge
-```
-
-[![context tax (o200k)](https://img.shields.io/badge/context%20tax%20(o200k)-297%20tokens%2Fturn-brightgreen)](https://github.com/TorutDev/turntax)
-
-The badge shows the largest always-loaded total among the tools found, counted with o200k_base.
-
-## Limits
-
-- Assumes the agent starts at the repository root. Files outside the repository (user-level `~/.claude/CLAUDE.md`, global rules, team rules in a dashboard) are not counted.
-- Counts instruction files only, not the agent's own system prompt, tool definitions or MCP servers.
-- Loading rules change. Each rule cites the vendor page and the date it was checked; please open an issue when one is out of date.
-
-## Contributing
-
-Loading rules and prices go out of date. Corrections with a link to the vendor's page are the most useful contribution; see [CONTRIBUTING.md](CONTRIBUTING.md).
-
-## License
-
-MIT
+# turntax
+
+Coding agents re-send their instruction files with every turn. `turntax` measures that fixed per-turn cost for a repository, for every agent that reads it, and shows where to cut it.
+
+```bash
+npx turntax
+```
+
+Try it in the browser, with nothing uploaded: https://torutdev.github.io/turntax/
+
+## Supported agents
+
+Each agent's documented loading rules decide what is sent on every turn, what loads only when the agent works in a folder or touches a matching file, and what is ignored.
+
+| Agent | Files it reads from the repository |
+| --- | --- |
+| Aider | files listed under `read:` in `.aider.conf.yml` (`CONVENTIONS.md` only when listed or passed with `--read`) |
+| Amp | `AGENTS.md` (or `AGENT.md` / `CLAUDE.md`), nested `AGENTS.md`, @-mentioned files |
+| Claude Code | `CLAUDE.md`, `CLAUDE.local.md`, `.claude/rules`, skills, commands, subagents, `AGENTS.md` when there is no `CLAUDE.md` |
+| Cline | `.clinerules/`, `.cline/rules/` |
+| Continue | `.continue/rules/` |
+| Cursor | `.cursor/rules/*.mdc`, `.cursorrules`, `AGENTS.md`, `CLAUDE.md` |
+| Gemini CLI | `GEMINI.md` |
+| GitHub Copilot | `.github/copilot-instructions.md`, `.github/instructions/`, `AGENTS.md` |
+| Goose | `.goosehints`, `AGENTS.md` |
+| JetBrains Junie | `.junie/AGENTS.md`, or `AGENTS.md` with `.junie/rules/`, or `.junie/guidelines` |
+| Kiro | `.kiro/steering/`, `AGENTS.md` |
+| OpenAI Codex | `AGENTS.md`, `AGENTS.override.md`, `.agents/skills` |
+| OpenCode | `AGENTS.md`, or `CLAUDE.md` when there is none |
+| Roo Code | `.roo/rules/`, `.roo/rules-{mode}/`, `.roorules`, `AGENTS.md` |
+| Windsurf (Devin Desktop) | `.devin/rules/`, `.windsurf/rules/`, `.windsurfrules`, `AGENTS.md` |
+| Zed | the first of `.rules`, `.cursorrules`, `.windsurfrules`, `.clinerules`, `.github/copilot-instructions.md`, `AGENT.md`, `AGENTS.md`, `CLAUDE.md`, `GEMINI.md` |
+
+Agents that load exactly the same files share one row in the report:
+
+```text
+always  o200k/turn  on-demand  model                tokens/turn  counted by                   100 turns  cached   agents
+4       272         53         (no selected model)                                                                Claude Code
+1       63          0          GPT-6.1 Sol          63           estimate (o200k_base proxy)  $0.01      $0.0006  OpenAI Codex, Roo Code, Kiro, JetBrains Junie, Goose, OpenCode
+1       17          0          (no selected model)                                                                Gemini CLI
+4       297         37         GPT-6.1 Sol          297          estimate (o200k_base proxy)  $0.06      $0.0030  Cursor
+2       74          8          GPT-6.1 Sol          74           estimate (o200k_base proxy)  $0.01      $0.0007  GitHub Copilot
+2       75          0          GPT-6.1 Sol          75           estimate (o200k_base proxy)  $0.01      $0.0008  Windsurf (Devin Desktop)
+1       11          0          GPT-6.1 Sol          11           estimate (o200k_base proxy)  $0.0022    $0.0001  Zed
+1       63          19         GPT-6.1 Sol          63           estimate (o200k_base proxy)  $0.01      $0.0006  Amp
+
+Advice (savings are estimates in o200k tokens per turn)
+  HIGH duplicate CLAUDE.md, AGENTS.md [saves ~48 tokens/turn]
+    3 identical lines are loaded twice every turn by cursor. Keep them in one file.
+  HIGH contradiction AGENTS.md, CLAUDE.md [saves ~11 tokens/turn]
+    Conflicting package manager: "Always use npm ..." (AGENTS.md:3) vs "Always use pnpm ..." (CLAUDE.md:5).
+  MEDIUM scopable-section CLAUDE.md:11 [saves ~128 tokens/turn]
+    Section "API package" is mostly about packages/api/. Move it to packages/api/AGENTS.md ...
+```
+
+(Excerpt of the output for [`test/fixtures/mixed`](test/fixtures/mixed) with `--models gpt-6.1-sol`.)
+
+## What it counts, and how
+
+| Model family | How tokens are counted | Label |
+| --- | --- | --- |
+| OpenAI GPT-5.x, gpt-oss | Offline with `o200k_base` (the encoding OpenAI's tiktoken maps them to) | exact |
+| OpenAI GPT-6.x | Offline with `o200k_base`; OpenAI has not published a newer encoding | estimate |
+| Claude | Only Anthropic's `count_tokens` API, with your key and `--claude-api` | API count |
+| Gemini | Only Google's `countTokens` API, with your key and `--gemini-api` | API count |
+
+Claude's tokenizer is not public, and Anthropic's docs note that newer Claude models produce noticeably more tokens than older ones for the same text. `turntax` never shows an OpenAI count as a Claude or Gemini number: without a key those rows say "needs API key". The `o200k` column is a labelled reference count for every file.
+
+Cost per N turns = tokens per turn × N × input price. The "cached" column assumes every turn reads the context from the prompt cache. Prices come from a dated table with a source link per model (`turntax --list-models`); pass `--prices my-prices.json` to use your own.
+
+See [docs/how-it-counts.md](docs/how-it-counts.md) for the loading rules per agent and their sources.
+
+## Advice
+
+All checks are deterministic. Each one shows an estimated saving in o200k tokens per turn.
+
+- **duplicate**: identical lines in two files. A per-turn saving only when one tool loads both; otherwise flagged as drift risk.
+- **contradiction**: conflicting rules reaching the same agent (package manager, indentation, quotes, semicolons).
+- **scopable-section**: a section mostly about one directory that could load only there (nested file, path-scoped rule, `applyTo`).
+- **oversized-section**: a large always-loaded section that could become an on-demand skill.
+- **size-limit**: documented limits (CLAUDE.md under 200 lines, Codex's 32 KiB cut-off, Windsurf's 12,000 characters, Cursor's 500 lines).
+- **misconfigured**: files a tool ignores, such as `.md` files in `.cursor/rules` or Windsurf rules without a `trigger`.
+- **stale-reference**: referenced files or `npm run` scripts that no longer exist.
+- **non-english**: non-English sections. The token multiplier is measured only against an English version you supply (`--english CLAUDE.md=CLAUDE.en.md`) or, if you opt in, a Claude translation (`--translate`).
+
+## Options
+
+```text
+turntax [path]
+  --tools <ids>             agents to report (default: every agent that reads a file); see --help
+  --models <ids>            see --list-models (default: claude-sonnet-5.5, gpt-6.1-sol, gemini-3.8-flash)
+  --turns <n>               cost projection (default 100)
+  --json | --md | --badge   output format (default: terminal table)
+  --out <file>              write the output to a file
+  --max-tokens <n>          exit 1 when any tool loads more than n o200k tokens per turn (CI gate)
+  --claude-api              exact Claude counts (ANTHROPIC_API_KEY)
+  --gemini-api              Gemini counts (GEMINI_API_KEY)
+  --english <file=en>       measure a language multiplier against your English version
+  --translate               opt-in Claude translation for that measurement (needs --claude-api)
+  --prices <file.json>      your own price table
+  --section-tokens <n>      threshold for oversized sections (default 600)
+```
+
+## Privacy
+
+Offline by default: no network calls, no telemetry. File contents are sent only when you pass `--claude-api`, `--gemini-api` or `--translate`, and only to that vendor's API. Keys are read from environment variables and sent only in request headers.
+
+## Web page
+
+[`web/`](web) is a static page that runs the same engine in the browser with the offline tokenizer only. Drop a repository folder or paste files; nothing is uploaded.
+
+```bash
+npm run build:web
+```
+
+## Badge
+
+```bash
+npx turntax --badge
+```
+
+[![context tax (o200k)](https://img.shields.io/badge/context%20tax%20(o200k)-297%20tokens%2Fturn-brightgreen)](https://github.com/TorutDev/turntax)
+
+The badge shows the largest always-loaded total among the tools found, counted with o200k_base.
+
+## Limits
+
+- Assumes the agent starts at the repository root. Files outside the repository (user-level `~/.claude/CLAUDE.md`, global rules, team rules in a dashboard) are not counted.
+- Counts instruction files only, not the agent's own system prompt, tool definitions or MCP servers.
+- Loading rules change. Each rule cites the vendor page and the date it was checked; please open an issue when one is out of date.
+
+## Contributing
+
+Loading rules and prices go out of date. Corrections with a link to the vendor's page are the most useful contribution; see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT

package/dist/core/advice.js

@@ -396,7 +396,7 @@ function nonEnglish(units, english) {
 /** True for instruction files that live in a package subdirectory rather than at the root or in a root tool folder. */
 function isNested(path) {
     const dir = dirname(path);
-    return dir !== '' && !/^\.(claude|github|cursor|windsurf|devin|agents)(\/|$)/.test(dir);
+    return dir !== '' && !/^\.(claude|github|cursor|windsurf|devin|agents|clinerules|cline|roo|kiro|junie|continue)(\/|$)/.test(dir);
 }
 function staleReferences(units, opts) {
     const out = [];

package/dist/core/classify.js

@@ -1,4 +1,4 @@
-import { basename, dirname, findImports, firstParagraph, parseFrontmatter, resolvePath, stripHtmlComments } from './markdown.js';
+import { basename, configList, dirname, findImports, firstParagraph, parseFrontmatter, resolvePath, stripHtmlComments } from './markdown.js';
 import { TOOLS } from './tools.js';
 /** Works out which files each tool loads, when, and with what text. */
 export function classify(input, toolIds) {
@@ -48,6 +48,28 @@ function applyRule(tool, rule, files, byPath) {
             return files
                 .filter((f) => rule.pattern.test(f.path))
                 .map((f) => unit(tool.id, f.path, 'ignored', rule.reason, f.text, { problem: rule.reason }));
+        case 'pattern':
+            return files
+                .filter((f) => rule.pattern.test(f.path))
+                .map((f) => unit(tool.id, f.path, rule.mode, rule.trigger, f.text, { notes: rule.note ? [rule.note] : [] }));
+        case 'precedence': {
+            const inGroup = (g) => files.filter((f) => g.patterns.some((p) => p.test(f.path)));
+            const winner = rule.groups.find((g) => inGroup(g).length > 0);
+            if (!winner)
+                return [];
+            return rule.groups.flatMap((g) => inGroup(g).map((f) => g === winner
+                ? unit(tool.id, f.path, 'always', 'project instructions', f.text, { notes: rule.note ? [rule.note] : [] })
+                : unit(tool.id, f.path, 'ignored', `${winner.label} takes precedence`, f.text)));
+        }
+        case 'config-list': {
+            const config = byPath.get(rule.configPath);
+            if (!config)
+                return [];
+            return configList(config, rule.key)
+                .map((p) => byPath.get(p))
+                .filter((f) => f !== undefined)
+                .map((f) => unit(tool.id, f.path, 'always', rule.trigger, f.text));
+        }
         case 'frontmatter':
             return files
                 .filter((f) => rule.pattern.test(f.path))
@@ -111,19 +133,27 @@ function applyHierarchical(tool, rule, files, byPath) {
         conditionFails = 'CLAUDE.md exists at the root, so Claude Code reads it instead of AGENTS.md (default setting).';
     if (rule.condition === 'copilot-no-agents-md' && files.some((f) => f.path === 'AGENTS.md'))
         conditionFails = 'A root AGENTS.md exists, which Copilot uses instead.';
-    const winners = new Map();
+    // Every matching file is read, except where the tool reads only one file per directory.
+    const firstPerLevel = new Map();
+    const read = [];
     const out = [];
     for (const name of rule.names) {
         for (const f of matches.filter((m) => basename(m.path) === name)) {
             const level = levelOf(f.path, rule.sameLevelDirs);
-            if (rule.onePerDirectory && winners.has(level)) {
-                out.push(unit(tool.id, f.path, 'ignored', `${basename(winners.get(level).path)} takes precedence`, f.text));
+            // The docs do not say when subdirectory copies load, so they are not counted either way.
+            if (level !== '' && rule.nested === 'skip')
+                continue;
+            const first = firstPerLevel.get(level);
+            if (rule.onePerDirectory && first) {
+                out.push(unit(tool.id, f.path, 'ignored', `${basename(first.path)} takes precedence`, f.text));
                 continue;
             }
-            winners.set(level, f);
+            if (!first)
+                firstPerLevel.set(level, f);
+            read.push(f);
         }
     }
-    for (const f of winners.values()) {
+    for (const f of read) {
         if (conditionFails) {
             out.push(unit(tool.id, f.path, 'ignored', conditionFails, f.text));
             continue;
@@ -186,7 +216,18 @@ function expandImports(tool, parent, rule, byPath, depth, seen = new Set([parent
             continue;
         seen.add(resolved);
         const notes = [];
-        const child = unit(tool, f.path, parent.mode, parent.trigger, transform(f.text, rule, notes), {
+        let mode = parent.mode;
+        let trigger = parent.trigger;
+        let text = f.text;
+        if (rule.importGlobs) {
+            const { frontmatter, body } = parseFrontmatter(f.text);
+            if (frontmatter.globs !== undefined && String(frontmatter.globs) !== '') {
+                mode = 'on-demand';
+                trigger = `globs: ${Array.isArray(frontmatter.globs) ? frontmatter.globs.join(', ') : String(frontmatter.globs)}`;
+                text = body;
+            }
+        }
+        const child = unit(tool, f.path, mode, trigger, transform(text, rule, notes), {
             importedFrom: parent.path,
             notes,
         });

package/dist/core/files.js

@@ -1,5 +1,5 @@
 /** Which repository paths can hold agent instructions. Shared by the CLI and the web page. */
-import { findImports, resolvePath } from './markdown.js';
+import { configList, findImports, resolvePath } from './markdown.js';
 export const SKIP_DIRS = new Set([
     'node_modules',
     '.git',
@@ -30,6 +30,13 @@ const NAMES = new Set([
     'GEMINI.md',
     '.cursorrules',
     '.windsurfrules',
+    '.clinerules',
+    '.roorules',
+    '.rules',
+    'AGENT.md',
+    'CONVENTIONS.md',
+    '.goosehints',
+    '.aider.conf.yml',
 ]);
 const PATTERNS = [
     /^\.github\/copilot-instructions\.md$/,
@@ -40,6 +47,13 @@ const PATTERNS = [
     /(^|\/)\.agents\/skills\/[^/]+\/SKILL\.md$/,
     /(^|\/)\.cursor\/rules\/.+\.mdc?$/,
     /(^|\/)\.(devin|windsurf)\/rules\/.+\.md$/,
+    /^\.(clinerules|cline\/rules)\/.+\.md$/,
+    /^\.roo\/rules(-[\w-]+)?\/.+\.(md|txt)$/,
+    /^\.roorules-[\w-]+$/,
+    /^\.kiro\/steering\/[^/]+\.md$/,
+    /^\.junie\/(AGENTS|playbook|guidelines)\.md$/,
+    /^\.junie\/(rules|guidelines)\/[^/]+\.md$/,
+    /^\.continue\/rules\/[^/]+\.md$/,
 ];
 export const MAX_DEPTH = 12;
 export function isInstructionFile(path) {
@@ -51,15 +65,22 @@ export function isSkippedDir(path) {
     const name = path.slice(path.lastIndexOf('/') + 1);
     return SKIP_DIRS.has(name) || path === '.claude/worktrees' || path.endsWith('/.claude/worktrees');
 }
-/** Adds in-repo files reached through @imports (up to five levels) to `found`. */
+/** Files a file pulls in: its @imports, or the read: list of .aider.conf.yml. */
+function references(f) {
+    if (f.path === '.aider.conf.yml')
+        return configList(f, 'read');
+    return findImports(f.text)
+        .map((t) => resolvePath(f.path, t))
+        .filter((p) => p !== null);
+}
+/** Adds in-repo files reached through @imports or config read lists (up to five levels) to `found`. */
 export async function addImports(found, read) {
     let queue = [...found.values()];
     for (let depth = 0; depth < 5 && queue.length; depth++) {
         const next = [];
         for (const f of queue) {
-            for (const target of findImports(f.text)) {
-                const rel = resolvePath(f.path, target);
-                if (rel === null || found.has(rel))
+            for (const rel of references(f)) {
+                if (found.has(rel))
                     continue;
                 const text = await read(rel);
                 if (text === null)

package/dist/core/markdown.js

@@ -168,3 +168,13 @@ export function resolvePath(fromFile, target) {
     }
     return parts.join('/');
 }
+/** Paths listed under `key` in a small YAML config (string, inline list or block list). */
+export function configList(config, key) {
+    const value = parseFrontmatter(`---\n${config.text}\n---\n`).frontmatter[key];
+    const list = value === undefined || value === '' ? [] : Array.isArray(value) ? value : [String(value)];
+    return list
+        .map((p) => p.replace(/\s+#.*$/, '').trim())
+        .filter(Boolean)
+        .map((p) => resolvePath(config.path, p))
+        .filter((p) => p !== null);
+}

package/dist/core/render.js

@@ -21,6 +21,39 @@ function table(rows, indent = '') {
     const widths = rows[0].map((_, c) => Math.max(...rows.map((r) => (r[c] ?? '').length)));
     return rows.map((r) => indent + r.map((cell, c) => cell.padEnd(widths[c])).join('  ').trimEnd()).join('\n');
 }
+/**
+ * Agents that load exactly the same files with the same results share one row,
+ * so a repository with only AGENTS.md does not print a dozen identical lines.
+ */
+export function groupTools(report) {
+    const groups = new Map();
+    for (const t of report.tools) {
+        const files = report.files
+            .filter((f) => f.tool === t.tool && f.mode !== 'ignored')
+            .map((f) => [f.path, f.part, f.mode, f.o200k])
+            .sort();
+        const key = JSON.stringify([files, t.models.map(({ model, perTurn, method, reason }) => [model, perTurn, method, reason])]);
+        const g = groups.get(key);
+        if (g)
+            g.names.push(t.name);
+        else
+            groups.set(key, { names: [t.name], tool: t });
+    }
+    return [...groups.values()];
+}
+/** File rows that are identical across agents, merged with the list of agents. */
+export function groupFiles(report) {
+    const groups = new Map();
+    for (const f of report.files) {
+        const key = JSON.stringify([f.path, f.part, f.mode, f.trigger, f.o200k, f.importedFrom ?? '']);
+        const g = groups.get(key);
+        if (g)
+            g.tools.push(f.tool);
+        else
+            groups.set(key, { file: f, tools: [f.tool] });
+    }
+    return [...groups.values()];
+}
 /** Highest always-loaded o200k total across the reported tools. */
 export function headlineTokens(report) {
     return Math.max(0, ...report.tools.map((t) => t.perTurnO200k));
@@ -34,28 +67,30 @@ export function renderText(report, root) {
         return out.join('\n');
     }
     const rows = [
-        ['tool', 'always', 'o200k/turn', 'on-demand', 'model', 'tokens/turn', 'counted by', `${report.turns} turns`, 'cached'],
+        ['always', 'o200k/turn', 'on-demand', 'model', 'tokens/turn', 'counted by', `${report.turns} turns`, 'cached', 'agents'],
     ];
-    for (const t of report.tools) {
-        const head = [t.name, String(t.alwaysFiles), fmtTokens(t.perTurnO200k), fmtTokens(t.onDemandO200k)];
+    for (const { names, tool: t } of groupTools(report)) {
+        const head = [String(t.alwaysFiles), fmtTokens(t.perTurnO200k), fmtTokens(t.onDemandO200k)];
         const blank = head.map(() => '');
+        const agents = names.join(', ');
         if (!t.models.length)
-            rows.push([...head, '(no selected model)', '', '', '', '']);
+            rows.push([...head, '(no selected model)', '', '', '', '', agents]);
         t.models.forEach((m, i) => rows.push([
             ...(i === 0 ? head : blank),
             m.label,
             ...(m.perTurn === null
                 ? ['-', m.reason ?? METHOD_LABEL[m.method], '-', '-']
                 : [fmtTokens(m.perTurn), METHOD_LABEL[m.method], fmtUsd(m.uncached), fmtUsd(m.cached)]),
+            i === 0 ? agents : '',
         ]));
     }
     out.push(table(rows));
     out.push('');
     out.push('Files');
-    const fileRows = [['tool', 'mode', 'file', 'o200k', 'loads']];
-    for (const f of report.files) {
+    const fileRows = [['mode', 'file', 'o200k', 'loads', 'agents']];
+    for (const { file: f, tools } of groupFiles(report)) {
         const name = f.part === 'full' ? f.path : `${f.path} (${f.part})`;
-        fileRows.push([f.tool, f.mode, name + (f.importedFrom ? ` <- @${f.importedFrom}` : ''), fmtTokens(f.o200k), f.trigger]);
+        fileRows.push([f.mode, name + (f.importedFrom ? ` <- @${f.importedFrom}` : ''), fmtTokens(f.o200k), f.trigger, tools.join(', ')]);
     }
     out.push(table(fileRows, '  '));
     const notes = [...new Set(report.files.flatMap((f) => f.notes.map((n) => `${f.path}: ${n}`)))];
@@ -95,20 +130,21 @@ function footer(report) {
 export function renderMarkdown(report) {
     const out = ['# Agent context tax report', ''];
     out.push(`Every agent re-sends its always-loaded instruction files with each turn. Costs are for ${report.turns} turns.`, '');
-    out.push('## Per tool', '');
-    out.push('| Tool | Model | Tokens / turn | Counted by | Uncached | Cached |', '| --- | --- | ---: | --- | ---: | ---: |');
-    for (const t of report.tools) {
+    out.push('## Per agent', '');
+    out.push('| Agents | Model | Tokens / turn | Counted by | Uncached | Cached |', '| --- | --- | ---: | --- | ---: | ---: |');
+    for (const { names, tool: t } of groupTools(report)) {
+        const agents = names.join(', ');
         if (!t.models.length)
-            out.push(`| ${t.name} | - | ${fmtTokens(t.perTurnO200k)} (o200k) | reference | - | - |`);
+            out.push(`| ${agents} | - | ${fmtTokens(t.perTurnO200k)} (o200k) | reference | - | - |`);
         for (const m of t.models)
             out.push(m.perTurn === null
-                ? `| ${t.name} | ${m.label} | - | ${m.reason ?? ''} | - | - |`
-                : `| ${t.name} | ${m.label} | ${fmtTokens(m.perTurn)} | ${METHOD_LABEL[m.method]} | ${fmtUsd(m.uncached)} | ${fmtUsd(m.cached)} |`);
+                ? `| ${agents} | ${m.label} | - | ${m.reason ?? ''} | - | - |`
+                : `| ${agents} | ${m.label} | ${fmtTokens(m.perTurn)} | ${METHOD_LABEL[m.method]} | ${fmtUsd(m.uncached)} | ${fmtUsd(m.cached)} |`);
     }
-    out.push('', '## Files', '', '| Tool | Mode | File | o200k tokens | Loads |', '| --- | --- | --- | ---: | --- |');
-    for (const f of report.files) {
+    out.push('', '## Files', '', '| Mode | File | o200k tokens | Loads | Agents |', '| --- | --- | ---: | --- | --- |');
+    for (const { file: f, tools } of groupFiles(report)) {
         const name = f.part === 'full' ? f.path : `${f.path} (${f.part})`;
-        out.push(`| ${f.tool} | ${f.mode} | \`${name}\` | ${fmtTokens(f.o200k)} | ${escapeCell(f.trigger)} |`);
+        out.push(`| ${f.mode} | \`${name}\` | ${fmtTokens(f.o200k)} | ${escapeCell(f.trigger)} | ${tools.join(', ')} |`);
     }
     out.push('', '## Advice', '');
     if (!report.advice.length)

package/dist/core/tools.js

@@ -291,6 +291,256 @@ export const TOOLS = [
         ],
         notes: ['Global rules (~/.codeium/windsurf/memories/global_rules.md) are outside the repository and not counted.'],
     },
+    {
+        id: 'cline',
+        name: 'Cline',
+        families: [],
+        sources: ['https://docs.cline.bot/features/cline-rules'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'frontmatter',
+                pattern: /^\.(?:clinerules|cline\/rules)\/.+\.md$/,
+                rootPrefixes: ['.clinerules/', '.cline/rules/'],
+                decide: (fm) => {
+                    if (Array.isArray(fm.paths) && fm.paths.length === 0)
+                        return { mode: 'ignored', trigger: 'paths: [] (never applies)' };
+                    if (has(fm, 'paths'))
+                        return { mode: 'on-demand', trigger: `paths: ${str(fm.paths)}` };
+                    return { mode: 'always', trigger: 'rule without paths' };
+                },
+            },
+        ],
+        limits: [],
+        notes: [
+            'Each rule can be toggled off in Cline; the audit assumes rules are on.',
+            'Cline also detects AGENTS.md, .cursorrules and .windsurfrules; whether they are on by default is not documented, so they are not counted.',
+            'A single .clinerules file (instead of a folder) is not documented and is not counted.',
+        ],
+    },
+    {
+        id: 'roo-code',
+        name: 'Roo Code',
+        families: [],
+        sources: ['https://roocodeinc.github.io/Roo-Code/features/custom-instructions'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'precedence',
+                groups: [
+                    { label: '.roo/rules/', patterns: [/^\.roo\/rules\/.+/] },
+                    { label: '.roorules', patterns: [/^\.roorules$/] },
+                    { label: '.clinerules', patterns: [/^\.clinerules$/] },
+                ],
+                note: 'Legacy .roorules and .clinerules are read only when .roo/rules/ has no content; their order between each other is assumed.',
+            },
+            { kind: 'pattern', pattern: /^\.roo\/rules-[\w-]+\/.+/, mode: 'on-demand', trigger: 'only in that Roo mode' },
+            { kind: 'pattern', pattern: /^\.roorules-[\w-]+$/, mode: 'on-demand', trigger: 'only in that Roo mode (legacy)' },
+            {
+                kind: 'hierarchical',
+                names: ['AGENTS.md', 'AGENT.md'],
+                onePerDirectory: true,
+                nested: 'skip',
+                nestedTrigger: '',
+                note: 'Read by default; the roo-cline.useAgentRules setting turns it off.',
+            },
+        ],
+        limits: [],
+        notes: ['Global ~/.roo/rules/ is outside the repository and not counted.'],
+    },
+    {
+        id: 'kiro',
+        name: 'Kiro',
+        families: [],
+        sources: ['https://kiro.dev/docs/steering/'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'frontmatter',
+                pattern: /^\.kiro\/steering\/[^/]+\.md$/,
+                rootPrefixes: ['.kiro/steering/'],
+                decide: (fm) => {
+                    switch (str(fm.inclusion).trim()) {
+                        case '':
+                        case 'always':
+                            return { mode: 'always', trigger: 'inclusion: always' };
+                        case 'fileMatch':
+                            return { mode: 'on-demand', trigger: `fileMatch: ${str(fm.fileMatchPattern)}` };
+                        case 'manual':
+                            return { mode: 'manual', trigger: 'inclusion: manual (#name)' };
+                        case 'auto':
+                            return {
+                                mode: 'on-demand',
+                                trigger: 'inclusion: auto (matched on description)',
+                                descriptionOnly: true,
+                                note: 'Description assumed to be in context so Kiro can match it (inferred, not documented).',
+                            };
+                        default:
+                            return { mode: 'always', trigger: `inclusion: ${str(fm.inclusion)} (unknown, treated as always)` };
+                    }
+                },
+            },
+            { kind: 'hierarchical', names: ['AGENTS.md'], nested: 'skip', nestedTrigger: '' },
+        ],
+        limits: [],
+        notes: [
+            'fileMatch and manual modes need Kiro CLI V3; older versions skip those files.',
+            'Global ~/.kiro/steering/ is outside the repository and not counted.',
+        ],
+    },
+    {
+        id: 'junie',
+        name: 'JetBrains Junie',
+        families: [],
+        sources: ['https://junie.jetbrains.com/docs/guidelines-and-memory.html'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'precedence',
+                groups: [
+                    { label: '.junie/AGENTS.md', patterns: [/^\.junie\/AGENTS\.md$/] },
+                    { label: 'AGENTS.md', patterns: [/^AGENTS\.md$/, /^\.junie\/playbook\.md$/, /^\.junie\/rules\/[^/]+\.md$/] },
+                    { label: '.junie/guidelines', patterns: [/^\.junie\/guidelines\.md$/, /^\.junie\/guidelines\/[^/]+\.md$/] },
+                ],
+                note: 'Follows the IDE plugin order; a custom guidelines path set in project settings is not modelled.',
+            },
+        ],
+        limits: [],
+        notes: ['Global ~/.junie/AGENTS.md is outside the repository and not counted.'],
+    },
+    {
+        id: 'zed',
+        name: 'Zed',
+        families: [],
+        sources: ['https://zed.dev/docs/ai/instructions'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'precedence',
+                groups: [
+                    '.rules',
+                    '.cursorrules',
+                    '.windsurfrules',
+                    '.clinerules',
+                    '.github/copilot-instructions.md',
+                    'AGENT.md',
+                    'AGENTS.md',
+                    'CLAUDE.md',
+                    'GEMINI.md',
+                ].map((path) => ({ label: path, patterns: [new RegExp(`^${path.replace(/\./g, '\\.')}$`)] })),
+                note: 'Zed uses only the first of these files it finds at the project root.',
+            },
+        ],
+        limits: [],
+        notes: ['Personal ~/.config/zed/AGENTS.md is outside the repository and not counted.'],
+    },
+    {
+        id: 'continue',
+        name: 'Continue',
+        families: [],
+        sources: ['https://docs.continue.dev/customize/deep-dives/rules'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'frontmatter',
+                pattern: /^\.continue\/rules\/[^/]+\.md$/,
+                rootPrefixes: ['.continue/rules/'],
+                decide: (fm) => {
+                    const always = fm.alwaysApply === true || str(fm.alwaysApply) === 'true';
+                    const never = fm.alwaysApply === false || str(fm.alwaysApply) === 'false';
+                    if (always)
+                        return { mode: 'always', trigger: 'alwaysApply: true' };
+                    if (has(fm, 'globs'))
+                        return { mode: 'on-demand', trigger: `globs: ${str(fm.globs)}` };
+                    if (!never)
+                        return { mode: 'always', trigger: 'no globs' };
+                    if (has(fm, 'description'))
+                        return {
+                            mode: 'on-demand',
+                            trigger: 'agent decides from description',
+                            descriptionOnly: true,
+                            note: 'Description assumed to be in context so the agent can decide (inferred, not documented).',
+                        };
+                    return { mode: 'on-demand', trigger: 'alwaysApply: false (agent decides)' };
+                },
+            },
+        ],
+        limits: [],
+        notes: ['Rules in config.yaml or from the Continue hub are not counted.'],
+    },
+    {
+        id: 'aider',
+        name: 'Aider',
+        families: [],
+        sources: ['https://aider.chat/docs/usage/conventions.html'],
+        checkedAt: '2026-10-10',
+        rules: [
+            { kind: 'config-list', configPath: '.aider.conf.yml', key: 'read', trigger: 'read: in .aider.conf.yml' },
+            { kind: 'pattern', pattern: /^CONVENTIONS\.md$/, mode: 'manual', trigger: 'only with --read, /read or read: in .aider.conf.yml' },
+        ],
+        limits: [],
+        notes: ['Aider loads no instruction file by itself; files given with --read are sent with every request.'],
+    },
+    {
+        id: 'goose',
+        name: 'Goose',
+        families: [],
+        sources: ['https://goose-docs.ai/docs/guides/context-engineering/using-goosehints'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'hierarchical',
+                names: ['AGENTS.md', '.goosehints'],
+                nested: 'on-demand',
+                nestedTrigger: 'when goose accesses files in',
+            },
+        ],
+        limits: [],
+        notes: [
+            'Needs the Developer extension; CONTEXT_FILE_NAMES can change which files are read.',
+            'Global ~/.config/goose/.goosehints is outside the repository and not counted.',
+        ],
+    },
+    {
+        id: 'amp',
+        name: 'Amp',
+        families: [],
+        sources: ['https://ampcode.com/docs/customize/agents-md'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'hierarchical',
+                names: ['AGENTS.md', 'AGENT.md', 'CLAUDE.md'],
+                onePerDirectory: true,
+                nested: 'on-demand',
+                nestedTrigger: 'when Amp reads a file in',
+                importDepth: 1,
+                importGlobs: true,
+                note: 'AGENT.md and CLAUDE.md are fallbacks for directories without AGENTS.md; their order between each other, and following @-mentions one level deep, are assumptions.',
+            },
+        ],
+        limits: [],
+        notes: ['User and system AGENTS.md files (~/.config/amp, /etc/ampcode) are outside the repository and not counted.'],
+    },
+    {
+        id: 'opencode',
+        name: 'OpenCode',
+        families: [],
+        sources: ['https://opencode.ai/docs/rules/'],
+        checkedAt: '2026-10-10',
+        rules: [
+            {
+                kind: 'hierarchical',
+                names: ['AGENTS.md', 'CLAUDE.md'],
+                onePerDirectory: true,
+                nested: 'skip',
+                nestedTrigger: '',
+                note: 'CLAUDE.md is read only when there is no AGENTS.md.',
+            },
+        ],
+        limits: [],
+        notes: ['Extra files listed under instructions in opencode.json are not counted.'],
+    },
 ];
 export const TOOL_IDS = TOOLS.map((t) => t.id);
 export function getTool(id) {

package/package.json

@@ -1,53 +1,63 @@
-{
-  "name": "turntax",
-  "version": "0.1.0",
-  "description": "Measure the per-turn token tax your AI coding-agent instruction files (CLAUDE.md, AGENTS.md, Cursor/Copilot/Windsurf rules) add to every agent turn.",
-  "license": "MIT",
-  "author": "TORUT LTD",
-  "homepage": "https://github.com/TorutDev/turntax#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/TorutDev/turntax.git"
-  },
-  "bugs": {
-    "url": "https://github.com/TorutDev/turntax/issues"
-  },
-  "type": "module",
-  "bin": {
-    "turntax": "dist/bin.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "engines": {
-    "node": ">=22"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "build:web": "esbuild src/web/main.ts --bundle --minify --format=esm --target=es2022 --outfile=web/app.js",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run",
-    "prepack": "npm run build"
-  },
-  "keywords": [
-    "claude-code",
-    "agents-md",
-    "codex",
-    "cursor",
-    "copilot",
-    "gemini-cli",
-    "windsurf",
-    "tokens",
-    "context",
-    "cli"
-  ],
-  "dependencies": {
-    "gpt-tokenizer": "4.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "24.19.0",
-    "esbuild": "0.28.2",
-    "typescript": "6.0.3",
-    "vitest": "5.0.3"
-  }
-}
+{
+  "name": "turntax",
+  "version": "0.2.0",
+  "description": "Measure the per-turn token cost of AI coding-agent instruction files (AGENTS.md, CLAUDE.md, Cursor, Copilot, Cline, Roo, Kiro, Windsurf and more) for every agent that reads them.",
+  "license": "MIT",
+  "author": "TORUT LTD",
+  "homepage": "https://github.com/TorutDev/turntax#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TorutDev/turntax.git"
+  },
+  "bugs": {
+    "url": "https://github.com/TorutDev/turntax/issues"
+  },
+  "type": "module",
+  "bin": {
+    "turntax": "dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:web": "esbuild src/web/main.ts --bundle --minify --format=esm --target=es2022 --outfile=web/app.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "agents-md",
+    "claude-code",
+    "codex",
+    "cursor",
+    "copilot",
+    "gemini-cli",
+    "windsurf",
+    "cline",
+    "roo-code",
+    "kiro",
+    "junie",
+    "zed",
+    "continue",
+    "aider",
+    "goose",
+    "amp",
+    "opencode",
+    "tokens",
+    "context",
+    "cli"
+  ],
+  "dependencies": {
+    "gpt-tokenizer": "4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.19.0",
+    "esbuild": "0.28.2",
+    "typescript": "6.0.3",
+    "vitest": "5.0.3"
+  }
+}