@avocadostudio-ai/orchestrator-core 0.3.2 → 0.4.0

package/dist/chat/anthropic-planner.d.ts

@@ -77,6 +77,8 @@ export declare function generatePlanWithAnthropic(args: {
         warn: (obj: Record<string, unknown>, msg: string) => void;
     };
     forceFullSchemaContracts?: boolean;
+    /** Restrict block-schema contracts to these types. See CommonGeneratePlanArgs. */
+    contractBlockTypeAllowlist?: string[];
     componentsManifest?: BlockManifest;
     lightweight?: boolean;
     signal?: AbortSignal;
@@ -90,6 +92,12 @@ export declare function generatePlanWithAnthropic(args: {
     thinking?: {
         effort: PlannerEffort;
     };
+    /**
+     * Multiplier on the computed output-token budget. The pipeline raises it on a
+     * retry that follows a `max_tokens` truncation so the next attempt has room the
+     * previous one lacked. Clamped to the per-path ceilings above.
+     */
+    outputTokenScale?: number;
 }): Promise<{
     plan: EditPlan;
     usage: TokenUsage;

package/dist/chat/anthropic-planner.js

@@ -11,6 +11,7 @@ import { extractUsage, ZERO_USAGE } from "../telemetry/usage.js";
 import { anthropicSystemPromptWithCache, anthropicSegmentedSystemPromptWithCache, anthropicToolWithCache, ANTHROPIC_FINE_GRAINED_STREAM_HEADERS } from "./anthropic-cache.js";
 import { executeToolCall } from "../tools/runtime.js";
 import { DEFERRABLE_IMAGE_TOOLS } from "./chat-pipeline-shared.js";
+import { buildFullPageTranslationChecklist } from "./chat-pipeline-translation.js";
 // Minimum text length to treat a text-only model response as meaningful
 // content (rather than discarding it in favor of the hardcoded fallback).
 const MIN_MEANINGFUL_RESPONSE_LENGTH = 20;
@@ -30,6 +31,14 @@ function isApiLevelError(err) {
         msg.includes("billing") ||
         /\b40[0-13]\b/.test(err.message));
 }
+/**
+ * Output-token ceilings for the planner. Current Claude models (Sonnet 5, Opus 5)
+ * accept up to 128K output tokens, but the SDK only supports budgets that large
+ * on a stream — a non-streaming `messages.create` with a 64K budget can sit past
+ * the HTTP timeout. The two paths therefore get separate ceilings.
+ */
+const PLANNER_MAX_TOKENS_NON_STREAMING = 32000;
+const PLANNER_MAX_TOKENS_STREAMING = 64000;
 /**
  * Try JSON.parse, then repairAndParseJson. Returns parsed object or null.
  */
@@ -53,6 +62,49 @@ function tryParseOrRepair(buf, log, model) {
         }
     }
 }
+/**
+ * Recover a usable plan from a turn that stopped on `max_tokens`.
+ *
+ * A truncated turn still buffered every token the model emitted before it hit
+ * the ceiling, and the repair strategies close the open brackets — so a
+ * page-wide translation that ran out of room comes back as most blocks
+ * translated rather than none. The coverage check then backfills or repairs the
+ * remainder, which costs a fraction of re-running the whole generation.
+ *
+ * Returns null when nothing usable survived; the caller should then throw so the
+ * pipeline retries with a larger budget.
+ */
+function salvageTruncatedPlan(args) {
+    const parsed = args.parsed ?? (args.buffer.length > 0 ? tryParseOrRepair(args.buffer, args.log, args.model) : null);
+    if (!parsed)
+        return null;
+    // Closing open brackets can leave the final op holding a half-written string —
+    // "Под" where the model was writing "Подзаголовок" — and that would be written
+    // into the page as if it were the translation. The buffer parses cleanly only
+    // when nothing was cut mid-value, so otherwise discard the trailing op.
+    let bufferComplete = false;
+    try {
+        JSON.parse(args.buffer);
+        bufferComplete = true;
+    }
+    catch { /* truncated mid-value — trailing op is suspect */ }
+    const ops = parsed.ops;
+    if (!bufferComplete && Array.isArray(ops))
+        ops.pop();
+    const salvagedOpCount = Array.isArray(parsed.ops)
+        ? (parsed.ops).length
+        : 0;
+    if (salvagedOpCount === 0)
+        return null;
+    args.log?.warn({
+        event: "anthropic_planner_truncation_salvaged",
+        model: args.model,
+        toolJsonBufLength: args.buffer.length,
+        droppedTrailingOp: !bufferComplete,
+        opCount: salvagedOpCount
+    }, "Anthropic planner: salvaged a partial plan from the truncated stream");
+    return parsed;
+}
 // ---------------------------------------------------------------------------
 // Singleton Anthropic client — reuses HTTP/2 connection pool across requests.
 // Lazily initialized on first use so module-level import doesn't throw if
@@ -228,14 +280,50 @@ export async function generatePlanWithAnthropic(args) {
             pageWideTranslation,
             legacyIncludeContracts: includeContracts,
             forceFullContracts: args.forceFullSchemaContracts,
-            componentsManifest: args.componentsManifest
+            componentsManifest: args.componentsManifest,
+            contractBlockTypeAllowlist: args.contractBlockTypeAllowlist
         });
+    // A full-page translation is a coverage problem, not a writing problem: the
+    // model reliably translates what it looks at, and the failures are sections it
+    // never looked at. "Translate all blocks" leaves it to infer the scope from the
+    // outline; an enumerated checklist with a count makes a forgotten section
+    // visible to the model itself, which is cheaper than catching it afterwards.
+    // Per-request, so it rides in the user turn and leaves the cached system
+    // prefix untouched.
+    const translationChecklist = pageWideTranslation
+        ? buildFullPageTranslationChecklist(args.currentPage)
+        : null;
     const user = {
         request: args.message,
         audienceHint: audienceHint ?? null,
         slug: args.slug,
         contextPack: args.contextPack,
         ...schemaContext.payload,
+        ...(translationChecklist && translationChecklist.length > 0
+            ? {
+                translationChecklist: {
+                    instruction: `This page has ${translationChecklist.length} blocks carrying text that must be translated. ` +
+                        `Emit an update_props op for EVERY blockId listed below and translate EVERY field path listed under it. ` +
+                        `Before you finish, count your ops: fewer than ${translationChecklist.length} means you skipped a section — go back and add it. ` +
+                        // The engine deep-merges list rows by index, so a row may carry only
+                        // the keys being translated — but it merges positionally, so a short
+                        // array truncates the list. Echoing whole rows is the expensive
+                        // failure (it doubled one CardGrid chunk's output); dropping rows is
+                        // the destructive one.
+                        `For list fields (paths like items[0].q), send EVERY row of the array in its original order, ` +
+                        `but inside each row include ONLY the fields you translated — omitted keys keep their current values, ` +
+                        `while omitted rows would delete list entries. ` +
+                        // "Leave URL-like fields alone" read as "leave ctaText alone" too, and
+                        // four card buttons stayed in English while their titles translated.
+                        // Destination vs. label is the distinction that matters, so name both
+                        // sides rather than describing one of them.
+                        `Leave DESTINATIONS out of the patch entirely — ctaHref, href, url, imageUrl, and any id. ` +
+                        `But LABELS are visible text and must be translated like any other string, including ctaText and secondaryCtaText: ` +
+                        `ctaText is the words on the button, not the link it points at.`,
+                    blocks: translationChecklist
+                }
+            }
+            : {}),
         feedback: args.feedback ?? null
     };
     const imageUrlForVision = typeof args.contextPack.selected?.imageUrlForVision === "string"
@@ -320,7 +408,31 @@ export async function generatePlanWithAnthropic(args) {
     const effortParam = thinkingParam ? args.thinking.effort : undefined;
     // Adaptive thinking counts thinking tokens against max_tokens; give headroom so
     // the actual response isn't truncated. Effort (not max_tokens) governs spend.
-    const plannerMaxTokens = thinkingParam ? 16000 : 8192;
+    const baseMaxTokens = thinkingParam ? 16000 : 8192;
+    // Whole-page translations and rewrites re-emit every translatable string on the
+    // page inside an op envelope, so their output length scales with the page — a
+    // flat budget truncates them.
+    //
+    // Size these from the page, and size them generously: `max_tokens` is a ceiling,
+    // not a reservation, so over-asking costs nothing while under-asking costs a
+    // whole extra generation. "translate this page to russian" on an 8.3 KB page
+    // needed 9139 output tokens and was budgeted 8772 — a 4% miss that cost 78
+    // seconds of retry. The estimate has to hold for the worst case, not the median:
+    //   - ~3x the page's own JSON, because the op envelope repeats
+    //     op/pageSlug/blockId/patch per block on top of the text itself, and target
+    //     languages run longer than the English source.
+    //   - ~2.5 bytes/token, not the ~4 that English averages: Cyrillic, Greek, and
+    //     CJK tokenize far denser, which is exactly the case that truncates.
+    const wholePageEdit = pageWideTranslation || pageWideRewrite;
+    const wholePageBudget = wholePageEdit
+        ? Math.ceil((JSON.stringify(args.currentPage).length * 3) / 2.5) + (thinkingParam ? 24000 : 8000)
+        : 0;
+    // The pipeline raises this on a retry that follows a truncation, so attempt N+1
+    // doesn't reproduce attempt N's failure with an identical budget.
+    const outputTokenScale = Math.max(1, args.outputTokenScale ?? 1);
+    const requestedMaxTokens = Math.ceil(Math.max(baseMaxTokens, wholePageBudget) * outputTokenScale);
+    const plannerMaxTokens = Math.min(requestedMaxTokens, PLANNER_MAX_TOKENS_NON_STREAMING);
+    const plannerStreamMaxTokens = Math.min(requestedMaxTokens, PLANNER_MAX_TOKENS_STREAMING);
     // Collapsed request params spread into every tool-loop create/stream call.
     // effort rides inside output_config alongside thinking; only the constrained-
     // decoding fallback (thinking OFF) sets output_config.format instead.
@@ -395,10 +507,13 @@ export async function generatePlanWithAnthropic(args) {
         for (let turn = 0; turn < maxToolTurns; turn += 1) {
             let response;
             let emittedTextDeltas = false;
+            // Mirrors the submit_edit_plan tool JSON streamed this turn, hoisted out of
+            // the stream branch so the max_tokens handler below can salvage from it.
+            let submitToolJsonBuf = "";
             if (client.messages.stream) {
                 const stream = client.messages.stream({
                     model: args.model,
-                    max_tokens: plannerMaxTokens,
+                    max_tokens: plannerStreamMaxTokens,
                     system: cachedSystem,
                     tools: toolDefs,
                     tool_choice: submitToolChoice,
@@ -460,6 +575,7 @@ export async function generatePlanWithAnthropic(args) {
                             continue;
                         const nextBuf = (submitToolJsonByIndex.get(idx) ?? "") + (event.delta.partial_json ?? "");
                         submitToolJsonByIndex.set(idx, nextBuf);
+                        submitToolJsonBuf = nextBuf;
                         emitProgressFromToolJson(nextBuf);
                     }
                 }
@@ -530,9 +646,25 @@ export async function generatePlanWithAnthropic(args) {
                     model: args.model,
                     stopReason: "max_tokens",
                     turn,
+                    toolJsonBufLength: submitToolJsonBuf.length,
                     contentBlockTypes: response.content.map((b) => b.type)
-                }, "Anthropic planner: response truncated (max_tokens) during tool loop");
-                throw new Error("Model response was truncated (max_tokens reached)");
+                }, "Anthropic planner: response truncated (max_tokens) during tool loop — attempting salvage");
+                const truncatedToolBlock = response.content
+                    .map((block) => asToolUseBlock(block))
+                    .find((block) => block?.name === "submit_edit_plan");
+                const salvaged = salvageTruncatedPlan({
+                    parsed: truncatedToolBlock?.input && typeof truncatedToolBlock.input === "object"
+                        ? truncatedToolBlock.input
+                        : undefined,
+                    buffer: submitToolJsonBuf,
+                    log: args.log,
+                    model: args.model
+                });
+                // Nothing parseable survived — let the caller retry with a bigger budget.
+                if (!salvaged)
+                    throw new Error("Model response was truncated (max_tokens reached)");
+                parsed = salvaged;
+                break;
             }
             if (args.onToken && !emittedTextDeltas) {
                 for (const block of response.content) {
@@ -679,8 +811,22 @@ export async function generatePlanWithAnthropic(args) {
                 content: toolResults
             });
         }
+        // Path 2: streaming. Chosen whenever *any* incremental callback is listening,
+        // not just `onToken`.
+        //
+        // Testing `onToken` alone conflated two different questions: "is a human
+        // watching prose arrive" and "does someone need the ops as they are parsed".
+        // A chunked full-page translation separates them — prose callbacks go to the
+        // first chunk only, because six chunks streaming six summaries into one
+        // message box reads as a stutter — so every other chunk fell through to the
+        // non-streaming `messages.create` below and never fired `onPlannedOp`. Those
+        // chunks' ops reached the merged plan but never reached the pipeline's
+        // streamed per-op apply, which then reported the partial stream as a finished
+        // apply and skipped the rest of the plan. A page-wide translation applied the
+        // first chunk's blocks, left the other five in the source language, and said
+        // it had translated the page.
     }
-    else if (args.onToken) {
+    else if (args.onToken || args.onPlannedOp || args.onFieldDraft || args.onSummaryChunk || args.onChangeLogEntry) {
         let toolJsonBuf = "";
         let textBuf = "";
         if (client.messages.stream) {
@@ -689,7 +835,7 @@ export async function generatePlanWithAnthropic(args) {
             // before emitting the tool call.
             const stream = client.messages.stream({
                 model: args.model,
-                max_tokens: plannerMaxTokens,
+                max_tokens: plannerStreamMaxTokens,
                 system: cachedSystem,
                 tools: [anthropicToolWithCache(submitPlanToolDef)],
                 tool_choice: thinkingParam
@@ -738,7 +884,7 @@ export async function generatePlanWithAnthropic(args) {
                         }
                         else if (event.delta?.type === "text_delta") {
                             textBuf += event.delta.text ?? "";
-                            args.onToken(event.delta.text ?? "");
+                            args.onToken?.(event.delta.text ?? "");
                         }
                     }
                 }
@@ -757,6 +903,7 @@ export async function generatePlanWithAnthropic(args) {
             }
             // If stream completed normally, try finalMessage() for validated tool input.
             // Skip if stream threw — finalMessage() would also fail.
+            let streamTruncated = false;
             if (!streamLoopError) {
                 let finalMessage;
                 try {
@@ -764,14 +911,16 @@ export async function generatePlanWithAnthropic(args) {
                     usage = extractUsage(finalMessage);
                     const streamStopReason = finalMessage?.stop_reason;
                     if (streamStopReason === "max_tokens") {
+                        // Don't throw yet — the buffer below usually holds a nearly-complete
+                        // plan. Record it and let the repair fallback try to salvage one.
+                        streamTruncated = true;
                         args.log?.warn({
                             event: "anthropic_planner_truncated",
                             model: args.model,
                             stopReason: streamStopReason,
                             toolJsonBufLength: toolJsonBuf.length,
                             textBufLength: textBuf.length
-                        }, "Anthropic planner: response truncated (max_tokens)");
-                        throw new Error("Model response was truncated (max_tokens reached)");
+                        }, "Anthropic planner: response truncated (max_tokens) — attempting salvage from streamed buffer");
                     }
                     const finalToolBlock = finalMessage.content
                         ?.map((block) => asToolUseBlock(block))
@@ -781,8 +930,6 @@ export async function generatePlanWithAnthropic(args) {
                     }
                 }
                 catch (finalMsgErr) {
-                    if (finalMsgErr instanceof Error && finalMsgErr.message.includes("max_tokens"))
-                        throw finalMsgErr;
                     args.log?.warn({
                         event: "anthropic_planner_final_message_failed",
                         model: args.model,
@@ -811,6 +958,13 @@ export async function generatePlanWithAnthropic(args) {
                     }
                 }
             }
+            if (streamTruncated) {
+                const salvaged = salvageTruncatedPlan({ parsed, buffer: toolJsonBuf, log: args.log, model: args.model });
+                // Nothing parseable survived — let the caller retry with a bigger budget.
+                if (!salvaged)
+                    throw new Error("Model response was truncated (max_tokens reached)");
+                parsed = salvaged;
+            }
         }
         else {
             const response = await client.messages.create({

package/dist/chat/chat-pipeline-translation.d.ts

@@ -18,6 +18,19 @@ export declare function findExplicitCtaTargetCoverageGap(args: {
     currentPage: PageDoc;
     slug: string;
 }): string | null;
+/**
+ * The checklist a full-page translation has to satisfy, block by block.
+ *
+ * Telling the planner "translate all blocks" is not the same as telling it which
+ * blocks exist — prose scope is easy to under-read, and a forgotten section
+ * looks identical to a section that was never in scope. This enumerates the work
+ * so the model can be held to a count it can see.
+ */
+export declare function buildFullPageTranslationChecklist(page: PageDoc): {
+    blockId: string;
+    blockType: string;
+    fields: string[];
+}[];
 export declare function findFullPageTranslationCoverageGap(args: {
     plan: EditPlan;
     message: string;

package/dist/chat/chat-pipeline-translation.js

@@ -228,6 +228,64 @@ export function findExplicitCtaTargetCoverageGap(args) {
     }
     return null;
 }
+/** Field kinds whose values are prose and must be translated. */
+function isTranslatableKind(kind) {
+    return kind === "text" || kind === "richtext" || kind === "imageAlt";
+}
+/**
+ * The translatable surface of one block: which top-level props and which
+ * list-child fields carry prose. One definition, used both to tell the planner
+ * what it must cover and to check afterwards whether it did.
+ */
+function translatableFieldKeys(meta) {
+    const topLevel = Object.entries(meta?.fields ?? {})
+        .filter(([, fm]) => isTranslatableKind(fm.kind))
+        .map(([key]) => key);
+    const lists = Object.entries(meta?.listFields ?? {})
+        .map(([listKey, listMeta]) => [
+        listKey,
+        Object.entries(listMeta.itemFields ?? {})
+            .filter(([, fm]) => isTranslatableKind(fm.kind))
+            .map(([key]) => key)
+    ])
+        .filter(([, itemFields]) => itemFields.length > 0);
+    return { topLevel, lists };
+}
+/**
+ * The checklist a full-page translation has to satisfy, block by block.
+ *
+ * Telling the planner "translate all blocks" is not the same as telling it which
+ * blocks exist — prose scope is easy to under-read, and a forgotten section
+ * looks identical to a section that was never in scope. This enumerates the work
+ * so the model can be held to a count it can see.
+ */
+export function buildFullPageTranslationChecklist(page) {
+    const blockMeta = getAllBlockMeta();
+    const entries = [];
+    for (const block of page.blocks) {
+        const { topLevel, lists } = translatableFieldKeys(blockMeta[block.type]);
+        const props = block.props;
+        const fields = topLevel.filter((key) => isNonEmptyString(props[key]));
+        for (const [listKey, itemFields] of lists) {
+            const listValue = props[listKey];
+            if (!Array.isArray(listValue))
+                continue;
+            for (let idx = 0; idx < listValue.length; idx += 1) {
+                const item = listValue[idx];
+                if (!item || typeof item !== "object" || Array.isArray(item))
+                    continue;
+                const row = item;
+                for (const field of itemFields) {
+                    if (isNonEmptyString(row[field]))
+                        fields.push(`${listKey}[${idx}].${field}`);
+                }
+            }
+        }
+        if (fields.length > 0)
+            entries.push({ blockId: block.id, blockType: String(block.type), fields });
+    }
+    return entries;
+}
 export function findFullPageTranslationCoverageGap(args) {
     if (inferTranslationScopeFromMessage(args.message) !== "page")
         return null;
@@ -244,47 +302,38 @@ export function findFullPageTranslationCoverageGap(args) {
         .filter((id) => typeof id === "string" && id.length > 0));
     if (touchedBlockIds.size === 0)
         return null;
+    // Every block is checked, not just the ones the plan touched. Scoping this to
+    // touchedBlockIds meant a block the model skipped *entirely* was invisible to
+    // the coverage check — a page-wide translation could leave a whole FAQ section
+    // in English and still report full coverage, because the section it forgot was
+    // also the section it was never asked about.
     const missingPaths = [];
     for (const block of args.currentPage.blocks) {
-        if (!touchedBlockIds.has(block.id))
-            continue;
-        const meta = blockMeta[block.type];
+        const { topLevel: translatableTopLevel, lists: translatableLists } = translatableFieldKeys(blockMeta[block.type]);
         // --- Top-level scalar prop coverage ---
-        if (meta?.fields) {
-            const translatableTopLevel = Object.entries(meta.fields)
-                .filter(([, fm]) => fm.kind === "text" || fm.kind === "richtext" || fm.kind === "imageAlt")
-                .map(([key]) => key);
-            if (translatableTopLevel.length > 0) {
-                const coveredTopLevel = new Set();
-                for (const op of args.plan.ops) {
-                    if (!("pageSlug" in op) || op.pageSlug !== args.slug)
-                        continue;
-                    if (op.op === "update_props" && op.blockId === block.id) {
-                        const patch = normalizeUpdatePropsPatch(op);
-                        for (const key of translatableTopLevel) {
-                            if (isNonEmptyString(patch[key]))
-                                coveredTopLevel.add(key);
-                        }
+        if (translatableTopLevel.length > 0) {
+            const coveredTopLevel = new Set();
+            for (const op of args.plan.ops) {
+                if (!("pageSlug" in op) || op.pageSlug !== args.slug)
+                    continue;
+                if (op.op === "update_props" && op.blockId === block.id) {
+                    const patch = normalizeUpdatePropsPatch(op);
+                    for (const key of translatableTopLevel) {
+                        if (isNonEmptyString(patch[key]))
+                            coveredTopLevel.add(key);
                     }
                 }
-                const blockProps = block.props;
-                for (const key of translatableTopLevel) {
-                    if (!isNonEmptyString(blockProps[key]))
-                        continue;
-                    if (!coveredTopLevel.has(key))
-                        missingPaths.push(`${block.id}.${key}`);
-                }
+            }
+            const blockProps = block.props;
+            for (const key of translatableTopLevel) {
+                if (!isNonEmptyString(blockProps[key]))
+                    continue;
+                if (!coveredTopLevel.has(key))
+                    missingPaths.push(`${block.id}.${key}`);
             }
         }
         // --- List field child coverage ---
-        const listFields = meta?.listFields ?? {};
-        const listEntries = Object.entries(listFields);
-        for (const [listKey, listMeta] of listEntries) {
-            const translatableItemFields = Object.entries(listMeta.itemFields ?? {})
-                .filter(([, fieldMeta]) => fieldMeta.kind === "text" || fieldMeta.kind === "richtext" || fieldMeta.kind === "imageAlt")
-                .map(([key]) => key);
-            if (translatableItemFields.length === 0)
-                continue;
+        for (const [listKey, translatableItemFields] of translatableLists) {
             const listValue = block.props[listKey];
             if (!Array.isArray(listValue) || listValue.length === 0)
                 continue;
@@ -350,9 +399,17 @@ export function findFullPageTranslationCoverageGap(args) {
     }
     if (missingPaths.length === 0)
         return null;
-    // Auto-patch: fill missing fields with original (untranslated) values rather than failing.
-    // This ensures partial LLM translations still apply — untranslated text is better than no translation.
+    // Auto-patch: where the plan already edits a block but left one of its fields
+    // out, fill that field with the original (untranslated) value rather than
+    // failing — a partially translated block still applies, and untranslated text
+    // beats losing the field.
+    //
+    // A block the plan never touched is a different case: there is no op to patch
+    // into, and writing the English back would be a no-op that papers over the
+    // miss. Those paths stay unresolved and are reported, so the caller can ask
+    // the model for the translation it skipped.
     let patched = 0;
+    const unresolved = [];
     for (const path of missingPaths) {
         // Parse path: "b_hero_1.heading" or "b_cardgrid_7.cards[0].imageAlt"
         const topMatch = path.match(/^([^.]+)\.([^[]+)$/);
@@ -374,6 +431,9 @@ export function findFullPageTranslationCoverageGap(args) {
                     patched++;
                 }
             }
+            else {
+                unresolved.push(path);
+            }
         }
         else if (listMatch) {
             const [, blockId, listKey, indexStr, field] = listMatch;
@@ -390,23 +450,27 @@ export function findFullPageTranslationCoverageGap(args) {
                 continue;
             // Find the existing update_props op and patch the list item
             const existingOp = args.plan.ops.find(op => op.op === "update_props" && "blockId" in op && op.blockId === blockId && "pageSlug" in op && op.pageSlug === args.slug);
-            if (existingOp && "patch" in existingOp) {
-                const patch = existingOp.patch;
-                if (Array.isArray(patch[listKey]) && patch[listKey][idx] && typeof patch[listKey][idx] === "object") {
-                    const itemPatch = patch[listKey][idx];
-                    if (!isNonEmptyString(itemPatch[field])) {
-                        itemPatch[field] = originalValue;
-                        patched++;
-                    }
+            const patch = existingOp && "patch" in existingOp ? existingOp.patch : null;
+            const itemPatch = patch && Array.isArray(patch[listKey]) && patch[listKey][idx] && typeof patch[listKey][idx] === "object"
+                ? patch[listKey][idx]
+                : null;
+            if (itemPatch) {
+                if (!isNonEmptyString(itemPatch[field])) {
+                    itemPatch[field] = originalValue;
+                    patched++;
                 }
             }
+            else {
+                unresolved.push(path);
+            }
         }
     }
     if (patched > 0) {
         console.log(`[translation-coverage] Auto-patched ${patched} missing fields with original values`);
-        return null; // Patched — no gap anymore
     }
-    return `Invalid full-page translation coverage. Missing translated fields: ${missingPaths.join(", ")}`;
+    if (unresolved.length === 0)
+        return null;
+    return `Invalid full-page translation coverage. Missing translated fields: ${unresolved.join(", ")}`;
 }
 export function normalizeVariationTypos(text) {
     return text

package/dist/chat/chat-pipeline.d.ts

@@ -9,7 +9,7 @@ import { generatePlanWithAnthropic, parseIntentWithAnthropic } from "./anthropic
 import { generatePlanWithGemini, parseIntentWithGemini } from "./gemini-planner.ts";
 import { type ThinkingEvent } from "./planner-types.ts";
 export { sentenceCase, firstUrlFromText, preferredImageAltText, collectMentionedSlugsFromPlan, collectMentionedSlugsFromOps, normalizePlanCopyForUi, futureToPastTense } from "./chat-pipeline-ui.ts";
-export { sanitizeMessageForPlanning, inferTranslationScopeFromMessage, isNonEmptyString, findFullPageTranslationCoverageGap, findExplicitCtaTargetCoverageGap, parseCloneAndTranslateRequest, type CloneAndTranslateRequest, type TranslationScope } from "./chat-pipeline-translation.ts";
+export { sanitizeMessageForPlanning, inferTranslationScopeFromMessage, isNonEmptyString, findFullPageTranslationCoverageGap, buildFullPageTranslationChecklist, findExplicitCtaTargetCoverageGap, parseCloneAndTranslateRequest, type CloneAndTranslateRequest, type TranslationScope } from "./chat-pipeline-translation.ts";
 export { shouldPreferFastModelForMessage, shouldUseLlmIntentRouter, compactPlannerContextPack, minimalPlannerContextPack, shouldUseMinimalPlannerContext, shouldPreferFocusedTranslation, shouldEnableReasoningForMessage } from "./chat-pipeline-context.ts";
 export { isRewriteLikeMessage, isPerformanceAwareMessage, isLikelyTextField, collectChangedTextFields, buildMetaChangeLogEntries, buildAiInsightChanges, buildOpChangeLogEntries, deterministicCreatePagePlan, deterministicDuplicatePagePlan, deterministicSelectedTextRewritePlan, shouldReturnDeterministicClarification, fmtSlug } from "./chat-pipeline-deterministic.ts";
 export { blockHasImageUrlProp, parsePath, getValueAtPath, setValueAtPath, deleteValueAtPath, extractIndexedQueries, extractReferencedItemIndices, blockSupportsImageAtPath, detectImagePaths, imageQueryFromItem, shouldPopulateAllChildImages, findImageTargets, rewriteAddBlockToChildImageUpdate, withUnsplashHeroImage, shouldResolveCreatePageHeroImage, resolveHeroImageForCreatePage, detectImageOps } from "./chat-pipeline-image.ts";