@devtrace-ai/cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# DevTrace
+
+**Know what your AI code actually costs you.** DevTrace is a local-first CLI that scans your git history and tells you what share of your codebase is AI-authored — and how much of it actually survived.
+
+```bash
+# coming soon (not yet published to npm)
+npx @devtrace-ai/cli init
+```
+
+**Works today, from source:**
+
+```bash
+git clone https://github.com/davidgdb/DevTrace.git devtrace
+cd devtrace
+npm install
+npm run build
+node dist/index.js init
+```
+
+`init` installs a git post-commit hook for forward capture, then retro-scans your last 90 days of commit history and shows you the reveal box below in seconds. Nothing leaves your machine.
+
+## The reveal
+
+```
+┌─ Your AI code, last 90 days ─────────────────────────
+│   AI-authored commits:        42  (31% of 134 commits)
+│   AI lines still at HEAD:      68%  ← lines still attributed to their original commit at HEAD
+│   Human lines still at HEAD:   81%
+│   By tool:
+│      Claude       71% survival  (28 commits)
+│      Cursor        52% survival  (14 commits, 3 unknown)
+│   AI lines rewritten since:    ~1,204
+└──────────────────────────────────────────────────────────────
+  → devtrace status         see traced session count
+  → devtrace report         full breakdown (DEVTRACE_LOG.md)
+  → devtrace churn          re-run windowed survival later
+```
+
+Numbers above are illustrative, not sample data from a real run.
+
+## How detection works
+
+DevTrace is trailer-first: it only claims high confidence when git gives it hard evidence, and says so honestly when it doesn't.
+
+| Tier | Meaning | Confidence | Basis |
+|---|---|---|---|
+| 1 — Confirmed | Commit trailer / co-author line (e.g. `Claude`, `Cursor`, `Copilot-Agent-Logs-Url`) | 0.95 | Fact, not inference |
+| 2 — Instrumented | DevTrace's own Claude Code hook observed the edits behind the commit (`devtrace claude-install`) | 0.85 | Observed generation, not vendor-attested |
+| 3 — Heuristic | Commit velocity (<45s after parent, >20 lines) or greenfield diff shape (150+ insertions, 0 deletions) | capped at 0.5, labeled `unknown-ai` | Weak prior, never proof |
+| 0 — Unknown | No signal either way | 0.3 | Honest "we don't know" — never fabricated as human |
+
+**Limits, honestly stated:** tools that don't leave a commit trailer (Copilot in most default configurations, plain inline completions, etc.) are nearly invisible to git-history analysis — DevTrace can only see what git records. Tier 3 heuristics are weak statistical priors that can misfire on `--amend`, squashes, rebases, or vendored code drops; they are never presented as certainty.
+
+## Privacy
+
+100% local. All session data is stored as JSONL on your own disk (`.devtrace/` by default). No network calls, no telemetry, no accounts. Only commit metadata (hashes, diff stats, timestamps, detected tool/confidence) is captured — never your source code or prompt content unless you explicitly annotate a session with it.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `devtrace init` | Install the git hook, write default config, run the retroactive scan |
+| `devtrace scan [--fast] [--since <n>d]` | Re-run the retroactive scan only. `--fast` skips the git-blame survival pass (numstat-only); `--since 30d` narrows the window (default 90 days) |
+| `devtrace status` | Show trust state, hook status, and traced session count (also the default with no subcommand) |
+| `devtrace report [--out <path>]` | Rebuild `DEVTRACE_LOG.md` and generate a self-contained HTML report (`.devtrace/report.html`) |
+| `devtrace card [--out <path>]` | Generate a shareable SVG scorecard (`.devtrace/card.svg`, social-card ratio) |
+| `devtrace digest [--since <n>d]` | Print + write a markdown digest of the last 7 days (`.devtrace/digest.md`) |
+| `devtrace churn` | Retroactively recompute code survival rates via `git blame` |
+| `devtrace export` | Export the session dataset to CSV (injection-sanitized) |
+| `devtrace annotate [--id <id>] [--correctness N] [--completeness N] [--effort N] [--prompt ...] [--notes ...] [--model ...] [--complexity ...]` | Rate/annotate the last session, or mark it human-only |
+| `devtrace trust` / `devtrace untrust` | Allow or block this workspace from running its configured test command on commit |
+| `devtrace uninstall` | Remove the post-commit hook |
+| `devtrace claude-install` / `claude-uninstall` | Add/remove the Claude Code hook integration (tier-2 capture, metadata only — never prompt text) |
+
+## Status
+
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)
+![tests](https://img.shields.io/badge/tests-node--test-lightgrey)
+
+Zero runtime dependencies. Not yet published to npm.
+
+30-day windowed survival is measured honestly: commits younger than 30 days report "window still open", never a fabricated number.
+
+## Roadmap (planned, not yet built)
+
+- PNG export for the scorecard card (WASM rasterizer, opt-in — the core stays zero-dependency)
+- Team dashboard across multiple repos/contributors
+
+## Contributing
+
+Issues and PRs welcome. Build with `npm run build`, test with `npm test` (`node --test`). No dependencies to keep the CLI auditable — please keep it that way.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/analyzer.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsAnalyzer = void 0;
+class MetricsAnalyzer {
+    static analyze(sessions) {
+        const byToolStats = {};
+        const byChangeTypeStats = {};
+        const stats = {
+            totalCommits: sessions.length,
+            aiCommits: 0,
+            humanCommits: 0,
+            aiContributionRate: 0,
+            avgInsertions: 0,
+            avgDeletions: 0,
+            reworkRate: 0,
+            byTool: byToolStats,
+            byChangeType: byChangeTypeStats,
+            timeline: {}
+        };
+        // Initialize tools
+        const tools = ['claude-code', 'gemini-cli', 'cursor', 'copilot', 'codex', 'aider', 'ollama', 'other', 'unknown-ai', 'none'];
+        const toolAnnotatedCounts = {
+            'claude-code': 0,
+            'gemini-cli': 0,
+            'cursor': 0,
+            'copilot': 0,
+            'codex': 0,
+            'aider': 0,
+            'ollama': 0,
+            'other': 0,
+            'unknown-ai': 0,
+            'none': 0
+        };
+        for (const tool of tools) {
+            stats.byTool[tool] = {
+                count: 0,
+                insertions: 0,
+                deletions: 0,
+                testPasses: 0,
+                testFailures: 0,
+                avgCorrectness: 0,
+                avgCompleteness: 0,
+                avgEffort: 0
+            };
+        }
+        // Initialize types
+        const types = ['feature', 'bugfix', 'refactor', 'test', 'docs', 'config', 'style', 'unknown'];
+        for (const type of types) {
+            stats.byChangeType[type] = {
+                count: 0,
+                aiCount: 0,
+                humanCount: 0,
+                avgInsertions: 0
+            };
+        }
+        let grandInsertions = 0;
+        let grandDeletions = 0;
+        let totalReworkInsertions = 0;
+        let totalReworkDeletions = 0;
+        for (const s of sessions) {
+            const isAI = s.aiTool !== 'none';
+            if (isAI)
+                stats.aiCommits++;
+            else
+                stats.humanCommits++;
+            grandInsertions += s.diff.totalInsertions;
+            grandDeletions += s.diff.totalDeletions;
+            // Group by tool (safely fallback to 'other' if tool is unrecognized)
+            let toolKey = s.aiTool;
+            if (!stats.byTool[toolKey]) {
+                toolKey = 'other';
+            }
+            const toolStats = stats.byTool[toolKey];
+            toolStats.count++;
+            toolStats.insertions += s.diff.totalInsertions;
+            toolStats.deletions += s.diff.totalDeletions;
+            if (s.testResult) {
+                if (s.testResult.exitCode === 0)
+                    toolStats.testPasses++;
+                else
+                    toolStats.testFailures++;
+            }
+            if (s.annotation) {
+                let hasAnnotation = false;
+                if (s.annotation.correctness !== undefined && s.annotation.correctness !== null) {
+                    toolStats.avgCorrectness += s.annotation.correctness;
+                    hasAnnotation = true;
+                }
+                if (s.annotation.completeness !== undefined && s.annotation.completeness !== null) {
+                    toolStats.avgCompleteness += s.annotation.completeness;
+                    hasAnnotation = true;
+                }
+                if (s.annotation.effortToIntegrate !== undefined && s.annotation.effortToIntegrate !== null) {
+                    toolStats.avgEffort += s.annotation.effortToIntegrate;
+                    hasAnnotation = true;
+                }
+                if (hasAnnotation) {
+                    toolAnnotatedCounts[toolKey]++;
+                }
+            }
+            // Group by change type (safely fallback to 'unknown' if unrecognized)
+            let typeKey = s.changeType;
+            if (!stats.byChangeType[typeKey]) {
+                typeKey = 'unknown';
+            }
+            const typeStats = stats.byChangeType[typeKey];
+            typeStats.count++;
+            typeStats.avgInsertions += s.diff.totalInsertions;
+            if (isAI)
+                typeStats.aiCount++;
+            else
+                typeStats.humanCount++;
+            // Timeline aggregation (YYYY-MM-DD)
+            const dateStr = s.timestamp.substring(0, 10);
+            if (!stats.timeline[dateStr]) {
+                stats.timeline[dateStr] = { total: 0, ai: 0, human: 0 };
+            }
+            stats.timeline[dateStr].total++;
+            if (isAI)
+                stats.timeline[dateStr].ai++;
+            else
+                stats.timeline[dateStr].human++;
+            // Rework tracking aggregation
+            if (s.churn) {
+                totalReworkDeletions += s.churn.linesReverted;
+                totalReworkInsertions += s.diff.totalInsertions;
+            }
+        }
+        // Compute averages
+        if (stats.totalCommits > 0) {
+            stats.aiContributionRate = parseFloat(((stats.aiCommits / stats.totalCommits) * 100).toFixed(1));
+            stats.avgInsertions = parseFloat((grandInsertions / stats.totalCommits).toFixed(1));
+            stats.avgDeletions = parseFloat((grandDeletions / stats.totalCommits).toFixed(1));
+        }
+        if (totalReworkInsertions > 0) {
+            stats.reworkRate = parseFloat(((totalReworkDeletions / totalReworkInsertions) * 100).toFixed(1));
+        }
+        // Normalize tool averages
+        for (const tool of tools) {
+            const toolStats = stats.byTool[tool];
+            const annotatedCount = toolAnnotatedCounts[tool];
+            if (annotatedCount > 0) {
+                toolStats.avgCorrectness = parseFloat((toolStats.avgCorrectness / annotatedCount).toFixed(1));
+                toolStats.avgCompleteness = parseFloat((toolStats.avgCompleteness / annotatedCount).toFixed(1));
+                toolStats.avgEffort = parseFloat((toolStats.avgEffort / annotatedCount).toFixed(1));
+            }
+            else {
+                toolStats.avgCorrectness = 0;
+                toolStats.avgCompleteness = 0;
+                toolStats.avgEffort = 0;
+            }
+        }
+        // Normalize change type averages
+        for (const type of types) {
+            const typeStats = stats.byChangeType[type];
+            if (typeStats.count > 0) {
+                typeStats.avgInsertions = parseFloat((typeStats.avgInsertions / typeStats.count).toFixed(1));
+            }
+        }
+        return stats;
+    }
+}
+exports.MetricsAnalyzer = MetricsAnalyzer;

package/dist/capture/claude.js

@@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCaptureSource = void 0;
+exports.slugifyCwd = slugifyCwd;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Slugifies an absolute path into the directory-name form Claude Code uses
+ * under ~/.claude/projects/. See module doc comment for the verified rule.
+ */
+function slugifyCwd(cwd) {
+    return cwd.replace(/[^A-Za-z0-9]/g, '-');
+}
+class ClaudeCaptureSource {
+    /** Base directory containing per-project transcript folders. Injectable for tests. */
+    baseDir;
+    constructor(baseDir) {
+        if (baseDir) {
+            this.baseDir = baseDir;
+        }
+        else {
+            const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+            this.baseDir = homeDir ? path.join(homeDir, '.claude', 'projects') : '';
+        }
+    }
+    /**
+     * Resolves the transcript directory for a given repo working directory.
+     * Returns null if it can't be resolved (no home dir) or doesn't exist.
+     */
+    resolveProjectDir(cwd) {
+        if (!this.baseDir)
+            return null;
+        const dir = path.join(this.baseDir, slugifyCwd(cwd));
+        if (!fs.existsSync(dir))
+            return null;
+        return dir;
+    }
+    /**
+     * Finds the most recently modified transcript (*.jsonl) for the given cwd,
+     * optionally bounded to files modified within `maxAgeMs` of now (recency
+     * window, e.g. to correlate a capture with a just-made commit).
+     */
+    findLatestTranscript(cwd, maxAgeMs) {
+        const projectDir = this.resolveProjectDir(cwd);
+        if (!projectDir)
+            return null;
+        let entries;
+        try {
+            entries = fs.readdirSync(projectDir);
+        }
+        catch {
+            return null;
+        }
+        const candidates = [];
+        for (const entry of entries) {
+            if (!entry.endsWith('.jsonl'))
+                continue;
+            const filePath = path.join(projectDir, entry);
+            try {
+                const stat = fs.statSync(filePath);
+                if (!stat.isFile())
+                    continue;
+                candidates.push({ filePath, mtimeMs: stat.mtimeMs });
+            }
+            catch {
+                // Skip files that vanish/error between readdir and stat.
+            }
+        }
+        if (candidates.length === 0)
+            return null;
+        candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+        const newest = candidates[0];
+        if (maxAgeMs !== undefined && Date.now() - newest.mtimeMs > maxAgeMs) {
+            return null;
+        }
+        return newest;
+    }
+    /**
+     * Extracts the plain text of a user/assistant `message.content` field,
+     * which may be a raw string or an array of content blocks (text,
+     * tool_result, thinking, etc). Unknown block shapes are ignored.
+     */
+    static extractText(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            const parts = [];
+            for (const block of content) {
+                if (block && typeof block === 'object') {
+                    const b = block;
+                    if (b.type === 'text' && typeof b.text === 'string') {
+                        parts.push(b.text);
+                    }
+                    // tool_result / tool_use / thinking blocks intentionally skipped:
+                    // they aren't the human-authored prompt text we want to surface.
+                }
+            }
+            return parts.join('\n');
+        }
+        return '';
+    }
+    /**
+     * Parses a transcript JSONL file and extracts the latest user prompt text
+     * plus the most recently observed assistant model name. Tolerates
+     * malformed lines by skipping them.
+     */
+    static parseTranscript(filePath) {
+        let raw;
+        try {
+            raw = fs.readFileSync(filePath, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        const lines = raw.split('\n');
+        let latestUserPrompt = '';
+        let latestUserTimestamp = -Infinity;
+        let latestModel = null;
+        let latestModelTimestamp = -Infinity;
+        let sessionId = '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                // Malformed line: skip and keep going (format is unstable by design).
+                continue;
+            }
+            if (!parsed || typeof parsed !== 'object')
+                continue;
+            if (typeof parsed.sessionId === 'string' && parsed.sessionId) {
+                sessionId = parsed.sessionId;
+            }
+            const ts = typeof parsed.timestamp === 'string' ? Date.parse(parsed.timestamp) : NaN;
+            const tsOrOrder = Number.isNaN(ts) ? 0 : ts;
+            if (parsed.type === 'user') {
+                const content = parsed.message?.content;
+                // Only treat string or block-array content with actual text as a
+                // real user-authored prompt; tool_result-only turns extract to ''
+                // and are skipped so we don't surface tool output as "the prompt".
+                const text = ClaudeCaptureSource.extractText(content);
+                if (text && tsOrOrder >= latestUserTimestamp) {
+                    latestUserTimestamp = tsOrOrder;
+                    latestUserPrompt = text;
+                }
+            }
+            else if (parsed.type === 'assistant') {
+                const model = parsed.message?.model;
+                if (typeof model === 'string' && model && tsOrOrder >= latestModelTimestamp) {
+                    latestModelTimestamp = tsOrOrder;
+                    latestModel = model;
+                }
+            }
+        }
+        if (!latestUserPrompt)
+            return null;
+        return { promptText: latestUserPrompt, model: latestModel, sessionId: sessionId || path.basename(filePath, '.jsonl') };
+    }
+    /**
+     * Public API: returns the latest user prompt + model + session id for
+     * THIS repo (cwd-correlated via the slugified project dir), or null if
+     * unavailable. `maxAgeMs`, if given, only considers transcripts modified
+     * within that window of now (e.g. to correlate with a just-made commit).
+     */
+    getLatestPrompt(cwd, maxAgeMs) {
+        const latest = this.findLatestTranscript(cwd, maxAgeMs);
+        if (!latest)
+            return null;
+        const parsed = ClaudeCaptureSource.parseTranscript(latest.filePath);
+        if (!parsed)
+            return null;
+        return {
+            promptText: parsed.promptText,
+            model: parsed.model,
+            sessionId: parsed.sessionId,
+            transcriptPath: latest.filePath,
+            mtimeMs: latest.mtimeMs
+        };
+    }
+}
+exports.ClaudeCaptureSource = ClaudeCaptureSource;

package/dist/capture/trailers.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrailerParser = void 0;
+/**
+ * Parses git commit trailers and known message conventions for AI-provenance signals.
+ * Pure functions — no git calls, no I/O. See docs/plans/03b Gap 3 trailer table.
+ */
+class TrailerParser {
+    /**
+     * Runs every known trailer/pattern check against a commit message (and optionally
+     * the commit author name, needed for Aider's ` (aider)` author-suffix convention).
+     * Returns all matches found (a commit can carry more than one trailer).
+     */
+    static parse(commitMessage, authorName = '') {
+        const matches = [];
+        const message = commitMessage || '';
+        this.matchClaudeCode(message, matches);
+        this.matchCopilot(message, matches);
+        this.matchCursor(message, matches);
+        this.matchCodex(message, matches);
+        this.matchAider(message, authorName, matches);
+        this.matchAssistedBy(message, matches);
+        return matches;
+    }
+    /** Convenience: true if any trailer/pattern matched. */
+    static hasMatch(commitMessage, authorName = '') {
+        return this.parse(commitMessage, authorName).length > 0;
+    }
+    static matchClaudeCode(message, matches) {
+        // Co-Authored-By: Claude <noreply@anthropic.com> (trailer key is case-insensitive)
+        if (/^co-authored-by:\s*claude\s*<noreply@anthropic\.com>/im.test(message)) {
+            matches.push({ tool: 'claude-code', pattern: 'trailer:claude-code' });
+            return;
+        }
+        // "Generated with Claude Code" attribution line
+        if (/generated with\s*\[?claude code\]?/i.test(message)) {
+            matches.push({ tool: 'claude-code', pattern: 'trailer:claude-code-generated-with' });
+        }
+    }
+    static matchCopilot(message, matches) {
+        // Co-authored-by: Copilot <...@users.noreply.github.com> or <copilot@github.com>
+        const coAuthored = /^co-authored-by:\s*copilot\s*<[^>]*(?:users\.noreply\.github\.com|copilot@github\.com)>/im;
+        if (coAuthored.test(message)) {
+            matches.push({ tool: 'copilot', pattern: 'trailer:copilot' });
+        }
+        // Agent-Logs-Url trailer indicates Copilot coding agent
+        if (/^agent-logs-url:/im.test(message)) {
+            matches.push({ tool: 'copilot', pattern: 'trailer:copilot-agent-logs-url' });
+        }
+    }
+    static matchCursor(message, matches) {
+        // Co-authored-by: Cursor <cursoragent@cursor.com>
+        if (/^co-authored-by:\s*cursor\s*<cursoragent@cursor\.com>/im.test(message)) {
+            matches.push({ tool: 'cursor', pattern: 'trailer:cursor' });
+        }
+    }
+    static matchCodex(message, matches) {
+        // Co-authored-by: Codex <noreply@openai.com> — medium confidence, unverified vendor string
+        if (/^co-authored-by:\s*codex\s*<noreply@openai\.com>/im.test(message)) {
+            matches.push({ tool: 'codex', pattern: 'unverified-pattern', unverified: true });
+        }
+    }
+    static matchAider(message, authorName, matches) {
+        // Author-name suffix: "Some Name (aider)"
+        if (/\(aider\)\s*$/i.test(authorName.trim())) {
+            matches.push({ tool: 'aider', pattern: 'trailer:aider-author-suffix' });
+            return;
+        }
+        // Co-authored-by: aider (aider commits its own author line, but flag also supports a trailer)
+        if (/^co-authored-by:\s*aider\b/im.test(message)) {
+            matches.push({ tool: 'aider', pattern: 'trailer:aider-co-authored-by' });
+            return;
+        }
+        // Message prefix convention: "aider: <message>"
+        if (/^aider:\s*/i.test(message.trim())) {
+            matches.push({ tool: 'aider', pattern: 'trailer:aider-message-prefix' });
+        }
+    }
+    static matchAssistedBy(message, matches) {
+        // Assisted-by: <agent>:<model>  (RFC trailer, Linux kernel/Fedora/Apache/LLVM/OpenTelemetry)
+        const re = /^assisted-by:\s*([\w.\-]+):([\w.\-]+)/im;
+        const m = re.exec(message);
+        if (m) {
+            const agentToken = m[1].toLowerCase();
+            const model = m[2];
+            matches.push({
+                tool: this.agentTokenToTool(agentToken),
+                model,
+                pattern: 'trailer:assisted-by'
+            });
+        }
+    }
+    /** Maps the free-form agent token in an Assisted-by trailer to a known AITool. */
+    static agentTokenToTool(agentToken) {
+        if (/claude/.test(agentToken))
+            return 'claude-code';
+        if (/copilot/.test(agentToken))
+            return 'copilot';
+        if (/cursor/.test(agentToken))
+            return 'cursor';
+        if (/codex/.test(agentToken))
+            return 'codex';
+        if (/aider/.test(agentToken))
+            return 'aider';
+        if (/gemini/.test(agentToken))
+            return 'gemini-cli';
+        if (/ollama/.test(agentToken))
+            return 'ollama';
+        return 'other';
+    }
+}
+exports.TrailerParser = TrailerParser;