salmon-loop 0.2.3 → 0.2.16

package/dist/core/llm/phase-router.js

@@ -12,16 +12,9 @@ export function createPhaseRoutingLlm(params) {
         chat(messages, options) {
             return resolve(options?.phase).chat(messages, options);
         },
-        getCapabilities() {
-            const base = defaultLlm.getCapabilities?.() ?? {};
-            const hasToolCalling = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().toolCalling);
-            const hasStreaming = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().streaming);
-            const hasJsonMode = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().responseFormatJsonObject);
-            return {
-                toolCalling: base.toolCalling || hasToolCalling,
-                streaming: base.streaming || hasStreaming,
-                responseFormatJsonObject: base.responseFormatJsonObject || hasJsonMode,
-            };
+        getCapabilities(options) {
+            const selected = resolve(options?.phase);
+            return selected.getCapabilities?.(options) ?? {};
         },
         createPlan(context, instruction, lastError, signal) {
             return resolve(Phase.PLAN).createPlan(context, instruction, lastError, signal);
@@ -33,11 +26,37 @@ export function createPhaseRoutingLlm(params) {
     if (hasAnyStreaming) {
         routed.chatStream = async function* (messages, options) {
             const selected = resolve(options?.phase);
+            const capabilities = selected.getCapabilities?.(options) ?? {};
+            if (capabilities.streaming === false) {
+                const fallback = await selected.chat(messages, options);
+                if (fallback.reasoning_content) {
+                    yield {
+                        role: 'assistant',
+                        source: 'synthesized',
+                        reasoningDelta: fallback.reasoning_content,
+                    };
+                }
+                if (fallback.content) {
+                    yield { role: 'assistant', source: 'synthesized', contentDelta: fallback.content };
+                }
+                if (Array.isArray(fallback.tool_calls) && fallback.tool_calls.length > 0) {
+                    yield { role: 'assistant', source: 'synthesized', tool_calls: fallback.tool_calls };
+                }
+                yield { role: 'assistant', source: 'synthesized', done: true, finishReason: 'stop' };
+                return;
+            }
             if (selected.chatStream) {
                 yield* selected.chatStream(messages, options);
                 return;
             }
             const fallback = await selected.chat(messages, options);
+            if (fallback.reasoning_content) {
+                yield {
+                    role: 'assistant',
+                    source: 'synthesized',
+                    reasoningDelta: fallback.reasoning_content,
+                };
+            }
             if (fallback.content) {
                 yield { role: 'assistant', source: 'synthesized', contentDelta: fallback.content };
             }

package/dist/core/llm/redact.js

@@ -1,4 +1,22 @@
 const SECRET_KEY_REGEX = /(api[-_]?key|authorization|token|secret|password|cookie)/i;
+const STRING_SECRET_PATTERNS = [
+    {
+        pattern: /(authorization\s*:\s*bearer\s+)[^\s'",`]+/gi,
+        replacement: '$1[REDACTED]',
+    },
+    {
+        pattern: /\bbearer\s+[a-z0-9._~+/=-]{16,}\b/gi,
+        replacement: 'Bearer [REDACTED]',
+    },
+    {
+        pattern: /\bsk-[a-z0-9_-]{16,}\b/gi,
+        replacement: '[REDACTED]',
+    },
+    {
+        pattern: /\b(api[-_]?key|token|secret|password|cookie)\s*[:=]\s*("[^"]*"|'[^']*'|[^\s'",`]+)/gi,
+        replacement: '$1=[REDACTED]',
+    },
+];
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -7,9 +25,16 @@ function truncate(value, max = 500) {
         return value;
     return value.slice(0, max) + '...';
 }
+function redactString(value) {
+    let redacted = value;
+    for (const { pattern, replacement } of STRING_SECRET_PATTERNS) {
+        redacted = redacted.replace(pattern, replacement);
+    }
+    return truncate(redacted, 500);
+}
 export function redactValue(value) {
     if (typeof value === 'string')
-        return truncate(value, 500);
+        return redactString(value);
     if (typeof value === 'number' || typeof value === 'boolean' || value === null)
         return value;
     if (Array.isArray(value))
@@ -29,9 +54,9 @@ export function redactValue(value) {
     return '[Unserializable]';
 }
 export function redactJsonString(raw) {
-    return truncate(raw, 500);
+    return redactString(raw);
 }
 export function redactErrorMessage(raw) {
-    return truncate(raw, 500);
+    return redactString(raw);
 }
 //# sourceMappingURL=redact.js.map

package/dist/core/llm/registry.js

@@ -39,6 +39,7 @@ export function createDefaultLlmRegistry() {
                     headers: resolved.api.headers,
                     timeoutMs: resolved.api.timeoutMs,
                     langfuseEnabled: options?.langfuseEnabled,
+                    capabilities: resolved.capabilities,
                 }),
                 backend: 'ai-sdk',
                 warnings,
@@ -73,6 +74,7 @@ export function createDefaultOpenAiFallback(resolved, options) {
             headers: resolved.api.headers,
             timeoutMs: resolved.api.timeoutMs,
             langfuseEnabled: options?.langfuseEnabled,
+            capabilities: resolved.capabilities,
         }),
         backend: 'ai-sdk',
         warnings,

package/dist/core/llm/request-augmentation.js

@@ -0,0 +1,55 @@
+const MEMORY_HEADER = '[Relevant memory]';
+function defaultCountTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function normalizeEntry(entry) {
+    return {
+        path: String(entry.path),
+        title: String(entry.title),
+        summary: String(entry.summary),
+        tags: entry.tags,
+    };
+}
+function formatRelevantMemoryEntry(entry) {
+    return `- ${entry.path} | ${entry.title}\n  ${entry.summary}`;
+}
+export function augmentPromptWithRelevantMemory(args) {
+    const basePrompt = String(args.basePrompt ?? '').trimEnd();
+    const selectedEntries = Array.isArray(args.selectedEntries)
+        ? args.selectedEntries.map(normalizeEntry)
+        : [];
+    if (selectedEntries.length === 0) {
+        return { prompt: basePrompt, injectedEntries: [] };
+    }
+    const countTokens = args.countTokens ?? defaultCountTokens;
+    const budgetTokens = typeof args.budgetTokens === 'number'
+        ? Math.max(0, Math.floor(args.budgetTokens))
+        : Number.MAX_SAFE_INTEGER;
+    const headerTokens = Math.max(0, Math.floor(countTokens(MEMORY_HEADER)));
+    if (headerTokens > budgetTokens) {
+        return { prompt: basePrompt, injectedEntries: [] };
+    }
+    let remainingBudget = budgetTokens - headerTokens;
+    const injectedEntries = [];
+    const renderedEntries = [];
+    for (const entry of selectedEntries) {
+        const rendered = formatRelevantMemoryEntry(entry);
+        const entryTokens = Math.max(0, Math.floor(countTokens(rendered)));
+        if (entryTokens > remainingBudget) {
+            break;
+        }
+        injectedEntries.push(entry);
+        renderedEntries.push(rendered);
+        remainingBudget -= entryTokens;
+    }
+    if (renderedEntries.length === 0) {
+        return { prompt: basePrompt, injectedEntries: [] };
+    }
+    const memoryBlock = [MEMORY_HEADER, ...renderedEntries].join('\n');
+    return {
+        prompt: basePrompt ? `${basePrompt}\n\n${memoryBlock}` : memoryBlock,
+        injectedEntries,
+        memoryBlock,
+    };
+}
+//# sourceMappingURL=request-augmentation.js.map

package/dist/core/llm/request-envelope.js

@@ -0,0 +1,334 @@
+import { createHash } from 'crypto';
+import { getPromptCachingManager } from '../context/cache/prompt-caching.js';
+function isArtifactHandle(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (typeof candidate.handle === 'string' &&
+        typeof candidate.mimeType === 'string' &&
+        typeof candidate.sha256 === 'string' &&
+        typeof candidate.size === 'number');
+}
+function mergeArtifactHandles(existing, incoming, limit = 4) {
+    const merged = [];
+    const seen = new Set();
+    for (const artifact of [...(existing ?? []), ...(incoming ?? [])]) {
+        if (!artifact || seen.has(artifact.handle))
+            continue;
+        seen.add(artifact.handle);
+        merged.push(artifact);
+    }
+    if (merged.length === 0)
+        return undefined;
+    return merged.slice(-limit);
+}
+function mergeReadArtifactRefs(existing, incoming, limit = 6) {
+    const merged = [];
+    const seen = new Set();
+    for (const item of [...(existing ?? []), ...(incoming ?? [])]) {
+        if (!item?.path || !item.artifact?.handle)
+            continue;
+        const key = `${item.path}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(item);
+    }
+    if (merged.length === 0)
+        return undefined;
+    return merged.slice(-limit);
+}
+function mergePreviewArtifactRefs(existing, incoming, limit = 6) {
+    const merged = [];
+    const seen = new Set();
+    for (const item of [...(existing ?? []), ...(incoming ?? [])]) {
+        if (!item?.label || !item.artifact?.handle)
+            continue;
+        const key = `${item.label}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(item);
+    }
+    if (merged.length === 0)
+        return undefined;
+    return merged.slice(-limit);
+}
+export function resolveRequestArtifactHints(params) {
+    const direct = params.artifactHints;
+    const auditEntries = params.toolCallingAudit ?? [];
+    const auditPatchArtifacts = [];
+    const auditAuditArtifacts = [];
+    const auditReadArtifacts = [];
+    const auditPreviewArtifacts = [];
+    for (const entry of auditEntries) {
+        if (entry?.toolResultStatus === 'ok' && entry.toolName === 'agent_dispatch') {
+            if (isArtifactHandle(entry.toolResultPatchArtifact)) {
+                auditPatchArtifacts.push(entry.toolResultPatchArtifact);
+            }
+            if (isArtifactHandle(entry.toolResultAuditArtifact)) {
+                auditAuditArtifacts.push(entry.toolResultAuditArtifact);
+            }
+        }
+        if (typeof entry.toolResultReadArtifactPath === 'string' &&
+            isArtifactHandle(entry.toolResultReadArtifact)) {
+            auditReadArtifacts.push({
+                path: entry.toolResultReadArtifactPath,
+                artifact: entry.toolResultReadArtifact,
+            });
+        }
+        if (typeof entry.toolResultPreviewLabel === 'string' &&
+            isArtifactHandle(entry.toolResultPreviewArtifact)) {
+            auditPreviewArtifacts.push({
+                label: entry.toolResultPreviewLabel,
+                artifact: entry.toolResultPreviewArtifact,
+            });
+        }
+    }
+    const resolved = {
+        verifyArtifact: direct?.verifyArtifact,
+        subAgentPatchArtifacts: mergeArtifactHandles(direct?.subAgentPatchArtifacts, auditPatchArtifacts),
+        subAgentAuditArtifacts: mergeArtifactHandles(direct?.subAgentAuditArtifacts, auditAuditArtifacts),
+        recentReadArtifacts: mergeReadArtifactRefs(direct?.recentReadArtifacts, auditReadArtifacts),
+        toolResultPreviewArtifacts: mergePreviewArtifactRefs(params.previewProvider?.getPreviewHints(), auditPreviewArtifacts),
+    };
+    if (!resolved.verifyArtifact &&
+        !resolved.subAgentPatchArtifacts?.length &&
+        !resolved.subAgentAuditArtifacts?.length &&
+        !resolved.recentReadArtifacts?.length &&
+        !resolved.toolResultPreviewArtifacts?.length) {
+        return undefined;
+    }
+    return resolved;
+}
+function toSafeMessage(message) {
+    if (!message || typeof message !== 'object')
+        return null;
+    if (message.role !== 'system' && message.role !== 'user' && message.role !== 'assistant') {
+        return null;
+    }
+    if (typeof message.content !== 'string')
+        return null;
+    const content = message.content.trimEnd();
+    if (!content)
+        return null;
+    return {
+        role: message.role,
+        content,
+    };
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function resolvePromptCacheMode(mode) {
+    return mode === 'strict_full_prompt' ? 'strict_full_prompt' : 'cache_safe_only';
+}
+function serializeAttachmentForFingerprint(item) {
+    return [
+        item.key,
+        item.kind,
+        item.label ?? '',
+        item.content ?? '',
+        item.artifactHandle ?? '',
+        item.mimeType ?? '',
+        typeof item.size === 'number' ? String(item.size) : '',
+    ].join('\u001f');
+}
+function createFingerprint(parts) {
+    if (parts.length === 0)
+        return undefined;
+    const hash = createHash('sha256');
+    for (const [index, part] of parts.entries()) {
+        hash.update(`part:${index}:${part.length}\n`);
+        hash.update(part);
+        hash.update('\n');
+    }
+    return hash.digest('hex');
+}
+function toArtifactAttachment(args) {
+    return {
+        key: args.key,
+        kind: 'artifact',
+        label: args.label,
+        content: '',
+        artifactHandle: args.artifact.handle,
+        mimeType: args.artifact.mimeType,
+        size: args.artifact.size,
+    };
+}
+export function buildArtifactHintAttachments(hints) {
+    if (!hints)
+        return [];
+    const attachments = [];
+    if (hints.verifyArtifact) {
+        attachments.push(toArtifactAttachment({
+            key: 'previous-verify-output',
+            label: 'Previous verify output',
+            artifact: hints.verifyArtifact,
+        }));
+    }
+    for (const [index, artifact] of (hints.subAgentPatchArtifacts ?? []).entries()) {
+        attachments.push(toArtifactAttachment({
+            key: `previous-subagent-patch-${index}`,
+            label: `Previous sub-agent patch artifact ${index + 1}`,
+            artifact,
+        }));
+    }
+    for (const [index, artifact] of (hints.subAgentAuditArtifacts ?? []).entries()) {
+        attachments.push(toArtifactAttachment({
+            key: `previous-subagent-audit-${index}`,
+            label: `Previous sub-agent audit artifact ${index + 1}`,
+            artifact,
+        }));
+    }
+    for (const [index, item] of (hints.recentReadArtifacts ?? []).entries()) {
+        attachments.push(toArtifactAttachment({
+            key: `recent-read-${index}`,
+            label: `Recent file read: ${item.path}`,
+            artifact: item.artifact,
+        }));
+    }
+    for (const [index, item] of (hints.toolResultPreviewArtifacts ?? []).entries()) {
+        attachments.push(toArtifactAttachment({
+            key: `tool-result-preview-${index}`,
+            label: item.label,
+            artifact: item.artifact,
+        }));
+    }
+    return attachments;
+}
+function buildPromptCachingHints(surface) {
+    const policy = {
+        mode: surface.mode,
+        eligibility: surface.cacheEligibility,
+        namespace: surface.namespace,
+        contextHash: surface.contextHash,
+        cacheSafeFingerprint: surface.cacheSafeFingerprint,
+        lateInjectionFingerprint: surface.lateInjectionFingerprint,
+    };
+    if (surface.cacheEligibility !== 'eligible' ||
+        !surface.contextHash ||
+        !surface.cacheSafeFingerprint) {
+        return {
+            openAICachePolicy: policy,
+        };
+    }
+    const components = [surface.contextHash, `stable:${surface.cacheSafeFingerprint}`];
+    if (surface.mode === 'strict_full_prompt' && surface.lateInjectionFingerprint) {
+        components.push(`late:${surface.lateInjectionFingerprint}`);
+    }
+    const manager = getPromptCachingManager();
+    return {
+        openAICacheHint: manager.generateOpenAICacheHint(surface.namespace ?? 'request-envelope', components),
+        openAICachePolicy: policy,
+    };
+}
+export function buildRequestEnvelope(params) {
+    const systemSections = (Array.isArray(params.system) ? params.system : [params.system]).map((item) => String(item ?? '').trimEnd());
+    const attachments = Array.isArray(params.attachments)
+        ? params.attachments
+            .filter((item) => item && (typeof item.content === 'string' || typeof item.artifactHandle === 'string'))
+            .map((item) => ({
+            ...item,
+            content: typeof item.content === 'string' ? item.content.trimEnd() : '',
+        }))
+            .filter((item) => item.content.length > 0 || typeof item.artifactHandle === 'string')
+        : [];
+    const userMetaMessages = [];
+    const conversationMessages = [];
+    if (Array.isArray(params.conversationContext)) {
+        for (const message of params.conversationContext) {
+            const safe = toSafeMessage(message);
+            if (!safe)
+                continue;
+            if (safe.role === 'system') {
+                userMetaMessages.push(safe);
+                continue;
+            }
+            conversationMessages.push(safe);
+        }
+    }
+    const cacheMode = resolvePromptCacheMode(params.cacheSafeSurface?.mode);
+    const cacheSafeAttachments = attachments.filter((item) => item.cacheSafe);
+    const lateInjectionAttachments = attachments.filter((item) => !item.cacheSafe);
+    const cacheSafeFingerprint = createFingerprint([
+        ...systemSections.map((section, index) => `system:${index}\u001f${section}`),
+        ...cacheSafeAttachments.map((item, index) => `attachment:${index}\u001f${serializeAttachmentForFingerprint(item)}`),
+    ]);
+    const lateInjectionFingerprint = createFingerprint([
+        `userPrompt\u001f${String(params.user ?? '').trimEnd()}`,
+        ...userMetaMessages.map((message, index) => `meta:${index}\u001f${message.content}`),
+        ...conversationMessages.map((message, index) => `conversation:${index}\u001f${message.role}\u001f${message.content}`),
+        ...lateInjectionAttachments.map((item, index) => `late-attachment:${index}\u001f${serializeAttachmentForFingerprint(item)}`),
+    ]);
+    const cacheSafeText = [...systemSections, ...cacheSafeAttachments.map((item) => item.content)]
+        .filter(Boolean)
+        .join('\n\n');
+    const manager = getPromptCachingManager();
+    const cacheEligibility = !params.cacheSafeSurface?.contextHash
+        ? 'missing_context_hash'
+        : !cacheSafeText.trim()
+            ? 'empty_cache_safe_surface'
+            : !manager.shouldCache(estimateTokens(cacheSafeText))
+                ? 'below_min_tokens'
+                : 'eligible';
+    const cacheSafeSurface = {
+        systemSections,
+        attachments: cacheSafeAttachments,
+        contextHash: params.cacheSafeSurface?.contextHash,
+        namespace: params.cacheSafeSurface?.namespace,
+        mode: cacheMode,
+        cacheEligibility,
+        cacheSafeFingerprint,
+        lateInjectionFingerprint,
+    };
+    return {
+        systemSections,
+        userPrompt: String(params.user ?? ''),
+        userMetaMessages,
+        conversationMessages,
+        attachments,
+        providerHints: {
+            ...buildPromptCachingHints(cacheSafeSurface),
+            ...(params.providerHints ?? {}),
+        },
+        cacheSafeSurface,
+    };
+}
+export function materializeRequestEnvelope(envelope) {
+    const artifactSection = (() => {
+        const artifactAttachments = envelope.attachments.filter((item) => item.kind === 'artifact' && typeof item.artifactHandle === 'string' && item.artifactHandle);
+        if (artifactAttachments.length === 0)
+            return '';
+        const lines = [
+            '# Available Artifacts',
+            'Use `artifact.read` with these handles when you need the full artifact contents.',
+        ];
+        for (const item of artifactAttachments) {
+            const suffix = [
+                item.mimeType ? `mime=${item.mimeType}` : undefined,
+                typeof item.size === 'number' ? `size=${item.size}` : undefined,
+            ]
+                .filter(Boolean)
+                .join(', ');
+            lines.push(`- ${item.label ?? item.key}: ${item.artifactHandle}${suffix ? ` (${suffix})` : ''}`);
+        }
+        return lines.join('\n');
+    })();
+    const out = [
+        {
+            role: 'system',
+            content: envelope.systemSections.filter(Boolean).join('\n\n'),
+        },
+    ];
+    out.push(...envelope.userMetaMessages);
+    out.push(...envelope.conversationMessages);
+    out.push({
+        role: 'user',
+        content: artifactSection.trim().length > 0
+            ? `${String(envelope.userPrompt ?? '')}\n\n${artifactSection}`
+            : String(envelope.userPrompt ?? ''),
+    });
+    return out;
+}
+//# sourceMappingURL=request-envelope.js.map

package/dist/core/llm/shared-request-assembly.js

@@ -0,0 +1,35 @@
+import { buildArtifactHintAttachments, buildRequestEnvelope, materializeRequestEnvelope, resolveRequestArtifactHints, } from './request-envelope.js';
+export function buildSharedRequestEnvelope(args) {
+    const cacheSurface = {
+        namespace: args.defaultNamespace,
+        contextHash: args.contextHash,
+    };
+    const resolvedArtifactHints = resolveRequestArtifactHints({
+        artifactHints: args.artifactHints,
+        toolCallingAudit: args.toolCallingAudit,
+        previewProvider: args.previewProvider,
+    });
+    const envelope = buildRequestEnvelope({
+        system: args.systemPrompt,
+        user: args.userPrompt,
+        conversationContext: args.conversationContext,
+        attachments: [
+            ...(args.attachments ?? []),
+            ...buildArtifactHintAttachments(resolvedArtifactHints),
+        ],
+        providerHints: args.providerHints,
+        cacheSafeSurface: {
+            contextHash: cacheSurface.contextHash,
+            namespace: cacheSurface.namespace,
+            mode: 'cache_safe_only',
+        },
+    });
+    const baseMessages = materializeRequestEnvelope(envelope);
+    return {
+        cacheSurface,
+        resolvedArtifactHints,
+        envelope,
+        baseMessages,
+    };
+}
+//# sourceMappingURL=shared-request-assembly.js.map

package/dist/core/llm/stream-utils.js

@@ -33,12 +33,20 @@ export function mapAiSdkStreamPartToChunk(part) {
         return null;
     }
     switch (part.type) {
-        case 'text-delta':
-        case 'reasoning-delta':
-            if (typeof part.text === 'string' && part.text) {
-                return { role: 'assistant', source: 'provider', contentDelta: part.text };
+        case 'text-delta': {
+            const text = typeof part.text === 'string' ? part.text : part.delta;
+            if (typeof text === 'string' && text) {
+                return { role: 'assistant', source: 'provider', contentDelta: text };
             }
             return null;
+        }
+        case 'reasoning-delta': {
+            const text = typeof part.text === 'string' ? part.text : part.delta;
+            if (typeof text === 'string' && text) {
+                return { role: 'assistant', source: 'provider', reasoningDelta: text };
+            }
+            return null;
+        }
         case 'tool-call':
             return {
                 role: 'assistant',
@@ -51,6 +59,7 @@ export function mapAiSdkStreamPartToChunk(part) {
                             name: part.toolName || 'unknown',
                             arguments: JSON.stringify(normalizeToolInput(part.input ?? {})),
                         },
+                        ...(part.providerMetadata ? { providerMetadata: part.providerMetadata } : {}),
                     },
                 ],
             };

package/dist/core/llm/utils.js

@@ -10,32 +10,22 @@ export function formatContextForPrompt(context, options = {}) {
     }
     return formatContextForXmlPrompt(context);
 }
-export function extractJson(content) {
-    // 1. Try to find JSON block
-    const jsonBlockMatch = content.match(/```json\s*\n([\s\S]*?)\n```/);
-    if (jsonBlockMatch) {
-        try {
-            return JSON.parse(jsonBlockMatch[1]);
-        }
-        catch (__e) {
-            // Fallback to raw content if block is invalid
-        }
+export function parsePlanFromLLMContent(content) {
+    const trimmed = String(content ?? '').trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+        throw new Error(text.llm.planInvalidJson);
     }
-    // 2. Try to find anything that looks like a JSON object
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (jsonMatch) {
-        try {
-            return JSON.parse(jsonMatch[0]);
-        }
-        catch (__e) {
-            // Fallback
-        }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
     }
-    // 3. Final fallback: try parsing the whole content
-    return JSON.parse(content);
-}
-export function parsePlanFromLLMContent(content) {
-    const plan = extractJson(content);
+    catch {
+        throw new Error(text.llm.planInvalidJson);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(text.llm.planInvalidJson);
+    }
+    const plan = parsed;
     if (!plan.goal || !Array.isArray(plan.files) || !Array.isArray(plan.changes) || !plan.verify) {
         throw new Error(text.llm.planInvalid);
     }
@@ -46,10 +36,9 @@ export function extractUnifiedDiffFromLLMContent(content) {
         throw wrapPatchEmpty();
     }
     const looksLikeUnifiedDiff = (text) => {
-        return /^\s*(diff --git |--- a\/)/m.test(text);
+        return /^\s*diff --git /m.test(text);
     };
-    // 1) Prefer fenced code blocks and always pick the LAST diff-like block (LLM may generate multiple attempts).
-    // Accept both git-style (`diff --git`) and minimal unified diffs (`--- a/...` + `+++ b/...`).
+    // 1) Prefer fenced code blocks and always pick the LAST canonical diff block (LLM may generate multiple attempts).
     const fencedBlocks = [];
     const fenceRegex = /```(?:diff)?\s*\n([\s\S]*?)\n```/gi;
     let fenceMatch = null;
@@ -62,10 +51,10 @@ export function extractUnifiedDiffFromLLMContent(content) {
     if (fencedBlocks.length > 0) {
         return fencedBlocks[fencedBlocks.length - 1].trim();
     }
-    // 2) Raw diff without markdown: keep the first diff-like section.
+    // 2) Raw diff without markdown: keep the first canonical diff section.
     // In "pure diff" mode, LLMs typically return only the patch, so selecting the first marker
     // avoids accidentally dropping the leading `diff --git` header.
-    const rawStart = content.search(/^\s*(diff --git |--- a\/)/m);
+    const rawStart = content.search(/^\s*diff --git /m);
     if (rawStart !== -1)
         return content.slice(rawStart).trim();
     // Final fallback: original simple cleanup