salmon-loop 0.2.13 → 0.2.16

package/dist/core/context/service.js

@@ -147,6 +147,14 @@ export class ContextService {
             if (target.path)
                 deduped.add(target.path);
         }
+        for (const file of result.context.relatedFiles ?? []) {
+            if (file.path)
+                deduped.add(file.path);
+        }
+        for (const snippet of result.context.rgSnippets ?? []) {
+            if (snippet.file)
+                deduped.add(snippet.file);
+        }
         return [...deduped].sort().slice(0, ContextService.MAX_CACHE_TRACKED_FILES);
     }
     async computeTrackedFilesSignature(repoPath, files) {

package/dist/core/context/steps/context-gather.js

@@ -1,7 +1,27 @@
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { LIMITS } from '../../config/limits.js';
+import { ensureInSandbox, normalizePath, safeJoin } from '../../utils/path.js';
+import { outlineSource } from '../ast/source-outline.js';
 import { CONTEXT_AUDIT_ACTION, CONTEXT_AUDIT_PHASE } from '../audit-constants.js';
 import { recordContextAuditEvent } from '../audit.js';
 import { extractKeywords } from '../keywords.js';
 import { assertNotAborted } from '../service-helpers.js';
+const fileAdapter = new FileAdapter();
+async function readMatchedFileContent(req, file) {
+    if (req.snapshotHash && req.checkpointManager) {
+        return req.checkpointManager.readSnapshotFile(req.repoPath, req.snapshotHash, file);
+    }
+    try {
+        const fullPath = ensureInSandbox(req.repoPath, safeJoin(req.repoPath, file));
+        const stat = await fileAdapter.stat(fullPath);
+        if (!stat.isFile() || stat.size > LIMITS.largeFileThresholdBytes)
+            return null;
+        return await fileAdapter.readFile(fullPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
 export function buildContextGatherStep(deps) {
     return async ({ req, diffScope, primaryText }) => {
         assertNotAborted(req.signal);
@@ -24,6 +44,24 @@ export function buildContextGatherStep(deps) {
         if (ghostFiles.length > 0) {
             astRes.relatedFiles.push(...ghostFiles);
         }
+        const relatedSeen = new Set(astRes.relatedFiles.map((file) => file.path));
+        const primaryPath = req.primaryFile
+            ? normalizePath(req.primaryFile).replace(/^(\.\/|\/)+/, '')
+            : undefined;
+        for (const snippet of rgSnippets) {
+            const file = normalizePath(snippet.file).replace(/^(\.\/|\/)+/, '');
+            if (!file || file === primaryPath || relatedSeen.has(file))
+                continue;
+            relatedSeen.add(file);
+            const content = await readMatchedFileContent(req, file);
+            astRes.relatedFiles.push({
+                path: file,
+                kind: 'dependency',
+                mode: content ? 'full' : 'outline',
+                content: content ?? `ripgrep match at line ${snippet.line}: ${snippet.content}`,
+                outline: content ? outlineSource(content) : undefined,
+            });
+        }
         recordContextAuditEvent(CONTEXT_AUDIT_ACTION.gatherCompleted, {
             rgSnippets: rgSnippets.length,
             includedFiles: diffRes.includedFiles.length,

package/dist/core/context/summarization/summarizer.js

@@ -9,7 +9,7 @@
  *
  * Based on best practices from LangChain, OpenAI Realtime API, and Voice AI systems.
  */
-import { getLogger } from '../../observability/logger.js';
+import { tryGetLogger } from '../../observability/logger.js';
 import { buildIncrementalSummaryPrompt, truncateSummary } from './prompts.js';
 import { DEFAULT_SUMMARIZATION_CONFIG } from './types.js';
 /**
@@ -49,6 +49,7 @@ export class ConversationSummarizer {
             summaryVersion: 2,
             structuredState: this.createEmptyStructuredState(),
             contextHash: undefined,
+            recoveryState: undefined,
         };
     }
     // ==================== Lifecycle ====================
@@ -57,7 +58,7 @@ export class ConversationSummarizer {
      */
     async initialize() {
         this.initialized = true;
-        getLogger().debug('[Summarizer] Initialized');
+        tryGetLogger()?.debug('[Summarizer] Initialized');
     }
     /**
      * Dispose resources.
@@ -77,10 +78,9 @@ export class ConversationSummarizer {
             summarizedMessageIds: [...this.state.summarizedMessageIds],
             lastSummarizedAt: this.state.lastSummarizedAt,
             summaryVersion: this.state.summaryVersion,
-            structuredState: this.state.structuredState
-                ? { ...this.state.structuredState }
-                : this.createEmptyStructuredState(),
+            structuredState: this.cloneStructuredState(this.state.structuredState),
             contextHash: this.state.contextHash,
+            recoveryState: this.cloneRecoveryState(this.state.recoveryState),
         };
     }
     /**
@@ -97,8 +97,9 @@ export class ConversationSummarizer {
                 ? this.normalizeStructuredState(state.structuredState)
                 : this.createEmptyStructuredState(),
             contextHash: state.contextHash,
+            recoveryState: this.cloneRecoveryState(state.recoveryState),
         };
-        getLogger().debug(`[Summarizer] Restored state with ${state.summarizedMessageIds.length} summarized messages`);
+        tryGetLogger()?.debug(`[Summarizer] Restored state with ${state.summarizedMessageIds.length} summarized messages`);
     }
     /**
      * Reset summarizer state.
@@ -112,6 +113,7 @@ export class ConversationSummarizer {
             summaryVersion: 2,
             structuredState: this.createEmptyStructuredState(),
             contextHash: undefined,
+            recoveryState: undefined,
         };
         this.summaryInProgress = false;
     }
@@ -189,7 +191,7 @@ export class ConversationSummarizer {
      */
     async triggerSummarization(messages, contextHash) {
         if (this.summaryInProgress) {
-            getLogger().debug('[Summarizer] Summary already in progress, skipping');
+            tryGetLogger()?.debug('[Summarizer] Summary already in progress, skipping');
             return null;
         }
         this.ensureStateAligned(contextHash);
@@ -200,7 +202,7 @@ export class ConversationSummarizer {
             // Fire and forget
             this.runSummarization(messages, contextHash).catch((err) => {
                 const errMsg = err instanceof Error ? err.message : String(err);
-                getLogger().warn(`[Summarizer] Async summarization failed: ${errMsg}`);
+                tryGetLogger()?.warn(`[Summarizer] Async summarization failed: ${errMsg}`);
             });
             return null;
         }
@@ -269,7 +271,7 @@ export class ConversationSummarizer {
                 this.state.summarizedMessageIds.push(msg.id);
             }
             this.state.lastSummarizedAt = Date.now();
-            getLogger().info(`[Summarizer] Summarized ${batch.length} messages, ` +
+            tryGetLogger()?.info(`[Summarizer] Summarized ${batch.length} messages, ` +
                 `reduced ${beforeTokens} → ${this.state.summaryTokens} tokens`);
             return {
                 summary: newSummary,
@@ -281,7 +283,7 @@ export class ConversationSummarizer {
             };
         }
         catch (error) {
-            getLogger().error('[Summarizer] Summarization failed', error);
+            tryGetLogger()?.error('[Summarizer] Summarization failed', error);
             throw error;
         }
         finally {
@@ -306,7 +308,7 @@ export class ConversationSummarizer {
             return;
         if (!this.state.contextHash || this.state.contextHash === contextHash)
             return;
-        getLogger().warn(`[Summarizer] Context hash changed (${this.state.contextHash} -> ${contextHash}), rebuilding summary state`);
+        tryGetLogger()?.warn(`[Summarizer] Context hash changed (${this.state.contextHash} -> ${contextHash}), rebuilding summary state`);
         this.state.summary = '';
         this.state.summaryTokens = 0;
         this.state.summarizedMessageIds = [];
@@ -327,7 +329,7 @@ export class ConversationSummarizer {
         }
         catch (error) {
             const errMsg = error instanceof Error ? error.message : String(error);
-            getLogger().warn(`[Summarizer] Failed to parse structured summary state: ${errMsg}`);
+            tryGetLogger()?.warn(`[Summarizer] Failed to parse structured summary state: ${errMsg}`);
             return { summary, structuredState: this.createEmptyStructuredState() };
         }
     }
@@ -346,6 +348,47 @@ export class ConversationSummarizer {
         normalized.owner = this.ensureStringArray(source.owner);
         return normalized;
     }
+    cloneStructuredState(state) {
+        if (!state)
+            return this.createEmptyStructuredState();
+        return {
+            decisions: [...state.decisions],
+            constraints: [...state.constraints],
+            open_questions: [...state.open_questions],
+            pending_tasks: [...state.pending_tasks],
+            rejected_options: [...state.rejected_options],
+            assumptions: [...state.assumptions],
+            risks: [...state.risks],
+            owner: [...state.owner],
+        };
+    }
+    cloneRecoveryFailureSummary(value) {
+        if (!value)
+            return undefined;
+        return {
+            reasonCode: value.reasonCode,
+            diagnosticCode: value.diagnosticCode,
+            safeHint: value.safeHint,
+            failurePhase: value.failurePhase,
+        };
+    }
+    cloneRecoveryState(state) {
+        if (!state)
+            return undefined;
+        const flowMode = typeof state.flowMode === 'string' ? state.flowMode : undefined;
+        const recentReadFiles = Array.isArray(state.recentReadFiles)
+            ? state.recentReadFiles.filter((item) => typeof item === 'string')
+            : undefined;
+        const next = {};
+        if (flowMode)
+            next.flowMode = flowMode;
+        const lastFailureSummary = this.cloneRecoveryFailureSummary(state.lastFailureSummary);
+        if (lastFailureSummary)
+            next.lastFailureSummary = lastFailureSummary;
+        if (recentReadFiles && recentReadFiles.length > 0)
+            next.recentReadFiles = [...recentReadFiles];
+        return Object.keys(next).length > 0 ? next : undefined;
+    }
     ensureStringArray(value) {
         if (!Array.isArray(value))
             return [];

package/dist/core/context/targeting/target-resolver.js

@@ -387,9 +387,6 @@ export class TargetResolver {
             debugLabel: 'context-targeting',
             maxRounds: 5,
             resolveData: async (ctx, key) => {
-                if (!ctx.primaryFile) {
-                    return [];
-                }
                 if (key === 'explicitTargets') {
                     const primary = buildPrimaryTarget(ctx.primaryFile);
                     const explicit = buildExplicitTargets(req);
@@ -401,6 +398,8 @@ export class TargetResolver {
                     return dedupeTargets([...primary, ...diff]);
                 }
                 if (key === 'symbolTargets') {
+                    if (!ctx.primaryFile)
+                        return [];
                     const primary = buildPrimaryTarget(ctx.primaryFile);
                     const res = buildSymbolTargets({
                         primaryFile: ctx.primaryFile,
@@ -420,6 +419,8 @@ export class TargetResolver {
                     const combined = dedupeTargets([...primary, ...imports, ...rg]);
                     if (combined.length > 0)
                         return combined;
+                    if (!ctx.primaryFile)
+                        return [];
                     return [
                         {
                             path: ctx.primaryFile,
@@ -434,7 +435,6 @@ export class TargetResolver {
             strategy: (engine) => {
                 return engine
                     .phase('Dependencies')
-                    .require((c) => Boolean(c.primaryFile), 'No primary file provided')
                     .requireData(['explicitTargets', 'symbolTargets', 'diffTargets', 'defaultTargets'])
                     .phase('Selection')
                     .when((c) => (c.data?.explicitTargets || []).some((t) => t.reason === 'explicit_path'), (p) => {

package/dist/core/extensions/index.js

@@ -1,6 +1,8 @@
+import path from 'node:path';
+import { getLogger } from '../observability/logger.js';
 import { loadConfig } from './load.js';
 import { mergeScopedEntries } from './merge.js';
-import { expandHome, getRepoMcpConfigPath, getRepoSkillConfigPath, getRepoToolConfigPath, getUserMcpConfigPath, getUserSkillConfigPath, getUserToolConfigPath, resolveRepoRelative, resolveUserRelative, } from './paths.js';
+import { expandHome, getRepoMcpConfigPath, getRepoSkillConfigPath, getRepoToolConfigPath, getUserMcpConfigPath, getUserSkillConfigPath, getUserToolConfigPath, isWithinRoot, resolveRepoRelative, resolveUserRelative, } from './paths.js';
 import { redactExtensions } from './redact.js';
 import { McpConfigSchema, SkillsConfigSchema, ToolsConfigSchema } from './schemas.js';
 function defaultEnabled(scope) {
@@ -63,16 +65,33 @@ function buildResolvedPlugins(entries, repoRoot) {
 function buildResolvedSkills(user, repo, repoRoot) {
     const repoDiscovery = repo?.discovery;
     const userDiscovery = user?.discovery;
-    const useDefaults = repoDiscovery?.useDefaults ?? userDiscovery?.useDefaults ?? true;
     const repoPaths = repoDiscovery && Array.isArray(repoDiscovery.paths) ? repoDiscovery.paths : undefined;
     const userPaths = userDiscovery && Array.isArray(userDiscovery.paths) ? userDiscovery.paths : undefined;
     let scope = 'repo';
     let paths = [];
     if (repoPaths && repoPaths.length > 0) {
         scope = 'repo';
+        const root = repoRoot ?? '';
         paths = repoPaths
-            .map((value) => resolvePathForScope(value, 'repo', repoRoot ?? ''))
-            .filter((p) => Boolean(p));
+            .filter((raw) => {
+            // Reject absolute paths in repo scope — only user-level config may specify them
+            const expanded = expandHome(raw);
+            if (path.isAbsolute(expanded)) {
+                getLogger().audit('SKILL_PATH_REJECTED', { path: raw, repoRoot: root, reason: 'absolute_path_in_repo_scope' }, { source: 'skill-loader', severity: 'high', scope: 'repo' });
+                return false;
+            }
+            return true;
+        })
+            .map((value) => resolvePathForScope(value, 'repo', root))
+            .filter((p) => Boolean(p))
+            .filter((p) => {
+            // Validate resolved paths stay within repo root
+            if (!isWithinRoot(p, root)) {
+                getLogger().audit('SKILL_PATH_REJECTED', { path: p, repoRoot: root, reason: 'outside_repo_root' }, { source: 'skill-loader', severity: 'high', scope: 'repo' });
+                return false;
+            }
+            return true;
+        });
     }
     else if (userPaths && userPaths.length > 0) {
         scope = 'user';
@@ -81,7 +100,6 @@ function buildResolvedSkills(user, repo, repoRoot) {
             .filter((p) => Boolean(p));
     }
     return {
-        useDefaults,
         paths,
         scope,
     };

package/dist/core/extensions/paths.js

@@ -1,5 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
+import { realpathSync } from '../adapters/fs/node-fs.js';
+import { tryGetLogger } from '../observability/logger.js';
 export const REPO_CONFIG_DIR = '.salmonloop/config';
 export const USER_CONFIG_DIR = path.join(os.homedir(), '.salmonloop', 'config');
 export function expandHome(value) {
@@ -37,4 +39,33 @@ export function getUserToolConfigPath() {
 export function getUserSkillConfigPath() {
     return path.join(USER_CONFIG_DIR, 'skills-user.json');
 }
+/**
+ * Check whether a candidate path resides within (or equals) a given root directory.
+ *
+ * Uses realpath resolution to detect symlink-based escapes when both paths exist.
+ * When the candidate does not yet exist on disk (e.g. configured before the
+ * directory is created), falls back to a lexical containment check on the
+ * resolved (but not realpath'd) path. This avoids silently discarding valid
+ * future paths while still catching traversal attacks on existing paths.
+ *
+ * @returns true when the resolved candidate is the root itself or a descendant;
+ *          false when the path escapes the root.
+ */
+export function isWithinRoot(candidate, root) {
+    const resolvedCandidate = path.resolve(candidate);
+    const resolvedRoot = path.resolve(root);
+    try {
+        // Happy path: both exist — use realpath to resolve symlinks
+        const realCandidate = realpathSync(resolvedCandidate);
+        const realRoot = realpathSync(resolvedRoot);
+        return realCandidate === realRoot || realCandidate.startsWith(realRoot + path.sep);
+    }
+    catch {
+        // Candidate or root does not exist yet — fall back to lexical check.
+        // This allows pre-declaring paths that will be created later, while
+        // still catching obvious traversal sequences like `../../etc`.
+        tryGetLogger()?.debug(`isWithinRoot: path not on disk, using lexical check for "${candidate}" against root "${root}"`);
+        return (resolvedCandidate === resolvedRoot || resolvedCandidate.startsWith(resolvedRoot + path.sep));
+    }
+}
 //# sourceMappingURL=paths.js.map

package/dist/core/extensions/schemas.js

@@ -59,12 +59,15 @@ export const ToolsConfigSchema = z.object({
     version: z.literal(1),
     plugins: z.record(z.string(), toolPluginSchema).optional().default({}),
 });
-const skillDiscoverySchema = z.object({
-    useDefaults: z.boolean().optional(),
+const skillDiscoverySchema = z
+    .object({
     paths: z.array(z.string()).optional(),
-});
-export const SkillsConfigSchema = z.object({
+})
+    .strict();
+export const SkillsConfigSchema = z
+    .object({
     version: z.literal(1),
     discovery: skillDiscoverySchema.optional().default({}),
-});
+})
+    .strict();
 //# sourceMappingURL=schemas.js.map

package/dist/core/facades/cli-chat.js

@@ -3,9 +3,13 @@ export { routeChatIntent } from '../intent/chat-intent.js';
 export { DEFAULT_LLM_OUTPUT_POLICY, emitLlmOutput } from '../llm/output-policy.js';
 export { logIgnoredError } from '../observability/ignored-error.js';
 export { getLogger } from '../observability/logger.js';
+export { resolveExecutionProfile } from '../runtime/execution-profile.js';
 export { runSalmonLoop } from '../runtime/loop.js';
+export { buildSessionArtifactStateFromLoopResult } from '../session/artifact-state.js';
 export { ChatSessionManager } from '../session/manager.js';
-export { buildSessionConversationContext, getDefaultSessionContextBudgetTokens, } from '../session/session-context-builder.js';
-export { refreshSessionSummary } from '../session/summary-sync.js';
+export { getDefaultSessionContextBudgetTokens } from '../session/session-context-builder.js';
+export { buildEffectiveConversationContext, refreshSessionSummary, } from '../session/summary-sync.js';
+export { createInitialTracking, onNormalTurnComplete } from '../session/compaction/tracking.js';
+export { runCompactionPipeline, reactiveCompact } from '../session/compaction/index.js';
 export { TokenTracker } from '../session/token-tracker.js';
 //# sourceMappingURL=cli-chat.js.map

package/dist/core/facades/cli-command-chat.js

@@ -3,6 +3,7 @@ export { ExtensionConfigError, resolveExtensions } from '../extensions/index.js'
 export { createRuntimeLlm } from '../llm/factory.js';
 export { getLogger } from '../observability/logger.js';
 export { PluginLoader } from '../plugin/loader.js';
+export { resolveExecutionProfile } from '../runtime/execution-profile.js';
 export { clearPluginRegistry, createPluginRegistry, setPluginRegistry, } from '../plugin/registry.js';
 export { clearPromptRegistry, createPromptRegistry, setPromptRegistry, } from '../prompts/registry.js';
 //# sourceMappingURL=cli-command-chat.js.map

package/dist/core/facades/cli-command-tool-names.js

@@ -1,5 +1,7 @@
+export { resolveExtensions } from '../extensions/index.js';
 export { getLogger } from '../observability/logger.js';
 export { skillToToolSpec } from '../skills/bridge.js';
+export { SkillLoader } from '../skills/loader.js';
 export { SkillParser } from '../skills/parser.js';
 export { registerAllBuiltins } from '../tools/builtin/index.js';
 export { ToolRegistry } from '../tools/registry.js';

package/dist/core/facades/cli-observability.js

@@ -1,3 +1,3 @@
 export { logIgnoredError } from '../observability/ignored-error.js';
-export { getLogger } from '../observability/logger.js';
+export { getLogger, tryGetLogger } from '../observability/logger.js';
 //# sourceMappingURL=cli-observability.js.map

package/dist/core/facades/cli-run-handler.js

@@ -1,7 +1,9 @@
 export { normalizePermissionMode } from '../config/index.js';
-export { getLogger } from '../observability/logger.js';
+export { getLogger, PlainReporter, SilentReporter } from '../observability/logger.js';
 export { createPluginRegistry, setPluginRegistry, } from '../plugin/registry.js';
 export { createPromptRegistry, setPromptRegistry, } from '../prompts/registry.js';
 export { getExitCode } from '../runtime/exit-codes.js';
-export { buildSessionConversationContext, getDefaultSessionContextBudgetTokens, } from '../session/session-context-builder.js';
+export { resolveExecutionProfile } from '../runtime/execution-profile.js';
+export { getDefaultSessionContextBudgetTokens } from '../session/session-context-builder.js';
+export { buildEffectiveConversationContext } from '../session/summary-sync.js';
 //# sourceMappingURL=cli-run-handler.js.map

package/dist/core/facades/cli-run-persist-session.js

@@ -1,2 +1,3 @@
+export { buildSessionArtifactStateFromLoopResult } from '../session/artifact-state.js';
 export { refreshSessionSummary } from '../session/summary-sync.js';
 //# sourceMappingURL=cli-run-persist-session.js.map

package/dist/core/facades/cli-serve.js

@@ -1,5 +1,3 @@
-export { mkdir } from '../adapters/fs/node-fs.js';
-export { defaultPathAdapter } from '../adapters/path/path-adapter.js';
 export { createSalmonTaskExecutor } from '../backends/salmon-loop/task-executor.js';
 export { GitSnapshotCheckpointService } from '../checkpoint-domain/service.js';
 export { resolveConfig } from '../config/resolve.js';
@@ -11,11 +9,11 @@ export { PluginLoader } from '../plugin/loader.js';
 export { clearPluginRegistry, createPluginRegistry, setPluginRegistry, } from '../plugin/registry.js';
 export { clearPromptRegistry, createPromptRegistry, setPromptRegistry, } from '../prompts/registry.js';
 export { buildA2AAgentCard } from '../protocols/a2a/agent-card.js';
+export { buildA2AFlowSkills } from '../protocols/shared/flow-mode-mapping.js';
 export { createAcpFormalAgent } from '../protocols/acp/formal-agent.js';
 export { startAcpStdioServer } from '../protocols/acp/stdio-server.js';
 export { createAgentServerRuntime } from '../runtime/agent-server-runtime.js';
+export { resolveExecutionProfile } from '../runtime/execution-profile.js';
 export { runSalmonLoop } from '../runtime/loop.js';
 export { getUserAcpSessionStorePath } from '../runtime/paths.js';
-export { getSidecarSocketPath, getSidecarListenOptions, createPipeListenOptions, createTcpListenOptions, } from '../runtime/sidecar-paths.js';
-export { buildSidecarRouteDescriptors, defaultSidecarRouteCatalog, } from '../runtime/sidecar-route-catalog.js';
 //# sourceMappingURL=cli-serve.js.map

package/dist/core/facades/cli-utils-worktree.js

@@ -1,2 +1,2 @@
-export { getLogger } from '../observability/logger.js';
+export { getLogger, tryGetLogger } from '../observability/logger.js';
 //# sourceMappingURL=cli-utils-worktree.js.map

package/dist/core/failure/diagnostics.js

@@ -97,6 +97,15 @@ function buildDependencyGuidance(input) {
 }
 function buildErrorCodeGuidance(input) {
     switch (input.errorCode) {
+        case 'LLM_RATE_LIMITED':
+            return {
+                diagnosticCode: 'LLM_RATE_LIMITED',
+                safeHint: 'LLM is rate limited. Please retry in a moment.',
+                remediationSteps: [
+                    'Retry the command after a short delay.',
+                    'If it persists, reduce concurrency or check provider quota.',
+                ],
+            };
         case 'LLM_HTTP_REQUEST_FAILED':
             return {
                 diagnosticCode: 'LLM_HTTP_REQUEST_FAILED',
@@ -106,6 +115,15 @@ function buildErrorCodeGuidance(input) {
                     'If it persists, check provider status or credentials.',
                 ],
             };
+        case 'LLM_AUTHENTICATION_FAILED':
+            return {
+                diagnosticCode: 'LLM_AUTHENTICATION_FAILED',
+                safeHint: 'LLM provider rejected the request credentials or access.',
+                remediationSteps: [
+                    'Check the provider API key, app id, and model access configuration.',
+                    'If the configuration is correct, confirm the selected model is enabled for this account.',
+                ],
+            };
         case 'LLM_HTTP_ABORTED':
             return {
                 diagnosticCode: 'LLM_HTTP_ABORTED',
@@ -184,7 +202,10 @@ export function buildFailureGuidance(input) {
     const dependencyGuidance = buildDependencyGuidance(input);
     if (dependencyGuidance)
         return dependencyGuidance;
-    const errorCodeGuidance = buildErrorCodeGuidance(input);
+    const errorCodeGuidance = buildErrorCodeGuidance({
+        ...input,
+        errorCode: input.rootCause ?? input.errorCode,
+    });
     if (errorCodeGuidance)
         return errorCodeGuidance;
     if (input.reasonCode === 'PREFLIGHT_NOT_GIT') {
@@ -210,6 +231,37 @@ export function buildFailureGuidance(input) {
             remediationSteps: ['Resolve conflicting local changes, then retry.'],
         };
     }
+    if (input.reasonCode === 'VERIFY_COMMAND_MISSING') {
+        return {
+            diagnosticCode: 'VERIFY_COMMAND_MISSING',
+            safeHint: 'Autopilot changed the workspace but no verification command was configured.',
+            remediationSteps: [
+                'Provide a verify command that exercises the changed behavior.',
+                'Retry after configuring verification for this run.',
+            ],
+        };
+    }
+    if (input.reasonCode === 'TOOL_CORRECTION_REQUIRED') {
+        const correctionHint = (() => {
+            switch (input.errorCode) {
+                case 'INVALID_INPUT':
+                case 'INVALID_TOOL_ARGUMENTS_JSON':
+                case 'MALFORMED_TOOL_CALL':
+                    return {
+                        diagnosticCode: 'TOOL_ARGUMENT_CORRECTION_NEEDED',
+                        safeHint: 'A tool call used invalid arguments. Adjust the tool arguments and retry.',
+                        remediationSteps: [
+                            'Retry with a valid JSON object that matches the tool input schema.',
+                            'Reuse the latest tool error details to correct only the invalid fields.',
+                        ],
+                    };
+                default:
+                    return undefined;
+            }
+        })();
+        if (correctionHint)
+            return correctionHint;
+    }
     return {
         diagnosticCode: input.reasonCode,
         safeHint: input.fallbackReason,

package/dist/core/grizzco/dsl/llm-strategy.js

@@ -1,9 +1,12 @@
+import { resolveLlmCapabilities } from '../../llm/capabilities.js';
 import { Phase } from '../../types/runtime.js';
 import { DecisionEngine, PlanBuilder } from './DecisionEngine.js';
 function defaultMaxRoundsForPhase(phase) {
     // Explore needs more rounds to navigate the codebase
     if (phase === Phase.EXPLORE)
         return 8;
+    if (phase === Phase.AUTOPILOT)
+        return 8;
     if (phase === Phase.RESEARCH)
         return 8;
     if (phase === Phase.PLAN)
@@ -13,7 +16,7 @@ function defaultMaxRoundsForPhase(phase) {
     return 4;
 }
 export function resolveLlmToolCallingPolicy(phase, llm) {
-    const caps = llm.getCapabilities?.();
+    const caps = resolveLlmCapabilities(llm, phase);
     const maxRounds = defaultMaxRoundsForPhase(phase);
     // Grizzco DSL engine is transaction-shaped; for LLM policies we inject a minimal context and keep all
     // decisions inside ctx.data to avoid coupling to file/operation semantics.