salmon-loop 0.2.3

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

@@ -0,0 +1,207 @@
+import { createHash } from 'crypto';
+import { z } from 'zod';
+import { text } from '../../../locales/index.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { FileStatus } from '../../grizzco/domain/grizzco-types.js';
+import { DecisionEngine, PlanBuilder } from '../../grizzco/dsl/DecisionEngine.js';
+import { StandardStrategy } from '../../grizzco/dsl/strategies.js';
+import { Executor } from '../../grizzco/execution/Executor.js';
+import { WorkerFactory } from '../../grizzco/execution/WorkerFactory.js';
+import { CachedService } from '../../grizzco/services/CachedService.js';
+import { GitConfigService } from '../../grizzco/services/implementations/default/GitConfigService.js';
+import { MockLockService } from '../../grizzco/services/implementations/mock/MockLockService.js';
+import { MockUserQuotaService } from '../../grizzco/services/implementations/mock/MockUserQuotaService.js';
+import { registry } from '../../grizzco/services/registry.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';
+function bootstrapRegistry() {
+    if (!registry.has('remote_lock'))
+        registry.register(new MockLockService());
+    if (!registry.has('user_quota'))
+        registry.register(new MockUserQuotaService());
+    if (!registry.has('git_config'))
+        registry.register(new CachedService(new GitConfigService()));
+}
+export const proposalApplySpec = {
+    name: 'proposal.apply',
+    source: 'builtin',
+    intent: 'WRITE',
+    description: text.tools.proposalApplyDescription,
+    riskLevel: 'high',
+    sideEffects: ['fs_write', 'git_write'],
+    concurrency: 'serial_only',
+    inputSchema: z.object({
+        handle: z.string().describe('Patch artifact handle (s8p://artifact/<id>)'),
+        snapshotRef: z
+            .string()
+            .optional()
+            .describe('Optional snapshot/base ref for merge workers (defaults to HEAD)'),
+    }),
+    outputSchema: z.object({
+        ok: z.boolean(),
+        handle: z.string(),
+        sha256: z.string(),
+        changedFiles: z.array(z.string()),
+        fileCount: z.number(),
+        lineCount: z.number(),
+        snapshotRef: z.string(),
+        appliedFiles: z.number(),
+        totalFiles: z.number(),
+    }),
+    // ToolPolicy forbids tool execution in APPLY. Keep this in VERIFY to allow
+    // challenge-response authorization without violating the execution contract.
+    allowedPhases: [Phase.VERIFY],
+    summarizeArgsForAuthorization: async (args, _ctx) => {
+        const handle = args?.handle;
+        if (!handle)
+            return undefined;
+        const read = await ArtifactStore.readText(handle);
+        if (!read.ok)
+            return JSON.stringify({ handle, preview: 'artifact_not_found' });
+        try {
+            const normalized = normalizeDiff(read.content);
+            const meta = validateDiff(normalized);
+            const changedFiles = meta.changedFiles.slice(0, 20);
+            return JSON.stringify({
+                handle,
+                fileCount: meta.fileCount,
+                lineCount: meta.lineCount,
+                changedFiles,
+                changedFilesTruncated: meta.changedFiles.length > changedFiles.length,
+            });
+        }
+        catch {
+            return JSON.stringify({ handle, preview: 'invalid_diff' });
+        }
+    },
+};
+export async function executeProposalApply(input, ctx) {
+    if (!ctx.worktreeRoot) {
+        throw new Error(text.tools.worktreeRequired);
+    }
+    const read = await ArtifactStore.readText(input.handle);
+    if (!read.ok) {
+        throw new Error(text.tools.artifactNotFound(input.handle));
+    }
+    const normalized = normalizeDiff(read.content);
+    const diffMeta = validateDiff(normalized);
+    const sha256 = createHash('sha256').update(normalized, 'utf8').digest('hex');
+    if (diffMeta.fileCount <= 0) {
+        throw new Error(text.llm.patchEmpty());
+    }
+    bootstrapRegistry();
+    const activePath = ctx.worktreeRoot || ctx.repoRoot;
+    const persistenceRoot = ctx.persistenceRoot || ctx.repoRoot;
+    const git = new GitAdapter(activePath);
+    const resolver = new FileStateResolver(git, activePath);
+    const workerFactory = new WorkerFactory(activePath);
+    const executor = new Executor(workerFactory, getRejectionsDir(persistenceRoot));
+    const operations = await convertDiffToShadowOperations(normalized);
+    const paths = operations.map((op) => op.path);
+    const stateMap = await resolver.getWorkspaceMap(paths);
+    let appliedFiles = 0;
+    for (const op of operations) {
+        const fileState = stateMap.get(op.path);
+        const fileInfo = fileState
+            ? { ...fileState, hasConflict: fileState.status === FileStatus.CONFLICT }
+            : {
+                path: op.path,
+                status: FileStatus.CLEAN,
+                isBinary: false,
+                isSymlink: false,
+                isIgnored: false,
+                hasConflict: false,
+                size: 0,
+            };
+        const dslCtx = {
+            repoRoot: activePath,
+            file: fileInfo,
+            operation: op,
+            options: {
+                force: false,
+                allowMM: true,
+                safeMode: true,
+                rejectDir: getRejectionsDir(persistenceRoot),
+                dryRun: Boolean(ctx.dryRun),
+                maxFileSize: 0,
+            },
+            snapshot: {
+                exists: true,
+                id: input.snapshotRef || 'HEAD',
+                timestamp: Date.now(),
+                path: '',
+            },
+            runtime: { needsRollback: false },
+            data: {},
+        };
+        const toolCtxForServices = {
+            workspace: {
+                baseRepoPath: persistenceRoot,
+                workPath: activePath,
+                strategy: 'worktree',
+            },
+            options: {
+                dryRun: Boolean(ctx.dryRun),
+            },
+            shadowInitialRef: input.snapshotRef || 'HEAD',
+        };
+        const fetchMissingData = async (keys) => {
+            const fetchPromises = keys.map(async (key) => {
+                const service = registry.get(key);
+                if (!service)
+                    throw new Error(text.grizzco.unknownDataDependency(key));
+                return { key, data: await service.fetch(toolCtxForServices, op.path) };
+            });
+            const results = await Promise.all(fetchPromises);
+            if (!dslCtx.data)
+                dslCtx.data = {};
+            results.forEach(({ key, data }) => {
+                dslCtx.data[key] = data;
+            });
+        };
+        const MAX_DSL_RETRIES = 10;
+        let dslRetries = 0;
+        let plan;
+        while (true) {
+            if (dslRetries++ > MAX_DSL_RETRIES) {
+                throw new Error(text.grizzco.microOrchestratorLoopStuck(op.path));
+            }
+            const planBuilder = new PlanBuilder();
+            const engine = new DecisionEngine(dslCtx, planBuilder);
+            StandardStrategy(engine);
+            const built = engine.build();
+            if (built.type === 'PLAN') {
+                plan = built.plan;
+                break;
+            }
+            if (built.type === 'NEED_DATA') {
+                await fetchMissingData(built.keys ?? [built.key]);
+                continue;
+            }
+        }
+        if (plan.shouldAbort) {
+            throw new Error(text.grizzco.planAborted(op.path, plan.abortReason || 'Unknown reason'));
+        }
+        const execResult = await executor.execute(plan, dslCtx);
+        if (!execResult.success) {
+            throw new Error(text.grizzco.executionFailed(op.path, execResult.error || 'Unknown error'));
+        }
+        if (execResult.actionTaken.startsWith('MERGE'))
+            appliedFiles++;
+    }
+    return {
+        ok: true,
+        handle: input.handle,
+        sha256,
+        changedFiles: diffMeta.changedFiles,
+        fileCount: diffMeta.fileCount,
+        lineCount: diffMeta.lineCount,
+        snapshotRef: input.snapshotRef || 'HEAD',
+        appliedFiles,
+        totalFiles: operations.length,
+    };
+}
+//# sourceMappingURL=proposal.js.map

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

@@ -0,0 +1,71 @@
+import { execa } from 'execa';
+import { z } from 'zod';
+import { text } from '../../../locales/index.js';
+import { Phase } from '../../types/runtime.js';
+import { getPlatformShellInvocation } from '../../utils/platform-shell.js';
+import { processResource, repoResource } from '../parallel/resource-helpers.js';
+export const shellExecSpec = {
+    name: 'shell.exec',
+    source: 'builtin',
+    intent: 'INFRA',
+    description: text.tools.shellExecDescription,
+    riskLevel: 'high',
+    sideEffects: ['process'],
+    concurrency: 'isolated',
+    computeResources: (_input, ctx) => [repoResource(ctx), processResource(ctx)],
+    allowedPhases: [Phase.SLASH],
+    inputSchema: z.object({
+        command: z.string().min(1).describe('Shell command to execute'),
+    }),
+    outputSchema: z.object({
+        ok: z.boolean(),
+        stdout: z.string(),
+        stderr: z.string(),
+        exitCode: z.number().nullable(),
+    }),
+    summarizeArgsForAuthorization: async (args, ctx) => {
+        const cwd = ctx.worktreeRoot || ctx.repoRoot;
+        return `command=${JSON.stringify(args.command)} cwd=${JSON.stringify(cwd)}`;
+    },
+};
+export async function executeShellExec(input, ctx) {
+    const cwd = ctx.worktreeRoot || ctx.repoRoot;
+    if (ctx.dryRun) {
+        return {
+            ok: true,
+            stdout: `[DRY_RUN] ${input.command}`,
+            stderr: '',
+            exitCode: 0,
+        };
+    }
+    try {
+        const shell = getPlatformShellInvocation(input.command);
+        const res = await execa(shell.file, shell.args, {
+            cwd,
+            env: {
+                ...process.env,
+                ...(ctx.env ?? {}),
+                SALMONLOOP_REPO_ROOT: ctx.repoRoot,
+                SALMONLOOP_WORKTREE_ROOT: ctx.worktreeRoot ?? '',
+                SALMONLOOP_ATTEMPT_ID: String(ctx.attemptId),
+            },
+            reject: false,
+        });
+        return {
+            ok: res.exitCode === 0,
+            stdout: (res.stdout ?? '').trim(),
+            stderr: (res.stderr ?? '').trim(),
+            exitCode: res.exitCode,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            stdout: '',
+            stderr: message,
+            exitCode: null,
+        };
+    }
+}
+//# sourceMappingURL=shell.js.map

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { text } from '../../../locales/index.js';
+import { Phase } from '../../types/runtime.js';
+import { runVerify, classifyError } from '../../verification/runner.js';
+import { processResource, repoResource } from '../parallel/resource-helpers.js';
+export const verifyRunSpec = {
+    name: 'test.run',
+    source: 'builtin',
+    intent: 'INFRA',
+    description: text.tools.testRunDescription,
+    riskLevel: 'medium',
+    sideEffects: ['process'],
+    concurrency: 'isolated',
+    computeResources: (_input, ctx) => [repoResource(ctx), processResource(ctx)],
+    inputSchema: z.object({
+        command: z.string().describe('The shell command to run for verification'),
+    }),
+    outputSchema: z.object({
+        ok: z.boolean(),
+        output: z.string(),
+        exitCode: z.number().nullable(),
+        errorType: z.string().optional(),
+        isRetryable: z.boolean().optional(),
+    }),
+    allowedPhases: [Phase.VERIFY],
+};
+/**
+ * Builtin tool to run verification commands
+ */
+export async function executeVerifyRun(input, ctx) {
+    const { command } = input;
+    const activePath = ctx.worktreeRoot || ctx.repoRoot;
+    const result = await runVerify(activePath, command, ctx.env, ctx.signal);
+    const errorType = !result.ok ? classifyError(result.output) : undefined;
+    return {
+        ...result,
+        errorType,
+        isRetryable: !result.ok ? true : false, // In SalmonLoop, most verification failures are retryable by the LLM
+    };
+}
+//# sourceMappingURL=verify.js.map

package/dist/core/tools/capability/executor.js

@@ -0,0 +1,84 @@
+import { getLogger } from '../../observability/logger.js';
+/**
+ * Runs a capability with automatic fallback across multiple backends.
+ */
+export async function runWithFallback(backends, input, ctx, opts) {
+    const meta = { tried: [] };
+    let tries = 0;
+    for (const backend of backends) {
+        if (tries >= opts.maxBackendTries)
+            break;
+        tries++;
+        // 1. Compatibility Check
+        let compatible = false;
+        try {
+            compatible = await backend.isCompatible(ctx);
+        }
+        catch (err) {
+            getLogger().debug(`Compatibility check failed for backend ${backend.id}: ${err}`);
+            compatible = false;
+        }
+        if (!compatible) {
+            meta.tried.push({
+                backendId: backend.id,
+                compatible: false,
+                result: 'fail',
+                failCode: 'UNAVAILABLE',
+            });
+            continue;
+        }
+        // 2. Input Normalization
+        const normalizedInput = backend.normalizeInput ? backend.normalizeInput(input) : input;
+        // 3. Audit Start
+        ctx.audit.event({
+            type: 'tool.backend.start',
+            backendId: backend.id,
+            phase: ctx.phase,
+            attemptId: ctx.attemptId,
+        });
+        // 4. Execution
+        const res = await backend.run(normalizedInput, ctx);
+        if (res.ok) {
+            // Success path
+            meta.chosenBackend = backend.id;
+            meta.tried.push({ backendId: backend.id, compatible: true, result: 'ok' });
+            ctx.audit.event({
+                type: 'tool.backend.ok',
+                backendId: backend.id,
+                phase: ctx.phase,
+                attemptId: ctx.attemptId,
+            });
+            return { output: res.output, meta };
+        }
+        // 5. Failure Path
+        meta.tried.push({
+            backendId: backend.id,
+            compatible: true,
+            result: 'fail',
+            failCode: res.code,
+            failMessage: res.message,
+        });
+        ctx.audit.event({
+            type: 'tool.backend.fail',
+            backendId: backend.id,
+            code: res.code,
+            retryable: res.retryable,
+            phase: ctx.phase,
+            attemptId: ctx.attemptId,
+        });
+        // If the error code is not in the fallback list (e.g., BAD_INPUT), we stop immediately
+        if (!opts.fallbackOn.has(res.code)) {
+            throw createBackendError(backend.id, res, meta);
+        }
+        getLogger().warn(`Backend ${backend.id} failed with ${res.code}, attempting fallback...`);
+    }
+    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;
+}
+//# sourceMappingURL=executor.js.map

package/dist/core/tools/capability/runner.js

@@ -0,0 +1,50 @@
+import { execa } from 'execa';
+/**
+ * Creates a standard controlled runner for tool execution.
+ * This encapsulates the process execution logic (execa) and
+ * normalizes the output for backends.
+ */
+export function createControlledRunner() {
+    return {
+        execFile: async (file, args, opts) => {
+            try {
+                const result = await execa(file, args, {
+                    cwd: opts?.cwd,
+                    timeout: opts?.timeoutMs,
+                    maxBuffer: opts?.maxStdoutBytes,
+                    env: opts?.env,
+                    reject: false, // Backends should handle exit codes themselves
+                });
+                return {
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                    exitCode: result.exitCode ?? 0,
+                    timedOut: result.timedOut,
+                };
+            }
+            catch (err) {
+                let stderr = String(err);
+                let exitCode = -1;
+                let timedOut = false;
+                if (err instanceof Error) {
+                    stderr = err.message;
+                }
+                if (err && typeof err === 'object') {
+                    if ('exitCode' in err && typeof err.exitCode === 'number') {
+                        exitCode = err.exitCode;
+                    }
+                    if ('timedOut' in err && typeof err.timedOut === 'boolean') {
+                        timedOut = err.timedOut;
+                    }
+                }
+                return {
+                    stdout: '',
+                    stderr,
+                    exitCode,
+                    timedOut,
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=runner.js.map

package/dist/core/tools/capability/types.js

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

package/dist/core/tools/dispatcher.js

@@ -0,0 +1,80 @@
+import * as crypto from 'crypto';
+import { ToolParser, ToolParseError } from './parser.js';
+/**
+ * ToolDispatcher acts as the high-level coordinator between the LLM
+ * and the ToolRouter. It handles the full lifecycle of a tool call
+ * from raw text to structured result.
+ */
+export class ToolDispatcher {
+    router;
+    options;
+    parser = new ToolParser();
+    constructor(router, options) {
+        this.router = router;
+        this.options = options;
+    }
+    /**
+     * Dispatches a tool call from LLM output text.
+     *
+     * @param text Raw completion text from LLM
+     * @param phase Current execution phase (host-provided)
+     * @returns ToolResult if a call was found, null if no tool call was intended
+     */
+    async dispatch(text, phase) {
+        try {
+            // 1. Parse using the strict XML-based parser
+            // This automatically masks code blocks to prevent unintended execution.
+            const parsed = this.parser.parse(text);
+            if (!parsed) {
+                return null;
+            }
+            // 2. Build the secure ToolCallEnvelope
+            // We inject metadata that the model cannot control, ensuring it
+            // operates within the host-defined security boundaries.
+            const envelope = {
+                id: crypto.randomUUID(),
+                phase,
+                toolName: parsed.tool,
+                args: parsed.args,
+                ctx: {
+                    repoRoot: this.options.repoRoot,
+                    persistenceRoot: this.options.persistenceRoot,
+                    worktreeRoot: this.options.worktreeRoot,
+                    attemptId: this.options.attemptId,
+                    dryRun: this.options.dryRun,
+                    model: this.options.model,
+                    userInputProvider: this.options.userInputProvider,
+                    agentKind: this.options.agentKind,
+                },
+            };
+            // 3. Delegate execution to the router (which handles Policy, Budget, etc.)
+            return await this.router.call(envelope);
+        }
+        catch (e) {
+            if (e instanceof ToolParseError) {
+                // Map parsing errors back to a result so the system can provide
+                // feedback to the model to retry with correct formatting.
+                return {
+                    id: `parse-err-${Date.now()}`,
+                    toolName: 'unknown',
+                    source: 'builtin',
+                    status: 'error',
+                    error: {
+                        code: 'PARSE_ERROR',
+                        message: e.message,
+                        retryable: true,
+                    },
+                };
+            }
+            // For unexpected system errors, we let them bubble up
+            throw e;
+        }
+    }
+    /**
+     * Updates the runtime context (e.g., when moving to a new attempt).
+     */
+    updateOptions(newOptions) {
+        this.options = { ...this.options, ...newOptions };
+    }
+}
+//# sourceMappingURL=dispatcher.js.map

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

@@ -0,0 +1,37 @@
+import { redactValue } from '../llm/redact.js';
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function limitValue(value, params) {
+    if (params.depth >= params.maxDepth)
+        return '[Truncated]';
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value)) {
+        const sliced = value.slice(0, params.maxArray);
+        return sliced.map((v) => limitValue(v, { ...params, depth: params.depth + 1 }));
+    }
+    if (isRecord(value)) {
+        const keys = Object.keys(value).sort().slice(0, params.maxKeys);
+        const out = {};
+        for (const key of keys) {
+            out[key] = limitValue(value[key], { ...params, depth: params.depth + 1 });
+        }
+        return out;
+    }
+    return '[Unserializable]';
+}
+export function buildHeadlessToolInputPayload(value) {
+    const redacted = redactValue(value);
+    const limited = limitValue(redacted, {
+        depth: 0,
+        maxDepth: 5,
+        maxKeys: 40,
+        maxArray: 40,
+    });
+    return isRecord(limited) ? limited : undefined;
+}
+//# sourceMappingURL=headless-payload.js.map

package/dist/core/tools/loader.js

@@ -0,0 +1,100 @@
+import { text } from '../../locales/index.js';
+import { skillToToolSpec } from '../skills/bridge.js';
+import { SkillLoader } from '../skills/loader.js';
+import { ToolAuditLogger } from './audit.js';
+import { BudgetGuard } from './budget.js';
+import { registerAllBuiltins } from './builtin/index.js';
+import { ToolDispatcher } from './dispatcher.js';
+import { registerMcpTools } from './mcp/loader.js';
+import { compilePermissionRules, getVisibleToolNamesFromAllowRules, shouldFilterRegistryByAllowRules, } from './permissions/permission-rules.js';
+import { registerPluginTools } from './plugins/loader.js';
+import { ToolPolicy } from './policy.js';
+import { ToolRegistry } from './registry.js';
+import { ToolRouter } from './router.js';
+import { ToolSanitizer } from './sanitize.js';
+/**
+ * Creates a fully configured tool stack for SalmonLoop.
+ * This is the primary entry point for setting up the tool calling system.
+ */
+export async function createStandardToolstack(options) {
+    // 1. Initialize core components
+    let registry = new ToolRegistry();
+    const policy = new ToolPolicy();
+    const budget = new BudgetGuard(options.budget);
+    const audit = new ToolAuditLogger({
+        onAuthorizationSummary: options.onAuthorizationSummary,
+        onAuthorizationDecision: options.onAuthorizationDecision,
+    });
+    const sanitize = new ToolSanitizer();
+    // 2. Register all builtin tools (rg, git, ast, ast-grep)
+    registerAllBuiltins(registry);
+    // 3. Load and register Skills as tools
+    const extensions = options.extensions;
+    const skillLoader = new SkillLoader({
+        repoRoot: options.repoRoot,
+        useDefaults: extensions?.skillDiscovery.useDefaults,
+        extraPaths: extensions?.skillDiscovery.paths,
+    });
+    const skills = await skillLoader.initialize();
+    for (const skill of skills) {
+        registry.register(skillToToolSpec(skill));
+    }
+    if (extensions) {
+        await registerMcpTools(registry, extensions.mcpServers);
+        await registerPluginTools(registry, extensions.toolPlugins);
+    }
+    const compiledPermissionRules = (() => {
+        if (!options.permissionRules)
+            return undefined;
+        const compiled = compilePermissionRules(options.permissionRules);
+        if (!compiled.ok) {
+            const summary = (compiled.errors ?? []).map((e) => `${e.raw}: ${e.message}`).slice(0, 5);
+            throw new Error(text.tools.permissionRulesParseFailed(summary.join('; ')));
+        }
+        return compiled.compiled;
+    })();
+    const allowSets = [];
+    if (Array.isArray(options.allowedToolNames) && options.allowedToolNames.length > 0) {
+        allowSets.push(new Set(options.allowedToolNames));
+    }
+    if (shouldFilterRegistryByAllowRules(compiledPermissionRules)) {
+        allowSets.push(getVisibleToolNamesFromAllowRules(compiledPermissionRules));
+    }
+    if (allowSets.length > 0) {
+        const intersect = new Set(allowSets[0]);
+        for (const next of allowSets.slice(1)) {
+            for (const name of Array.from(intersect)) {
+                if (!next.has(name))
+                    intersect.delete(name);
+            }
+        }
+        const filtered = new ToolRegistry();
+        for (const name of intersect) {
+            const spec = registry.getSpec(name);
+            if (spec)
+                filtered.register(spec);
+        }
+        registry = filtered;
+    }
+    // 4. Create Router (The execution pipeline)
+    const router = new ToolRouter(registry, policy, budget, audit, sanitize, options.authorizationProvider, { authorizationMode: options.authorizationMode, permissionRules: compiledPermissionRules });
+    // 4. Create Dispatcher (The high-level coordinator for LLM text)
+    const dispatcher = new ToolDispatcher(router, {
+        repoRoot: options.repoRoot,
+        persistenceRoot: options.persistenceRoot,
+        worktreeRoot: options.worktreeRoot,
+        attemptId: options.attemptId,
+        dryRun: options.dryRun,
+        model: options.model,
+    });
+    return {
+        registry,
+        router,
+        dispatcher,
+        budget,
+        audit,
+        policy,
+        sanitize,
+    };
+}
+//# sourceMappingURL=loader.js.map