klyro 0.1.17 → 0.1.18

package/dist/agent/runtime.d.ts

@@ -76,6 +76,7 @@ export interface RunOptions {
         command?: string;
         maxRepairAttempts?: number;
         timeoutMs?: number;
+        requireVerify?: boolean;
     };
     /**
      * Level 9 — persistence. When a SessionStore is provided, every message

package/dist/agent/runtime.js

@@ -17,8 +17,12 @@
 import { text, toolUse, toolResult as mkToolResult } from './message.js';
 import { redact } from '../policy/secret-redactor.js';
 import { RuntimeTelemetry, emptyTelemetryBlock, summarizeToolCall } from '../context/level7.js';
+import * as path from 'node:path';
 import { verify, diagnosticForModel } from '../verification/engine.js';
 import { detectVerifyCommand } from '../verification/auto.js';
+import { ensureBaseline, getBaseline } from '../verification/baseline.js';
+import { classifyFailure, rerunOnce, gatherRepairContext, guardRepair } from '../verification/classify.js';
+import { findRelatedTests, buildScopedCommand, runScopedVerify, syntaxCheck, checkImports } from '../verification/scoped.js';
 import { globalBus } from '../events/bus.js';
 import { TraceWriter } from '../trace/writer.js';
 const DEFAULT_MAX_STEPS = 30;
@@ -92,6 +96,20 @@ export async function run(opts, deps) {
     };
     const store = opts.persist?.store;
     const sessionId = opts.persist?.sessionId;
+    // 6.1 baseline cache per HEAD — capture before first edit
+    let baselinePrimed = false;
+    async function primeBaseline() {
+        if (baselinePrimed)
+            return;
+        baselinePrimed = true;
+        const cmd = opts.verify?.command ?? detectVerifyCommand(opts.cwd);
+        if (!cmd)
+            return;
+        try {
+            await ensureBaseline(opts.cwd, cmd);
+        }
+        catch { /* ignore */ }
+    }
     async function checkpoint(msg, obs) {
         if (!store || !sessionId)
             return;
@@ -271,13 +289,53 @@ export async function run(opts, deps) {
             if (verifyEnabled && hasEdits && verifyCmd && verificationAttempts < maxRepairs) {
                 emit?.({ kind: 'verification_started', command: verifyCmd });
                 let vResult;
+                // 6.3 — scoped run if edited files known
+                const edited = [...fileEditCounts.keys()];
+                const related = findRelatedTests(opts.cwd, edited);
+                const scopedCmd = buildScopedCommand(opts.cwd, verifyCmd, related);
+                const cmdToRun = scopedCmd ?? verifyCmd;
+                const isScoped = !!scopedCmd;
+                if (isScoped)
+                    emit?.({ kind: 'verification_started', command: cmdToRun });
                 try {
-                    vResult = await verify({ cwd: opts.cwd, command: verifyCmd, timeoutMs: opts.verify?.timeoutMs });
+                    if (isScoped) {
+                        const sr = await runScopedVerify(opts.cwd, cmdToRun, opts.verify?.timeoutMs);
+                        const det = sr.ok ? undefined : (await import('../verification/detect.js')).detect(sr.stdout, sr.stderr, sr.exitCode);
+                        vResult = { ok: sr.ok, exitCode: sr.exitCode, stdout: sr.stdout, stderr: sr.stderr, ...(det ? { failure: det } : {}) };
+                    }
+                    else {
+                        vResult = await verify({ cwd: opts.cwd, command: cmdToRun, timeoutMs: opts.verify?.timeoutMs });
+                    }
                 }
                 catch (e) {
                     const msg = e instanceof Error ? e.message : String(e);
                     vResult = { ok: false, exitCode: -1, stdout: '', stderr: msg, failure: { type: 'unknown', files: [], raw: msg, exitCode: -1 } };
                 }
+                // 6.3 — sanity checks before full verify
+                if (vResult.ok) {
+                    // quick syntax/import guard for last edited files
+                    for (const f of edited.slice(-3)) {
+                        const sc = await syntaxCheck(opts.cwd, f);
+                        if (!sc.ok) {
+                            vResult = { ok: false, exitCode: 1, stdout: '', stderr: sc.error ?? `syntax error ${f}`, failure: { type: 'build', files: [{ path: f, message: sc.error ?? 'syntax error' }], raw: sc.error ?? '', exitCode: 1 } };
+                            break;
+                        }
+                        const ic = checkImports(opts.cwd, f);
+                        if (!ic.ok) {
+                            vResult = { ok: false, exitCode: 1, stdout: '', stderr: `missing imports in ${f}: ${ic.missing.join(', ')}`, failure: { type: 'build', files: ic.missing.map((m) => ({ path: f, message: `missing import ${m}` })), raw: `missing imports ${ic.missing.join(', ')}`, exitCode: 1 } };
+                            break;
+                        }
+                    }
+                }
+                // If scoped passed but full may still fail, run full before declaring success
+                if (vResult.ok && isScoped) {
+                    try {
+                        const full = await verify({ cwd: opts.cwd, command: verifyCmd, timeoutMs: opts.verify?.timeoutMs });
+                        if (!full.ok)
+                            vResult = full;
+                    }
+                    catch { /* scoped success is enough */ }
+                }
                 if (vResult.ok) {
                     emit?.({ kind: 'verification_succeeded', command: verifyCmd });
                     emit?.({ kind: 'final_text', text: finalText });
@@ -291,16 +349,90 @@ export async function run(opts, deps) {
                     await closeTracer();
                     return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: true, command: verifyCmd, attempts: verificationAttempts } };
                 }
-                // Failure → repair loop
+                // 6.4 — classify
+                const baseline = await getBaseline(opts.cwd, verifyCmd);
+                const isFlaky = await rerunOnce(opts.cwd, cmdToRun, 30_000);
+                const cls = classifyFailure({ failure: vResult.failure, stdout: vResult.stdout, stderr: vResult.stderr }, baseline, isFlaky);
+                if (cls === 'flaky') {
+                    // rerun succeeded on second try — treat as flaky, don't count as repair
+                    emit?.({ kind: 'verification_succeeded', command: verifyCmd });
+                    emit?.({ kind: 'final_text', text: finalText });
+                    emit?.({ kind: 'step_end', step: steps });
+                    if (store && sessionId) {
+                        try {
+                            await store.setStatus(sessionId, 'complete', finalText);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    await closeTracer();
+                    return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: true, command: verifyCmd, attempts: verificationAttempts } };
+                }
+                if (cls === 'env') {
+                    // don't try to repair env failures with code edits
+                    const envMsg = { role: 'user', content: [text(`Verification failed due to environment issue (not code):\n\n${diagnosticForModel(vResult)}\n\nPlease suggest how to fix the environment (install deps, set env vars) rather than editing code. If this is a missing binary, ask the user.`)] };
+                    transcript.push(envMsg);
+                    await checkpoint(envMsg);
+                    verificationAttempts++;
+                    emit?.({ kind: 'verification_failed', step: String(steps), reason: `env: ${diagnosticForModel(vResult).slice(0, 600)}` });
+                    if (verificationAttempts >= maxRepairs) {
+                        await closeTracer();
+                        return { status: 'verify_failed', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: false, command: verifyCmd, attempts: verificationAttempts, failureType: 'env' } };
+                    }
+                    emit?.({ kind: 'step_end', step: steps });
+                    continue;
+                }
+                if (cls === 'pre_existing') {
+                    // pre-existing — don't penalize, but still surface
+                    const preMsg = { role: 'user', content: [text(`Note: verification failure appears pre-existing (present in baseline at HEAD). Current failure:\n\n${diagnosticForModel(vResult)}\n\nIf this failure is unrelated to your changes, you may proceed, but try to avoid making it worse.`)] };
+                    transcript.push(preMsg);
+                    await checkpoint(preMsg);
+                    // still count as needing repair if introduced files overlap, else allow completion
+                    // For now, treat pre-existing as non-blocking after one warning if no introduced files in failure
+                    const introducedPaths = new Set(edited);
+                    const failurePaths = new Set(vResult.failure?.files.map((f) => f.path).filter(Boolean) ?? []);
+                    const overlaps = [...failurePaths].some((p) => introducedPaths.has(p) || introducedPaths.has(path.basename(p)));
+                    if (!overlaps) {
+                        emit?.({ kind: 'verification_succeeded', command: verifyCmd });
+                        emit?.({ kind: 'final_text', text: finalText });
+                        emit?.({ kind: 'step_end', step: steps });
+                        if (store && sessionId) {
+                            try {
+                                await store.setStatus(sessionId, 'complete', finalText);
+                            }
+                            catch { /* ignore */ }
+                        }
+                        await closeTracer();
+                        return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: true, command: verifyCmd, attempts: verificationAttempts } };
+                    }
+                }
+                // Failure → repair loop (introduced)
                 verificationAttempts++;
                 const diagnostic = diagnosticForModel(vResult);
                 const failureType = vResult.failure?.type ?? 'unknown';
+                // 6.4 — gather context
+                const ctx = await gatherRepairContext(opts.cwd, vResult.failure);
+                const ctxBlock = [
+                    ctx.hunks ? `Changed hunks:\n${ctx.hunks.slice(0, 1500)}` : '',
+                    ctx.failingTests.length > 0 ? `Failing test excerpt:\n${ctx.failingTests[0]?.content.slice(0, 1500)}` : '',
+                    ctx.blame ? `Blame:\n${ctx.blame.slice(0, 800)}` : '',
+                ].filter(Boolean).join('\n\n');
                 emit?.({ kind: 'verification_failed', step: String(steps), reason: diagnostic.slice(0, 800) });
                 emit?.({ kind: 'repair_started', attempt: verificationAttempts, maxAttempts: maxRepairs, reason: diagnostic.slice(0, 400) });
                 telemetry.recordError(`verify_${failureType}`);
+                // 6.4 guard — check if last diff touches assertions/skips (would need approval)
+                try {
+                    const diffText = await (await import('node:fs/promises')).readFile(path.join(opts.cwd, '.klyro', 'checkpoints', 'last.diff'), 'utf-8').catch(() => ctx.hunks);
+                    const g = guardRepair(diffText ?? ctx.hunks, edited);
+                    if (g.blocked) {
+                        const guardMsg = { role: 'user', content: [text(`Repair guard blocked: ${g.reason}\n\nIf you must edit test assertions or add skips, first ask the user for explicit approval via ask_user.`)] };
+                        transcript.push(guardMsg);
+                        await checkpoint(guardMsg);
+                    }
+                }
+                catch { /* ignore guard */ }
                 const repairMsg = {
                     role: 'user',
-                    content: [text(`Verification failed (attempt ${verificationAttempts}/${maxRepairs}) running \`${verifyCmd}\`:\n\n${diagnostic}\n\nPlease analyze the failure, re-read the failing files, and repair the code. Focus on the error above.`)],
+                    content: [text(`Verification failed (attempt ${verificationAttempts}/${maxRepairs}, class=${cls}) running \`${verifyCmd}\`:\n\n${diagnostic}\n\n${ctxBlock ? `\nContext:\n${ctxBlock}\n` : ''}\nPlease analyze the failure, re-read the failing files, and repair the code. Focus on the error above. Do not edit test assertions unless the test itself is wrong — fix the source.`)],
                 };
                 transcript.push(repairMsg);
                 await checkpoint(repairMsg);
@@ -398,8 +530,11 @@ export async function run(opts, deps) {
             await checkpoint(toolMsg, { toolCallId: call.id, toolName: call.name, input: call.input, output, isError: !obs.ok });
             if (obs.ok) {
                 telemetry.recordToolCall(call, latencyMs, false);
-                if (call.name === 'write_file' || call.name === 'edit_file')
+                if (call.name === 'write_file' || call.name === 'edit_file' || call.name === 'multi_edit' || call.name === 'apply_patch')
                     hasEdits = true;
+                // 6.1 — prime baseline on first edit
+                if (hasEdits && !baselinePrimed)
+                    void primeBaseline();
             }
             else {
                 const code = String(obs.error?.code ?? 'tool_error');

package/dist/cli/eval.js

@@ -61,6 +61,21 @@ export async function runEval(opts) {
             for (const e of entries) {
                 if (opts.filter && !e.includes(opts.filter))
                     continue;
+                // 6.5 — suite filter: smoke = type smoke, l6 = prefix l6-introduce
+                if (opts.suite && opts.suite !== 'smoke') {
+                    if (!e.startsWith(opts.suite) && !e.includes(opts.suite))
+                        continue;
+                }
+                else if (opts.suite === 'smoke') {
+                    // smoke = only type smoke (exclude l6 introduce fixtures)
+                    try {
+                        const metaRaw = await fs.readFile(path.join(fixturesDir, e, 'meta.json'), 'utf-8');
+                        const meta = JSON.parse(metaRaw);
+                        if (meta.suite === 'l6' || meta.type === 'l6-introduce')
+                            continue;
+                    }
+                    catch { /* no meta → include */ }
+                }
                 const taskPath = path.join(fixturesDir, e, 'task.md');
                 try {
                     const task = await fs.readFile(taskPath, 'utf-8');

package/dist/cli/repl.js

@@ -480,6 +480,29 @@ export async function startRepl(opts = {}) {
                 }
                 return;
             }
+            case 'verify': {
+                const { detectVerifiers, primaryVerifyCommand } = await import('../verification/registry.js');
+                const { verify } = await import('../verification/engine.js');
+                const verifiers = detectVerifiers(cwd);
+                if (verifiers.length === 0) {
+                    queuedAppend({ id: `vrfy-${Date.now()}`, kind: 'text', text: 'No verifiers detected (no test/typecheck/lint/build). Try `npm test` manually.', role: 'assistant' });
+                    return;
+                }
+                const list = verifiers.map((v) => `  ${v.id}: ${v.command}`).join('\n');
+                queuedAppend({ id: `vrfy-list-${Date.now()}`, kind: 'text', text: `Verifiers:\n${list}`, role: 'assistant' });
+                const cmd = primaryVerifyCommand(cwd);
+                if (!cmd)
+                    return;
+                queuedAppend({ id: `vrfy-run-${Date.now()}`, kind: 'text', text: `[verify] running \`${cmd}\`...`, role: 'assistant' });
+                try {
+                    const res = await verify({ cwd, command: cmd });
+                    queuedAppend({ id: `vrfy-res-${Date.now()}`, kind: 'text', text: res.ok ? `[verify] passed (${cmd})` : `[verify] failed (${cmd}): ${res.stderr.slice(0, 500)}`, role: 'assistant' });
+                }
+                catch (err) {
+                    queuedAppend({ id: `vrfy-err-${Date.now()}`, kind: 'error', message: `verify failed: ${err instanceof Error ? err.message : String(err)}` });
+                }
+                return;
+            }
             case 'compact':
                 queuedAppend({
                     id: `stub-${Date.now()}`,

package/dist/cli/run.d.ts

@@ -59,6 +59,7 @@ export interface RunCliOptions {
     verifyCommand?: string;
     maxRepairAttempts?: number;
     verifyTimeoutMs?: number;
+    requireVerify?: boolean;
     /** Level 9 — persistence */
     persist?: boolean;
     sessionId?: string;

package/dist/cli/run.js

@@ -110,6 +110,7 @@ export async function runOnce(opts) {
             command: opts.verifyCommand,
             maxRepairAttempts: opts.maxRepairAttempts ?? 3,
             timeoutMs: opts.verifyTimeoutMs,
+            requireVerify: opts.requireVerify,
         };
     const result = await run({
         task: opts.task,
@@ -212,6 +213,22 @@ export async function runOnce(opts) {
             stderr.write(`klyro: verification failed after ${result.verification?.attempts ?? 3} repairs — see output above\n`);
         return 5;
     }
+    // 6.5 — --require-verify: if edits were made but verification never passed, exit 8
+    if (opts.requireVerify && result.verification && !result.verification.ok) {
+        if (output === 'json')
+            stdout.write(JSON.stringify({ kind: 'final', status: 'require_verify_failed' }) + '\n');
+        else
+            stderr.write('klyro: --require-verify: verification required but not passed\n');
+        return 8;
+    }
+    if (opts.requireVerify && !result.verification) {
+        // hasEdits but no verification command found
+        if (output === 'json')
+            stdout.write(JSON.stringify({ kind: 'final', status: 'require_verify_missing' }) + '\n');
+        else
+            stderr.write('klyro: --require-verify: no verification command found and edits were made\n');
+        return 8;
+    }
     if (output === 'json')
         stdout.write(JSON.stringify({ kind: 'final', status: 'ok', text: result.finalText }) + '\n');
     return 0;

package/dist/cli/slash/parser.d.ts

@@ -49,6 +49,8 @@ export type SlashCommand = {
     kind: 'memory';
 } | {
     kind: 'jobs';
+} | {
+    kind: 'verify';
 } | {
     kind: 'prompt';
     text: string;

package/dist/cli/slash/parser.js

@@ -14,7 +14,7 @@
  * Anything not starting with "/" is a regular prompt and yields
  * { kind: 'prompt', text }.
  */
-const KNOWN = ['clear', 'compact', 'model', 'diff', 'undo', 'rewind', 'plan', 'status', 'quit', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'memory', 'jobs', 'exit', 'clear'];
+const KNOWN = ['clear', 'compact', 'model', 'diff', 'undo', 'rewind', 'plan', 'status', 'quit', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'memory', 'jobs', 'verify', 'exit', 'clear'];
 export function parse(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/')) {
@@ -35,6 +35,7 @@ export function parse(input) {
         case 'thinking': return { kind: 'thinking' };
         case 'memory': return { kind: 'memory' };
         case 'jobs': return { kind: 'jobs' };
+        case 'verify': return { kind: 'verify' };
         case 'quit':
         case 'exit':
         case 'q': return { kind: 'quit' };

package/dist/index.js

@@ -296,6 +296,7 @@ async function main() {
         .option('--verify-command <cmd>', 'Custom verification command (default: auto-detected)')
         .option('--max-repairs <n>', 'Max autonomous repair attempts (default 3)', (v) => parsePositiveInt('--max-repairs', v))
         .option('--persist', 'Enable session persistence (Level 9, default: enabled)')
+        .option('--require-verify', 'Fail with exit 8 if no verification passed after edits (6.5)')
         .action(async (prompt, opts) => {
         const model = opts.model ?? process.env.KLYRO_MODEL;
         if (!model) {
@@ -328,6 +329,7 @@ async function main() {
                 verifyCommand: opts.verifyCommand,
                 maxRepairAttempts: opts.maxRepairs,
                 persist: opts.persist,
+                requireVerify: !!opts.requireVerify,
             });
             process.exit(code);
         }

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[];
+};

package/dist/verification/scoped.js

@@ -0,0 +1,214 @@
+/**
+ * 6.3 — Scoped runs & sanity checks
+ * Edited files → related tests (name match), scoped verify command, syntax + import checks.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+export function findRelatedTests(cwd, editedFiles) {
+    if (editedFiles.length === 0)
+        return [];
+    const allTests = [];
+    // collect candidate test files via simple walk (respect .gitignore minimally)
+    function walk(dir, depth = 0) {
+        if (depth > 6)
+            return;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === 'dist' || e.name === '.klyro')
+                continue;
+            const p = path.join(dir, e.name);
+            if (e.isDirectory())
+                walk(p, depth + 1);
+            else if (e.isFile() && /(?:\.test\.|\.spec\.|__tests__|test_)/.test(p))
+                allTests.push(p);
+        }
+    }
+    walk(cwd);
+    const related = new Set();
+    for (const edited of editedFiles) {
+        const base = path.basename(edited, path.extname(edited)); // foo.ts -> foo
+        const dir = path.dirname(edited);
+        for (const t of allTests) {
+            const tb = path.basename(t);
+            // name match: foo.ts -> foo.test.ts, test_foo.py, foo_spec.ts, etc.
+            if (tb.includes(base) || base.includes(path.basename(t, path.extname(t)).replace(/\.test|\.spec|test_/g, ''))) {
+                related.add(path.relative(cwd, t));
+            }
+            // same directory prefix also counts
+            if (t.startsWith(dir) && tb.includes(base.slice(0, 4)))
+                related.add(path.relative(cwd, t));
+        }
+    }
+    return [...related];
+}
+export function buildScopedCommand(cwd, baseCommand, relatedTests) {
+    if (relatedTests.length === 0)
+        return null;
+    if (relatedTests.length > 10)
+        return null; // too many → full suite
+    // npm test heuristic: npm test -- <files> or vitest/jest file list
+    if (baseCommand.includes('npm test') || baseCommand.includes('pnpm test') || baseCommand.includes('yarn test') || baseCommand.includes('bun test')) {
+        return `${baseCommand} -- ${relatedTests.map((f) => `"${f}"`).join(' ')}`;
+    }
+    if (baseCommand.includes('pytest')) {
+        return `pytest ${relatedTests.map((f) => `"${f}"`).join(' ')}`;
+    }
+    if (baseCommand.includes('go test')) {
+        // go test ./... with file filter — fallback to full
+        return null;
+    }
+    if (baseCommand.includes('cargo test')) {
+        // cargo test --test <name>
+        return null;
+    }
+    return null;
+}
+export async function runScopedVerify(cwd, command, timeoutMs = 45_000) {
+    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[scoped 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) });
+        });
+    });
+}
+/** Quick syntax check: try to parse file with node --check or tsc snippet */
+export async function syntaxCheck(cwd, file) {
+    const full = path.join(cwd, file);
+    const ext = path.extname(file);
+    if (ext === '.ts' || ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+        // Use tsc transpileModule if available, else node --check for js
+        try {
+            const content = fs.readFileSync(full, 'utf-8');
+            // minimal check: try to parse via new Function (for js) or just check no obvious syntax error via tsc
+            // For now, use tsc --noEmit --skipLibCheck on single file quickly
+            if (ext === '.ts') {
+                // spawn tsc --noEmit --skipLibCheck <file> with 10s timeout
+                const ok = await new Promise((resolve) => {
+                    const child = spawn(`npx tsc --noEmit --skipLibCheck "${full}"`, { cwd, shell: true, env: process.env });
+                    let done = false;
+                    const t = setTimeout(() => { if (!done) {
+                        done = true;
+                        try {
+                            child.kill();
+                        }
+                        catch { }
+                        resolve(false);
+                    } }, 10_000);
+                    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); });
+                });
+                if (!ok)
+                    return { ok: false, error: `syntax error in ${file} (tsc)` };
+                return { ok: true };
+            }
+            // js: node --check
+            const ok2 = await new Promise((resolve) => {
+                const child = spawn(`node --check "${full}"`, { cwd, shell: true, env: process.env });
+                let done = false;
+                const t = setTimeout(() => { if (!done) {
+                    done = true;
+                    try {
+                        child.kill();
+                    }
+                    catch { }
+                    resolve(false);
+                } }, 5000);
+                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); });
+            });
+            if (!ok2)
+                return { ok: false, error: `syntax error in ${file} (node --check)` };
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: String(e) };
+        }
+    }
+    if (ext === '.py') {
+        const ok = await new Promise((resolve) => {
+            const child = spawn(`python -m py_compile "${full}"`, { cwd, shell: true, env: process.env });
+            let done = false;
+            const t = setTimeout(() => { if (!done) {
+                done = true;
+                try {
+                    child.kill();
+                }
+                catch { }
+                resolve(false);
+            } }, 5000);
+            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(true); }); // python may not exist → skip
+        });
+        if (!ok)
+            return { ok: false, error: `syntax error in ${file} (py_compile)` };
+    }
+    return { ok: true };
+}
+/** Import-path existence check (TS/JS): read file, extract imports, verify targets exist */
+export function checkImports(cwd, file) {
+    const full = path.join(cwd, file);
+    const ext = path.extname(file);
+    if (!['.ts', '.js', '.tsx', '.jsx', '.mjs', '.cjs'].includes(ext))
+        return { ok: true, missing: [] };
+    let content = '';
+    try {
+        content = fs.readFileSync(full, 'utf-8');
+    }
+    catch {
+        return { ok: true, missing: [] };
+    }
+    const importRe = /(?:import\s+.*?from\s+['"](.+?)['"]|require\(['"](.+?)['"]\))/g;
+    const missing = [];
+    let m;
+    while ((m = importRe.exec(content))) {
+        const spec = m[1] ?? m[2];
+        if (!spec || !spec.startsWith('.'))
+            continue; // only relative imports
+        const target = path.resolve(path.dirname(full), spec);
+        const candidates = [target, `${target}.ts`, `${target}.js`, `${target}/index.ts`, `${target}/index.js`, `${target}.tsx`];
+        const exists = candidates.some((p) => fs.existsSync(p));
+        if (!exists)
+            missing.push(spec);
+    }
+    return { ok: missing.length === 0, missing };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klyro",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",