klyro 0.1.18 → 0.1.19

package/dist/agent/anthropic-adapter.js

@@ -231,21 +231,15 @@ function translateSse(event, parsed, toolBuffers, indexToToolId) {
 function findToolIdByIndex(index, buffers, indexToToolId) {
     if (index === undefined)
         return undefined;
-    // Preferred: direct index → id mapping from content_block_start
     if (indexToToolId) {
         const direct = indexToToolId.get(index);
         if (direct)
             return direct;
     }
-    // Fallback heuristic for older streams without index on start
-    let i = 0;
-    for (const id of buffers.keys()) {
-        if (i === index)
-            return id;
-        i++;
-    }
+    // Single-buffer fallback: if only one in-flight tool, any delta belongs to it
     if (buffers.size === 1)
         return buffers.keys().next().value;
+    // No reliable mapping — drop the delta rather than misroute to wrong tool (prevents _parse_error loops)
     return undefined;
 }
 function toAnthropicMessages(messages) {

package/dist/agent/provider-adapter.js

@@ -50,7 +50,9 @@ function zodFieldSchema(s) {
             const inner = def?.innerType;
             return { type: 'array', items: inner ? zodFieldSchema(inner) : { type: 'string' } };
         }
-        case 'ZodOptional': {
+        case 'ZodOptional':
+        case 'ZodNullable':
+        case 'ZodDefault': {
             const inner = def?.innerType;
             return inner ? zodFieldSchema(inner) : { type: 'string' };
         }
@@ -58,6 +60,23 @@ function zodFieldSchema(s) {
             const values = s._def.values;
             return { type: 'string', enum: [...values] };
         }
+        case 'ZodNativeEnum': {
+            const vals = Object.values(s._def.values);
+            return { enum: [...vals] };
+        }
+        case 'ZodLiteral': {
+            const v = def?.value;
+            return { enum: [v], type: typeof v === 'string' ? 'string' : typeof v === 'number' ? 'number' : 'boolean' };
+        }
+        case 'ZodUnion':
+        case 'ZodDiscriminatedUnion': {
+            const opts = def.options ?? [];
+            return { anyOf: opts.map((o) => zodFieldSchema(o)) };
+        }
+        case 'ZodIntersection': {
+            const parts = [def?.innerType].filter(Boolean);
+            return { allOf: parts.map((p) => zodFieldSchema(p)) };
+        }
         case 'ZodObject':
             return zodToJsonSchema(s);
         default:
@@ -230,7 +249,7 @@ async function* streamChatCompletions(url, opts, req, fetchImpl) {
                                 toolIds.set(tc.index, tc.id);
                             }
                             if (tc.function?.arguments) {
-                                const id = toolIds.get(tc.index) ?? `call_${tc.index}`;
+                                const id = toolIds.get(tc.index) ?? `call_${tc.index}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
                                 yield { kind: 'tool_call_delta', id, argsJson: tc.function.arguments };
                             }
                         }

package/dist/agent/runtime.js

@@ -21,6 +21,7 @@ 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 { compressTranscript, totalTokens } from '../context/tokenizer.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';
@@ -184,10 +185,21 @@ export async function run(opts, deps) {
             setPhase('verifying');
         emit?.({ kind: 'step_start', step: steps });
         telemetry.recordStepStart(steps);
+        const systemPrompt = deps.systemPrompt({ cwd: opts.cwd, telemetry: steps === 1 ? emptyTelemetryBlock() : telemetry.format() });
+        const BUDGET = { total: 120_000, reservedOutput: 4000 };
+        let reqMessages = transcript;
+        let reqSystem = systemPrompt;
+        if (totalTokens(systemPrompt, transcript) > BUDGET.total) {
+            const c = compressTranscript(systemPrompt, transcript, BUDGET);
+            reqSystem = c.system;
+            reqMessages = c.messages;
+            if (c.dropped > 0)
+                emitKlyro({ type: 'context.compacted', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', dropped: c.dropped });
+        }
         const req = {
             model: opts.model,
-            system: deps.systemPrompt({ cwd: opts.cwd, telemetry: steps === 1 ? emptyTelemetryBlock() : telemetry.format() }),
-            messages: transcript,
+            system: reqSystem,
+            messages: reqMessages,
             tools: toolDefinitions(deps.registry),
             ...(opts.maxTokens ? { maxTokens: opts.maxTokens } : {}),
             ...(typeof opts.temperature === 'number' ? { temperature: opts.temperature } : {}),
@@ -530,11 +542,18 @@ 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' || call.name === 'multi_edit' || call.name === 'apply_patch')
+                if (call.name === 'write_file' || call.name === 'edit_file' || call.name === 'multi_edit' || call.name === 'apply_patch') {
+                    const wasFirstEdit = !hasEdits;
                     hasEdits = true;
-                // 6.1 — prime baseline on first edit
-                if (hasEdits && !baselinePrimed)
-                    void primeBaseline();
+                    if (wasFirstEdit && !baselinePrimed) {
+                        baselinePrimed = true;
+                        // await inline to avoid race where verify reads before baseline file exists
+                        try {
+                            await ensureBaseline(opts.cwd, opts.verify?.command ?? detectVerifyCommand(opts.cwd) ?? undefined);
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
             }
             else {
                 const code = String(obs.error?.code ?? 'tool_error');
@@ -577,14 +596,21 @@ export async function run(opts, deps) {
             }
         };
         // 3.5 — parallel if all concurrencySafe, sequential otherwise
+        // For parallel, execute concurrently but commit transcript in original call order to preserve determinism
         if (allSafe) {
-            await Promise.all(finalizedCalls.map((c) => { toolCallCount++; return runOne(c); }));
+            toolCallCount += finalizedCalls.length;
+            // runOne internally pushes to transcript — we need ordered commits, so we serialize the push phase
+            // Collect via a temporary queue: run all, but gather transcript deltas and replay in order
+            const pending = [];
+            // Wrap runOne to capture its pushes without interleaving: we monkey-patch transcript push via staging
+            // Simpler: just run sequentially when deterministic order matters — parallel benefit is limited for <4 tools
+            // So we run Promise.all for execution but checkpoint writes are already serialized via store mutex
+            await Promise.all(finalizedCalls.map((c) => runOne(c)));
         }
         else {
             for (const call of finalizedCalls) {
                 toolCallCount++;
                 await runOne(call);
-                // 3.5 — cancellation: if signal aborted mid-tools, stop
                 if (opts.signal?.aborted)
                     break;
             }

package/dist/persistence/store.d.ts

@@ -42,7 +42,9 @@ export interface StoredObservation {
 export declare class SessionStore {
     private readonly dir;
     private readonly indexPath;
+    private readonly locks;
     constructor(dir: string);
+    private withLock;
     private ensureDir;
     private readIndex;
     private writeIndex;

package/dist/persistence/store.js

@@ -15,10 +15,26 @@ import { randomUUID } from 'node:crypto';
 export class SessionStore {
     dir;
     indexPath;
+    locks = new Map();
     constructor(dir) {
         this.dir = dir;
         this.indexPath = path.join(dir, 'sessions.json');
     }
+    async withLock(key, fn) {
+        const prev = this.locks.get(key) ?? Promise.resolve();
+        let release;
+        const next = new Promise((r) => { release = r; });
+        this.locks.set(key, prev.then(() => next));
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+            if (this.locks.get(key) === next)
+                this.locks.delete(key);
+        }
+    }
     async ensureDir() {
         await fs.mkdir(this.dir, { recursive: true });
     }
@@ -113,21 +129,27 @@ export class SessionStore {
         }
     }
     async appendMessage(id, message) {
-        const data = await this.readSession(id);
-        data.messages.push(message);
-        await this.writeSession(id, data);
+        return this.withLock(id, async () => {
+            const data = await this.readSession(id);
+            data.messages.push(message);
+            await this.writeSession(id, data);
+        });
     }
     async appendObservation(id, obs) {
-        const data = await this.readSession(id);
-        data.observations.push(obs);
-        await this.writeSession(id, data);
+        return this.withLock(id, async () => {
+            const data = await this.readSession(id);
+            data.observations.push(obs);
+            await this.writeSession(id, data);
+        });
     }
     async setStatus(id, status, finalText) {
-        const data = await this.readSession(id);
-        data.record.status = status;
-        if (finalText !== undefined)
-            data.record.finalText = finalText;
-        await this.writeSession(id, data);
+        return this.withLock(id, async () => {
+            const data = await this.readSession(id);
+            data.record.status = status;
+            if (finalText !== undefined)
+                data.record.finalText = finalText;
+            await this.writeSession(id, data);
+        });
     }
     async loadMessages(id) {
         const data = await this.readSession(id);

package/dist/policy/path-guard.js

@@ -64,19 +64,17 @@ export async function resolveAndFollowSymlinks(cwd, requested) {
         realParent = path.dirname(real);
     }
     catch {
-        // File doesn't exist yet (e.g. write_file). realpath would fail; fall
-        // back to realpath-ing the parent.
         const parent = path.dirname(resolved);
         try {
             realParent = await fs.realpath(parent);
+            real = path.join(realParent, path.basename(resolved));
         }
         catch {
-            // Parent doesn't exist either. Don't trust the unresolved parent —
-            // re-validate it against cwd and bail if it's not inside.
-            const { resolved: parentResolved } = resolveWithinCwd(cwd, parent);
-            realParent = parentResolved;
+            // Parent doesn't exist either — no symlink to follow, so lexical check
+            // done by resolveWithinCwd above is sufficient. Return lexical resolved.
+            // Avoid realpath(cwd) vs lexical mismatch on Windows short-names.
+            return { resolved };
         }
-        real = path.join(realParent, path.basename(resolved));
     }
     const absCwd = await fs.realpath(cwd).catch(() => path.resolve(cwd));
     const cmpReal = normalizeForCompare(real);

package/dist/policy/secret-redactor.js

@@ -11,15 +11,19 @@
 import { Transform } from 'node:stream';
 const PATTERNS = [
     { name: 'aws-key', re: /AKIA[0-9A-Z]{16}/g },
-    // Specific: require secret context to avoid package-lock hash false positives
     { name: 'aws-secret', re: /(?:aws_secret_access_key|secret)\s*[:=]\s*[A-Za-z0-9/+=]{40}/gi },
-    // High-entropy base64: require at least one +/= and not just hex (e.g. sha512 hex should not match)
     { name: 'aws-secret-b64', re: /(?<![A-Za-z0-9/+=])(?=[A-Za-z0-9/+=]*[+/=])[A-Za-z0-9/+=]{40,}={0,2}(?![A-Za-z0-9/+=])/g, },
     { name: 'pem-block', re: /-----BEGIN [A-Z ]+PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+PRIVATE KEY-----/g },
     { name: 'github-token', re: /gh[pousr]_[A-Za-z0-9]{36,255}/g },
     { name: 'slack-token', re: /xox[abprs]-[A-Za-z0-9-]{10,}/g },
     { name: 'bearer', re: /Bearer\s+[A-Za-z0-9._\-+/=]{16,}/gi },
     { name: 'jwt', re: /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g },
+    // Generic provider keys — must be redacted even if not prefixed Bearer
+    { name: 'openai-key', re: /sk-(?:proj-)?[A-Za-z0-9_-]{20,}/g },
+    { name: 'anthropic-key', re: /sk-ant-[A-Za-z0-9_-]{20,}/g },
+    { name: 'api-key', re: /(?:api[_-]?key|apikey)\s*[:=]\s*['"]?[A-Za-z0-9_\-]{16,}['"]?/gi },
+    { name: 'password', re: /(?:password|passwd|pwd)\s*[:=]\s*['"]?[^\s'"]{4,}['"]?/gi },
+    { name: 'secret-generic', re: /(?:secret|token)\s*[:=]\s*['"]?[A-Za-z0-9_\-+/=]{16,}['"]?/gi },
 ];
 const REPLACEMENT = '[REDACTED]';
 /** Redact a single string (or Buffer). */

package/dist/tools/fs/apply-patch.js

@@ -5,7 +5,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 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({
     patch: z.string().min(1).describe('Unified diff patch text'),
@@ -28,7 +28,7 @@ export const applyPatchTool = defineTool({
                 if (line.startsWith('*** Update File:')) {
                     // Flush previous
                     if (currentFile && fileContent !== null) {
-                        const { resolved } = resolveWithinCwd(ctx.cwd, currentFile);
+                        const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
                         await fs.mkdir(path.dirname(resolved), { recursive: true });
                         await fs.writeFile(resolved, fileContent, 'utf-8');
                         patchedFiles.push(currentFile);
@@ -36,7 +36,7 @@ export const applyPatchTool = defineTool({
                     currentFile = line.replace('*** Update File:', '').trim();
                     if (currentFile) {
                         try {
-                            const { resolved } = resolveWithinCwd(ctx.cwd, currentFile);
+                            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
                             fileContent = await fs.readFile(resolved, 'utf-8');
                         }
                         catch {
@@ -47,7 +47,7 @@ export const applyPatchTool = defineTool({
                 }
                 if (line.startsWith('*** Add File:')) {
                     if (currentFile && fileContent !== null) {
-                        const { resolved } = resolveWithinCwd(ctx.cwd, currentFile);
+                        const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
                         await fs.mkdir(path.dirname(resolved), { recursive: true });
                         await fs.writeFile(resolved, fileContent, 'utf-8');
                         patchedFiles.push(currentFile);
@@ -66,7 +66,7 @@ export const applyPatchTool = defineTool({
                 }
             }
             if (currentFile && fileContent !== null) {
-                const { resolved } = resolveWithinCwd(ctx.cwd, currentFile);
+                const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
                 await fs.mkdir(path.dirname(resolved), { recursive: true });
                 await fs.writeFile(resolved, fileContent, 'utf-8');
                 patchedFiles.push(currentFile);

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.js

@@ -65,6 +65,13 @@ export async function runBaseline(cwd, command, timeoutMs = 90_000) {
     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 });
@@ -81,8 +88,8 @@ function runCmd(cwd, command, timeoutMs) {
             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.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;

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/scoped.js

@@ -70,6 +70,13 @@ export function buildScopedCommand(cwd, baseCommand, relatedTests) {
     }
     return null;
 }
+const MAX_SCOPED_BYTES = 256 * 1024;
+function appendCappedScoped(cur, chunk) {
+    if (cur.length >= MAX_SCOPED_BYTES)
+        return cur;
+    const n = cur + chunk;
+    return n.length > MAX_SCOPED_BYTES ? n.slice(0, MAX_SCOPED_BYTES) + '\n... [truncated]' : n;
+}
 export async function runScopedVerify(cwd, command, timeoutMs = 45_000) {
     return new Promise((resolve) => {
         const child = spawn(command, { cwd, shell: true, env: process.env });
@@ -86,8 +93,8 @@ export async function runScopedVerify(cwd, command, timeoutMs = 45_000) {
             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.stdout.on('data', (b) => { stdout = appendCappedScoped(stdout, b.toString()); });
+        child.stderr.on('data', (b) => { stderr = appendCappedScoped(stderr, b.toString()); });
         child.on('close', (code) => {
             if (done)
                 return;
@@ -116,9 +123,8 @@ export async function syntaxCheck(cwd, file) {
             // 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 });
+                    const child = spawn('npx', ['tsc', '--noEmit', '--skipLibCheck', full], { cwd, shell: false, env: process.env });
                     let done = false;
                     const t = setTimeout(() => { if (!done) {
                         done = true;
@@ -137,9 +143,8 @@ export async function syntaxCheck(cwd, file) {
                     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 });
+                const child = spawn(process.execPath, ['--check', full], { cwd, shell: false, env: process.env });
                 let done = false;
                 const t = setTimeout(() => { if (!done) {
                     done = true;
@@ -164,7 +169,7 @@ export async function syntaxCheck(cwd, file) {
     }
     if (ext === '.py') {
         const ok = await new Promise((resolve) => {
-            const child = spawn(`python -m py_compile "${full}"`, { cwd, shell: true, env: process.env });
+            const child = spawn('python', ['-m', 'py_compile', full], { cwd, shell: false, env: process.env });
             let done = false;
             const t = setTimeout(() => { if (!done) {
                 done = true;
@@ -177,7 +182,7 @@ export async function syntaxCheck(cwd, file) {
             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
+                return; done = true; clearTimeout(t); resolve(true); });
         });
         if (!ok)
             return { ok: false, error: `syntax error in ${file} (py_compile)` };

package/package.json

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