@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/nlp/deterministic-planner.js

@@ -0,0 +1,1631 @@
+import { z } from "zod";
+import { allowedBlockTypes, getBlockMeta, IMAGE_PLACEHOLDER } from "@avocadostudio-ai/shared";
+import { extractRouteMentions, normalizeRouteCandidate, parseCreatePageRequest, requestsContentGeneration, toSeedSlug } from "./intent-helpers.js";
+import { isBatchAddRequest, isFieldContentUpdateRequest, stripSiteContextEnvelope, stripPositionalAnchorPhrase, extractMentionedBlockTypes, hasCrossPageScope } from "./intent-detection.js";
+import { defaultPropsForType, inferBlockTypeFromText, nextBlockId } from "./plan-normalizer.js";
+import { getSessionDraft, getSiteConfig } from "../state/session-state.js";
+import { inferAddedBlockTypeFromMessage, resolveBlockRef, ordinalToIndex, resolveReferencesFromMessage } from "./deterministic-planner-refs.js";
+import { EXCEPT_PATTERN, THIS_ONE_PATTERN } from "./intent-patterns.js";
+import { extractAudienceTargets, titleCaseWords, audiencePatchForBlock, coercePatchForBlock, inferSimpleFieldPatchFromMessage, isRewriteRequest, shouldKeepRichTextTitleOnTranslate, inferFieldHintFromMessage, coercePatchForEditablePath, quotedText, buildListAppendPatch } from "./deterministic-planner-patches.js";
+import { userFacingPropNames } from "./deterministic-planner-suggestions.js";
+import { st } from "../chat/locale-strings.js";
+import { buildCreatePagePlan, isPageRouteRenameRequest } from "./deterministic-planner-pages.js";
+const CONTAINER_BLOCK_TYPES = /\b(carousel|slideshow|slider|cardgrid|card\s*grid|faqaccordion|faq|testimonials?|featuregrid|feature\s*grid|gallery|tabs?|table)\b/i;
+// User-facing block label ("FAQ Accordion", not the raw "FAQAccordion" type).
+// change_log/summary text ships on the MCP + HTTP API and persists into chat
+// history, so it must read cleanly. Mirrors describeOp in the changelog validator.
+// (Raw block IDs interpolated here used to be blanked by the id-stripper, leaving
+// "Removed ." / "Appended item to ." — issue #14a; raw types leaked as
+// "FAQAccordion" — #15a.)
+function blockLabel(type) {
+    return getBlockMeta(type)?.displayName ?? type;
+}
+// "tab"/"slide"/"row" are LIST ITEMS that only exist inside a container block, so
+// "add a tab …" / "add a slide …" map to the container's type. Without this the
+// generic block-type scan picks an incidental label keyword ("a tab called
+// Pricing" → CardGrid) instead of Tabs (#22). "stat" is covered by the existing
+// Stats keyword. Anchored to "add … <item>" so it doesn't fire on prose mentions.
+const ITEM_WORD_TO_CONTAINER = [
+    { test: /\b(?:add|insert)\b[^.]*?\btabs?\b/, type: "Tabs" },
+    { test: /\b(?:add|insert)\b[^.]*?\bslides?\b/, type: "Carousel" },
+    { test: /\b(?:add|insert)\b[^.]*?\brows?\b/, type: "Table" }
+];
+function inferItemContainerType(message) {
+    const lower = message.toLowerCase();
+    return ITEM_WORD_TO_CONTAINER.find((e) => e.test.test(lower))?.type;
+}
+// Container nouns that inferBlockTypeFromText doesn't recognise on their own ("the
+// classes grid" → CardGrid, "the faq accordion" → FAQAccordion). Used when resolving
+// the TARGET of an "add X to the <container>" phrase (#28).
+const CONTAINER_NOUN_TO_TYPE = [
+    { test: /\bgrids?\b/, type: "CardGrid" },
+    { test: /\baccordion\b/, type: "FAQAccordion" },
+    { test: /\bcarousel\b|\bsliders?\b/, type: "Carousel" },
+    { test: /\bgaller(?:y|ies)\b/, type: "Gallery" },
+    { test: /\btabs?\b/, type: "Tabs" },
+    { test: /\btables?\b/, type: "Table" }
+];
+function inferContainerTypeFromNoun(phrase) {
+    const lower = phrase.toLowerCase();
+    return CONTAINER_NOUN_TO_TYPE.find((e) => e.test.test(lower))?.type;
+}
+/** Detects "remove X from/in [container]" or "remove X from slides/items/cards" — intra-block, not page-level */
+function isContainerScopedRemove(message) {
+    const lower = message.toLowerCase();
+    if (/\b(?:from|in|within|inside)\b/.test(lower) && CONTAINER_BLOCK_TYPES.test(lower))
+        return true;
+    if (/\b(?:from|in|within)\s+(?:all\s+)?(?:slides?|items?|cards?|questions?|entries?|rows?|features?)\b/.test(lower))
+        return true;
+    return false;
+}
+export const blockTypeEnum = z.enum(allowedBlockTypes);
+export const intentSchema = z.object({
+    action: z.enum(["add", "move", "update", "remove", "info", "clarify"]),
+    target_block_ref: z.string().min(1).nullish(),
+    target_block_type: blockTypeEnum.nullish(),
+    new_block_type: blockTypeEnum.nullish(),
+    position: z.enum(["top", "bottom", "before", "after"]).nullish(),
+    anchor_block_ref: z.string().min(1).nullish(),
+    patch: z.record(z.string(), z.unknown()).nullish(),
+    summary: z.string().min(1).nullish(),
+    assumption: z.string().min(1).nullish(),
+    complexity: z.enum(["simple", "standard", "complex"]).nullish()
+});
+/** Returns true when an add-block message carries content direction beyond the block type name. */
+function hasContentDirective(message) {
+    const lower = message.toLowerCase();
+    // Phrases that signal the user wants specific content, not just a default block
+    return /\b(about|featuring|directing|promoting|highlighting|explaining|describing|marketing|showcasing|illustrating|linking to|that\s+(links?|points?|directs?|promotes?|describes?|shows?|explains?))\b/i.test(lower)
+        || /\bfor\b.*\b(audience|users?|visitors?|customers?|readers?)\b/i.test(lower)
+        || /\bwith\b.*\b(content|text|copy|images?|questions?|items?|cards?|testimonials?|features?)\b/i.test(lower)
+        || /\b(proper|real|good|relevant|meaningful|appropriate|custom|tailored|compelling|engaging)\b/i.test(lower);
+}
+function isHeroLayoutRequest(message) {
+    const lower = message.toLowerCase();
+    if (!/\b(hero|banner)\b/.test(lower))
+        return false;
+    const mentionsVisual = /\b(image|photo|picture|text|copy|content)\b/.test(lower);
+    const mentionsSide = /\b(left|right|left-side|right-side)\b/.test(lower);
+    const mentionsSwap = /\b(swap|flip|reverse)\b/.test(lower) && /\b(image|photo|picture)\b/.test(lower) && /\b(text|copy|content)\b/.test(lower);
+    return (mentionsVisual && mentionsSide) || mentionsSwap;
+}
+function hasQuotedConstraintOnlyText(message) {
+    if (!quotedText(message))
+        return false;
+    return (/\b(?:avoid|without|exclude|ban|forbid|never use|do not use|don't use)\b[^.\n]{0,140}["'][^"']+["']/i.test(message) ||
+        /\b(?:avoid|without|exclude)\b[^.\n]{0,140}\b(?:cliche|cliches|buzzword|buzzwords)\b[^.\n]{0,140}["'][^"']+["']/i.test(message));
+}
+function hasQuotedReplacementDirective(message) {
+    return /\b(?:set|change|update|edit|replace|rewrite|reword|rephrase)\b[^.\n]{0,160}\b(?:to|as|with)\b[^.\n]{0,40}["'][^"']+["']/i.test(message);
+}
+// Whole-section/block nouns that make "hide X" mean "remove the block" (#31).
+const HIDE_BLOCK_NOUN = /\b(sections?|blocks?|grids?|card\s*grids?|feature\s*grids?|testimonials?|hero|cta|faq|accordion|carousel|gallery|banner|two[\s-]?columns?|tabs?|table)\b/;
+// A field noun means "hide X" targets something INSIDE a block (its image, copy,
+// CTA, …), not the block itself — must NOT route to the destructive block delete.
+const HIDE_FIELD_NOUN = /\b(image|images|photo|photos|picture|pictures|logo|logos|icon|icons|heading|headline|subheading|subtitle|caption|captions|label|labels|price|prices|paragraph|paragraphs|button|buttons|link|links|field|fields)\b/;
+// A block noun used as the object of a locative preposition ("… on/in the hero")
+// is the CONTAINER of the real target, not the target — defer.
+const HIDE_FIELD_IN_BLOCK = /\b(?:on|in|of|from|within|inside)\s+(?:the\s+)?(?:sections?|blocks?|grids?|card\s*grids?|feature\s*grids?|testimonials?|hero|cta|faq|accordion|carousel|gallery|banner|two[\s-]?columns?|tabs?|table)\b/;
+function inferActionFromMessage(message) {
+    const lower = message.toLowerCase();
+    const hasPageCreateCue = Boolean(parseCreatePageRequest(message));
+    if (isHeroLayoutRequest(lower))
+        return "update";
+    if (hasPageCreateCue)
+        return "add";
+    // "add X in/to [the Y] heading/subheading/copy/..." → update to a field, not add.
+    // Must run before the generic verb-position pass so "add" does not win.
+    if (isFieldContentUpdateRequest(message))
+        return "update";
+    // "hide the third section" / "hide the testimonials block" — the editor has no
+    // visibility toggle, so hiding a whole section means removing it. Route "hide" to
+    // remove ONLY when it targets a WHOLE section/block — never a field inside one.
+    // "hide the hero image" / "hide the hero subheading" / "hide the cta on the hero"
+    // all name a block noun but mean "clear a field", and routing them here deletes
+    // the entire block at high confidence (auto-applied). When a field noun appears,
+    // or a block noun is the object of a locative preposition ("… on/in the hero"),
+    // the target is something INSIDE the block, so defer to the LLM instead of the
+    // destructive block-removal path. (#31, and the field-hide regression.)
+    if (/\bhide\b/.test(lower) && HIDE_BLOCK_NOUN.test(lower) && !HIDE_FIELD_NOUN.test(lower) && !HIDE_FIELD_IN_BLOCK.test(lower)) {
+        return "remove";
+    }
+    // Use earliest-verb-position to resolve ambiguity (e.g., "add a delete button" → "add")
+    const verbPatterns = [
+        { action: "remove", pattern: /\b(remove|delete)\b/ },
+        { action: "move", pattern: /\b(move|reorder|re-arrange|rearrange)\b/ },
+        { action: "add", pattern: /\b(add|insert|create|include|put)\b/ },
+        { action: "update", pattern: /\b(update|change|edit|set|rewrit\w*|reword\w*|rephras\w*|replace|improve|shorten|reduc\w*|trim|cut|polish\w*|refin\w*|refresh\w*|tighten\w*|clarif\w*|rename)\b/ },
+    ];
+    let earliest = null;
+    for (const { action, pattern } of verbPatterns) {
+        const match = pattern.exec(lower);
+        if (match && (earliest === null || match.index < earliest.index)) {
+            earliest = { action, index: match.index };
+        }
+    }
+    if (earliest)
+        return earliest.action;
+    if (/\bad\b/.test(lower) && inferBlockTypeFromText(lower))
+        return "add";
+    return null;
+}
+function inferPatchFromMessage(args) {
+    const { message, action, targetBlock, activeEditablePath } = args;
+    if (action !== "update")
+        return undefined;
+    const heroImagePositionPatch = inferHeroImagePositionPatch(message, targetBlock);
+    if (heroImagePositionPatch)
+        return heroImagePositionPatch;
+    const directPatch = inferSimpleFieldPatchFromMessage(message);
+    if (directPatch && Object.keys(directPatch).length > 0)
+        return directPatch;
+    const quoted = quotedText(message);
+    if (!quoted)
+        return undefined;
+    if (activeEditablePath && /^[a-zA-Z0-9_]+$/.test(activeEditablePath)) {
+        return { [activeEditablePath]: quoted };
+    }
+    const block = targetBlock;
+    if (!block)
+        return undefined;
+    const allowedKeys = Object.keys(block.props);
+    if (allowedKeys.length === 0)
+        return undefined;
+    const hintedKey = inferFieldHintFromMessage(message, allowedKeys);
+    if (!hintedKey)
+        return undefined;
+    return { [hintedKey]: quoted };
+}
+function inferHeroImagePositionPatch(message, targetBlock) {
+    if (!targetBlock || targetBlock.type !== "Hero")
+        return null;
+    const lower = message.toLowerCase();
+    const asksSwapImageAndText = (/\bswap\b/.test(lower) || /\bflip\b/.test(lower) || /\breverse\b/.test(lower)) &&
+        /\b(image|photo|picture)\b/.test(lower) &&
+        /\b(text|copy|content)\b/.test(lower);
+    if (asksSwapImageAndText) {
+        const current = String(targetBlock.props.imagePosition ?? "right");
+        return { imagePosition: current === "left" ? "right" : "left" };
+    }
+    if (/\b(image|photo|picture)\b[\s\w-]*\b(?:on|to)\s+the\s+left\b/.test(lower) ||
+        /\b(?:left|left-side)\s+(?:image|photo|picture)\b/.test(lower) ||
+        /\b(?:image|photo|picture)\s+(?:left|left-side)\b/.test(lower)) {
+        return { imagePosition: "left" };
+    }
+    if (/\b(image|photo|picture)\b[\s\w-]*\b(?:on|to)\s+the\s+right\b/.test(lower) ||
+        /\b(?:right|right-side)\s+(?:image|photo|picture)\b/.test(lower) ||
+        /\b(?:image|photo|picture)\s+(?:right|right-side)\b/.test(lower)) {
+        return { imagePosition: "right" };
+    }
+    if (/\b(text|copy|content)\b[\s\w-]*\b(?:on|to)\s+the\s+left\b/.test(lower) ||
+        /\b(?:left|left-side)\s+(?:text|copy|content)\b/.test(lower) ||
+        /\b(?:text|copy|content)\s+(?:left|left-side)\b/.test(lower)) {
+        return { imagePosition: "right" };
+    }
+    if (/\b(text|copy|content)\b[\s\w-]*\b(?:on|to)\s+the\s+right\b/.test(lower) ||
+        /\b(?:right|right-side)\s+(?:text|copy|content)\b/.test(lower) ||
+        /\b(?:text|copy|content)\s+(?:right|right-side)\b/.test(lower)) {
+        return { imagePosition: "left" };
+    }
+    return null;
+}
+export function inferDeterministicIntent(args) {
+    const raw = stripSiteContextEnvelope(args.message).trim();
+    if (!raw)
+        return null;
+    let action = inferActionFromMessage(raw);
+    if (!action)
+        return null;
+    // "remove all except hero" / "delete everything but CTA" — handle deterministically for remove
+    if (action === "remove" && EXCEPT_PATTERN.test(raw)) {
+        // If message scopes the remove to a specific container block (e.g. "from slides in Carousel"),
+        // this is an intra-block item operation — defer to LLM.
+        if (isContainerScopedRemove(raw))
+            return null;
+        let keepType = inferBlockTypeFromText(raw);
+        // "this one" / "this block" / "the selected" → resolve from activeBlockId
+        if (!keepType && args.activeBlockId && THIS_ONE_PATTERN.test(raw)) {
+            const activeBlock = args.currentPage.blocks.find((b) => b.id === args.activeBlockId);
+            if (activeBlock)
+                keepType = activeBlock.type;
+        }
+        if (keepType && args.currentPage.blocks.some((b) => b.type === keepType)) {
+            return {
+                action: "remove",
+                target_block_type: keepType,
+                summary: `Removed all blocks except ${keepType}.`
+            };
+        }
+        return null;
+    }
+    // "add all except ..." — needs LLM
+    if (action === "add" && EXCEPT_PATTERN.test(raw)) {
+        return null;
+    }
+    // In focused inline-edit mode, "add image/photo" should update the selected image field,
+    // not add a new block.
+    if (action === "add" &&
+        typeof args.activeEditablePath === "string" &&
+        args.activeEditablePath.trim() === "imageUrl" &&
+        /\b(image|photo|picture)\b/i.test(raw)) {
+        action = "update";
+    }
+    const refs = resolveReferencesFromMessage({
+        message: raw,
+        currentPage: args.currentPage,
+        activeBlockId: args.activeBlockId
+    });
+    let targetBlock = refs.target
+        ? args.currentPage.blocks.find((block) => block.id === refs.target?.id) ?? null
+        : null;
+    if (!targetBlock && args.activeBlockId) {
+        targetBlock = args.currentPage.blocks.find((block) => block.id === args.activeBlockId) ?? null;
+    }
+    const inferred = { action };
+    if (targetBlock) {
+        inferred.target_block_ref = targetBlock.id;
+        inferred.target_block_type = targetBlock.type;
+    }
+    else {
+        // For an add, the trailing "below/after the <Type>" names the placement
+        // anchor — not a target to act on — so scan the anchor-stripped text. Otherwise
+        // target_block_type latches onto the anchor's type and resurfaces as the block
+        // to create via the compile fallback chain (#18).
+        const scanText = action === "add" ? stripPositionalAnchorPhrase(raw) : raw;
+        const typeFromMessage = inferBlockTypeFromText(scanText);
+        if (typeFromMessage)
+            inferred.target_block_type = typeFromMessage;
+        if (typeFromMessage) {
+            const byType = args.currentPage.blocks.filter((block) => block.type === typeFromMessage);
+            if (byType.length === 1) {
+                targetBlock = byType[0] ?? null;
+                if (targetBlock)
+                    inferred.target_block_ref = targetBlock.id;
+            }
+        }
+    }
+    if (action === "add") {
+        // Infer the block to ADD from the message with any trailing positional anchor
+        // removed ("add a gallery after the testimonials" → "add a gallery"), so the
+        // anchor's own type isn't picked up as the new block (#18). Fall back to the
+        // ACTIVELY-SELECTED block's type only — never to a targetBlock resolved from a
+        // free-text scan, which above (lines ~303-312) latches onto the anchor's type.
+        const addText = stripPositionalAnchorPhrase(raw);
+        const selectedType = targetBlock && targetBlock.id === args.activeBlockId ? targetBlock.type : undefined;
+        // Item words that only exist INSIDE a container map to that container's type,
+        // so "add a tab called Pricing" resolves to Tabs — not CardGrid (via the
+        // incidental "Pricing") or FAQAccordion (via a "FAQ" label) (#22). Checked
+        // first so the generic keyword scan can't latch onto label noise.
+        const itemContainerType = inferItemContainerType(addText);
+        const inferredAddType = itemContainerType ??
+            inferAddedBlockTypeFromMessage(addText) ??
+            inferBlockTypeFromText(addText) ??
+            selectedType;
+        if (inferredAddType)
+            inferred.new_block_type = inferredAddType;
+    }
+    if (action === "move" || action === "add") {
+        const lower = raw.toLowerCase();
+        if (/\b(top|first|start|beginning)\b/.test(lower))
+            inferred.position = "top";
+        else if (/\b(bottom|last|end)\b/.test(lower))
+            inferred.position = "bottom";
+        else if (/\b(before|above)\b/.test(lower))
+            inferred.position = "before";
+        else if (/\b(after|below|under)\b/.test(lower))
+            inferred.position = "after";
+        if (refs.anchor?.id)
+            inferred.anchor_block_ref = refs.anchor.id;
+    }
+    const patch = inferPatchFromMessage({
+        message: raw,
+        action,
+        targetBlock: targetBlock ?? undefined,
+        activeEditablePath: args.activeEditablePath
+    });
+    if (patch && Object.keys(patch).length > 0)
+        inferred.patch = patch;
+    return inferred;
+}
+/**
+ * Returns true when the message mentions a specific block type or block-synonymous
+ * term, indicating the user is talking about a block — not about the page itself.
+ * Used to guard page-level operations from misclassifying block-level requests.
+ *
+ * Strips noise that causes false positives:
+ * - Text after "this/the page" (page name refs like "move this page before Pricing")
+ * - Route slugs ("/pricing", "/about-us") — these are page refs, not block types
+ */
+function messageRefersToBlock(message, activeBlockId) {
+    // When the message explicitly says "this/the page", "this" refers to the page, not the selected block
+    if (activeBlockId && /\b(this|the|current)\s+page\b/i.test(message))
+        return false;
+    if (activeBlockId)
+        return true;
+    // Strip text after "this/the/current page" (page name references)
+    // and strip route slugs (/pricing, /about) that could false-match block keywords
+    const cleaned = message
+        .replace(/\b(?:this|the|current)\s+page\b.*/i, "")
+        .replace(/\/[a-z0-9_-]+/gi, "");
+    if (inferBlockTypeFromText(cleaned))
+        return true;
+    // "the/this section", "a component", "the block" — block-synonymous terms with article
+    if (/\b(?:the|this|a|that)\s+(?:section|component|block|element|widget)\b/i.test(cleaned))
+        return true;
+    return false;
+}
+/**
+ * Detects "move (this) page before/after X" — page nav move requests.
+ * Matches both route-based ("move page after /pricing") and natural language
+ * ("move this page before About us") anchor references.
+ * Requires "move" directly adjacent to "this/the/current page" to avoid matching
+ * block positioning phrases like "move CTA to the top of the page".
+ */
+function isNavMoveRequest(message) {
+    const lower = message.toLowerCase();
+    const movesThisPage = /\bmove\s+(?:this|the|current)\s+page\b/.test(lower);
+    const hasPlacement = /\b(before|after|above|below|first|last|top|bottom|start|end|beginning)\b/.test(lower);
+    return movesThisPage && hasPlacement;
+}
+/**
+ * Resolves a natural language page name (e.g. "About us") to a slug by matching
+ * against page titles in the session draft. Returns undefined if no match.
+ */
+function resolvePageSlugByTitle(sessionDraft, name) {
+    const lower = name.toLowerCase().trim();
+    if (!lower)
+        return undefined;
+    for (const [slug, page] of sessionDraft) {
+        if (page.title.toLowerCase() === lower)
+            return slug;
+    }
+    // Fuzzy: check if name is contained in title or vice versa
+    for (const [slug, page] of sessionDraft) {
+        const titleLower = page.title.toLowerCase();
+        if (titleLower.includes(lower) || lower.includes(titleLower))
+            return slug;
+    }
+    return undefined;
+}
+// Conjunctions that separate independent clauses (", and …", "… then …", "; …").
+// Bare commas are intentionally excluded so a value/list comma doesn't over-split.
+const CLAUSE_CONJUNCTION = /\s*(?:;|,?\s+(?:and|then|also|plus)\s+)/i;
+// A broad set of edit verbs, INCLUDING natural-language ones the verb-position
+// classifier ignores ("make", "put", "take out", "rename", "reflect").
+const CLAUSE_ACTION_VERB = /\b(?:add|insert|create|include|put|remove|delete|clear|take\s+out|get\s+rid|move|reorder|rearrange|swap|update|change|edit|set|replace|rewrite|reword|rephrase|make|rename|shorten|tighten|reflect|turn|hide|show|sort|soften|expand|highlight)\b/i;
+/**
+ * True when the message carries more than one independent edit intent ("add a
+ * testimonials section … and make the CTA …", "delete the 2nd and 3rd cards … and
+ * rename the first"). The deterministic path models a SINGLE simple intent, so it
+ * would handle only the first clause and silently drop the rest — these must defer to
+ * the LLM, which plans every clause. A single intent with an incidental conjunction
+ * inside a quoted value or an adjective list ("'Health and Wellness'", "bigger and
+ * bolder") has only ONE action-bearing clause and stays deterministic. (#32)
+ */
+/** Blank out quoted values so a conjunction/verb inside a replacement string
+ * ("… to 'Cut costs and move faster'") can't be read as a clause boundary. */
+function stripQuotedValues(raw) {
+    return raw
+        .replace(/"[^"]*"/g, " ")
+        .replace(/'[^']*'/g, " ")
+        .replace(/“[^”]*”/g, " ")
+        .replace(/‘[^’]*’/g, " ");
+}
+export function isMultiIntentRequest(raw) {
+    // Strip quoted values first: "change the heading to 'Cut costs and move faster'"
+    // is ONE intent, but the "and" inside the value would otherwise split it into two
+    // pseudo-clauses that each look action-bearing → false multi-intent deferral.
+    const clauses = stripQuotedValues(raw).split(CLAUSE_CONJUNCTION).filter((c) => c.trim().length > 0);
+    if (clauses.length < 2)
+        return false;
+    return clauses.filter((c) => CLAUSE_ACTION_VERB.test(c)).length >= 2;
+}
+/**
+ * Returns true only when UI context makes the intent completely unambiguous,
+ * so the deterministic planner can handle it without an LLM call.
+ */
+export function isHighConfidenceDeterministicCase(args) {
+    const raw = stripSiteContextEnvelope(args.message).trim();
+    if (!raw)
+        return false;
+    // Case 1: Inline edit — user clicked a field, typed a quoted value
+    if (args.activeBlockId && args.activeEditablePath && quotedText(raw))
+        return true;
+    // Case 2: Inline list append — "add another item" with block selected
+    if (args.activeBlockId) {
+        const block = args.currentPage.blocks.find(b => b.id === args.activeBlockId);
+        if (block && /\b(add|insert)\b/i.test(raw) && /\b(another|more|new)\b/i.test(raw)) {
+            if (buildListAppendPatch(block, raw))
+                return true;
+        }
+    }
+    // Case 3: Simple add/remove with clear block type — no LLM needed
+    // Bail out for compound requests ("remove X and add Y") — these need the LLM
+    const hasCompoundAction = /\b(remove|delete|clear)\b.+\band\b.+\b(add|insert|create)\b/i.test(raw)
+        || /\b(add|insert|create)\b.+\band\b.+\b(remove|delete|clear)\b/i.test(raw);
+    if (hasCompoundAction)
+        return false;
+    // Bail out for multi-intent requests the single-intent deterministic path can't model
+    // ("add a testimonials section ... and make the CTA ...") — it would handle only the
+    // first clause and silently drop the rest. The compound decomposer / LLM take over. (#32)
+    if (isMultiIntentRequest(raw))
+        return false;
+    const hasExceptionModifier = EXCEPT_PATTERN.test(raw);
+    if (hasExceptionModifier) {
+        // "remove all except X" can be handled deterministically when X resolves to a block type on the page
+        const action = inferActionFromMessage(raw);
+        if (action === "remove") {
+            if (isContainerScopedRemove(raw))
+                return false; // intra-block item op — defer to LLM
+            let keepType = inferBlockTypeFromText(raw);
+            if (!keepType && args.activeBlockId && THIS_ONE_PATTERN.test(raw)) {
+                const activeBlock = args.currentPage.blocks.find((b) => b.id === args.activeBlockId);
+                if (activeBlock)
+                    keepType = activeBlock.type;
+            }
+            if (keepType && args.currentPage.blocks.some((b) => b.type === keepType))
+                return true;
+        }
+        return false;
+    }
+    const action = inferActionFromMessage(raw);
+    // Cross-page scope ("update the CTA on all pages", "change X site-wide") can't be
+    // honored by the single-page deterministic path — it would silently narrow the edit
+    // to the current page only. Defer to the LLM, which can fan out across pages (ops
+    // carry pageSlug) or clarify. Create-page requests are exempt — they legitimately
+    // target one new page, not the whole site (issue #29).
+    if (hasCrossPageScope(raw) && !parseCreatePageRequest(raw))
+        return false;
+    // Case: create_page — "create a new /about page", "create a new test page"
+    // Defer to LLM when user wants content generation (topic + block types enumerated)
+    if (action === "add" && parseCreatePageRequest(raw) && !requestsContentGeneration(raw))
+        return true;
+    // "add X to each/every card" = bulk item update — needs LLM for content generation
+    if (action === "add" && /\b(each|every)\b/i.test(raw))
+        return false;
+    // Counted multi-block add without enough named types → needs LLM for content generation
+    if (action === "add" && isBatchAddRequest(raw) && extractMentionedBlockTypes(raw).length < 2)
+        return false;
+    // Case: page rename — "rename page to Our community", "rename this page to /plans"
+    if (action === "update" && isPageRouteRenameRequest(raw))
+        return true;
+    // Case: page nav move — "move this page before About us", "move page after /pricing"
+    // Guard: if message mentions a block type, it's a block move, not a nav move
+    if (action === "move" && isNavMoveRequest(raw) && !messageRefersToBlock(raw, args.activeBlockId))
+        return true;
+    // Case: page-level delete — "delete this page", "remove the page"
+    if (action === "remove" && /\b(delete|remove)\b.*\bpage\b/i.test(raw) && !messageRefersToBlock(raw, args.activeBlockId))
+        return true;
+    // Multiple distinct removal targets ("remove the testimonials, the CTA, and both two-column sections")
+    // — the deterministic path infers only the FIRST block type and emits a single remove_block,
+    // silently dropping the rest. Defer to the LLM so every requested target is handled (issue #17B).
+    if (action === "remove" && extractMentionedBlockTypes(raw).length >= 2)
+        return false;
+    const removeType = inferBlockTypeFromText(raw);
+    if (action === "remove" && removeType) {
+        if (args.currentPage.blocks.filter((b) => b.type === removeType).length > 1)
+            return false;
+        return true;
+    }
+    if (action === "remove" && args.activeBlockId && /\b(this|selected|it)\b/i.test(raw))
+        return true;
+    // "add a hero image of X" when Hero already exists = image update, not block add — defer to LLM
+    const addBlockType = action === "add" ? inferBlockTypeFromText(raw) : null;
+    if (action === "add" && addBlockType && /\b(image|photo|picture|icon)\b/i.test(raw) && args.currentPage.blocks.some(b => b.type === addBlockType))
+        return false;
+    // "add icons to the stats / features" — `icon` is a per-item FIELD, never a
+    // block or a list item, and "stats"/"features" don't resolve to a block type,
+    // so the guard above misses and the add-item path inserts a junk placeholder
+    // row ("100+ / New metric") instead of icons. Any "add … icon …" request is a
+    // field edit, so defer to the LLM (it sets the icon field via update_props).
+    if (action === "add" && /\bicons?\b/i.test(raw))
+        return false;
+    // "add CTA directing to recipes" = needs LLM for content-aware props
+    if (action === "add" && inferBlockTypeFromText(raw) && hasContentDirective(raw))
+        return false;
+    // Defer to LLM when topic + multiple block types are enumerated (needs content generation)
+    if (action === "add" && inferBlockTypeFromText(raw) && !requestsContentGeneration(raw))
+        return true;
+    // Compound multi-block update ("change the hero heading to 'X' and the CTA button
+    // to 'Y'") — the deterministic update path infers only the FIRST block type and
+    // emits a single update_props, silently dropping the other clause. When the message
+    // names ≥2 distinct block types joined by a conjunction (counted OUTSIDE quoted
+    // values so block words inside the replacement text don't inflate the count), defer
+    // to the LLM so every targeted block is updated (issue #29).
+    if (action === "update") {
+        const outsideQuotes = stripQuotedValues(raw);
+        if (/\b(?:and|plus)\b|&|,/.test(outsideQuotes) && extractMentionedBlockTypes(outsideQuotes).length >= 2) {
+            return false;
+        }
+    }
+    // Case 4: Simple update with clear block type reference and quoted value
+    if (action === "update" && inferBlockTypeFromText(raw) && quotedText(raw)) {
+        if (hasQuotedConstraintOnlyText(raw))
+            return false;
+        if (isRewriteRequest(raw) && !hasQuotedReplacementDirective(raw))
+            return false;
+        return true;
+    }
+    return false;
+}
+/**
+ * Splits a compound message ("remove the hero and add a CTA") into sub-parts
+ * at conjunction boundaries, but only when the parts contain verbs from
+ * different action categories (add vs remove, etc.).
+ *
+ * Returns null when the message is not a decomposable compound request.
+ */
+function splitCompoundMessage(raw) {
+    // Bail when 3+ distinct action verbs are present — too complex for 2-way split
+    const lower = raw.toLowerCase();
+    const verbCategories = [
+        /\b(?:add|insert|create|include)\b/,
+        /\b(?:remove|delete|clear)\b/,
+        /\b(?:move|reorder|rearrange)\b/,
+        /\b(?:update|change|edit|set|replace)\b/,
+    ];
+    const matchedCategories = verbCategories.filter((p) => p.test(lower)).length;
+    if (matchedCategories >= 3)
+        return null;
+    // Only split when two different action-category verbs are connected by a conjunction.
+    // Pattern: <verb-group-A> ... <and|then|,> ... <verb-group-B>
+    const addVerbs = String.raw `(?:add|insert|create|include)`;
+    const removeVerbs = String.raw `(?:remove|delete|clear)`;
+    const conjunction = String.raw `(?:\s+and\s+|\s+then\s+|\s*,\s*(?:and\s+)?(?:then\s+)?)`;
+    // Try add...conjunction...remove
+    const arPattern = new RegExp(String.raw `(.*\b${addVerbs}\b[^,]*?)${conjunction}(\b${removeVerbs}\b.*)`, "i");
+    const arMatch = raw.match(arPattern);
+    if (arMatch?.[1] && arMatch?.[2])
+        return [arMatch[1].trim(), arMatch[2].trim()];
+    // Try remove...conjunction...add
+    const raPattern = new RegExp(String.raw `(.*\b${removeVerbs}\b[^,]*?)${conjunction}(\b${addVerbs}\b.*)`, "i");
+    const raMatch = raw.match(raPattern);
+    if (raMatch?.[1] && raMatch?.[2])
+        return [raMatch[1].trim(), raMatch[2].trim()];
+    // Try move...conjunction...add/remove
+    const moveVerbs = String.raw `(?:move|reorder|rearrange)`;
+    const updateVerbs = String.raw `(?:update|change|edit|set|replace)`;
+    const pairs = [
+        [moveVerbs, addVerbs],
+        [moveVerbs, removeVerbs],
+        [addVerbs, updateVerbs],
+        [removeVerbs, updateVerbs],
+        [updateVerbs, addVerbs],
+        [updateVerbs, removeVerbs],
+    ];
+    for (const [a, b] of pairs) {
+        const pattern = new RegExp(String.raw `(.*\b${a}\b[^,]*?)${conjunction}(\b${b}\b.*)`, "i");
+        const match = raw.match(pattern);
+        if (match?.[1] && match?.[2])
+            return [match[1].trim(), match[2].trim()];
+    }
+    return null;
+}
+/**
+ * Attempts to handle a compound message ("remove the hero and add a CTA")
+ * by decomposing it into sub-intents and running each through the
+ * deterministic planner. Returns null if any sub-intent can't be handled
+ * deterministically.
+ */
+export function tryCompoundDeterministicPlan(args) {
+    const raw = stripSiteContextEnvelope(args.message).trim();
+    if (!raw)
+        return null;
+    const parts = splitCompoundMessage(raw);
+    if (!parts)
+        return null;
+    const [firstMsg, secondMsg] = parts;
+    // Check both parts individually for high-confidence
+    for (const msg of [firstMsg, secondMsg]) {
+        if (!isHighConfidenceDeterministicCase({
+            message: msg,
+            currentPage: args.currentPage,
+            activeBlockId: args.activeBlockId,
+            activeEditablePath: args.activeEditablePath
+        }))
+            return null;
+    }
+    // Build intent + plan for first part
+    const firstIntent = inferDeterministicIntent({
+        message: firstMsg,
+        currentPage: args.currentPage,
+        activeBlockId: args.activeBlockId,
+        activeEditablePath: args.activeEditablePath
+    });
+    if (!firstIntent)
+        return null;
+    const firstPlan = compileDeterministicPlan({
+        session: args.session,
+        intent: firstIntent,
+        message: firstMsg,
+        slug: args.slug,
+        currentPage: args.currentPage,
+        activeBlockId: args.activeBlockId,
+        activeEditablePath: args.activeEditablePath
+    });
+    if (!firstPlan || firstPlan.intent !== "edit_plan" || firstPlan.ops.length === 0)
+        return null;
+    // Apply first plan's ops to a cloned page so second plan sees updated state
+    // (e.g., removed blocks are no longer visible, added blocks can be referenced)
+    let updatedPage = args.currentPage;
+    for (const op of firstPlan.ops) {
+        if (op.op === "remove_block") {
+            updatedPage = { ...updatedPage, blocks: updatedPage.blocks.filter((b) => b.id !== op.blockId) };
+        }
+        else if (op.op === "add_block") {
+            updatedPage = { ...updatedPage, blocks: [...updatedPage.blocks, op.block] };
+        }
+    }
+    // Build intent + plan for second part
+    const secondIntent = inferDeterministicIntent({
+        message: secondMsg,
+        currentPage: updatedPage,
+        activeBlockId: args.activeBlockId,
+        activeEditablePath: args.activeEditablePath
+    });
+    if (!secondIntent)
+        return null;
+    const secondPlan = compileDeterministicPlan({
+        session: args.session,
+        intent: secondIntent,
+        message: secondMsg,
+        slug: args.slug,
+        currentPage: updatedPage,
+        activeBlockId: args.activeBlockId,
+        activeEditablePath: args.activeEditablePath
+    });
+    if (!secondPlan || secondPlan.intent !== "edit_plan" || secondPlan.ops.length === 0)
+        return null;
+    // Merge: removes first (so IDs are valid), then adds
+    const removeOps = [...firstPlan.ops, ...secondPlan.ops].filter(op => op.op === "remove_block" || op.op === "remove_page");
+    const otherOps = [...firstPlan.ops, ...secondPlan.ops].filter(op => op.op !== "remove_block" && op.op !== "remove_page");
+    return {
+        intent: "edit_plan",
+        summary_for_user: [firstPlan.summary_for_user, secondPlan.summary_for_user].join(" "),
+        change_log: [...firstPlan.change_log, ...secondPlan.change_log],
+        ops: [...removeOps, ...otherOps]
+    };
+}
+// ---------------------------------------------------------------------------
+// Header / site-config shortcut
+// ---------------------------------------------------------------------------
+const SMART_QUOTES_RE = /[‘’“”]/g;
+function normalizeQuotes(value) {
+    return value.replace(SMART_QUOTES_RE, (ch) => (ch === "‘" || ch === "’" ? "'" : '"'));
+}
+function stripWrappingQuotes(value) {
+    const trimmed = value.trim().replace(/[.!?;:]+$/, "").trim();
+    const m = trimmed.match(/^["'](.+)["']$/);
+    return (m ? m[1] : trimmed).trim();
+}
+/**
+ * Matches high-confidence requests targeting the SiteHeader / siteConfig.
+ * Returns a one-op `update_site_config` plan or null if no clear match.
+ */
+function tryHeaderConfigPlan(args) {
+    const { session, message, assumptions } = args;
+    const lower = message.toLowerCase();
+    const draft = getSessionDraft(session);
+    const config = getSiteConfig(session);
+    // ── Logo ──────────────────────────────────────────────────────────────
+    const messageNorm = normalizeQuotes(message);
+    const mentionsLogo = /\b(logo)\b/.test(lower);
+    if (mentionsLogo) {
+        // "use URL as the logo" / "set logo to URL" / "change the logo to URL"
+        const useAs = messageNorm.match(/\buse\s+["']?(\S+?)["']?\s+as\s+(?:the\s+)?(?:site\s+)?logo\b/i);
+        const setTo = messageNorm.match(/\b(?:change|set|update|make)\s+(?:the\s+)?(?:site\s+)?logo\s+(?:to|=)\s+(.+?)$/i);
+        const raw = useAs ? useAs[1] : setTo ? setTo[1] : null;
+        if (raw) {
+            const url = stripWrappingQuotes(raw);
+            if (/^(https?:\/\/|\/)/.test(url) && !/\s/.test(url)) {
+                return {
+                    intent: "edit_plan",
+                    summary_for_user: `Will update the **site logo**.`,
+                    change_log: [...assumptions, `Set site logo to ${url}.`],
+                    ops: [{ op: "update_site_config", patch: { logo: url } }]
+                };
+            }
+        }
+    }
+    // ── Site name ────────────────────────────────────────────────────────
+    const mentionsSiteName = /\bsite\s+name\b/.test(lower) ||
+        /\brename\s+the\s+site\b/.test(lower) ||
+        /\bchange\s+the\s+site\s+to\b/.test(lower);
+    if (mentionsSiteName) {
+        const fromSiteName = messageNorm.match(/\bsite\s+name\s+(?:to|=|:)\s+(.+?)$/i);
+        const renameSite = messageNorm.match(/\brename\s+the\s+site\s+to\s+(.+)$/i);
+        const changeSite = messageNorm.match(/\bchange\s+the\s+site\s+to\s+(.+)$/i);
+        const raw = (fromSiteName ? stripWrappingQuotes(fromSiteName[1]) : null)
+            ?? (renameSite ? stripWrappingQuotes(renameSite[1]) : null)
+            ?? (changeSite ? stripWrappingQuotes(changeSite[1]) : null);
+        if (raw && raw.length > 0 && raw.length <= 80) {
+            return {
+                intent: "edit_plan",
+                summary_for_user: `Will rename the site to **${raw}**.`,
+                change_log: [...assumptions, `Set site name to "${raw}".`],
+                ops: [{ op: "update_site_config", patch: { name: raw } }]
+            };
+        }
+    }
+    // ── Nav label rename ─────────────────────────────────────────────────
+    // Patterns: "rename the X link to Y", "rename X in the nav to Y",
+    //           "relabel the X tab to Y", "change the X menu item to Y"
+    const navTokens = "(?:link|tab|menu(?:\\s+item)?|nav(?:igation)?(?:\\s+item)?|item|entry)";
+    const navContextRe = new RegExp(`\\b(?:rename|relabel|change|update|set)\\s+(?:the\\s+)?["']?([^"']+?)["']?\\s+${navTokens}\\s+to\\s+(.+)$`, "i");
+    const inNavRe = new RegExp(`\\b(?:rename|relabel|change|update|set)\\s+(?:the\\s+)?["']?([^"']+?)["']?\\s+(?:in|on)\\s+(?:the\\s+)?(?:nav(?:igation)?|menu|header)\\s+to\\s+(.+)$`, "i");
+    const navMatch = messageNorm.match(navContextRe) ?? messageNorm.match(inNavRe);
+    if (navMatch) {
+        const fromLabelRaw = stripWrappingQuotes(navMatch[1]);
+        const toLabel = stripWrappingQuotes(navMatch[2]);
+        if (fromLabelRaw && toLabel && toLabel.length <= 80) {
+            const slug = resolveNavSlugByLabel(fromLabelRaw, config.navLabels ?? {}, draft);
+            if (slug) {
+                const mergedLabels = { ...(config.navLabels ?? {}), [slug]: toLabel };
+                return {
+                    intent: "edit_plan",
+                    summary_for_user: `Will rename the **${fromLabelRaw}** nav link to **${toLabel}**.`,
+                    change_log: [...assumptions, `Renamed nav label ${slug} from "${fromLabelRaw}" to "${toLabel}".`],
+                    ops: [{ op: "update_site_config", patch: { navLabels: mergedLabels } }]
+                };
+            }
+        }
+    }
+    return null;
+}
+function resolveNavSlugByLabel(label, navLabels, draft) {
+    const lower = label.toLowerCase().trim();
+    if (!lower)
+        return undefined;
+    // 1. Existing override matches exactly
+    for (const [slug, override] of Object.entries(navLabels)) {
+        if (typeof override === "string" && override.toLowerCase() === lower)
+            return slug;
+    }
+    // 2. Page title matches (uses the same fuzzy matcher as page rename)
+    const byTitle = resolvePageSlugByTitle(draft, label);
+    if (byTitle)
+        return byTitle;
+    // 3. Slug last segment matches (e.g. "about" → /about, "our team" → /our-team)
+    const seed = toSeedSlug(label);
+    if (seed) {
+        const candidate = `/${seed}`;
+        if (draft.has(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+export function compileDeterministicPlan(args) {
+    const { session, intent, message, slug, currentPage, activeBlockId, activeEditablePath } = args;
+    const cleanMessage = stripSiteContextEnvelope(message);
+    const lowerMessage = message.toLowerCase();
+    // Header / site-config requests bypass intent inference and resolve straight
+    // to update_site_config. The SiteHeader is not a page block, so phrasing like
+    // "rename the About link" or "change the logo" must NOT fall into update_props.
+    const headerPlan = tryHeaderConfigPlan({ session, message: cleanMessage, assumptions: intent.assumption ? [intent.assumption] : [] });
+    if (headerPlan)
+        return headerPlan;
+    const routeMentions = extractRouteMentions(cleanMessage);
+    const assumptions = [];
+    if (intent.assumption)
+        assumptions.push(intent.assumption);
+    const hasStructuralVerb = /\b(move|reorder|re-arrange|rearrange|add|remove|delete|create|duplicate|rename)\b/.test(lowerMessage);
+    if (process.env.OPENAI_API_KEY &&
+        (intent.action === "update" || intent.action === "clarify") &&
+        !hasStructuralVerb &&
+        isRewriteRequest(message) &&
+        (!hasQuotedReplacementDirective(message) || hasQuotedConstraintOnlyText(message)))
+        return null;
+    const hasConditionalQualifier = /\bif\s+(required|needed|necessary)\b/.test(lowerMessage);
+    const asksSectionReorder = /\b(reorder|re-order|rearrange|re-organize|reorganize)\b/.test(lowerMessage) &&
+        /\b(section|sections|block|blocks|content|layout|flow|readability)\b/.test(lowerMessage);
+    const hasExplicitPlacementCue = /\b(top|bottom|first|last|before|after|above|below|under|between)\b/.test(lowerMessage);
+    const hasExplicitBlockMentionInMessage = /\bb_[a-z0-9_]+\b/.test(lowerMessage) ||
+        /\b(hero|feature grid|features|testimonials?|faq|cta|card grid|cards?|rich[\s-]?text)\b/.test(lowerMessage);
+    const selectedBlock = activeBlockId ? currentPage.blocks.find((b) => b.id === activeBlockId) ?? null : null;
+    const secondaryButtonMentioned = lowerMessage.includes("secondary cta") ||
+        lowerMessage.includes("secondary button") ||
+        lowerMessage.includes("second cta") ||
+        lowerMessage.includes("second button") ||
+        /sec\w*nd\w*ry\s+(cta|button)/.test(lowerMessage);
+    const asksSecondaryCtaAdd = secondaryButtonMentioned &&
+        (lowerMessage.includes("add") || lowerMessage.includes("create") || lowerMessage.includes("insert") || lowerMessage.includes("include"));
+    const asksPageRename = isPageRouteRenameRequest(message);
+    if ((intent.action === "update" || intent.action === "move" || intent.action === "clarify") && asksPageRename) {
+        const mentionsCurrentPage = /\b(this|current|the)\s+page\b/.test(lowerMessage);
+        let fromSlug = routeMentions[0] ?? slug;
+        let toSlug = routeMentions.length >= 2 ? routeMentions[routeMentions.length - 1] : undefined;
+        if (!toSlug && routeMentions.length === 1 && mentionsCurrentPage) {
+            toSlug = routeMentions[0];
+            fromSlug = slug;
+        }
+        // Extract natural language name after "to" when no route mentions resolve
+        let newTitle;
+        if (!toSlug || toSlug === fromSlug) {
+            // Strip clarification history and site context before extracting the target name
+            const msgForRename = message.replace(/\nClarification from user:[\s\S]*/i, "").replace(/\s*\[site context\][\s\S]*$/i, "").trim();
+            const nameMatch = msgForRename.match(/\brename\b.*\bpage\b.*?\bto\s+(.+)$/i)
+                ?? msgForRename.match(/\brename\b.*?\bto\s+(.+)$/i);
+            if (nameMatch) {
+                const rawName = nameMatch[1].replace(/[.!?]+$/, "").trim();
+                if (rawName) {
+                    const seed = toSeedSlug(rawName);
+                    if (seed) {
+                        toSlug = `/${seed}`;
+                        fromSlug = slug;
+                        newTitle = rawName.split(/\s+/).map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+                    }
+                }
+            }
+        }
+        if (!toSlug || toSlug === fromSlug) {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "rename.needsPath"),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        const renameOp = { op: "rename_page", pageSlug: fromSlug, newPageSlug: toSlug, ...(newTitle ? { newTitle } : {}) };
+        return {
+            intent: "edit_plan",
+            summary_for_user: st(args.locale, "rename.done", { from: fromSlug, to: toSlug }),
+            change_log: [...assumptions, `Renamed page ${fromSlug} -> ${toSlug}.`],
+            ops: [renameOp]
+        };
+    }
+    const asksPageDelete = /\b(delete|remove)\b.*\bpage\b/.test(lowerMessage) && !messageRefersToBlock(cleanMessage, args.activeBlockId);
+    if ((intent.action === "remove" || intent.action === "clarify") && asksPageDelete) {
+        const targetSlug = routeMentions[0] ?? slug;
+        if (targetSlug === "/") {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "delete.homeBlocked"),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        return {
+            intent: "edit_plan",
+            summary_for_user: st(args.locale, "delete.done", { slug: targetSlug }),
+            change_log: [...assumptions, `Removed page ${targetSlug}.`],
+            ops: [{ op: "remove_page", pageSlug: targetSlug }]
+        };
+    }
+    const requestedCreateSlug = parseCreatePageRequest(message);
+    // When the user mentions "template", skip deterministic page creation
+    // and let the LLM planner use the template definitions from site context.
+    const mentionsTemplate = /\btemplate\b/i.test(cleanMessage);
+    if ((intent.action === "add" || intent.action === "clarify" || intent.action === "update") && requestedCreateSlug) {
+        if (mentionsTemplate)
+            return null; // defer to LLM planner
+        const createPlan = buildCreatePagePlan({ session, requestedSlug: requestedCreateSlug, assumptions, userMessage: message });
+        if (createPlan)
+            return createPlan;
+    }
+    const hasNavContext = /\b(nav|navigation|menu|first|last|position)\b/.test(lowerMessage) || routeMentions.length >= 2;
+    const asksNavMove = !messageRefersToBlock(cleanMessage, args.activeBlockId) && (/\b(nav|navigation|menu|tabs?|tab order|page order)\b/.test(lowerMessage) ||
+        /\bmove\b.*\btab\b/.test(lowerMessage) ||
+        (/\bmove\b.*\bpage\b/.test(lowerMessage) && hasNavContext) ||
+        /\breorder\b.*\b(page|nav|menu|tabs?)\b/.test(lowerMessage) ||
+        isNavMoveRequest(cleanMessage));
+    if ((intent.action === "move" || intent.action === "clarify") && asksNavMove) {
+        const sessionDraft = getSessionDraft(session);
+        const slugsRaw = Array.from(sessionDraft.keys());
+        const ordered = slugsRaw.includes("/") ? ["/", ...slugsRaw.filter((route) => route !== "/")] : slugsRaw;
+        const movedSlug = routeMentions[0] ?? slug;
+        if (!ordered.includes(movedSlug)) {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "move.notFound", { slug: movedSlug }),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        if (movedSlug === "/") {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "move.homeFixed"),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        // Extract anchor page name from natural language when no route mentions available
+        const resolveAnchorSlug = () => {
+            if (routeMentions.length >= 2)
+                return routeMentions[1];
+            // "move page before About us" → extract "About us"
+            const anchorMatch = cleanMessage.match(/\b(?:before|after|above|below|under)\s+(.+)$/i);
+            if (anchorMatch) {
+                const name = anchorMatch[1].replace(/\s*\[site context\][\s\S]*$/i, "").replace(/[.!?]+$/, "").trim();
+                return resolvePageSlugByTitle(sessionDraft, name);
+            }
+            return undefined;
+        };
+        let afterPageSlug;
+        if (/\b(top|first|start|beginning)\b/.test(lowerMessage)) {
+            afterPageSlug = undefined;
+        }
+        else if (/\b(bottom|last|end)\b/.test(lowerMessage)) {
+            const tail = [...ordered].reverse().find((route) => route !== movedSlug);
+            afterPageSlug = tail === "/" ? "/" : tail;
+        }
+        else if (/\b(after|below|under)\b/.test(lowerMessage)) {
+            const anchor = resolveAnchorSlug();
+            if (!anchor) {
+                return {
+                    intent: "needs_clarification",
+                    summary_for_user: st(args.locale, "move.specifyWhere"),
+                    change_log: assumptions,
+                    ops: []
+                };
+            }
+            afterPageSlug = anchor;
+        }
+        else if (/\b(before|above)\b/.test(lowerMessage)) {
+            const anchor = resolveAnchorSlug();
+            if (!anchor) {
+                return {
+                    intent: "needs_clarification",
+                    summary_for_user: st(args.locale, "move.specifyWhere"),
+                    change_log: assumptions,
+                    ops: []
+                };
+            }
+            if (anchor === "/")
+                afterPageSlug = undefined;
+            else {
+                const index = ordered.findIndex((route) => route === anchor);
+                if (index === -1) {
+                    return {
+                        intent: "needs_clarification",
+                        summary_for_user: st(args.locale, "move.anchorNotFound", { slug: anchor }),
+                        change_log: assumptions,
+                        ops: []
+                    };
+                }
+                const previous = ordered.slice(0, index).reverse().find((route) => route !== movedSlug);
+                afterPageSlug = previous === "/" ? "/" : previous;
+            }
+        }
+        else if (routeMentions.length >= 2) {
+            afterPageSlug = routeMentions[1];
+        }
+        else {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "move.specifyWhere"),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        return {
+            intent: "edit_plan",
+            summary_for_user: afterPageSlug === undefined
+                ? `Moved ${movedSlug} to the first nav position (after Home).`
+                : `Moved ${movedSlug} after ${afterPageSlug}.`,
+            change_log: [...assumptions, `Reordered nav: ${movedSlug}`],
+            ops: [{ op: "move_page", pageSlug: movedSlug, afterPageSlug }]
+        };
+    }
+    const audiences = extractAudienceTargets(message);
+    const audience = audiences[0];
+    const asksAudienceCreatePage = audiences.length > 0 &&
+        /\b(create|generate|build|make|draft)\b/.test(lowerMessage) &&
+        /\b(pages?|landing pages?)\b/.test(lowerMessage);
+    if (asksAudienceCreatePage && audience) {
+        if (process.env.OPENAI_API_KEY)
+            return null;
+        const now = new Date().toISOString();
+        const reservedSlugs = new Set(getSessionDraft(session).keys());
+        const allocateSlug = (requested) => {
+            let candidate = requested;
+            if (!reservedSlugs.has(candidate)) {
+                reservedSlugs.add(candidate);
+                return candidate;
+            }
+            let idx = 2;
+            while (reservedSlugs.has(`${requested}-${idx}`))
+                idx += 1;
+            candidate = `${requested}-${idx}`;
+            reservedSlugs.add(candidate);
+            return candidate;
+        };
+        const pages = audiences.map((aud, index) => {
+            const seed = toSeedSlug(aud) || `audience-${index + 1}`;
+            const requestedSlug = routeMentions[index] ?? `/for-${seed}`;
+            const normalizedRequested = normalizeRouteCandidate(requestedSlug) ?? `/for-${seed}`;
+            const newSlug = allocateSlug(normalizedRequested);
+            const label = titleCaseWords(aud);
+            const page = {
+                id: `p_for_${seed}`,
+                slug: newSlug,
+                title: `For ${label}`,
+                updatedAt: now,
+                blocks: [
+                    {
+                        id: `b_hero_${seed}`,
+                        type: "Hero",
+                        props: {
+                            heading: `Built for ${label}`,
+                            subheading: `Everything on this page is tailored for ${aud}.`,
+                            ctaText: "Get Started",
+                            ctaHref: "/",
+                            imageUrl: IMAGE_PLACEHOLDER,
+                            imageAlt: `Audience-focused hero image for ${label}`
+                        }
+                    },
+                    {
+                        id: `b_features_${seed}`,
+                        type: "FeatureGrid",
+                        props: {
+                            title: `Why ${label} choose this`,
+                            features: [
+                                { title: "Relevant messaging", description: `Copy aligned to ${aud} needs and language.` },
+                                { title: "Clear outcomes", description: "Benefits are framed around practical results." },
+                                { title: "Focused next step", description: "CTA is tuned for this audience journey." }
+                            ]
+                        }
+                    },
+                    {
+                        id: `b_faq_${seed}`,
+                        type: "FAQAccordion",
+                        props: {
+                            title: `FAQ for ${label}`,
+                            items: [
+                                { q: `Is this suitable for ${aud}?`, a: `Yes, this page is tailored for ${aud}.` },
+                                { q: "How quickly can I start?", a: "Most visitors can get started in minutes." },
+                                { q: "Can I customize later?", a: "Yes, content and sections can be updated anytime." }
+                            ]
+                        }
+                    },
+                    {
+                        id: `b_cta_${seed}`,
+                        type: "CTA",
+                        props: {
+                            title: `Start with a plan for ${label}`,
+                            description: "Take the next step with content designed for your audience.",
+                            ctaText: "Start now",
+                            ctaHref: "/"
+                        }
+                    }
+                ]
+            };
+            return { page, audience: aud };
+        });
+        const createdAudienceLabels = pages.map((entry) => entry.audience);
+        const summaryAudienceList = createdAudienceLabels.join(", ");
+        return {
+            intent: "edit_plan",
+            summary_for_user: pages.length === 1
+                ? `Created a new page tailored for ${audience}.`
+                : `Created ${pages.length} new pages tailored for ${summaryAudienceList}.`,
+            change_log: [
+                ...assumptions,
+                ...pages.map((entry) => `Created page ${entry.page.slug} for audience: ${entry.audience}.`)
+            ],
+            ops: pages.map((entry) => ({ op: "create_page", page: entry.page }))
+        };
+    }
+    const asksAudienceRetarget = Boolean(audience) &&
+        !asksAudienceCreatePage &&
+        (/\bfor\b/.test(lowerMessage) || /\baudience\b/.test(lowerMessage) || /\btarget\b/.test(lowerMessage));
+    if (asksAudienceRetarget && audience) {
+        const targets = selectedBlock
+            ? [selectedBlock]
+            : currentPage.blocks.filter((block) => block.type === "Hero" || block.type === "CTA" || block.type === "RichText").slice(0, 3);
+        if (process.env.OPENAI_API_KEY && !selectedBlock)
+            return null;
+        const ops = [];
+        for (const block of targets) {
+            const patch = audiencePatchForBlock(block, audience);
+            if (Object.keys(patch).length === 0)
+                continue;
+            ops.push({ op: "update_props", pageSlug: slug, blockId: block.id, patch });
+        }
+        if (ops.length > 0) {
+            return {
+                intent: "edit_plan",
+                summary_for_user: st(args.locale, "audience.done", { audience }),
+                change_log: [...assumptions, `Retargeted copy for audience: ${audience}.`],
+                ops
+            };
+        }
+    }
+    if (intent.action === "move" && hasConditionalQualifier && asksSectionReorder && !hasExplicitPlacementCue && !hasExplicitBlockMentionInMessage) {
+        return {
+            intent: "needs_clarification",
+            summary_for_user: st(args.locale, "reorder.specify"),
+            change_log: [...assumptions, "Skipped ambiguous conditional reorder request without explicit section or placement."],
+            ops: []
+        };
+    }
+    if (selectedBlock?.type === "Hero" &&
+        asksSecondaryCtaAdd &&
+        (intent.action === "add" || intent.action === "clarify" || intent.action === "update")) {
+        const heroProps = selectedBlock.props;
+        const existingText = typeof heroProps.secondaryCtaText === "string" ? heroProps.secondaryCtaText.trim() : "";
+        const existingHref = typeof heroProps.secondaryCtaHref === "string" ? heroProps.secondaryCtaHref.trim() : "";
+        const quoted = quotedText(message);
+        const patch = {
+            secondaryCtaText: quoted ?? (existingText.length > 0 ? existingText : "Learn more"),
+            secondaryCtaHref: existingHref.length > 0 ? existingHref : "/"
+        };
+        return {
+            intent: "edit_plan",
+            summary_for_user: st(args.locale, "hero.secondaryCta"),
+            change_log: [...assumptions, `Updated ${selectedBlock.id}: secondaryCtaText, secondaryCtaHref`],
+            ops: [{ op: "update_props", pageSlug: slug, blockId: selectedBlock.id, patch }]
+        };
+    }
+    // "each/every/all" signals a bulk update across items — needs LLM, not inline append
+    const asksBulkUpdate = /\b(each|every|all)\b/.test(lowerMessage);
+    const asksInlineAdd = !asksBulkUpdate &&
+        lowerMessage.includes("add") &&
+        (lowerMessage.includes("inside") ||
+            lowerMessage.includes("within") ||
+            lowerMessage.includes("current") ||
+            lowerMessage.includes("this one") ||
+            lowerMessage.includes("more") ||
+            lowerMessage.includes("another"));
+    if ((intent.action === "add" || intent.action === "clarify") && asksInlineAdd) {
+        let inlineTarget = selectedBlock;
+        let ambiguousContainerType = null;
+        if (!inlineTarget) {
+            const typeMap = [
+                { test: /\btestimonial/, type: "Testimonials" },
+                { test: /\b(faq|question)/, type: "FAQAccordion" },
+                { test: /\bfeature/, type: "FeatureGrid" },
+                { test: /\bcard/, type: "CardGrid" },
+                { test: /\btab/, type: "Tabs" },
+                { test: /\bslide/, type: "Carousel" },
+                { test: /\bstat/, type: "Stats" },
+                { test: /\brow/, type: "Table" }
+            ];
+            for (const entry of typeMap) {
+                if (entry.test.test(lowerMessage)) {
+                    const matches = currentPage.blocks.filter((b) => b.type === entry.type);
+                    // Keep scanning when this item word names a container that isn't on the
+                    // page: "add another card to the features section" mentions "feature"
+                    // (no FeatureGrid here) but the cards live in a CardGrid, matched by the
+                    // later "card" entry — breaking on the first match stranded it (#19).
+                    if (matches.length === 1) {
+                        inlineTarget = matches[0];
+                        break;
+                    }
+                    // Referenced type exists but isn't unique (e.g. 3 CardGrids) — remember it
+                    // so we can defer rather than fabricate a new container below.
+                    if (matches.length > 1 && !ambiguousContainerType)
+                        ambiguousContainerType = entry.type;
+                }
+            }
+        }
+        if (inlineTarget) {
+            const patch = buildListAppendPatch(inlineTarget, message);
+            if (patch) {
+                return {
+                    intent: "edit_plan",
+                    summary_for_user: st(args.locale, "update.done", { type: blockLabel(inlineTarget.type) }),
+                    change_log: [...assumptions, `Added one entry to ${blockLabel(inlineTarget.type)}.`],
+                    ops: [{ op: "update_props", pageSlug: slug, blockId: inlineTarget.id, patch }]
+                };
+            }
+        }
+        // Clear "append another item to the <X>" intent, but the target container can't
+        // be resolved deterministically (multiple of that type) — defer to the LLM to
+        // pick the right block by heading instead of falling through and adding a phantom
+        // empty container (#19). Without this the request creates a junk Card/FeatureGrid.
+        if (!inlineTarget && ambiguousContainerType)
+            return null;
+    }
+    if (intent.action === "info") {
+        // Let the full planner handle info queries — it produces detailed
+        // block descriptions via the submit_edit_plan tool.
+        return null;
+    }
+    if (intent.action === "clarify" && !activeEditablePath) {
+        return {
+            intent: "needs_clarification",
+            summary_for_user: intent.summary ?? st(args.locale, "update.specify"),
+            change_log: assumptions,
+            ops: []
+        };
+    }
+    // "remove all except X" — generate remove ops for every block NOT matching the kept type
+    if (intent.action === "remove" && EXCEPT_PATTERN.test(cleanMessage)) {
+        const keepType = intent.target_block_type;
+        if (keepType) {
+            const toRemove = currentPage.blocks.filter((b) => b.type !== keepType);
+            if (toRemove.length === 0) {
+                return {
+                    intent: "edit_plan",
+                    summary_for_user: st(args.locale, "remove.allAlready", { type: blockLabel(keepType) }),
+                    change_log: assumptions,
+                    ops: []
+                };
+            }
+            return {
+                intent: "edit_plan",
+                summary_for_user: intent.summary ?? `Removed all blocks except ${keepType}.`,
+                change_log: [
+                    ...assumptions,
+                    ...toRemove.map((b) => `Removed ${blockLabel(b.type)}.`)
+                ],
+                ops: toRemove.map((b) => ({ op: "remove_block", pageSlug: slug, blockId: b.id }))
+            };
+        }
+    }
+    if (intent.action === "remove") {
+        let target = resolveBlockRef({
+            ref: intent.target_block_ref,
+            currentPage,
+            activeBlockId,
+            fallbackType: intent.target_block_type
+        });
+        if (!target && !activeBlockId) {
+            const inferredType = inferBlockTypeFromText(cleanMessage);
+            if (inferredType) {
+                const matches = currentPage.blocks.filter((b) => b.type === inferredType);
+                if (matches.length === 1)
+                    target = matches[0];
+            }
+        }
+        if (!target) {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "remove.needsBlock"),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        // Detect item-level removal (e.g., "remove the first question from the FAQ")
+        // Skip when the user wants to remove image *properties* (e.g. "remove images from cards")
+        const asksRemoveImageProps = /\bremove\b.*\b(images?|photos?|pictures?)\b.*\b(from|in|on)\b/i.test(lowerMessage);
+        // The ambiguous triggers below ("card", "feature", ordinals) ALSO appear when the
+        // user is selecting among sibling CONTAINER BLOCKS ("delete the second card grid",
+        // "remove the first feature grid", "hide the third section"). Removing an item there
+        // is destructive and wrong — it deletes one card and shifts the array while the
+        // summary claims the whole block is gone (#31). Treat it as a block removal when the
+        // message names a container block as the target and isn't scoped INTO the container
+        // ("the last card IN the grid" / "a question FROM the faq" stay item ops).
+        const namesContainerAsTarget = /\b(?:card\s*grids?|feature\s*grids?|grids?|two[\s-]?columns?|carousels?|galler(?:y|ies)|accordions?|sections?|blocks?)\b/i.test(lowerMessage);
+        const itemScopedIntoContainer = /\b(?:cards?|questions?|items?|entries|entry|testimonials?|features?|slides?|rows?|stats?|tabs?|points?|photos?|images?)\s+(?:in|inside|within|from|of|on)\b/i.test(lowerMessage) ||
+            isContainerScopedRemove(lowerMessage);
+        const removesWholeContainer = namesContainerAsTarget && !itemScopedIntoContainer;
+        // "remove all the card grids" / "delete every feature grid" — every block of the
+        // target's type, not one item. Emit a remove_block per matching block (#31).
+        if (removesWholeContainer && /\b(?:all|every|each)\b/i.test(lowerMessage)) {
+            const matches = currentPage.blocks.filter((b) => b.type === target.type);
+            if (matches.length > 0) {
+                return {
+                    intent: "edit_plan",
+                    summary_for_user: intent.summary ?? st(args.locale, "remove.done", { type: blockLabel(target.type) }),
+                    change_log: [...assumptions, ...matches.map(() => `Removed ${blockLabel(target.type)}.`)],
+                    ops: matches.map((b) => ({ op: "remove_block", pageSlug: slug, blockId: b.id }))
+                };
+            }
+        }
+        const asksRemoveItem = !asksRemoveImageProps && !removesWholeContainer && /\b(question|item|entry|testimonial|card|feature|first|second|third|last)\b/i.test(lowerMessage);
+        if (asksRemoveItem) {
+            const bProps = target.props;
+            if (bProps) {
+                for (const [key, val] of Object.entries(bProps)) {
+                    if (!Array.isArray(val) || val.length === 0)
+                        continue;
+                    // Use ordinalToIndex for consistent ordinal parsing
+                    const ordMatch = lowerMessage.match(/\b(first|second|third|fourth|fifth|last|1st|2nd|3rd|4th|5th)\b/i);
+                    const parsedIdx = ordMatch ? ordinalToIndex(ordMatch[1]) : 0;
+                    if (parsedIdx === null) {
+                        return {
+                            intent: "needs_clarification",
+                            summary_for_user: st(args.locale, "remove.specifyItem"),
+                            change_log: assumptions,
+                            ops: []
+                        };
+                    }
+                    const idx = parsedIdx === -1 ? val.length - 1 : parsedIdx;
+                    if (idx >= val.length) {
+                        return {
+                            intent: "needs_clarification",
+                            summary_for_user: st(args.locale, "remove.outOfRange", { count: String(val.length), type: blockLabel(target.type), index: String(idx + 1) }),
+                            change_log: assumptions,
+                            ops: []
+                        };
+                    }
+                    return {
+                        intent: "edit_plan",
+                        summary_for_user: intent.summary ?? st(args.locale, "remove.itemDone", { type: blockLabel(target.type) }),
+                        change_log: [...assumptions, `Removed item ${idx + 1} from ${blockLabel(target.type)}.`],
+                        ops: [{ op: "remove_item", pageSlug: slug, blockId: target.id, listKey: key, index: idx }]
+                    };
+                }
+            }
+        }
+        return {
+            intent: "edit_plan",
+            summary_for_user: intent.summary ?? st(args.locale, "remove.done", { type: blockLabel(target.type) }),
+            change_log: [...assumptions, `Removed ${blockLabel(target.type)}.`],
+            ops: [{ op: "remove_block", pageSlug: slug, blockId: target.id }]
+        };
+    }
+    if (intent.action === "update" || (intent.action === "clarify" && !!activeEditablePath)) {
+        const target = resolveBlockRef({
+            ref: intent.target_block_ref,
+            currentPage,
+            activeBlockId,
+            fallbackType: intent.target_block_type
+        });
+        if (!target) {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "update.needsBlock"),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        const childPatch = coercePatchForEditablePath(target, activeEditablePath, intent.patch, message);
+        const fullPatch = coercePatchForBlock(target, intent.patch);
+        const mergedRichTextTranslationPatch = shouldKeepRichTextTitleOnTranslate({
+            target,
+            activeEditablePath,
+            message,
+            fullPatch
+        })
+            ? { ...fullPatch, ...(childPatch?.patch ?? {}) }
+            : null;
+        const patch = mergedRichTextTranslationPatch ?? childPatch?.patch ?? fullPatch;
+        if (Object.keys(patch).length === 0) {
+            const editableFields = userFacingPropNames(target.type, Object.keys(target.props));
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "update.invalidFields", { type: blockLabel(target.type) }),
+                change_log: [...assumptions, `Editable fields: ${editableFields.join(", ")}`],
+                ops: []
+            };
+        }
+        const changedKeys = userFacingPropNames(target.type, Object.keys(patch));
+        return {
+            intent: "edit_plan",
+            summary_for_user: intent.summary ?? st(args.locale, "update.done", { type: blockLabel(target.type) }),
+            change_log: [
+                ...assumptions,
+                childPatch
+                    ? `Updated ${blockLabel(target.type)} ${activeEditablePath}: ${changedKeys.join(", ")}`
+                    : `Updated ${blockLabel(target.type)}: ${changedKeys.join(", ")}`
+            ],
+            ops: [{ op: "update_props", pageSlug: slug, blockId: target.id, patch }]
+        };
+    }
+    if (intent.action === "move") {
+        const target = resolveBlockRef({
+            ref: intent.target_block_ref,
+            currentPage,
+            activeBlockId,
+            fallbackType: intent.target_block_type
+        });
+        if (!target) {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "move.needsBlock"),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        let afterBlockId;
+        if (intent.position === "top") {
+            afterBlockId = undefined;
+        }
+        else if (intent.position === "bottom") {
+            const tail = [...currentPage.blocks].reverse().find((b) => b.id !== target.id);
+            afterBlockId = tail?.id;
+        }
+        else if (intent.position === "after" || (intent.anchor_block_ref && !intent.position)) {
+            const anchor = resolveBlockRef({ ref: intent.anchor_block_ref, currentPage });
+            if (!anchor) {
+                return {
+                    intent: "needs_clarification",
+                    summary_for_user: st(args.locale, "move.anchorBlockNotFound"),
+                    change_log: assumptions,
+                    ops: []
+                };
+            }
+            afterBlockId = anchor.id;
+        }
+        else if (intent.position === "before") {
+            const anchor = resolveBlockRef({ ref: intent.anchor_block_ref, currentPage });
+            if (!anchor) {
+                return {
+                    intent: "needs_clarification",
+                    summary_for_user: st(args.locale, "move.anchorBlockBeforeNotFound"),
+                    change_log: assumptions,
+                    ops: []
+                };
+            }
+            const idx = currentPage.blocks.findIndex((b) => b.id === anchor.id);
+            if (idx > 0)
+                afterBlockId = currentPage.blocks[idx - 1]?.id;
+            else
+                afterBlockId = undefined;
+        }
+        else if (message.toLowerCase().includes("bottom") || message.toLowerCase().includes("end")) {
+            const tail = [...currentPage.blocks].reverse().find((b) => b.id !== target.id);
+            afterBlockId = tail?.id;
+        }
+        else {
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "move.specifyDirection"),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        return {
+            intent: "edit_plan",
+            summary_for_user: intent.summary ?? st(args.locale, "move.blockDone", { type: blockLabel(target.type) }),
+            change_log: [...assumptions, `Moved ${blockLabel(target.type)}.`],
+            ops: [{ op: "move_block", pageSlug: slug, blockId: target.id, afterBlockId }]
+        };
+    }
+    if (intent.action === "add") {
+        // --- Batch add: "add 3 blocks: hero, cardgrid and CTA" ----------------
+        if (isBatchAddRequest(message)) {
+            // Strip any trailing positional anchor so a real batch ("add a hero and a
+            // cta below the header") doesn't also create the anchor block (#18).
+            const blockTypes = extractMentionedBlockTypes(stripPositionalAnchorPhrase(message));
+            if (blockTypes.length >= 2) {
+                const ops = [];
+                const changeLog = [...assumptions];
+                // Track blocks as we add them so nextBlockId generates unique IDs
+                let pageSnapshot = currentPage;
+                for (const bt of blockTypes) {
+                    const blockId = nextBlockId(bt, pageSnapshot);
+                    const props = defaultPropsForType(bt);
+                    ops.push({ op: "add_block", pageSlug: slug, block: { id: blockId, type: bt, props } });
+                    changeLog.push(`Added ${blockLabel(bt)} block.`);
+                    // Update snapshot so the next nextBlockId sees existing IDs
+                    pageSnapshot = { ...pageSnapshot, blocks: [...pageSnapshot.blocks, { id: blockId, type: bt, props }] };
+                }
+                return {
+                    intent: "edit_plan",
+                    summary_for_user: st(args.locale, "add.multiple", { types: blockTypes.map(blockLabel).join(", ") }),
+                    change_log: changeLog,
+                    ops
+                };
+            }
+        }
+        // --- Single add -------------------------------------------------------
+        // Scan the message with any trailing positional anchor removed so "add a
+        // contact form below the hero" does not resolve to the anchor's type (Hero)
+        // and silently create a phantom duplicate (#18).
+        const addText = stripPositionalAnchorPhrase(message);
+        const blockType = intent.new_block_type ??
+            inferAddedBlockTypeFromMessage(addText) ??
+            intent.target_block_type ??
+            inferBlockTypeFromText(intent.target_block_ref ?? "") ??
+            inferBlockTypeFromText(addText);
+        if (!blockType) {
+            // No block type found — check if this is an image replacement request
+            // e.g. "add unsplash image", "add a new photo", "add image"
+            const isImageRequest = /\b(image|photo|picture)\b/.test(lowerMessage);
+            if (isImageRequest) {
+                const hero = selectedBlock?.type === "Hero"
+                    ? selectedBlock
+                    : currentPage.blocks.find((b) => b.type === "Hero") ?? null;
+                if (hero) {
+                    return {
+                        intent: "edit_plan",
+                        summary_for_user: st(args.locale, "add.heroImage"),
+                        change_log: [...assumptions, `Updated ${blockLabel(hero.type)}: image`],
+                        ops: [{ op: "update_props", pageSlug: slug, blockId: hero.id, patch: { imageUrl: "pending" } }]
+                    };
+                }
+            }
+            return {
+                intent: "needs_clarification",
+                summary_for_user: st(args.locale, "add.specifyType", { types: allowedBlockTypes.map(blockLabel).join(", ") }),
+                change_log: assumptions,
+                ops: []
+            };
+        }
+        // Check if this is an item-level addition to an existing list block.
+        // An explicit positional placement ("add a testimonials section below the
+        // hero") always means a NEW block at that spot — never an item appended to an
+        // existing one — so skip the append path when an anchor/position is set (#18).
+        const explicitPlacement = intent.position != null || intent.anchor_block_ref != null;
+        // "add an FAQ section" / "add a testimonials section" names a NEW block to
+        // create, even when one of that type already exists — the block noun
+        // ("section"/"block") is the object of the add. Only count it when it appears
+        // BEFORE any "to the <container>" clause, so "add a testimonial to the
+        // testimonials section" (an item appended into a container) still appends (#15).
+        const addObject = lowerMessage.split(/\bto\s+the\b/)[0] ?? lowerMessage;
+        const wantsNewBlock = /\b(?:section|block)\b/.test(addObject);
+        const existingOfType = currentPage.blocks.filter((b) => b.type === blockType);
+        if (existingOfType.length === 1 && !explicitPlacement && !wantsNewBlock) {
+            const existing = existingOfType[0];
+            const listPatch = buildListAppendPatch(existing, message);
+            if (listPatch) {
+                return {
+                    intent: "edit_plan",
+                    summary_for_user: intent.summary ?? st(args.locale, "add.itemDone", { type: blockLabel(existing.type) }),
+                    change_log: [...assumptions, `Appended item to ${blockLabel(existing.type)}.`],
+                    ops: [{ op: "update_props", pageSlug: slug, blockId: existing.id, patch: listPatch }]
+                };
+            }
+        }
+        // "add a <child> to/into the <existing block>" — e.g. "add a video to the hero",
+        // "add a button to the CTA", "add a card to the classes grid". A same-type item
+        // append was already handled just above; reaching here means the target names an
+        // existing block of a DIFFERENT type, so the user wants to put something INSIDE (or
+        // onto) that block, not create a new top-level one. The deterministic scan can't model
+        // that and tends to mistake the target's type for the block to create — a phantom
+        // duplicate Hero/CTA, or a stray Card. Hand these to the LLM, which disambiguates (#28).
+        const intoClause = lowerMessage.match(/\b(?:in|into|to)\s+the\s+([a-z][a-z0-9 ]*)/);
+        if (intoClause && !wantsNewBlock && !explicitPlacement) {
+            const targetPhrase = intoClause[1];
+            const targetType = inferBlockTypeFromText(targetPhrase) ?? inferContainerTypeFromNoun(targetPhrase);
+            const targetsPageOrPosition = /\b(page|site|top|bottom|end|start|beginning|middle)\b/.test(targetPhrase);
+            if (targetType != null && !targetsPageOrPosition && currentPage.blocks.some((b) => b.type === targetType)) {
+                return null;
+            }
+        }
+        const blockId = nextBlockId(blockType, currentPage);
+        const baseProps = defaultPropsForType(blockType);
+        const patch = coercePatchForBlock({ id: blockId, type: blockType, props: baseProps }, intent.patch);
+        const props = { ...baseProps, ...patch };
+        const addOp = {
+            op: "add_block",
+            pageSlug: slug,
+            block: { id: blockId, type: blockType, props }
+        };
+        let extraMoveTop = null;
+        if (intent.position === "after" || (intent.anchor_block_ref && !intent.position)) {
+            const anchor = resolveBlockRef({ ref: intent.anchor_block_ref, currentPage });
+            if (!anchor) {
+                return {
+                    intent: "needs_clarification",
+                    summary_for_user: st(args.locale, "add.anchorAfterNotFound"),
+                    change_log: assumptions,
+                    ops: []
+                };
+            }
+            addOp.afterBlockId = anchor.id;
+        }
+        else if (intent.position === "before") {
+            const anchor = resolveBlockRef({ ref: intent.anchor_block_ref, currentPage });
+            if (!anchor) {
+                return {
+                    intent: "needs_clarification",
+                    summary_for_user: st(args.locale, "add.anchorBeforeNotFound"),
+                    change_log: assumptions,
+                    ops: []
+                };
+            }
+            const idx = currentPage.blocks.findIndex((b) => b.id === anchor.id);
+            if (idx > 0)
+                addOp.afterBlockId = currentPage.blocks[idx - 1]?.id;
+            else
+                extraMoveTop = { op: "move_block", pageSlug: slug, blockId, afterBlockId: undefined };
+        }
+        else if (intent.position === "top") {
+            extraMoveTop = { op: "move_block", pageSlug: slug, blockId, afterBlockId: undefined };
+        }
+        else if (intent.position === "bottom" || !intent.position) {
+            // no-op: add without anchor appends to bottom in applyOpsAtomically
+        }
+        const ops = extraMoveTop ? [addOp, extraMoveTop] : [addOp];
+        return {
+            intent: "edit_plan",
+            summary_for_user: intent.summary ?? st(args.locale, "add.done", { type: blockLabel(blockType) }),
+            change_log: [...assumptions, `Added ${blockLabel(blockType)} block.`],
+            ops
+        };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Re-exports from split files (preserve public API)
+// ---------------------------------------------------------------------------
+export { extractAudienceTarget, extractAudienceTargets, titleCaseWords, addAudienceSuffix, audiencePatchForBlock, coercePatchForBlock, parseIndexedPath, inferSimpleFieldPatchFromMessage, isRewriteRequest, isTranslationRequest, shouldKeepRichTextTitleOnTranslate, inferFieldHintFromMessage, rewriteFromExisting, coercePatchForEditablePath, quotedText, buildListAppendPatch } from "./deterministic-planner-patches.js";
+export { editablePropsFromBlock, promptFromPropKey, userFacingPropNames, ORDINALS, humanizeArrayPath, childSuggestions, clarificationSuggestions, postEditSuggestions, demoPlanFromMessage, titleCaseSentence, pageMetaContractSummary, blockContractsSummary } from "./deterministic-planner-suggestions.js";
+export { nextAvailableSlug, createPageBlocks, buildCreatePagePlan, isPageRouteRenameRequest } from "./deterministic-planner-pages.js";
+export { readPathValue, resolveImageUrlForAltField, fetchImageAsBase64, resolveAttachmentsForLlm, selectedBlockSnapshot, arrayPropLengths, pageIntentSummary, plannerContextPack } from "./deterministic-planner-context.js";
+export { inferAddedBlockTypeFromMessage, resolveBlockRef, ordinalToIndex, resolveByDescriptor, resolveReferencesFromMessage } from "./deterministic-planner-refs.js";