@aglyn/plugins-ai 1.0.0-beta.243 → 1.0.0-beta.246

package/src/lib/runtime/ai-doctrine-validators.d.ts

@@ -130,6 +130,14 @@ export interface AiDoctrineTreeContext extends AiNodeTreeContext {
      * to when the site has none for what it promises. Absent: none is known.
      */
     homeScreenIds?: readonly string[];
+    /**
+     * The site's pages that place its form, by id (AGL-3729): where a link whose
+     * words ask a visitor to get in touch (`aiAsksToGetInTouch`) does what it
+     * says, even when that page is home. A guided start's café put its
+     * pre-order form on Home, and its Menu page's "Request weekend pickup"
+     * links there. Absent: none is known, and a link home is held to its words.
+     */
+    formScreenIds?: readonly string[];
     /**
      * The node as the model wrote it, by the id the checked tree gives it
      * (AGL-3078), for a tree that was stored before it is checked: a page
@@ -472,6 +480,39 @@ export declare function isAiLinkElement(componentId: unknown): boolean;
  * a re-ask to inherit the band's contrast text or to set it.
  */
 export declare function detectInvisibleLinks(tree: AiDoctrineTree, outputKind: AiOutputKind): AiDoctrineViolation[];
+/**
+ * Whether a link's words ask a visitor to get in touch — contact, book, quote,
+ * request, order, pre-order, enquire — which the site's form answers
+ * (AGL-3729). The layout language sends such a link to the form.
+ */
+export declare function aiAsksToGetInTouch(label: string): boolean;
+/**
+ * RULE 10'S LINK SENT HOME, REPAIRED IN CODE (AGL-3729).
+ *
+ * The rule's own advice is "link the page that does, or leave the link out",
+ * and both halves are something code can do once it knows where the site's
+ * form is. A Free guided start's café (beta.243, 2026-10-12) put its contact
+ * and pre-order form on Home; its Menu page's "Request weekend pickup" was
+ * sent to Home, and the page was refused on every answer, since the
+ * destination was the compiler's, not the model's. So, before the check reads
+ * the tree, each link `detectUnrelatedScreenLinks` would refuse is:
+ *
+ * - repointed to the page that places the site's form, when its words ask a
+ *   visitor to get in touch and the site has such a page that is not the page
+ *   being checked (`formScreenIds`, `ownScreenIds`). The platform reaches a
+ *   section of another page by no anchor (AGL-2867), so the link names the
+ *   page; a link to a section of its own page is the Scroll to element
+ *   interaction, which this never writes;
+ * - otherwise left out: the node and everything under it are taken off the
+ *   page, and out of its parent's children.
+ *
+ * The root is never taken out. A tree with nothing to repair comes back as
+ * the same object; a node that is changed is copied, never edited in place.
+ */
+export declare function aiSettleUnrelatedScreenLinks<T extends AiDoctrineTree>(tree: T, outputKind: AiOutputKind, context?: Pick<AiDoctrineTreeContext, 'homeScreenIds' | 'formScreenIds'> & {
+    /** The page being checked, by every id it goes by: a link never goes to itself. */
+    ownScreenIds?: readonly string[];
+}): T;
 /**
  * Rule 10, for a link sent where the site has nothing for it (AGL-3056). A
  * link whose purpose the site has no screen for is left out; it never goes to
@@ -483,7 +524,7 @@ export declare function detectInvisibleLinks(tree: AiDoctrineTree, outputKind: A
  * not say home is refused, with a re-ask to link the screen that does what it
  * says, or to leave the link out.
  */
-export declare function detectUnrelatedScreenLinks(tree: AiDoctrineTree, outputKind: AiOutputKind, context?: Pick<AiDoctrineTreeContext, 'homeScreenIds'>): AiDoctrineViolation[];
+export declare function detectUnrelatedScreenLinks(tree: AiDoctrineTree, outputKind: AiOutputKind, context?: Pick<AiDoctrineTreeContext, 'homeScreenIds' | 'formScreenIds'>): AiDoctrineViolation[];
 /**
  * Rule 10, for a link that goes nowhere (AGL-3072). A Button or a Screen Link
  * goes where its `screenId` or its `href` says, and those are the only
@@ -849,6 +890,23 @@ export declare function aiSettlePlanFormDatasets(plan: AiBuildPlan, inventory: A
  * so the rule still asks.
  */
 export declare function aiSettlePlanLayouts(plan: AiBuildPlan, inventory: AiSiteInventory | null, capabilities?: AiPlanCapabilities | null): AiBuildPlan;
+/**
+ * A page section that is a layout region — a header, navigation or footer,
+ * read by the name rule 2's `plan-layout-region-section` reads — is taken off
+ * the page before the rules read the plan (AGL-3750). The region is already
+ * the layout's, so the rule's own answer, "take the section off the page", is
+ * the only one: a live Free start of 2026-10-12 (a bakery that sells cakes to
+ * order) planned a Header and a Footer on its pages three times and stopped.
+ *
+ * Only a section that places nothing, or nothing but a layout (which rule 2
+ * refuses placing as well), is taken off: one that places a form or a
+ * component may be a band misnamed, so the rule still asks. A page whose
+ * every section is a region keeps them all, and is re-asked as before, since
+ * a page of no sections has no answer here. A home this leaves under its
+ * fewest sections, or a Free plan still past its wall, is the existing
+ * checks' to settle or refuse.
+ */
+export declare function aiSettlePlanLayoutRegionSections(plan: AiBuildPlan, inventory: AiSiteInventory | null): AiBuildPlan;
 /** The contact form a plan is given when a section collects answers and the plan makes no form. */
 export declare const AI_PLAN_SETTLED_FORM: {
     readonly name: "Contact form";
@@ -986,6 +1044,42 @@ export declare function aiFreePageSectionsWithin(creations: {
     layouts: number;
     pages?: number;
 }, credits?: Readonly<AiFreePageWorstCase>): number;
+/**
+ * The most sections past the Free wall a plan is trimmed by rather than
+ * re-asked (AGL-3737). The live candle-shop start of 2026-10-12 planned 9
+ * sections against a wall of 8 on all three answers, each with a home of 7:
+ * the model reaching for the budget the site redo names ("plan 7 to 8") and
+ * landing one band past it, which no re-ask cured. Within two, the plan's
+ * shape is right and only a band or two the brief needs least is extra, so
+ * taking those from the end loses nothing the plan depends on. Further over,
+ * the shape itself is off — a list planned as sections, a page the wall
+ * cannot pay for — and cutting more would drop content the model meant, so
+ * that plan is still re-asked.
+ */
+export declare const AI_FREE_WALL_SETTLE_MAX_OVER = 2;
+/**
+ * A Free plan a section or two past the wall is trimmed to fit before the
+ * rules read the plan (AGL-3737), rather than re-asked: which sections go has
+ * one answer, so the re-ask only costs the member a stopped start. The live
+ * candle-shop start of 2026-10-12 asked for a home of 7 and a second page of
+ * 2 against a wall of 8, three answers running, and stopped needing input.
+ *
+ * One section goes at a time, the last of its page that `freeWallKeeps`
+ * does not hold, from the page furthest past its share: the home at / past
+ * its fewest (`aiSiteHomeMinSections`, five on a site start whose wall pays
+ * for a full home), any other page past two; on a tie, the longer page, then
+ * the home. No home goes under its fewest and no page under one section. The
+ * shares are what a site start is told to plan (a home of five or six, the
+ * other page two or three): the candle shop's 7 + 2 becomes 6 + 2, never
+ * 7 + 1, and the recorded yoga answer's 6 + 4 becomes 5 + 3, the shape its
+ * own redo chose.
+ *
+ * A plan more than `AI_FREE_WALL_SETTLE_MAX_OVER` past the wall, a site
+ * start past its page cap, a plan with a list split into sections, and a
+ * plan the trim cannot fit without a section it keeps are returned
+ * unchanged, for the wall to re-ask.
+ */
+export declare function aiSettlePlanFreeWall(plan: AiBuildPlan, inventory: AiSiteInventory | null, capabilities?: AiPlanCapabilities | null): AiBuildPlan;
 /**
  * The Free wall (plan): a plan asks for no more sections than the Free taste
  * pays for at its worst beside what the job builds first (AGL-3070). A live

package/src/lib/runtime/ai-doctrine-validators.js

@@ -26,6 +26,8 @@ import { renderEmailHtml } from "@aglyn/shared-util-email/email-render";
 import { AI_BUILD_PLAN_CREATION_NOUNS, AI_BUILD_PLAN_EMBED_HOST_NAMES, AI_BUILD_PLAN_LIMITS, AI_PLAN_ASKS_FOR_VIDEO, aiEmbedHostOf, aiEmbedVideoKey, AI_PLAN_DATASET_ITEM_OP, aiPlanCreateFor, aiPlanFormDatasetNames, aiPlanItemFor, aiPlanSlugKey, aiPlanUndeclaredRefs, isAiPlanNewRef } from "../model/ai-build-plan.js";
 import { aiCreationNoun, aiPlanCanPlaceForm, aiPlanUncreatable, aiPlanUncreatableKind } from "../model/ai-plan-capabilities.js";
 import { aiFreeSiteSectionsWithin, aiSiteHomeMinSections, aiSitePlanIsHome } from "../model/ai-site-job.js";
+import { aiLayoutIsShopPage, aiLayoutShopGridSection } from "../layout-language/ai-layout-listings.js";
+import { aiStorefrontSays } from "../layout-language/ai-layout-storefront.js";
 import { AI_INSTANCE_REF_PROP, validateAiNodeTree } from "./ai-node-tree.js";
 import { AI_PAGE_SCROLL_TO_PROP, aiPageLinkTarget, aiStoredScrollTargets } from "./ai-page-links.js";
 import { AI_EMAIL_CLIP_BYTES, AI_OUTPUT_BUDGETS, AI_OUTPUT_SURFACE, AI_TEXT_LIMITS, isHeadlineVariant } from "./ai-palette.js";
@@ -1841,20 +1843,23 @@ const GRID = 'muiGrid';
     ];
 }
 /** A link's words that say it goes home. */ const HOME_WORDS = /\bhome(?:\s?page)?\b/i;
+/** Words that ask a visitor to get in touch, which the site's form answers. */ const GET_IN_TOUCH_WORDS = /\b(?:contact|book|booking|call|quote|estimate|appointment|schedule|reserve|reservation|get in touch|request|visit|enquire|inquire|enquiry|inquiry|message|talk|consult|consultation|order|pre-?order|sign up|join|apply|start)\b/i;
 /**
- * Rule 10, for a link sent where the site has nothing for it (AGL-3056). A
- * link whose purpose the site has no screen for is left out; it never goes to
- * a screen that does something else. The site inventory cannot say what each
- * screen is for, but it can name the one a model falls back to: a live About
- * page's footer sent "Request a Consultation" to the home screen, because the
- * site had no consultation screen. So a Screen Link or a Button, outside the
- * header and the navigation, that links the home screen with words that do
- * not say home is refused, with a re-ask to link the screen that does what it
- * says, or to leave the link out.
- */ export function detectUnrelatedScreenLinks(tree, outputKind, context = {}) {
-    var _context_homeScreenIds;
+ * Whether a link's words ask a visitor to get in touch — contact, book, quote,
+ * request, order, pre-order, enquire — which the site's form answers
+ * (AGL-3729). The layout language sends such a link to the form.
+ */ export function aiAsksToGetInTouch(label) {
+    return GET_IN_TOUCH_WORDS.test(label);
+}
+/**
+ * The links rule 10 refuses as sent home for nothing (`detectUnrelatedScreenLinks`),
+ * in document order. A link whose words ask a visitor to get in touch, sent to
+ * a home page that places the site's form, does what it says (AGL-3729).
+ */ function unrelatedScreenLinks(tree, outputKind, context) {
+    var _context_homeScreenIds, _context_formScreenIds;
     if (outputKind === 'email' || outputKind === 'form') return [];
     const home = new Set((_context_homeScreenIds = context.homeScreenIds) != null ? _context_homeScreenIds : []);
+    const forms = new Set((_context_formScreenIds = context.formScreenIds) != null ? _context_formScreenIds : []);
     const sent = [];
     for (const visit of walkTree(tree)){
         var _node_props, _node_props1, _node_props2;
@@ -1864,6 +1869,8 @@ const GRID = 'muiGrid';
         const linksHome = typeof screenId === 'string' && home.has(screenId) || ((_node_props1 = node.props) == null ? void 0 : _node_props1['href']) === '/';
         const label = typeof ((_node_props2 = node.props) == null ? void 0 : _node_props2['children']) === 'string' ? node.props['children'].trim() : '';
         if (!linksHome || !label || HOME_WORDS.test(label)) continue;
+        // Home holds the site's form, and the words ask for what it does (AGL-3729).
+        if (typeof screenId === 'string' && forms.has(screenId) && aiAsksToGetInTouch(label)) continue;
         // The header and the navigation link home by name and by the site's own brand.
         const inNavigation = hasAncestor(tree, visit, (ancestor)=>ancestor.componentId === 'muiAppBar' || [
                 'header',
@@ -1874,6 +1881,88 @@ const GRID = 'muiGrid';
             label
         });
     }
+    return sent;
+}
+/**
+ * RULE 10'S LINK SENT HOME, REPAIRED IN CODE (AGL-3729).
+ *
+ * The rule's own advice is "link the page that does, or leave the link out",
+ * and both halves are something code can do once it knows where the site's
+ * form is. A Free guided start's café (beta.243, 2026-10-12) put its contact
+ * and pre-order form on Home; its Menu page's "Request weekend pickup" was
+ * sent to Home, and the page was refused on every answer, since the
+ * destination was the compiler's, not the model's. So, before the check reads
+ * the tree, each link `detectUnrelatedScreenLinks` would refuse is:
+ *
+ * - repointed to the page that places the site's form, when its words ask a
+ *   visitor to get in touch and the site has such a page that is not the page
+ *   being checked (`formScreenIds`, `ownScreenIds`). The platform reaches a
+ *   section of another page by no anchor (AGL-2867), so the link names the
+ *   page; a link to a section of its own page is the Scroll to element
+ *   interaction, which this never writes;
+ * - otherwise left out: the node and everything under it are taken off the
+ *   page, and out of its parent's children.
+ *
+ * The root is never taken out. A tree with nothing to repair comes back as
+ * the same object; a node that is changed is copied, never edited in place.
+ */ export function aiSettleUnrelatedScreenLinks(tree, outputKind, context = {}) {
+    var _context_ownScreenIds, _find, _context_formScreenIds;
+    const sent = unrelatedScreenLinks(tree, outputKind, context);
+    if (!sent.length) return tree;
+    const own = new Set((_context_ownScreenIds = context.ownScreenIds) != null ? _context_ownScreenIds : []);
+    const formScreen = (_find = ((_context_formScreenIds = context.formScreenIds) != null ? _context_formScreenIds : []).find((id)=>!own.has(id))) != null ? _find : null;
+    const nodes = _extends({}, tree.nodes);
+    const parents = new Map();
+    for (const visit of walkTree(tree)){
+        const parent = visit.ancestors[visit.ancestors.length - 1];
+        if (parent !== undefined) parents.set(visit.id, parent);
+    }
+    for (const { id, label } of sent){
+        var _nodes_parent_nodes;
+        if (!nodes[id]) continue;
+        if (formScreen && aiAsksToGetInTouch(label)) {
+            var _nodes_id_props;
+            const props = _extends({}, (_nodes_id_props = nodes[id].props) != null ? _nodes_id_props : {}, {
+                screenId: formScreen
+            });
+            delete props['href'];
+            nodes[id] = _extends({}, nodes[id], {
+                props
+            });
+            continue;
+        }
+        const parent = parents.get(id);
+        if (parent === undefined || !nodes[parent]) continue;
+        nodes[parent] = _extends({}, nodes[parent], {
+            nodes: ((_nodes_parent_nodes = nodes[parent].nodes) != null ? _nodes_parent_nodes : []).filter((child)=>child !== id)
+        });
+        const stack = [
+            id
+        ];
+        while(stack.length){
+            var _ref;
+            var _nodes_next;
+            const next = stack.pop();
+            stack.push(...(_ref = (_nodes_next = nodes[next]) == null ? void 0 : _nodes_next.nodes) != null ? _ref : []);
+            delete nodes[next];
+        }
+    }
+    return _extends({}, tree, {
+        nodes
+    });
+}
+/**
+ * Rule 10, for a link sent where the site has nothing for it (AGL-3056). A
+ * link whose purpose the site has no screen for is left out; it never goes to
+ * a screen that does something else. The site inventory cannot say what each
+ * screen is for, but it can name the one a model falls back to: a live About
+ * page's footer sent "Request a Consultation" to the home screen, because the
+ * site had no consultation screen. So a Screen Link or a Button, outside the
+ * header and the navigation, that links the home screen with words that do
+ * not say home is refused, with a re-ask to link the screen that does what it
+ * says, or to leave the link out.
+ */ export function detectUnrelatedScreenLinks(tree, outputKind, context = {}) {
+    const sent = unrelatedScreenLinks(tree, outputKind, context);
     if (!sent.length) return [];
     return [
         {
@@ -3682,6 +3771,37 @@ const FORM_SECTION_NAME = /\bform\b|\bsign[- ]?up\b|\bsubscribe\b|\bnewsletter\b
             }))
     });
 }
+/**
+ * A page section that is a layout region — a header, navigation or footer,
+ * read by the name rule 2's `plan-layout-region-section` reads — is taken off
+ * the page before the rules read the plan (AGL-3750). The region is already
+ * the layout's, so the rule's own answer, "take the section off the page", is
+ * the only one: a live Free start of 2026-10-12 (a bakery that sells cakes to
+ * order) planned a Header and a Footer on its pages three times and stopped.
+ *
+ * Only a section that places nothing, or nothing but a layout (which rule 2
+ * refuses placing as well), is taken off: one that places a form or a
+ * component may be a band misnamed, so the rule still asks. A page whose
+ * every section is a region keeps them all, and is re-asked as before, since
+ * a page of no sections has no answer here. A home this leaves under its
+ * fewest sections, or a Free plan still past its wall, is the existing
+ * checks' to settle or refuse.
+ */ export function aiSettlePlanLayoutRegionSections(plan, inventory) {
+    const kinds = inventoryKinds(inventory);
+    const removable = (section)=>LAYOUT_REGION_NAME.test(section.name) && section.uses.every((ref)=>refKind(ref, plan, kinds) === 'layout');
+    let changed = false;
+    const screens = plan.screens.map((screen)=>{
+        const kept = screen.sections.filter((section)=>!removable(section));
+        if (kept.length === screen.sections.length || !kept.length) return screen;
+        changed = true;
+        return _extends({}, screen, {
+            sections: kept
+        });
+    });
+    return changed ? _extends({}, plan, {
+        screens
+    }) : plan;
+}
 /** Every saved form a plan could place, the plan's own creations first. */ function planFormChoices(plan, inventory) {
     var _ref;
     return [
@@ -4332,6 +4452,135 @@ function slugKey(slug) {
     const needs = !((_ref = inventory == null ? void 0 : inventory.layouts.length) != null ? _ref : 0) && capabilities.create.layout.allowed ? 1 : 0;
     return Math.max(creates, needs);
 }
+/** The Free wall a plan is held to, or null where the job is not on the Free taste. */ function freePlanWall(plan, inventory, capabilities) {
+    if (!(capabilities == null ? void 0 : capabilities.freeTaste)) return null;
+    const asked = plan.screens.reduce((sum, screen)=>sum + screen.sections.length, 0);
+    const layouts = freePlanLayouts(plan, inventory, capabilities);
+    const pages = Math.max(plan.screens.length, 1);
+    // A Free site scaffold (AGL-3594) is held to its page cap first, and then to
+    // what a SITE plan's worst case leaves for sections, with room for a retry.
+    const sitePages = capabilities.freeSitePages;
+    const overPages = sitePages !== undefined && plan.screens.length > sitePages;
+    // A site start's saved form is a step of its own (AGL-3596), counted on the wall since AGL-3660.
+    const forms = plan.create.filter((entry)=>entry.kind === 'form').length - aiPlanUncreatable(plan, capabilities).filter((entry)=>entry.kind === 'form').length;
+    const fits = sitePages !== undefined ? aiFreeSiteSectionsWithin({
+        layouts,
+        pages,
+        forms: Math.max(0, forms)
+    }, FREE_AI_TASTE_CREDITS_PER_MONTH) : aiFreePageSectionsWithin({
+        layouts,
+        pages
+    });
+    // A site start's home keeps its full five (AGL-3660): told only "plan at
+    // most 8", the live yoga start of 2026-10-08 cut a home of 6 to 4 and kept
+    // its other page, so the redo names where the sections come from.
+    const homeMin = sitePages !== undefined && plan.screens.some(aiSitePlanIsHome) ? aiSiteHomeMinSections({
+        pages,
+        across: fits
+    }) : 0;
+    return {
+        asked,
+        fits,
+        layouts,
+        pages,
+        sitePages,
+        overPages,
+        homeMin
+    };
+}
+/**
+ * The most sections past the Free wall a plan is trimmed by rather than
+ * re-asked (AGL-3737). The live candle-shop start of 2026-10-12 planned 9
+ * sections against a wall of 8 on all three answers, each with a home of 7:
+ * the model reaching for the budget the site redo names ("plan 7 to 8") and
+ * landing one band past it, which no re-ask cured. Within two, the plan's
+ * shape is right and only a band or two the brief needs least is extra, so
+ * taking those from the end loses nothing the plan depends on. Further over,
+ * the shape itself is off — a list planned as sections, a page the wall
+ * cannot pay for — and cutting more would drop content the model meant, so
+ * that plan is still re-asked.
+ */ export const AI_FREE_WALL_SETTLE_MAX_OVER = 2;
+/** A section through which a visitor reaches the owner: contact, a visit, a booking. */ const REACH_SECTION_NAME = /\b(?:contact|get in touch|visit(?: us)?|find us|locations?|hours|book(?:ing)?|reserve|reservations?)\b/i;
+/**
+ * Whether the Free wall's trim keeps a section of a page (AGL-3737): the
+ * page's opening, any section that places something (a dataset it lists, a
+ * form, a component — dropping it would leave a creation unplaced), one that
+ * collects answers or says how to reach the owner, and a storefront's
+ * listing parts — the bestsellers, the collections, the sign-up, and a Shop
+ * page's product grid.
+ */ function freeWallKeeps(screen, index) {
+    const section = screen.sections[index];
+    if (index === 0 || section.uses.length > 0) return true;
+    if (FORM_SECTION_NAME.test(section.name) || REACH_SECTION_NAME.test(section.name)) return true;
+    if (aiStorefrontSays('featured', section.name) || aiStorefrontSays('collections', section.name) || aiStorefrontSays('signup', section.name)) {
+        return true;
+    }
+    return aiLayoutIsShopPage(screen) && aiLayoutShopGridSection(screen.sections) === index;
+}
+/**
+ * A Free plan a section or two past the wall is trimmed to fit before the
+ * rules read the plan (AGL-3737), rather than re-asked: which sections go has
+ * one answer, so the re-ask only costs the member a stopped start. The live
+ * candle-shop start of 2026-10-12 asked for a home of 7 and a second page of
+ * 2 against a wall of 8, three answers running, and stopped needing input.
+ *
+ * One section goes at a time, the last of its page that `freeWallKeeps`
+ * does not hold, from the page furthest past its share: the home at / past
+ * its fewest (`aiSiteHomeMinSections`, five on a site start whose wall pays
+ * for a full home), any other page past two; on a tie, the longer page, then
+ * the home. No home goes under its fewest and no page under one section. The
+ * shares are what a site start is told to plan (a home of five or six, the
+ * other page two or three): the candle shop's 7 + 2 becomes 6 + 2, never
+ * 7 + 1, and the recorded yoga answer's 6 + 4 becomes 5 + 3, the shape its
+ * own redo chose.
+ *
+ * A plan more than `AI_FREE_WALL_SETTLE_MAX_OVER` past the wall, a site
+ * start past its page cap, a plan with a list split into sections, and a
+ * plan the trim cannot fit without a section it keeps are returned
+ * unchanged, for the wall to re-ask.
+ */ export function aiSettlePlanFreeWall(plan, inventory, capabilities = null) {
+    const wall = freePlanWall(plan, inventory, capabilities);
+    if (!wall || wall.overPages) return plan;
+    const over = wall.asked - wall.fits;
+    if (over <= 0 || over > AI_FREE_WALL_SETTLE_MAX_OVER) return plan;
+    // A list split into sections is joined by its re-ask, which frees the room;
+    // a trim would cut one of its items and hide the split from the rule.
+    if (detectPlanSplitLists(plan, inventory, capabilities).length) return plan;
+    const kept = plan.screens.map((screen)=>screen.sections.map((section, index)=>({
+                section,
+                index
+            })));
+    const home = plan.screens.findIndex(aiSitePlanIsHome);
+    const floor = (screenIndex)=>screenIndex === home ? Math.max(wall.homeMin, 1) : 1;
+    const target = (screenIndex)=>screenIndex === home ? Math.max(wall.homeMin, 1) : 2;
+    // The last section of a page the trim may take, or -1.
+    const last = (screenIndex)=>{
+        const entries = kept[screenIndex];
+        if (entries.length <= floor(screenIndex)) return -1;
+        for(let at = entries.length - 1; at > 0; at -= 1){
+            if (!freeWallKeeps(plan.screens[screenIndex], entries[at].index)) return at;
+        }
+        return -1;
+    };
+    for(let left = over; left > 0; left -= 1){
+        let pick = -1;
+        for(let index = 0; index < kept.length; index += 1){
+            if (last(index) === -1) continue;
+            const room = kept[index].length - target(index);
+            const best = pick === -1 ? null : kept[pick].length - target(pick);
+            if (best === null || room > best || room === best && (kept[index].length > kept[pick].length || kept[index].length === kept[pick].length && index === home)) {
+                pick = index;
+            }
+        }
+        if (pick === -1) return plan;
+        kept[pick].splice(last(pick), 1);
+    }
+    return _extends({}, plan, {
+        screens: plan.screens.map((screen, index)=>kept[index].length === screen.sections.length ? screen : _extends({}, screen, {
+                sections: kept[index].map((entry)=>entry.section)
+            }))
+    });
+}
 /**
  * The Free wall (plan): a plan asks for no more sections than the Free taste
  * pays for at its worst beside what the job builds first (AGL-3070). A live
@@ -4342,14 +4591,10 @@ function slugKey(slug) {
  * proven with, so no plan the proof admits is refused. It is no building rule,
  * so it names none.
  */ export function detectPlanOverFreeWall(plan, inventory, capabilities) {
-    if (!(capabilities == null ? void 0 : capabilities.freeTaste)) return [];
-    const asked = plan.screens.reduce((sum, screen)=>sum + screen.sections.length, 0);
-    const layouts = freePlanLayouts(plan, inventory, capabilities);
-    const pages = Math.max(plan.screens.length, 1);
-    // A Free site scaffold (AGL-3594) is held to its page cap first, and then to
-    // what a SITE plan's worst case leaves for sections, with room for a retry.
-    const sitePages = capabilities.freeSitePages;
-    if (sitePages !== undefined && plan.screens.length > sitePages) {
+    const wall = freePlanWall(plan, inventory, capabilities);
+    if (!wall) return [];
+    const { asked, layouts, pages, sitePages, fits, homeMin } = wall;
+    if (sitePages !== undefined && wall.overPages) {
         return [
             {
                 rule: null,
@@ -4361,26 +4606,9 @@ function slugKey(slug) {
             }
         ];
     }
-    // A site start's saved form is a step of its own (AGL-3596), counted on the wall since AGL-3660.
-    const forms = plan.create.filter((entry)=>entry.kind === 'form').length - aiPlanUncreatable(plan, capabilities).filter((entry)=>entry.kind === 'form').length;
-    const fits = sitePages !== undefined ? aiFreeSiteSectionsWithin({
-        layouts,
-        pages,
-        forms: Math.max(0, forms)
-    }, FREE_AI_TASTE_CREDITS_PER_MONTH) : aiFreePageSectionsWithin({
-        layouts,
-        pages
-    });
     if (asked <= fits) return [];
     const job = pages > 1 ? `a Free plan of ${pages} pages` : 'a Free page';
     const beside = layouts ? ` that creates ${layouts > 1 ? `${layouts} layouts` : 'its layout'}` : '';
-    // A site start's home keeps its full five (AGL-3660): told only "plan at
-    // most 8", the live yoga start of 2026-10-08 cut a home of 6 to 4 and kept
-    // its other page, so the redo names where the sections come from.
-    const homeMin = sitePages !== undefined && plan.screens.some(aiSitePlanIsHome) ? aiSiteHomeMinSections({
-        pages,
-        across: fits
-    }) : 0;
     const keepHome = homeMin ? ` Keep the home page at / at ${homeMin} or more sections, and take the rest from the other ${pages > 2 ? 'pages' : 'page'}.` : '';
     // A site start's redo keeps the plan full (AGL-3660): the wall's sections
     // are its budget to use, and a redo told only "at most" cuts far under it.