klyro 1.0.1 → 1.0.2

package/dist/verification/classify.js

@@ -4,6 +4,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { spawn } from 'node:child_process';
+import { filteredVerifyEnv } from './registry.js';
 import { detect } from './detect.js';
 function signatureOf(failure, fallbackExit) {
     return {
@@ -48,7 +49,7 @@ export function classifyFailure(current, baseline, flakyRerunOk) {
 }
 export async function rerunOnce(cwd, command, timeoutMs = 45_000) {
     return new Promise((resolve) => {
-        const child = spawn(command, { cwd, shell: true, env: process.env });
+        const child = spawn(command, { cwd, shell: true, env: filteredVerifyEnv() });
         let done = false;
         const t = setTimeout(() => { if (!done) {
             done = true;
@@ -92,7 +93,7 @@ export async function gatherRepairContext(cwd, failure) {
 }
 function execCapturePipe(cwd, cmd) {
     return new Promise((resolve) => {
-        const child = spawn(cmd, { cwd, shell: true, env: process.env });
+        const child = spawn(cmd, { cwd, shell: true, env: filteredVerifyEnv() });
         const chunks = [];
         child.stdout.on('data', (b) => { chunks.push(b); });
         child.stderr.on('data', (b) => { chunks.push(b); });
@@ -102,7 +103,7 @@ function execCapturePipe(cwd, cmd) {
 }
 function execCaptureArgv(cwd, file, args) {
     return new Promise((resolve) => {
-        const child = spawn('git', [...args, file], { cwd, shell: false, env: process.env });
+        const child = spawn('git', [...args, file], { cwd, shell: false, env: filteredVerifyEnv() });
         const chunks = [];
         child.stdout.on('data', (b) => { chunks.push(b); });
         child.stderr.on('data', (b) => { chunks.push(b); });

package/dist/verification/engine.d.ts

@@ -8,10 +8,18 @@
  * structured Failure (and the model has had up to N attempts to fix).
  */
 import { type Failure } from './detect.js';
+/** Verification mode. Canonical definition — agent/runtime.ts converges to
+ * this type automatically once this export exists (see its conditional
+ * VerifyMode). Backward-compatible: pure type, no runtime change. */
+export type VerifyMode = 'strict' | 'advisory' | 'off';
 export interface VerifyOptions {
     cwd: string;
     command: string;
     timeoutMs?: number;
+    /** Owning session for `verification.*` bus events. Optional for backward
+     * compatibility — siblings pass `sessionId` at verify call sites; when
+     * absent the emitted events fall back to 'ephemeral'. */
+    sessionId?: string;
 }
 export interface VerifyResult {
     ok: boolean;

package/dist/verification/engine.js

@@ -11,6 +11,7 @@ import { spawn } from 'node:child_process';
 import { detect, summarize } from './detect.js';
 import { filteredVerifyEnv } from './registry.js';
 import { redact } from '../policy/secret-redactor.js';
+import { globalBus } from '../events/bus.js';
 const MAX_VERIFY_BYTES = 256 * 1024;
 function appendCapped(current, chunk) {
     if (current.length >= MAX_VERIFY_BYTES)
@@ -48,9 +49,30 @@ const DANGEROUS_VERIFY_PATTERNS = [
     { pattern: /\|\|\s*rm\s+-rf/, reason: 'chained rm -rf' },
 ];
 export async function verify(opts) {
+    const sid = opts.sessionId ?? 'ephemeral';
+    const emitStarted = () => {
+        try {
+            globalBus.emit({ type: 'verification.started', ts: Date.now(), sessionId: sid, command: opts.command });
+        }
+        catch { /* bus never throws */ }
+    };
+    const emitSucceeded = () => {
+        try {
+            globalBus.emit({ type: 'verification.succeeded', ts: Date.now(), sessionId: sid, command: opts.command });
+        }
+        catch { /* bus never throws */ }
+    };
+    const emitFailed = (reason) => {
+        try {
+            globalBus.emit({ type: 'verification.failed', ts: Date.now(), sessionId: sid, command: opts.command, reason });
+        }
+        catch { /* bus never throws */ }
+    };
+    emitStarted();
     // SEC-004: reject dangerous patterns before spawning
     for (const { pattern, reason } of DANGEROUS_VERIFY_PATTERNS) {
         if (pattern.test(opts.command)) {
+            emitFailed(`Command blocked: ${reason}`);
             return {
                 ok: false,
                 exitCode: -1,
@@ -75,6 +97,7 @@ export async function verify(opts) {
             const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_VERIFY_BYTES);
             const se = Buffer.concat(errChunks).toString('utf-8').slice(0, MAX_VERIFY_BYTES);
             const raw = se + '\n' + so;
+            emitFailed('[verify timeout]');
             resolve({
                 ok: false,
                 exitCode: -1,
@@ -96,10 +119,12 @@ export async function verify(opts) {
             const se = Buffer.concat(errChunks).toString('utf-8').slice(0, MAX_VERIFY_BYTES);
             const exit = typeof code === 'number' ? code : -1;
             if (exit === 0) {
+                emitSucceeded();
                 resolve({ ok: true, exitCode: 0, stdout: so, stderr: se });
                 return;
             }
             const failure = detect(so, se, exit);
+            emitFailed(failure.type);
             resolve({ ok: false, exitCode: exit, stdout: so, stderr: se, failure });
         });
     });

package/dist/verification/registry.js

@@ -5,6 +5,7 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { filteredEnv as siblingFilteredEnv } from '../tools/shell/shell-exec.js';
 function exists(p) {
     try {
         return fs.existsSync(p);
@@ -115,10 +116,13 @@ export function primaryVerifyCommand(cwd) {
 }
 // S2 — filtered env for ALL spawned verify commands.
 //
-// Sibling `tools/shell/shell-exec.ts` owns an equivalent `filteredEnv` but
-// does not export it, so this mirrors that filter (allowlisted prefixes +
-// exact keys, secret-ish names stripped, preload vectors deleted) instead of
-// importing sibling internals.
+// Delegates to the sibling-owned `filteredEnv` from
+// `tools/shell/shell-exec.ts` (EXACT export name — verified via grep) for
+// the allowlist base, then applies this module's stricter secret strip
+// (sibling only strips SECRET/TOKEN + named keys; verify children also
+// strip KEY-shaped names like NODE_API_KEY) plus the Windows shell vars a
+// spawned shell needs (SystemRoot/COMSPEC/...) and preload-vector deletes.
+// `filteredVerifyEnv` already exists — reuse it, don't duplicate it.
 const VERIFY_ENV_PREFIXES = ['PATH', 'HOME', 'USER', 'SHELL', 'TERM', 'LANG', 'NODE_', 'NPM_', 'PNPM_', 'YARN_'];
 // Exact keys: sibling's PWD/TMPDIR/TEMP plus the Windows OS vars a spawned
 // shell needs to start (COMSPEC/SystemRoot/PATHEXT/...) — none carry secrets.
@@ -130,7 +134,14 @@ const VERIFY_ENV_EXACT = new Set([
 const VERIFY_ENV_SECRET_RE = /SECRET|TOKEN|KEY/i;
 /** Filtered env for verify children: allowlist + secret strip + preload-vector delete. */
 export function filteredVerifyEnv() {
-    const out = {};
+    // Sibling-owned base (allowlisted prefixes + secret strip).
+    const out = { ...siblingFilteredEnv() };
+    // Harden beyond the sibling: strip KEY-shaped names the sibling passes
+    // through (e.g. NODE_API_KEY) before overlaying our own allowlist.
+    for (const k of Object.keys(out)) {
+        if (VERIFY_ENV_SECRET_RE.test(k))
+            delete out[k];
+    }
     for (const [k, v] of Object.entries(process.env)) {
         if (v === undefined)
             continue;

package/dist/verification/scoped.js

@@ -78,14 +78,45 @@ export function buildScopedCommand(cwd, baseCommand, relatedTests) {
     if (baseCommand.includes('pytest')) {
         return `pytest ${safe.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>
+        // Cargo keeps the full suite: `cargo test` selects by test-target name
+        // (`--test <name>`), lib/bin unit-test filters, or `-- <filter>` args —
+        // none of which map 1:1 onto file paths. Interpolating a file path as a
+        // filter would silently run the WRONG subset (substring match against
+        // test names), so fall back to the full suite rather than lie about
+        // coverage. (Checked before the `go test` branch: "cargo test" contains
+        // the substring "go test".)
         return null;
     }
+    // NOTE: `baseCommand.includes('go test')` must stay AFTER the cargo branch
+    // above — "cargo test" contains "go test" as a substring.
+    if (baseCommand.includes('go test')) {
+        // Go has no file-scoped test selection: `go test` takes package
+        // patterns, not file paths (passing `foo_test.go` directly errors with
+        // "no Go files in ..."). Derive `go test ./<pkgdirs...>` from the
+        // directories of the related test files instead: dedupe, cap 10, and
+        // reuse the same containment-validated `safe` list as every other
+        // branch (untrusted paths never reach the shell).
+        const dirs = [];
+        const seen = new Set();
+        for (const f of safe) {
+            const d = path.dirname(f);
+            const pkg = d === '.' ? '.' : `./${d.split(path.sep).join('/')}`;
+            if (!seen.has(pkg)) {
+                seen.add(pkg);
+                dirs.push(pkg);
+            }
+            if (dirs.length >= 10)
+                break;
+        }
+        if (dirs.length === 0)
+            return null;
+        // Preserve a './...'-style base by replacing it; otherwise append.
+        if (baseCommand.includes('./...')) {
+            return baseCommand.replace('./...', dirs.join(' '));
+        }
+        return `${baseCommand} ${dirs.join(' ')}`;
+    }
     return null;
 }
 const MAX_SCOPED_BYTES = 256 * 1024;

package/package.json

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