@avocadostudio-ai/orchestrator-core 0.3.1 → 0.3.3

package/dist/http/screenshot-actions.d.ts

@@ -24,8 +24,8 @@
  * page. So the path is declarable: per request, per registered site, or via
  * `createOrchestrator({ draftPath })`.
  */
-import type { Logger } from "../logger.js";
-import type { ActionResult } from "./history-actions.js";
+import type { Logger } from "../logger.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 export type ScreenshotParams = {
     session?: string;

package/dist/http/session-actions.d.ts

@@ -17,7 +17,7 @@
  * embedding its own editor, and it would answer a question no embedded caller
  * should be asking.
  */
-import type { ActionResult } from "./history-actions.js";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * The caller's bound session and a summary of its state.

package/dist/http/telemetry-feedback-actions.d.ts

@@ -15,8 +15,8 @@
  * status code and body to send; neither Fastify nor `Response` appears in this
  * file.
  */
-import type { FeedbackStore } from "../telemetry/feedback-store.js";
-import type { ActionResult } from "./history-actions.js";
+import type { FeedbackStore } from "../telemetry/feedback-store.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * The store is a parameter, not a module singleton.

package/dist/http/unsplash-actions.d.ts

@@ -15,8 +15,8 @@
  * orchestrator runtime is ready, and why this file needs no collaborators
  * beyond an access key and a `fetch`.
  */
-import type { Logger } from "../logger.js";
-import type { ActionResult } from "./history-actions.js";
+import type { Logger } from "../logger.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * Raw query values, straight off the wire.

package/dist/http/variations-actions.d.ts

@@ -17,8 +17,8 @@
  * wire bytes for callers that don't already have an SSE writer. Neither Fastify
  * nor `Response` appears in this file.
  */
-import { type VariationRequestBody, type VariationPipelineContext, type VariationResult, type VariationImageUpdate } from "../chat/variation-pipeline.js";
-import type { ActionResult } from "./history-actions.js";
+import { type VariationRequestBody, type VariationPipelineContext, type VariationResult, type VariationImageUpdate } from "../chat/variation-pipeline.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 export type { VariationRequestBody, VariationPipelineContext };
 export type ParsedVariationRequest = {

package/dist/index.d.ts

@@ -2,3 +2,10 @@ export { createOrchestrator, type CreateOrchestratorConfig, type OrchestratorHan
 export type { OrchestratorAuth, AuthContext } from "./handler/auth.ts";
 export type { CmsAdapter, CmsCapabilities, CmsInlineAsset, CmsPublishContext, CmsPublishResult, CmsPerspective, CmsReadOptions, CmsMediaItem, CmsMediaPage, CmsMediaQuery, ResolvedCapabilities } from "./cms/adapter.ts";
 export { jsonFileAdapter, editorApiAdapter, resolveCapabilities, cmsMediaSource, cmsMediaLabel, type JsonFileAdapterOptions, type EditorApiAdapterOptions, type CmsMediaSource, type CmsMediaSourceConfig } from "./cms/index.ts";
+export { registerPublishTarget, selectPublishTarget, getPublishTarget, listPublishTargets } from "./publish/publish-target-registry.ts";
+export type { PublishTarget, PublishContext, PublishOutcome, PublishStatus, PublishResult } from "./publish/publish-target.ts";
+export { SqliteDurableStore, InMemoryDurableStore, getDurableStore, resetDurableStore, setDurableStore, durableStoreIsEphemeral, type SqliteDurableStoreOptions, type InMemoryDurableStoreOptions, type DurableStore, type FindingInput, type FindingRecord, type FindingQuery, type FindingSeverity, type FindingStatus, type FindingEvidence, type CheckRunInput, type CheckRunRecord, type CheckRunPatch, type CheckRunTrigger, type MemoryInput, type MemoryRecord, type MemoryQuery, type MemoryScope, type MemoryKind, type MemorySource, type MemoryStatus, type CorrectionInput, type CorrectionRecord, type CorrectionQuery, type CorrectionOutcome, type ProposalInput, type ProposalRecord, type ProposalQuery, type ProposalStatus } from "./durable/index.ts";
+export { runDraftChecks, runChecksForSession, scheduleChecksAfterApply, scheduleChecksAfterPublish, cancelScheduledChecks, fingerprintFor, DRAFT_RULES, walkPageFields, fieldText, type RunChecksArgs, type CheckRule, type CheckContext, type RuleFinding, type FieldEntry, type SiteView } from "./checks/index.ts";
+export { runChecksAction, listFindingsAction, listCheckRunsAction, updateFindingAction, type RunChecksParams, type ListFindingsParams, type UpdateFindingParams, type ChecksScope } from "./http/checks-actions.ts";
+export { durableHealth, noteDurableFailure, isDiscardInFlight } from "./durable/durable-store-singleton.ts";
+export { loadPendingPlan, savePendingPlan, clearPendingPlan, peekPendingPlan } from "./durable/pending-plan-store.ts";

package/dist/index.js

@@ -19,3 +19,30 @@
 // The Fastify HTTP wrapper lives in apps/orchestrator and imports from here.
 export { createOrchestrator } from "./handler/create-orchestrator.js";
 export { jsonFileAdapter, editorApiAdapter, resolveCapabilities, cmsMediaSource, cmsMediaLabel } from "./cms/index.js";
+// The publish-target plugin point. `docs-site/integration/publishing.mdx` has
+// documented this as the way to publish somewhere we do not ship a target for
+// since before the package had an export map, and told the reader to import it
+// from `"./publish/publish-target-registry.js"` — a relative path into *this*
+// repository, pasted into their file. It cannot resolve from anywhere, and
+// there was no specifier that could: the symbol was not exported here, so a
+// registry consumer had no reachable way to register a target at all.
+//
+// The interface was always meant to be public — `architecture.mdx` calls it the
+// integration point for "S3, GitLab Pages, Netlify, a CMS API, a custom CI/CD
+// pipeline". Only the export was missing.
+export { registerPublishTarget, selectPublishTarget, getPublishTarget, listPublishTargets } from "./publish/publish-target-registry.js";
+// The durable substrate for findings, memory, corrections and proposals. It is
+// public because the implementation is meant to be replaceable: a library-mode
+// host on a serverless platform has no persistent disk for a SQLite file, and
+// every record here would otherwise die with the process. `DurableStore` is the
+// seam a Neon- or Turso-backed store fills — which is only true if a consumer
+// installing from the registry can reach the type.
+export { SqliteDurableStore, InMemoryDurableStore, getDurableStore, resetDurableStore, setDurableStore, durableStoreIsEphemeral } from "./durable/index.js";
+// The draft-tier checks: pure functions of a PageDoc and the block manifest,
+// producing findings into the durable store. Public so an integrator can run
+// them (or add a rule of their own) against a site we do not host.
+export { runDraftChecks, runChecksForSession, scheduleChecksAfterApply, scheduleChecksAfterPublish, cancelScheduledChecks, fingerprintFor, DRAFT_RULES, walkPageFields, fieldText } from "./checks/index.js";
+// The checks HTTP surface, mounted by both transports.
+export { runChecksAction, listFindingsAction, listCheckRunsAction, updateFindingAction } from "./http/checks-actions.js";
+export { durableHealth, noteDurableFailure, isDiscardInFlight } from "./durable/durable-store-singleton.js";
+export { loadPendingPlan, savePendingPlan, clearPendingPlan, peekPendingPlan } from "./durable/pending-plan-store.js";

package/dist/nlp/deterministic-planner-context.d.ts

@@ -46,6 +46,22 @@ export declare function selectedBlockSnapshot(args: {
     selectedEditablePath: string | null;
     selectedEditableValue: {} | null;
 } | null;
+/**
+ * How an item in a list prop gets named to the planner, in precedence order.
+ *
+ * A list whose items match none of these reaches the planner as a bare count,
+ * and the planner then cannot answer "update the FAQ entry about freezing" —
+ * it knows there are three entries and nothing about any of them. It says so,
+ * correctly, and asks which one. Three of the twelve list fields in the block
+ * registry were in that state: `FAQAccordion.items` names its question `q`,
+ * `Testimonials.items` has `author`/`quote`, and `Gallery.images` has
+ * `caption`/`alt`. None of those were listed here.
+ *
+ * `arrayPropLabelKeys` is asserted against the block registry by a test, so a
+ * new block with a differently-named item field fails there rather than
+ * silently costing the planner a clarification round-trip.
+ */
+export declare const ARRAY_PROP_LABEL_KEYS: readonly ["label", "title", "heading", "question", "q", "name", "author", "caption", "alt", "quote", "value", "text"];
 export declare function arrayPropLengths(props: Record<string, unknown>): Record<string, {
     length: number;
     labels?: string[];

package/dist/nlp/deterministic-planner-context.js

@@ -184,6 +184,35 @@ export function selectedBlockSnapshot(args) {
 // ---------------------------------------------------------------------------
 // Array prop metadata
 // ---------------------------------------------------------------------------
+/**
+ * How an item in a list prop gets named to the planner, in precedence order.
+ *
+ * A list whose items match none of these reaches the planner as a bare count,
+ * and the planner then cannot answer "update the FAQ entry about freezing" —
+ * it knows there are three entries and nothing about any of them. It says so,
+ * correctly, and asks which one. Three of the twelve list fields in the block
+ * registry were in that state: `FAQAccordion.items` names its question `q`,
+ * `Testimonials.items` has `author`/`quote`, and `Gallery.images` has
+ * `caption`/`alt`. None of those were listed here.
+ *
+ * `arrayPropLabelKeys` is asserted against the block registry by a test, so a
+ * new block with a differently-named item field fails there rather than
+ * silently costing the planner a clarification round-trip.
+ */
+export const ARRAY_PROP_LABEL_KEYS = [
+    "label",
+    "title",
+    "heading",
+    "question",
+    "q",
+    "name",
+    "author",
+    "caption",
+    "alt",
+    "quote",
+    "value",
+    "text"
+];
 export function arrayPropLengths(props) {
     const out = {};
     for (const [key, value] of Object.entries(props)) {
@@ -192,13 +221,10 @@ export function arrayPropLengths(props) {
         const labels = [];
         for (const item of value) {
             if (typeof item === "object" && item !== null) {
-                const labelValue = item.label ??
-                    item.title ??
-                    item.heading ??
-                    item.question ??
-                    item.name;
-                if (typeof labelValue === "string")
-                    labels.push(labelValue);
+                const record = item;
+                const labelKey = ARRAY_PROP_LABEL_KEYS.find((candidate) => typeof record[candidate] === "string");
+                if (labelKey)
+                    labels.push(record[labelKey]);
             }
         }
         out[key] = labels.length > 0 ? { length: value.length, labels } : { length: value.length };

package/dist/nlp/deterministic-planner-suggestions.js

@@ -31,7 +31,7 @@ export function promptFromPropKey(propKey, blockType) {
         return CLARIFICATION_LABELS[propKey];
     const human = blockType ? getPropDisplayName(blockType, propKey) : propKey;
     // Fall back to the registry-declared label so host-app overrides (e.g.
-    // villa's TwoColumn adding `sectionId`) surface as "Edit Section id" rather
+    // a host site's TwoColumn adding `sectionId`) surface as "Edit Section id" rather
     // than leaking the raw camelCase key into the UI.
     return human === propKey ? `Edit ${propKey}` : `Edit ${human.toLowerCase()}`;
 }

package/dist/nlp/plan-normalizer.js

@@ -1,6 +1,135 @@
-import { allowedBlockTypes, declaredDefaultPropsForType, defaultPropsForType as sharedDefaultPropsForType } from "@avocadostudio-ai/shared";
+import { allowedBlockTypes, blockSchemas, declaredDefaultPropsForType, defaultPropsForType as sharedDefaultPropsForType, getBlockMeta } from "@avocadostudio-ai/shared";
 import { extractRouteMentions, firstRouteMention, normalizeRouteCandidate, parseCreatePageRequest } from "./intent-helpers.js";
 // ---------------------------------------------------------------------------
+// Prop-name aliasing, asked of the registry rather than of a literal
+// ---------------------------------------------------------------------------
+/*
+ * Models confuse Avocado's own prop names — `heading` for a section that calls
+ * it `title`, `question`/`answer` for FAQ items that call them `q`/`a`. The
+ * aliases below exist to repair that, and they are worth keeping.
+ *
+ * They were applied by comparing the block type against the literal string
+ * "Hero", which is a name only Avocado's own catalogue has. Every other block
+ * in the world is `!== "Hero"`, so a site that brings its own blocks and names
+ * a text prop `heading` had that prop deleted here and replaced with `title` —
+ * a prop its schema does not have. The ops engine then stripped `title` as a
+ * hallucinated prop, the edit vanished, and the user was told that "some
+ * requested styling isn't available" on their block. Nothing in the chain was
+ * wrong about its own job; the first link was answering a question about a name
+ * instead of about a schema.
+ *
+ * So ask the registry. A rename now requires positive evidence in both
+ * directions: the block cannot take the key the planner used, and can take the
+ * one we would rewrite it to. Every other case — unknown block type, a block
+ * that accepts both, a block that accepts neither — leaves the value alone,
+ * which is the answer that loses no data.
+ */
+function blockAcceptsProp(blockType, prop) {
+    if (!blockType)
+        return false;
+    const meta = getBlockMeta(blockType);
+    if (meta?.fields && prop in meta.fields)
+        return true;
+    // Manifest-registered blocks may carry a schema richer than their derived
+    // meta, so the schema gets the second look rather than the first refusal.
+    const shape = blockSchemas[blockType]?.shape;
+    return Boolean(shape && prop in shape);
+}
+/*
+ * Avocado's own `autoplay` / `loop` / `striped` are string enums ("true" /
+ * "false"), not booleans, so a model that emits a real boolean has to be
+ * coerced. That coercion ran on every block type, and a custom block whose
+ * `loop` is a genuine `z.boolean()` had the string `"true"` written into it —
+ * silently, and only on the chat path, so it looked like a CMS problem.
+ *
+ * Coerce only where the block actually declares the prop as a string enum.
+ */
+const BOOLEAN_ENUM_PROPS = ["autoplay", "loop", "striped"];
+/**
+ * Ask the block's own schema, which is the only thing that actually knows:
+ * rewrite a boolean to `"true"`/`"false"` exactly when the schema rejects the
+ * boolean and accepts the string. A block that takes a real boolean keeps it,
+ * a block that takes either keeps what the planner sent, and an unregistered
+ * type is left alone.
+ */
+function coerceBooleanEnumProps(blockType, props) {
+    const shape = blockSchemas[blockType]?.shape;
+    if (!shape)
+        return;
+    for (const key of BOOLEAN_ENUM_PROPS) {
+        const value = props[key];
+        if (typeof value !== "boolean")
+            continue;
+        const field = shape[key];
+        if (typeof field?.safeParse !== "function")
+            continue;
+        const asString = value ? "true" : "false";
+        /*
+         * Round-trip, not merely "parses". Avocado's own `autoplay` is
+         * `z.enum(["true","false"]).default("false").catch("false")`, and `.catch`
+         * means a boolean parses *successfully* — into the wrong value. Accepting
+         * that as "the block wants a boolean" would leave the silent wrong answer
+         * in place. A schema genuinely wants a boolean only when it gives the
+         * boolean back unchanged.
+         */
+        const asBool = field.safeParse(value);
+        if (asBool.success && asBool.data === value)
+            continue;
+        const asStr = field.safeParse(asString);
+        if (!asStr.success || asStr.data !== asString)
+            continue;
+        props[key] = asString;
+    }
+}
+/** Rename `from`→`to` only when the block demonstrably wants `to` and not `from`. */
+function shouldAliasProp(blockType, from, to) {
+    return !blockAcceptsProp(blockType, from) && blockAcceptsProp(blockType, to);
+}
+/*
+ * The same question for a key inside a list item. `listFields[key].itemFields`
+ * is the declared shape; a block with no declared list metadata answers "no"
+ * to both halves and is therefore left alone.
+ */
+function listItemAcceptsKey(blockType, listKey, itemKey) {
+    if (!blockType)
+        return false;
+    const itemFields = getBlockMeta(blockType)?.listFields?.[listKey]?.itemFields;
+    return Boolean(itemFields && itemKey in itemFields);
+}
+function shouldAliasItemKey(blockType, listKey, from, to) {
+    return (!listItemAcceptsKey(blockType, listKey, from) && listItemAcceptsKey(blockType, listKey, to));
+}
+const ITEM_KEY_ALIASES = {
+    question: "q",
+    answer: "a",
+    testimonial: "quote",
+    review: "quote"
+};
+/**
+ * Apply the list-item aliases to one array prop, block-type aware.
+ * Shared by the `update_props` and `add_block` paths so they cannot drift.
+ */
+function aliasListItems(blockType, listKey, value) {
+    return value.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return item;
+        const entry = item;
+        let changed = false;
+        const mapped = {};
+        for (const [k, v] of Object.entries(entry)) {
+            const alias = ITEM_KEY_ALIASES[k.toLowerCase()];
+            if (alias && !(alias in entry) && shouldAliasItemKey(blockType, listKey, k.toLowerCase(), alias)) {
+                mapped[alias] = v;
+                changed = true;
+            }
+            else {
+                mapped[k] = v;
+            }
+        }
+        return changed ? mapped : entry;
+    });
+}
+// ---------------------------------------------------------------------------
 // Op reordering: create_page must precede ops targeting the same slug
 // ---------------------------------------------------------------------------
 function reorderCreatePageFirst(ops) {
@@ -582,6 +711,19 @@ export function normalizePlanCandidate(input, args) {
         return args.currentPage.blocks[idx - 1]?.id;
     };
     const usedBlockIds = new Set((args?.currentPage?.blocks ?? []).map((b) => b.id));
+    /**
+     * Block ids this pass renamed, old → new.
+     *
+     * Renaming an `add_block` id is only safe if the rest of the plan follows it.
+     * A plan that adds `b_hero_x` and then updates `b_hero_x` means the block it
+     * just added; leave the reference pointing at the colliding name and the
+     * update lands on the *existing* block instead — content written over the
+     * wrong block, which is the failure mode this repo keeps re-shipping. Ops are
+     * normalized in order, so only ops after the rename are rewritten: a
+     * reference that came *before* the add_block can only have meant the block
+     * that was already there.
+     */
+    const renamedBlockIds = new Map();
     let createdPageSlug;
     let droppedPageLevelUpdate = false;
     // itemIds already claimed by a remove_item freeze in THIS plan — used to spot
@@ -843,6 +985,19 @@ export function normalizePlanCandidate(input, args) {
             raw.afterBlockId =
                 raw.after_block_id ?? raw.after ?? raw.insertAfterId ?? beforeToAfter(raw.beforeId ?? raw.insertBeforeId);
         }
+        // Follow any add_block id an earlier op in this plan had to uniquify. Runs
+        // after the alias resolution above so `after_block_id` and friends are
+        // already folded into the canonical keys. See `renamedBlockIds`.
+        if (renamedBlockIds.size > 0) {
+            for (const key of ["blockId", "afterBlockId", "newBlockId"]) {
+                const value = raw[key];
+                if (typeof value === "string") {
+                    const renamed = renamedBlockIds.get(value);
+                    if (renamed)
+                        raw[key] = renamed;
+                }
+            }
+        }
         if (!raw.afterPageSlug) {
             raw.afterPageSlug =
                 raw.afterPageSlug ??
@@ -886,38 +1041,17 @@ export function normalizePlanCandidate(input, args) {
             const patch = raw.patch;
             const targetBlock = args?.currentPage?.blocks.find((b) => b.id === raw.blockId);
             const blockType = targetBlock?.type ?? "";
-            if (blockType !== "Hero" && "heading" in patch && !("title" in patch)) {
+            if ("heading" in patch && !("title" in patch) && shouldAliasProp(blockType, "heading", "title")) {
                 patch.title = patch.heading;
                 delete patch.heading;
             }
-            const itemKeyAliases = { question: "q", answer: "a", testimonial: "quote", review: "quote" };
             for (const [propKey, propVal] of Object.entries(patch)) {
                 if (!Array.isArray(propVal))
                     continue;
-                patch[propKey] = propVal.map((item) => {
-                    if (!item || typeof item !== "object" || Array.isArray(item))
-                        return item;
-                    const entry = item;
-                    let changed = false;
-                    const mapped = {};
-                    for (const [k, v] of Object.entries(entry)) {
-                        const alias = itemKeyAliases[k.toLowerCase()];
-                        if (alias && !(alias in entry)) {
-                            mapped[alias] = v;
-                            changed = true;
-                        }
-                        else {
-                            mapped[k] = v;
-                        }
-                    }
-                    return changed ? mapped : entry;
-                });
+                patch[propKey] = aliasListItems(blockType, propKey, propVal);
             }
             // Block-specific prop key remapping and type coercion (mirrors add_block path)
-            for (const k of ["autoplay", "loop", "striped"]) {
-                if (typeof patch[k] === "boolean")
-                    patch[k] = patch[k] ? "true" : "false";
-            }
+            coerceBooleanEnumProps(blockType, patch);
             if (blockType === "Carousel" && Array.isArray(patch.slides) && !patch.items) {
                 patch.items = patch.slides;
                 delete patch.slides;
@@ -1138,51 +1272,57 @@ export function normalizePlanCandidate(input, args) {
                     block.props = {};
                 }
             }
-            if ((!block.id || typeof block.id !== "string") && typeof block.type === "string") {
-                let fallbackId = `b_${String(block.type).toLowerCase()}_${Date.now()}`;
+            /*
+             * The model authors this id. Nothing in the `add_block` prompt says how
+             * to build one, so it free-associates from the page and the block type —
+             * `b_featuregrid_wellness` for a FeatureGrid on /avocado-wellness. That is
+             * a near-deterministic function of the prompt, so the same request asked
+             * twice produces the same id twice, and the second one dies in the ops
+             * engine on "Block id … already exists", taking the whole plan down with
+             * it: a committing apply is all-or-nothing.
+             *
+             * `usedBlockIds` is seeded from the page's existing blocks and knew this
+             * all along. It was consulted only when the model *omitted* an id, which
+             * is the one case that cannot collide; a supplied id went through
+             * untouched and was never even registered, so two ops in one plan could
+             * pick the same name. Uniquify instead — a fourth FeatureGrid is a
+             * legitimate reading of "populate this page", and only the label was
+             * wrong. The engine's own check stays as the backstop and must never be
+             * relaxed into an overwrite.
+             */
+            const suppliedId = typeof block.id === "string" && block.id.length > 0 ? block.id : null;
+            const idStem = suppliedId ?? (typeof block.type === "string" ? `b_${String(block.type).toLowerCase()}_${Date.now()}` : null);
+            if (idStem) {
+                let candidate = idStem;
                 let sfx = 0;
-                while (usedBlockIds.has(fallbackId)) {
+                while (usedBlockIds.has(candidate)) {
                     sfx++;
-                    fallbackId = `b_${String(block.type).toLowerCase()}_${Date.now()}_${sfx}`;
+                    candidate = `${idStem}_${sfx}`;
                 }
-                usedBlockIds.add(fallbackId);
-                block.id = fallbackId;
+                usedBlockIds.add(candidate);
+                if (suppliedId && candidate !== suppliedId)
+                    renamedBlockIds.set(suppliedId, candidate);
+                block.id = candidate;
             }
             raw.block = block;
             // Remap heading→title for non-Hero blocks (LLMs often confuse heading/title)
             if (block.props && typeof block.props === "object" && !Array.isArray(block.props)) {
                 const bProps = block.props;
                 const blockType = typeof block.type === "string" ? block.type : "";
-                if (blockType !== "Hero" && "heading" in bProps && !("title" in bProps)) {
+                if ("heading" in bProps && !("title" in bProps) && shouldAliasProp(blockType, "heading", "title")) {
                     bProps.title = bProps.heading;
                     delete bProps.heading;
                 }
             }
-            // Remap list item keys inside add_block props (e.g., question→q, answer→a)
+            // Remap list item keys inside add_block props (e.g., question→q, answer→a),
+            // asking the block's own list metadata rather than rewriting every array.
             if (block.props && typeof block.props === "object" && !Array.isArray(block.props)) {
                 const bProps = block.props;
-                const itemKeyAliases = { question: "q", answer: "a", testimonial: "quote", review: "quote" };
+                const blockType = typeof block.type === "string" ? block.type : "";
                 for (const [propKey, propVal] of Object.entries(bProps)) {
                     if (!Array.isArray(propVal))
                         continue;
-                    bProps[propKey] = propVal.map((item) => {
-                        if (!item || typeof item !== "object" || Array.isArray(item))
-                            return item;
-                        const entry = item;
-                        let changed = false;
-                        const mapped = {};
-                        for (const [k, v] of Object.entries(entry)) {
-                            const alias = itemKeyAliases[k.toLowerCase()];
-                            if (alias && !(alias in entry)) {
-                                mapped[alias] = v;
-                                changed = true;
-                            }
-                            else {
-                                mapped[k] = v;
-                            }
-                        }
-                        return changed ? mapped : entry;
-                    });
+                    bProps[propKey] = aliasListItems(blockType, propKey, propVal);
                 }
             }
             // Block-specific prop key remapping and type coercion
@@ -1190,10 +1330,7 @@ export function normalizePlanCandidate(input, args) {
                 const cProps = block.props;
                 const bt = block.type;
                 // Coerce boolean→string for "true"/"false" enum props (Carousel, Video, Table)
-                for (const k of ["autoplay", "loop", "striped"]) {
-                    if (typeof cProps[k] === "boolean")
-                        cProps[k] = cProps[k] ? "true" : "false";
-                }
+                coerceBooleanEnumProps(typeof bt === "string" ? bt : "", cProps);
                 // Carousel: slides→items
                 if (bt === "Carousel" && Array.isArray(cProps.slides) && !cProps.items) {
                     cProps.items = cProps.slides;

package/dist/ops/destructive-action-gate.js

@@ -24,12 +24,17 @@ function slugsTouchedByOps(ops) {
             set.add(op.toPageSlug);
             continue;
         }
+        // rename_page: one page, under two names. Counting both slugs made every
+        // rename look like a cross-page plan and held it for approval — the same
+        // miscount duplicate_page and duplicate_block are special-cased for above.
+        if (op.op === "rename_page") {
+            set.add(typeof op.newPageSlug === "string" ? op.newPageSlug : op.pageSlug);
+            continue;
+        }
         if ("pageSlug" in op && typeof op.pageSlug === "string")
             set.add(op.pageSlug);
         if (op.op === "duplicate_block" && typeof op.toPageSlug === "string")
             set.add(op.toPageSlug);
-        if (op.op === "rename_page" && typeof op.newPageSlug === "string")
-            set.add(op.newPageSlug);
     }
     return Array.from(set);
 }

package/dist/ops/ops-engine.d.ts

@@ -22,7 +22,18 @@ export declare function isNoEffectiveChangeError(reason: string): boolean;
  */
 export declare function isAlreadyCurrentError(reason: string): boolean;
 export declare function classifyGuardrailError(reason: string): GuardrailErrorCategory;
-export declare function formatValidationError(reason: string): string;
+/**
+ * `category` is the one the failure was actually thrown with, for callers that
+ * still hold it. Without it this falls back to reading the category back out of
+ * the message, which is a guess — see `isRepairEligibleCategory`.
+ */
+export declare function formatValidationError(reason: string, category?: GuardrailErrorCategory): string;
+/**
+ * The deterministic repair pass exists for plans that are structurally wrong
+ * but fixable — a bad prop name, an id that clashes. Anything else is either
+ * hopeless or not the planner's fault, and re-prompting it wastes a model call.
+ */
+export declare function isRepairEligibleCategory(category: GuardrailErrorCategory): category is "schema_violation";
 export declare function isDeterministicRepairEligible(reason: string): boolean;
 /**
  * Extracts structured fields from a planner schema_violation reason so the