klyro 0.1.16 → 0.1.18

package/dist/verification/baseline.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 6.1 — Baseline run (pre-existing failure cache per HEAD)
+ * Before first edit, run primary verifier and cache result keyed by git HEAD.
+ * Used to distinguish introduced vs pre-existing failures (6.4 classify).
+ */
+export interface BaselineResult {
+    head: string;
+    command: string;
+    ok: boolean;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    capturedAt: number;
+}
+export declare function getBaseline(cwd: string, command?: string): Promise<BaselineResult | null>;
+export declare function runBaseline(cwd: string, command?: string, timeoutMs?: number): Promise<BaselineResult | null>;
+export declare function ensureBaseline(cwd: string, command?: string): Promise<BaselineResult | null>;

package/dist/verification/baseline.js

@@ -0,0 +1,108 @@
+/**
+ * 6.1 — Baseline run (pre-existing failure cache per HEAD)
+ * Before first edit, run primary verifier and cache result keyed by git HEAD.
+ * Used to distinguish introduced vs pre-existing failures (6.4 classify).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { primaryVerifyCommand } from './registry.js';
+async function gitHead(cwd) {
+    return new Promise((resolve) => {
+        const child = spawn('git', ['rev-parse', 'HEAD'], { cwd, shell: false });
+        let out = '';
+        child.stdout.on('data', (b) => { out += b.toString(); });
+        child.on('close', () => resolve(out.trim() || 'no-head'));
+        child.on('error', () => resolve('no-head'));
+    });
+}
+function baselinePath(cwd, head) {
+    const safe = head.slice(0, 12) || 'no-head';
+    return path.join(cwd, '.klyro', 'baselines', `${safe}.json`);
+}
+export async function getBaseline(cwd, command) {
+    const cmd = command ?? primaryVerifyCommand(cwd);
+    if (!cmd)
+        return null;
+    const head = await gitHead(cwd);
+    const p = baselinePath(cwd, head);
+    try {
+        const raw = fs.readFileSync(p, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.head === head && parsed.command === cmd)
+            return parsed;
+    }
+    catch { /* miss */ }
+    return null;
+}
+export async function runBaseline(cwd, command, timeoutMs = 90_000) {
+    const cmd = command ?? primaryVerifyCommand(cwd);
+    if (!cmd)
+        return null;
+    const head = await gitHead(cwd);
+    const p = baselinePath(cwd, head);
+    // if cached, return
+    const cached = await getBaseline(cwd, cmd);
+    if (cached)
+        return cached;
+    const result = await runCmd(cwd, cmd, timeoutMs);
+    const baseline = {
+        head,
+        command: cmd,
+        ok: result.ok,
+        exitCode: result.exitCode,
+        stdout: result.stdout.slice(0, 8000),
+        stderr: result.stderr.slice(0, 8000),
+        capturedAt: Date.now(),
+    };
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        const tmp = `${p}.tmp-${crypto.randomBytes(4).toString('hex')}`;
+        fs.writeFileSync(tmp, JSON.stringify(baseline, null, 2));
+        fs.renameSync(tmp, p);
+    }
+    catch { /* ignore */ }
+    return baseline;
+}
+function runCmd(cwd, command, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, { cwd, shell: true, env: process.env });
+        let stdout = '';
+        let stderr = '';
+        let done = false;
+        const timer = setTimeout(() => {
+            if (done)
+                return;
+            done = true;
+            try {
+                child.kill();
+            }
+            catch { /* ignore */ }
+            resolve({ ok: false, exitCode: -1, stdout, stderr: stderr + '\n[baseline timeout]' });
+        }, timeoutMs);
+        child.stdout.on('data', (b) => { stdout += b.toString(); });
+        child.stderr.on('data', (b) => { stderr += b.toString(); });
+        child.on('close', (code) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            const exit = typeof code === 'number' ? code : -1;
+            resolve({ ok: exit === 0, exitCode: exit, stdout, stderr });
+        });
+        child.on('error', (err) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve({ ok: false, exitCode: -1, stdout, stderr: String(err) });
+        });
+    });
+}
+export async function ensureBaseline(cwd, command) {
+    const existing = await getBaseline(cwd, command);
+    if (existing)
+        return existing;
+    return runBaseline(cwd, command);
+}

package/dist/verification/classify.d.ts

@@ -0,0 +1,22 @@
+import type { Failure } from './detect.js';
+import type { BaselineResult } from './baseline.js';
+export type FailureClass = 'introduced' | 'pre_existing' | 'flaky' | 'env';
+export declare function classifyFailure(current: {
+    failure?: Failure;
+    stdout: string;
+    stderr: string;
+}, baseline: BaselineResult | null, flakyRerunOk?: boolean): FailureClass;
+export declare function rerunOnce(cwd: string, command: string, timeoutMs?: number): Promise<boolean>;
+export interface RepairContext {
+    failingTests: {
+        file: string;
+        content: string;
+    }[];
+    hunks: string;
+    blame: string;
+}
+export declare function gatherRepairContext(cwd: string, failure: Failure | undefined): Promise<RepairContext>;
+export declare function guardRepair(diff: string, editedFiles: string[]): {
+    blocked: boolean;
+    reason?: string;
+};

package/dist/verification/classify.js

@@ -0,0 +1,108 @@
+/**
+ * 6.4 — Repair classifier + context gather + guard
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+export function classifyFailure(current, baseline, flakyRerunOk) {
+    const combined = (current.stderr + '\n' + current.stdout).toLowerCase();
+    // env: missing binary, network, permission, no such file, EACCES etc
+    if (/enoent|command not found|no such file|network|econn|etimedout|eacces|permission denied|env/.test(combined) && /error/i.test(combined)) {
+        // only if not a real test failure but env
+        if (!current.failure || current.failure.type === 'unknown')
+            return 'env';
+        // even test failures can be env if message hints
+        if (/enoent|not found/.test(combined))
+            return 'env';
+    }
+    if (flakyRerunOk)
+        return 'flaky';
+    if (baseline && !baseline.ok) {
+        const baseRaw = (baseline.stderr + '\n' + baseline.stdout);
+        // if current failure files overlap baseline failure raw, treat as pre-existing
+        if (current.failure && baseline.stdout + baseline.stderr) {
+            const curPaths = new Set(current.failure.files.map((f) => f.path).filter(Boolean));
+            const baseContains = [...curPaths].some((p) => baseRaw.includes(p));
+            if (baseContains)
+                return 'pre_existing';
+            // also if same exit code and type, likely pre-existing
+            if (baseRaw.includes(current.failure.files[0]?.message ?? '') && baseRaw.length > 0)
+                return 'pre_existing';
+        }
+        // if baseline failed and current also fails with similar raw length, assume pre-existing
+        if (current.failure && baseline.stderr.length > 0 && combined.includes(baseline.stderr.slice(0, 200).toLowerCase()))
+            return 'pre_existing';
+    }
+    return 'introduced';
+}
+export async function rerunOnce(cwd, command, timeoutMs = 45_000) {
+    return new Promise((resolve) => {
+        const child = spawn(command, { cwd, shell: true, env: process.env });
+        let done = false;
+        const t = setTimeout(() => { if (!done) {
+            done = true;
+            try {
+                child.kill();
+            }
+            catch { }
+            resolve(false);
+        } }, timeoutMs);
+        child.on('close', (code) => { if (done)
+            return; done = true; clearTimeout(t); resolve(code === 0); });
+        child.on('error', () => { if (done)
+            return; done = true; clearTimeout(t); resolve(false); });
+    });
+}
+export async function gatherRepairContext(cwd, failure) {
+    const failingTests = [];
+    if (failure) {
+        for (const f of failure.files.slice(0, 3)) {
+            if (!f.path)
+                continue;
+            const full = path.join(cwd, f.path);
+            try {
+                const raw = fs.readFileSync(full, 'utf-8');
+                // slice around failing line if available
+                const lines = raw.split('\n');
+                const start = Math.max(0, (f.line ?? 1) - 20);
+                const end = Math.min(lines.length, (f.line ?? 1) + 20);
+                failingTests.push({ file: f.path, content: lines.slice(start, end).join('\n') });
+            }
+            catch { /* ignore */ }
+        }
+    }
+    // hunks: git diff --stat + --unified=2 for changed files
+    const hunks = await execCapture(cwd, 'git diff --stat && echo "---" && git diff -U2 2>&1 | head -n 300');
+    const blame = failure?.files[0]?.path
+        ? await execCapture(cwd, `git blame "${failure.files[0].path}" 2>&1 | head -n 20`)
+        : '';
+    return { failingTests, hunks, blame };
+}
+function execCapture(cwd, cmd) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, { cwd, shell: true, env: process.env });
+        let out = '';
+        child.stdout.on('data', (b) => { out += b.toString(); });
+        child.stderr.on('data', (b) => { out += b.toString(); });
+        child.on('close', () => resolve(out.slice(0, 4000)));
+        child.on('error', () => resolve(''));
+    });
+}
+// Guard: does diff touch assertions or add skips?
+const ASSERT_RE = /(?:expect\s*\(|assert\.|assert\(|should\.|chai\.)/;
+const SKIP_RE = /(?:\.skip\(|\.todo\(|xdescribe\(|xit\(|xtest\(|@pytest\.mark\.skip|pytest\.skip|:\s*skip\b)/i;
+export function guardRepair(diff, editedFiles) {
+    if (!diff)
+        return { blocked: false };
+    const addedLines = diff.split('\n').filter((l) => l.startsWith('+') && !l.startsWith('+++'));
+    const touchesAssert = addedLines.some((l) => ASSERT_RE.test(l));
+    const addsSkip = addedLines.some((l) => SKIP_RE.test(l));
+    if (touchesAssert && addedLines.length < 20) {
+        // touching assertions in a small diff likely means editing test expectations — require approval
+        return { blocked: true, reason: 'repair touches test assertions — requires explicit approval (edit expectations directly is discouraged)' };
+    }
+    if (addsSkip) {
+        return { blocked: true, reason: 'repair adds skip/todo — requires explicit approval (skipping tests is not a fix)' };
+    }
+    return { blocked: false };
+}

package/dist/verification/detect.js

@@ -11,39 +11,178 @@
  * the raw output; we just pre-structure the high-signal lines.
  */
 const TS_LINE = /^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/;
+const TSC_LINE2 = /^(.+?):(\d+):(\d+)\s+-\s+error\s+(TS\d+):\s+(.+)$/;
 const TEST_FAIL = /^\s*✘|FAIL\s+(\S+)|✗\s+(\S+)|×\s+(.+?)\s/;
-const LINT_LINE = /^(.+?)\s*$/;
 const RUNTIME_LINE = /^(?:Error|TypeError|ReferenceError):\s+(.+)$/;
+// 6.2 — dedicated patterns for each runner/linter/compiler
+const PYTEST_FAIL = /FAILED\s+(\S+?)(?:::\S+)?\s+-\s+(.+)/;
+const PYTEST_ASSERT = /AssertionError:\s*(.+)/;
+const GO_FAIL = /^---\s+FAIL:\s+(\S+)\s+\((.+)\)/;
+const GO_PKG_FAIL = /^FAIL\s+(\S+)\s/;
+const CARGO_FAIL = /^test\s+(\S+)\s+\.\.\.\s+FAILED/;
+const CARGO_PANIC = /thread\s+'(.+?)'\s+panicked at\s+'(.+?)',\s+(.+?):(\d+):(\d+)/;
+const MOCHA_FAIL = /^\s*\d+\)\s+(.+)$/;
+const JUNIT_FAIL = /<(?:failure|error)[\s>]/;
+const ESLINT_LINE = /^(.+?):(\d+):(\d+):\s+(error|warning)\s+(.+?)\s+\((.+?)\)\s*$/;
+const RUFF_LINE = /^(.+?):(\d+):(\d+):\s+([A-Z]\d+)\s+(.+)$/;
+const MYPY_LINE = /^(.+?):(\d+):\s+error:\s+(.+?)\s+\[(.+?)\]\s*$/;
+const GCC_LINE = /^(.+?):(\d+):(\d+):\s+(?:fatal\s+)?error:\s+(.+)$/;
+const VITE_ERROR = /ERROR\s+in\s+(.+)|Module build failed.+/;
+const DOTNET_CS = /^(.+?)\((\d+),(\d+)\):\s+error\s+(CS\d+):\s+(.+)$/;
+const GENERIC_FILE_LINE = /^(.+?):(\d+)(?::(\d+))?:\s*(.+)$/;
 export function detect(stdout, stderr, exitCode) {
     const combined = stderr + '\n' + stdout;
     if (exitCode === 0) {
         return { type: 'unknown', files: [], raw: combined, exitCode };
     }
-    // TypeScript tsc.
+    // TypeScript tsc (both formats)
     const tsMatches = [];
     for (const line of combined.split(/\r?\n/)) {
-        const m = TS_LINE.exec(line);
+        let m = TS_LINE.exec(line);
         if (m && m[1] && m[2] && m[3] && m[4] && m[5]) {
             tsMatches.push({ path: m[1], line: Number(m[2]), column: Number(m[3]), code: m[4], message: m[5] });
+            continue;
+        }
+        m = TSC_LINE2.exec(line);
+        if (m && m[1] && m[2] && m[3] && m[4] && m[5]) {
+            tsMatches.push({ path: m[1], line: Number(m[2]), column: Number(m[3]), code: m[4], message: m[5] });
+        }
+        const dm = DOTNET_CS.exec(line);
+        if (dm && dm[1] && dm[2] && dm[3] && dm[4] && dm[5]) {
+            tsMatches.push({ path: dm[1], line: Number(dm[2]), column: Number(dm[3]), code: dm[4], message: dm[5] });
         }
     }
     if (tsMatches.length > 0)
-        return { type: 'type', files: tsMatches, raw: combined, exitCode };
-    // Test runner.
-    if (/Test Suites:|FAIL\s|Tests:.*failed|✘|✗/.test(combined)) {
+        return { type: 'type', files: dedupe(tsMatches), raw: combined, exitCode };
+    // JUnit XML
+    if (JUNIT_FAIL.test(combined)) {
+        const files = [];
+        for (const line of combined.split(/\r?\n/)) {
+            if (JUNIT_FAIL.test(line))
+                files.push({ path: '', message: line.trim() });
+        }
+        // also extract file:line fallback
+        if (files.length === 0)
+            return { type: 'test', files: extractGeneric(combined, 5), raw: combined, exitCode };
+        return { type: 'test', files: dedupe(files), raw: combined, exitCode };
+    }
+    // pytest
+    if (/FAILED\s+\S+|AssertionError|pytest/.test(combined)) {
+        const files = [];
+        for (const line of combined.split(/\r?\n/)) {
+            let m = PYTEST_FAIL.exec(line);
+            if (m && m[1]) {
+                files.push({ path: m[1], message: m[2] ?? line.trim() });
+                continue;
+            }
+            m = PYTEST_ASSERT.exec(line);
+            if (m) {
+                files.push({ path: '', message: m[0] });
+                continue;
+            }
+        }
+        if (files.length > 0)
+            return { type: 'test', files: dedupe(files), raw: combined, exitCode };
+    }
+    // go test
+    if (/---\s+FAIL:|FAIL\s+\S+/.test(combined)) {
+        const files = [];
+        for (const line of combined.split(/\r?\n/)) {
+            let m = GO_FAIL.exec(line);
+            if (m && m[1]) {
+                files.push({ path: m[1], message: line.trim() });
+                continue;
+            }
+            m = GO_PKG_FAIL.exec(line);
+            if (m && m[1]) {
+                files.push({ path: m[1], message: line.trim() });
+            }
+        }
+        if (files.length > 0)
+            return { type: 'test', files: dedupe(files), raw: combined, exitCode };
+    }
+    // cargo test
+    if (/test result: FAILED|FAILED.*cargo|panicked at/.test(combined)) {
+        const files = [];
+        for (const line of combined.split(/\r?\n/)) {
+            let m = CARGO_FAIL.exec(line);
+            if (m && m[1]) {
+                files.push({ path: m[1], message: line.trim() });
+                continue;
+            }
+            m = CARGO_PANIC.exec(line);
+            if (m && m[3] && m[4] && m[5]) {
+                files.push({ path: m[3], line: Number(m[4]), column: Number(m[5]), message: m[2] ?? line.trim() });
+            }
+        }
+        if (files.length > 0)
+            return { type: 'test', files: dedupe(files), raw: combined, exitCode };
+    }
+    // Generic test runner (vitest/jest/mocha)
+    if (/Test Suites:|FAIL\s|Tests:.*failed|✘|✗|×\s+/.test(combined) || MOCHA_FAIL.test(combined)) {
         const files = [];
         for (const line of combined.split(/\r?\n/)) {
             const m = TEST_FAIL.exec(line);
             if (m) {
                 const target = m[1] ?? m[2] ?? m[3] ?? line.trim();
                 files.push({ path: target, message: line.trim() });
+                continue;
             }
+            const mm = MOCHA_FAIL.exec(line);
+            if (mm && mm[1])
+                files.push({ path: '', message: mm[1] });
         }
-        return { type: 'test', files, raw: combined, exitCode };
+        if (files.length > 0)
+            return { type: 'test', files: dedupe(files), raw: combined, exitCode };
+        // fallback: any FAIL line
+        if (/FAIL/.test(combined))
+            return { type: 'test', files: extractGeneric(combined, 5), raw: combined, exitCode };
     }
-    // ESLint.
-    if (/error\s+at\s+|eslint.*problem|✖/.test(combined)) {
-        return { type: 'lint', files: extractFirstLines(combined, 5), raw: combined, exitCode };
+    // ESLint
+    {
+        const es = [];
+        for (const line of combined.split(/\r?\n/)) {
+            const m = ESLINT_LINE.exec(line);
+            if (m && m[1] && m[2] && m[3] && m[5])
+                es.push({ path: m[1], line: Number(m[2]), column: Number(m[3]), code: m[6], message: m[5] });
+        }
+        if (es.length > 0)
+            return { type: 'lint', files: dedupe(es), raw: combined, exitCode };
+    }
+    // ruff / flake8
+    {
+        const rf = [];
+        for (const line of combined.split(/\r?\n/)) {
+            const m = RUFF_LINE.exec(line);
+            if (m && m[1] && m[2] && m[3] && m[4] && m[5])
+                rf.push({ path: m[1], line: Number(m[2]), column: Number(m[3]), code: m[4], message: m[5] });
+        }
+        if (rf.length > 0)
+            return { type: 'lint', files: dedupe(rf), raw: combined, exitCode };
+    }
+    // mypy
+    {
+        const mp = [];
+        for (const line of combined.split(/\r?\n/)) {
+            const m = MYPY_LINE.exec(line);
+            if (m && m[1] && m[2] && m[3] && m[4])
+                mp.push({ path: m[1], line: Number(m[2]), code: m[4], message: m[3] });
+        }
+        if (mp.length > 0)
+            return { type: 'type', files: dedupe(mp), raw: combined, exitCode };
+    }
+    // gcc/clang, vite/webpack
+    {
+        const gc = [];
+        for (const line of combined.split(/\r?\n/)) {
+            const m = GCC_LINE.exec(line);
+            if (m && m[1] && m[2] && m[3] && m[4])
+                gc.push({ path: m[1], line: Number(m[2]), column: Number(m[3]), message: m[4] });
+            else if (VITE_ERROR.test(line))
+                gc.push({ path: '', message: line.trim() });
+        }
+        if (gc.length > 0)
+            return { type: 'build', files: dedupe(gc), raw: combined, exitCode };
     }
     // Runtime exception.
     const lines = combined.split(/\r?\n/);
@@ -53,10 +192,36 @@ export function detect(stdout, stderr, exitCode) {
     }
     // Generic build.
     if (/error/i.test(combined)) {
+        const gf = extractGeneric(combined, 5);
+        if (gf.length > 0)
+            return { type: 'build', files: gf, raw: combined, exitCode };
         return { type: 'build', files: extractFirstLines(combined, 5), raw: combined, exitCode };
     }
     return { type: 'unknown', files: extractFirstLines(combined, 3), raw: combined, exitCode };
 }
+function dedupe(files) {
+    const seen = new Set();
+    const out = [];
+    for (const f of files) {
+        const key = `${f.path}:${f.line ?? ''}:${f.column ?? ''}:${f.message}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(f);
+        }
+    }
+    return out;
+}
+function extractGeneric(s, n) {
+    const out = [];
+    for (const line of s.split(/\r?\n/)) {
+        const m = GENERIC_FILE_LINE.exec(line);
+        if (m && m[1] && m[2] && m[4])
+            out.push({ path: m[1], line: Number(m[2]), column: m[3] ? Number(m[3]) : undefined, message: m[4] });
+        if (out.length >= n)
+            break;
+    }
+    return out;
+}
 function extractFirstLines(s, n) {
     return s
         .split(/\r?\n/)

package/dist/verification/registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 6.1 — Verifier registry
+ * Detects available verifiers from project heuristics (package.json / Makefile / pyproject / Cargo).
+ * Each verifier is a named command that can be run via `verify` engine.
+ */
+export type VerifierKind = 'tests' | 'typecheck' | 'lint' | 'build' | 'format-check' | 'custom';
+export interface Verifier {
+    id: VerifierKind;
+    label: string;
+    command: string;
+    priority: number;
+}
+export declare function detectVerifiers(cwd: string): Verifier[];
+export declare function primaryVerifyCommand(cwd: string): string | null;
+export interface VerifySettings {
+    commands?: string[];
+    onEdit?: boolean;
+    afterChange?: boolean;
+    beforeDone?: boolean;
+    maxRepairs?: number;
+    requireVerify?: boolean;
+}
+export declare function resolveVerifySettings(raw: Record<string, unknown> | undefined): VerifySettings;

package/dist/verification/registry.js

@@ -0,0 +1,130 @@
+/**
+ * 6.1 — Verifier registry
+ * Detects available verifiers from project heuristics (package.json / Makefile / pyproject / Cargo).
+ * Each verifier is a named command that can be run via `verify` engine.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function exists(p) {
+    try {
+        return fs.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+function readJson(p) {
+    try {
+        const raw = fs.readFileSync(p, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function pm(cwd) {
+    if (exists(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (exists(path.join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (exists(path.join(cwd, 'bun.lockb')))
+        return 'bun';
+    return 'npm';
+}
+function runCmd(base, cwd) {
+    const m = pm(cwd);
+    if (base === 'test')
+        return `${m} test`;
+    if (base === 'build')
+        return `${m} run build`;
+    if (base === 'lint')
+        return `${m} run lint`;
+    return `${m} run ${base}`;
+}
+export function detectVerifiers(cwd) {
+    const out = [];
+    const pkg = readJson(path.join(cwd, 'package.json'));
+    const hasPkg = !!pkg;
+    // tests — highest priority
+    if (hasPkg && pkg?.scripts?.test) {
+        out.push({ id: 'tests', label: 'tests', command: runCmd('test', cwd), priority: 10 });
+    }
+    else if (exists(path.join(cwd, 'pyproject.toml')) || exists(path.join(cwd, 'requirements.txt')) || exists(path.join(cwd, 'setup.py'))) {
+        // pytest heuristic — check pyproject for pytest
+        out.push({ id: 'tests', label: 'pytest', command: 'pytest', priority: 10 });
+    }
+    else if (exists(path.join(cwd, 'go.mod'))) {
+        out.push({ id: 'tests', label: 'go test', command: 'go test ./...', priority: 10 });
+    }
+    else if (exists(path.join(cwd, 'Cargo.toml'))) {
+        out.push({ id: 'tests', label: 'cargo test', command: 'cargo test', priority: 10 });
+    }
+    else if (exists(path.join(cwd, 'Makefile')) || exists(path.join(cwd, 'makefile'))) {
+        try {
+            const mk = fs.readFileSync(path.join(cwd, exists(path.join(cwd, 'Makefile')) ? 'Makefile' : 'makefile'), 'utf-8');
+            if (/^test:/m.test(mk))
+                out.push({ id: 'tests', label: 'make test', command: 'make test', priority: 10 });
+        }
+        catch { /* ignore */ }
+    }
+    // typecheck
+    if (exists(path.join(cwd, 'tsconfig.json'))) {
+        out.push({ id: 'typecheck', label: 'tsc', command: 'npx tsc --noEmit', priority: 20 });
+    }
+    else if (exists(path.join(cwd, 'pyproject.toml'))) {
+        try {
+            const py = fs.readFileSync(path.join(cwd, 'pyproject.toml'), 'utf-8');
+            if (py.includes('mypy'))
+                out.push({ id: 'typecheck', label: 'mypy', command: 'mypy .', priority: 20 });
+        }
+        catch { /* ignore */ }
+    }
+    // lint — check for eslint config or lint script
+    if (hasPkg && pkg?.scripts?.lint) {
+        out.push({ id: 'lint', label: 'lint', command: runCmd('lint', cwd), priority: 30 });
+    }
+    else if (exists(path.join(cwd, '.eslintrc.json')) || exists(path.join(cwd, '.eslintrc.js')) || exists(path.join(cwd, '.eslintrc.cjs')) || exists(path.join(cwd, 'eslint.config.js')) || exists(path.join(cwd, 'eslint.config.cjs')) || exists(path.join(cwd, 'eslint.config.mjs'))) {
+        out.push({ id: 'lint', label: 'eslint', command: 'npx eslint .', priority: 30 });
+    }
+    else if (exists(path.join(cwd, 'ruff.toml')) || exists(path.join(cwd, '.ruff.toml')) || exists(path.join(cwd, 'pyproject.toml'))) {
+        try {
+            if (exists(path.join(cwd, 'pyproject.toml'))) {
+                const py2 = fs.readFileSync(path.join(cwd, 'pyproject.toml'), 'utf-8');
+                if (py2.includes('[tool.ruff]'))
+                    out.push({ id: 'lint', label: 'ruff', command: 'ruff check .', priority: 30 });
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // build
+    if (hasPkg && pkg?.scripts?.build) {
+        out.push({ id: 'build', label: 'build', command: runCmd('build', cwd), priority: 40 });
+    }
+    // format-check
+    if (exists(path.join(cwd, '.prettierrc')) || exists(path.join(cwd, '.prettierrc.json')) || exists(path.join(cwd, 'prettier.config.js')) || exists(path.join(cwd, '.prettierrc.cjs'))) {
+        out.push({ id: 'format-check', label: 'prettier', command: 'npx prettier --check .', priority: 50 });
+    }
+    else if (hasPkg && pkg?.scripts?.['format:check']) {
+        out.push({ id: 'format-check', label: 'format:check', command: runCmd('format:check', cwd), priority: 50 });
+    }
+    return out.sort((a, b) => a.priority - b.priority);
+}
+export function primaryVerifyCommand(cwd) {
+    const v = detectVerifiers(cwd);
+    return v[0]?.command ?? null;
+}
+export function resolveVerifySettings(raw) {
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const v = raw.verify;
+    if (!v || typeof v !== 'object')
+        return {};
+    return {
+        commands: Array.isArray(v.commands) ? v.commands : undefined,
+        onEdit: typeof v.onEdit === 'boolean' ? v.onEdit : undefined,
+        afterChange: typeof v.afterChange === 'boolean' ? v.afterChange : undefined,
+        beforeDone: typeof v.beforeDone === 'boolean' ? v.beforeDone : undefined,
+        maxRepairs: typeof v.maxRepairs === 'number' ? v.maxRepairs : undefined,
+        requireVerify: typeof v.requireVerify === 'boolean' ? v.requireVerify : undefined,
+    };
+}

package/dist/verification/scoped.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 6.3 — Scoped runs & sanity checks
+ * Edited files → related tests (name match), scoped verify command, syntax + import checks.
+ */
+export declare function findRelatedTests(cwd: string, editedFiles: string[]): string[];
+export declare function buildScopedCommand(cwd: string, baseCommand: string, relatedTests: string[]): string | null;
+export declare function runScopedVerify(cwd: string, command: string, timeoutMs?: number): Promise<{
+    ok: boolean;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+/** Quick syntax check: try to parse file with node --check or tsc snippet */
+export declare function syntaxCheck(cwd: string, file: string): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/** Import-path existence check (TS/JS): read file, extract imports, verify targets exist */
+export declare function checkImports(cwd: string, file: string): {
+    ok: boolean;
+    missing: string[];
+};