salmon-loop 0.3.2 → 0.4.1

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

@@ -1,4 +1,7 @@
+import { agentAwaitTaskSpec } from '../../sub-agent/tools/task-await.js';
 import { subAgentTaskSpec } from '../../sub-agent/tools/task-spawn.js';
+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';
@@ -15,116 +18,47 @@ import { shellExecSpec, executeShellExec } from './shell.js';
 import { verifyRunSpec, executeVerifyRun } from './verify.js';
 import { workspaceInfoSpec, executeWorkspaceInfo } from './workspace.js';
 /**
- * Registers all builtin tools into the provided registry
+ * Registers all builtin tools into the provided registry.
+ * Uses defineTool() to pair specs with executors type-safely.
  */
 export function registerAllBuiltins(registry) {
-    // Register sub-agent tool
+    // Sub-agent tools (already self-contained)
     registry.register(subAgentTaskSpec);
-    registry.register({
-        ...artifactReadSpec,
-        executor: executeArtifactRead,
-    });
-    registry.register({
-        ...updateKnowledgeSpec,
-        executor: executeUpdateKnowledge,
-    });
-    registry.register({
-        ...workspaceInfoSpec,
-        executor: executeWorkspaceInfo,
-    });
-    registry.register({
-        ...proposalApplySpec,
-        executor: executeProposalApply,
-    });
-    // Register unified code.search with its specific executor
-    registry.register({
-        ...CodeSearchSpec,
-        executor: codeSearchExecutor,
-    });
-    registry.register({
-        ...astDefsRefsSpec,
-        executor: executeAstDefsRefs,
-    });
-    registry.register({
-        ...gitCatSpec,
-        executor: executeGitCat,
-    });
-    registry.register({
-        ...gitStatusSpec,
-        executor: executeGitStatus,
-    });
-    registry.register({
-        ...gitDiffCheckSpec,
-        executor: executeGitDiffCheck,
-    });
-    registry.register({
-        ...gitApplyCheckSpec,
-        executor: executeGitApplyCheck,
-    });
-    registry.register({
-        ...benchmarkReportSpec,
-        executor: executeBenchmarkReport,
-    });
-    registry.register({
-        ...sweBenchLoadInstanceSpec,
-        executor: executeSweBenchLoadInstance,
-    });
-    registry.register({
-        ...sweBenchWritePredictionSpec,
-        executor: executeSweBenchWritePrediction,
-    });
-    registry.register({
-        ...sweBenchSubmitPredictionsSpec,
-        executor: executeSweBenchSubmitPredictions,
-    });
-    registry.register({
-        ...sweBenchGetReportSpec,
-        executor: executeSweBenchGetReport,
-    });
-    registry.register({
-        ...fsReadFileSpec,
-        executor: executeFsReadFile,
-    });
-    registry.register({
-        ...codeReadSpec,
-        executor: executeFsReadFile,
-    });
-    registry.register({
-        ...fsListSpec,
-        executor: executeFsList,
-    });
-    registry.register({
-        ...fsListDirectorySpec,
-        executor: executeFsListDirectory,
-    });
-    registry.register({
-        ...fsListFilesSpec,
-        executor: executeFsListFiles,
-    });
-    registry.register({
-        ...astGrepSpec,
-        executor: executeAstGrep,
-    });
-    registry.register({
-        ...verifyRunSpec,
-        executor: executeVerifyRun,
-    });
-    registry.register({
-        ...shellExecSpec,
-        executor: executeShellExec,
-    });
-    registry.register({
-        ...fsWriteFileSpec,
-        executor: executeFsWriteFile,
-    });
-    registry.register({
-        ...fsCreateDirectorySpec,
-        executor: executeFsCreateDirectory,
-    });
-    registry.register({
-        ...fsDeleteFileSpec,
-        executor: executeFsDeleteFile,
-    });
+    registry.register(agentAwaitTaskSpec);
+    registry.register(agentTeamSpec);
+    // Artifact & knowledge
+    registry.register(defineTool(artifactReadSpec, executeArtifactRead));
+    registry.register(defineTool(updateKnowledgeSpec, executeUpdateKnowledge));
+    registry.register(defineTool(workspaceInfoSpec, executeWorkspaceInfo));
+    registry.register(defineTool(proposalApplySpec, executeProposalApply));
+    // Code search & AST
+    registry.register(defineTool(CodeSearchSpec, codeSearchExecutor));
+    registry.register(defineTool(astDefsRefsSpec, executeAstDefsRefs));
+    registry.register(defineTool(astGrepSpec, executeAstGrep));
+    // Git
+    registry.register(defineTool(gitCatSpec, executeGitCat));
+    registry.register(defineTool(gitStatusSpec, executeGitStatus));
+    registry.register(defineTool(gitDiffCheckSpec, executeGitDiffCheck));
+    registry.register(defineTool(gitApplyCheckSpec, executeGitApplyCheck));
+    // Benchmark / SWE-bench
+    registry.register(defineTool(benchmarkReportSpec, executeBenchmarkReport));
+    registry.register(defineTool(sweBenchLoadInstanceSpec, executeSweBenchLoadInstance));
+    registry.register(defineTool(sweBenchWritePredictionSpec, executeSweBenchWritePrediction));
+    registry.register(defineTool(sweBenchSubmitPredictionsSpec, executeSweBenchSubmitPredictions));
+    registry.register(defineTool(sweBenchGetReportSpec, executeSweBenchGetReport));
+    // Filesystem
+    registry.register(defineTool(fsReadFileSpec, executeFsReadFile));
+    registry.register(defineTool(codeReadSpec, executeFsReadFile));
+    registry.register(defineTool(fsListSpec, executeFsList));
+    registry.register(defineTool(fsListDirectorySpec, executeFsListDirectory));
+    registry.register(defineTool(fsListFilesSpec, executeFsListFiles));
+    registry.register(defineTool(fsWriteFileSpec, executeFsWriteFile));
+    registry.register(defineTool(fsCreateDirectorySpec, executeFsCreateDirectory));
+    registry.register(defineTool(fsDeleteFileSpec, executeFsDeleteFile));
+    // Execution
+    registry.register(defineTool(verifyRunSpec, executeVerifyRun));
+    registry.register(defineTool(shellExecSpec, executeShellExec));
+    // Plan & interaction
     registry.register(planInitSpec);
     registry.register(planReadSpec);
     registry.register(planUpdateSpec);

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

@@ -75,28 +75,26 @@ export const askUserSpec = {
     outputSchema: askUserOutputSchema,
     executor: async (input, ctx) => {
         if (ctx.agentKind === 'subagent') {
-            const err = new Error(text.tools.askUserSubagentBlocked);
-            err.code = 'ASK_USER_SUBAGENT_BLOCKED';
-            throw err;
+            throw Object.assign(new Error(text.tools.askUserSubagentBlocked), {
+                code: 'ASK_USER_SUBAGENT_BLOCKED',
+            });
         }
         if (!ctx.userInputProvider) {
-            const err = new Error(text.tools.askUserRequired);
             const inputRequired = buildInputRequired(input);
-            err.code = 'INTERRUPT_REQUIRED';
-            err.interrupt = {
-                type: 'awaiting_input',
-                reason: inputRequired.reason ?? 'clarification',
-                prompt: inputRequired.prompt,
-                data: { inputRequired },
-            };
-            throw err;
+            throw Object.assign(new Error(text.tools.askUserRequired), {
+                code: 'INTERRUPT_REQUIRED',
+                interrupt: {
+                    type: 'awaiting_input',
+                    reason: inputRequired.reason ?? 'clarification',
+                    prompt: inputRequired.prompt,
+                    data: { inputRequired },
+                },
+            });
         }
         const output = await ctx.userInputProvider.askUser(input, { signal: ctx.signal });
         const validationError = validateAnswers(input, output.answers);
         if (validationError) {
-            const err = new Error(validationError);
-            err.code = 'INVALID_OUTPUT';
-            throw err;
+            throw Object.assign(new Error(validationError), { code: 'INVALID_OUTPUT' });
         }
         return { questions: input.questions, answers: output.answers };
     },

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

@@ -14,6 +14,7 @@ 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 +49,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);
@@ -99,7 +100,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/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 },
                 };