salmon-loop 0.3.2 → 0.5.0

package/dist/core/grizzco/engine/transaction/transaction-runner.js

@@ -3,7 +3,7 @@ import { mapErrorForAudit } from '../../../observability/error-mapping.js';
 import { ReflectionEngine } from '../../../reflection/engine.js';
 import { resolveExecutionProfile } from '../../../runtime/execution-profile.js';
 import { executeFlowAttempt } from '../../flows/flow-dispatch.js';
-import { resolveAttemptFailure } from './attempt-failure.js';
+import { extractErrorCode, resolveAttemptFailure } from './attempt-failure.js';
 import { buildAuthorizationSummary } from './authorization-summary.js';
 import { mapRetryExhaustedReport, mapSuccessReport, mapTerminalFailureReport, } from './report-mapper.js';
 import { evaluateRetryPolicy } from './retry-policy.js';
@@ -128,7 +128,6 @@ export class FlowTransactionRunner {
     lastRecentReadArtifacts;
     lastToolResultPreviewArtifacts;
     lastReplacementState;
-    pendingAutopilotVerification;
     constructor(params) {
         this.params = params;
         this.lastVerifyArtifact = params.options.artifactHints?.verifyArtifact;
@@ -183,7 +182,6 @@ export class FlowTransactionRunner {
                         : undefined,
                 },
                 replacementState: this.lastReplacementState,
-                pendingVerification: this.pendingAutopilotVerification,
                 lastError: this.currentLastError,
                 applyBackRuntime: {
                     activeRepoPath: this.params.env.activeRepoPath,
@@ -212,20 +210,9 @@ export class FlowTransactionRunner {
                 flowReport: result,
                 context: shrinkCtx,
                 flowMode: this.params.flowMode,
+                verifyPolicy: this.params.options.verifyPolicy,
             });
             lastAttemptFailure = attemptFailure;
-            if (this.params.flowMode === 'autopilot') {
-                if (attemptFailure?.reasonCode === 'VERIFY_FAILED') {
-                    this.pendingAutopilotVerification = {
-                        changedFiles: terminalCtx && 'changedFiles' in terminalCtx
-                            ? (terminalCtx.changedFiles ?? undefined)
-                            : undefined,
-                    };
-                }
-                else if (!attemptFailure) {
-                    this.pendingAutopilotVerification = undefined;
-                }
-            }
             const entry = {
                 attempt,
                 plan: shrinkCtx?.plan ?? null,
@@ -245,27 +232,24 @@ export class FlowTransactionRunner {
                         ? 'SHRINK'
                         : 'APPLY_BACK';
                 recordAuditEvent('loop.attempt.success', { attempt, flowMode: this.params.flowMode }, { phase: successPhase, severity: 'low', scope: 'session' });
-                // Reflection Mechanism: trigger when multiple attempts were needed
-                if (attempt > 1 && this.params.options.llm) {
-                    const reflectionEngine = new ReflectionEngine(this.params.options.llm);
-                    const reflectionInput = {
+                this.emitReflection({
+                    success: true,
+                    attempt,
+                    input: {
                         instruction: this.params.options.instruction,
                         history: this.historyEntries,
                         success: true,
                         metadata: shrinkCtx?.context?.projectMetadata,
                         finalPlan: shrinkCtx?.plan,
                         finalPatch: shrinkCtx?.diff,
-                    };
-                    reflectionEngine
-                        .reflect(reflectionInput, this.params.options.repoPath)
-                        .catch((e) => recordAuditEvent('reflection.error', { error: String(e) }, { severity: 'medium' }));
-                }
+                    },
+                });
                 return mapSuccessReport({
                     attempt,
                     flowReport: result,
                     history: this.historyEntries,
                     authorizationSummary: this.authorizationSummary,
-                    lastErrorCode: this.extractErrorCode(result.error),
+                    lastErrorCode: extractErrorCode(result.error),
                     lastContext: terminalCtx,
                     lastVerifyArtifact: this.lastVerifyArtifact,
                     lastSubAgentPatchArtifacts: this.lastSubAgentPatchArtifacts,
@@ -317,12 +301,20 @@ export class FlowTransactionRunner {
                 if (retryDecision.retryExhausted) {
                     break;
                 }
+                this.emitReflection({
+                    success: false,
+                    input: {
+                        instruction: this.params.options.instruction,
+                        history: this.historyEntries,
+                        success: false,
+                    },
+                });
                 return mapTerminalFailureReport({
                     attempt,
                     flowReport: result,
                     history: this.historyEntries,
                     authorizationSummary: this.authorizationSummary,
-                    lastErrorCode: attemptFailure.errorCode ?? this.extractErrorCode(result.error),
+                    lastErrorCode: attemptFailure.errorCode ?? extractErrorCode(result.error),
                     lastContext: terminalCtx,
                     lastVerifyArtifact: this.lastVerifyArtifact,
                     lastSubAgentPatchArtifacts: this.lastSubAgentPatchArtifacts,
@@ -333,7 +325,7 @@ export class FlowTransactionRunner {
                 });
             }
             this.currentContext = shrinkCtx?.context;
-            this.currentLastError = attemptFailure.reason;
+            this.currentLastError = shrinkCtx?.lastError ?? attemptFailure.reason;
             this.params.emit({
                 type: 'retry',
                 fromAttempt: attempt,
@@ -346,13 +338,21 @@ export class FlowTransactionRunner {
         if (!lastReport) {
             throw new Error('SalmonLoop execution terminated without a FlowReport');
         }
+        this.emitReflection({
+            success: false,
+            input: {
+                instruction: this.params.options.instruction,
+                history: this.historyEntries,
+                success: false,
+            },
+        });
         return mapRetryExhaustedReport({
             attempts: retries,
             flowReport: lastReport,
             history: this.historyEntries,
             authorizationSummary: this.authorizationSummary,
             failure: lastAttemptFailure,
-            lastErrorCode: this.extractErrorCode(lastReport.error),
+            lastErrorCode: extractErrorCode(lastReport.error),
             lastContext: this.lastContext,
             lastVerifyArtifact: this.lastVerifyArtifact,
             lastSubAgentPatchArtifacts: this.lastSubAgentPatchArtifacts,
@@ -361,13 +361,19 @@ export class FlowTransactionRunner {
             lastToolResultPreviewArtifacts: this.lastToolResultPreviewArtifacts,
         });
     }
-    extractErrorCode(error) {
-        if (typeof error === 'object' && error !== null) {
-            return (error.llmCode ??
-                error.code ??
-                error.name);
+    emitReflection(params) {
+        if (!this.params.options.llm)
+            return;
+        const engine = new ReflectionEngine(this.params.options.llm);
+        const { repoPath } = this.params.options;
+        const fallback = (e) => recordAuditEvent('reflection.error', { error: String(e) }, { severity: 'medium' });
+        if (params.success) {
+            const method = (params.attempt ?? 1) > 1 ? 'reflect' : 'reflectOnSuccess';
+            engine[method](params.input, repoPath).catch(fallback);
+        }
+        else {
+            engine.reflectOnFailure(params.input, repoPath).catch(fallback);
         }
-        return undefined;
     }
 }
 //# sourceMappingURL=transaction-runner.js.map

package/dist/core/grizzco/execution/RejectionManager.js

@@ -1,5 +1,6 @@
 import * as path from 'path';
 import * as fs from '../../adapters/fs/node-fs.js';
+import { getLogger } from '../../observability/logger.js';
 /**
  * RejectionManager
  * Handles creation and management of .rej files for failed merges.
@@ -46,13 +47,14 @@ export class RejectionManager {
                         ...header,
                     });
                 }
-                catch {
-                    // Ignore malformed files
+                catch (error) {
+                    getLogger().debug(`[RejectionManager] Malformed rejection file ${file}: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
             return rejections;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[RejectionManager] Failed to read rejection directory: ${error instanceof Error ? error.message : String(error)}`);
             return [];
         }
     }
@@ -63,8 +65,8 @@ export class RejectionManager {
         try {
             await fs.rm(this.rejectDir, { recursive: true, force: true });
         }
-        catch {
-            // Ignore
+        catch (error) {
+            getLogger().warn(`[RejectionManager] Failed to clear rejection directory: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 }

package/dist/core/grizzco/runtime/apply-back-runtime.js

@@ -2,6 +2,8 @@ import { text } from '../../../locales/index.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { writeDebugArtifact } from '../../observability/debug-artifacts.js';
 import { buildErrorEnvelope, toSafeErrorSummary } from '../../observability/error-envelope.js';
+import { getLogger } from '../../observability/logger.js';
+import { isRecord } from '../../utils/serialize.js';
 import { collectSidecarPaths } from './apply-back-utils.js';
 export async function runApplyBackPhase(params) {
     const { checkpointRef, initialSnapshotHash, options, synchronizer, activeRepoPath, shadowTaskId, attempt, emit, } = params;
@@ -89,13 +91,14 @@ export async function runApplyBackPhase(params) {
                     `safeTelemetry=${JSON.stringify(toSafeTelemetry(applyBackTelemetry), null, 2)}`,
                     '',
                     `errorType=${error instanceof Error ? error.name : typeof error}`,
-                    `errorCode=${error?.code ?? error?.llmCode ?? ''}`,
+                    `errorCode=${isRecord(error) ? (error.code ?? error.llmCode ?? '') : ''}`,
                     `errorMessage=${error instanceof Error ? error.message : String(error)}`,
                 ].join('\n'),
             });
         }
-        catch {
+        catch (artifactError) {
             // Best-effort: do not mask the primary failure if artifact writing fails.
+            getLogger().debug(`[ApplyBackRuntime] Failed to write debug artifact: ${artifactError instanceof Error ? artifactError.message : String(artifactError)}`);
         }
         const envelope = buildErrorEnvelope({
             domain: 'applyBack',

package/dist/core/grizzco/services/implementations/default/GitConfigService.js

@@ -10,7 +10,8 @@ export class GitConfigService {
                 try {
                     return await git.exec(['config', '--get', key], { allowError: true });
                 }
-                catch {
+                catch (error) {
+                    getLogger().debug(`[GitConfigService] git config --get failed for key "${key}": ${error instanceof Error ? error.message : String(error)}`);
                     return null;
                 }
             };

package/dist/core/grizzco/services/registry.js

@@ -26,5 +26,23 @@ export const registry = {
     has(id) {
         return services.has(id);
     },
+    /**
+     * Unregister a data service by its identifier
+     */
+    unregister(id) {
+        return services.delete(id);
+    },
+    /**
+     * Clear all registered services (for testing or shutdown)
+     */
+    clear() {
+        services.clear();
+    },
+    /**
+     * List all registered service IDs
+     */
+    list() {
+        return Array.from(services.keys());
+    },
 };
 //# sourceMappingURL=registry.js.map

package/dist/core/grizzco/steps/audit.js

@@ -8,6 +8,8 @@ import { mapErrorForDisplay } from '../../observability/error-mapping.js';
 import { getLogger } from '../../observability/logger.js';
 import { getAuditDir } from '../../runtime/paths.js';
 import { SalmonError } from '../../types/errors.js';
+import { errorMessage } from '../../utils/error.js';
+import { isRecord } from '../../utils/serialize.js';
 function replaceRedactedTokens(value) {
     if (value === null || value === undefined)
         return value;
@@ -43,7 +45,7 @@ export async function saveAudit(report, _options) {
             });
         }
         catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
+            const msg = errorMessage(error);
             getLogger().warn(`[Audit] Failed to externalize verify output: ${msg}`);
             recordAuditEvent('audit.blob.externalize.failed', { target: 'verifyResult.output', error: msg.slice(0, 500) }, { source: 'saveAudit', severity: 'low', scope: 'session', phase: 'AUDIT' });
         }
@@ -55,7 +57,7 @@ export async function saveAudit(report, _options) {
             });
         }
         catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
+            const msg = errorMessage(error);
             getLogger().warn(`[Audit] Failed to externalize tool audit summaries: ${msg}`);
             recordAuditEvent('audit.blob.externalize.failed', { target: 'toolAuditLogs.*', error: msg.slice(0, 500) }, { source: 'saveAudit', severity: 'low', scope: 'session', phase: 'AUDIT' });
         }
@@ -70,7 +72,12 @@ export async function saveAudit(report, _options) {
                     : errorInfo?.code || errorInfo?.llmCode,
             }
             : report.error
-                ? { name: 'UnknownError', message: String(report.error), stack: undefined }
+                ? {
+                    name: 'UnknownError',
+                    message: String(report.error),
+                    stack: undefined,
+                    code: undefined,
+                }
                 : undefined;
         const mappedErrorMeta = replaceRedactedTokens(errorMeta);
         const errorDisplay = mapErrorForDisplay({
@@ -130,7 +137,7 @@ export async function saveAudit(report, _options) {
         return `${auditDir}/${filename}`;
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = errorMessage(error);
         getLogger().error(`[Audit] Failed to save audit log: ${msg}`);
         return undefined;
     }
@@ -162,7 +169,7 @@ async function writeBlobBestEffort(args) {
         return { path: path.join('blobs', blobName), sha256, chars: content.length };
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = errorMessage(error);
         getLogger().warn(`[Audit] Failed to write blob ${blobName}: ${msg}`);
         recordAuditEvent('audit.blob.write.failed', {
             target: auditTarget,
@@ -179,7 +186,7 @@ async function externalizeVerifyOutput(args) {
     if (!sanitizedContext)
         return;
     const verifyResult = sanitizedContext.verifyResult;
-    if (!verifyResult || typeof verifyResult !== 'object')
+    if (!isRecord(verifyResult))
         return;
     const output = verifyResult.output;
     if (typeof output !== 'string')
@@ -292,15 +299,18 @@ function sanitizeContext(ctx) {
     if (typed.applyBackResult)
         safe.applyBackResult = typed.applyBackResult;
     if (typed.toolCallingAudit && Array.isArray(typed.toolCallingAudit)) {
+        const KEYS_TO_STRIP = new Set([
+            'rawArgsPreview',
+            'parsedArgsPreview',
+            'toolResultErrorMessage',
+        ]);
         safe.toolCallingAudit = typed.toolCallingAudit.map((entry) => {
             if (!entry || typeof entry !== 'object')
                 return entry;
-            const typedEntry = entry;
-            const keepArgsPreview = typedEntry.toolResultErrorCode === 'INVALID_INPUT';
+            const keepArgsPreview = entry.toolResultErrorCode === 'INVALID_INPUT';
             if (keepArgsPreview)
                 return entry;
-            const { rawArgsPreview: _rawArgsPreview, parsedArgsPreview: _parsedArgsPreview, toolResultErrorMessage: _toolResultErrorMessage, ...rest } = typedEntry;
-            return rest;
+            return Object.fromEntries(Object.entries(entry).filter(([k]) => !KEYS_TO_STRIP.has(k)));
         });
     }
     if (typed.toolAuditLogger?.getLogs) {

package/dist/core/grizzco/steps/autopilot.js

@@ -6,6 +6,7 @@ import { GitAdapter } from '../../adapters/git/git-adapter.js';
 import { LIMITS } from '../../config/limits.js';
 import { supportsLlmStreaming } from '../../llm/capabilities.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
+import { getLogger } from '../../observability/logger.js';
 import { getAutopilotSystemPrompt } from '../../prompts/runtime.js';
 import { SessionReplacementPreviewProvider } from '../../session/replacement-preview-provider.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
@@ -286,13 +287,11 @@ function isRuntimeGeneratedPath(path) {
     return false;
 }
 function lastFailedToolAuditEntry(entries) {
-    if (!Array.isArray(entries))
+    if (!Array.isArray(entries) || entries.length === 0)
         return undefined;
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const entry = entries[index];
-        if (entry?.toolResultStatus && entry.toolResultStatus !== 'ok') {
-            return entry;
-        }
+    const last = entries[entries.length - 1];
+    if (last?.toolResultStatus && last.toolResultStatus !== 'ok') {
+        return last;
     }
     return undefined;
 }
@@ -370,12 +369,16 @@ export async function runAutopilot(ctx) {
         try {
             workspaceFingerprintBefore = await captureWorkspaceFingerprintForContext(ctx);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[Autopilot] Workspace fingerprint capture failed (before): ${error instanceof Error ? error.message : String(error)}`);
             samplingFailedClosed = true;
         }
     }
-    const assistant = supportsTools
-        ? await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(shared.baseMessages, {
+    let assistant = null;
+    let content = '';
+    const messages = shared.baseMessages;
+    assistant = supportsTools
+        ? await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(messages, {
             phase: AUTOPILOT_TOOL_PHASE,
             providerHints: shared.envelope.providerHints,
             temperature: 0.2,
@@ -400,7 +403,7 @@ export async function runAutopilot(ctx) {
             },
             emit: (event) => ctx.emit({ ...event, timestamp: event.timestamp ?? new Date() }),
         })
-        : await llmClient.chat(shared.baseMessages, {
+        : await llmClient.chat(messages, {
             phase: 'AUTOPILOT',
             providerHints: shared.envelope.providerHints,
             temperature: 0.2,
@@ -408,7 +411,7 @@ export async function runAutopilot(ctx) {
             tools: [],
             toolChoice: 'none',
         });
-    const content = String(assistant?.content ?? '').trim();
+    content = String(assistant?.content ?? '').trim();
     if (!supportsTools) {
         emitLlmOutput({
             emit: ctx.emit,
@@ -435,28 +438,18 @@ export async function runAutopilot(ctx) {
                         workspaceFingerprintBefore.head !== workspaceFingerprintAfter.head ||
                         workspaceFingerprintBefore.index !== workspaceFingerprintAfter.index;
             }
-            catch {
+            catch (error) {
+                getLogger().debug(`[Autopilot] Workspace fingerprint capture failed (after): ${error instanceof Error ? error.message : String(error)}`);
                 mutated = true;
             }
         }
     }
-    const pendingChangedFiles = ctx.pendingVerification?.changedFiles && ctx.pendingVerification.changedFiles.length > 0
-        ? ctx.pendingVerification.changedFiles
-        : undefined;
-    const effectiveChangedFiles = changedFiles && changedFiles.length > 0
-        ? changedFiles
-        : pendingChangedFiles && pendingChangedFiles.length > 0
-            ? pendingChangedFiles
-            : undefined;
-    const effectiveMutated = mutated || Boolean(ctx.pendingVerification);
+    const effectiveChangedFiles = changedFiles && changedFiles.length > 0 ? changedFiles : undefined;
     return {
         ...ctx,
-        mutated: effectiveMutated,
+        mutated,
         changedFiles: effectiveChangedFiles,
-        pendingVerification: effectiveMutated
-            ? { changedFiles: effectiveChangedFiles }
-            : ctx.pendingVerification,
-        completion: resolveAutopilotCompletion({ content, mutated: effectiveMutated, localAudit }),
+        completion: resolveAutopilotCompletion({ content, mutated, localAudit }),
         toolCallingAudit: mergedAudit,
         report: {
             kind: 'answer',
@@ -473,13 +466,10 @@ export async function runAutopilotVerifyGate(ctx) {
         };
     }
     if (!ctx.options.verify) {
+        // Autopilot is LLM-driven: the agent verifies on its own via shell.exec.
+        // Skip the gate instead of failing — the agent's tool calls are the verification.
         return {
             ...ctx,
-            completion: {
-                status: 'verification_missing',
-                reason: 'Autopilot changed the workspace but no verification command was configured.',
-                errorCode: 'VERIFY_COMMAND_MISSING',
-            },
             verifyResult: undefined,
         };
     }
@@ -491,7 +481,6 @@ export async function runAutopilotVerifyGate(ctx) {
     const nextCtx = {
         ...ctx,
         verifyResult,
-        pendingVerification: verifyResult.ok ? undefined : ctx.pendingVerification,
     };
     return verifyArtifact ? { ...nextCtx, verifyArtifact } : nextCtx;
 }

package/dist/core/grizzco/steps/display-report.js

@@ -1,18 +1,11 @@
 import { text } from '../../../locales/index.js';
 import { SalmonError } from '../../types/errors.js';
+import { safeStringify } from '../../utils/serialize.js';
 export class ReportContextMissingError extends SalmonError {
     constructor(message) {
         super(message, 'REPORT_CONTEXT_MISSING');
     }
 }
-function safeStringify(value) {
-    try {
-        return JSON.stringify(value, null, 2);
-    }
-    catch {
-        return String(value);
-    }
-}
 function removeLeadingSpaces(content) {
     const lines = content.split('\n');
     const minIndent = lines
@@ -40,7 +33,7 @@ function normalizeSuggestions(input) {
             }
             if (isReviewSuggestion(item)) {
                 const type = typeof item.type === 'string' ? item.type : 'note';
-                const content = typeof item.content === 'string' ? item.content : safeStringify(item);
+                const content = typeof item.content === 'string' ? item.content : safeStringify(item, { indent: 2 });
                 return { type, content };
             }
             return { type: 'note', content: String(item) };
@@ -51,10 +44,10 @@ function normalizeSuggestions(input) {
     }
     if (isReviewSuggestion(input)) {
         const type = typeof input.type === 'string' ? input.type : 'note';
-        const content = typeof input.content === 'string' ? input.content : safeStringify(input);
+        const content = typeof input.content === 'string' ? input.content : safeStringify(input, { indent: 2 });
         return [{ type, content }];
     }
-    return [{ type: 'note', content: safeStringify(input) }];
+    return [{ type: 'note', content: safeStringify(input, { indent: 2 }) }];
 }
 export async function displayReport(ctx) {
     if (!ctx.report || !ctx.report.kind) {

package/dist/core/grizzco/steps/explore.js

@@ -2,12 +2,14 @@ import path from 'path';
 import { text } from '../../../locales/index.js';
 import { supportsLlmStreaming } from '../../llm/capabilities.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { getLogger } from '../../observability/logger.js';
 import { getExplorePrompt, getExploreSystemPrompt } from '../../prompts/runtime.js';
 import { SessionReplacementPreviewProvider } from '../../session/replacement-preview-provider.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
 import { SalmonError } from '../../types/errors.js';
 import { Phase } from '../../types/runtime.js';
 import { ensureInSandbox, isSafeRelativePath, normalizePath } from '../../utils/path.js';
+import { isRecord } from '../../utils/serialize.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
 import { ContextValidator } from '../validation/ContextValidator.js';
 import { buildPhaseRequestEnvelope } from './request-assembly.js';
@@ -103,7 +105,11 @@ export const exploreCodebase = async (ctx) => {
                     // Intercept tools with READ intent
                     if (intent === 'READ' && result.status === 'ok') {
                         const output = result.output;
-                        const content = typeof output === 'string' ? output : output?.content;
+                        const content = typeof output === 'string'
+                            ? output
+                            : isRecord(output) && typeof output.content === 'string'
+                                ? output.content
+                                : undefined;
                         if (typeof content === 'string') {
                             try {
                                 // Attempt to parse arguments to get the file path
@@ -114,8 +120,9 @@ export const exploreCodebase = async (ctx) => {
                                     capturedFiles.set(filePath, content);
                                 }
                             }
-                            catch {
+                            catch (error) {
                                 // Ignore parsing errors, just don't capture
+                                getLogger().debug(`[Explore] Failed to parse tool arguments for file capture: ${error instanceof Error ? error.message : String(error)}`);
                             }
                         }
                     }
@@ -191,15 +198,18 @@ export const exploreCodebase = async (ctx) => {
                     capturedFiles.set(rel, content);
                 }
             }
-            catch {
+            catch (error) {
                 // Best-effort; failure here should not abort exploration.
+                getLogger().debug(`[Explore] Failed to read inferred file "${rel}": ${error instanceof Error ? error.message : String(error)}`);
             }
         }
     }
     // Validation: Check for exploration consistency using ContextValidator on LOCAL audit
     const validation = ContextValidator.validateExploration(localAudit, capturedFiles.size);
     if (!validation.isValid) {
-        const msg = text.grizzco.validation[validation.errorCode] || validation.errorCode;
+        const validationMessages = text.grizzco.validation;
+        const raw = validation.errorCode ? validationMessages[validation.errorCode] : undefined;
+        const msg = typeof raw === 'string' ? raw : (validation.errorCode ?? 'unknown');
         ctx.emit({
             type: 'log',
             level: 'error',

package/dist/core/grizzco/steps/generateReview.js

@@ -1,5 +1,6 @@
 import { text } from '../../../locales/index.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
+import { getLogger } from '../../observability/logger.js';
 import { getReviewPrompt } from '../../prompts/runtime.js';
 function normalizeReviewSuggestions(value) {
     if (value == null)
@@ -23,7 +24,8 @@ function parseReviewResponse(content) {
     try {
         return normalizeReviewSuggestions(JSON.parse(content));
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[GenerateReview] Failed to parse review response as JSON: ${error instanceof Error ? error.message : String(error)}`);
         return normalizeReviewSuggestions(content);
     }
 }

package/dist/core/grizzco/steps/patch/prompt-input.js

@@ -5,9 +5,12 @@ import { Phase } from '../../../types/runtime.js';
 import { buildPhaseRequestEnvelope } from '../request-assembly.js';
 export async function buildPatchPromptInput(args) {
     const planStr = JSON.stringify(args.plan, null, 2);
-    const systemPrompt = await getPatchSystemPrompt(args.promptVisibleTools, {
+    const baseSystemPrompt = await getPatchSystemPrompt(args.promptVisibleTools, {
         plan: args.planRuntime,
     });
+    const systemPrompt = args.subAgentSystemPrompt
+        ? [baseSystemPrompt, args.subAgentSystemPrompt]
+        : baseSystemPrompt;
     const requestEnvelope = await buildPhaseRequestEnvelope({
         phase: args.phase ?? Phase.PATCH,
         defaultNamespace: 'patch',

package/dist/core/grizzco/steps/patch.js

@@ -95,6 +95,7 @@ export const generatePatch = async (ctx) => {
         artifactHints: ctx.artifactHints,
         replacementState: ctx.replacementState,
         toolCallingAudit: ctx.toolCallingAudit,
+        subAgentSystemPrompt: ctx.options.subAgentSystemPrompt,
     });
     const { cacheSurface, envelope, baseMessages } = patchPromptInput;
     const supportsStreaming = supportsLlmStreaming(ctx.options.llm, Phase.PATCH);