salmon-loop 0.2.3

package/dist/core/config/limits.js

@@ -0,0 +1,77 @@
+export const LIMITS = {
+    // Patch safety
+    maxFilesChanged: 2,
+    maxDiffLines: 200,
+    maxRetries: 2,
+    // Context budget (token-based, with char fallback)
+    maxContextTokens: 7500, // ~30k chars equivalent
+    minContextTokens: 1250, // ~5k chars equivalent
+    maxPrimaryTokens: 3000, // ~12k chars equivalent
+    // Legacy char-based limits (for backwards compatibility)
+    maxContextChars: 30000,
+    minContextChars: 5000, // Protect against over-shrinking
+    maxPrimaryChars: 12000, // Cap primary file to prevent context explosion
+    // Search / shrink
+    maxKeywords: 3,
+    maxRelatedFiles: 20,
+    maxSnippetsAfterShrink: 30,
+    minSnippetChars: 64,
+    defaultSearchMatches: 100,
+    maxSearchMatches: 500,
+    // Verify
+    verifyOutputMaxLines: 300,
+    verifyTimeoutMs: Number(process.env.SALMONLOOP_VERIFY_TIMEOUT_MS) || 120000,
+    worktreePrepareTimeoutMs: Number(process.env.SALMONLOOP_WORKTREE_PREPARE_TIMEOUT_MS) || 600000,
+    auditVerifyOutputMaxInlineChars: 4000,
+    auditVerifyOutputPreviewHeadChars: 2000,
+    auditVerifyOutputPreviewTailChars: 2000,
+    auditToolSummaryMaxInlineChars: 4000,
+    auditToolSummaryPreviewHeadChars: 2000,
+    auditToolSummaryPreviewTailChars: 2000,
+    // Concurrency
+    maxConcurrentOperations: Number(process.env.SALMONLOOP_MAX_CONCURRENT) || 3,
+    // Logging
+    maxLogLength: 10000,
+    // Monitoring
+    maxErrorHistory: 10,
+    // Tool execution
+    defaultToolTimeoutMs: 30000,
+    maxToolOutputBytes: 1048576,
+    // Structured output
+    maxJsonSchemaBytes: 256 * 1024,
+    // Artifact storage (OS temp)
+    artifactTtlMs: Number(process.env.SALMONLOOP_ARTIFACT_TTL_MS) || 7 * 24 * 60 * 60 * 1000, // 7d
+    artifactMaxFiles: Number(process.env.SALMONLOOP_ARTIFACT_MAX_FILES) || 2000,
+    artifactMaxTotalBytes: Number(process.env.SALMONLOOP_ARTIFACT_MAX_TOTAL_BYTES) || 200 * 1024 * 1024, // 200MB
+    artifactGcIntervalMs: Number(process.env.SALMONLOOP_ARTIFACT_GC_INTERVAL_MS) || 60 * 1000, // 60s
+    // Heuristics & Size Limits
+    largeFileThresholdBytes: 10240,
+    binaryCheckBufferSize: 8192,
+    // Cache & Depth
+    astCacheSize: 50,
+    astCacheTTLMs: 60000,
+    maxDependencyDepth: 3,
+    // Git timeout
+    gitTimeoutMs: 15000,
+    gitKillGraceMs: Number(process.env.SALMONLOOP_GIT_KILL_GRACE_MS) || 8000,
+    // Conservative cross-platform command line budget (Windows is ~32k).
+    gitArgMaxChars: Number(process.env.SALMONLOOP_GIT_ARG_MAX_CHARS) || 30000,
+    // Resource locking
+    lockWaitTimeoutMs: 30000, // 30s wait before reporting timeout
+    lockAcquireHardTimeoutMs: Number(process.env.SALMONLOOP_LOCK_ACQUIRE_HARD_TIMEOUT_MS) || 60000, // Includes hung IO protection
+    lockStaleThresholdMs: 300000, // 5m stale threshold
+    // Retry strategies
+    retry: {
+        io: {
+            initialDelayMs: 100,
+            maxDelayMs: 2000,
+            maxAttempts: 5,
+        },
+        api: {
+            initialDelayMs: 500,
+            maxDelayMs: 10000,
+            maxAttempts: 3,
+        },
+    },
+};
+//# sourceMappingURL=limits.js.map

package/dist/core/config/load.js

@@ -0,0 +1,34 @@
+import { readFile } from '../adapters/fs/node-fs.js';
+import { ConfigError } from './errors.js';
+import { parseConfigText } from './file-format.js';
+import { getDefaultRepoConfigPaths, resolveConfigPath } from './paths.js';
+import { validateConfigFileV1 } from './validate.js';
+export async function tryLoadConfigFile(opts) {
+    if (!opts.enabled)
+        return null;
+    const candidatePaths = opts.configPath
+        ? [resolveConfigPath(opts.repoRoot, opts.configPath)]
+        : getDefaultRepoConfigPaths(opts.repoRoot);
+    for (let i = 0; i < candidatePaths.length; i++) {
+        const absPath = candidatePaths[i];
+        try {
+            const raw = await readFile(absPath, 'utf8');
+            const parsed = parseConfigText(raw, absPath);
+            const config = validateConfigFileV1(parsed);
+            return { path: absPath, config };
+        }
+        catch (e) {
+            if ((e && typeof e === 'object' && 'code' in e ? e.code : undefined) ===
+                'ENOENT') {
+                const isLast = i === candidatePaths.length - 1;
+                if (opts.required && isLast) {
+                    throw new ConfigError('CONFIG_FILE_NOT_FOUND', { path: absPath });
+                }
+                continue;
+            }
+            throw e;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=load.js.map

package/dist/core/config/normalize.js

@@ -0,0 +1,35 @@
+export function normalizeUiLogView(raw) {
+    const value = String(raw ?? '')
+        .trim()
+        .toLowerCase();
+    if (value === 'full' || value === 'verbose')
+        return 'full';
+    if (value === 'standard' || value === 'normal')
+        return 'standard';
+    if (value === 'compact' || value === 'dense')
+        return 'compact';
+    return undefined;
+}
+export function normalizeUiLogMode(raw) {
+    const value = String(raw ?? '')
+        .trim()
+        .toLowerCase();
+    if (value === 'quiet' || value === 'minimal')
+        return 'quiet';
+    if (value === 'normal' || value === 'default')
+        return 'normal';
+    if (value === 'debug' || value === 'all')
+        return 'debug';
+    return undefined;
+}
+export function normalizePermissionMode(raw) {
+    const value = String(raw ?? '')
+        .trim()
+        .toLowerCase();
+    if (value === 'interactive')
+        return 'interactive';
+    if (value === 'yolo')
+        return 'yolo';
+    return undefined;
+}
+//# sourceMappingURL=normalize.js.map

package/dist/core/config/paths.js

@@ -0,0 +1,20 @@
+import { join, resolve } from 'path';
+/**
+ * Repo-local configuration lives under ".salmonloop/" and is expected to be gitignored.
+ * Runtime state is stored under ".salmonloop/runtime/" (audit, rejections, tmp, locks).
+ */
+export function getDefaultRepoConfigPath(repoRoot) {
+    return getDefaultRepoConfigPaths(repoRoot)[0];
+}
+export function getDefaultRepoConfigPaths(repoRoot) {
+    const base = join(resolve(repoRoot), '.salmonloop', 'config');
+    return [join(base, 'config.yaml'), join(base, 'config.yml'), join(base, 'config.json')];
+}
+export function resolveConfigPath(repoRoot, configPath) {
+    // Relative paths are resolved against the target repo root (not the CLI's cwd).
+    return resolve(repoRoot, configPath);
+}
+export function getDefaultIndexPath(repoRoot) {
+    return join(resolve(repoRoot), '.salmonloop', 'index');
+}
+//# sourceMappingURL=paths.js.map

package/dist/core/config/redact.js

@@ -0,0 +1,16 @@
+export function redactConfigForPrint(config) {
+    const cloned = JSON.parse(JSON.stringify(config));
+    const providers = cloned.llm?.providers;
+    if (providers) {
+        for (const p of Object.values(providers)) {
+            if (p.api?.apiKey) {
+                p.api.apiKey = '[REDACTED]';
+            }
+        }
+    }
+    if (cloned.observability?.langfuse?.apiKey) {
+        cloned.observability.langfuse.apiKey = '[REDACTED]';
+    }
+    return cloned;
+}
+//# sourceMappingURL=redact.js.map

package/dist/core/config/resolve-env.js

@@ -0,0 +1,43 @@
+export function firstNonEmpty(value) {
+    if (!value)
+        return undefined;
+    const v = value.trim();
+    return v ? v : undefined;
+}
+export function parseBoolEnv(value) {
+    if (value === undefined)
+        return undefined;
+    const raw = value.trim().toLowerCase();
+    if (!raw)
+        return undefined;
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+export function resolveApiKey(inlineKey) {
+    const inline = firstNonEmpty(inlineKey || undefined);
+    if (inline)
+        return { key: inline, source: 'inline' };
+    const env = process.env.SALMONLOOP_API_KEY || process.env.S8P_API_KEY;
+    const envKey = firstNonEmpty(env);
+    if (envKey)
+        return { key: envKey, source: 'env' };
+    return { source: 'missing' };
+}
+export function resolveModelId(configModelId) {
+    return (firstNonEmpty(configModelId) ||
+        firstNonEmpty(process.env.SALMONLOOP_MODEL) ||
+        firstNonEmpty(process.env.S8P_MODEL) ||
+        'gpt-4o');
+}
+export function firstProviderRef(value) {
+    if (!value)
+        return undefined;
+    if (typeof value === 'string')
+        return firstNonEmpty(value);
+    for (const v of value) {
+        const found = firstNonEmpty(v);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+//# sourceMappingURL=resolve-env.js.map

package/dist/core/config/resolve-llm.js

@@ -0,0 +1,130 @@
+import { resolveBaseUrl } from '../llm/base-url.js';
+import { ConfigError } from './errors.js';
+import { firstProviderRef, resolveApiKey, resolveModelId } from './resolve-env.js';
+export function resolveLlmFromConfig(raw) {
+    const llm = raw?.llm;
+    const providers = llm?.providers || {};
+    const modelProfiles = llm?.models || {};
+    const hasConfiguredLlm = Boolean(llm);
+    if (!hasConfiguredLlm) {
+        return {
+            id: 'default',
+            type: 'openai-compatible',
+            clientPackage: undefined,
+            api: {
+                baseUrl: resolveBaseUrl(undefined),
+                timeoutMs: undefined,
+                headers: undefined,
+                apiKey: resolveApiKey(undefined).key,
+                apiKeySource: resolveApiKey(undefined).source,
+            },
+            models: {
+                selectedModelId: resolveModelId(undefined),
+                selectedModelSlot: 'default',
+            },
+        };
+    }
+    if (Object.keys(providers).length === 0) {
+        throw new ConfigError('CONFIG_LLM_PROVIDERS_REQUIRED');
+    }
+    if (Object.keys(modelProfiles).length === 0) {
+        throw new ConfigError('CONFIG_LLM_MODELS_REQUIRED');
+    }
+    const activeModelSlot = llm?.activeModel || Object.keys(modelProfiles)[0];
+    const activeProfile = modelProfiles[activeModelSlot];
+    if (!activeProfile) {
+        throw new ConfigError('CONFIG_LLM_ACTIVE_MODEL_NOT_FOUND', { model: activeModelSlot });
+    }
+    const providerId = firstProviderRef(activeProfile.provider);
+    if (!providerId) {
+        throw new ConfigError('CONFIG_LLM_MODEL_PROVIDER_INVALID', { model: activeModelSlot });
+    }
+    const provider = providers[providerId];
+    if (!provider) {
+        throw new ConfigError('CONFIG_LLM_MODEL_PROVIDER_NOT_FOUND', {
+            model: activeModelSlot,
+            provider: providerId,
+        });
+    }
+    const apiKeyResolution = resolveApiKey(provider.api?.apiKey);
+    const baseUrl = resolveBaseUrl(provider.api?.baseUrl);
+    const selectedModelId = resolveModelId(activeProfile.id);
+    const routing = llm?.routing;
+    const phaseToProviderModel = routing?.phaseToModel && typeof routing.phaseToModel === 'object'
+        ? Object.fromEntries(Object.entries(routing.phaseToModel)
+            .map(([phase, profileSlot]) => {
+            const profile = modelProfiles[profileSlot];
+            if (!profile) {
+                throw new ConfigError('CONFIG_LLM_PHASE_MODEL_NOT_FOUND', {
+                    phase,
+                    model: profileSlot,
+                });
+            }
+            const phaseProviderId = firstProviderRef(profile.provider);
+            if (!phaseProviderId) {
+                throw new ConfigError('CONFIG_LLM_PHASE_PROVIDER_INVALID', {
+                    phase,
+                    model: profileSlot,
+                });
+            }
+            const phaseProvider = providers[phaseProviderId];
+            if (!phaseProvider) {
+                throw new ConfigError('CONFIG_LLM_PHASE_PROVIDER_NOT_FOUND', {
+                    phase,
+                    model: profileSlot,
+                    provider: phaseProviderId,
+                });
+            }
+            const phaseKey = resolveApiKey(phaseProvider.api?.apiKey);
+            return [
+                phase,
+                {
+                    id: phaseProviderId,
+                    type: phaseProvider.type || 'openai-compatible',
+                    clientPackage: phaseProvider.client?.package,
+                    api: {
+                        baseUrl: resolveBaseUrl(phaseProvider.api?.baseUrl),
+                        timeoutMs: phaseProvider.api?.timeoutMs,
+                        headers: phaseProvider.api?.headers,
+                        apiKey: phaseKey.key,
+                        apiKeySource: phaseKey.source,
+                    },
+                    model: {
+                        id: resolveModelId(profile.id),
+                        slot: profileSlot,
+                    },
+                },
+            ];
+        })
+            .filter(Boolean))
+        : undefined;
+    const resolvedRouting = routing &&
+        (routing.fallbackProviders !== undefined ||
+            routing.taskToModel !== undefined ||
+            routing.phaseToModel !== undefined)
+        ? {
+            fallbackProviders: routing.fallbackProviders,
+            taskToModel: routing.taskToModel,
+            phaseToModel: routing.phaseToModel,
+            phaseToProviderModel,
+        }
+        : undefined;
+    return {
+        id: providerId,
+        type: provider?.type || 'openai-compatible',
+        clientPackage: provider?.client?.package,
+        api: {
+            baseUrl,
+            timeoutMs: provider?.api?.timeoutMs,
+            headers: provider?.api?.headers,
+            apiKey: apiKeyResolution.key,
+            apiKeySource: apiKeyResolution.source,
+        },
+        models: {
+            selectedModelId,
+            selectedModelSlot: activeModelSlot,
+        },
+        routing: resolvedRouting,
+    };
+}
+//# sourceMappingURL=resolve-llm.js.map

package/dist/core/config/resolve.js

@@ -0,0 +1,68 @@
+import { resolveLlmOutputPolicy } from '../llm/output-policy.js';
+import { tryLoadConfigFile } from './load.js';
+import { getDefaultRepoConfigPath } from './paths.js';
+import { resolveLlmFromConfig } from './resolve-llm.js';
+import { resolveAstValidationStrictness } from './resolvers/ast-validation.js';
+import { resolveDynamicBudget, resolveUseTokenBudget } from './resolvers/context.js';
+import { resolveAuditBuffer, resolveAuditScope, resolveLangfuseObservability, } from './resolvers/observability.js';
+import { resolveMarkdownRenderMode, resolveMarkdownTheme } from './resolvers/output.js';
+import { resolvePermissionMode } from './resolvers/permission-mode.js';
+import { resolveRedactionConfig } from './resolvers/security.js';
+import { resolveServerConfig } from './resolvers/server.js';
+import { resolveToolAuthorization } from './resolvers/tool-authorization.js';
+import { resolveUiLogMode, resolveUiLogView } from './resolvers/ui.js';
+export async function resolveConfig(opts) {
+    const enabled = opts.enableConfigFile !== false;
+    const path = opts.configFilePath;
+    const required = Boolean(opts.configFilePath);
+    const loaded = await tryLoadConfigFile({
+        repoRoot: opts.repoRoot,
+        configPath: path,
+        enabled,
+        required,
+    });
+    const raw = loaded?.config;
+    const uiLogMode = resolveUiLogMode(raw);
+    const permissionMode = resolvePermissionMode(raw);
+    return {
+        source: {
+            enabled,
+            path: loaded?.path || path || getDefaultRepoConfigPath(opts.repoRoot),
+            used: Boolean(loaded),
+        },
+        raw,
+        permissionMode,
+        server: resolveServerConfig(raw),
+        context: {
+            useTokenBudget: resolveUseTokenBudget(raw),
+            dynamicBudget: resolveDynamicBudget(raw),
+        },
+        observability: {
+            langfuse: resolveLangfuseObservability(raw),
+            audit: {
+                scope: resolveAuditScope(raw),
+                buffer: resolveAuditBuffer(raw),
+            },
+        },
+        security: {
+            redaction: resolveRedactionConfig(raw),
+        },
+        ui: {
+            logMode: uiLogMode,
+            logView: resolveUiLogView(raw, uiLogMode),
+        },
+        verify: {
+            command: raw?.verify?.command,
+            timeoutMs: raw?.verify?.timeoutMs,
+        },
+        astValidation: {
+            strictness: resolveAstValidationStrictness(raw),
+        },
+        llm: resolveLlmFromConfig(raw),
+        llmOutput: resolveLlmOutputPolicy(raw?.output?.llm),
+        markdownTheme: resolveMarkdownTheme(raw),
+        markdownRenderMode: resolveMarkdownRenderMode(raw),
+        toolAuthorization: resolveToolAuthorization(raw),
+    };
+}
+//# sourceMappingURL=resolve.js.map

package/dist/core/config/resolvers/ast-validation.js

@@ -0,0 +1,8 @@
+import { DEFAULT_AST_VALIDATION_STRICTNESS } from '../defaults.js';
+export function resolveAstValidationStrictness(raw) {
+    const strictness = raw?.astValidation?.strictness;
+    if (strictness === 'strict' || strictness === 'lenient')
+        return strictness;
+    return DEFAULT_AST_VALIDATION_STRICTNESS;
+}
+//# sourceMappingURL=ast-validation.js.map

package/dist/core/config/resolvers/context.js

@@ -0,0 +1,21 @@
+import { DEFAULT_DYNAMIC_BUDGET, DEFAULT_USE_TOKEN_BUDGET } from '../defaults.js';
+export function resolveUseTokenBudget(raw) {
+    const value = raw?.context?.useTokenBudget;
+    if (value === undefined)
+        return DEFAULT_USE_TOKEN_BUDGET;
+    return value !== false;
+}
+export function resolveDynamicBudget(raw) {
+    const config = raw?.context?.dynamicBudget;
+    return {
+        enabled: config?.enabled ?? DEFAULT_DYNAMIC_BUDGET.enabled,
+        minBudget: config?.minBudget ?? DEFAULT_DYNAMIC_BUDGET.minBudget,
+        maxBudget: config?.maxBudget ?? DEFAULT_DYNAMIC_BUDGET.maxBudget,
+        adjustmentStep: config?.adjustmentStep ?? DEFAULT_DYNAMIC_BUDGET.adjustmentStep,
+        alerts: {
+            truncationRateWarn: config?.alerts?.truncationRateWarn ?? DEFAULT_DYNAMIC_BUDGET.alerts.truncationRateWarn,
+            criticalDropRateWarn: config?.alerts?.criticalDropRateWarn ?? DEFAULT_DYNAMIC_BUDGET.alerts.criticalDropRateWarn,
+        },
+    };
+}
+//# sourceMappingURL=context.js.map

package/dist/core/config/resolvers/observability.js

@@ -0,0 +1,45 @@
+import { DEFAULT_AUDIT_BUFFER } from '../defaults.js';
+import { firstNonEmpty, parseBoolEnv } from '../resolve-env.js';
+function resolveLangfuseApiKey(inlineKey) {
+    const inline = firstNonEmpty(inlineKey);
+    if (inline)
+        return { key: inline, source: 'inline' };
+    const envKey = firstNonEmpty(process.env.SALMONLOOP_LANGFUSE_API_KEY);
+    if (envKey)
+        return { key: envKey, source: 'env' };
+    return { source: 'missing' };
+}
+export function resolveLangfuseObservability(raw) {
+    const cfg = raw?.observability?.langfuse;
+    const enabled = parseBoolEnv(process.env.SALMONLOOP_LANGFUSE) ?? cfg?.enabled ?? false;
+    const outcome = parseBoolEnv(process.env.SALMONLOOP_LANGFUSE_OUTCOME) ?? cfg?.outcome ?? false;
+    // Prefer explicit proxy base URL env override (backwards-compatible). This may be either:
+    // - a root proxy URL (e.g. "https://api.s8p.io"), or
+    // - a full /langfuse endpoint (e.g. "https://api.s8p.io/langfuse/").
+    const endpoint = firstNonEmpty(process.env.SALMONLOOP_LANGFUSE_PROXY_URL) ?? firstNonEmpty(cfg?.endpoint);
+    const resolvedApiKey = resolveLangfuseApiKey(cfg?.apiKey);
+    const sessionId = firstNonEmpty(process.env.SALMONLOOP_LANGFUSE_SESSION_ID) ?? firstNonEmpty(cfg?.sessionId);
+    const userId = firstNonEmpty(process.env.SALMONLOOP_LANGFUSE_USER_ID) ?? firstNonEmpty(cfg?.userId);
+    return {
+        enabled,
+        outcome,
+        endpoint,
+        apiKey: resolvedApiKey.key,
+        apiKeySource: resolvedApiKey.source,
+        sessionId,
+        userId,
+    };
+}
+export function resolveAuditBuffer(raw) {
+    const cfg = raw?.observability?.audit?.buffer;
+    return {
+        maxEvents: cfg?.maxEvents ?? DEFAULT_AUDIT_BUFFER.maxEvents,
+        maxBytes: cfg?.maxBytes ?? DEFAULT_AUDIT_BUFFER.maxBytes,
+        droppedWarn: cfg?.droppedWarn ?? DEFAULT_AUDIT_BUFFER.droppedWarn,
+    };
+}
+export function resolveAuditScope(raw) {
+    const scope = raw?.observability?.audit?.scope;
+    return scope === 'user' ? 'user' : 'repo';
+}
+//# sourceMappingURL=observability.js.map

package/dist/core/config/resolvers/output.js

@@ -0,0 +1,8 @@
+import { DEFAULT_MARKDOWN_RENDER_MODE, DEFAULT_MARKDOWN_THEME } from '../types.js';
+export function resolveMarkdownTheme(raw) {
+    return raw?.output?.markdown?.theme ?? DEFAULT_MARKDOWN_THEME;
+}
+export function resolveMarkdownRenderMode(raw) {
+    return raw?.output?.markdown?.mode ?? DEFAULT_MARKDOWN_RENDER_MODE;
+}
+//# sourceMappingURL=output.js.map

package/dist/core/config/resolvers/permission-mode.js

@@ -0,0 +1,6 @@
+import { normalizePermissionMode } from '../normalize.js';
+export function resolvePermissionMode(raw) {
+    const cfg = normalizePermissionMode(raw?.mode);
+    return cfg ?? 'interactive';
+}
+//# sourceMappingURL=permission-mode.js.map

package/dist/core/config/resolvers/security.js

@@ -0,0 +1,14 @@
+import { DEFAULT_REDACTION_CONFIG } from '../defaults.js';
+export function resolveRedactionConfig(raw) {
+    const cfg = raw?.security?.redaction;
+    return {
+        enabled: cfg?.enabled ?? DEFAULT_REDACTION_CONFIG.enabled,
+        mark: cfg?.mark ?? DEFAULT_REDACTION_CONFIG.mark,
+        maxDepth: cfg?.maxDepth ?? DEFAULT_REDACTION_CONFIG.maxDepth,
+        keyAllowlist: cfg?.keyAllowlist,
+        keyDenylist: cfg?.keyDenylist,
+        patterns: cfg?.patterns,
+        disableDefaults: cfg?.disableDefaults,
+    };
+}
+//# sourceMappingURL=security.js.map

package/dist/core/config/resolvers/server.js

@@ -0,0 +1,36 @@
+export function resolveServerConfig(raw) {
+    const serverRaw = raw?.server;
+    if (!serverRaw)
+        return undefined;
+    const server = {};
+    if (serverRaw.a2a) {
+        server.a2a = {
+            host: serverRaw.a2a.host,
+            port: serverRaw.a2a.port,
+            tokens: serverRaw.a2a.tokens,
+        };
+    }
+    if (serverRaw.sidecar) {
+        server.sidecar = {
+            socket: serverRaw.sidecar.socket,
+            allowConditional: serverRaw.sidecar.allowConditional,
+        };
+    }
+    if (serverRaw.acp) {
+        server.acp = {
+            sessionStore: {
+                maxEntries: serverRaw.acp.sessionStore?.maxEntries,
+                maxAgeMs: serverRaw.acp.sessionStore?.maxAgeMs,
+                historyMaxEntries: serverRaw.acp.sessionStore?.historyMaxEntries,
+                lockStaleMs: serverRaw.acp.sessionStore?.lockStaleMs,
+                lockHeartbeatMs: serverRaw.acp.sessionStore?.lockHeartbeatMs,
+            },
+            checkpointManifest: {
+                lockStaleMs: serverRaw.acp.checkpointManifest?.lockStaleMs,
+                lockHeartbeatMs: serverRaw.acp.checkpointManifest?.lockHeartbeatMs,
+            },
+        };
+    }
+    return Object.keys(server).length > 0 ? server : undefined;
+}
+//# sourceMappingURL=server.js.map

package/dist/core/config/resolvers/tool-authorization.js

@@ -0,0 +1,39 @@
+import { DEFAULT_TOOL_AUTH } from '../defaults.js';
+export function resolveToolAuthorization(raw) {
+    const config = raw?.toolAuthorization;
+    return {
+        sessionTtlMs: config?.sessionTtlMs ?? DEFAULT_TOOL_AUTH.sessionTtlMs,
+        autoAllowRisk: {
+            low: config?.autoAllowRisk?.low ?? DEFAULT_TOOL_AUTH.autoAllowRisk?.low,
+            medium: config?.autoAllowRisk?.medium ?? DEFAULT_TOOL_AUTH.autoAllowRisk?.medium,
+            high: config?.autoAllowRisk?.high ?? DEFAULT_TOOL_AUTH.autoAllowRisk?.high,
+        },
+        nonInteractive: {
+            strategy: config?.nonInteractive?.strategy ?? DEFAULT_TOOL_AUTH.nonInteractive?.strategy ?? 'deny',
+            command: config?.nonInteractive?.command,
+            mcp: config?.nonInteractive?.mcp,
+        },
+        allowlist: {
+            repoFile: config?.allowlist?.repoFile ?? DEFAULT_TOOL_AUTH.allowlist?.repoFile,
+            userFile: config?.allowlist?.userFile ?? DEFAULT_TOOL_AUTH.allowlist?.userFile,
+            summary: {
+                every: config?.allowlist?.summary?.every ?? DEFAULT_TOOL_AUTH.allowlist?.summary?.every,
+                minIntervalMs: config?.allowlist?.summary?.minIntervalMs ??
+                    DEFAULT_TOOL_AUTH.allowlist?.summary?.minIntervalMs,
+                failureMinIntervalMs: config?.allowlist?.summary?.failureMinIntervalMs ??
+                    DEFAULT_TOOL_AUTH.allowlist?.summary?.failureMinIntervalMs,
+                maxToolStats: config?.allowlist?.summary?.maxToolStats ??
+                    DEFAULT_TOOL_AUTH.allowlist?.summary?.maxToolStats,
+                maxPathStats: config?.allowlist?.summary?.maxPathStats ??
+                    DEFAULT_TOOL_AUTH.allowlist?.summary?.maxPathStats,
+            },
+            matching: {
+                denySideEffects: config?.allowlist?.matching?.denySideEffects ??
+                    DEFAULT_TOOL_AUTH.allowlist?.matching?.denySideEffects,
+                allowSideEffects: config?.allowlist?.matching?.allowSideEffects ??
+                    DEFAULT_TOOL_AUTH.allowlist?.matching?.allowSideEffects,
+            },
+        },
+    };
+}
+//# sourceMappingURL=tool-authorization.js.map

package/dist/core/config/resolvers/ui.js

@@ -0,0 +1,26 @@
+import { normalizeUiLogMode, normalizeUiLogView } from '../normalize.js';
+import { DEFAULT_UI_LOG_MODE, DEFAULT_UI_LOG_VIEW } from '../types.js';
+export function resolveUiLogMode(raw) {
+    const env = normalizeUiLogMode(process.env.SALMONLOOP_UI_LOG_MODE) ??
+        normalizeUiLogMode(process.env.SALMONLOOP_UI_MODE);
+    if (env)
+        return env;
+    const cfg = normalizeUiLogMode(raw?.ui?.log?.mode);
+    return cfg ?? DEFAULT_UI_LOG_MODE;
+}
+export function resolveUiLogView(raw, mode) {
+    const env = normalizeUiLogView(process.env.SALMONLOOP_UI_LOG_VIEW) ??
+        normalizeUiLogView(process.env.SALMONLOOP_UI_LOG) ??
+        normalizeUiLogView(process.env.SALMONLOOP_UI_DENSITY);
+    if (env)
+        return env;
+    const cfg = normalizeUiLogView(raw?.ui?.log?.view);
+    if (cfg)
+        return cfg;
+    if (mode === 'quiet')
+        return 'compact';
+    if (mode === 'debug')
+        return 'full';
+    return DEFAULT_UI_LOG_VIEW;
+}
+//# sourceMappingURL=ui.js.map

package/dist/core/config/types/config-file.js

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

package/dist/core/config/types/primitives.js

@@ -0,0 +1,9 @@
+export const MARKDOWN_THEMES = ['default', 'vivid'];
+export const DEFAULT_MARKDOWN_THEME = 'default';
+export const MARKDOWN_RENDER_MODES = ['enhanced', 'native'];
+export const DEFAULT_MARKDOWN_RENDER_MODE = 'enhanced';
+export const UI_LOG_VIEWS = ['full', 'standard', 'compact'];
+export const DEFAULT_UI_LOG_VIEW = 'standard';
+export const UI_LOG_MODES = ['quiet', 'normal', 'debug'];
+export const DEFAULT_UI_LOG_MODE = 'normal';
+//# sourceMappingURL=primitives.js.map

package/dist/core/config/types/resolved.js

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

package/dist/core/config/types.js

@@ -0,0 +1,4 @@
+export * from './types/primitives.js';
+export * from './types/config-file.js';
+export * from './types/resolved.js';
+//# sourceMappingURL=types.js.map