salmon-loop 0.4.1 → 0.5.0

package/dist/core/tools/builtin/index.js

@@ -4,12 +4,13 @@ import { agentTeamSpec } from '../../sub-agent/tools/team.js';
 import { defineTool } from '../types.js';
 import { artifactReadSpec, executeArtifactRead } from './artifact.js';
 import { astGrepSpec, executeAstGrep } from './ast-grep.js';
-import { astDefsRefsSpec, executeAstDefsRefs } from './ast.js';
+import { astDefsRefsSpec, executeAstDefsRefs, codeFindReferencesSpec, executeCodeFindReferences, } from './ast.js';
 import { benchmarkReportSpec, executeBenchmarkReport, executeGitApplyCheck, executeGitDiffCheck, executeSweBenchGetReport, executeSweBenchLoadInstance, executeSweBenchSubmitPredictions, executeSweBenchWritePrediction, gitApplyCheckSpec, gitDiffCheckSpec, sweBenchGetReportSpec, sweBenchLoadInstanceSpec, sweBenchSubmitPredictionsSpec, sweBenchWritePredictionSpec, } from './benchmark.js';
 import { codeSearchExecutor } from './code-search/executor.js';
 import { CodeSearchSpec } from './code-search/spec.js';
-import { codeReadSpec, executeFsCreateDirectory, executeFsList, executeFsListDirectory, executeFsListFiles, executeFsReadFile, executeFsDeleteFile, executeFsWriteFile, fsCreateDirectorySpec, fsDeleteFileSpec, fsListSpec, fsListDirectorySpec, fsListFilesSpec, fsReadFileSpec, fsWriteFileSpec, } from './fs.js';
-import { gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus } from './git.js';
+import { codeReadSpec, executeFsCreateDirectory, executeFsEditFile, executeFsList, executeFsListDirectory, executeFsListFiles, executeFsReadFile, executeFsDeleteFile, executeFsWriteFile, fsCreateDirectorySpec, fsDeleteFileSpec, fsEditFileSpec, fsListSpec, fsListDirectorySpec, fsListFilesSpec, fsReadFileSpec, fsWriteFileSpec, } from './fs.js';
+import { gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus, gitBlameSpec, executeGitBlame, gitLogSpec, executeGitLog, gitShowSpec, executeGitShow, } from './git.js';
+import { globFindSpec, executeGlobFind } from './glob.js';
 import { askUserSpec } from './interaction.js';
 import { updateKnowledgeSpec, executeUpdateKnowledge } from './knowledge.js';
 import { planInitSpec, planReadSpec, planUpdateSpec } from './plan.js';
@@ -34,12 +35,18 @@ export function registerAllBuiltins(registry) {
     // Code search & AST
     registry.register(defineTool(CodeSearchSpec, codeSearchExecutor));
     registry.register(defineTool(astDefsRefsSpec, executeAstDefsRefs));
+    registry.register(defineTool(codeFindReferencesSpec, executeCodeFindReferences));
     registry.register(defineTool(astGrepSpec, executeAstGrep));
     // Git
     registry.register(defineTool(gitCatSpec, executeGitCat));
     registry.register(defineTool(gitStatusSpec, executeGitStatus));
+    registry.register(defineTool(gitBlameSpec, executeGitBlame));
+    registry.register(defineTool(gitLogSpec, executeGitLog));
+    registry.register(defineTool(gitShowSpec, executeGitShow));
     registry.register(defineTool(gitDiffCheckSpec, executeGitDiffCheck));
     registry.register(defineTool(gitApplyCheckSpec, executeGitApplyCheck));
+    // Glob
+    registry.register(defineTool(globFindSpec, executeGlobFind));
     // Benchmark / SWE-bench
     registry.register(defineTool(benchmarkReportSpec, executeBenchmarkReport));
     registry.register(defineTool(sweBenchLoadInstanceSpec, executeSweBenchLoadInstance));
@@ -53,6 +60,7 @@ export function registerAllBuiltins(registry) {
     registry.register(defineTool(fsListDirectorySpec, executeFsListDirectory));
     registry.register(defineTool(fsListFilesSpec, executeFsListFiles));
     registry.register(defineTool(fsWriteFileSpec, executeFsWriteFile));
+    registry.register(defineTool(fsEditFileSpec, executeFsEditFile));
     registry.register(defineTool(fsCreateDirectorySpec, executeFsCreateDirectory));
     registry.register(defineTool(fsDeleteFileSpec, executeFsDeleteFile));
     // Execution
@@ -64,5 +72,5 @@ export function registerAllBuiltins(registry) {
     registry.register(planUpdateSpec);
     registry.register(askUserSpec);
 }
-export { CodeSearchSpec, codeSearchExecutor, astDefsRefsSpec as codeAstSpec, executeAstDefsRefs as executeCodeAst, gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus, codeReadSpec, fsListSpec, executeFsList, fsReadFileSpec as fsReadSpec, executeFsReadFile as executeFsRead, updateKnowledgeSpec, executeUpdateKnowledge, astGrepSpec as codeSearchAstSpec, executeAstGrep as executeCodeSearchAst, verifyRunSpec as testRunSpec, executeVerifyRun as executeTestRun, gitDiffCheckSpec, executeGitDiffCheck, gitApplyCheckSpec, executeGitApplyCheck, benchmarkReportSpec, executeBenchmarkReport, sweBenchLoadInstanceSpec, executeSweBenchLoadInstance, sweBenchWritePredictionSpec, executeSweBenchWritePrediction, sweBenchSubmitPredictionsSpec, executeSweBenchSubmitPredictions, sweBenchGetReportSpec, executeSweBenchGetReport, workspaceInfoSpec, executeWorkspaceInfo, };
+export { CodeSearchSpec, codeSearchExecutor, astDefsRefsSpec as codeAstSpec, executeAstDefsRefs as executeCodeAst, codeFindReferencesSpec, executeCodeFindReferences, gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus, gitBlameSpec, executeGitBlame, gitLogSpec, executeGitLog, gitShowSpec, executeGitShow, globFindSpec, executeGlobFind, codeReadSpec, fsListSpec, executeFsList, fsReadFileSpec as fsReadSpec, executeFsReadFile as executeFsRead, updateKnowledgeSpec, executeUpdateKnowledge, astGrepSpec as codeSearchAstSpec, executeAstGrep as executeCodeSearchAst, verifyRunSpec as testRunSpec, executeVerifyRun as executeTestRun, gitDiffCheckSpec, executeGitDiffCheck, gitApplyCheckSpec, executeGitApplyCheck, benchmarkReportSpec, executeBenchmarkReport, sweBenchLoadInstanceSpec, executeSweBenchLoadInstance, sweBenchWritePredictionSpec, executeSweBenchWritePrediction, sweBenchSubmitPredictionsSpec, executeSweBenchSubmitPredictions, sweBenchGetReportSpec, executeSweBenchGetReport, workspaceInfoSpec, executeWorkspaceInfo, };
 //# sourceMappingURL=index.js.map

package/dist/core/tools/builtin/knowledge.js

@@ -1,10 +1,86 @@
 import { z } from 'zod';
-import { writeFile, mkdir } from '../../adapters/fs/node-fs.js';
+import { readdir, readFile, writeFile, mkdir } from '../../adapters/fs/node-fs.js';
 import { getDefaultIndexPath } from '../../config/paths.js';
+import { getLogger, tryGetLogger } from '../../observability/logger.js';
 import { Phase } from '../../types/runtime.js';
 import { safeJoin } from '../../utils/path.js';
 let lastEventTimestampMs = 0;
 let eventSequence = 0;
+// ── Knowledge quality gates ──────────────────────────────────────────────────
+const MIN_RULE_LENGTH = 10;
+const MAX_RULE_LENGTH = 500;
+function isValidContent(text) {
+    const trimmed = text.trim();
+    return (trimmed.length >= MIN_RULE_LENGTH && trimmed.length <= MAX_RULE_LENGTH && /[\w]/.test(trimmed));
+}
+/** Simple Levenshtein distance for short strings. */
+function levenshtein(a, b) {
+    if (a === b)
+        return 0;
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++)
+        matrix[i] = [i];
+    for (let j = 0; j <= a.length; j++)
+        matrix[0][j] = j;
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            const cost = b[i - 1] === a[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+        }
+    }
+    return matrix[b.length][a.length];
+}
+/** Check if a rule is too similar to any existing rule. */
+function isDuplicateRule(newRule, existingRules) {
+    const normalized = newRule.trim().toLowerCase();
+    for (const existing of existingRules) {
+        const existingNorm = existing.trim().toLowerCase();
+        if (normalized === existingNorm)
+            return true;
+        if (levenshtein(normalized, existingNorm) < 5)
+            return true;
+    }
+    return false;
+}
+/** Load existing knowledge to check for duplicates. */
+async function loadExistingKnowledge(knowledgeDir) {
+    const rules = [];
+    const decisions = [];
+    const deprecatedRules = [];
+    try {
+        const files = await readdir(knowledgeDir);
+        const jsonFiles = files.filter((f) => f.endsWith('.json')).sort();
+        for (const file of jsonFiles) {
+            try {
+                const content = await readFile(safeJoin(knowledgeDir, file), 'utf-8');
+                const data = JSON.parse(content);
+                if (Array.isArray(data.project_rules))
+                    rules.push(...data.project_rules);
+                if (Array.isArray(data.deprecated_rules))
+                    deprecatedRules.push(...data.deprecated_rules);
+                if (Array.isArray(data.architectural_decisions)) {
+                    for (const d of data.architectural_decisions) {
+                        if (typeof d.decision === 'string')
+                            decisions.push(d.decision);
+                    }
+                }
+            }
+            catch (error) {
+                /* skip corrupted */
+                getLogger().debug(`[Knowledge] Failed to read knowledge file ${file}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    catch (error) {
+        /* dir missing */
+        getLogger().debug(`[Knowledge] Failed to read knowledge directory: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { rules, decisions, deprecatedRules };
+}
 function nextEventFilePrefix() {
     const nowMs = Date.now();
     if (nowMs === lastEventTimestampMs) {
@@ -36,6 +112,14 @@ const updateKnowledgeInputSchema = z.discriminatedUnion('category', [
         category: z.literal('user_preferences'),
         preferences: z.string().describe('Updated description of user personal preferences'),
     }),
+    z.object({
+        category: z.literal('lessons_learned'),
+        lessons: z.array(z.string()).describe('Lessons learned from execution outcomes'),
+        source: z
+            .enum(['success', 'failure'])
+            .optional()
+            .describe('Whether lessons came from success or failure'),
+    }),
 ]);
 export const updateKnowledgeSpec = {
     name: 'update_knowledge',
@@ -56,8 +140,60 @@ export async function executeUpdateKnowledge(input, ctx) {
     const { repoRoot } = ctx;
     const indexPath = getDefaultIndexPath(repoRoot);
     const knowledgeDir = safeJoin(indexPath, 'knowledge');
-    // Use timestamp + per-process sequence to ensure unique append-only filenames
-    // even when multiple events occur within the same millisecond.
+    await mkdir(knowledgeDir, { recursive: true });
+    const existing = await loadExistingKnowledge(knowledgeDir);
+    // ── Quality gates ────────────────────────────────────────────────────────
+    if (input.category === 'project_rules') {
+        // Filter out rules that are invalid or duplicate
+        const validRules = [];
+        let skipped = 0;
+        for (const rule of input.rules) {
+            if (!isValidContent(rule)) {
+                skipped++;
+                continue;
+            }
+            if (isDuplicateRule(rule, existing.rules)) {
+                skipped++;
+                continue;
+            }
+            if (isDuplicateRule(rule, existing.deprecatedRules)) {
+                skipped++;
+                continue;
+            }
+            validRules.push(rule);
+        }
+        if (skipped > 0) {
+            tryGetLogger()?.debug(`[Knowledge] Filtered ${skipped} invalid/duplicate rules`);
+        }
+        // If all rules were filtered, skip the write entirely
+        if (validRules.length === 0 &&
+            (!input.deprecated_rules || input.deprecated_rules.length === 0)) {
+            return { success: true, message: 'All rules were duplicates or invalid, nothing to record' };
+        }
+        // Rewrite input with filtered rules
+        input.rules = validRules;
+    }
+    if (input.category === 'architectural_decisions') {
+        if (!isValidContent(input.decision)) {
+            return { success: true, message: 'Decision too short or invalid, nothing to record' };
+        }
+        if (isDuplicateRule(input.decision, existing.decisions)) {
+            return { success: true, message: 'Decision already recorded, skipping duplicate' };
+        }
+    }
+    if (input.category === 'user_preferences') {
+        if (!isValidContent(input.preferences)) {
+            return { success: true, message: 'Preferences too short or invalid, nothing to record' };
+        }
+    }
+    if (input.category === 'lessons_learned') {
+        const validLessons = input.lessons.filter((l) => isValidContent(l));
+        if (validLessons.length === 0) {
+            return { success: true, message: 'All lessons were invalid, nothing to record' };
+        }
+        input.lessons = validLessons;
+    }
+    // ── Write ────────────────────────────────────────────────────────────────
     const fileName = `${nextEventFilePrefix()}-${input.category}.json`;
     const filePath = safeJoin(knowledgeDir, fileName);
     let dataToSave = {};
@@ -82,9 +218,15 @@ export async function executeUpdateKnowledge(input, ctx) {
         case 'user_preferences':
             dataToSave = { user_preferences: input.preferences };
             break;
+        case 'lessons_learned':
+            dataToSave = {
+                lessons_learned: input.lessons,
+                source: input.source ?? 'unknown',
+                date: new Date().toISOString().split('T')[0],
+            };
+            break;
     }
     try {
-        await mkdir(knowledgeDir, { recursive: true });
         await writeFile(filePath, JSON.stringify(dataToSave, null, 2));
         return {
             success: true,

package/dist/core/tools/builtin/proposal.js

@@ -9,6 +9,7 @@ import { Executor } from '../../grizzco/execution/Executor.js';
 import { WorkerFactory } from '../../grizzco/execution/WorkerFactory.js';
 import { MockLockService } from '../../grizzco/services/implementations/mock/MockLockService.js';
 import { registry } from '../../grizzco/services/registry.js';
+import { getLogger } from '../../observability/logger.js';
 import { normalizeDiff, validateDiff, convertDiffToShadowOperations } from '../../patch/diff.js';
 import { getRejectionsDir } from '../../runtime/paths.js';
 import { FileStateResolver } from '../../strata/layers/file-state-resolver.js';
@@ -67,7 +68,8 @@ export const proposalApplySpec = {
                 changedFilesTruncated: meta.changedFiles.length > changedFiles.length,
             });
         }
-        catch {
+        catch (error) {
+            getLogger().warn(`[Proposal] Failed to validate diff for authorization preview: ${error instanceof Error ? error.message : String(error)}`);
             return JSON.stringify({ handle, preview: 'invalid_diff' });
         }
     },

package/dist/core/tools/builtin/verify.js

@@ -1,7 +1,9 @@
 import { z } from 'zod';
 import { text } from '../../../locales/index.js';
+import { parseRunnerOutput, parseStructuredSummary } from '../../feedback/parsers.js';
 import { Phase } from '../../types/runtime.js';
-import { runVerify, classifyError } from '../../verification/runner.js';
+import { detectRunner, injectJsonFlags, } from '../../verification/detect-runner.js';
+import { runVerify, classifyError, isRetryable as checkRetryable, parseTestSummary, } from '../../verification/runner.js';
 import { processResource, repoResource } from '../parallel/resource-helpers.js';
 export const verifyRunSpec = {
     name: 'test.run',
@@ -14,6 +16,10 @@ export const verifyRunSpec = {
     computeResources: (_input, ctx) => [repoResource(ctx), processResource(ctx)],
     inputSchema: z.object({
         command: z.string().describe('The shell command to run for verification'),
+        runner: z
+            .enum(['jest', 'vitest', 'pytest', 'tsc', 'eslint', 'bun', 'go'])
+            .optional()
+            .describe('Test runner type. Auto-detected from command if omitted.'),
     }),
     outputSchema: z.object({
         ok: z.boolean(),
@@ -21,6 +27,24 @@ export const verifyRunSpec = {
         exitCode: z.number().nullable(),
         errorType: z.string().optional(),
         isRetryable: z.boolean().optional(),
+        diagnostics: z
+            .array(z.object({
+            file: z.string(),
+            line: z.number().optional(),
+            column: z.number().optional(),
+            severity: z.enum(['error', 'warning']),
+            message: z.string(),
+            source: z.string(),
+        }))
+            .optional(),
+        summary: z
+            .object({
+            total: z.number(),
+            passed: z.number(),
+            failed: z.number(),
+            skipped: z.number(),
+        })
+            .optional(),
     }),
     allowedPhases: [Phase.VERIFY],
 };
@@ -29,13 +53,21 @@ export const verifyRunSpec = {
  */
 export async function executeVerifyRun(input, ctx) {
     const { command } = input;
+    const runner = input.runner ?? detectRunner(command);
+    const effectiveCommand = injectJsonFlags(command, runner);
     const activePath = ctx.worktreeRoot || ctx.repoRoot;
-    const result = await runVerify(activePath, command, ctx.env, ctx.signal);
+    const result = await runVerify(activePath, effectiveCommand, ctx.env, ctx.signal);
     const errorType = !result.ok ? classifyError(result.output) : undefined;
+    // Structured parsing when we know the runner; generic text heuristics otherwise
+    const diagnostics = !result.ok ? parseRunnerOutput(result.output, runner) : [];
+    // Prefer structured JSON summary; fall back to regex-based text parser
+    const summary = parseStructuredSummary(result.output, runner) ?? parseTestSummary(result.output);
     return {
         ...result,
         errorType,
-        isRetryable: !result.ok ? true : false, // In SalmonLoop, most verification failures are retryable by the LLM
+        isRetryable: errorType ? checkRetryable(errorType) : false,
+        diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
+        summary,
     };
 }
 //# sourceMappingURL=verify.js.map

package/dist/core/tools/permissions/permission-rules.js

@@ -1,4 +1,5 @@
 import { text } from '../../../locales/index.js';
+import { getLogger } from '../../observability/logger.js';
 import { normalizeDiff, validateDiff } from '../../patch/diff.js';
 import { ArtifactStore } from '../../sub-agent/artifacts/store.js';
 import { normalizeRepoRelativePath } from '../../utils/path.js';
@@ -363,7 +364,8 @@ async function loadProposalChangedFiles(handle) {
         const meta = validateDiff(normalized);
         return meta.changedFiles ?? [];
     }
-    catch {
+    catch (error) {
+        getLogger().warn(`[PermissionRules] Failed to load proposal changed files: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
 }

package/dist/core/tools/router.js

@@ -1,5 +1,8 @@
 import * as crypto from 'crypto';
+import path from 'path';
 import { z } from 'zod';
+import { readFile } from '../adapters/fs/node-fs.js';
+import { AstParser } from '../ast/parser.js';
 import { LIMITS } from '../config/limits.js';
 import { getLogger } from '../observability/logger.js';
 import { isRecord } from '../utils/serialize.js';
@@ -110,7 +113,7 @@ export class ToolRouter {
                 ctx: normalizedEnvelope.ctx,
             });
             if (permissionDecision.kind === 'deny') {
-                const result = this.createErrorResult(normalizedEnvelope, startedAt, 'denied', 'PERMISSION_RULE_DENY', permissionDecision.reason, {
+                const result = this.createErrorResult(normalizedEnvelope, startedAt, 'denied', 'PERMISSION_RULE_DENY', permissionDecision.reason ?? 'Permission denied', {
                     authorization: {
                         outcome: 'deny',
                         reason: permissionDecision.reason,
@@ -192,6 +195,12 @@ export class ToolRouter {
                 outputSummary: sanitized.summary,
                 durationMs,
             };
+            // Per-edit syntax guard: check for syntax errors after file writes
+            const syntaxWarnings = await checkPostEditSyntax(spec, normalizedEnvelope.args, rawOutput, normalizedEnvelope.ctx);
+            if (syntaxWarnings.length > 0) {
+                result.warnings = syntaxWarnings;
+                result.meta = { ...result.meta, syntaxWarning: true };
+            }
             this.audit.onEnd(result);
             return result;
         }
@@ -260,7 +269,7 @@ export class ToolRouter {
             ctx: normalizedEnvelope.ctx,
         });
         if (permissionDecision.kind === 'deny') {
-            const toolResult = this.createErrorResult(normalizedEnvelope, startedAt, 'denied', 'PERMISSION_RULE_DENY', permissionDecision.reason, {
+            const toolResult = this.createErrorResult(normalizedEnvelope, startedAt, 'denied', 'PERMISSION_RULE_DENY', permissionDecision.reason ?? 'Permission denied', {
                 authorization: {
                     outcome: 'deny',
                     reason: permissionDecision.reason,
@@ -379,7 +388,8 @@ export class ToolRouter {
                 return raw;
             return `${raw.slice(0, maxLength)}...`;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[ToolRouter] Failed to summarize args: ${error instanceof Error ? error.message : String(error)}`);
             return '[Unserializable]';
         }
     }
@@ -392,7 +402,8 @@ export class ToolRouter {
             // Truncation to 16 hex was insufficient collision resistance for security use.
             return crypto.createHash('sha256').update(raw).digest('hex');
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[ToolRouter] Failed to hash args: ${error instanceof Error ? error.message : String(error)}`);
             return undefined;
         }
     }
@@ -495,9 +506,81 @@ export class ToolRouter {
             ]);
             return typeof result === 'string' && result.trim() ? result : fallback;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[ToolRouter] Failed to get authorization args summary: ${error instanceof Error ? error.message : String(error)}`);
             return fallback;
         }
     }
 }
+/**
+ * Per-edit syntax guard: after a file write, parse the file with tree-sitter
+ * and return syntax error warnings. Non-blocking — returns empty array on
+ * any failure (missing grammar, parse error, etc.).
+ */
+async function checkPostEditSyntax(spec, args, rawOutput, ctx) {
+    if (spec.name !== 'fs.write_file' && spec.name !== 'fs.edit_file')
+        return [];
+    if (!isRecord(rawOutput) || typeof rawOutput.path !== 'string')
+        return [];
+    const filePath = rawOutput.path;
+    let content;
+    if (spec.name === 'fs.write_file') {
+        if (!isRecord(args) || typeof args.content !== 'string')
+            return [];
+        content = args.content;
+    }
+    else {
+        // fs.edit_file — read post-edit content from disk
+        try {
+            const absolutePath = path.resolve(ctx.repoRoot, filePath);
+            content = await readFile(absolutePath, 'utf-8');
+        }
+        catch (error) {
+            getLogger().debug(`[ToolRouter] Failed to read file for post-edit syntax check: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
+    // Detect language from extension
+    const ext = path.extname(filePath).toLowerCase().replace('.', '');
+    if (!ext)
+        return [];
+    // Only check for languages that have tree-sitter support
+    const plugin = ctx.languagePlugins?.getByExtension(`.${ext}`);
+    if (!plugin)
+        return [];
+    try {
+        const tree = await AstParser.parse(content, plugin.meta.id);
+        if (!tree?.rootNode)
+            return [];
+        const errors = collectSyntaxErrors(tree.rootNode);
+        if (errors.length === 0)
+            return [];
+        return [
+            `Syntax warning in ${filePath}: ${errors.length} error(s) detected — ` +
+                errors
+                    .slice(0, 3)
+                    .map((e) => `line ${e.line}: ${e.text}`)
+                    .join('; '),
+        ];
+    }
+    catch (error) {
+        // Tree-sitter parse failed (no grammar, etc.) — silently skip
+        getLogger().debug(`[ToolRouter] Post-edit syntax check parse failed: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}
+function collectSyntaxErrors(node, errors = [], depth = 0) {
+    if (depth > 50)
+        return errors; // prevent stack overflow
+    if (node.type === 'ERROR' || node.isMissing) {
+        errors.push({
+            line: (node.startPosition?.row ?? 0) + 1,
+            text: node.text?.slice(0, 80) ?? node.type,
+        });
+    }
+    for (const child of node.children ?? []) {
+        collectSyntaxErrors(child, errors, depth + 1);
+    }
+    return errors;
+}
 //# sourceMappingURL=router.js.map

package/dist/core/tools/session.js

@@ -46,8 +46,9 @@ function safeParseJson(argsText) {
                 try {
                     value = JSON.parse(nested);
                 }
-                catch {
+                catch (error) {
                     // Ignore: fall back to the first parse result to preserve observability.
+                    getLogger().debug(`[ToolSession] Double-decoded JSON parse fallback: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
         }
@@ -71,7 +72,8 @@ function formatToolResultForModel(result) {
     try {
         return JSON.stringify(payload);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[ToolSession] Failed to serialize tool result: ${error instanceof Error ? error.message : String(error)}`);
         return JSON.stringify({
             id: result.id,
             toolName: result.toolName,
@@ -88,7 +90,8 @@ function safeStringifyForAudit(value) {
     try {
         return redactJsonString(JSON.stringify(redactValue(value)));
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[ToolSession] Failed to stringify value for audit: ${error instanceof Error ? error.message : String(error)}`);
         return '[Unserializable]';
     }
 }
@@ -215,7 +218,8 @@ function serializeToolResultOutputForArtifact(output) {
             fileExt: 'json',
         };
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[ToolSession] Failed to serialize tool output for artifact: ${error instanceof Error ? error.message : String(error)}`);
         return undefined;
     }
 }
@@ -789,7 +793,8 @@ function coercePlanUpdatePatch(args) {
                 coercedPatchSource: 'stringified',
             };
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[ToolSession] Failed to parse plan.update patch JSON: ${error instanceof Error ? error.message : String(error)}`);
             return { args, error: formatPlanUpdatePatchTypeError('string') };
         }
     }

package/dist/core/types/batch.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=batch.js.map

package/dist/core/utils/sanitizer.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../observability/logger.js';
 /**
  * Sanitizes any error input (object, string, or mixed) to prevent leakage
  * of sensitive technical data like Zod dumps or stack traces.
@@ -10,7 +11,8 @@ export function sanitizeErrorMessage(err) {
     try {
         msg = err instanceof Error ? err.message : typeof err === 'string' ? err : JSON.stringify(err);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[Sanitizer] Failed to convert error to string: ${error instanceof Error ? error.message : String(error)}`);
         msg = String(err);
     }
     // 2. Strict Whitelist Detection
@@ -87,7 +89,8 @@ export function sanitizeObject(obj, maxDepth = MAX_DEPTH, depth = 0) {
             try {
                 result[key] = sanitizeObject(value, maxDepth, depth + 1);
             }
-            catch {
+            catch (error) {
+                getLogger().debug(`[Sanitizer] Circular reference detected during object sanitization: ${error instanceof Error ? error.message : String(error)}`);
                 result[key] = '[CIRCULAR]';
             }
         }

package/dist/core/utils/serialize.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../observability/logger.js';
 /**
  * Safely serialize a value to JSON string.
  * Returns '[Unserializable]' if JSON.stringify throws and String() also fails.
@@ -10,11 +11,13 @@ export function safeStringify(value, options) {
         }
         return raw;
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[Serialize] JSON.stringify failed, falling back to String(): ${error instanceof Error ? error.message : String(error)}`);
         try {
             return String(value);
         }
-        catch {
+        catch (innerError) {
+            getLogger().debug(`[Serialize] String() conversion also failed: ${innerError instanceof Error ? innerError.message : String(innerError)}`);
             return '[Unserializable]';
         }
     }

package/dist/core/verification/detect-runner.js

@@ -0,0 +1,86 @@
+/**
+ * Test runner detection and JSON flag injection.
+ *
+ * Detects which test runner a command invokes and, when the runner
+ * supports structured JSON output, rewrites the command to emit JSON
+ * so downstream parsers can consume machine-readable data instead of
+ * regex-matching human-friendly text.
+ */
+// ── Detection ────────────────────────────────────────────────────────────────
+/** Heuristic detection from the raw command string. */
+export function detectRunner(command) {
+    const cmd = command.toLowerCase();
+    // Order matters: more specific patterns first
+    if (/\bvitest\b/.test(cmd))
+        return 'vitest';
+    if (/\bjest\b/.test(cmd))
+        return 'jest';
+    if (/\bpytest\b/.test(cmd) || /\bpy\.test\b/.test(cmd))
+        return 'pytest';
+    if (/\btsc\b/.test(cmd))
+        return 'tsc';
+    if (/\beslint\b/.test(cmd))
+        return 'eslint';
+    if (/\bbun\s+test\b/.test(cmd))
+        return 'bun';
+    if (/\bgo\s+test\b/.test(cmd))
+        return 'go';
+    // npm/pnpm/yarn script proxies — try to infer from script name
+    if (/\bnpm\s+run\s+/.test(cmd) || /\bpnpm\s+/.test(cmd) || /\byarn\s+/.test(cmd)) {
+        if (/test:unit|test:e2e|test:integration|test:full/.test(cmd))
+            return 'unknown';
+        if (/\btest\b/.test(cmd))
+            return 'unknown'; // could be anything
+    }
+    return 'unknown';
+}
+// ── JSON flag injection ──────────────────────────────────────────────────────
+/** Returns true when the runner supports structured JSON output. */
+export function supportsJsonOutput(runner) {
+    return (runner === 'jest' ||
+        runner === 'vitest' ||
+        runner === 'eslint' ||
+        runner === 'bun' ||
+        runner === 'go');
+}
+/**
+ * Rewrite the command to emit structured output.
+ *
+ * Only modifies commands for runners that support JSON.
+ * Returns the original command unchanged when the runner
+ * has no JSON mode (pytest, tsc) or is unknown.
+ */
+export function injectJsonFlags(command, runner) {
+    switch (runner) {
+        case 'jest':
+            // jest --json --outputFile=/dev/null would suppress file write;
+            // but --json alone prints to stdout which is what we want.
+            // Avoid duplicating --json if already present.
+            if (command.includes('--json'))
+                return command;
+            return `${command} --json`;
+        case 'vitest':
+            // vitest --reporter=json --run  (--run prevents watch mode)
+            if (command.includes('--reporter=json') || command.includes('--reporter json'))
+                return command;
+            return `${command} --reporter=json --run`;
+        case 'eslint':
+            // eslint --format json
+            if (command.includes('--format json') || command.includes('--format=json'))
+                return command;
+            return `${command} --format json`;
+        case 'bun':
+            // bun test --json  (outputs NDJSON to stdout)
+            if (command.includes('--json'))
+                return command;
+            return `${command} --json`;
+        case 'go':
+            // go test -json
+            if (command.includes('-json'))
+                return command;
+            return `${command} -json`;
+        default:
+            return command;
+    }
+}
+//# sourceMappingURL=detect-runner.js.map