salmon-loop 0.3.2 → 0.5.0

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,11 +9,13 @@ 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';
 import { ArtifactStore } from '../../sub-agent/artifacts/store.js';
 import { Phase } from '../../types/runtime.js';
+import { isRecord } from '../../utils/serialize.js';
 function bootstrapRegistry() {
     if (!registry.has('remote_lock'))
         registry.register(new MockLockService());
@@ -48,7 +50,7 @@ export const proposalApplySpec = {
     // challenge-response authorization without violating the execution contract.
     allowedPhases: [Phase.VERIFY],
     summarizeArgsForAuthorization: async (args, _ctx) => {
-        const handle = args?.handle;
+        const handle = isRecord(args) && typeof args.handle === 'string' ? args.handle : undefined;
         if (!handle)
             return undefined;
         const read = await ArtifactStore.readText(handle);
@@ -66,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' });
         }
     },
@@ -99,7 +102,15 @@ export async function executeProposalApply(input, ctx) {
     for (const op of operations) {
         const fileState = stateMap.get(op.path);
         const fileInfo = fileState
-            ? { ...fileState, hasConflict: fileState.status === FileStatus.CONFLICT }
+            ? {
+                path: fileState.path,
+                status: fileState.status,
+                isBinary: fileState.isBinary,
+                isSymlink: fileState.isSymlink,
+                isIgnored: fileState.isIgnored,
+                hasConflict: fileState.status === FileStatus.CONFLICT,
+                size: fileState.size,
+            }
             : {
                 path: op.path,
                 status: FileStatus.CLEAN,

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/capability/executor.js

@@ -75,10 +75,10 @@ export async function runWithFallback(backends, input, ctx, opts) {
     throw new Error(`All backends failed for capability. Tried: ${JSON.stringify(meta.tried)}`);
 }
 function createBackendError(backendId, fail, meta) {
-    const error = new Error(`Backend ${backendId} failed: [${fail.code}] ${fail.message}`);
-    error.backendId = backendId;
-    error.failCode = fail.code;
-    error.meta = meta;
-    return error;
+    return Object.assign(new Error(`Backend ${backendId} failed: [${fail.code}] ${fail.message}`), {
+        backendId,
+        failCode: fail.code,
+        meta,
+    });
 }
 //# sourceMappingURL=executor.js.map

package/dist/core/tools/headless-payload.js

@@ -1,7 +1,5 @@
 import { redactValue } from '../llm/redact.js';
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
+import { isRecord } from '../utils/serialize.js';
 function limitValue(value, params) {
     if (params.depth >= params.maxDepth)
         return '[Truncated]';

package/dist/core/tools/mapper.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { unwrapZodSchema } from '../utils/zod.js';
 function formatToolExamplesForDescription(spec) {
     if (!Array.isArray(spec.examples) || spec.examples.length === 0)
         return '';
@@ -13,37 +14,8 @@ function formatToolExamplesForDescription(spec) {
 function toolDescriptionForModel(spec) {
     return `${spec.description}${formatToolExamplesForDescription(spec)}`;
 }
-function unwrapForSchemaGeneration(schema) {
-    let current = schema;
-    for (let depth = 0; depth < 20; depth++) {
-        const ZodEffects = z.ZodEffects;
-        if (typeof ZodEffects === 'function' && current instanceof ZodEffects) {
-            current = current._def.schema;
-            continue;
-        }
-        if (current instanceof z.ZodPipe) {
-            // z.preprocess in Zod v4 produces a ZodPipe(in=ZodTransform, out=<schema>).
-            current = current._def.out;
-            continue;
-        }
-        if (current instanceof z.ZodOptional) {
-            current = current._def.innerType;
-            continue;
-        }
-        if (current instanceof z.ZodNullable) {
-            current = current._def.innerType;
-            continue;
-        }
-        if (current instanceof z.ZodDefault) {
-            current = current._def.innerType;
-            continue;
-        }
-        break;
-    }
-    return current;
-}
 function zodToOpenApi3(schema) {
-    const unwrapped = unwrapForSchemaGeneration(schema);
+    const unwrapped = unwrapZodSchema(schema);
     const description = unwrapped.description;
     if (unwrapped instanceof z.ZodObject) {
         const shape = unwrapped.shape;
@@ -64,34 +36,28 @@ function zodToOpenApi3(schema) {
         return out;
     }
     if (unwrapped instanceof z.ZodArray) {
-        const items = zodToOpenApi3(unwrapped._def.type);
+        const items = zodToOpenApi3(unwrapped.element);
         const out = { type: 'array', items };
         if (description)
             out.description = description;
         return out;
     }
     if (unwrapped instanceof z.ZodEnum) {
-        const options = unwrapped.options ?? unwrapped._def?.values;
-        let values = [];
-        if (Array.isArray(options)) {
-            values = options.map(String);
-        }
-        else if (options && typeof options === 'object') {
-            values = Object.values(options).map(String);
-        }
+        const options = unwrapped.options;
+        const values = options.map(String);
         const out = values.length > 0 ? { type: 'string', enum: values } : { type: 'string' };
         if (description)
             out.description = description;
         return out;
     }
     if (unwrapped instanceof z.ZodLiteral) {
-        const out = { const: unwrapped._def.value };
+        const out = { const: unwrapped.value };
         if (description)
             out.description = description;
         return out;
     }
     if (unwrapped instanceof z.ZodUnion) {
-        const options = unwrapped._def.options;
+        const options = unwrapped.options;
         const out = { oneOf: options.map((o) => zodToOpenApi3(o)) };
         if (description)
             out.description = description;
@@ -110,7 +76,7 @@ function zodToOpenApi3(schema) {
         return out;
     }
     if (unwrapped instanceof z.ZodNumber) {
-        const isInt = Boolean(unwrapped._def.checks?.some((c) => c.kind === 'int'));
+        const isInt = unwrapped.isInt;
         const out = { type: isInt ? 'integer' : 'number' };
         if (description)
             out.description = description;

package/dist/core/tools/parallel/persistence.js

@@ -1,5 +1,12 @@
 import path from 'path';
 import { syncFs as fs } from '../../adapters/fs/node-fs.js';
+import { isRecord } from '../../utils/serialize.js';
+function isPersistedPlanState(value) {
+    return (isRecord(value) &&
+        isRecord(value.plan) &&
+        isRecord(value.result) &&
+        typeof value.updatedAt === 'string');
+}
 /**
  * Persistence layer for parallel execution plans.
  * Supports saving, loading, and listing plans from the .salmonloop/parallel directory.
@@ -41,10 +48,13 @@ export class PlanPersistence {
         const filePath = path.join(this.getPersistenceDir(repoRoot), `${planId}.json`);
         try {
             const content = await fs.readFile(filePath, 'utf8');
-            return JSON.parse(content);
+            const parsed = JSON.parse(content);
+            if (!isPersistedPlanState(parsed))
+                return null;
+            return parsed;
         }
         catch (_error) {
-            if (_error.code === 'ENOENT') {
+            if (isRecord(_error) && _error.code === 'ENOENT') {
                 return null;
             }
             throw _error;
@@ -63,7 +73,9 @@ export class PlanPersistence {
             for (const file of jsonFiles) {
                 try {
                     const content = await fs.readFile(path.join(dir, file), 'utf8');
-                    states.push(JSON.parse(content));
+                    const parsed = JSON.parse(content);
+                    if (isPersistedPlanState(parsed))
+                        states.push(parsed);
                 }
                 catch (_error) {
                     // Skip malformed or unreadable files
@@ -73,7 +85,7 @@ export class PlanPersistence {
             return states;
         }
         catch (_error) {
-            if (_error.code === 'ENOENT') {
+            if (isRecord(_error) && _error.code === 'ENOENT') {
                 return [];
             }
             throw _error;
@@ -117,7 +129,7 @@ export class PlanPersistence {
             await fs.unlink(filePath);
         }
         catch (_error) {
-            if (_error.code !== 'ENOENT') {
+            if (isRecord(_error) && _error.code !== 'ENOENT') {
                 throw _error;
             }
         }

package/dist/core/tools/parallel/scheduler.js

@@ -1,3 +1,5 @@
+import { Phase } from '../../types/runtime.js';
+import { isRecord } from '../../utils/serialize.js';
 import { isRecoverableToolInputErrorCode } from '../recoverable-tool-errors.js';
 import { IsolationManager } from './isolation.js';
 import { resolveArgsWithResults } from './resolve-args.js';
@@ -14,8 +16,7 @@ export class ParallelScheduler {
     tryResolveSpec(node) {
         if (node.spec)
             return node.spec;
-        const router = this.router;
-        const spec = typeof router.getSpec === 'function' ? router.getSpec(node.toolName) : undefined;
+        const spec = this.router.getSpec?.(node.toolName);
         if (!spec)
             return undefined;
         node.spec = spec;
@@ -28,6 +29,8 @@ export class ParallelScheduler {
         return parsed.success ? parsed.data : args;
     }
     shouldFallbackFromComputeResources(spec, args, error) {
+        if (!spec.inputSchema || typeof spec.inputSchema.safeParse !== 'function')
+            return false;
         const parsed = spec.inputSchema.safeParse(args);
         if (parsed.success)
             return false;
@@ -35,9 +38,7 @@ export class ParallelScheduler {
         if (issueCode === 'invalid_type' || issueCode === 'invalid_union' || issueCode === 'custom') {
             return true;
         }
-        const errorCode = typeof error === 'object' && error !== null && 'code' in error
-            ? error.code
-            : undefined;
+        const errorCode = isRecord(error) && typeof error.code === 'string' ? error.code : undefined;
         return isRecoverableToolInputErrorCode(errorCode);
     }
     deriveDefaultResources(spec, ctx) {
@@ -139,7 +140,7 @@ export class ParallelScheduler {
             try {
                 const spec = this.tryResolveSpec(node);
                 if (!spec) {
-                    const phase = typeof baseCtx.phase === 'string' ? baseCtx.phase : undefined;
+                    const phase = isRecord(baseCtx) && typeof baseCtx.phase === 'string' ? baseCtx.phase : undefined;
                     const toolResult = {
                         id: nodeId,
                         toolName: node.toolName,
@@ -185,15 +186,14 @@ export class ParallelScheduler {
                 const resolvedArgs = resolveArgsWithResults(node.args, nodeResults);
                 const normalizedArgs = this.normalizeArgsForSpec(spec, resolvedArgs);
                 // 1.5 Deferred authorization preflight (avoid holding locks while waiting for user)
-                const preflight = typeof this.router.preflightDeferredAuthorization === 'function'
-                    ? await this.router.preflightDeferredAuthorization({
-                        id: nodeId,
-                        phase: baseCtx.phase || 'execute',
-                        toolName: node.toolName,
-                        args: normalizedArgs,
-                        ctx: baseCtx,
-                    })
-                    : null;
+                const phase = isRecord(baseCtx) && typeof baseCtx.phase === 'string' ? baseCtx.phase : Phase.EXPLORE;
+                const preflight = (await this.router.preflightDeferredAuthorization?.({
+                    id: nodeId,
+                    phase,
+                    toolName: node.toolName,
+                    args: normalizedArgs,
+                    ctx: baseCtx,
+                })) ?? null;
                 if (preflight?.kind === 'pending') {
                     nodeStates.set(nodeId, 'BLOCKED_APPROVAL');
                     const approval = {
@@ -250,7 +250,7 @@ export class ParallelScheduler {
                     const runStart = Date.now();
                     const result = await this.router.call({
                         id: nodeId,
-                        phase: baseCtx.phase || 'execute',
+                        phase,
                         toolName: node.toolName,
                         args: normalizedArgs,
                         ctx: isolatedEnv
@@ -275,7 +275,9 @@ export class ParallelScheduler {
                             toolName: node.toolName,
                             riskLevel: spec.riskLevel,
                             message: result.error.message || 'Approval required',
-                            confirmToken: result.error.confirmToken,
+                            confirmToken: isRecord(result.error)
+                                ? result.error.confirmToken
+                                : undefined,
                         };
                         nodeResults[nodeId] = {
                             status: 'BLOCKED_APPROVAL',
@@ -307,18 +309,18 @@ export class ParallelScheduler {
             catch (e) {
                 nodeStates.set(nodeId, 'FAILED');
                 const error = e instanceof Error
-                    ? { code: 'EXECUTION_ERROR', message: e.message, stack: e.stack }
-                    : { code: 'EXECUTION_ERROR', message: String(e) };
+                    ? { code: 'EXECUTION_ERROR', message: e.message, retryable: false }
+                    : { code: 'EXECUTION_ERROR', message: String(e), retryable: false };
                 const toolResult = {
                     id: nodeId,
                     toolName: node.toolName,
                     source: 'builtin',
                     status: 'error',
-                    error: error,
+                    error,
                 };
                 nodeResults[nodeId] = {
                     status: 'FAILED',
-                    error: error,
+                    error,
                     toolResult,
                     timing: { lockWaitMs: 0, runMs: 0 },
                 };