@devtrace-ai/cli 1.0.0

package/dist/core/survival.js

@@ -0,0 +1,400 @@
+"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.computeSurvival = computeSurvival;
+exports.survivalRateFor = survivalRateFor;
+exports.computeWindowedSurvival = computeWindowedSurvival;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const DEFAULT_MAX_FILE_BYTES = 1024 * 1024; // 1MB
+const DEFAULT_MAX_FILE_LINES = 20000;
+/**
+ * Pass 2 of the retroactive scan: blame HEAD once per file (not once per commit-per-file),
+ * and reverse-attribute every surviving line back to the commit that introduced it.
+ * O(files-alive-at-HEAD) git-blame invocations, amortized across every window commit that
+ * touched those files — see docs/plans/04-architecture-audit-build-plan.md §2.3.
+ */
+async function computeSurvival(touchedFiles, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    const maxFileLines = options.maxFileLines ?? DEFAULT_MAX_FILE_LINES;
+    const concurrency = Math.max(1, Math.min(options.concurrency ?? os.cpus().length, 8));
+    const timeBudgetMs = options.timeBudgetMs ?? Infinity;
+    const ignoreFilter = options.ignoreFilter;
+    const startTime = Date.now();
+    const survivingLines = new Map();
+    const skippedFiles = [];
+    // De-dupe and filter to files that still exist at HEAD (working tree == HEAD is assumed
+    // for a clean checkout; we read from disk since that's what's actually blame-able).
+    const uniqueFiles = Array.from(new Set(touchedFiles));
+    const candidateFiles = [];
+    for (const file of uniqueFiles) {
+        if (ignoreFilter && ignoreFilter.shouldIgnore(file))
+            continue;
+        const absPath = path.join(cwd, file);
+        let stat;
+        try {
+            stat = fs.statSync(absPath);
+        }
+        catch {
+            continue; // file no longer exists at HEAD — nothing to blame
+        }
+        if (!stat.isFile())
+            continue;
+        if (stat.size > maxFileBytes) {
+            skippedFiles.push(file);
+            continue;
+        }
+        candidateFiles.push(file);
+    }
+    let filesBlamed = 0;
+    let cursor = 0;
+    const totalFiles = candidateFiles.length;
+    async function worker() {
+        while (cursor < candidateFiles.length) {
+            if (Date.now() - startTime > timeBudgetMs) {
+                // Budget exhausted — mark all remaining candidates as skipped (unknown survival).
+                while (cursor < candidateFiles.length) {
+                    skippedFiles.push(candidateFiles[cursor]);
+                    cursor++;
+                }
+                return;
+            }
+            const idx = cursor++;
+            const file = candidateFiles[idx];
+            const lineCount = countLinesQuick(path.join(cwd, file), maxFileLines);
+            if (lineCount === null) {
+                skippedFiles.push(file);
+            }
+            else {
+                const perCommit = await blameFile(file, 'HEAD', cwd);
+                if (perCommit === null) {
+                    skippedFiles.push(file);
+                }
+                else {
+                    for (const [hash, count] of perCommit.entries()) {
+                        survivingLines.set(hash, (survivingLines.get(hash) || 0) + count);
+                    }
+                }
+            }
+            filesBlamed++;
+            if (options.onProgress) {
+                options.onProgress(filesBlamed, totalFiles);
+            }
+        }
+    }
+    const workers = Array.from({ length: Math.min(concurrency, Math.max(1, candidateFiles.length)) }, () => worker());
+    await Promise.all(workers);
+    return {
+        survivingLines,
+        skippedFiles,
+        filesBlamed,
+        filesSkipped: skippedFiles.length
+    };
+}
+/**
+ * Returns the file's line count, or null if it exceeds maxFileLines (size guard).
+ * Cheap synchronous read — files are already size-bounded by maxFileBytes before this runs.
+ */
+function countLinesQuick(absPath, maxFileLines) {
+    try {
+        const content = fs.readFileSync(absPath, 'utf8');
+        // Guard against pathological single-line minified files too: count newlines, cap early.
+        let lines = 1;
+        for (let i = 0; i < content.length; i++) {
+            if (content.charCodeAt(i) === 10) {
+                lines++;
+                if (lines > maxFileLines)
+                    return null;
+            }
+        }
+        return lines;
+    }
+    catch {
+        return null; // unreadable (e.g. binary with invalid utf8, permissions) — skip
+    }
+}
+/**
+ * Runs `git blame --line-porcelain <ref> -- <file>` and returns a Map<commitHash, lineCount>
+ * for that single file, parsing porcelain groups properly: a new attribution group starts
+ * with a line matching `^<40-or-64-hex-hash> <origLine> <finalLine>(?: <numLines>)?$`, and
+ * every subsequent line up to and including the tab-prefixed content line belongs to that
+ * group's commit. This is NOT a naive "line startsWith(hash)" prefix match — commit hash
+ * only appears once per group, with content lines following it via metadata, not repetition.
+ *
+ * `ref` may be any git-ish (HEAD or a specific boundary commit hash) so this can be reused
+ * for both HEAD survival and windowed (commit+30d) survival against the same file.
+ */
+function blameFile(file, ref, cwd) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)('git', ['blame', '--line-porcelain', ref, '--', file], {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let buffer = '';
+        let stderr = '';
+        const counts = new Map();
+        let currentHash = null;
+        const commitLineRe = /^([0-9a-f]{40}|[0-9a-f]{64}) (\d+) (\d+)(?: (\d+))?$/;
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (data) => {
+            buffer += data;
+            let nlIdx;
+            while ((nlIdx = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.substring(0, nlIdx);
+                buffer = buffer.substring(nlIdx + 1);
+                processLine(line);
+            }
+        });
+        function processLine(line) {
+            if (line.length === 0)
+                return;
+            if (line[0] === '\t') {
+                // Content line — closes the current group. Attribute exactly one line to currentHash.
+                if (currentHash) {
+                    counts.set(currentHash, (counts.get(currentHash) || 0) + 1);
+                }
+                return;
+            }
+            const commitMatch = commitLineRe.exec(line);
+            if (commitMatch) {
+                currentHash = commitMatch[1];
+                return;
+            }
+            // Otherwise it's a metadata line (author, author-mail, summary, previous, filename, etc.)
+            // belonging to the current group — no action needed, we only care about the content line.
+        }
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (data) => {
+            stderr += data;
+        });
+        child.on('error', () => resolve(null));
+        child.on('close', (code) => {
+            if (buffer.length > 0) {
+                processLine(buffer);
+            }
+            if (code !== 0) {
+                resolve(null); // e.g. file not tracked at HEAD, or blame failure — treat as unknown
+                return;
+            }
+            resolve(counts);
+        });
+    });
+}
+/**
+ * survivalRate(C) = survivingLines[C] / insertions(C), capped at 1.0.
+ * Returns null (unknown) when the commit's insertions were 0 (nothing to measure) — callers
+ * should distinguish this from a genuine 0 survival rate.
+ */
+function survivalRateFor(survivingLines, insertions) {
+    if (insertions <= 0)
+        return null;
+    return Math.min(1.0, survivingLines / insertions);
+}
+const WINDOW_DAYS = 30;
+const WINDOW_MS = WINDOW_DAYS * 24 * 60 * 60 * 1000;
+/**
+ * Windowed 30-day survival (T1.1): for each commit old enough to have a full 30-day window,
+ * blame the (file, boundary-commit) pair at the last commit within [C.date, C.date+30d] —
+ * NOT always HEAD — and reverse-attribute surviving lines the same way computeSurvival does.
+ * Commits younger than 30 days are 'window-open' (never a fabricated false/0). Commits that hit
+ * a size guard or the time budget are 'unknown', never silently coerced to 0.
+ *
+ * Perf: (file, boundary) blame pairs are cached and computed at most once even when many
+ * commits resolve to the same boundary commit (common for repos with sparse commit cadence),
+ * reusing the same bounded concurrency pool and time budget as computeSurvival.
+ */
+async function computeWindowedSurvival(commits, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    const maxFileLines = options.maxFileLines ?? DEFAULT_MAX_FILE_LINES;
+    const concurrency = Math.max(1, Math.min(options.concurrency ?? os.cpus().length, 8));
+    const timeBudgetMs = options.timeBudgetMs ?? Infinity;
+    const now = options.now ?? Date.now();
+    const startTime = Date.now();
+    const survival30d = new Map();
+    // Step 1: classify each commit as window-open (too young) or eligible, and resolve the
+    // boundary commit (last commit at or before C.date + 30d) for eligible ones. Boundary
+    // resolution is one cheap `git rev-list` per commit (not per file) — negligible next to blame.
+    const boundaryByCommit = new Map(); // commitHash -> boundary hash | null (resolution failed -> unknown)
+    const eligible = [];
+    for (const c of commits) {
+        const commitTime = new Date(c.authorDate).getTime();
+        if (isNaN(commitTime) || now - commitTime < WINDOW_MS) {
+            survival30d.set(c.commitHash, { status: 'window-open' });
+            continue;
+        }
+        eligible.push(c);
+        const boundaryDate = new Date(commitTime + WINDOW_MS).toISOString();
+        const boundary = resolveBoundaryCommit(boundaryDate, cwd);
+        boundaryByCommit.set(c.commitHash, boundary);
+        if (boundary === null) {
+            survival30d.set(c.commitHash, { status: 'unknown' });
+        }
+    }
+    const measurable = eligible.filter(c => boundaryByCommit.get(c.commitHash) !== null);
+    if (measurable.length === 0) {
+        return { survival30d };
+    }
+    const pairSurviving = new Map();
+    const pairsToBlame = [];
+    const seenPairs = new Set();
+    for (const c of measurable) {
+        const boundary = boundaryByCommit.get(c.commitHash);
+        for (const file of c.files) {
+            const key = `${boundary}${file}`;
+            if (seenPairs.has(key))
+                continue;
+            seenPairs.add(key);
+            pairsToBlame.push({ key, boundary, file });
+        }
+    }
+    let blamed = 0;
+    let cursor = 0;
+    const total = pairsToBlame.length;
+    async function worker() {
+        while (cursor < pairsToBlame.length) {
+            if (Date.now() - startTime > timeBudgetMs) {
+                while (cursor < pairsToBlame.length) {
+                    const { key } = pairsToBlame[cursor];
+                    pairSurviving.set(key, 'unknown');
+                    cursor++;
+                }
+                return;
+            }
+            const idx = cursor++;
+            const { key, boundary, file } = pairsToBlame[idx];
+            const lineCount = countLinesAtRefQuick(file, boundary, cwd, maxFileBytes, maxFileLines);
+            if (lineCount === null) {
+                pairSurviving.set(key, 'unknown');
+            }
+            else {
+                const perCommit = await blameFile(file, boundary, cwd);
+                pairSurviving.set(key, perCommit === null ? 'unknown' : perCommit);
+            }
+            blamed++;
+            if (options.onProgress) {
+                options.onProgress(blamed, total);
+            }
+        }
+    }
+    const workers = Array.from({ length: Math.min(concurrency, Math.max(1, pairsToBlame.length)) }, () => worker());
+    await Promise.all(workers);
+    // Step 3: aggregate per commit from its (boundary, file) pairs' cached blame results.
+    for (const c of measurable) {
+        const boundary = boundaryByCommit.get(c.commitHash);
+        let surviving = 0;
+        let anyUnknown = false;
+        for (const file of c.files) {
+            const key = `${boundary}${file}`;
+            const result = pairSurviving.get(key);
+            if (result === undefined || result === 'unknown') {
+                anyUnknown = true;
+                continue;
+            }
+            surviving += result.get(c.commitHash) || 0;
+        }
+        if (anyUnknown) {
+            // If the time budget was hit, degrade to unknown rather than silently understating
+            // survival from only the files that did get blamed.
+            survival30d.set(c.commitHash, { status: 'unknown' });
+            continue;
+        }
+        const rate = survivalRateFor(surviving, c.insertions);
+        survival30d.set(c.commitHash, rate === null ? { status: 'unknown' } : { status: 'measured', rate });
+    }
+    return { survival30d };
+}
+/**
+ * Resolves the boundary commit for a windowed measurement: the last commit at or before
+ * `beforeDateIso` (i.e. "closest to C+30d without going over"), reachable from HEAD.
+ * Returns null if resolution fails (e.g. shallow clone missing history) — callers must
+ * treat that as 'unknown', never fabricate a survival number.
+ */
+function resolveBoundaryCommit(beforeDateIso, cwd) {
+    try {
+        const result = (0, child_process_1.spawnSync)('git', ['rev-list', '-1', `--before=${beforeDateIso}`, 'HEAD'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        if (result.status !== 0)
+            return null;
+        const hash = result.stdout.trim();
+        return hash.length > 0 ? hash : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Size-guard check for a file *as it existed at `ref`* (not the working tree — the boundary
+ * commit is generally not HEAD, so we must read git object size/content, not disk state).
+ * Returns the line count, or null if the file doesn't exist at ref, exceeds the byte/line
+ * guard, or is otherwise unreadable (binary, etc.).
+ */
+function countLinesAtRefQuick(file, ref, cwd, maxFileBytes, maxFileLines) {
+    try {
+        const sizeResult = (0, child_process_1.spawnSync)('git', ['cat-file', '-s', `${ref}:${file}`], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        if (sizeResult.status !== 0)
+            return null; // file doesn't exist at this ref
+        const size = parseInt(sizeResult.stdout.trim(), 10);
+        if (isNaN(size) || size > maxFileBytes)
+            return null;
+        const contentResult = (0, child_process_1.spawnSync)('git', ['show', `${ref}:${file}`], {
+            cwd,
+            encoding: 'utf8',
+            maxBuffer: maxFileBytes + 1024,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        if (contentResult.status !== 0)
+            return null;
+        const content = contentResult.stdout;
+        let lines = 1;
+        for (let i = 0; i < content.length; i++) {
+            if (content.charCodeAt(i) === 10) {
+                lines++;
+                if (lines > maxFileLines)
+                    return null;
+            }
+        }
+        return lines;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/detector.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIDetector = void 0;
+const git_1 = require("./git");
+const trailers_1 = require("./capture/trailers");
+// Heuristic (tier 3) signals are weak priors, never proof. Each contributes at most
+// this much confidence individually, and the tier as a whole is capped well below
+// the trailer-confirmed floor so it can never be mistaken for a confirmed detection.
+const HEURISTIC_SIGNAL_CAP = 0.25;
+const HEURISTIC_TIER_CAP = 0.5;
+const TRAILER_CONFIDENCE = 0.95;
+const UNKNOWN_MAX_CONFIDENCE = 0.3;
+class AIDetector {
+    /**
+     * Evaluates whether a commit shows AI provenance, tier-first:
+     *   Tier 1 (confirmed): any commit-trailer match from TrailerParser — fact, not inference.
+     *   Tier 3 (heuristic): velocity/greenfield diff-shape priors, demoted and capped.
+     *   Tier 0 (unknown): no evidence — reported with LOW confidence (this used to be
+     *     inverted into a fabricated 1.0 "confidence it's human"; see reasons below for the fix).
+     */
+    static detect(commitHash, diff, cwd = process.cwd()) {
+        const reasons = [];
+        const metadata = git_1.GitTracker.getCommitMetadata(commitHash, cwd);
+        const commitMsg = metadata.message;
+        // --- Tier 1: confirmed trailer match(es) ---
+        const trailerMatches = trailers_1.TrailerParser.parse(commitMsg, metadata.author);
+        if (trailerMatches.length > 0) {
+            const primary = trailerMatches[0];
+            for (const match of trailerMatches) {
+                const suffix = match.model ? ` (model: ${match.model})` : '';
+                reasons.push(`${match.pattern}${match.unverified ? ' [unverified-pattern]' : ''}${suffix}`);
+            }
+            return {
+                tool: primary.tool,
+                confidence: TRAILER_CONFIDENCE,
+                tier: 1,
+                reasons
+            };
+        }
+        // --- Tier 3: heuristic weak priors (git-only signals; never proof) ---
+        let heuristicScore = 0;
+        let heuristicFired = false;
+        // Velocity heuristic: commit landed <45s after its parent with >20 lines changed.
+        // Weak in both directions — false positives on --amend/squash/typo commits, false
+        // negatives on careful AI sessions, and rebases rewrite the timestamps it depends on.
+        try {
+            const parentHash = git_1.GitTracker.resolveRef(`${commitHash}~1`, cwd);
+            if (parentHash) {
+                const parentMetadata = git_1.GitTracker.getCommitMetadata(parentHash, cwd);
+                const commitTime = new Date(metadata.timestamp).getTime();
+                const parentTime = new Date(parentMetadata.timestamp).getTime();
+                const diffSeconds = (commitTime - parentTime) / 1000;
+                if (diffSeconds > 0 && diffSeconds < 45) {
+                    const linesChanged = diff.totalInsertions + diff.totalDeletions;
+                    if (linesChanged > 20) {
+                        heuristicFired = true;
+                        heuristicScore += Math.min(HEURISTIC_SIGNAL_CAP, 0.2);
+                        reasons.push(`heuristic:velocity (${diffSeconds.toFixed(1)}s < 45s threshold, ${linesChanged} lines changed)`);
+                    }
+                }
+            }
+        }
+        catch {
+            // No parent (initial commit) — velocity heuristic doesn't apply.
+        }
+        // Greenfield density heuristic: large insert-only diffs are typical of AI initial dumps,
+        // but equally typical of vendored code drops, generated files, or human scaffolding.
+        if (diff.totalInsertions > 150 && diff.totalDeletions === 0) {
+            heuristicFired = true;
+            heuristicScore += Math.min(HEURISTIC_SIGNAL_CAP, 0.2);
+            reasons.push(`heuristic:greenfield (${diff.totalInsertions} insertions, 0 deletions)`);
+        }
+        if (heuristicFired) {
+            const confidence = Math.min(HEURISTIC_TIER_CAP, heuristicScore);
+            return {
+                tool: 'unknown-ai',
+                confidence,
+                tier: 3,
+                reasons
+            };
+        }
+        // --- Tier 0: no evidence. Honest low confidence — NOT a fabricated 1.0 "human" score. ---
+        reasons.push('tier0:no-signal');
+        return {
+            tool: 'none',
+            confidence: UNKNOWN_MAX_CONFIDENCE,
+            tier: 0,
+            reasons
+        };
+    }
+}
+exports.AIDetector = AIDetector;

package/dist/digest.js

@@ -0,0 +1,183 @@
+"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.parseSinceDays = parseSinceDays;
+exports.buildDigest = buildDigest;
+exports.writeDigestMarkdown = writeDigestMarkdown;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const html_report_1 = require("./html_report");
+function weightedSurvivalRate(sessions) {
+    let totalInsertions = 0;
+    let totalSurviving = 0;
+    let anyKnown = false;
+    for (const s of sessions) {
+        if (!s.churn || s.diff.totalInsertions <= 0)
+            continue;
+        anyKnown = true;
+        totalInsertions += s.diff.totalInsertions;
+        totalSurviving += s.diff.totalInsertions * s.churn.survivalRate;
+    }
+    if (!anyKnown || totalInsertions === 0)
+        return null;
+    return totalSurviving / totalInsertions;
+}
+/** Parses `--since <n>d` style args into a day count. Defaults to 7. */
+function parseSinceDays(sinceArg) {
+    if (!sinceArg)
+        return 7;
+    const m = /^(\d+)d$/.exec(sinceArg);
+    if (m)
+        return parseInt(m[1], 10);
+    const n = parseInt(sinceArg, 10);
+    return Number.isFinite(n) && n > 0 ? n : 7;
+}
+/**
+ * Builds the terminal + markdown digest for the last N days: new commits captured, AI share,
+ * survival movements, and newly-measured 30-day windows. Honest "no data" when the window is empty.
+ */
+function buildDigest(sessions, days, now = new Date()) {
+    const cutoff = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
+    const windowSessions = sessions.filter(s => {
+        const t = new Date(s.timestamp);
+        return !isNaN(t.getTime()) && t >= cutoff && t <= now;
+    });
+    const lines = [];
+    const md = [];
+    const header = `DevTrace digest — last ${days} day${days === 1 ? '' : 's'}`;
+    lines.push(header);
+    lines.push('='.repeat(header.length));
+    md.push(`# ${header}`, '');
+    md.push(`_Generated ${now.toISOString()}_`, '');
+    if (windowSessions.length === 0) {
+        const msg = 'No commits captured in this window.';
+        lines.push('', msg);
+        md.push(msg, '');
+        return { markdown: md.join('\n'), text: lines.join('\n'), windowSessions };
+    }
+    const aiSessions = windowSessions.filter(s => s.aiTool !== 'none');
+    const humanSessions = windowSessions.filter(s => s.aiTool === 'none');
+    const aiSharePct = ((aiSessions.length / windowSessions.length) * 100).toFixed(0);
+    lines.push('', `New commits captured: ${windowSessions.length}`);
+    lines.push(`  AI-authored: ${aiSessions.length} (${aiSharePct}%)`);
+    lines.push(`  Human-authored: ${humanSessions.length}`);
+    md.push(`## New commits captured`, '');
+    md.push(`- Total: ${windowSessions.length}`);
+    md.push(`- AI-authored: ${aiSessions.length} (${aiSharePct}%)`);
+    md.push(`- Human-authored: ${humanSessions.length}`, '');
+    // By-tool breakdown within the window
+    const byTool = new Map();
+    for (const s of aiSessions) {
+        if (!byTool.has(s.aiTool))
+            byTool.set(s.aiTool, []);
+        byTool.get(s.aiTool).push(s);
+    }
+    if (byTool.size > 0) {
+        lines.push('', 'By tool:');
+        md.push(`## By tool`, '');
+        for (const [tool, toolSessions] of byTool.entries()) {
+            const rate = weightedSurvivalRate(toolSessions);
+            const rateText = rate === null ? 'unknown' : `${(rate * 100).toFixed(0)}%`;
+            lines.push(`  ${(0, html_report_1.toolLabel)(tool)}: ${toolSessions.length} commit(s), survival ${rateText}`);
+            md.push(`- **${(0, html_report_1.toolLabel)(tool)}**: ${toolSessions.length} commit(s), survival ${rateText}`);
+        }
+        md.push('');
+    }
+    // Survival movement: compare AI survival rate of window commits vs. the rest of history.
+    const restSessions = sessions.filter(s => !windowSessions.includes(s) && s.aiTool !== 'none');
+    const windowAiSurvival = weightedSurvivalRate(aiSessions);
+    const restAiSurvival = weightedSurvivalRate(restSessions);
+    lines.push('', 'Survival movement:');
+    md.push(`## Survival movement`, '');
+    if (windowAiSurvival === null) {
+        lines.push('  AI survival (this window): unknown (no churn data yet)');
+        md.push(`- AI survival (this window): unknown (no churn data yet)`);
+    }
+    else {
+        lines.push(`  AI survival (this window): ${(windowAiSurvival * 100).toFixed(0)}%`);
+        md.push(`- AI survival (this window): ${(windowAiSurvival * 100).toFixed(0)}%`);
+    }
+    if (restAiSurvival === null) {
+        lines.push('  AI survival (prior history): unknown (no baseline yet)');
+        md.push(`- AI survival (prior history): unknown (no baseline yet)`);
+    }
+    else {
+        lines.push(`  AI survival (prior history): ${(restAiSurvival * 100).toFixed(0)}%`);
+        md.push(`- AI survival (prior history): ${(restAiSurvival * 100).toFixed(0)}%`);
+    }
+    if (windowAiSurvival !== null && restAiSurvival !== null) {
+        const delta = (windowAiSurvival - restAiSurvival) * 100;
+        const dir = delta > 0 ? 'up' : delta < 0 ? 'down' : 'flat';
+        lines.push(`  Movement: ${dir} ${Math.abs(delta).toFixed(0)}pp`);
+        md.push(`- Movement: ${dir} ${Math.abs(delta).toFixed(0)}pp`);
+    }
+    md.push('');
+    // Newly-measured 30-day windows: sessions whose survival30d is 'measured' AND whose
+    // originating commit falls in-window OR whose measurement crossed into 'measured' recently.
+    // We only have current state (no history of prior digest runs), so we report commits in the
+    // window that now have a measured 30d verdict — an honest proxy for "newly measured."
+    const newlyMeasured = windowSessions.filter(s => s.churn?.survival30d?.status === 'measured');
+    lines.push('', `Newly-measured 30-day windows: ${newlyMeasured.length}`);
+    md.push(`## Newly-measured 30-day windows`, '');
+    if (newlyMeasured.length === 0) {
+        lines.push('  None this window.');
+        md.push('None this window.');
+    }
+    else {
+        md.push(`| Commit | Date | Tool | Survival (30d) |`);
+        md.push(`| :--- | :--- | :--- | :---: |`);
+        for (const s of newlyMeasured) {
+            const w = s.churn.survival30d;
+            const hash = s.commitHash.substring(0, 8);
+            const date = s.timestamp.substring(0, 10);
+            lines.push(`  ${hash}  ${date}  ${(0, html_report_1.toolLabel)(s.aiTool)}  ${(w.rate * 100).toFixed(0)}%`);
+            md.push(`| \`${hash}\` | ${date} | ${(0, html_report_1.toolLabel)(s.aiTool)} | ${(w.rate * 100).toFixed(0)}% |`);
+        }
+    }
+    md.push('');
+    return { markdown: md.join('\n'), text: lines.join('\n'), windowSessions };
+}
+/** Writes the digest markdown to `.devtrace/digest.md` and returns the absolute path. */
+function writeDigestMarkdown(markdown, projectDir) {
+    const config = config_1.ConfigManager.loadConfig(projectDir);
+    const storageDir = path.join(projectDir, config.storageDir);
+    if (!fs.existsSync(storageDir)) {
+        fs.mkdirSync(storageDir, { recursive: true });
+    }
+    const target = path.join(storageDir, 'digest.md');
+    fs.writeFileSync(target, markdown, 'utf8');
+    return target;
+}