@zhijiewang/openharness 2.0.0 → 2.3.0

package/dist/harness/submit-handler.js

@@ -2,10 +2,10 @@
  * Shared submit/input handler — processes user input before sending to LLM.
  * Used by both cell renderer REPL and Ink REPL.
  */
-import { createUserMessage, createInfoMessage } from '../types/message.js';
-import { processSlashCommand } from '../commands/index.js';
-import { cybergotchiEvents } from '../cybergotchi/events.js';
-import { resolveMcpMention } from '../mcp/loader.js';
+import { processSlashCommand } from "../commands/index.js";
+import { cybergotchiEvents } from "../cybergotchi/events.js";
+import { resolveMcpMention } from "../mcp/loader.js";
+import { createInfoMessage, createUserMessage } from "../types/message.js";
 /**
  * Process user input: handle exit, companion mentions, slash commands,
  * @mentions, and prepare the prompt for the LLM.
@@ -18,16 +18,36 @@ export async function handleUserInput(input, ctx) {
         const name = ctx.companionConfig.soul.name.toLowerCase();
         const lower = trimmed.toLowerCase();
         if (lower.startsWith(`@${name}`) || lower.startsWith(`${name},`) || lower.startsWith(`${name} `)) {
-            cybergotchiEvents.emit('cybergotchi', { type: 'userAddressed', text: trimmed });
+            cybergotchiEvents.emit("cybergotchi", { type: "userAddressed", text: trimmed });
             return { handled: true, messages };
         }
     }
+    // ! Bash mode — direct shell execution, output added to context
+    if (trimmed.startsWith("!") && trimmed.length > 1) {
+        const command = trimmed.slice(1).trim();
+        try {
+            const { execSync } = await import("node:child_process");
+            const output = execSync(command, {
+                encoding: "utf-8",
+                cwd: process.cwd(),
+                timeout: 30_000,
+                maxBuffer: 1024 * 1024,
+                windowsHide: true,
+            });
+            messages = [...messages, createInfoMessage(`$ ${command}\n${output.trimEnd()}`)];
+        }
+        catch (err) {
+            const output = String(err.stdout ?? err.stderr ?? err.message ?? "Command failed");
+            messages = [...messages, createInfoMessage(`$ ${command}\n${output.trimEnd()}`)];
+        }
+        return { handled: true, messages };
+    }
     // Vim toggle
-    if (trimmed === '/vim') {
+    if (trimmed === "/vim") {
         return { handled: true, messages, vimToggled: true };
     }
     // Slash commands
-    if (trimmed.startsWith('/')) {
+    if (trimmed.startsWith("/")) {
         const cmdCtx = {
             messages,
             model: ctx.currentModel,
@@ -69,36 +89,52 @@ export async function handleUserInput(input, ctx) {
     }
     // Normal prompt — add user message
     messages = [...messages, createUserMessage(input)];
-    // Resolve @mentions — local files first, then MCP resources
+    // Resolve @mentions — supports @file, @file#L5-10, @file#5-10, MCP resources
     let resolvedInput = input;
-    const mentionPattern = /@([\w][\w./-]*)/g;
-    const mentions = [...input.matchAll(mentionPattern)].map(m => m[1]);
+    const mentionPattern = /@([\w][\w./-]*)(?:#L?(\d+)(?:-(\d+))?)?/g;
+    const mentions = [...input.matchAll(mentionPattern)];
     const companionName = ctx.companionConfig?.soul?.name?.toLowerCase();
-    for (const mention of mentions) {
+    for (const match of mentions) {
+        const mention = match[1];
+        const startLine = match[2] ? parseInt(match[2], 10) : undefined;
+        const endLine = match[3] ? parseInt(match[3], 10) : startLine;
+        const fullRef = match[0];
         if (companionName && mention.toLowerCase() === companionName)
             continue;
-        // Try local file first (supports paths like @src/main.ts, @README.md)
+        // Try local file first (supports paths like @src/main.ts, @README.md#L5-10)
         try {
-            const { existsSync, readFileSync } = await import('node:fs');
-            const { resolve } = await import('node:path');
+            const { existsSync, readFileSync } = await import("node:fs");
+            const { resolve } = await import("node:path");
             const filePath = resolve(process.cwd(), mention);
             if (existsSync(filePath)) {
-                const content = readFileSync(filePath, 'utf-8');
-                const truncated = content.length > 10_000
-                    ? content.slice(0, 10_000) + '\n[...truncated]'
-                    : content;
-                resolvedInput += `\n\n[File @${mention}]:\n${truncated}`;
+                let content = readFileSync(filePath, "utf-8");
+                // Apply line range if specified
+                if (startLine !== undefined) {
+                    const lines = content.split("\n");
+                    const start = Math.max(0, startLine - 1); // 1-indexed to 0-indexed
+                    const end = endLine !== undefined ? endLine : start + 1;
+                    content = lines.slice(start, end).join("\n");
+                    resolvedInput += `\n\n[File ${fullRef} (lines ${startLine}-${endLine ?? startLine})]:\n${content}`;
+                }
+                else {
+                    const truncated = content.length > 10_000 ? `${content.slice(0, 10_000)}\n[...truncated]` : content;
+                    resolvedInput += `\n\n[File @${mention}]:\n${truncated}`;
+                }
                 continue;
             }
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         // Fall back to MCP resource
         try {
             const content = await resolveMcpMention(mention);
             if (content)
                 resolvedInput += `\n\n[Resource @${mention}]:\n${content.slice(0, 5000)}`;
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     return { handled: false, messages, prompt: resolvedInput };
 }

package/dist/harness/telemetry.d.ts

@@ -12,7 +12,7 @@
  * Optional: POST to configurable endpoint on session end.
  */
 export type TelemetryEvent = {
-    type: 'session_start' | 'tool_call' | 'error' | 'session_end';
+    type: "session_start" | "tool_call" | "error" | "session_end";
     timestamp: number;
     sessionId: string;
     payload: TelemetryPayload;

package/dist/harness/telemetry.js

@@ -11,11 +11,11 @@
  * Events are batched locally as JSONL in ~/.oh/telemetry/.
  * Optional: POST to configurable endpoint on session end.
  */
-import { appendFileSync, mkdirSync, existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { readOhConfig } from './config.js';
-const TELEMETRY_DIR = join(homedir(), '.oh', 'telemetry');
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readOhConfig } from "./config.js";
+const TELEMETRY_DIR = join(homedir(), ".oh", "telemetry");
 // ── State ──
 let _enabled;
 let _sessionFile = null;
@@ -40,14 +40,16 @@ export function recordEvent(event) {
         return;
     try {
         const file = getSessionFile(event.sessionId);
-        appendFileSync(file, JSON.stringify(event) + '\n');
+        appendFileSync(file, `${JSON.stringify(event)}\n`);
+    }
+    catch {
+        /* never crash on telemetry failure */
     }
-    catch { /* never crash on telemetry failure */ }
 }
 /** Convenience: record a tool call event */
 export function recordToolCall(sessionId, toolName, durationMs, isError) {
     recordEvent({
-        type: 'tool_call',
+        type: "tool_call",
         timestamp: Date.now(),
         sessionId,
         payload: { toolName, durationMs, isError },
@@ -56,7 +58,7 @@ export function recordToolCall(sessionId, toolName, durationMs, isError) {
 /** Convenience: record session start */
 export function recordSessionStart(sessionId, provider, model) {
     recordEvent({
-        type: 'session_start',
+        type: "session_start",
         timestamp: Date.now(),
         sessionId,
         payload: { provider, model, platform: process.platform },
@@ -65,7 +67,7 @@ export function recordSessionStart(sessionId, provider, model) {
 /** Convenience: record session end with stats */
 export function recordSessionEnd(sessionId, stats) {
     recordEvent({
-        type: 'session_end',
+        type: "session_end",
         timestamp: Date.now(),
         sessionId,
         payload: stats,
@@ -74,7 +76,7 @@ export function recordSessionEnd(sessionId, stats) {
 /** Convenience: record an error */
 export function recordError(sessionId, category) {
     recordEvent({
-        type: 'error',
+        type: "error",
         timestamp: Date.now(),
         sessionId,
         payload: { errorCategory: category },
@@ -86,10 +88,10 @@ export function readSessionEvents(sessionId) {
     if (!existsSync(file))
         return [];
     try {
-        return readFileSync(file, 'utf-8')
-            .split('\n')
+        return readFileSync(file, "utf-8")
+            .split("\n")
             .filter(Boolean)
-            .map(line => JSON.parse(line));
+            .map((line) => JSON.parse(line));
     }
     catch {
         return [];
@@ -99,25 +101,27 @@ export function readSessionEvents(sessionId) {
 export function getAggregateStats() {
     if (!existsSync(TELEMETRY_DIR))
         return { totalSessions: 0, totalEvents: 0, toolUsage: {}, errorCategories: {} };
-    const files = readdirSync(TELEMETRY_DIR).filter(f => f.endsWith('.jsonl'));
+    const files = readdirSync(TELEMETRY_DIR).filter((f) => f.endsWith(".jsonl"));
     const toolUsage = {};
     const errorCategories = {};
     let totalEvents = 0;
     for (const file of files) {
         try {
-            const lines = readFileSync(join(TELEMETRY_DIR, file), 'utf-8').split('\n').filter(Boolean);
+            const lines = readFileSync(join(TELEMETRY_DIR, file), "utf-8").split("\n").filter(Boolean);
             totalEvents += lines.length;
             for (const line of lines) {
                 const event = JSON.parse(line);
-                if (event.type === 'tool_call' && event.payload.toolName) {
+                if (event.type === "tool_call" && event.payload.toolName) {
                     toolUsage[event.payload.toolName] = (toolUsage[event.payload.toolName] ?? 0) + 1;
                 }
-                if (event.type === 'error' && event.payload.errorCategory) {
+                if (event.type === "error" && event.payload.errorCategory) {
                     errorCategories[event.payload.errorCategory] = (errorCategories[event.payload.errorCategory] ?? 0) + 1;
                 }
             }
         }
-        catch { /* skip malformed files */ }
+        catch {
+            /* skip malformed files */
+        }
     }
     return { totalSessions: files.length, totalEvents, toolUsage, errorCategories };
 }

package/dist/harness/traces.d.ts

@@ -15,7 +15,7 @@ export type TraceSpan = {
     endTime: number;
     durationMs: number;
     attributes: Record<string, unknown>;
-    status: 'ok' | 'error';
+    status: "ok" | "error";
 };
 export type TraceEvent = {
     name: string;
@@ -31,7 +31,7 @@ export declare class SessionTracer {
     /** Start a new span. Returns the span ID. */
     startSpan(name: string, attributes?: Record<string, unknown>, parentSpanId?: string): string;
     /** End a span and record it. */
-    endSpan(spanId: string, status?: 'ok' | 'error', extraAttributes?: Record<string, unknown>): TraceSpan | null;
+    endSpan(spanId: string, status?: "ok" | "error", extraAttributes?: Record<string, unknown>): TraceSpan | null;
     /** Get all completed spans */
     getSpans(): TraceSpan[];
     /** Get a summary of the trace */

package/dist/harness/traces.js

@@ -7,11 +7,12 @@
  *
  * Compatible with OpenTelemetry export format.
  */
-import { appendFileSync, mkdirSync, existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-const TRACE_DIR = join(homedir(), '.oh', 'traces');
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const TRACE_DIR = join(homedir(), ".oh", "traces");
 // ── Tracer ──
+const MAX_IN_MEMORY_SPANS = 1000;
 export class SessionTracer {
     sessionId;
     spans = [];
@@ -27,7 +28,7 @@ export class SessionTracer {
         return spanId;
     }
     /** End a span and record it. */
-    endSpan(spanId, status = 'ok', extraAttributes) {
+    endSpan(spanId, status = "ok", extraAttributes) {
         const active = this.activeSpans.get(spanId);
         if (!active)
             return null;
@@ -44,6 +45,10 @@ export class SessionTracer {
             status,
         };
         this.spans.push(span);
+        // Cap in-memory spans (durable source is on disk)
+        if (this.spans.length > MAX_IN_MEMORY_SPANS) {
+            this.spans = this.spans.slice(-MAX_IN_MEMORY_SPANS);
+        }
         this.persistSpan(span);
         return span;
     }
@@ -62,7 +67,7 @@ export class SessionTracer {
             entry.count++;
             entry.totalMs += span.durationMs;
             spansByName[span.name] = entry;
-            if (span.status === 'error')
+            if (span.status === "error")
                 errors++;
             if (span.startTime < minStart)
                 minStart = span.startTime;
@@ -81,9 +86,11 @@ export class SessionTracer {
         try {
             mkdirSync(TRACE_DIR, { recursive: true });
             const file = join(TRACE_DIR, `${this.sessionId}.jsonl`);
-            appendFileSync(file, JSON.stringify(span) + '\n');
+            appendFileSync(file, `${JSON.stringify(span)}\n`);
+        }
+        catch {
+            /* never crash on tracing failure */
         }
-        catch { /* never crash on tracing failure */ }
     }
 }
 // ── Trace Loading ──
@@ -93,10 +100,10 @@ export function loadTrace(sessionId) {
     if (!existsSync(file))
         return [];
     try {
-        return readFileSync(file, 'utf-8')
-            .split('\n')
+        return readFileSync(file, "utf-8")
+            .split("\n")
             .filter(Boolean)
-            .map(line => JSON.parse(line));
+            .map((line) => JSON.parse(line));
     }
     catch {
         return [];
@@ -107,16 +114,16 @@ export function listTracedSessions() {
     if (!existsSync(TRACE_DIR))
         return [];
     return readdirSync(TRACE_DIR)
-        .filter(f => f.endsWith('.jsonl'))
-        .map(f => f.replace('.jsonl', ''));
+        .filter((f) => f.endsWith(".jsonl"))
+        .map((f) => f.replace(".jsonl", ""));
 }
 /** Format trace for display */
 export function formatTrace(spans) {
     if (spans.length === 0)
-        return 'No trace spans recorded.';
+        return "No trace spans recorded.";
     const lines = [`Trace (${spans.length} spans):\n`];
     // Group by parent for tree display
-    const roots = spans.filter(s => !s.parentSpanId);
+    const roots = spans.filter((s) => !s.parentSpanId);
     const children = new Map();
     for (const s of spans) {
         if (s.parentSpanId) {
@@ -126,12 +133,12 @@ export function formatTrace(spans) {
         }
     }
     function renderSpan(span, indent) {
-        const status = span.status === 'error' ? '✗' : '✓';
-        const pad = '  '.repeat(indent);
+        const status = span.status === "error" ? "✗" : "✓";
+        const pad = "  ".repeat(indent);
         const attrs = Object.entries(span.attributes)
             .filter(([, v]) => v !== undefined)
             .map(([k, v]) => `${k}=${String(v).slice(0, 30)}`)
-            .join(' ');
+            .join(" ");
         lines.push(`${pad}${status} ${span.name} (${span.durationMs}ms) ${attrs}`);
         const kids = children.get(span.spanId) ?? [];
         for (const kid of kids)
@@ -141,27 +148,29 @@ export function formatTrace(spans) {
         renderSpan(root, 0);
     // Summary
     const totalMs = spans.reduce((sum, s) => sum + s.durationMs, 0);
-    const errors = spans.filter(s => s.status === 'error').length;
-    lines.push('');
+    const errors = spans.filter((s) => s.status === "error").length;
+    lines.push("");
     lines.push(`Total: ${spans.length} spans, ${totalMs}ms, ${errors} errors`);
-    return lines.join('\n');
+    return lines.join("\n");
 }
 /** Export trace in OpenTelemetry-compatible format */
 export function exportTraceOTLP(sessionId, spans) {
     return {
-        resourceSpans: [{
+        resourceSpans: [
+            {
                 resource: {
                     attributes: [
-                        { key: 'service.name', value: { stringValue: 'openharness' } },
-                        { key: 'session.id', value: { stringValue: sessionId } },
+                        { key: "service.name", value: { stringValue: "openharness" } },
+                        { key: "session.id", value: { stringValue: sessionId } },
                     ],
                 },
-                scopeSpans: [{
-                        scope: { name: 'openharness.agent' },
-                        spans: spans.map(s => ({
-                            traceId: sessionId.padEnd(32, '0').slice(0, 32),
-                            spanId: s.spanId.padEnd(16, '0').slice(0, 16),
-                            parentSpanId: s.parentSpanId?.padEnd(16, '0').slice(0, 16),
+                scopeSpans: [
+                    {
+                        scope: { name: "openharness.agent" },
+                        spans: spans.map((s) => ({
+                            traceId: sessionId.padEnd(32, "0").slice(0, 32),
+                            spanId: s.spanId.padEnd(16, "0").slice(0, 16),
+                            parentSpanId: s.parentSpanId?.padEnd(16, "0").slice(0, 16),
                             name: s.name,
                             startTimeUnixNano: s.startTime * 1_000_000,
                             endTimeUnixNano: s.endTime * 1_000_000,
@@ -169,10 +178,12 @@ export function exportTraceOTLP(sessionId, spans) {
                                 key: k,
                                 value: { stringValue: String(v) },
                             })),
-                            status: { code: s.status === 'ok' ? 1 : 2 },
+                            status: { code: s.status === "ok" ? 1 : 2 },
                         })),
-                    }],
-            }],
+                    },
+                ],
+            },
+        ],
     };
 }
 //# sourceMappingURL=traces.js.map

package/dist/harness/verification.d.ts

@@ -15,7 +15,7 @@ export type VerificationRule = {
 };
 export type VerificationConfig = {
     enabled: boolean;
-    mode: 'warn' | 'block';
+    mode: "warn" | "block";
     rules: VerificationRule[];
 };
 export type VerificationResult = {

package/dist/harness/verification.js

@@ -8,10 +8,10 @@
  * This is the single highest-impact harness engineering pattern —
  * research shows 2-3x quality improvement from automated feedback.
  */
-import { execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { extname, join } from 'node:path';
-import { readOhConfig } from './config.js';
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { extname, join } from "node:path";
+import { readOhConfig } from "./config.js";
 const MAX_SUMMARY_CHARS = 500;
 const DEFAULT_TIMEOUT_MS = 10_000;
 // ── Auto-detection ──
@@ -20,43 +20,50 @@ export function autoDetectRules(projectRoot) {
     const root = projectRoot ?? process.cwd();
     const rules = [];
     // TypeScript
-    if (existsSync(join(root, 'tsconfig.json'))) {
+    if (existsSync(join(root, "tsconfig.json"))) {
         rules.push({
-            extensions: ['.ts', '.tsx'],
-            lint: 'npx tsc --noEmit 2>&1 | head -20',
+            extensions: [".ts", ".tsx"],
+            lint: "npx tsc --noEmit 2>&1 | head -20",
             timeout: 15_000,
         });
     }
     // ESLint (JS/TS)
-    const eslintConfigs = ['.eslintrc', '.eslintrc.js', '.eslintrc.json', '.eslintrc.yml', 'eslint.config.js', 'eslint.config.mjs'];
-    if (eslintConfigs.some(f => existsSync(join(root, f)))) {
+    const eslintConfigs = [
+        ".eslintrc",
+        ".eslintrc.js",
+        ".eslintrc.json",
+        ".eslintrc.yml",
+        "eslint.config.js",
+        "eslint.config.mjs",
+    ];
+    if (eslintConfigs.some((f) => existsSync(join(root, f)))) {
         rules.push({
-            extensions: ['.js', '.jsx', '.ts', '.tsx'],
-            lint: 'npx eslint {file} --no-color 2>&1 | head -15',
+            extensions: [".js", ".jsx", ".ts", ".tsx"],
+            lint: "npx eslint {file} --no-color 2>&1 | head -15",
             timeout: 10_000,
         });
     }
     // Python — ruff (fast) or pylint
-    if (existsSync(join(root, 'pyproject.toml')) || existsSync(join(root, 'setup.py'))) {
+    if (existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "setup.py"))) {
         rules.push({
-            extensions: ['.py'],
-            lint: 'ruff check {file} 2>&1 | head -10',
+            extensions: [".py"],
+            lint: "ruff check {file} 2>&1 | head -10",
             timeout: 10_000,
         });
     }
     // Go
-    if (existsSync(join(root, 'go.mod'))) {
+    if (existsSync(join(root, "go.mod"))) {
         rules.push({
-            extensions: ['.go'],
-            lint: 'go vet ./... 2>&1 | head -10',
+            extensions: [".go"],
+            lint: "go vet ./... 2>&1 | head -10",
             timeout: 15_000,
         });
     }
     // Rust
-    if (existsSync(join(root, 'Cargo.toml'))) {
+    if (existsSync(join(root, "Cargo.toml"))) {
         rules.push({
-            extensions: ['.rs'],
-            lint: 'cargo check 2>&1 | tail -10',
+            extensions: [".rs"],
+            lint: "cargo check 2>&1 | tail -10",
             timeout: 30_000,
         });
     }
@@ -78,7 +85,7 @@ export function getVerificationConfig() {
         }
         _cachedConfig = {
             enabled: true,
-            mode: v.mode ?? 'warn',
+            mode: v.mode ?? "warn",
             rules: v.rules ?? autoDetectRules(),
         };
         return _cachedConfig;
@@ -89,7 +96,7 @@ export function getVerificationConfig() {
         _cachedConfig = null;
         return null;
     }
-    _cachedConfig = { enabled: true, mode: 'warn', rules: autoRules };
+    _cachedConfig = { enabled: true, mode: "warn", rules: autoRules };
     return _cachedConfig;
 }
 /** Clear cached config (for testing or after config changes) */
@@ -100,15 +107,15 @@ export function invalidateVerificationCache() {
 /** Extract file paths from tool input that were modified */
 export function extractFilePaths(toolName, toolInput) {
     switch (toolName) {
-        case 'Write':
-        case 'Edit':
+        case "Write":
+        case "Edit":
             return toolInput.file_path ? [String(toolInput.file_path)] : [];
-        case 'MultiEdit':
+        case "MultiEdit":
             // MultiEdit has an array of edits, each with file_path
             if (Array.isArray(toolInput.edits)) {
                 const paths = new Set();
                 for (const edit of toolInput.edits) {
-                    if (edit && typeof edit === 'object' && 'file_path' in edit) {
+                    if (edit && typeof edit === "object" && "file_path" in edit) {
                         paths.add(String(edit.file_path));
                     }
                 }
@@ -123,7 +130,7 @@ export function extractFilePaths(toolName, toolInput) {
 /** Find the matching rule for a file extension */
 function findRule(filePath, rules) {
     const ext = extname(filePath).toLowerCase();
-    return rules.find(r => r.extensions.includes(ext)) ?? null;
+    return rules.find((r) => r.extensions.includes(ext)) ?? null;
 }
 /**
  * Shell-escape a file path to prevent command injection.
@@ -131,7 +138,7 @@ function findRule(filePath, rules) {
  */
 function shellEscape(s) {
     // On Windows, use double quotes; on POSIX, use single quotes
-    if (process.platform === 'win32') {
+    if (process.platform === "win32") {
         // Double-quote and escape internal double quotes and special chars
         return `"${s.replace(/"/g, '\\"')}"`;
     }
@@ -144,30 +151,30 @@ function shellEscape(s) {
  */
 export async function runVerificationForFiles(filePaths, config) {
     if (filePaths.length === 0)
-        return { ran: false, passed: true, summary: '' };
+        return { ran: false, passed: true, summary: "" };
     if (filePaths.length === 1)
         return runVerification(filePaths[0], config);
     const results = [];
     for (const fp of filePaths) {
         results.push(await runVerification(fp, config));
     }
-    const ran = results.some(r => r.ran);
-    const passed = results.every(r => r.passed);
-    const failures = results.filter(r => r.ran && !r.passed);
+    const ran = results.some((r) => r.ran);
+    const passed = results.every((r) => r.passed);
+    const failures = results.filter((r) => r.ran && !r.passed);
     if (!ran)
-        return { ran: false, passed: true, summary: '' };
+        return { ran: false, passed: true, summary: "" };
     if (passed)
-        return { ran: true, passed: true, summary: '' };
+        return { ran: true, passed: true, summary: "" };
     // Aggregate failure summaries (cap total to MAX_SUMMARY_CHARS)
-    const summaryParts = failures.map(r => r.summary).filter(Boolean);
-    const summary = summaryParts.join('\n---\n').slice(0, MAX_SUMMARY_CHARS);
+    const summaryParts = failures.map((r) => r.summary).filter(Boolean);
+    const summary = summaryParts.join("\n---\n").slice(0, MAX_SUMMARY_CHARS);
     return { ran: true, passed: false, summary };
 }
 /** Run verification for a single file. Returns result with concise summary. */
 export async function runVerification(filePath, config) {
     const rule = findRule(filePath, config.rules);
-    if (!rule || !rule.lint) {
-        return { ran: false, passed: true, summary: '' };
+    if (!rule?.lint) {
+        return { ran: false, passed: true, summary: "" };
     }
     const command = rule.lint.replace(/\{file\}/g, shellEscape(filePath));
     const timeout = rule.timeout ?? DEFAULT_TIMEOUT_MS;
@@ -175,21 +182,20 @@ export async function runVerification(filePath, config) {
         execSync(command, {
             timeout,
             cwd: process.cwd(),
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
             windowsHide: true,
         });
         // Exit code 0 = passed
-        return { ran: true, passed: true, summary: '' };
+        return { ran: true, passed: true, summary: "" };
     }
     catch (err) {
         // Timeout detection — check killed flag, signal, or error code
-        const isTimeout = err.killed || err.signal === 'SIGTERM' || err.code === 'ETIMEDOUT'
-            || (err.status === null && err.signal);
+        const isTimeout = err.killed || err.signal === "SIGTERM" || err.code === "ETIMEDOUT" || (err.status === null && err.signal);
         if (isTimeout) {
             return { ran: true, passed: false, summary: `Verification timed out after ${timeout / 1000}s` };
         }
-        const output = String(err.stdout ?? err.stderr ?? err.message ?? 'Unknown error');
+        const output = String(err.stdout ?? err.stderr ?? err.message ?? "Unknown error");
         const summary = output.slice(0, MAX_SUMMARY_CHARS).trim();
         return { ran: true, passed: false, summary };
     }