salmon-loop 0.2.13 → 0.3.0

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,

package/dist/core/grizzco/steps/request-assembly.js

@@ -0,0 +1,78 @@
+import { augmentPromptWithRelevantMemory } from '../../llm/request-augmentation.js';
+import { buildSharedRequestEnvelope as buildSharedRequestEnvelopeCore, } from '../../llm/shared-request-assembly.js';
+import { formatContextForPrompt } from '../../llm/utils.js';
+import { buildRelevantMemoryCandidates, selectRelevantMemory, } from '../../memory/relevant-retrieval.js';
+import { resolveVisibleToolNames, } from '../../tools/tool-visibility.js';
+import { resolveCacheSharingSurface, } from './cache-sharing.js';
+export function buildSharedRequestEnvelope(args) {
+    return buildSharedRequestEnvelopeCore(args);
+}
+export async function buildAugmentedRequestEnvelope(args) {
+    const baseContextPrompt = args.baseContextPrompt ?? args.contextResult?.prompt ?? formatContextForPrompt(args.context);
+    const localContextHash = args.contextResult?.meta?.contextHash ?? args.context.contextHash;
+    const cacheSurface = resolveCacheSharingSurface({
+        phase: args.phase,
+        defaultNamespace: args.defaultNamespace,
+        localContextHash,
+        cacheSharing: args.cacheSharing,
+        mismatchPolicy: args.cacheMismatchPolicy,
+        onMismatch: args.onCacheMismatch,
+    });
+    const relevantMemory = selectRelevantMemory({
+        instruction: args.context.instruction,
+        candidates: args.relevantMemory?.entries ?? buildRelevantMemoryCandidates(args.context),
+        activeToolNames: resolveVisibleToolNames({
+            phase: args.phase,
+            toolstack: args.toolVisibility?.toolstack,
+            runtime: args.toolVisibility?.runtime,
+            worktreeRoot: args.toolVisibility?.worktreeRoot,
+            flowMode: args.toolVisibility?.flowMode,
+        }),
+        maxItems: args.relevantMemory?.maxItems,
+        alreadySurfacedText: [
+            baseContextPrompt,
+            ...(Array.isArray(args.systemPrompt) ? args.systemPrompt : [args.systemPrompt]),
+            ...(args.conversationContext ?? []).map((message) => message.content),
+        ],
+    });
+    const contextPrompt = augmentPromptWithRelevantMemory({
+        basePrompt: baseContextPrompt,
+        selectedEntries: relevantMemory,
+        budgetTokens: args.relevantMemory?.budgetTokens,
+        countTokens: args.relevantMemory?.countTokens,
+    }).prompt;
+    const userPrompt = await args.buildUserPrompt(contextPrompt);
+    const shared = buildSharedRequestEnvelope({
+        defaultNamespace: cacheSurface.namespace,
+        contextHash: cacheSurface.contextHash,
+        systemPrompt: args.systemPrompt,
+        userPrompt,
+        conversationContext: args.conversationContext,
+        artifactHints: args.artifactHints,
+        toolCallingAudit: args.toolCallingAudit,
+        previewProvider: args.previewProvider,
+        attachments: [
+            {
+                key: 'context-prompt',
+                kind: 'context',
+                label: 'Context prompt',
+                content: contextPrompt,
+                cacheSafe: true,
+            },
+            ...(args.extraAttachments ?? []),
+        ],
+        providerHints: args.providerHints,
+    });
+    return {
+        contextPrompt,
+        userPrompt,
+        cacheSurface,
+        resolvedArtifactHints: shared.resolvedArtifactHints,
+        envelope: shared.envelope,
+        baseMessages: shared.baseMessages,
+    };
+}
+export async function buildPhaseRequestEnvelope(args) {
+    return buildAugmentedRequestEnvelope(args);
+}
+//# sourceMappingURL=request-assembly.js.map

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

@@ -1,23 +1,14 @@
 import { text } from '../../../locales/index.js';
-import { composeChatMessages } from '../../llm/message-composition.js';
+import { supportsLlmStreaming } from '../../llm/capabilities.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
-import { formatContextForPrompt } from '../../llm/utils.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { getResearchPrompt, getResearchSystemPrompt } from '../../prompts/runtime.js';
+import { SessionReplacementPreviewProvider } from '../../session/replacement-preview-provider.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
 import { Phase } from '../../types/runtime.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
-function buildResearchPrompt(contextText, instruction) {
-    return [
-        'You are running in deep research mode.',
-        'Use available tools to gather external information as needed.',
-        'Return JSON with keys: researchNotes, researchFindings, sources, researchText.',
-        'Each researchFinding should include: summary, confidence (0-1), uncertainty (string).',
-        'Each source should include: toolName, summary, ok, timestamp (epoch ms).',
-        '',
-        `Instruction:\n${instruction}`,
-        '',
-        `Context:\n${contextText}`,
-    ].join('\n');
-}
+import { buildPhaseRequestEnvelope } from './request-assembly.js';
+import { buildPhaseToolRuntimeContext, buildToolVisibilityRuntime } from './tool-runtime.js';
 function normalizeFindings(value) {
     if (!value)
         return [];
@@ -88,20 +79,43 @@ function buildSourcesFromAudit(entries) {
     }));
 }
 export async function generateResearch(ctx) {
-    const contextText = formatContextForPrompt(ctx.context);
-    const prompt = buildResearchPrompt(contextText, ctx.options.instruction);
-    const systemPrompt = 'You are a research assistant. Prefer evidence-backed claims.';
-    const baseMessages = composeChatMessages({
-        system: systemPrompt,
-        user: prompt,
+    const systemPrompt = await getResearchSystemPrompt();
+    const toolVisibility = buildToolVisibilityRuntime(ctx);
+    const requestEnvelope = await buildPhaseRequestEnvelope({
+        phase: Phase.RESEARCH,
+        defaultNamespace: 'research',
+        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.RESEARCH,
+            });
+        },
+        systemPrompt,
+        buildUserPrompt: async (contextText) => await getResearchPrompt(contextText, ctx.options.instruction),
         conversationContext: ctx.options.conversationContext,
+        artifactHints: ctx.artifactHints,
+        toolCallingAudit: ctx.toolCallingAudit,
+        previewProvider: new SessionReplacementPreviewProvider(ctx.replacementState),
+        toolVisibility: {
+            toolstack: ctx.toolstack,
+            runtime: toolVisibility,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            flowMode: ctx.mode,
+        },
     });
+    const { cacheSurface, envelope, baseMessages } = requestEnvelope;
     const toolPolicy = resolveLlmToolCallingPolicy(Phase.RESEARCH, ctx.options.llm);
-    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const supportsStreaming = supportsLlmStreaming(ctx.options.llm, Phase.RESEARCH);
     const localAudit = [];
     const sourcesFromAudit = () => buildSourcesFromAudit(localAudit);
     if (!ctx.toolstack || !toolPolicy.enabled) {
         const response = await ctx.options.llm.chat(baseMessages, {
+            providerHints: envelope.providerHints,
             signal: ctx.options.signal,
             phase: Phase.RESEARCH,
         });
@@ -133,22 +147,11 @@ export async function generateResearch(ctx) {
         kind: 'research',
         step: 'RESEARCH',
     };
-    const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, { signal: ctx.options.signal }, {
+    const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, { providerHints: envelope.providerHints, signal: ctx.options.signal }, {
         phase: Phase.RESEARCH,
         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.RESEARCH, cacheSurface),
+        toolVisibility,
         toolstack: ctx.toolstack,
         eventPayload: ctx.options.eventPayload,
         toolCallingAudit: {

package/dist/core/grizzco/steps/tool-runtime.js

@@ -0,0 +1,47 @@
+import { buildSystemPrefixDigest, buildToolSchemaHash, } from '../../sub-agent/prefix-consistency.js';
+export function buildPhaseToolRuntimeContext(ctx, phase, cacheSurface) {
+    return {
+        repoRoot: ctx.workspace.workPath,
+        persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
+        worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+        flowMode: ctx.mode,
+        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,
+        phase,
+        contextSnapshot: {
+            conversationContext: ctx.options.conversationContext,
+            artifactHints: ctx.artifactHints,
+            toolCallingAudit: ctx.toolCallingAudit,
+            replacementState: ctx.replacementState,
+            planRuntime: ctx.planRuntime,
+            cacheSharing: {
+                namespace: cacheSurface.namespace,
+                contextHash: cacheSurface.contextHash,
+                toolSchemaHash: buildToolSchemaHash({
+                    phase,
+                    allowedToolNames: ctx.options.allowedToolNames,
+                }),
+                systemPrefixDigest: buildSystemPrefixDigest({
+                    phase,
+                    namespace: cacheSurface.namespace,
+                    contextHash: cacheSurface.contextHash,
+                }),
+            },
+        },
+    };
+}
+export function buildToolVisibilityRuntime(ctx) {
+    if (!ctx.planRuntime) {
+        return undefined;
+    }
+    return {
+        plan: ctx.planRuntime,
+    };
+}
+//# sourceMappingURL=tool-runtime.js.map

package/dist/core/grizzco/steps/verify-shared.js

@@ -0,0 +1,23 @@
+import { ArtifactStore } from '../../sub-agent/artifacts/store.js';
+import { runVerify as runVerifyCommand } from '../../verification/runner.js';
+export async function executeVerifyForWorkspace(params) {
+    const verifyResult = await runVerifyCommand(params.workspacePath, params.verify, undefined, params.signal);
+    let verifyArtifact;
+    if (!verifyResult.ok && verifyResult.output) {
+        try {
+            verifyArtifact = await ArtifactStore.saveText({
+                content: verifyResult.output,
+                mimeType: 'text/plain',
+                fileExt: 'log',
+            });
+        }
+        catch {
+            // Best-effort only; keep verifyResult.output in-memory for shrink/error classification.
+        }
+    }
+    return {
+        verifyResult,
+        ...(verifyArtifact ? { verifyArtifact } : {}),
+    };
+}
+//# sourceMappingURL=verify-shared.js.map

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

@@ -1,8 +1,7 @@
 import { text } from '../../../locales/index.js';
 import { collectBudgetMetrics, evaluateBudgetAlert, getGlobalAdjuster, recordBudgetAlert, } from '../../context/budget/integration.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
-import { ArtifactStore } from '../../sub-agent/artifacts/store.js';
-import { runVerify as runVerifyCommand } from '../../verification/runner.js';
+import { executeVerifyForWorkspace } from './verify-shared.js';
 function extractCommandProgram(command) {
     const trimmed = command.trim();
     if (!trimmed)
@@ -16,8 +15,11 @@ export const runVerify = async (ctx) => {
             verifyResult: { ok: true, output: text.loop.verificationSkipped, exitCode: null },
         };
     }
-    const verifyResult = await runVerifyCommand(ctx.workspace.workPath, ctx.options.verify, undefined, ctx.options.signal);
-    let verifyArtifact;
+    const { verifyResult, verifyArtifact } = await executeVerifyForWorkspace({
+        workspacePath: ctx.workspace.workPath,
+        verify: ctx.options.verify,
+        signal: ctx.options.signal,
+    });
     recordAuditEvent('verify.summary', {
         ok: verifyResult.ok,
         exitCode: verifyResult.exitCode,
@@ -92,23 +94,13 @@ export const runVerify = async (ctx) => {
             message: text.loop.verificationFailedSummary,
             timestamp: new Date(),
         });
-        if (verifyResult.output) {
-            try {
-                verifyArtifact = await ArtifactStore.saveText({
-                    content: verifyResult.output,
-                    mimeType: 'text/plain',
-                    fileExt: 'log',
-                });
-                ctx.emit({
-                    type: 'log',
-                    level: 'debug',
-                    message: text.loop.verificationOutputStored(verifyArtifact.handle),
-                    timestamp: new Date(),
-                });
-            }
-            catch {
-                // Best-effort only; keep verifyResult.output in-memory for shrink/error classification.
-            }
+        if (verifyArtifact) {
+            ctx.emit({
+                type: 'log',
+                level: 'debug',
+                message: text.loop.verificationOutputStored(verifyArtifact.handle),
+                timestamp: new Date(),
+            });
         }
         // We don't throw here, because we want to trigger rollback/shrink in the pipeline
         // But wait, the Pipeline abstraction propagates errors immediately.

package/dist/core/interaction/orchestration/facade.js

@@ -20,7 +20,7 @@ export function createInteractionFacade(deps) {
                 id: input.taskId ?? `task_${Date.now()}`,
                 capability: input.capability,
                 state: 'accepted',
-                request: input.request,
+                request: { ...input.request, extensions: input.extensions },
                 createdAt: new Date().toISOString(),
                 attempt: 1,
             };

package/dist/core/llm/ai-sdk/chat-executor.js

@@ -34,6 +34,7 @@ export async function executeAiSdkChatRequest(input) {
                         options: input.options,
                         headers: attemptCtx.langfuseHeaders,
                         abortSignal: attemptCtx.abortSignal,
+                        providerOptionsKey: input.providerOptionsKey,
                     }));
                     const usage = extractUsageFromAiSdkResult(result);
                     if (usage) {
@@ -74,6 +75,7 @@ export async function* executeAiSdkChatStreamRequest(input) {
                     options: input.options,
                     headers: attemptCtx.langfuseHeaders,
                     abortSignal: attemptCtx.abortSignal,
+                    providerOptionsKey: input.providerOptionsKey,
                 }));
                 yield* mapAiSdkStreamResultToChunks(result.fullStream);
             },

package/dist/core/llm/ai-sdk/high-level-phase-specs.js

@@ -0,0 +1,63 @@
+import { LIMITS } from '../../config/limits.js';
+import { getPatchPrompt, getPlanPrompt } from '../../prompts/runtime.js';
+import { wrapPlanEmpty, sanitizeError, LlmError } from '../errors.js';
+import { extractUnifiedDiffFromLLMContent, parsePlanFromLLMContent } from '../utils.js';
+export const HIGH_LEVEL_PHASE_NAMES = [
+    'plan',
+    'patch',
+];
+function buildContextPromptAttachment(contextPrompt) {
+    return {
+        key: 'context-prompt',
+        kind: 'context',
+        label: 'Context prompt',
+        content: contextPrompt,
+        cacheSafe: true,
+    };
+}
+function buildPatchAttachments(contextPrompt, planStr) {
+    return [
+        buildContextPromptAttachment(contextPrompt),
+        {
+            key: 'plan-json',
+            kind: 'plan',
+            label: 'Plan JSON',
+            content: planStr,
+        },
+    ];
+}
+function parsePlanResult(content) {
+    if (!content) {
+        throw wrapPlanEmpty();
+    }
+    try {
+        return parsePlanFromLLMContent(content);
+    }
+    catch (e) {
+        throw new LlmError('LLM plan parsing failed', 'LLM_PLAN_INVALID_JSON', {
+            causeMessage: sanitizeError(e),
+        });
+    }
+}
+function parsePatchResult(content) {
+    return extractUnifiedDiffFromLLMContent(content ?? '');
+}
+export const HIGH_LEVEL_PHASE_SPECS = {
+    plan: {
+        name: 'plan',
+        namespace: 'plan',
+        observationName: 'PLAN:plan-json',
+        buildPrompt: async ({ contextPrompt, instruction, lastError }) => getPlanPrompt(contextPrompt, instruction, LIMITS.maxFilesChanged, lastError),
+        buildAttachments: ({ contextPrompt }) => [buildContextPromptAttachment(contextPrompt)],
+        parseResult: (content) => parsePlanResult(content),
+    },
+    patch: {
+        name: 'patch',
+        namespace: 'patch',
+        observationName: 'PATCH:unified-diff',
+        buildPrompt: async ({ planStr, contextPrompt, lastError }) => getPatchPrompt(planStr, contextPrompt, LIMITS.maxFilesChanged, LIMITS.maxDiffLines, lastError),
+        buildAttachments: ({ contextPrompt, planStr }) => buildPatchAttachments(contextPrompt, planStr),
+        parseResult: (content) => parsePatchResult(content),
+    },
+};
+//# sourceMappingURL=high-level-phase-specs.js.map