salmon-loop 0.2.13 → 0.2.16

package/dist/core/grizzco/steps/patch/diff-salvage.js

@@ -0,0 +1,46 @@
+import { extractAndValidatePatch } from './diff-normalization.js';
+const SALVAGEABLE_PATCH_CODES = new Set(['LLM_PATCH_NOT_UNIFIED_DIFF', 'LLM_PATCH_EMPTY']);
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+export function isSalvageablePatchError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const llmCode = error.llmCode;
+    return typeof llmCode === 'string' && SALVAGEABLE_PATCH_CODES.has(llmCode);
+}
+export async function salvagePatchDiff(args) {
+    if (!isSalvageablePatchError(args.initialError))
+        return null;
+    args.onAttempt?.({
+        reason: errorMessage(args.initialError),
+        badContentLength: args.rawContent.length,
+    });
+    const repaired = await args.repair({ badContent: args.rawContent });
+    const repairedContent = repaired.content || '';
+    try {
+        const validated = extractAndValidatePatch({
+            rawContent: repairedContent,
+            plannedFiles: args.plannedFiles,
+        });
+        args.onResult?.({
+            ok: true,
+            contentLength: repairedContent.length,
+        });
+        return {
+            ...validated,
+            rawContent: repairedContent,
+        };
+    }
+    catch (salvageError) {
+        args.onResult?.({
+            ok: false,
+            contentLength: repairedContent.length,
+            error: errorMessage(salvageError).slice(0, 400),
+        });
+        throw args.initialError;
+    }
+}
+//# sourceMappingURL=diff-salvage.js.map

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

@@ -0,0 +1,42 @@
+import { LIMITS } from '../../../config/limits.js';
+import { getPatchPrompt, getPatchSystemPrompt } from '../../../prompts/runtime.js';
+import { SessionReplacementPreviewProvider } from '../../../session/replacement-preview-provider.js';
+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, {
+        plan: args.planRuntime,
+    });
+    const requestEnvelope = await buildPhaseRequestEnvelope({
+        phase: args.phase ?? Phase.PATCH,
+        defaultNamespace: 'patch',
+        context: args.context,
+        contextResult: args.contextResult,
+        cacheSharing: args.cacheSharing,
+        onCacheMismatch: args.onCacheMismatch,
+        systemPrompt,
+        buildUserPrompt: (contextPrompt) => getPatchPrompt(planStr, contextPrompt, LIMITS.maxFilesChanged, LIMITS.maxDiffLines, args.lastError),
+        conversationContext: args.conversationContext,
+        artifactHints: args.artifactHints,
+        previewProvider: new SessionReplacementPreviewProvider(args.replacementState),
+        toolCallingAudit: args.toolCallingAudit,
+        toolVisibility: args.toolVisibility,
+        extraAttachments: [
+            {
+                key: 'plan-json',
+                kind: 'plan',
+                label: 'Plan JSON',
+                content: planStr,
+            },
+        ],
+    });
+    return {
+        planStr,
+        systemPrompt,
+        envelope: requestEnvelope.envelope,
+        baseMessages: requestEnvelope.baseMessages,
+        cacheSurface: requestEnvelope.cacheSurface,
+    };
+}
+//# sourceMappingURL=prompt-input.js.map

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

@@ -1,98 +1,116 @@
-import { text } from '../../../locales/index.js';
-import { GitAdapter } from '../../adapters/git/git-adapter.js';
-import { LIMITS } from '../../config/limits.js';
+import { supportsLlmStreaming } from '../../llm/capabilities.js';
 import { repairToUnifiedDiff } from '../../llm/contracts/repair.js';
-import { wrapPatchEmpty, wrapPatchInvalid, wrapPatchNotUnifiedDiff } from '../../llm/errors.js';
-import { composeChatMessages } from '../../llm/message-composition.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
-import { extractUnifiedDiffFromLLMContent, formatContextForPrompt } from '../../llm/utils.js';
-import { normalizeDiff, validateDiff } from '../../patch/diff.js';
-import { getPatchPrompt, getPatchSystemPrompt } from '../../prompts/runtime.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
-import { DiffValidationError } from '../../types/errors.js';
+import { resolveVisibleToolSpecs } from '../../tools/tool-visibility.js';
 import { Phase } from '../../types/runtime.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
-async function checkPatchApplies(args) {
-    const git = new GitAdapter(args.repoRoot);
-    return git.execMeta(['apply', '--check', '--recount', '--ignore-whitespace', '--whitespace=nowarn', '-'], {
-        input: Buffer.from(args.diff, 'utf8'),
-        timeoutMs: 15000,
-        limits: { maxStdoutBytes: 0, maxStderrChars: 4000 },
+import { checkPatchApplies } from './patch/apply-check.js';
+import { extractAndValidatePatch } from './patch/diff-normalization.js';
+import { salvagePatchDiff } from './patch/diff-salvage.js';
+import { buildPatchPromptInput } from './patch/prompt-input.js';
+import { buildPhaseToolRuntimeContext, buildToolVisibilityRuntime } from './tool-runtime.js';
+const recordPatchSalvageAttempt = (args) => {
+    recordAuditEvent('patch.salvage.attempt', {
+        reason: args.reason,
+        badContentLength: args.badContentLength,
+        toolsDisabled: true,
+    }, { source: 'patch', severity: 'low', scope: 'session', phase: 'PATCH' });
+};
+const recordPatchSalvageResult = (args) => {
+    recordAuditEvent('patch.salvage.result', {
+        ok: args.ok,
+        contentLength: args.contentLength,
+        error: args.error,
+    }, {
+        source: 'patch',
+        severity: args.ok ? 'low' : 'medium',
+        scope: 'session',
+        phase: 'PATCH',
     });
-}
+};
 export const generatePatch = async (ctx) => {
     const toolstack = ctx.toolstack;
     const toolPolicy = resolveLlmToolCallingPolicy(Phase.PATCH, ctx.options.llm);
     // Backwards-compatible fallback for non-tool-capable LLMs.
     if (!toolstack || !toolPolicy.enabled) {
-        const patch = await ctx.options.llm.createPatch(ctx.context, ctx.plan, ctx.lastError, ctx.options.signal);
+        const legacyPatch = await ctx.options.llm.createPatch(ctx.context, ctx.plan, ctx.lastError, ctx.options.signal);
         emitLlmOutput({
             emit: ctx.emit,
             policy: ctx.options.llmOutput,
             kind: 'patch',
             step: 'PATCH',
-            content: patch,
+            content: legacyPatch,
+        });
+        const validated = extractAndValidatePatch({
+            rawContent: legacyPatch,
+            plannedFiles: ctx.plan.files,
         });
-        const normalizedPatch = normalizeDiff(patch);
-        let diffMeta;
-        try {
-            diffMeta = validateDiff(normalizedPatch);
-        }
-        catch (e) {
-            if (e instanceof DiffValidationError) {
-                if (e.message === text.diff.notUnifiedFormat)
-                    throw wrapPatchNotUnifiedDiff();
-                if (e.message.startsWith(text.llm.patchEmpty()))
-                    throw wrapPatchEmpty();
-                throw wrapPatchInvalid(e.message);
-            }
-            throw e;
-        }
         ctx.emit({
             type: 'log',
             level: 'debug',
-            message: `Patch generated: ${diffMeta.changedFiles.length} files changed`,
+            message: `Patch generated: ${validated.diffMeta.changedFiles.length} files changed`,
             timestamp: new Date(),
         });
         return {
             ...ctx,
-            diff: normalizedPatch,
-            diffMeta,
-            changedFiles: diffMeta.changedFiles,
+            diff: validated.normalizedPatch,
+            diffMeta: validated.diffMeta,
+            changedFiles: validated.diffMeta.changedFiles,
         };
     }
-    const planStr = JSON.stringify(ctx.plan, null, 2);
-    const prompt = await getPatchPrompt(planStr, formatContextForPrompt(ctx.context), LIMITS.maxFilesChanged, LIMITS.maxDiffLines, ctx.lastError);
-    const systemPrompt = await getPatchSystemPrompt(toolstack?.registry, { plan: ctx.planRuntime });
-    const baseMessages = composeChatMessages({
-        system: systemPrompt,
-        user: prompt,
+    const toolVisibility = buildToolVisibilityRuntime(ctx);
+    const promptVisibleTools = resolveVisibleToolSpecs({
+        phase: Phase.PATCH,
+        toolstack,
+        worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+        flowMode: ctx.mode,
+        runtime: toolVisibility,
+    });
+    const patchPromptInput = await buildPatchPromptInput({
+        context: ctx.context,
+        contextResult: ctx.contextResult,
+        plan: ctx.plan,
+        planRuntime: ctx.planRuntime,
+        lastError: ctx.lastError,
+        promptVisibleTools,
+        toolVisibility: {
+            toolstack,
+            runtime: toolVisibility,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            flowMode: ctx.mode,
+        },
+        phase: Phase.PATCH,
+        cacheSharing: ctx.cacheSharing,
+        onCacheMismatch: (mismatch) => {
+            recordAuditEvent('request.cache_sharing_hash_mismatch', mismatch, {
+                source: 'llm',
+                severity: 'low',
+                scope: 'session',
+                phase: Phase.PATCH,
+            });
+        },
         conversationContext: ctx.options.conversationContext,
+        artifactHints: ctx.artifactHints,
+        replacementState: ctx.replacementState,
+        toolCallingAudit: ctx.toolCallingAudit,
     });
-    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const { cacheSurface, envelope, baseMessages } = patchPromptInput;
+    const supportsStreaming = supportsLlmStreaming(ctx.options.llm, Phase.PATCH);
     const llmOutput = {
         policy: ctx.options.llmOutput,
         kind: 'patch',
         step: 'PATCH',
     };
     const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, {
+        providerHints: envelope.providerHints,
         signal: ctx.options.signal,
     }, {
         phase: Phase.PATCH,
         llm: ctx.options.llm,
-        runtime: {
-            repoRoot: ctx.workspace.workPath,
-            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
-            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
-            attemptId: ctx.attempt ?? 1,
-            dryRun: Boolean(ctx.options?.dryRun),
-            llm: ctx.options.llm,
-            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
-            userInputProvider: ctx.options.userInputProvider,
-            agentKind: ctx.options.agentKind ?? 'primary',
-            languagePlugins: ctx.options.languagePlugins,
-            subAgentController: ctx.options.subAgentController,
-        },
+        runtime: buildPhaseToolRuntimeContext(ctx, Phase.PATCH, cacheSurface),
+        toolVisibility,
         toolstack,
         eventPayload: ctx.options.eventPayload,
         toolCallingAudit: {
@@ -107,114 +125,55 @@ export const generatePatch = async (ctx) => {
         emit: (event) => ctx.emit({ ...event, timestamp: event.timestamp ?? new Date() }),
     });
     let rawContent = response.content || '';
-    let patch = '';
-    let normalizedPatch = '';
-    let diffMeta;
-    const validateWithLlmErrors = (diffText) => {
-        const normalized = normalizeDiff(diffText);
-        try {
-            return validateDiff(normalized);
-        }
-        catch (e) {
-            if (e instanceof DiffValidationError) {
-                if (e.message === text.diff.notUnifiedFormat)
-                    throw wrapPatchNotUnifiedDiff();
-                if (e.message.startsWith(text.llm.patchEmpty()))
-                    throw wrapPatchEmpty();
-                throw wrapPatchInvalid(e.message);
-            }
-            throw e;
-        }
-    };
+    let parsedPatch;
     try {
-        patch = extractUnifiedDiffFromLLMContent(rawContent);
-        normalizedPatch = normalizeDiff(patch);
-        diffMeta = validateWithLlmErrors(patch);
+        parsedPatch = extractAndValidatePatch({
+            rawContent,
+            plannedFiles: ctx.plan.files,
+        });
     }
     catch (e) {
-        const asLlmError = e;
-        if (asLlmError instanceof Error &&
-            'llmCode' in asLlmError &&
-            asLlmError.llmCode &&
-            ['LLM_PATCH_EMPTY', 'LLM_PATCH_NOT_UNIFIED_DIFF'].includes(asLlmError.llmCode)) {
-            let repaired;
-            try {
-                repaired = await repairToUnifiedDiff({
-                    llm: ctx.options.llm,
-                    baseMessages,
-                    chatOptions: { signal: ctx.options.signal },
-                    badContent: rawContent,
-                    reason: asLlmError.message,
-                });
-            }
-            catch {
-                throw asLlmError;
-            }
-            rawContent = repaired.content || '';
-            patch = extractUnifiedDiffFromLLMContent(rawContent);
-            normalizedPatch = normalizeDiff(patch);
-            diffMeta = validateWithLlmErrors(patch);
-            emitLlmOutput({
-                emit: ctx.emit,
-                policy: ctx.options.llmOutput,
-                kind: 'patch',
-                step: 'PATCH',
-                content: patch,
-            });
-        }
-        else {
-            throw asLlmError;
+        const salvaged = await salvagePatchDiff({
+            initialError: e,
+            rawContent,
+            plannedFiles: ctx.plan.files,
+            repair: ({ badContent }) => repairToUnifiedDiff({ badContent }),
+            onAttempt: recordPatchSalvageAttempt,
+            onResult: recordPatchSalvageResult,
+        });
+        if (!salvaged) {
+            throw e;
         }
+        rawContent = salvaged.rawContent;
+        parsedPatch = salvaged;
+        emitLlmOutput({
+            emit: ctx.emit,
+            policy: ctx.options.llmOutput,
+            kind: 'patch',
+            step: 'PATCH',
+            content: salvaged.patch,
+        });
     }
     // Deterministic contract: the patch should be applicable (git apply --check) before moving on.
     // When this fails, attempt a single LLM repair pass using the git error message as feedback.
     const applyCheck = await checkPatchApplies({
         repoRoot: ctx.workspace.workPath,
-        diff: normalizedPatch,
+        diff: parsedPatch.normalizedPatch,
     });
     if (!applyCheck.ok) {
-        const details = (applyCheck.stderr || '').trim();
-        try {
-            const repaired = await repairToUnifiedDiff({
-                llm: ctx.options.llm,
-                baseMessages,
-                chatOptions: { signal: ctx.options.signal },
-                badContent: patch,
-                reason: `Patch does not apply cleanly: ${details.slice(0, 1200)}`,
-            });
-            rawContent = repaired.content || '';
-            patch = extractUnifiedDiffFromLLMContent(rawContent);
-            normalizedPatch = normalizeDiff(patch);
-            diffMeta = validateWithLlmErrors(patch);
-            const applyCheck2 = await checkPatchApplies({
-                repoRoot: ctx.workspace.workPath,
-                diff: normalizedPatch,
-            });
-            if (applyCheck2.ok) {
-                emitLlmOutput({
-                    emit: ctx.emit,
-                    policy: ctx.options.llmOutput,
-                    kind: 'patch',
-                    step: 'PATCH',
-                    content: patch,
-                });
-            }
-        }
-        catch {
-            // Preserve the original patch and let VALIDATE provide the canonical failure if needed.
-        }
+        // Preserve the original patch and let VALIDATE provide the canonical failure if needed.
     }
     ctx.emit({
         type: 'log',
         level: 'debug',
-        message: `Patch generated: ${diffMeta.changedFiles.length} files changed`,
+        message: `Patch generated: ${parsedPatch.diffMeta.changedFiles.length} files changed`,
         timestamp: new Date(),
     });
     return {
         ...ctx,
-        diff: normalizedPatch,
-        diffMeta,
-        changedFiles: diffMeta.changedFiles,
+        diff: parsedPatch.normalizedPatch,
+        diffMeta: parsedPatch.diffMeta,
+        changedFiles: parsedPatch.diffMeta.changedFiles,
     };
 };
 //# sourceMappingURL=patch.js.map

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

@@ -1,16 +1,21 @@
 import { text } from '../../../locales/index.js';
 import { LIMITS } from '../../config/limits.js';
+import { supportsLlmStreaming } from '../../llm/capabilities.js';
 import { repairToJsonObject } from '../../llm/contracts/repair.js';
 import { sanitizeError } from '../../llm/errors.js';
-import { composeChatMessages } from '../../llm/message-composition.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
-import { formatContextForPrompt, parsePlanFromLLMContent } from '../../llm/utils.js';
+import { parsePlanFromLLMContent } from '../../llm/utils.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { logIgnoredError } from '../../observability/ignored-error.js';
 import { readPlan, updatePlan } from '../../plan/index.js';
 import { getPlanPrompt, getPlanSystemPrompt } from '../../prompts/runtime.js';
+import { SessionReplacementPreviewProvider } from '../../session/replacement-preview-provider.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
+import { resolveVisibleToolSpecs } from '../../tools/tool-visibility.js';
 import { Phase } from '../../types/runtime.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
+import { buildPhaseRequestEnvelope } from './request-assembly.js';
+import { buildPhaseToolRuntimeContext, buildToolVisibilityRuntime } from './tool-runtime.js';
 function sanitizeSubtaskText(raw) {
     const oneLine = String(raw ?? '')
         .replace(/\r?\n/g, ' ')
@@ -27,6 +32,25 @@ function sanitizeSubtaskText(raw) {
         return withoutComments;
     return withoutComments.slice(0, maxLen - 1).trimEnd() + '…';
 }
+function recordPlanRepairAttempt(args) {
+    recordAuditEvent('plan.repair.attempt', {
+        reason: args.reason,
+        badContentLength: args.badContentLength,
+        toolsDisabled: true,
+    }, { source: 'plan', severity: 'low', scope: 'session', phase: 'PLAN' });
+}
+function recordPlanRepairResult(args) {
+    recordAuditEvent('plan.repair.result', {
+        ok: args.ok,
+        contentLength: args.contentLength,
+        error: args.error,
+    }, {
+        source: 'plan',
+        severity: args.ok ? 'low' : 'medium',
+        scope: 'session',
+        phase: 'PLAN',
+    });
+}
 async function hydrateRuntimePlanTodos(ctx, plan) {
     const runtime = ctx.planRuntime;
     if (!runtime?.sessionId)
@@ -64,6 +88,15 @@ async function hydrateRuntimePlanTodos(ctx, plan) {
         },
     });
 }
+export function hasSuccessfulPlanUpdateDuringPlan(ctx) {
+    const auditEntries = ctx.toolCallingAudit;
+    if (!Array.isArray(auditEntries) || auditEntries.length === 0)
+        return false;
+    return auditEntries.some((entry) => entry.phase === Phase.PLAN &&
+        entry.toolName === 'plan.update' &&
+        entry.toolResultStatus === 'ok' &&
+        entry.toolResultOutputOk === true);
+}
 export const generatePlan = async (ctx) => {
     const toolstack = ctx.toolstack;
     const toolPolicy = resolveLlmToolCallingPolicy(Phase.PLAN, ctx.options.llm);
@@ -83,21 +116,53 @@ export const generatePlan = async (ctx) => {
             message: `Plan generated: ${plan.goal}`,
             timestamp: new Date(),
         });
-        // Best-effort: keep runtime plan actionable even if the LLM doesn't call plan.* tools.
-        await hydrateRuntimePlanTodos(ctx, plan).catch((error) => logIgnoredError('[Plan] hydrate runtime plan todos (legacy)', error));
+        if (ctx.planRuntime?.sessionId) {
+            // Transitional fallback: legacy/non-tool PLAN runs may hydrate runtime subtasks from final JSON.
+            await hydrateRuntimePlanTodos(ctx, plan).catch((error) => logIgnoredError('[Plan] hydrate runtime plan todos (legacy)', error));
+        }
         return {
             ...ctx,
             plan,
         };
     }
-    const prompt = await getPlanPrompt(formatContextForPrompt(ctx.context), ctx.options.instruction, LIMITS.maxFilesChanged, ctx.lastError);
-    const systemPrompt = await getPlanSystemPrompt(toolstack?.registry, { plan: ctx.planRuntime });
-    const baseMessages = composeChatMessages({
-        system: systemPrompt,
-        user: prompt,
+    const toolVisibility = buildToolVisibilityRuntime(ctx);
+    const promptVisibleTools = resolveVisibleToolSpecs({
+        phase: Phase.PLAN,
+        toolstack,
+        worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+        flowMode: ctx.mode,
+        runtime: toolVisibility,
+    });
+    const systemPrompt = await getPlanSystemPrompt(promptVisibleTools, toolVisibility);
+    const requestEnvelope = await buildPhaseRequestEnvelope({
+        phase: Phase.PLAN,
+        defaultNamespace: 'plan',
+        context: ctx.context,
+        contextResult: ctx.contextResult,
+        cacheSharing: ctx.cacheSharing,
+        onCacheMismatch: (mismatch) => {
+            recordAuditEvent('request.cache_sharing_hash_mismatch', mismatch, {
+                source: 'llm',
+                severity: 'low',
+                scope: 'session',
+                phase: Phase.PLAN,
+            });
+        },
+        systemPrompt,
+        buildUserPrompt: (contextPrompt) => getPlanPrompt(contextPrompt, ctx.options.instruction, LIMITS.maxFilesChanged, ctx.lastError),
         conversationContext: ctx.options.conversationContext,
+        artifactHints: ctx.artifactHints,
+        toolCallingAudit: ctx.toolCallingAudit,
+        previewProvider: new SessionReplacementPreviewProvider(ctx.replacementState),
+        toolVisibility: {
+            toolstack,
+            runtime: toolVisibility,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            flowMode: ctx.mode,
+        },
     });
-    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const { cacheSurface, envelope, baseMessages } = requestEnvelope;
+    const supportsStreaming = supportsLlmStreaming(ctx.options.llm, Phase.PLAN);
     const llmOutput = {
         policy: ctx.options.llmOutput,
         kind: 'plan',
@@ -105,23 +170,13 @@ export const generatePlan = async (ctx) => {
     };
     const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, {
         responseFormat: 'json_object',
+        providerHints: envelope.providerHints,
         signal: ctx.options.signal,
     }, {
         phase: Phase.PLAN,
         llm: ctx.options.llm,
-        runtime: {
-            repoRoot: ctx.workspace.workPath,
-            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
-            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
-            attemptId: ctx.attempt ?? 1,
-            dryRun: Boolean(ctx.options?.dryRun),
-            llm: ctx.options.llm,
-            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
-            userInputProvider: ctx.options.userInputProvider,
-            agentKind: ctx.options.agentKind ?? 'primary',
-            languagePlugins: ctx.options.languagePlugins,
-            subAgentController: ctx.options.subAgentController,
-        },
+        runtime: buildPhaseToolRuntimeContext(ctx, Phase.PLAN, cacheSurface),
+        toolVisibility,
         toolstack,
         eventPayload: ctx.options.eventPayload,
         toolCallingAudit: {
@@ -145,6 +200,10 @@ export const generatePlan = async (ctx) => {
         plan = parsePlanFromLLMContent(finalContent);
     }
     catch (e) {
+        recordPlanRepairAttempt({
+            reason: sanitizeError(e),
+            badContentLength: finalContent.length,
+        });
         let repaired;
         try {
             repaired = await repairToJsonObject({
@@ -156,6 +215,11 @@ export const generatePlan = async (ctx) => {
             });
         }
         catch (repairError) {
+            recordPlanRepairResult({
+                ok: false,
+                contentLength: 0,
+                error: sanitizeError(repairError).slice(0, 400),
+            });
             throw new Error(text.llm.planParseFailed(finalContent, sanitizeError(repairError)));
         }
         finalContent = repaired.content || '';
@@ -172,8 +236,17 @@ export const generatePlan = async (ctx) => {
             plan = parsePlanFromLLMContent(finalContent);
         }
         catch (e2) {
+            recordPlanRepairResult({
+                ok: false,
+                contentLength: finalContent.length,
+                error: sanitizeError(e2).slice(0, 400),
+            });
             throw new Error(text.llm.planParseFailed(finalContent, sanitizeError(e2)));
         }
+        recordPlanRepairResult({
+            ok: true,
+            contentLength: finalContent.length,
+        });
     }
     ctx.emit({
         type: 'log',
@@ -181,8 +254,11 @@ export const generatePlan = async (ctx) => {
         message: `Plan generated: ${plan.goal}`,
         timestamp: new Date(),
     });
-    // Best-effort: keep runtime plan actionable even if the LLM doesn't call plan.* tools.
-    await hydrateRuntimePlanTodos(ctx, plan).catch((error) => logIgnoredError('[Plan] hydrate runtime plan todos (tools)', error));
+    const hasModelPlanUpdate = hasSuccessfulPlanUpdateDuringPlan(ctx);
+    if (ctx.planRuntime?.sessionId && !hasModelPlanUpdate) {
+        // Transitional fallback: only hydrate when PLAN did not successfully persist via plan.update.
+        await hydrateRuntimePlanTodos(ctx, plan).catch((error) => logIgnoredError('[Plan] hydrate runtime plan todos (tools)', error));
+    }
     return {
         ...ctx,
         plan,

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

@@ -1,15 +1,13 @@
 import { text } from '../../../locales/index.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { resolveExecutionProfile } from '../../runtime/execution-profile.js';
 import { createStandardToolstack } from '../../tools/loader.js';
-import { Phase } from '../../types/runtime.js';
 import { preflight } from '../../verification/runner.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
 export const runPreflight = async (ctx) => {
+    const executionProfile = resolveExecutionProfile(ctx.mode);
     const result = await preflight(ctx.workspace, ctx.emit, {
-        ignoreDirty: ctx.mode === 'review' ||
-            ctx.mode === 'research' ||
-            ctx.mode === 'answer' ||
-            ctx.options.permissionMode === 'yolo',
+        ignoreDirty: executionProfile.ignoreDirtyPreflight,
     });
     if (!result.ok) {
         const reason = result.reason || text.loop.preflightFailedNotGit;
@@ -29,7 +27,8 @@ export const runPreflight = async (ctx) => {
         message: text.loop.preflightPassed,
         timestamp: new Date(),
     });
-    const toolstack = resolveLlmToolCallingPolicy(Phase.PLAN, ctx.options.llm).enabled
+    const toolstack = resolveLlmToolCallingPolicy(executionProfile.entryPhase, ctx.options.llm)
+        .enabled
         ? await createStandardToolstack({
             repoRoot: ctx.workspace.workPath,
             persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,