@minionry/minion 0.7.36

package/dist/server/services/websocket/prompt-queue-handlers.js

@@ -0,0 +1,96 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { scopeExecutionDir } from './handler-context.js';
+import { denyIfViewOnly } from './plan-helpers.js';
+function broadcastPromptQueueSync(ctx, registry, tabId) {
+    ctx.broadcastToAll({
+        type: 'promptQueueSync',
+        tabId,
+        data: { tabId, queue: registry.getPromptQueue(tabId) },
+    });
+}
+export function handleQueueEnqueuePrompt(ctx, _ws, msg, tabId) {
+    const prompt = msg.data?.prompt;
+    if (typeof prompt !== 'string' || !prompt)
+        return;
+    const registry = ctx.getRegistry('');
+    registry.enqueuePrompt(tabId, {
+        prompt,
+        attachments: msg.data?.attachments,
+        meta: msg.data?.meta,
+    });
+    broadcastPromptQueueSync(ctx, registry, tabId);
+}
+export function handleQueueRemovePrompt(ctx, _ws, msg, tabId) {
+    const index = msg.data?.index;
+    if (typeof index !== 'number')
+        return;
+    const registry = ctx.getRegistry('');
+    registry.removeQueuedPrompt(tabId, index);
+    broadcastPromptQueueSync(ctx, registry, tabId);
+}
+export function handleQueueClearPrompts(ctx, _ws, _msg, tabId) {
+    const registry = ctx.getRegistry('');
+    registry.clearPromptQueue(tabId);
+    broadcastPromptQueueSync(ctx, registry, tabId);
+}
+function broadcastComposerQueueSync(ctx, registry, boardId) {
+    ctx.broadcastToAll({
+        type: 'composerPromptQueueSync',
+        data: { boardId, queue: registry.getBoardQueue(boardId).map((item) => ({ prompt: item.prompt })) },
+    });
+}
+const MODEL_WIRE_KEYS = [
+    'modelStrategy', 'engine', 'model', 'effortLevel', 'fastMode',
+    'runModel', 'runEngine', 'runEffortLevel', 'runFastMode',
+];
+function pickModelWireFields(data) {
+    if (!data)
+        return undefined;
+    const picked = {};
+    let found = false;
+    for (const key of MODEL_WIRE_KEYS) {
+        if (key in data) {
+            picked[key] = data[key];
+            found = true;
+        }
+    }
+    return found ? picked : undefined;
+}
+export function handleQueueEnqueueComposerPrompt(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const boardId = msg.data?.boardId;
+    const prompt = msg.data?.prompt;
+    if (typeof boardId !== 'string' || !boardId || typeof prompt !== 'string' || !prompt)
+        return;
+    const registry = ctx.getRegistry(workingDir);
+    const meta = {
+        executionDir: scopeExecutionDir(ctx, boardId),
+        agentTabId: typeof msg.data?.agentTabId === 'string' ? msg.data.agentTabId : undefined,
+        modelData: pickModelWireFields(msg.data),
+    };
+    registry.enqueueBoardPrompt(boardId, { prompt, attachments: msg.data?.attachments, meta });
+    broadcastComposerQueueSync(ctx, registry, boardId);
+}
+export function handleQueueRemoveComposerPrompt(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const boardId = msg.data?.boardId;
+    const index = msg.data?.index;
+    if (typeof boardId !== 'string' || !boardId || typeof index !== 'number')
+        return;
+    const registry = ctx.getRegistry(workingDir);
+    registry.removeBoardQueuedPrompt(boardId, index);
+    broadcastComposerQueueSync(ctx, registry, boardId);
+}
+export function handleQueueClearComposerPrompts(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const boardId = msg.data?.boardId;
+    if (typeof boardId !== 'string' || !boardId)
+        return;
+    const registry = ctx.getRegistry(workingDir);
+    registry.clearBoardQueue(boardId);
+    broadcastComposerQueueSync(ctx, registry, boardId);
+}

package/dist/server/services/websocket/quality-agent-cost.js

@@ -0,0 +1,229 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { promises as fsp } from 'node:fs';
+import { join } from 'node:path';
+import { spacePath } from '../space-layout.js';
+import { movementWrittenFiles } from './movement-written-files.js';
+import { attributeToTrackedDirectories } from './quality-tools.js';
+import { findingCountsTowardGrade, } from './quality-types.js';
+export const MAX_HISTORY_FILES = 200;
+export const MAX_HISTORY_BYTES = 64 * 1024 * 1024;
+export const MIN_TURNS_PER_FILE = 5;
+export const MIN_TURNS_PER_SIDE = 10;
+export const MAX_FILE_ROWS = 100;
+export const AGENT_COST_STRUCTURAL_CATEGORIES = new Set([
+    'complexity',
+    'file-length',
+    'function-length',
+    'architecture',
+    'oop',
+    'maintainability',
+    'duplication',
+]);
+const RUN_LEVEL_BOARD_SESSION = /-pm-(?:BOARD-|run$)/;
+const RECOGNIZED_WRITE_TOOL_ENGINE = 'claude-code';
+export function isRunLevelBoardSession(fileName) {
+    return RUN_LEVEL_BOARD_SESSION.test(fileName.endsWith('.json') ? fileName.slice(0, -'.json'.length) : fileName);
+}
+export async function sampleAgentCost(options) {
+    try {
+        return await sample(options);
+    }
+    catch (error) {
+        return { available: false, reason: `agent-turn history could not be sampled: ${describeError(error, options.spaceRoot)}` };
+    }
+}
+function describeError(error, spaceRoot) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.split(spaceRoot).join('<space>');
+}
+async function sample(options) {
+    const historyDir = spacePath(options.spaceRoot, 'history');
+    let names;
+    try {
+        names = (await fsp.readdir(historyDir)).filter((name) => name.endsWith('.json') && !isRunLevelBoardSession(name));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { available: false, reason: 'no agent-turn history: this Space has no .minionry/history/ directory yet' };
+        }
+        return { available: false, reason: `agent-turn history could not be opened: ${describeError(error, options.spaceRoot)}` };
+    }
+    let unreadableFiles = 0;
+    const stats = await Promise.all(names.map(async (name) => {
+        try {
+            const s = await fsp.stat(join(historyDir, name));
+            return { name, mtimeMs: s.mtimeMs, size: s.size };
+        }
+        catch {
+            unreadableFiles += 1;
+            return null;
+        }
+    }));
+    const { selected, truncated } = selectNewest(stats.filter((s) => s !== null), options.maxFiles ?? MAX_HISTORY_FILES, options.maxBytes ?? MAX_HISTORY_BYTES);
+    const cache = options.persistence.loadAgentCostCache();
+    const fresh = {};
+    const movements = [];
+    for (const file of selected) {
+        const hit = cache[file.name];
+        if (hit && hit.mtimeMs === file.mtimeMs && hit.size === file.size) {
+            fresh[file.name] = hit;
+            movements.push(...hit.movements);
+            continue;
+        }
+        const parsed = await parseHistoryFile(join(historyDir, file.name));
+        if (parsed === null) {
+            unreadableFiles += 1;
+            continue;
+        }
+        fresh[file.name] = { mtimeMs: file.mtimeMs, size: file.size, movements: parsed };
+        movements.push(...parsed);
+    }
+    options.persistence.saveAgentCostCache(fresh);
+    return {
+        available: true,
+        sampledAt: new Date().toISOString(),
+        truncated,
+        unreadableFiles,
+        ...joinAgentCost(movements, options),
+    };
+}
+function selectNewest(files, maxFiles, maxBytes) {
+    const ordered = [...files].sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const selected = [];
+    let bytes = 0;
+    for (const file of ordered) {
+        if (selected.length >= maxFiles || bytes + file.size > maxBytes)
+            return { selected, truncated: true };
+        selected.push(file);
+        bytes += file.size;
+    }
+    return { selected, truncated: false };
+}
+async function parseHistoryFile(path) {
+    let data;
+    try {
+        data = JSON.parse(await fsp.readFile(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    if (typeof data !== 'object' || data === null)
+        return null;
+    const session = data;
+    if (!Array.isArray(session.movements))
+        return null;
+    const sessionEngine = typeof session.engine === 'string' ? session.engine : undefined;
+    return session.movements.map((movement) => reduceMovement(movement, sessionEngine));
+}
+function reduceMovement(movement, sessionEngine) {
+    const m = movement ?? {};
+    const reduced = {
+        engine: typeof m.engine === 'string' ? m.engine : (sessionEngine ?? RECOGNIZED_WRITE_TOOL_ENGINE),
+        toolUses: Array.isArray(m.toolUseHistory) ? m.toolUseHistory.length : 0,
+        written: movementWrittenFiles(m),
+    };
+    if (typeof m.outputTokens === 'number' && Number.isFinite(m.outputTokens))
+        reduced.outputTokens = m.outputTokens;
+    if (typeof m.durationMs === 'number' && Number.isFinite(m.durationMs))
+        reduced.durationMs = m.durationMs;
+    return reduced;
+}
+function placeMovement(m, options) {
+    if (m.written.length === 0) {
+        return m.toolUses > 0 && m.engine !== RECOGNIZED_WRITE_TOOL_ENGINE ? { kind: 'unattributed', reason: 'unknownWriteTools' } : { kind: 'elsewhere' };
+    }
+    if (m.outputTokens === undefined)
+        return { kind: 'unattributed', reason: 'missingOutputTokens' };
+    const attributed = attributeToTrackedDirectories(options.spaceRoot, [{ path: options.reportPath }], m.written);
+    if (attributed.length === 0)
+        return { kind: 'unattributed', reason: 'outsideSpaceRoot' };
+    const mine = attributed.find((entry) => entry.path === options.reportPath);
+    if (!mine)
+        return { kind: 'elsewhere' };
+    const placement = { kind: 'attributed', outputTokens: m.outputTokens, files: [...new Set(mine.files)] };
+    if (m.durationMs !== undefined)
+        placement.durationMs = m.durationMs;
+    return placement;
+}
+function tallyStructuralFiles(turn, structural, perFile) {
+    let touched = false;
+    for (const file of turn.files) {
+        if (!structural.has(file))
+            continue;
+        touched = true;
+        const samples = perFile.get(file) ?? { outputTokens: [], durationMs: [] };
+        samples.outputTokens.push(turn.outputTokens);
+        if (turn.durationMs !== undefined)
+            samples.durationMs.push(turn.durationMs);
+        perFile.set(file, samples);
+    }
+    return touched;
+}
+export function joinAgentCost(movements, options) {
+    const structural = activeStructuralFiles(options.results);
+    const unattributed = { missingOutputTokens: 0, outsideSpaceRoot: 0, unknownWriteTools: 0 };
+    const perFile = new Map();
+    const withStructural = [];
+    const withoutStructural = [];
+    for (const m of movements) {
+        const placed = placeMovement(m, options);
+        if (placed.kind === 'unattributed')
+            unattributed[placed.reason] += 1;
+        if (placed.kind !== 'attributed')
+            continue;
+        (tallyStructuralFiles(placed, structural, perFile) ? withStructural : withoutStructural).push(placed.outputTokens);
+    }
+    return {
+        sampledTurns: movements.length,
+        attributedTurns: withStructural.length + withoutStructural.length,
+        unattributed,
+        files: fileRows(perFile),
+        comparison: {
+            withStructuralFindings: side(withStructural),
+            withoutStructuralFindings: side(withoutStructural),
+        },
+    };
+}
+function activeStructuralFiles(results) {
+    const files = new Set();
+    for (const finding of [...(results.findings ?? []), ...(results.codeReview ?? [])]) {
+        if (!AGENT_COST_STRUCTURAL_CATEGORIES.has(finding.category) || !findingCountsTowardGrade(finding))
+            continue;
+        if (typeof finding.file !== 'string' || finding.file === '')
+            continue;
+        files.add(finding.file.replace(/^\.\//, ''));
+    }
+    return files;
+}
+function fileRows(perFile) {
+    return [...perFile.entries()]
+        .sort(([fileA, a], [fileB, b]) => b.outputTokens.length - a.outputTokens.length || (fileA < fileB ? -1 : fileA > fileB ? 1 : 0))
+        .slice(0, MAX_FILE_ROWS)
+        .map(([file, samples]) => fileRow(file, samples));
+}
+function fileRow(file, samples) {
+    const turns = samples.outputTokens.length;
+    if (turns < MIN_TURNS_PER_FILE)
+        return { file, turns, reason: `${plural(turns, 'turn')}; ${MIN_TURNS_PER_FILE} needed` };
+    const row = { file, turns, medianOutputTokens: median(samples.outputTokens) };
+    if (samples.durationMs.length >= MIN_TURNS_PER_FILE)
+        row.medianDurationMs = median(samples.durationMs);
+    else
+        row.reason = `${plural(samples.durationMs.length, 'turn')} recorded durationMs; ${MIN_TURNS_PER_FILE} needed`;
+    return row;
+}
+function side(outputTokens) {
+    const turns = outputTokens.length;
+    if (turns < MIN_TURNS_PER_SIDE)
+        return { turns, reason: `${plural(turns, 'turn')}; ${MIN_TURNS_PER_SIDE} needed` };
+    return { turns, medianOutputTokens: median(outputTokens) };
+}
+function median(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}

package/dist/server/services/websocket/quality-agent-notes.js

@@ -0,0 +1,113 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { relative, resolve } from 'node:path';
+import { getQualityAgentNotes } from '../settings.js';
+import { movementWrittenFiles } from './movement-written-files.js';
+import { getPersistence } from './quality-handlers.js';
+import { indexDismissals } from './quality-service.js';
+export const QUALITY_NOTE_OPEN = '--- Minionry quality note ---';
+export const QUALITY_NOTE_CLOSE = '--- End quality note ---';
+export const QUALITY_NOTE_MAX_FINDINGS = 10;
+export const QUALITY_NOTE_MAX_CHARS = 1_500;
+export const QUALITY_NOTE_TRANSCRIPT_CODE = 'QUALITY_AGENT_NOTE';
+export const QUALITY_REVIEW_TAB_PREFIX = 'quality-review-';
+const SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
+const MAX_LINE_CHARS = 400;
+const notes = new Map();
+export function isInteractiveAgentTab(session, tabId) {
+    return session.appOrigin === undefined && !tabId.startsWith(QUALITY_REVIEW_TAB_PREFIX);
+}
+export function buildQualityAgentNote(spaceRoot, movement, announced) {
+    const written = new Set(movementWrittenFiles(movement).map((file) => resolve(file)));
+    if (written.size === 0)
+        return null;
+    const candidates = announced.flatMap((change) => noteFindingsOf(spaceRoot, written, change));
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity]);
+    const findings = fitWithinCaps(candidates);
+    return findings.length > 0 ? { spaceRoot, findings } : null;
+}
+function noteFindingsOf(spaceRoot, written, change) {
+    if (change.kind !== 'agentTurn' || change.worktree)
+        return [];
+    const out = [];
+    for (const f of change.results.findings) {
+        if (!qualifies(f))
+            continue;
+        const absolute = resolve(spaceRoot, change.path, f.file);
+        if (!written.has(absolute))
+            continue;
+        out.push({
+            severity: f.severity,
+            path: relative(spaceRoot, absolute),
+            line: f.line,
+            title: f.title,
+            ...(f.suggestion ? { suggestion: f.suggestion } : {}),
+            ...(f.fingerprint !== undefined ? { fingerprint: f.fingerprint } : {}),
+            reportPath: change.path,
+        });
+    }
+    return out;
+}
+function qualifies(f) {
+    return f.introduced === true && f.dismissal === undefined && f.status !== 'likely-fp' && SEVERITY_RANK[f.severity] <= SEVERITY_RANK.medium;
+}
+function fitWithinCaps(sorted) {
+    for (let count = Math.min(sorted.length, QUALITY_NOTE_MAX_FINDINGS); count > 0; count--) {
+        const prefix = sorted.slice(0, count);
+        if (renderQualityAgentNote(prefix).length <= QUALITY_NOTE_MAX_CHARS)
+            return prefix;
+    }
+    return [];
+}
+function renderFindingLine(f) {
+    const location = f.line === null ? f.path : `${f.path}:${f.line}`;
+    const line = [location, f.title, ...(f.suggestion ? [f.suggestion] : [])].join(' — ');
+    return line.length > MAX_LINE_CHARS ? `${line.slice(0, MAX_LINE_CHARS - 1)}…` : line;
+}
+export function renderQualityAgentNote(findings) {
+    const count = findings.length;
+    return [
+        QUALITY_NOTE_OPEN,
+        `The quality scan of your previous turn found ${count} new ${count === 1 ? 'issue' : 'issues'} in files you wrote (paths are relative to the Space root). Fix them in this turn, or say why they are intended:`,
+        ...findings.map((f) => `- ${renderFindingLine(f)}`),
+        QUALITY_NOTE_CLOSE,
+    ].join('\n');
+}
+export function recordQualityAgentNote(tabId, spaceRoot, movement, announced) {
+    const note = buildQualityAgentNote(spaceRoot, movement, announced);
+    if (!note)
+        return null;
+    if (!getQualityAgentNotes())
+        return null;
+    notes.set(tabId, note);
+    return note;
+}
+export function takeQualityAgentNote(tabId) {
+    const note = notes.get(tabId);
+    if (!note)
+        return null;
+    notes.delete(tabId);
+    if (!getQualityAgentNotes())
+        return null;
+    const suppressions = getPersistence(note.spaceRoot).loadSuppressions();
+    const indexes = new Map();
+    const kept = note.findings.filter((f) => {
+        if (f.fingerprint === undefined)
+            return true;
+        let index = indexes.get(f.reportPath);
+        if (!index) {
+            index = indexDismissals(f.reportPath, suppressions);
+            indexes.set(f.reportPath, index);
+        }
+        return !index.has(f.fingerprint);
+    });
+    return kept.length > 0 ? renderQualityAgentNote(kept) : null;
+}
+export function peekQualityAgentNote(tabId) {
+    return notes.get(tabId);
+}
+export function resetQualityAgentNotes() {
+    notes.clear();
+}

package/dist/server/services/websocket/quality-change-activity.js

@@ -0,0 +1,187 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { executeGitCommand } from '../git/command.js';
+import { unquoteGitPath } from '../git/parsers.js';
+import { findingCountsTowardGrade, } from './quality-types.js';
+export const CHANGE_ACTIVITY_WINDOW_DAYS = 90;
+export const CHANGE_ACTIVITY_COMMIT_CAP = 2_000;
+export const CHANGE_ACTIVITY_MOST_CHANGED_FILES = 50;
+const GIT_OPTIONS = {
+    timeoutMs: 60_000,
+    maxOutputBytes: 64 * 1024 * 1024,
+    env: { GIT_OPTIONAL_LOCKS: '0' },
+};
+const COMMIT_MARKER = '\0';
+export const GIT_LOG_ARGV = Object.freeze([
+    '-c',
+    'core.quotePath=true',
+    'log',
+    '--numstat',
+    '--no-renames',
+    '--format=%x00%H%x00%cI',
+    `--since=${CHANGE_ACTIVITY_WINDOW_DAYS}.days.ago`,
+    `--max-count=${CHANGE_ACTIVITY_COMMIT_CAP + 1}`,
+    '--',
+    '.',
+]);
+const GIT_PREFIX_ARGV = Object.freeze(['rev-parse', '--is-inside-work-tree', '--show-prefix']);
+const GIT_HEAD_ARGV = Object.freeze(['rev-parse', 'HEAD', '--abbrev-ref', 'HEAD']);
+const GIT_STATUS_ARGV = Object.freeze(['status', '--porcelain', '--untracked-files=normal', '--', '.']);
+const NUMSTAT_LINE = /^(\d+|-)\t(\d+|-)\t(.+)$/;
+const OBJECT_NAME = /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/;
+export async function sampleChangeActivity(options) {
+    try {
+        return await sample(options);
+    }
+    catch (error) {
+        return { changeActivity: unavailable(`change activity could not be sampled: ${describeError(error, options.dirPath)}`) };
+    }
+}
+function unavailable(reason) {
+    return { available: false, reason, windowDays: CHANGE_ACTIVITY_WINDOW_DAYS, commitsScanned: 0, truncated: false, files: {} };
+}
+async function sample(options) {
+    const { dirPath } = options;
+    const located = await executeGitCommand([...GIT_PREFIX_ARGV], dirPath, GIT_OPTIONS);
+    if (isGitMissing(located))
+        return { changeActivity: unavailable('git is not on PATH') };
+    if (located.exitCode !== 0) {
+        const reason = /not a git repository/i.test(located.stderr) ? 'not inside a git work tree' : `git rev-parse failed: ${firstLine(located.stderr) || `exit code ${located.exitCode}`}`;
+        return { changeActivity: unavailable(redact(reason, dirPath)) };
+    }
+    const [insideWorkTree = '', prefix = ''] = located.stdout.split('\n').map((line) => line.trim());
+    if (insideWorkTree !== 'true')
+        return { changeActivity: unavailable('not inside a git work tree') };
+    const [log, head, status] = await Promise.all([
+        executeGitCommand([...GIT_LOG_ARGV], dirPath, GIT_OPTIONS),
+        executeGitCommand([...GIT_HEAD_ARGV], dirPath, GIT_OPTIONS),
+        executeGitCommand([...GIT_STATUS_ARGV], dirPath, GIT_OPTIONS),
+    ]);
+    const commit = toCommitRef(head, status);
+    if (log.exitCode !== 0) {
+        return {
+            changeActivity: unavailable(redact(`git log failed: ${firstLine(log.stderr) || `exit code ${log.exitCode}`}`, dirPath)),
+            ...(commit ? { commit } : {}),
+        };
+    }
+    const parsed = parseGitLogNumstat(log.stdout, prefix);
+    return {
+        changeActivity: {
+            available: true,
+            windowDays: CHANGE_ACTIVITY_WINDOW_DAYS,
+            commitsScanned: parsed.commitsScanned,
+            truncated: parsed.truncated,
+            files: selectChangeActivityFiles(parsed.files, options.results),
+        },
+        ...(commit ? { commit } : {}),
+    };
+}
+function isGitMissing(result) {
+    return result.exitCode !== 0 && result.stdout === '' && /\bENOENT\b/.test(result.stderr);
+}
+function toCommitRef(head, status) {
+    if (head.exitCode !== 0 || status.exitCode !== 0)
+        return undefined;
+    const [sha = '', branch = ''] = head.stdout.split('\n').map((line) => line.trim());
+    if (!OBJECT_NAME.test(sha) || branch === '')
+        return undefined;
+    return { sha, branch, dirty: status.stdout.trim() !== '' };
+}
+function firstLine(text) {
+    return text.split('\n')[0]?.trim() ?? '';
+}
+function redact(text, dirPath) {
+    return text.split(dirPath).join('<directory>');
+}
+function describeError(error, dirPath) {
+    return redact(error instanceof Error ? error.message : String(error), dirPath);
+}
+export function parseGitLogNumstat(stdout, prefix) {
+    const dirPrefix = normalizePrefix(prefix);
+    const tallies = new Map();
+    let commitsScanned = 0;
+    let truncated = false;
+    let current = null;
+    for (const line of stdout.split('\n')) {
+        if (line.startsWith(COMMIT_MARKER)) {
+            if (commitsScanned >= CHANGE_ACTIVITY_COMMIT_CAP) {
+                truncated = true;
+                break;
+            }
+            commitsScanned += 1;
+            current = commitDate(line.split(COMMIT_MARKER)[2] ?? '');
+        }
+        else if (current !== null && line !== '') {
+            tallyNumstatLine(line, current, dirPrefix, tallies);
+        }
+    }
+    const files = {};
+    for (const [file, { commits, linesChanged, lastChangedAt }] of tallies)
+        files[file] = { commits, linesChanged, lastChangedAt };
+    return { commitsScanned, truncated, files };
+}
+function tallyNumstatLine(line, current, dirPrefix, tallies) {
+    const match = NUMSTAT_LINE.exec(line);
+    if (!match)
+        return;
+    const file = directoryRelative(decodeNumstatPath(match[3]), dirPrefix);
+    if (file === null)
+        return;
+    const linesChanged = numstatCount(match[1]) + numstatCount(match[2]);
+    const tally = tallies.get(file);
+    if (!tally) {
+        tallies.set(file, { commits: 1, linesChanged, lastChangedAt: current.at, lastChangedMs: current.atMs });
+        return;
+    }
+    tally.commits += 1;
+    tally.linesChanged += linesChanged;
+    if (current.atMs > tally.lastChangedMs) {
+        tally.lastChangedAt = current.at;
+        tally.lastChangedMs = current.atMs;
+    }
+}
+function normalizePrefix(prefix) {
+    const trimmed = prefix.trim().replace(/\/+$/, '');
+    return trimmed === '' ? '' : `${trimmed}/`;
+}
+function commitDate(raw) {
+    const atMs = Date.parse(raw);
+    return Number.isFinite(atMs) ? { at: new Date(atMs).toISOString(), atMs } : { at: raw, atMs: Number.NEGATIVE_INFINITY };
+}
+function numstatCount(field) {
+    return field === '-' ? 0 : Number(field);
+}
+function decodeNumstatPath(raw) {
+    if (!raw.startsWith('"'))
+        return raw;
+    return Buffer.from(unquoteGitPath(raw), 'latin1').toString('utf8');
+}
+function directoryRelative(repoRelative, dirPrefix) {
+    if (dirPrefix === '')
+        return repoRelative === '' ? null : repoRelative;
+    if (!repoRelative.startsWith(dirPrefix))
+        return null;
+    const relative = repoRelative.slice(dirPrefix.length);
+    return relative === '' ? null : relative;
+}
+export function selectChangeActivityFiles(files, results) {
+    const active = activeFindingFiles(results);
+    const ranked = Object.entries(files).sort(([fileA, a], [fileB, b]) => b.commits - a.commits || b.linesChanged - a.linesChanged || (fileA < fileB ? -1 : fileA > fileB ? 1 : 0));
+    const selected = {};
+    ranked.forEach(([file, row], index) => {
+        if (index < CHANGE_ACTIVITY_MOST_CHANGED_FILES || active.has(file))
+            selected[file] = row;
+    });
+    return selected;
+}
+function activeFindingFiles(results) {
+    const files = new Set();
+    for (const finding of [...(results.findings ?? []), ...(results.codeReview ?? [])]) {
+        if (!findingCountsTowardGrade(finding))
+            continue;
+        if (typeof finding.file !== 'string' || finding.file === '')
+            continue;
+        files.add(finding.file.replace(/^\.\//, ''));
+    }
+    return files;
+}