klyro 0.1.17 → 0.1.19

package/dist/tools/fs/write-file.js

@@ -9,7 +9,7 @@ import * as path from 'node:path';
 import * as crypto from 'node:crypto';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
-import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { resolveAndFollowSymlinks } from '../../policy/path-guard.js';
 import { safe } from '../normalize.js';
 const InputSchema = z.object({
     path: z.string().min(1).describe('Path relative to cwd or absolute (must be inside cwd)'),
@@ -26,7 +26,7 @@ export const writeFileTool = defineTool({
     renderResult: (output) => `${output.path} written ${output.bytesWritten} bytes`,
     execute: async (input, ctx) => {
         return safe(async () => {
-            const { resolved } = resolveWithinCwd(ctx.cwd, input.path);
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
             const parent = path.dirname(resolved);
             await fs.mkdir(parent, { recursive: true });
             // 3.2: if file exists and was not read this session, warn but allow with diff

package/dist/tools/search/grep.d.ts

@@ -31,6 +31,26 @@ export declare const grepTool: import("../types.js").Tool<{
     maxResults?: number | undefined;
     contextLines?: number | undefined;
 }, {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "INVALID_INPUT";
+        readonly message: "Pattern too long (max 200 chars)";
+    };
+    pattern?: undefined;
+    hits?: undefined;
+    truncated?: undefined;
+    searchedFiles?: undefined;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "INVALID_INPUT";
+        readonly message: "Pattern rejected (potential ReDoS)";
+    };
+    pattern?: undefined;
+    hits?: undefined;
+    truncated?: undefined;
+    searchedFiles?: undefined;
+} | {
     readonly ok: false;
     readonly error: {
         readonly code: "INVALID_INPUT";

package/dist/tools/search/grep.js

@@ -24,6 +24,13 @@ export const grepTool = defineTool({
     inputSchema: InputSchema,
     execute: async (input, ctx) => {
         return safe(async () => {
+            if (input.pattern.length > 200) {
+                return { ok: false, error: { code: TOOL_ERROR_CODES.INVALID_INPUT, message: 'Pattern too long (max 200 chars)' } };
+            }
+            // reject catastrophic backtracking patterns (nested quantifiers like (a+)+ )
+            if (/\([^)]*\+[^)]*\)\+|\(\.\*\)\*|\{[0-9]+,[0-9]*\}\s*\+/.test(input.pattern)) {
+                return { ok: false, error: { code: TOOL_ERROR_CODES.INVALID_INPUT, message: 'Pattern rejected (potential ReDoS)' } };
+            }
             const base = input.cwd ? resolveWithinCwd(ctx.cwd, input.cwd).resolved : ctx.cwd;
             let re;
             try {

package/dist/tools/shell/background.js

@@ -4,7 +4,28 @@
 import { spawn } from 'node:child_process';
 const jobs = new Map();
 let counter = 0;
+const MAX_JOBS = 5;
+const JOB_TTL_MS = 10 * 60 * 1000;
+function pruneJobs() {
+    if (jobs.size <= MAX_JOBS)
+        return;
+    const sorted = [...jobs.values()].sort((a, b) => a.start - b.start);
+    for (const j of sorted.slice(0, jobs.size - MAX_JOBS)) {
+        try {
+            j.proc.kill('SIGKILL');
+        }
+        catch { /* ignore */ }
+        jobs.delete(j.id);
+    }
+    for (const j of [...jobs.values()]) {
+        if (Date.now() - j.start > JOB_TTL_MS && j.proc.exitCode !== null)
+            jobs.delete(j.id);
+    }
+}
 export function startBackground(command, cwd) {
+    pruneJobs();
+    if (jobs.size >= MAX_JOBS)
+        throw new Error(`Too many background jobs (max ${MAX_JOBS}) — kill one with /jobs`);
     const id = `job-${++counter}-${Date.now().toString(36)}`;
     const proc = spawn(command, { cwd, shell: true, windowsHide: true });
     const job = { id, command, cwd, proc, output: '', start: Date.now() };
@@ -13,7 +34,10 @@ export function startBackground(command, cwd) {
         job.output = job.output.slice(-1_000_000); });
     proc.stderr?.on('data', (b) => { job.output += b.toString(); if (job.output.length > 1_000_000)
         job.output = job.output.slice(-1_000_000); });
-    proc.on('close', () => { });
+    proc.on('close', () => {
+        setTimeout(() => { if (jobs.get(id)?.proc.exitCode !== null)
+            jobs.delete(id); }, JOB_TTL_MS);
+    });
     return id;
 }
 export function getOutput(id, filter) {

package/dist/tools/shell/shell-exec.js

@@ -77,6 +77,13 @@ const DANGEROUS_PATTERNS = [
     { pattern: /curl.*\|\s*(sh|bash|zsh|python|python3|perl|ruby|php)/i, reason: 'curl|sh to unknown host' },
     { pattern: /wget.*\|\s*(sh|bash|python|perl|ruby)/i, reason: 'wget|sh pipe' },
     { pattern: /rm\s+-rf\s+--no-preserve-root\s+\//, reason: 'recursive delete --no-preserve-root' },
+    // Shell metacharacter escapes — block command substitution and chaining of dangerous cmds
+    { pattern: /\$\(/, reason: 'command substitution $()' },
+    { pattern: /`[^`]*`/, reason: 'command substitution via backticks' },
+    { pattern: /\|\s*bash\b|\|\s*sh\b/, reason: 'pipe to shell' },
+    { pattern: /;\s*rm\s+-rf/, reason: 'chained rm -rf' },
+    { pattern: /&&\s*rm\s+-rf/, reason: 'chained rm -rf' },
+    { pattern: /\|\|\s*rm\s+-rf/, reason: 'chained rm -rf' },
 ];
 export const shellExecTool = defineTool({
     name: 'shell_exec',

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,115 @@
+/**
+ * 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;
+}
+const MAX_BASELINE_BYTES = 256 * 1024;
+function cap(cur, chunk) {
+    if (cur.length >= MAX_BASELINE_BYTES)
+        return cur;
+    const n = cur + chunk;
+    return n.length > MAX_BASELINE_BYTES ? n.slice(0, MAX_BASELINE_BYTES) + '\n... [truncated]' : n;
+}
+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 = cap(stdout, b.toString()); });
+        child.stderr.on('data', (b) => { stderr = cap(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/engine.js

@@ -9,6 +9,14 @@
  */
 import { spawn } from 'node:child_process';
 import { detect, summarize } from './detect.js';
+import { redact } from '../policy/secret-redactor.js';
+const MAX_VERIFY_BYTES = 256 * 1024;
+function appendCapped(current, chunk) {
+    if (current.length >= MAX_VERIFY_BYTES)
+        return current;
+    const next = current + chunk;
+    return next.length > MAX_VERIFY_BYTES ? next.slice(0, MAX_VERIFY_BYTES) + '\n... [truncated]' : next;
+}
 export async function verify(opts) {
     const timeout = opts.timeoutMs ?? 5 * 60 * 1000;
     return new Promise((resolve) => {
@@ -30,8 +38,8 @@ export async function verify(opts) {
                 failure: { type: 'runtime', files: [], raw, exitCode: -1 },
             });
         }, timeout);
-        child.stdout.on('data', (b) => { stdout += b.toString(); });
-        child.stderr.on('data', (b) => { stderr += b.toString(); });
+        child.stdout.on('data', (b) => { stdout = appendCapped(stdout, b.toString()); });
+        child.stderr.on('data', (b) => { stderr = appendCapped(stderr, b.toString()); });
         child.on('close', (code) => {
             if (done)
                 return;
@@ -53,5 +61,8 @@ export function diagnosticForModel(result) {
         return 'Verification passed.';
     if (!result.failure)
         return `Verification failed with exit ${result.exitCode}.`;
-    return summarize(result.failure);
+    // redact raw before summarizing so secrets don't enter transcript
+    const redactedRaw = redact(result.failure.raw);
+    const redactedFailure = { ...result.failure, raw: redactedRaw, files: result.failure.files.map((f) => ({ ...f, message: redact(f.message) })) };
+    return summarize(redactedFailure);
 }

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;