peaks-loop 3.0.0

package/dist/src/services/scan/diff-scope-service.d.ts

@@ -0,0 +1,40 @@
+export type ScopePattern = {
+    raw: string;
+    regex: RegExp;
+    line: number;
+};
+export type FileClassification = 'in-scope' | 'out-of-scope-violation' | 'unclassified' | 'auto-allowed';
+export type ClassifiedFile = {
+    path: string;
+    classification: FileClassification;
+    matchedPattern?: string;
+    reason: string;
+};
+export type DiffScopeReport = {
+    ok: boolean;
+    rdArtifactPath: string;
+    inScopePatterns: ScopePattern[];
+    outOfScopePatterns: ScopePattern[];
+    changedFiles: ClassifiedFile[];
+    violations: ClassifiedFile[];
+    unclassified: ClassifiedFile[];
+    gitAvailable: boolean;
+    patternsDeclared: boolean;
+};
+export type DiffScopeError = {
+    kind: 'rd-not-found';
+};
+export type DiffScopeOptions = {
+    projectRoot: string;
+    requestId: string;
+    sessionId?: string;
+    baseRef?: string;
+};
+/**
+ * Convert a simple glob pattern to a regex.
+ * Supports `**` (any path including separators), `*` (one path segment), `?` (single char).
+ * Leading `/` is removed; matching is relative to project root.
+ */
+export declare function globToRegex(pattern: string): RegExp;
+export declare function getDiffVsScope(options: DiffScopeOptions): Promise<DiffScopeReport | DiffScopeError>;
+export declare function isDiffScopeError(value: DiffScopeReport | DiffScopeError): value is DiffScopeError;

package/dist/src/services/scan/diff-scope-service.js

@@ -0,0 +1,198 @@
+import { execFileSync } from 'node:child_process';
+import { showRequestArtifact } from '../artifacts/request-artifact-service.js';
+const RED_LINE_HEADER = /^##\s+Red-line scope\s*$/;
+const IN_SCOPE_SUBHEADER = /^(?:###?\s+)?(?:in[- ]scope|scope|allowed):\s*$/i;
+const OUT_OF_SCOPE_SUBHEADER = /^(?:###?\s+)?(?:out[- ]of[- ]scope|forbidden|excluded|not in scope|do not touch):\s*$/i;
+const OUT_OF_SCOPE_INLINE = /\b(?:out[- ]of[- ]scope|do not modify|do not touch|forbidden|excluded)\b/i;
+const PLACEHOLDER_PATTERNS = [
+    /^<[^>]+>$/, // <placeholder>
+    /^\.{2,}$/, // ...
+    /^(?:in-scope|out-of-scope)\s+(?:files|surfaces)/i // bullet that is the template label, not a real path
+];
+const AUTO_ALLOWED_PATHS = [
+    /^\.peaks\//,
+    /^\.peaks-artifacts\//,
+    /^\.git\//
+];
+const AUTO_ALLOWED_TEST_FILE = /\.(?:test|spec)\.[a-z]+$/i;
+const AUTO_ALLOWED_TEST_DIR = /(?:^|\/)(?:tests?|__tests__|__mocks__|test|spec)\//;
+function isPlaceholder(text) {
+    return PLACEHOLDER_PATTERNS.some((pattern) => pattern.test(text));
+}
+function escapeRegex(text) {
+    return text.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Convert a simple glob pattern to a regex.
+ * Supports `**` (any path including separators), `*` (one path segment), `?` (single char).
+ * Leading `/` is removed; matching is relative to project root.
+ */
+export function globToRegex(pattern) {
+    const trimmed = pattern.replace(/^\.?\/+/, '').replace(/\/+$/, '');
+    let body = '';
+    let i = 0;
+    while (i < trimmed.length) {
+        const ch = trimmed[i] ?? '';
+        if (ch === '*') {
+            if (trimmed[i + 1] === '*') {
+                body += '.*';
+                i += 2;
+                // Skip following slash if any (since '**/' should match zero or more dirs)
+                if (trimmed[i] === '/')
+                    i += 1;
+            }
+            else {
+                body += '[^/]*';
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === '?') {
+            body += '[^/]';
+            i += 1;
+            continue;
+        }
+        body += escapeRegex(ch);
+        i += 1;
+    }
+    // If the pattern ends with no trailing slash and no extension wildcard, also allow it to match files under the path (treat as dir prefix)
+    // E.g. `src/services/login` should match `src/services/login/handler.ts`.
+    body = (!trimmed.includes("*") && !trimmed.includes("?") && !trimmed.includes("."))
+        ? `${body}(?:/.*)?`
+        : body;
+    return new RegExp(`^${body}$`);
+}
+function classifyPatternLine(raw) {
+    // Strip leading "- ", "* ", numbered list, or trailing comments.
+    const cleaned = raw.replace(/^\s*[-*+]\s*/, '').replace(/^\s*\d+\.\s*/, '').trim();
+    if (cleaned.length === 0)
+        return { pattern: null };
+    if (isPlaceholder(cleaned))
+        return { pattern: null };
+    // Take the first word/path-like token before whitespace or backticks.
+    // If the line wraps a path in backticks, extract it; otherwise take the whole line.
+    const backtickMatch = /`([^`]+)`/.exec(cleaned);
+    if (backtickMatch !== null && backtickMatch[1] !== undefined) {
+        return { pattern: backtickMatch[1].trim() };
+    }
+    // If the cleaned line is just a path-ish token, take it as-is.
+    if (/^[\w./*?{}[\]@-]+$/.test(cleaned)) {
+        return { pattern: cleaned };
+    }
+    // Otherwise the bullet is descriptive prose (e.g. "do not touch payment module"); skip.
+    return { pattern: null };
+}
+function parseRedLineScope(rdBody) {
+    const lines = rdBody.split(/\r?\n/);
+    let inSection = false;
+    let mode = 'unspecified';
+    const inScope = [];
+    const outOfScope = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i] ?? '';
+        if (!inSection) {
+            if (RED_LINE_HEADER.test(raw)) {
+                inSection = true;
+            }
+            continue;
+        }
+        if (/^##\s/.test(raw))
+            break; // next H2
+        if (IN_SCOPE_SUBHEADER.test(raw.trim())) {
+            mode = 'in';
+            continue;
+        }
+        if (OUT_OF_SCOPE_SUBHEADER.test(raw.trim())) {
+            mode = 'out';
+            continue;
+        }
+        const { pattern } = classifyPatternLine(raw);
+        if (pattern === null)
+            continue;
+        const target = mode === 'out' || (mode === 'unspecified' && OUT_OF_SCOPE_INLINE.test(raw))
+            ? outOfScope
+            : inScope;
+        target.push({ raw: pattern, regex: globToRegex(pattern), line: i + 1 });
+    }
+    const declared = inScope.length > 0 || outOfScope.length > 0;
+    return { inScope, outOfScope, declared };
+}
+function tryGitChangedFiles(projectRoot, baseRef) {
+    try {
+        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', baseRef], { encoding: 'utf8' });
+        const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8' });
+        const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        return { ok: true, files: Array.from(new Set([...tracked, ...untracked])) };
+    }
+    catch {
+        return { ok: false, files: [] };
+    }
+}
+function isAutoAllowed(path) {
+    if (AUTO_ALLOWED_PATHS.some((pattern) => pattern.test(path)))
+        return true;
+    if (AUTO_ALLOWED_TEST_FILE.test(path))
+        return true;
+    if (AUTO_ALLOWED_TEST_DIR.test(path))
+        return true;
+    return false;
+}
+function classifyFile(path, inScope, outOfScope) {
+    if (isAutoAllowed(path)) {
+        return { classification: 'auto-allowed', reason: 'Auto-allowed (test, mock, or Peaks artifact path)' };
+    }
+    const outMatch = outOfScope.find((pattern) => pattern.regex.test(path));
+    if (outMatch !== undefined) {
+        return { classification: 'out-of-scope-violation', matchedPattern: outMatch.raw, reason: `Matches explicit out-of-scope pattern "${outMatch.raw}"` };
+    }
+    const inMatch = inScope.find((pattern) => pattern.regex.test(path));
+    if (inMatch !== undefined) {
+        return { classification: 'in-scope', matchedPattern: inMatch.raw, reason: `Matches in-scope pattern "${inMatch.raw}"` };
+    }
+    return { classification: 'unclassified', reason: 'Does not match any declared scope pattern' };
+}
+export async function getDiffVsScope(options) {
+    const baseRef = options.baseRef ?? 'HEAD';
+    const showOptions = {
+        projectRoot: options.projectRoot,
+        role: 'rd',
+        requestId: options.requestId
+    };
+    if (options.sessionId !== undefined) {
+        showOptions.sessionId = options.sessionId;
+    }
+    const rdArtifact = await showRequestArtifact(showOptions);
+    if (rdArtifact === null) {
+        return { kind: 'rd-not-found' };
+    }
+    const { inScope, outOfScope, declared } = parseRedLineScope(rdArtifact.content);
+    const { ok: gitAvailable, files } = tryGitChangedFiles(options.projectRoot, baseRef);
+    const changedFiles = files.map((path) => {
+        const { classification, matchedPattern, reason } = classifyFile(path, inScope, outOfScope);
+        const entry = { path, classification, reason };
+        if (matchedPattern !== undefined) {
+            entry.matchedPattern = matchedPattern;
+        }
+        return entry;
+    });
+    const violations = changedFiles.filter((file) => file.classification === 'out-of-scope-violation');
+    const unclassified = changedFiles.filter((file) => file.classification === 'unclassified');
+    // ok if patterns are declared AND no violations AND no unclassified non-trivial files.
+    // If patterns were NOT declared, treat as a warning (ok=false but with a clear "patterns missing" reason).
+    const ok = gitAvailable && declared && violations.length === 0 && unclassified.length === 0;
+    return {
+        ok,
+        rdArtifactPath: rdArtifact.path,
+        inScopePatterns: inScope,
+        outOfScopePatterns: outOfScope,
+        changedFiles,
+        violations,
+        unclassified,
+        gitAvailable,
+        patternsDeclared: declared
+    };
+}
+export function isDiffScopeError(value) {
+    return value.kind !== undefined;
+}

package/dist/src/services/scan/existing-system-service.d.ts

@@ -0,0 +1,7 @@
+import type { ExistingSystemReport } from './scan-types.js';
+export type ExistingSystemScanOptions = {
+    projectRoot: string;
+    maxTokens?: number;
+    maxSamplesPerKind?: number;
+};
+export declare function scanExistingSystem(options: ExistingSystemScanOptions): Promise<ExistingSystemReport>;

package/dist/src/services/scan/existing-system-service.js

@@ -0,0 +1,300 @@
+import { readdir, stat } from 'node:fs/promises';
+import { basename, join, relative } from 'node:path';
+import { isDirectory, pathExists, readText } from '../../shared/fs.js';
+import { scanArchetype } from './archetype-service.js';
+const DEFAULT_MAX_TOKENS = 40;
+const DEFAULT_SAMPLES = 5;
+const COLOR_KEYWORDS = ['color', 'primary', 'success', 'warning', 'error', 'danger', 'info', 'bg', 'background', 'border', 'text'];
+const SPACING_KEYWORDS = ['spacing', 'gap', 'padding', 'margin', 'size'];
+const TYPO_KEYWORDS = ['font', 'text-size', 'line-height', 'letter-spacing', 'heading'];
+const RADIUS_KEYWORDS = ['radius', 'rounded'];
+const STYLE_DIRS = ['src/styles', 'src/style', 'styles', 'src/assets/styles', 'src/theme', 'theme'];
+const COMPONENT_DIRS = ['src/components', 'src/Components', 'components'];
+const SERVICE_DIRS = ['src/services', 'src/service', 'src/api', 'src/apis'];
+const HOOK_DIRS = ['src/hooks', 'src/hook', 'src/composables'];
+function classifyToken(name) {
+    const lower = name.toLowerCase();
+    if (RADIUS_KEYWORDS.some((kw) => lower.includes(kw)))
+        return 'radius';
+    if (TYPO_KEYWORDS.some((kw) => lower.includes(kw)))
+        return 'typography';
+    if (SPACING_KEYWORDS.some((kw) => lower.includes(kw)))
+        return 'spacing';
+    if (COLOR_KEYWORDS.some((kw) => lower.includes(kw)))
+        return 'color';
+    return null;
+}
+function parseLessOrSassVars(content, sourceRel) {
+    const tokens = [];
+    // Match `@var: value;` (Less) or `$var: value;` (Sass)
+    const regex = /^\s*[@$]([a-zA-Z][\w-]*)\s*:\s*([^;]+);/gm;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const [, rawName, rawValue] = match;
+        if (rawName === undefined || rawValue === undefined)
+            continue;
+        tokens.push({ name: rawName, value: rawValue.trim(), source: sourceRel });
+    }
+    return tokens;
+}
+function parseCssVars(content, sourceRel) {
+    const tokens = [];
+    const regex = /--([a-zA-Z][\w-]*)\s*:\s*([^;]+);/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const [, rawName, rawValue] = match;
+        if (rawName === undefined || rawValue === undefined)
+            continue;
+        tokens.push({ name: `--${rawName}`, value: rawValue.trim(), source: sourceRel });
+    }
+    return tokens;
+}
+async function walkStyleFiles(projectRoot) {
+    const found = [];
+    for (const candidate of STYLE_DIRS) {
+        const full = join(projectRoot, candidate);
+        if (!(await isDirectory(full)))
+            continue;
+        const queue = [full];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === undefined)
+                break;
+            let entries;
+            try {
+                entries = await readdir(current, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                    continue;
+                const entryPath = join(current, entry.name);
+                if (entry.isDirectory()) {
+                    queue.push(entryPath);
+                }
+                else if (/\.(less|scss|sass|css)$/i.test(entry.name)) {
+                    found.push(entryPath);
+                }
+            }
+        }
+    }
+    return found;
+}
+async function extractTailwindTokens(projectRoot) {
+    const candidates = ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.cjs', 'tailwind.config.mjs'];
+    for (const candidate of candidates) {
+        const full = join(projectRoot, candidate);
+        if (await pathExists(full)) {
+            const content = await readText(full);
+            const tokens = [];
+            // Heuristic: extract keys under theme.extend.* via simple regex.
+            const colorBlock = /colors\s*:\s*\{([\s\S]*?)\}/.exec(content);
+            if (colorBlock?.[1] !== undefined) {
+                const colorRegex = /([a-zA-Z_][\w-]*)\s*:\s*['"`]([^'"`]+)['"`]/g;
+                let match;
+                while ((match = colorRegex.exec(colorBlock[1])) !== null) {
+                    const [, name, value] = match;
+                    if (name !== undefined && value !== undefined) {
+                        tokens.push({ name, value, source: candidate });
+                    }
+                }
+            }
+            return { tokens, source: { path: candidate, kind: 'tailwind-config' } };
+        }
+    }
+    return { tokens: [], source: null };
+}
+async function listFilesByMtime(dir, exts, max) {
+    if (!(await isDirectory(dir)))
+        return [];
+    const collected = [];
+    const queue = [dir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === undefined)
+            break;
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(full);
+            }
+            else if (exts.test(entry.name)) {
+                try {
+                    const stats = await stat(full);
+                    collected.push({ path: full, mtimeMs: stats.mtimeMs });
+                }
+                catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+                    // skip unreadable
+                }
+            }
+        }
+    }
+    collected.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return collected.slice(0, max);
+}
+function classifyComponentNaming(samples) {
+    if (samples.length === 0)
+        return 'unknown';
+    let pascal = 0;
+    let kebab = 0;
+    for (const sample of samples) {
+        const name = basename(sample.path).replace(/\.[^.]+$/, '');
+        if (/^[A-Z][a-zA-Z0-9]*$/.test(name))
+            pascal += 1;
+        else if (/^[a-z][a-z0-9-]*$/.test(name))
+            kebab += 1;
+    }
+    if (pascal > 0 && kebab === 0)
+        return 'PascalCase';
+    if (kebab > 0 && pascal === 0)
+        return 'kebab-case';
+    if (pascal > 0 || kebab > 0)
+        return 'mixed';
+    return 'unknown';
+}
+async function firstExistingDir(projectRoot, candidates) {
+    for (const candidate of candidates) {
+        if (await isDirectory(join(projectRoot, candidate))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function dedupeTokens(tokens, max) {
+    const seen = new Set();
+    const out = [];
+    for (const token of tokens) {
+        const key = `${token.name}=${token.value}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(token);
+        if (out.length >= max)
+            break;
+    }
+    return out;
+}
+function findInconsistencies(tokens) {
+    const issues = [];
+    const byName = new Map();
+    for (const token of tokens) {
+        const set = byName.get(token.name) ?? new Set();
+        set.add(token.value);
+        byName.set(token.name, set);
+    }
+    for (const [name, values] of byName.entries()) {
+        if (values.size > 1) {
+            issues.push(`token "${name}" has ${values.size} different values across sources: ${[...values].join(' | ')}`);
+        }
+    }
+    return issues;
+}
+export async function scanExistingSystem(options) {
+    const { projectRoot } = options;
+    const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const maxSamples = options.maxSamplesPerKind ?? DEFAULT_SAMPLES;
+    const archetypeReport = await scanArchetype({ projectRoot });
+    if (archetypeReport.archetype === 'greenfield' || archetypeReport.archetype === 'unknown') {
+        return {
+            archetype: archetypeReport.archetype,
+            scanned: false,
+            scanSkippedReason: `archetype=${archetypeReport.archetype} — extraction only runs on legacy projects`,
+            visualTokens: { colors: [], spacing: [], typography: [], radii: [], sources: [] },
+            conventions: { componentNaming: 'unknown', componentDir: null, serviceDir: null, hookDir: null, samples: [] },
+            inconsistencies: []
+        };
+    }
+    const sources = [];
+    const rawTokens = [];
+    const styleFiles = await walkStyleFiles(projectRoot);
+    for (const file of styleFiles) {
+        const content = await readText(file);
+        const rel = relative(projectRoot, file).split(/[\\/]/).join('/');
+        if (/\.less$/i.test(file)) {
+            const lessTokens = parseLessOrSassVars(content, rel);
+            if (lessTokens.length > 0) {
+                sources.push({ path: rel, kind: 'less-vars' });
+                rawTokens.push(...lessTokens);
+            }
+        }
+        else if (/\.s[ac]ss$/i.test(file)) {
+            const sassTokens = parseLessOrSassVars(content, rel);
+            if (sassTokens.length > 0) {
+                sources.push({ path: rel, kind: 'sass-vars' });
+                rawTokens.push(...sassTokens);
+            }
+        }
+        const cssVars = parseCssVars(content, rel);
+        if (cssVars.length > 0) {
+            sources.push({ path: rel, kind: 'css-vars' });
+            rawTokens.push(...cssVars);
+        }
+    }
+    const tailwind = await extractTailwindTokens(projectRoot);
+    if (tailwind.source !== null) {
+        sources.push(tailwind.source);
+        rawTokens.push(...tailwind.tokens);
+    }
+    const colors = [];
+    const spacing = [];
+    const typography = [];
+    const radii = [];
+    for (const token of rawTokens) {
+        const category = classifyToken(token.name);
+        if (category === 'color')
+            colors.push(token);
+        else if (category === 'spacing')
+            spacing.push(token);
+        else if (category === 'typography')
+            typography.push(token);
+        else if (category === 'radius')
+            radii.push(token);
+    }
+    const componentDir = await firstExistingDir(projectRoot, COMPONENT_DIRS);
+    const serviceDir = await firstExistingDir(projectRoot, SERVICE_DIRS);
+    const hookDir = await firstExistingDir(projectRoot, HOOK_DIRS);
+    const componentSamples = componentDir !== null
+        ? await listFilesByMtime(join(projectRoot, componentDir), /\.(tsx|jsx|vue|svelte)$/i, maxSamples)
+        : [];
+    const serviceSamples = serviceDir !== null
+        ? await listFilesByMtime(join(projectRoot, serviceDir), /\.(ts|js)$/i, maxSamples)
+        : [];
+    const hookSamples = hookDir !== null
+        ? await listFilesByMtime(join(projectRoot, hookDir), /\.(ts|js)$/i, maxSamples)
+        : [];
+    const samples = [
+        ...componentSamples.map((sample) => ({ path: relative(projectRoot, sample.path).split(/[\\/]/).join('/'), kind: 'component' })),
+        ...serviceSamples.map((sample) => ({ path: relative(projectRoot, sample.path).split(/[\\/]/).join('/'), kind: 'service' })),
+        ...hookSamples.map((sample) => ({ path: relative(projectRoot, sample.path).split(/[\\/]/).join('/'), kind: 'hook' }))
+    ];
+    return {
+        archetype: archetypeReport.archetype,
+        scanned: true,
+        visualTokens: {
+            colors: dedupeTokens(colors, maxTokens),
+            spacing: dedupeTokens(spacing, maxTokens),
+            typography: dedupeTokens(typography, maxTokens),
+            radii: dedupeTokens(radii, maxTokens),
+            sources
+        },
+        conventions: {
+            componentNaming: classifyComponentNaming(componentSamples),
+            componentDir,
+            serviceDir,
+            hookDir,
+            samples
+        },
+        inconsistencies: findInconsistencies(rawTokens)
+    };
+}

package/dist/src/services/scan/file-size-scan.d.ts

@@ -0,0 +1,23 @@
+export declare const DEFAULT_FILE_SIZE_THRESHOLD = 800;
+export type FileSizeViolation = {
+    file: string;
+    lines: number;
+};
+export type FileSizeScanResult = {
+    ok: boolean;
+    threshold: number;
+    checkedFiles: number;
+    /** Files that appeared in `git diff` but no longer exist on disk (e.g.
+     *  deleted in the working tree). Pre-#015 the scan crashed on these via
+     *  ENOENT; now they are reported here as informational data. */
+    deletedFiles: string[];
+    violations: FileSizeViolation[];
+};
+export type FileSizeScanOptions = {
+    projectRoot: string;
+    /** Compare working tree against this ref. Default 'HEAD'. */
+    baseRef?: string;
+    /** Line count threshold. Default 800. */
+    threshold?: number;
+};
+export declare function scanFileSize(options: FileSizeScanOptions): FileSizeScanResult;

package/dist/src/services/scan/file-size-scan.js

@@ -0,0 +1,68 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+export const DEFAULT_FILE_SIZE_THRESHOLD = 800;
+function getChangedFiles(projectRoot, baseRef) {
+    try {
+        // --diff-filter=AM keeps only Added + Modified entries. Deleted files
+        // (--diff-filter=D) are intentionally excluded: they have no on-disk
+        // body to count, and a refactor that deletes large files is exactly
+        // when the gate should NOT block. Slice #015 fix.
+        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', '--diff-filter=AM', baseRef], { encoding: 'utf8' });
+        const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8' });
+        const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        return Array.from(new Set([...tracked, ...untracked]));
+    }
+    catch {
+        return [];
+    }
+}
+function countLines(filePath) {
+    const content = readFileSync(filePath, 'utf8');
+    return content.split(/\r?\n/).length;
+}
+export function scanFileSize(options) {
+    const baseRef = options.baseRef ?? 'HEAD';
+    const threshold = options.threshold ?? DEFAULT_FILE_SIZE_THRESHOLD;
+    const files = getChangedFiles(options.projectRoot, baseRef);
+    const violations = [];
+    const deletedFiles = [];
+    let checkedFiles = 0;
+    for (const file of files) {
+        const absolute = join(options.projectRoot, file);
+        // Pre-#015: readFileSync threw ENOENT for files that appear in
+        // `git diff --name-only` but no longer exist on disk (e.g. a refactor
+        // that deletes source files). That aborted the entire
+        // `peaks request transition rd → implemented` flow with
+        // `code: PREREQUISITES_MISSING`. Now we skip missing paths — a
+        // deleted file has no lines to count. Belt-and-braces: the
+        // `getChangedFiles` filter above already excludes `--diff-filter=D`,
+        // but a manually-passed `baseRef` (tests) or a path that was
+        // untracked-then-deleted still flows through here, so the
+        // existsSync guard stays as a second line of defense.
+        if (!existsSync(absolute)) {
+            try {
+                const st = statSync(absolute);
+                if (!st.isFile())
+                    continue;
+            }
+            catch {
+                deletedFiles.push(file);
+                continue;
+            }
+        }
+        checkedFiles += 1;
+        const lines = countLines(absolute);
+        if (lines > threshold) {
+            violations.push({ file, lines });
+        }
+    }
+    return {
+        ok: violations.length === 0,
+        threshold,
+        checkedFiles,
+        deletedFiles,
+        violations
+    };
+}