sygnal 6.2.0 → 6.3.0

package/src/extra/ai/compose/decisions.ts

@@ -0,0 +1,1649 @@
+/*
+ * PLAN-9 B-1 / B-2 / B-4: `compose.decisions()`, the decision-model backend of `compose` (TypeSafe Jev,
+ * Ollama `nimble`, anything `decide()` reaches). It composes a layout from the catalog's parts with
+ * choice / noul questions only: the model never writes text. Ported from the research encodings,
+ * with their exact wording:
+ *   - structure: dev-plans/research/ai-compose/structure/composer.mjs (TEXT, 189/210 on Jev);
+ *   - params, records and edits: dev-plans/research/ai-compose/params-edits/params-edits.mjs (W).
+ *
+ * Steps (one `decide()` request each, through the HTTP sink):
+ *   0. categories (parts with a `category`; `prefilter: true`, or the default 'auto' when the select
+ *      step would ask about more than PREFILTER_AT parts, PREFILTER_AT_SMALL with profile 'small'):
+ *      `cat_<id>` per category (B-5: same accuracy at about half the tokens, one more call).
+ *   1. select (state: the request alone):
+ *        use_<part> (omit / use; structure wording, params-edits wording for a part with params); count_<part> (0..maxUses) for a repeatable part;
+ *        pick_<group> (omit + each member) for a `group` of alternatives;
+ *        rec_<part>__<n> (n = 1..4; none + records) for a record part: "which <label> does user_request name
+ *          first / second / …", over the records a lexical prefilter on name / aliases kept;
+ *        param_<part>__<name> for an enum param or the bins of a number param, with not_stated
+ *          (= the default); `type: 'text'` / `'list'` params keep their default (LLM-only; a part
+ *          with a required one and no default is left out, SYG680);
+ *        row: "side by side?" (a noul gate, when the catalog has the built-in `row`).
+ *      Nothing chosen: nothing fits (1 call). One part in one possible place: done (1 call).
+ *   2. layout (state: the request + the selected elements): parent_<k> over the places `in`
+ *      allows; with the row gate on, beside_<k> and left_<a>_vs_<b>; first_<a>_vs_<b> per pair;
+ *      gap_<x>_in_<part> for a part used 2+ times.
+ *      With 4+ elements that may share rows, also same_<a>_vs_<b> (a noul per pair), so a row longer
+ *      than 3 (up to the row container's `max`) can be read: one beside answer per element names
+ *      one neighbour, a chain that average-linkage splits.
+ * Reading is code: rows by average-linkage clustering of `beside` (`rowMean`), order by summed
+ * pairwise probabilities, pins, required parts, companions, containers present only when filled,
+ * `minSlots` unwrap, limits. The result goes through `finish()` (layout.ts), shared with `llm()`.
+ *
+ * Edits (B-4, params-edits.mjs §3, its wording): with a previous layout that has parts, at most 2 calls.
+ *   edit (state: the request + current_page, each node described with its record, settings and
+ *     place): remove_<node> (noul), simpler_<node> (read only under the `simpler` gate),
+ *     set_<node>__<param> (keep + the other options; read only under the `change` gate), add_<part> /
+ *     add_g_<group> for the parts not on the page (+ their params, + 2 record slots over the records
+ *     the request names that aren't on the page), the gates swap / simpler / placed / change, and
+ *     moved_1 / moved_2 (which node does the request move: slots over the nodes, a lookup).
+ *   where (only when something moves or is added): where_<node> per mover over not_stated, top,
+ *     bottom, above:/below:/beside:<node>, into:<container key>:<slot> (the places its `in` allows; a
+ *     container not on the page is created).
+ *   Rules: kept nodes keep their keys (the reply says `keyed`: the behavior doesn't re-key); a
+ *   setting change keeps the key and is never a removal; added nodes get keys the previous layout
+ *   never had; a replacement (swap + one removed + one added) takes the removed node's place and
+ *   row unless its where says otherwise; a reference node (another mover's anchor) never moves; a
+ *   simpler page is never empty; nothing to do at all reads as "nothing fits" (the layout kept).
+ * Every choice respects `maxOptions` (Ollama: 25): a larger one is split into chunks that repeat its
+ * head options, merged back before reading. `profile: 'small'` (G-755): pairwise order questions in
+ * both option orders, near-ties ordered by where the request names the parts.
+ *
+ * `pending` is plain JSON (the behavior keeps it in state): the step, the prompt, the record
+ * values the prefilter kept, the selected items. The questions are rebuilt from it to read a reply,
+ * so a reply is checked against the criteria that were sent (a choice outside them: SYG682).
+ *
+ * Side-effect free (0 B for apps that don't import it).
+ */
+import {decide, choice, noul} from '../decide'
+import {answers as answersFor} from '../answers'
+import {report} from '../../diagnostics/index'
+import {fromTree, toTree, finish} from './layout'
+
+const ROOT = 'page'
+const ROOT_SLOT = 'default'
+const ROW = 'row'
+const ROW_MIN = 0.5
+/** rowable elements from which the layout step adds same-row nouls */
+const SAME_ROW = 4
+const sep = '__'
+
+// ---------- wording (structure/composer.mjs TEXT and params-edits.mjs W, verbatim) ----------
+export const TEXT = {
+  select: 'Is this element one of the things user_request asks to see? Choose use only when user_request names this element or describes what it shows. Choose omit for elements that are merely about the same topic, area or page as what user_request asks for.',
+  variant: 'Which of these elements does user_request ask for, by name or by what it shows? Choose omit when it asks for none of them. When it asks for this kind of element without saying which, choose the first one.',
+  count: (d: string) => `How many times does user_request want this element on the page: ${d}? Choose 0 when it does not ask for it.`,
+  omit: 'None of these elements is needed.',
+  category: 'Does user_request ask for anything in this area, by name or by what it shows?',
+  row: 'Does user_request explicitly ask for some elements to be placed side by side, next to each other, beside each other or in a row?',
+  parent: (d: string) => `Where does this element go: ${d}? Follow user_request when it says where. Otherwise choose the place whose description fits this element best.`,
+  beside: (d: string) => `Which element does user_request want side by side with this element, in the same row: ${d}? Choose none unless user_request asks for these elements to be next to each other, beside each other or in a row.`,
+  // new (rows of 4+): one `beside` answer per element names one neighbour, so a long row reads as a chain
+  same: (a: string, b: string) => `Does user_request want these two elements in the same row, side by side: ${a}; and ${b}? Answer no unless user_request asks for both of them to be next to each other or in one row.`,
+  gap: (d: string, n: number, x: string, guidance?: string) => `This page shows this element ${n} times: ${d}. Where does this other element go relative to those copies: ${x}? Follow user_request: it may say where each copy goes (for example at the top and again at the bottom) and what goes between them.${guidance ? ' When user_request does not say: ' + guidance : ''}`,
+  left: 'If these two elements are side by side in a row, which one is on the left? Follow user_request: the one it puts on the left, or names first when it lists them side by side, is on the left.',
+  first: (guidance?: string) => `Which of these two elements comes first on the page (higher up, or further left in a row)? Follow user_request: an element it wants at the top, first, above or on the left comes first; one it wants below, under, after, at the end or on the right comes later. When user_request does not say, ${guidance ? guidance + ' Otherwise ' : ''}the one user_request mentions first comes first.`,
+}
+const ORDINAL = ['', 'first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh', 'eighth']
+export const W = {
+  select: 'Does user_request ask for this element, by name or by what it shows? Every element user_request names must be used, wherever on the page it wants it. Omit elements user_request does not ask for, even when related to the topic.',
+  param: (d: string, label: string, ask?: string) => `Consider this element: ${d}. ${ask ?? `Which ${label} does user_request ask for it?`} Choose not_stated when user_request does not mention a ${label}.`,
+  notStated: (label: string) => `user_request does not mention a ${label}`,
+  recordFamily: (d: string, label: string, names: string[]) => `${d}; one per ${label} that user_request names${names.length ? ` (the ${label}s: ${names.join(', ')})` : ''}`,
+  slot: (d: string, label: string, n: number) => `${d}. Which ${label} does user_request name ${ORDINAL[n] ?? `as number ${n}`}? Choose none when user_request names fewer than ${n} ${label}${n > 1 ? 's' : ''} from this list.`,
+  slotNone: (label: string, n: number) => `user_request names fewer than ${n} ${label}${n > 1 ? 's' : ''} from this list`,
+}
+
+// ---------- the catalog (normalized form, phase1-contract.md) ----------
+const partIds = (c: any) => Object.keys(c.parts || {})
+const partOf = (c: any, id: string) => c.parts?.[id]
+const containerOf = (c: any, id: string) => c.containers?.[id]
+const hasRows = (c: any) => !!containerOf(c, ROW)
+const paramsOf = (part: any) => part?.params || {}
+const labelOf = (name: string, p: any) => p.label ?? name
+/**
+ * a param's kind: the normalized catalog's `kind` (types.ts: 'options' | 'number' | 'text' | 'list' |
+ * 'record'); a raw declaration (`options` / `from` / `type`) reads the same
+ */
+const kindOf = (p: any): string => p?.kind ?? (typeof p?.from == 'function' ? 'record' : p?.options ? 'options' : p?.type ?? '')
+/** the record param of a part (at most one) */
+const recordParam = (part: any) => Object.keys(paramsOf(part)).find(k => kindOf(part.params[k]) == 'record')
+/** the options a decision model picks from: an enum's options, a number param's bins */
+const optionsOf = (p: any) => (kindOf(p) == 'number' ? p.bins : kindOf(p) == 'options' ? p.options : null) || {}
+const askable = (p: any) => (kindOf(p) == 'options' || kindOf(p) == 'number') && Object.keys(optionsOf(p)).length > 1
+/** a required param a decision model can't fill (free text with no default): the part is LLM-only */
+export const llmOnly = (part: any) => Object.values(paramsOf(part)).some((p: any) => kindOf(p) != 'record' && !askable(p) && p.required && p.default === undefined)
+const maxUses = (part: any) => Math.max(1, part?.maxUses ?? 1)
+/** record slots per record part: "the first … fourth <label> the request names" (params-edits maxRecords) */
+const RECORD_SLOTS = 4
+const slotNames = (k: any) => Object.keys(k?.slots || {default: null})
+
+/** the allowed places of a part or container as 'container:slot' strings */
+function allowed(c: any, entry: any): string[] {
+  const out: string[] = []
+  for (const d of entry?.in || [ROOT]) {
+    if (d === ROOT) out.push(`${ROOT}:${ROOT_SLOT}`)
+    else if (d.includes(':')) { if (containerOf(c, d.split(':')[0])) out.push(d) }
+    else if (d !== ROW && containerOf(c, d)) for (const s of slotNames(containerOf(c, d))) out.push(`${d}:${s}`)
+  }
+  return out.length ? out : [`${ROOT}:${ROOT_SLOT}`]
+}
+
+// ---------- records: the lexical prefilter (params-edits.mjs narrowRecords) ----------
+const words = (t: any) => String(t).toLowerCase().replace(/'s\b/g, '').match(/[\p{L}\p{N}]+/gu) || []
+function recordsOf(part: any, rp: string, state: any): any[] {
+  let list: any
+  try { list = part.params[rp].from(state) } catch (_) { return [] }
+  return Array.isArray(list) ? list.filter((r: any) => r && r.value != null) : []
+}
+/** the records whose every name word (or every word of an alias) is in the prompt, best first */
+export function narrowRecords(list: any[], prompt: string, max = 254) {
+  const have = new Set(words(prompt))
+  return list
+    .map(r => ({r, s: Math.max(...[r.name ?? r.value, ...(r.aliases || [])].map(n => { const w = words(n); return w.filter(x => have.has(x)).length / (w.length || 1) }))}))
+    .filter(x => x.s >= 1).slice(0, max).map(x => x.r)
+}
+const recordText = (r: any) => r.description ?? r.name ?? String(r.value)
+const recordName = (r: any) => r.name ?? recordText(r).split(/[:,]/)[0]
+
+// ---------- choices over a backend's candidate limit (params-edits.mjs chunkedChoice) ----------
+/**
+ * A choice with more options than the backend takes (Ollama: 25, `maxOptions`) is split into
+ * chunks `<name>__c<k>`, each repeating the `head` options (not_stated / keep / none / omit); every
+ * choice goes through here, so every question respects the limit. `unchunk()` merges the answers
+ * back into `<name>` before reading.
+ */
+function chunked(qs: any, meta: any, name: string, instructions: string, head: any, options: any, m: any, max: number) {
+  const entries = Object.entries(options)
+  const room = Math.max(1, max - Object.keys(head).length)
+  if (entries.length <= room) { qs[name] = choice(instructions, {...head, ...options}); meta[name] = m; return }
+  // even chunks (sizes differ by 1 at most), so none is left with a single option
+  const n = Math.ceil(entries.length / room)
+  for (let k = 0, i = 0; k < n; k++) {
+    const size = Math.floor(entries.length / n) + (k < entries.length % n ? 1 : 0)
+    qs[`${name}${sep}c${k}`] = choice(instructions, {...head, ...Object.fromEntries(entries.slice(i, i + size))})
+    meta[`${name}${sep}c${k}`] = {...m, base: name, chunk: k, head: Object.keys(head)}
+    i += size
+  }
+}
+/**
+ * the chunked answers merged under their base name: the chunk whose non-head answer is the most
+ * probable (its own answer object), else the first chunk (all answered a head option)
+ */
+function unchunk(a: any, meta: any) {
+  const out = {...a}
+  const best: any = {}
+  for (const [name, m] of Object.entries<any>(meta)) {
+    if (m.base == null || !a[name]) continue
+    const x = a[name], b = best[m.base]
+    const head = (y: any) => m.head.includes(y.choice)
+    const p = (y: any) => y.probabilities?.[y.choice] ?? 0
+    if (!b || (head(b) && !head(x)) || (!head(b) && !head(x) && p(x) > p(b))) best[m.base] = x
+  }
+  return Object.assign(out, best)
+}
+const readChunked = (a: any, name: string) => a[name]
+
+// ---------- step 0: categories ----------
+const categoriesOf = (c: any) => {
+  const out: string[] = []
+  for (const id of partIds(c)) { const k = partOf(c, id).category; if (k != null && !out.includes(k)) out.push(k) }
+  return out
+}
+export function categoryStep(c: any, prompt: string) {
+  const questions: any = {}, meta: any = {}
+  for (const id of categoriesOf(c)) {
+    questions[`cat_${id}`] = choice(TEXT.category, {omit: 'Nothing in this area is needed.', use: c.categories?.[id] ?? id})
+    meta[`cat_${id}`] = {kind: 'cat', category: id}
+  }
+  return {state: {user_request: prompt}, questions, meta}
+}
+
+// ---------- step 1: select ----------
+const said = new Set<string>()
+function excluded(id: string) {
+  if (said.has(id)) return
+  said.add(id)
+  dev('SYG680', `part '${id}' has a required text param with no default: a decision model can't fill it, so compose.decisions() never places it (it is LLM-only)`, 'info')
+}
+function dev(code: string, message: string, severity: 'error' | 'warn' | 'info') {
+  try { report(code, {component: 'compose.decisions', message, severity}) } catch (e) { queueMicrotask(() => { throw e }) }
+}
+
+/** the parts the select step asks about: not required ones, not LLM-only ones, in the chosen categories */
+function selectable(c: any, categories?: string[] | null) {
+  return partIds(c).filter(id => {
+    const p = partOf(c, id)
+    if (p.required) return false
+    if (llmOnly(p)) { excluded(id); return false }
+    return !categories || p.category == null || categories.includes(p.category)
+  })
+}
+
+/**
+ * The select questions. `records`: the record values the prefilter kept per record part (start()
+ * computes it; reply() and fake() rebuild the same questions from it). Returns `meta` per question.
+ */
+export function selectStep(c: any, prompt: string, {categories = null, records = {}, max = 255}: any = {}) {
+  const questions: any = {}, meta: any = {}
+  const ids = selectable(c, categories).filter(id => !recordParam(partOf(c, id)) || records[id]?.length)
+  const seen = new Set<string>()
+  for (const id of ids) {
+    const part = partOf(c, id)
+    const rp = recordParam(part)
+    if (part.group != null) {
+      if (!seen.has(part.group)) {
+        seen.add(part.group)
+        const members = ids.filter(m => partOf(c, m).group === part.group)
+        const withRecords = members.some(m => recordParam(partOf(c, m)))
+        chunked(questions, meta, `pick_${part.group}`, withRecords ? W.select : TEXT.variant, {omit: TEXT.omit},
+          Object.fromEntries(members.map(m => {
+            const mp = partOf(c, m), mr = recordParam(mp)
+            return [m, mr ? W.recordFamily(mp.description, labelOf(mr, mp.params[mr]), records[m].map((r: any) => r.name)) : mp.description]
+          })), {kind: 'pick', group: part.group, members}, max)
+      }
+    } else if (!rp && maxUses(part) > 1) {
+      const criteria: any = {}
+      for (let n = 1; n <= maxUses(part); n++) criteria[n] = n === 1 ? 'Once.' : `${n} times, in different places on the page.`
+      chunked(questions, meta, `count_${id}`, TEXT.count(part.description), {0: 'Not on the page.'}, criteria, {kind: 'count', part: id}, max)
+    } else if (!rp) {
+      // a part with choice params takes params-edits' select wording: the strict structure wording
+      // drops a part the request names by a param value ("refunded orders", "complaints"), which
+      // the description leaves out on purpose (Jev, params set x3: 57/60 mixed, 46/60 strict only,
+      // 54/60 params wording only; the structure set keeps 64/70: its parts have no params)
+      const withParams = Object.values<any>(paramsOf(part)).some(askable)
+      questions[`use_${id}`] = choice(withParams ? W.select : TEXT.select, {omit: TEXT.omit, use: part.description})
+      meta[`use_${id}`] = {kind: 'use', part: id}
+    }
+    if (rp) {
+      const label = labelOf(rp, part.params[rp])
+      const options = Object.fromEntries(records[id].map((r: any) => [String(r.value), r.description]))
+      for (let n = 1; n <= RECORD_SLOTS; n++) {
+        chunked(questions, meta, `rec_${id}${sep}${n}`, W.slot(part.description, label, n), {none: W.slotNone(label, n)}, options, {kind: 'rec', part: id, n}, max)
+      }
+    }
+  }
+  // params: of the asked parts and the required ones (read only for the parts that are used)
+  const required = partIds(c).filter(id => partOf(c, id).required && !llmOnly(partOf(c, id)))
+  for (const id of [...required, ...ids]) {
+    const part = partOf(c, id)
+    for (const [name, p] of Object.entries<any>(paramsOf(part))) {
+      if (!askable(p)) continue
+      const label = labelOf(name, p)
+      chunked(questions, meta, `param_${id}${sep}${name}`, W.param(part.description, label, p.ask), {not_stated: W.notStated(label)},
+        Object.fromEntries(Object.entries(optionsOf(p)).map(([v, d]) => [String(v), d])), {kind: 'param', part: id, param: name}, max)
+    }
+  }
+  if (hasRows(c)) { questions.row = noul(TEXT.row); meta.row = {kind: 'row'} }
+  return {state: {user_request: prompt}, questions, meta}
+}
+
+/** the record values the prefilter keeps for each record part, as `{ value, name, description }` */
+function prefilterRecords(c: any, state: any, prompt: string, categories: string[] | null, max: number) {
+  const out: any = {}
+  for (const id of selectable(c, categories)) {
+    const part = partOf(c, id), rp = recordParam(part)
+    if (!rp) continue
+    const kept = narrowRecords(recordsOf(part, rp, state), prompt, max - 1)
+    if (kept.length) out[id] = kept.map(r => ({value: r.value, name: recordName(r), description: recordText(r)}))
+  }
+  return out
+}
+
+const useProbability = (a: any) => (!a ? 0 : a.type === 'noul' ? a.noul : a.probabilities?.use ?? (a.choice === 'use' ? 1 : 0))
+const keyPart = (s: string) => s.replace(/[^A-Za-z0-9_]/g, '_')
+
+/** an enum / number param's value from its answer (not_stated or nothing: the default; only non-defaults kept) */
+function readParams(c: any, id: string, a: any) {
+  const out: any = {}
+  for (const [name, p] of Object.entries<any>(paramsOf(partOf(c, id)))) {
+    if (!askable(p)) continue
+    const x = readChunked(a, `param_${id}${sep}${name}`)
+    const v = x?.choice
+    if (!v || v === 'not_stated' || !(v in optionsOf(p))) continue
+    const value = kindOf(p) == 'number' ? Number(v) : v
+    if (String(value) !== String(p.default)) out[name] = value
+  }
+  return out
+}
+
+/** describes a selected node to the model: description, record, params in force (params-edits describeNode) */
+function describe(c: any, id: string, params: any, record?: any) {
+  const part = partOf(c, id)
+  let d = part.description
+  if (record) d += `, for ${record.description}`
+  for (const [name, p] of Object.entries<any>(paramsOf(part))) {
+    if (!askable(p)) continue
+    const v = params?.[name] ?? p.default
+    if (v === undefined) continue
+    d += `; ${labelOf(name, p)}: ${optionsOf(p)[v] ?? v}`
+  }
+  return d
+}
+
+/**
+ * select answers → { items: [{ key, part, params?, d }], row, unavailable }. Keys: the part id, `__2`
+ * for further copies, `<part>__<record>` for records. Adds required parts and companions; caps at
+ * limits.maxParts (keeping the most probable).
+ */
+export function readSelect(c: any, a: any, {categories = null, records = {}, maxParts}: any = {}) {
+  const scored: any[] = [] // [{ part, params, record?, p }] in catalog order
+  const ids = selectable(c, categories).filter(id => !recordParam(partOf(c, id)) || records[id]?.length)
+  const seen = new Set<string>()
+  const prob = (x: any) => x?.probabilities?.[x.choice] ?? 1
+  const recordsFor = (id: string, atLeastOne: boolean) => {
+    const out: any[] = []
+    for (let n = 1; n <= RECORD_SLOTS; n++) {
+      const x = a[`rec_${id}${sep}${n}`]
+      if (!x) break
+      // the group choice already said "these records": slot 1 is the best record even when none wins
+      const best = Object.entries<any>(x.probabilities || {}).filter(([k]) => k !== 'none').sort((u, v) => v[1] - u[1])[0]
+      const v = n === 1 && atLeastOne && x.choice === 'none' && best ? best[0] : x.choice
+      if (v === 'none' || v == null) break
+      const r = records[id].find((r: any) => String(r.value) === v)
+      if (r && !out.some(o => o.r === r)) out.push({r, p: v === x.choice ? prob(x) : best[1]})
+    }
+    return out
+  }
+  const add = (id: string, p: number) => {
+    const rp = recordParam(partOf(c, id))
+    if (!rp) { scored.push({part: id, params: readParams(c, id, a), p}); return }
+    for (const {r, p: q} of recordsFor(id, partOf(c, id).group != null)) scored.push({part: id, params: {...readParams(c, id, a), [rp]: r.value}, record: r, p: q})
+  }
+  for (const id of ids) {
+    const part = partOf(c, id)
+    if (part.group != null) {
+      if (seen.has(part.group)) continue
+      seen.add(part.group)
+      const x = a[`pick_${part.group}`]
+      if (x && x.choice !== 'omit' && partOf(c, x.choice)?.group === part.group) add(x.choice, prob(x))
+    } else if (recordParam(part)) add(id, 1)
+    else if (maxUses(part) > 1) {
+      const x = a[`count_${id}`]
+      const n = Math.min(maxUses(part), Number(x?.choice ?? 0) || 0)
+      for (let i = 0; i < n; i++) add(id, prob(x))
+    } else {
+      const p = useProbability(a[`use_${id}`])
+      if (p >= 0.5) add(id, p)
+    }
+  }
+  if (!scored.length) return {items: [], row: false, unavailable: true}
+  const max = Math.min(c.limits?.maxParts ?? 12, maxParts ?? Infinity)
+  let list = scored
+  if (list.length > max) {
+    const keep = new Set([...list].sort((x, y) => y.p - x.p).slice(0, max))
+    list = list.filter(x => keep.has(x))
+  }
+  const required = partIds(c).filter(id => partOf(c, id).required && !llmOnly(partOf(c, id))).map(id => ({part: id, params: readParams(c, id, a)}))
+  list = [...required, ...list]
+  for (const x of [...list]) {
+    for (const id of partOf(c, x.part)?.companions || []) if (partOf(c, id) && !list.some(y => y.part === id)) list.push({part: id, params: {}})
+  }
+  // keys
+  const used = new Set<string>(), count: any = {}
+  const items = list.map(x => {
+    let key = x.record ? `${x.part}${sep}${keyPart(String(x.record.value))}` : x.part
+    if (!x.record) { count[x.part] = (count[x.part] || 0) + 1; if (count[x.part] > 1) key = `${x.part}${sep}${count[x.part]}` }
+    for (let i = 2; used.has(key); i++) key = `${key}_${i}`
+    used.add(key)
+    const params = Object.keys(x.params || {}).length ? x.params : undefined
+    return {key, part: x.part, ...(params && {params}), ...(x.record && {record: true}), d: describe(c, x.part, x.params, x.record)}
+  })
+  return {items, row: !!a.row && (a.row.noul ?? 0) >= 0.5, unavailable: false}
+}
+
+// ---------- step 2: layout ----------
+const copyOf = (items: any[], key: string) => {
+  const it = items.find(i => i.key === key)
+  if (!it || it.record) return 1
+  return items.filter(i => i.part === it.part && !i.record).findIndex(i => i.key === key) + 1
+}
+const multiParts = (items: any[], keys: string[]) => new Set(keys.map(k => items.find(i => i.key === k)).filter(i => i && !i.record && copyOf(items, i.key) > 1).map(i => i.part))
+
+/** everything the layout step needs to know about the selection */
+export function plan(c: any, sel: any) {
+  const items = sel.items
+  const nodes: string[] = items.map((i: any) => i.key)
+  const containers: string[] = []
+  const entry = (k: string) => containerOf(c, k) && !items.some((i: any) => i.key === k) ? containerOf(c, k) : partOf(c, items.find((i: any) => i.key === k)?.part)
+  for (let i = 0; i < nodes.length; i++) {
+    for (const d of allowed(c, entry(nodes[i]))) {
+      const k = d.split(':')[0]
+      if (k !== ROOT && !nodes.includes(k)) { nodes.push(k); containers.push(k) }
+    }
+  }
+  const dests: any = {}
+  for (const k of nodes) {
+    // a container never goes into a container that accepts only parts (`accepts: 'leaves'`)
+    const box = !items.some((i: any) => i.key === k)
+    dests[k] = allowed(c, entry(k)).filter(d => { const x = d.split(':')[0]; return x !== k && (x === ROOT || nodes.includes(x)) && !(box && containerOf(c, x)?.accepts === 'leaves') })
+    if (!dests[k].length) dests[k] = [`${ROOT}:${ROOT_SLOT}`]
+  }
+  const leaves: string[] = items.map((i: any) => i.key)
+  const rowable = sel.row && hasRows(c)
+    ? leaves.filter(k => dests[k].some((d: string) => { const x = d.split(':')[0]; return x === ROOT || !containerOf(c, x)?.arranged }))
+    : []
+  return {nodes, containers, dests, leaves, rowable}
+}
+
+const pinOf = (c: any, items: any[], key: string) => partOf(c, items.find(i => i.key === key)?.part)?.pin
+const describeCopy = (items: any[], key: string) => {
+  const it = items.find(i => i.key === key)
+  const n = copyOf(items, key)
+  return n > 1 ? `${it.d} (copy ${n})` : it.d
+}
+function destLabel(c: any, dest: string) {
+  const [k, slot] = dest.split(':')
+  if (k === ROOT) return `${containerOf(c, ROOT)?.description ?? c.description ?? 'The page'}, at the top level (not inside any section, tab or group)`
+  const x = containerOf(c, k)
+  return x?.slots?.[slot] || x?.description || k
+}
+const needsLayout = (p: any) => p.nodes.length > 1 && (p.leaves.length > 1 || p.nodes.some((k: string) => p.dests[k].length > 1))
+
+export function layoutStep(c: any, prompt: string, sel: any, max = 255, debias = false) {
+  const p = plan(c, sel)
+  const items = sel.items
+  const questions: any = {}, meta: any = {}
+  const label = (k: string) => (items.some((i: any) => i.key === k) ? describeCopy(items, k) : containerOf(c, k)?.description ?? k)
+  for (const k of p.nodes) {
+    if (p.dests[k].length < 2) continue
+    chunked(questions, meta, `parent_${k}`, TEXT.parent(label(k)), {}, Object.fromEntries(p.dests[k].map((d: string) => [d, destLabel(c, d)])), {kind: 'parent', key: k}, max)
+  }
+  if (p.rowable.length > 1) {
+    for (const k of p.rowable) {
+      chunked(questions, meta, `beside_${k}`, TEXT.beside(label(k)), {none: 'No element: this one is not side by side with another.'},
+        Object.fromEntries(p.rowable.filter((o: string) => o !== k).map((o: string) => [o, label(o)])), {kind: 'beside', key: k}, max)
+    }
+    // 4+ elements that may share rows: also a same-row noul per pair, so rows longer than 3 (up to
+    // the row container's `max`) can be read (beside answers alone make a chain that average-linkage splits)
+    if (p.rowable.length >= SAME_ROW) p.rowable.forEach((a: string, i: number) => p.rowable.slice(i + 1).forEach((b: string) => {
+      questions[`same_${a}_vs_${b}`] = noul(TEXT.same(label(a), label(b)))
+      meta[`same_${a}_vs_${b}`] = {kind: 'same', a, b}
+    }))
+    p.rowable.forEach((a: string, i: number) => p.rowable.slice(i + 1).forEach((b: string) => {
+      for (const [x, y] of debias ? [[a, b], [b, a]] : [[a, b]]) {
+        questions[`left_${x}_vs_${y}`] = choice(TEXT.left, {[x]: label(x), [y]: label(y)})
+        meta[`left_${x}_vs_${y}`] = {kind: 'left', a: x, b: y}
+      }
+    }))
+  }
+  const free = p.leaves.filter(k => !pinOf(c, items, k))
+  const multi = multiParts(items, free)
+  const single = free.filter(k => !multi.has(items.find((i: any) => i.key === k).part))
+  // debias: each pair is asked in both orders too (a small model favours the first option)
+  single.forEach((a, i) => single.slice(i + 1).forEach(b => {
+    for (const [x, y] of debias ? [[a, b], [b, a]] : [[a, b]]) {
+      questions[`first_${x}_vs_${y}`] = choice(TEXT.first(c.guidance), {[x]: label(x), [y]: label(y)})
+      meta[`first_${x}_vs_${y}`] = {kind: 'first', a: x, b: y}
+    }
+  }))
+  for (const id of multi) {
+    const n = free.filter(k => items.find((i: any) => i.key === k).part === id).length
+    for (const x of single) {
+      const criteria: any = {0: `Above all ${n} copies of it (before the first one).`}
+      for (let g = 1; g < n; g++) criteria[g] = `Between copy ${g} and copy ${g + 1} of it.`
+      criteria[n] = `Below all ${n} copies of it (after the last one).`
+      chunked(questions, meta, `gap_${x}_in_${id}`, TEXT.gap(partOf(c, id).description, n, label(x), c.guidance), {}, criteria, {kind: 'gap', key: x, part: id}, max)
+    }
+  }
+  const state = {user_request: prompt, selected_elements: p.leaves.map(k => ({id: k, content: describeCopy(items, k)}))}
+  return {state, questions, meta, plan: p}
+}
+
+/**
+ * profile 'small': where the request first names each element (its name: the description before
+ * '(' or ':', or the part id's words; longer names claim their words first); Infinity when it
+ * doesn't. A tie-breaker for pairwise order, which a small model answers by option position.
+ */
+export function mentions(c: any, items: any[], prompt: string): Record<string, number> {
+  const text = String(prompt).toLowerCase()
+  const claimed = new Array(text.length).fill(false)
+  const pos: any = {}
+  const phrases: Array<[string, string]> = []
+  for (const it of items) {
+    pos[it.key] = Infinity
+    if (it.record) continue
+    const head = String(partOf(c, it.part)?.description ?? '').split(/[(:;,]/)[0].trim().toLowerCase()
+    const id = it.part.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase()
+    for (const ph of new Set([head, id])) if (ph) phrases.push([ph, it.key])
+  }
+  phrases.sort((x, y) => y[0].length - x[0].length)
+  for (const [ph, key] of phrases) {
+    if (pos[key] !== Infinity) continue
+    const re = new RegExp(`\\b${ph.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}s?\\b`, 'g')
+    for (let m; (m = re.exec(text));) {
+      if (claimed.slice(m.index, m.index + m[0].length).some(Boolean)) continue
+      for (let i = m.index; i < m.index + m[0].length; i++) claimed[i] = true
+      pos[key] = m.index
+      break
+    }
+  }
+  return pos
+}
+/** profile 'small': a pair whose mean answers differ by less than this goes by the mention order */
+const TIE = 0.4
+/** a pair's [x, y] win shares, a near-tie decided by where the request names them (`pos`) */
+function pairWins(px: number, py: number, x: string, y: string, pos: Record<string, number> | null): [number, number] {
+  if (!pos || Math.abs(px - py) >= TIE || pos[x] === pos[y]) return [px, py]
+  return pos[x] < pos[y] ? [1, 0] : [0, 1]
+}
+
+/** pairwise answers → rank per leaf (0 = first): summed win probabilities; copies go into the gaps chosen */
+function ranks(items: any[], leaves: string[], a: any, pos: Record<string, number> | null = null) {
+  const partKey = (k: string) => items.find(i => i.key === k).part
+  const multi = multiParts(items, leaves)
+  const single = leaves.filter(k => !multi.has(partKey(k)))
+  const wins: any = Object.fromEntries(single.map(k => [k, 0]))
+  single.forEach((x, i) => single.slice(i + 1).forEach(y => {
+    // the pair asked once, or in both orders (debias): the mean
+    const fs = [a[`first_${x}_vs_${y}`]?.probabilities, a[`first_${y}_vs_${x}`]?.probabilities].filter(Boolean)
+    if (!fs.length) return
+    const mean = (k: string) => fs.reduce((u, f) => u + (f[k] ?? 0), 0) / fs.length
+    const [wx, wy] = pairWins(mean(x), mean(y), x, y, pos)
+    wins[x] += wx
+    wins[y] += wy
+  }))
+  const sorted = [...single].sort((x, y) => wins[y] - wins[x] || single.indexOf(x) - single.indexOf(y))
+  const score: any = Object.fromEntries(sorted.map((k, i) => [k, i]))
+  for (const id of multi) {
+    const copies = leaves.filter(k => partKey(k) === id).sort((x, y) => copyOf(items, x) - copyOf(items, y))
+    const gap = (x: string) => {
+      const pr = a[`gap_${x}_in_${id}`]?.probabilities
+      return pr ? Object.entries<any>(pr).reduce((s, [g, q]) => s + Number(g) * q, 0) : copies.length
+    }
+    copies.forEach((k, i) => {
+      const before = sorted.filter(x => gap(x) < i + 0.5)
+      score[k] = (before.length ? Math.max(...before.map(x => score[x])) : -1) + 0.5 + i * 0.01
+    })
+  }
+  const out = [...leaves].sort((x, y) => score[x] - score[y] || leaves.indexOf(x) - leaves.indexOf(y))
+  return Object.fromEntries(out.map((k, i) => [k, i]))
+}
+
+/** layout answers → the composition as a Tree (contract format), before `finish()` */
+export function readLayout(c: any, sel: any, a: any, {rowMean = 0.25, prompt = null}: any = {}): any[] {
+  const p = plan(c, sel)
+  const items = sel.items
+  const itemOf = (k: string) => items.find((i: any) => i.key === k)
+  const parent: any = {}
+  for (const k of p.nodes) {
+    const x = a[`parent_${k}`]?.choice
+    parent[k] = p.dests[k].includes(x) ? x : p.dests[k][0]
+  }
+  // cycles → the root
+  const nodeOf = (dest: string) => dest.split(':')[0]
+  for (const k of p.nodes) {
+    const seen = new Set([k])
+    let x = nodeOf(parent[k])
+    while (x !== ROOT) {
+      if (seen.has(x)) { parent[k] = `${ROOT}:${ROOT_SLOT}`; break }
+      seen.add(x)
+      x = nodeOf(parent[x])
+    }
+  }
+  const free = p.leaves.filter(k => !pinOf(c, items, k))
+  const pos = prompt != null ? mentions(c, items, prompt) : null
+  const fr = ranks(items, free, a, pos)
+  const rank: any = {}
+  for (const k of p.leaves) {
+    const pin = pinOf(c, items, k)
+    rank[k] = pin === 'start' ? -1000 + p.leaves.indexOf(k) : pin === 'end' ? 1000 + p.leaves.indexOf(k) : fr[k]
+  }
+  const tree: any = {[ROOT]: {part: ROOT, slots: {[ROOT_SLOT]: []}}}
+  for (const k of p.nodes) {
+    const it = itemOf(k)
+    tree[k] = it ? {part: it.part, params: it.params} : {part: k, slots: Object.fromEntries(slotNames(containerOf(c, k)).map(s => [s, []]))}
+  }
+  for (const k of p.nodes) { const [x, s] = parent[k].split(':'); tree[x].slots[s].push(k) }
+  // drop empty containers (repeat: a container may hold only empty containers)
+  for (let dropped = true; dropped;) {
+    dropped = false
+    for (const k of p.containers) {
+      if (!tree[k] || Object.values<any>(tree[k].slots).some(l => l.length)) continue
+      const [x, s] = parent[k].split(':')
+      tree[x].slots[s] = tree[x].slots[s].filter((y: string) => y !== k)
+      delete tree[k]
+      dropped = true
+    }
+  }
+  // unwrap containers with fewer non-empty slots than minSlots
+  for (const k of p.containers) {
+    const min = containerOf(c, k)?.minSlots
+    if (!tree[k] || !min) continue
+    const full = Object.values<any>(tree[k].slots).filter(l => l.length)
+    if (full.length >= min) continue
+    const [x, s] = parent[k].split(':')
+    const kids = full.flat()
+    for (const y of kids) parent[y] = `${x}:${s}`
+    tree[x].slots[s] = tree[x].slots[s].filter((y: string) => y !== k).concat(kids)
+    delete tree[k]
+  }
+  const rankOf = (k: string): number => {
+    if (k in rank) return rank[k]
+    const kids = tree[k]?.slots ? Object.values<any>(tree[k].slots).flat() : []
+    return kids.length ? Math.min(...kids.map(rankOf)) : Infinity
+  }
+  // rows: average-linkage clustering of `beside` among the siblings of one non-arranged slot
+  let rowN = 0
+  if (p.rowable.length > 1) {
+    const up: any = {}
+    const find = (x: string): string => (up[x] === undefined || up[x] === x ? x : (up[x] = find(up[x])))
+    const pt = (x: string, y: string) => {
+      const beside = Math.max(a[`beside_${x}`]?.probabilities?.[y] ?? 0, a[`beside_${y}`]?.probabilities?.[x] ?? 0)
+      const same = a[`same_${x}_vs_${y}`] ?? a[`same_${y}_vs_${x}`]
+      return same ? (beside + (same.noul ?? 0)) / 2 : beside
+    }
+    const rowMax = containerOf(c, ROW)?.max ?? Infinity
+    const bySlot = new Map<string, string[]>()
+    for (const k of p.rowable) if (tree[k]) { if (!bySlot.has(parent[k])) bySlot.set(parent[k], []); bySlot.get(parent[k])!.push(k) }
+    for (const members of bySlot.values()) {
+      const groups = members.map(k => [k])
+      for (;;) {
+        let best: any = null
+        groups.forEach((g, i) => groups.slice(i + 1).forEach((h, j) => {
+          const all = g.flatMap(x => h.map(y => pt(x, y)))
+          const m = all.reduce((u, v) => u + v, 0) / all.length
+          // one confident link and enough support overall (beside answers are sparse)
+          // and a row never grows past the row container's `max` (the built-in row: 4)
+          if (g.length + h.length <= rowMax && Math.max(...all) >= ROW_MIN && m >= rowMean && (!best || m > best.m)) best = {m, i, j: i + 1 + j}
+        }))
+        if (!best) break
+        groups[best.i] = groups[best.i].concat(groups[best.j])
+        groups.splice(best.j, 1)
+      }
+      for (const g of groups) for (const x of g.slice(1)) up[find(x)] = find(g[0])
+    }
+    for (const [id, t] of Object.entries<any>(tree)) {
+      if (!t.slots || (id !== ROOT && containerOf(c, t.part)?.arranged)) continue
+      for (const [s, list] of Object.entries<any>(t.slots)) {
+        const groups = new Map<string, string[]>()
+        for (const x of list) if (p.rowable.includes(x)) { const r = find(x); if (!groups.has(r)) groups.set(r, []); groups.get(r)!.push(x) }
+        let next = [...list]
+        for (const members of groups.values()) {
+          if (members.length < 2) continue
+          const rowKey = `row#${++rowN}`
+          tree[rowKey] = {part: ROW, slots: {default: members}}
+          next = next.filter(x => !members.includes(x)).concat(rowKey)
+        }
+        t.slots[s] = next
+      }
+    }
+  }
+  // order every slot; inside a row, left/right answers win
+  const leftWins = (k: string, members: string[]) => members.reduce((w, o) => {
+    if (o === k) return w
+    const prs = [a[`left_${k}_vs_${o}`]?.probabilities, a[`left_${o}_vs_${k}`]?.probabilities].filter(Boolean)
+    if (!prs.length) return w + (rankOf(k) < rankOf(o) ? 1 : 0)
+    const mean = (x: string) => prs.reduce((u: number, pr: any) => u + (pr[x] ?? 0), 0) / prs.length
+    return w + pairWins(mean(k), mean(o), k, o, pos)[0]
+  }, 0)
+  for (const t of Object.values<any>(tree)) {
+    if (!t.slots) continue
+    for (const s of Object.keys(t.slots)) {
+      if (t.part === ROW) {
+        const m = t.slots[s]
+        const w = Object.fromEntries(m.map((k: string) => [k, leftWins(k, m)]))
+        m.sort((x: string, y: string) => w[y] - w[x] || rankOf(x) - rankOf(y))
+      } else t.slots[s].sort((x: string, y: string) => rankOf(x) - rankOf(y))
+    }
+  }
+  return toContractTree(c, tree, c.limits?.maxDepth ?? 4)
+}
+
+/** the internal tree → the contract's Tree; a container deeper than maxDepth moves to the root */
+function toContractTree(c: any, tree: any, maxDepth: number): any[] {
+  const overflow: string[] = []
+  const visit = (k: string, depth: number): any => {
+    const t = tree[k]
+    if (!t.slots) return {part: t.part, ...(t.params && {params: t.params})}
+    const kids: any = {}
+    for (const [s, list] of Object.entries<any>(t.slots)) {
+      const out: any[] = []
+      for (const x of list) {
+        if (depth + 1 > maxDepth && tree[x].slots) { overflow.push(x); continue }
+        out.push(visit(x, depth + 1))
+      }
+      if (out.length) kids[s] = out
+    }
+    const named = slotNames(t.part === ROW ? null : containerOf(c, t.part))
+    return {part: t.part, children: named.length === 1 && named[0] === ROOT_SLOT ? kids[ROOT_SLOT] || [] : kids}
+  }
+  const root = visit(ROOT, 0).children
+  for (const x of overflow) root.push(visit(x, 1))
+  return root
+}
+
+// ---------- replies: validation (SYG682) ----------
+function validate(questions: any, a: any) {
+  const out: any = {}
+  let bad = 0
+  for (const [name, x] of Object.entries<any>(a || {})) {
+    const q = questions[name]
+    if (!q || !x) continue
+    if (q.type === 'choice' && !(String(x.choice) in q.criteria)) {
+      dev('SYG682', `the answer to '${name}' is ${JSON.stringify(x.choice)}, not one of its options (${Object.keys(q.criteria).join(', ')}): ignored`, 'warn')
+      bad++
+      continue
+    }
+    out[name] = q.type === 'choice' ? {...x, choice: String(x.choice)} : x
+  }
+  return {answers: out, bad}
+}
+
+// ---------- edits (B-4): params-edits.mjs editQuestions / readEdit / editWhereQuestions / applyEdit ----------
+/**
+ * The edit wording, verbatim from params-edits.mjs W (66/66 tuned, 43/48 held-out on Jev);
+ * `into` (a container slot) is new: the research's edits were on flat pages with rows.
+ */
+export const EDIT = {
+  remove: (d: string) => `Does user_request ask to take this element off the page (remove, delete, hide or drop it, or swap it for a different element)? The element: ${d}. Changing its settings (time range, filter, category, sort, number of rows) keeps it on the page. Answer no for elements user_request does not mention.`,
+  simplerGate: 'Does user_request ask to make the page simpler, shorter, cleaner or less busy, without naming what to remove?',
+  simpler: (d: string) => `This element is on the current page. To make the page simpler, would you remove it as secondary to the page's main purpose? Keep the most important elements. The element: ${d}`,
+  placeGate: 'Does user_request say where an element on the current page should go (at the top, at the bottom, first, last, above, below, next to another element)?',
+  changeGate: (labels: string[]) => `Does user_request ask to change a setting of an element already on the page (such as its ${labels.join(', ')})?`,
+  moveSlot: (n: number) => `Which element on the current page does user_request ask to move to another place (to the top, the bottom, above, below or next to another element)${n > 1 ? ', other than the ones already named' : ''}? ${n > 1 ? `Answer the ${ORDINAL[n] ?? n}` : 'Answer the first'} such element; an element named only as the reference point (the X in "next to X" or "below X") is not moved. Choose none when user_request asks to move fewer than ${n} element${n > 1 ? 's' : ''}.`,
+  moveSlotNone: (n: number) => `user_request asks to move fewer than ${n} element${n > 1 ? 's' : ''} already on the page`,
+  add: 'This element is not on the current page. Does user_request ask to add it or show it, by name or by what it shows? Answer omit when user_request does not ask for it.',
+  addSlot: (d: string, label: string, n: number) => `${d}. Which ${label} does user_request ask to add to the page ${ORDINAL[n] ?? `as number ${n}`}? Choose none when user_request asks to add fewer than ${n} ${label}${n > 1 ? 's' : ''} from this list.`,
+  swap: 'Does user_request ask to replace or swap one element for a different element (instead of, in place of, swap X for Y)?',
+  setParam: (d: string, label: string) => `This element is on the current page: ${d}. Does user_request ask to change its ${label}? Choose keep unless user_request asks for a different ${label}.`,
+  keepParam: (label: string, cur: string) => `keep the current ${label}: ${cur}`,
+  where: (d: string, added: boolean) => `${added ? 'This element is being added to the page' : 'This element is being moved'}: ${d}. Where does user_request want it?${added ? ' Choose not_stated when user_request does not say where.' : ''}`,
+  inPlace: (d: string) => `user_request does not say where: it takes the place of ${d}`,
+  notStatedAdded: 'user_request does not say where',
+  notStatedMoved: 'user_request does not ask to move it after all',
+  top: 'At the very top of the page',
+  bottom: 'At the very bottom of the page',
+  above: (d: string) => `Just above: ${d}`,
+  below: (d: string) => `Just below: ${d}`,
+  beside: (d: string) => `Next to, side by side with: ${d}`,
+  into: (label: string) => `Inside: ${label}`,
+}
+/** move slots and record add slots per edit (params-edits: moveSlots 2, recordSlots 2) */
+const MOVE_SLOTS = 2
+const ADD_SLOTS = 2
+
+/** a leaf (a part node) of the current layout, as the edit questions describe it */
+interface Leaf {key: string; part: string; params?: any; place: string; at: string; row: string | null; d: string; r?: string}
+
+/** the parts of a layout in reading order, with their places (`place`: container part + slot, for `in`; `at`: container key + slot) */
+export function editLeaves(c: any, layout: any, state: any): Leaf[] {
+  const out: Leaf[] = []
+  const nodes = layout?.nodes || {}
+  const seen = new Set<string>()
+  const visit = (key: string, place: string, at: string, row: string | null) => {
+    const n = nodes[key]
+    if (!n || seen.has(key)) return
+    seen.add(key)
+    if (n.slots) {
+      if (n.part === ROW) { for (const k of n.slots[ROOT_SLOT] || []) visit(k, place, at, key); return }
+      for (const [s, list] of Object.entries<any>(n.slots)) for (const k of list || []) visit(k, `${n.part}:${s}`, `${key}:${s}`, null)
+      return
+    }
+    const part = partOf(c, n.part)
+    if (!part) return
+    const rp = recordParam(part)
+    let r: string | undefined
+    if (rp && n.params?.[rp] != null) {
+      const rec = recordsOf(part, rp, state).find(x => String(x.value) === String(n.params[rp]))
+      r = rec ? recordText(rec) : String(n.params[rp])
+    }
+    const leaf: Leaf = {key, part: n.part, ...(n.params && {params: n.params}), place, at, row, d: '', ...(r !== undefined && {r})}
+    leaf.d = describeLeaf(c, leaf)
+    out.push(leaf)
+  }
+  const root = layout?.root ?? ROOT
+  seen.add(root)
+  for (const k of nodes[root]?.slots?.[ROOT_SLOT] || []) visit(k, `${ROOT}:${ROOT_SLOT}`, `${root}:${ROOT_SLOT}`, null)
+  return out
+}
+/** describeNode: the description, its record, the params in force, and where it is when not on the page itself */
+function describeLeaf(c: any, l: {part: string; params?: any; r?: string; place?: string}) {
+  const d = describe(c, l.part, l.params, l.r !== undefined ? {description: l.r} : undefined)
+  return l.place && l.place !== `${ROOT}:${ROOT_SLOT}` ? `${d}; inside: ${destLabel(c, l.place)}` : d
+}
+/** question names per node key (keys may hold ':' and '~') */
+function qnames(keys: string[]) {
+  const used = new Set<string>(), out: any = {}
+  for (const k of keys) {
+    let q = keyPart(k)
+    for (let i = 2; used.has(q); i++) q = `${keyPart(k)}_${i}`
+    used.add(q)
+    out[k] = q
+  }
+  return out
+}
+const identityKey = (c: any, part: string, params: any) => {
+  const rp = recordParam(partOf(c, part))
+  return rp && params?.[rp] != null ? `${part}:${params[rp]}` : part
+}
+function uniqueKey(base: string, used: Set<string>) {
+  let k = base
+  for (let i = 2; used.has(k); i++) k = `${base}~${i}`
+  used.add(k)
+  return k
+}
+const rowable = (c: any, place: string) => hasRows(c) && (place.split(':')[0] === ROOT || !containerOf(c, place.split(':')[0])?.arranged)
+
+/** the parts an edit may add: selectable ones not at maxUses; record parts with records the prompt names that aren't on the page */
+function addableParts(c: any, leaves: Leaf[], records: any) {
+  return selectable(c, null).filter(id => {
+    const part = partOf(c, id)
+    if (recordParam(part)) return !!records[id]?.length
+    return leaves.filter(l => l.part === id).length < maxUses(part)
+  })
+}
+/** per record part, the records the prompt names (the prefilter) that are not on the page */
+function addRecords(c: any, state: any, prompt: string, leaves: Leaf[], max: number) {
+  const out: any = {}
+  for (const [id, list] of Object.entries<any>(prefilterRecords(c, state, prompt, null, max))) {
+    const rp = recordParam(partOf(c, id)) as string
+    const on = new Set(leaves.filter(l => l.part === id).map(l => String(l.params?.[rp])))
+    const left = list.filter((r: any) => !on.has(String(r.value)))
+    if (left.length) out[id] = left
+  }
+  return out
+}
+
+/** edit call 1: per node remove / simpler / setting changes, adds (+ their params and record slots), the gates, move slots */
+export function editStep(c: any, pending: any, max = 255) {
+  const leaves: Leaf[] = pending.leaves, records = pending.records || {}
+  const q = qnames(leaves.map(l => l.key))
+  const questions: any = {}, meta: any = {}
+  for (const l of leaves) {
+    const k = q[l.key]
+    questions[`remove_${k}`] = noul(EDIT.remove(l.d)); meta[`remove_${k}`] = {kind: 'remove', key: l.key}
+    questions[`simpler_${k}`] = noul(EDIT.simpler(l.d)); meta[`simpler_${k}`] = {kind: 'simpler', key: l.key}
+    for (const [name, p] of Object.entries<any>(paramsOf(partOf(c, l.part)))) {
+      if (!askable(p)) continue
+      const label = labelOf(name, p), opts = optionsOf(p), cur = String(l.params?.[name] ?? p.default)
+      chunked(questions, meta, `set_${k}${sep}${name}`, EDIT.setParam(l.d, label), {keep: EDIT.keepParam(label, opts[cur] ?? cur)},
+        Object.fromEntries(Object.entries<any>(opts).filter(([v]) => String(v) !== cur).map(([v, d]) => [String(v), d])), {kind: 'set', key: l.key, param: name}, max)
+    }
+  }
+  const add = addableParts(c, leaves, records)
+  const groups = new Set<string>()
+  for (const id of add) {
+    const part = partOf(c, id), rp = recordParam(part)
+    if (part.group != null) {
+      if (groups.has(part.group)) continue
+      groups.add(part.group)
+      const members = add.filter(m => partOf(c, m).group === part.group)
+      chunked(questions, meta, `add_g_${part.group}`, EDIT.add, {omit: TEXT.omit}, Object.fromEntries(members.map(m => {
+        const mp = partOf(c, m), mr = recordParam(mp)
+        return [m, mr ? W.recordFamily(mp.description, labelOf(mr, mp.params[mr]), records[m].map((r: any) => r.name)) : mp.description]
+      })), {kind: 'addg', group: part.group, members}, max)
+    } else if (!rp) {
+      questions[`add_${id}`] = choice(EDIT.add, {omit: TEXT.omit, use: part.description}); meta[`add_${id}`] = {kind: 'add', part: id}
+    }
+  }
+  for (const id of add) {
+    const part = partOf(c, id), rp = recordParam(part)
+    if (rp) {
+      const label = labelOf(rp, part.params[rp])
+      const options = Object.fromEntries(records[id].map((r: any) => [String(r.value), r.description]))
+      for (let n = 1; n <= ADD_SLOTS; n++) chunked(questions, meta, `rec_${id}${sep}${n}`, EDIT.addSlot(part.description, label, n), {none: W.slotNone(label, n)}, options, {kind: 'rec', part: id, n}, max)
+    }
+    for (const [name, p] of Object.entries<any>(paramsOf(part))) {
+      if (!askable(p)) continue
+      const label = labelOf(name, p)
+      chunked(questions, meta, `param_${id}${sep}${name}`, W.param(part.description, label, p.ask), {not_stated: W.notStated(label)},
+        Object.fromEntries(Object.entries(optionsOf(p)).map(([v, d]) => [String(v), d])), {kind: 'param', part: id, param: name}, max)
+    }
+  }
+  questions.swap = noul(EDIT.swap); meta.swap = {kind: 'swap'}
+  questions.simpler = noul(EDIT.simplerGate); meta.simpler = {kind: 'simplerGate'}
+  questions.placed = noul(EDIT.placeGate); meta.placed = {kind: 'placed'}
+  // the settings named in the gate: the labels of the params on the page
+  const labels = [...new Set(leaves.flatMap(l => Object.entries<any>(paramsOf(partOf(c, l.part))).filter(([, p]) => askable(p)).map(([n, p]) => labelOf(n, p))))]
+  if (labels.length) { questions.change = noul(EDIT.changeGate(labels)); meta.change = {kind: 'change'} }
+  for (let n = 1; n <= MOVE_SLOTS; n++) {
+    chunked(questions, meta, `moved_${n}`, EDIT.moveSlot(n), {none: EDIT.moveSlotNone(n)}, Object.fromEntries(leaves.map(l => [l.key, l.d])), {kind: 'moved', n}, max)
+  }
+  return {state: {user_request: pending.prompt, current_page: leaves.map(l => l.d)}, questions, meta}
+}
+
+/**
+ * call-1 answers → the plan: { removed, moved, added: [{ key, part, params?, d }], params: { key: params }, swap }.
+ * A node whose settings change is never removed; `placed` with no move slot answered moves every
+ * node (its `where` not_stated keeps it); a vague "simpler" never empties the page.
+ */
+export function readEdit(c: any, pending: any, a: any) {
+  const leaves: Leaf[] = pending.leaves, records = pending.records || {}
+  const q = qnames(leaves.map(l => l.key))
+  const on = (x: any) => (x?.noul ?? 0) >= 0.5
+  const plan: any = {removed: [], moved: [], added: [], params: {}, swap: on(a.swap)}
+  const simpler = on(a.simpler), changing = on(a.change)
+  const slotMoved: string[] = []
+  for (let n = 1; n <= MOVE_SLOTS; n++) {
+    const x = a[`moved_${n}`]?.choice
+    if (!x || x === 'none') break
+    if (!slotMoved.includes(x)) slotMoved.push(x)
+  }
+  for (const l of leaves) {
+    const k = q[l.key]
+    const next = {...(l.params || {})}
+    let changed = false
+    for (const [name, p] of Object.entries<any>(paramsOf(partOf(c, l.part)))) {
+      if (!askable(p)) continue
+      const v = changing ? a[`set_${k}${sep}${name}`]?.choice : null
+      if (!v || v === 'keep' || !(v in optionsOf(p))) continue
+      changed = true
+      const value = kindOf(p) == 'number' ? Number(v) : v
+      if (String(value) === String(p.default)) delete next[name]
+      else next[name] = value
+    }
+    if (!changed && (on(a[`remove_${k}`]) || (simpler && on(a[`simpler_${k}`])))) { plan.removed.push(l.key); continue }
+    if (slotMoved.includes(l.key)) plan.moved.push(l.key)
+    if (changed) plan.params[l.key] = next
+  }
+  if (slotMoved.length) plan.named = slotMoved
+  if (!plan.moved.length && on(a.placed)) plan.moved = leaves.map(l => l.key).filter(k => !plan.removed.includes(k))
+  if (plan.removed.length === leaves.length && simpler) plan.removed = plan.removed.filter((k: string) => on(a[`remove_${q[k]}`]))
+  // adds, in catalog order (record parts: in slot order); fresh keys, never one of the previous layout's
+  const used = new Set<string>(Object.keys(pending.previous?.nodes || {}))
+  for (const id of addableParts(c, leaves, records)) {
+    const part = partOf(c, id), rp = recordParam(part)
+    const asked = part.group != null ? a[`add_g_${part.group}`]?.choice === id : rp ? true : a[`add_${id}`]?.choice === 'use'
+    if (!asked) continue
+    const own = readParams(c, id, a)
+    const push = (params: any, r?: any) => {
+      const p = Object.keys(params).length ? params : undefined
+      plan.added.push({key: uniqueKey(identityKey(c, id, p), used), part: id, ...(p && {params: p}), d: describeLeaf(c, {part: id, params: p, ...(r && {r: r.description})})})
+    }
+    if (!rp) { push(own); continue }
+    // the group choice already said "these records": slot 1 is the best record even when none wins
+    const got: any[] = []
+    for (let n = 1; n <= ADD_SLOTS; n++) {
+      const x = a[`rec_${id}${sep}${n}`]
+      if (!x) break
+      const best = Object.entries<any>(x.probabilities || {}).filter(([k]) => k !== 'none').sort((u, v) => v[1] - u[1])[0]
+      const v = n === 1 && part.group != null && x.choice === 'none' && best ? best[0] : x.choice
+      if (v === 'none' || v == null) break
+      const r = records[id].find((r: any) => String(r.value) === v)
+      if (r && !got.includes(r)) got.push(r)
+    }
+    for (const r of got) push({...own, [rp]: r.value}, r)
+  }
+  return plan
+}
+
+/** the nodes that stay and the ones placed by call 2 (moved, then added; a replace: the added node takes the removed one's place) */
+function editSets(c: any, pending: any) {
+  const leaves: Leaf[] = pending.leaves, p = pending.plan
+  const rep: string | null = p.swap && p.removed.length === 1 && p.added.length === 1 ? p.removed[0] : null
+  const stay = leaves.filter(l => !p.removed.includes(l.key) && !p.moved.includes(l.key))
+  // a moved node is described with its new settings
+  const moved = leaves.filter(l => p.moved.includes(l.key)).map(l => {
+    const m: any = {...l, exists: true}
+    if (p.params[l.key]) { m.params = p.params[l.key]; m.d = describeLeaf(c, m) }
+    return m
+  })
+  const added = p.added.map((x: any) => ({...x, exists: false, ...(rep && {replaces: rep})}))
+  return {rep, stay, movers: [...moved, ...added] as any[]}
+}
+
+/** a mover's question name */
+const moverNames = (pending: any) => qnames([...pending.leaves.map((l: Leaf) => l.key), ...pending.plan.added.map((x: any) => x.key)])
+
+/**
+ * Edit call 2 (only when something moves or is added): one `where_<key>` choice per mover over
+ * not_stated (added: the bottom, or its first allowed place; moved: it stays; a replacement: the
+ * removed node's place), top / bottom (when it may go on the page itself), above / below / beside
+ * each node that stays or moves (where its `in` allows), and `into:<container key>:<slot>` for each
+ * other place its `in` allows (a container not on the page is created).
+ */
+export function whereStep(c: any, pending: any, max = 255) {
+  const {stay, movers} = editSets(c, pending)
+  const q = moverNames(pending)
+  const leafD = (k: string) => pending.leaves.find((l: Leaf) => l.key === k)?.d ?? k
+  const nodes = pending.previous?.nodes || {}
+  const questions: any = {}, meta: any = {}
+  for (const m of movers) {
+    const places = allowed(c, partOf(c, m.part))
+    const onPage = places.includes(`${ROOT}:${ROOT_SLOT}`)
+    const head: any = {not_stated: m.replaces ? EDIT.inPlace(leafD(m.replaces)) : m.exists ? EDIT.notStatedMoved : EDIT.notStatedAdded}
+    if (onPage) { head.top = EDIT.top; head.bottom = EDIT.bottom }
+    const options: any = {}
+    for (const s of [...stay, ...movers.filter(o => o.exists && o.key !== m.key)]) {
+      if (!places.includes(s.place)) continue
+      options[`above:${s.key}`] = EDIT.above(s.d)
+      options[`below:${s.key}`] = EDIT.below(s.d)
+      if (rowable(c, s.place)) options[`beside:${s.key}`] = EDIT.beside(s.d)
+    }
+    for (const pl of places) {
+      if (pl === `${ROOT}:${ROOT_SLOT}`) continue
+      const [cid, slot] = pl.split(':')
+      const keys = Object.keys(nodes).filter(k => nodes[k]?.part === cid && nodes[k].slots)
+      for (const ck of keys.length ? keys : [cid]) options[`into:${ck}:${slot}`] = EDIT.into(destLabel(c, pl) + (keys.length > 1 ? ` (${ck})` : ''))
+    }
+    chunked(questions, meta, `where_${q[m.key]}`, EDIT.where(m.d, !m.exists), head, options, {kind: 'where', key: m.key}, max)
+  }
+  return {state: {user_request: pending.prompt, current_page: pending.leaves.map((l: Leaf) => l.d)}, questions, meta}
+}
+
+/**
+ * The plan + call-2 answers → the new layout (finished). Nodes that stay keep their keys, places,
+ * rows and order; a setting change keeps the key; an added node or a replacement gets a fresh key.
+ * A moved node that another mover is placed relative to is only the reference point and stays (of
+ * two naming each other, the less sure one); a moved node answered not_stated stays; a
+ * replacement answered not_stated takes the removed node's place (and row).
+ */
+export function applyEdit(c: any, pending: any, a: any, state: any) {
+  const {rep, movers} = editSets(c, pending)
+  const plan = pending.plan, previous = pending.previous
+  const q = moverNames(pending)
+  const whereOf = (m: any) => a[`where_${q[m.key]}`]
+  const w = (m: any): string => whereOf(m)?.choice ?? 'not_stated'
+  const anchor = (m: any) => { const x = w(m); return /^(above|below|beside):/.test(x) ? x.slice(x.indexOf(':') + 1) : null }
+  const conf = (m: any) => whereOf(m)?.confidence ?? 0
+  // of two naming each other, the surer one moves (a tie: the one the move slots named first)
+  const rank = (m: any) => { const i = (plan.named || []).indexOf(m.key); return i < 0 ? Infinity : i }
+  const surer = (m: any, o: any) => conf(m) > conf(o) || (conf(m) === conf(o) && rank(m) < rank(o))
+  const stays = new Set(movers.filter(m =>
+    (m.exists && movers.some(o => o !== m && anchor(o) === m.key && !(anchor(m) === o.key && surer(m, o))))
+    || ((m.exists || m.replaces) && w(m) === 'not_stated')).map(m => m.key))
+  // the working tree
+  type T = {key: string; part: string; params?: any; slots?: Record<string, T[]>}
+  const nodes = previous.nodes
+  const build = (k: string): T | null => {
+    const n = nodes[k]
+    if (!n) return null
+    const t: T = {key: k, part: n.part, ...(n.params && {params: n.params})}
+    if (n.slots) t.slots = Object.fromEntries(Object.entries<any>(n.slots).map(([s, l]) => [s, (l || []).map(build).filter(Boolean)]))
+    return t
+  }
+  const root = build(previous.root) as T
+  root.slots ||= {}
+  root.slots[ROOT_SLOT] ||= []
+  const top = root.slots[ROOT_SLOT]
+  const locate = (key: string): {t: T; arr: T[]; i: number; parent: T} | null => {
+    let out: any = null
+    const go = (t: T) => {
+      for (const s in t.slots) t.slots[s].forEach((x, i, arr) => { if (out) return; if (x.key === key) out = {t: x, arr, i, parent: t}; else if (x.slots) go(x) })
+    }
+    go(root)
+    return out
+  }
+  const used = new Set<string>([...Object.keys(nodes), ...plan.added.map((x: any) => x.key)])
+  const node = (m: any): T => ({key: m.key, part: m.part, ...(m.params && Object.keys(m.params).length && {params: m.params})})
+  for (const [k, params] of Object.entries<any>(plan.params)) {
+    const x = locate(k)
+    if (!x) continue
+    if (Object.keys(params).length) x.t.params = params
+    else delete x.t.params
+  }
+  const repMover = rep ? movers.find(m => m.replaces) : null
+  for (const k of plan.removed) {
+    const x = locate(k)
+    if (!x) continue
+    if (repMover && k === rep && stays.has(repMover.key)) x.arr.splice(x.i, 1, node(repMover))
+    else x.arr.splice(x.i, 1)
+  }
+  const detached: any = {}
+  for (const m of movers) {
+    if (!m.exists || stays.has(m.key)) continue
+    const x = locate(m.key)
+    if (x) { x.arr.splice(x.i, 1); detached[m.key] = x.t }
+  }
+  for (const m of movers) {
+    if (stays.has(m.key)) continue
+    const n = detached[m.key] ?? node(m)
+    const x = w(m), op = x.split(':')[0]
+    if (op === 'top') { top.unshift(n); continue }
+    if (op === 'above' || op === 'below' || op === 'beside') {
+      const t = locate(x.slice(x.indexOf(':') + 1))
+      if (!t) { top.push(n); continue }
+      if (op === 'beside') {
+        if (t.parent.part === ROW) t.arr.splice(t.i + 1, 0, n)
+        else t.arr.splice(t.i, 1, {key: uniqueKey(ROW, used), part: ROW, slots: {[ROOT_SLOT]: [t.t, n]}})
+        continue
+      }
+      // above / below a node in a row: above / below the row
+      const b = t.parent.part === ROW ? locate(t.parent.key) ?? t : t
+      b.arr.splice(b.i + (op === 'below' ? 1 : 0), 0, n)
+      continue
+    }
+    if (op === 'into') {
+      const rest = x.slice(5), j = rest.lastIndexOf(':'), ck = rest.slice(0, j), slot = rest.slice(j + 1)
+      const t = locate(ck)?.t
+      if (t?.slots) { (t.slots[slot] ||= []).push(n); continue }
+      if (containerOf(c, ck)) {
+        const ct: T = {key: uniqueKey(ck, used), part: ck, slots: Object.fromEntries(slotNames(containerOf(c, ck)).map(s => [s, [] as T[]]))}
+        ;(ct.slots![slot] ||= []).push(n)
+        top.push(ct)
+        continue
+      }
+    }
+    // bottom; an added node with no stated place (finish() moves a part that can't be on the page to its first place)
+    top.push(n)
+  }
+  const out: any = {}
+  const emit = (t: T) => {
+    out[t.key] = {part: t.part, ...(t.params && {params: t.params}), ...(t.slots && {slots: Object.fromEntries(Object.entries(t.slots).map(([s, l]) => [s, l.map(x => (emit(x), x.key))]))})}
+  }
+  emit(root)
+  return finish(c, {root: previous.root, nodes: out}, state)
+}
+
+// ---------- fake for edits: answers that make an edit read as a target ----------
+/** a node's identity in a layout: part + record */
+const leafIdentity = (c: any, l: {part: string; params?: any}) => identityKey(c, l.part, l.params)
+
+/**
+ * The edit's call-1 picks for one candidate plan; null when the target can't be expressed (a
+ * setting a decision model can't change, a part that can't be added, too many records).
+ */
+function editPicks(c: any, pending: any, want: Leaf[], {moved, swap}: {moved: string[]; swap: boolean}) {
+  const leaves: Leaf[] = pending.leaves, records = pending.records || {}
+  const q = qnames(leaves.map(l => l.key))
+  const picks: any = {swap, simpler: false}
+  const wantBy = new Map(want.map(l => [l.key, l]))
+  let changing = false
+  for (const l of leaves) {
+    const k = q[l.key], to = wantBy.get(l.key)
+    picks[`remove_${k}`] = !to
+    picks[`simpler_${k}`] = false
+    for (const [name, p] of Object.entries<any>(paramsOf(partOf(c, l.part)))) {
+      if (!to) { picks[`set_${k}${sep}${name}`] = 'keep'; continue }
+      const cur = l.params?.[name] ?? p.default, next = to.params?.[name] ?? p.default
+      if (String(cur) === String(next)) { if (askable(p)) picks[`set_${k}${sep}${name}`] = 'keep'; continue }
+      if (!askable(p)) return null
+      changing = true
+      picks[`set_${k}${sep}${name}`] = String(next)
+    }
+  }
+  picks.change = changing
+  // adds: one per plain part, one member per group, up to ADD_SLOTS records per record part
+  const prevKeys = new Set(leaves.map(l => l.key))
+  const adds = want.filter(l => !prevKeys.has(l.key))
+  const add = addableParts(c, leaves, records)
+  const groups: any = {}
+  const per: any = {}
+  for (const l of adds) {
+    if (!add.includes(l.part)) return null
+    const part = partOf(c, l.part)
+    ;(per[l.part] ||= []).push(l)
+    if (part.group != null) { if (groups[part.group] && groups[part.group] !== l.part) return null; groups[part.group] = l.part }
+  }
+  for (const id of add) {
+    const part = partOf(c, id), rp = recordParam(part), mine = per[id] || []
+    if (part.group != null) picks[`add_g_${part.group}`] ??= 'omit'
+    else if (!rp) picks[`add_${id}`] = mine.length ? 'use' : 'omit'
+    if (!rp && mine.length > 1) return null
+    if (rp) {
+      if (mine.length > ADD_SLOTS) return null
+      for (let n = 1; n <= ADD_SLOTS; n++) picks[`rec_${id}${sep}${n}`] = mine[n - 1] ? String(mine[n - 1].params?.[rp]) : 'none'
+    }
+    if (part.group != null && mine.length) picks[`add_g_${part.group}`] = id
+    // params: one answer per part (its added nodes share them)
+    for (const [name, p] of Object.entries<any>(paramsOf(part))) {
+      if (kindOf(p) == 'record') continue
+      const vals = [...new Set(mine.map((l: Leaf) => String(l.params?.[name] ?? p.default)))]
+      if (vals.length > 1) return null
+      if (!askable(p)) { if (vals.length && vals[0] !== String(p.default)) return null; continue }
+      picks[`param_${id}${sep}${name}`] = !vals.length || vals[0] === String(p.default) ? 'not_stated' : vals[0]
+    }
+  }
+  // moves: up to MOVE_SLOTS by the move slots, more by the `placed` gate (every node gets a where)
+  const many = moved.length > MOVE_SLOTS
+  for (let n = 1; n <= MOVE_SLOTS; n++) picks[`moved_${n}`] = !many && moved[n - 1] ? moved[n - 1] : 'none'
+  picks.placed = many
+  return picks
+}
+
+/**
+ * Where picks that read as `want`: for each mover, the options that could put it where the target
+ * has it (beside the row-mate before it; below the node before it, above the one after it; top,
+ * bottom, into; not_stated for the nodes meant to stay), tried depth first until the layout reads
+ * as the target (`ok`). null when none does within the budget.
+ */
+function wherePicks(c: any, pending: any, step: any, wantLayout: any, ok: (picks: any) => boolean, stay: Set<string>, budget = {n: 400}) {
+  const {movers} = editSets(c, pending)
+  const q = moverNames(pending)
+  const opts = optionsAt(step)
+  // the target's places: per leaf, its slot sequence (rows flattened, marked) and row
+  const W = editLeaves(c, wantLayout, {})
+  const byKey = new Map(W.map((l, i) => [l.key, {...l, i}]))
+  // the added movers ↔ the target's new leaves (by identity, in order)
+  const prevKeys = new Set(pending.leaves.map((l: Leaf) => l.key))
+  const fresh = W.filter(l => !prevKeys.has(l.key))
+  const target = (m: any) => {
+    if (m.exists) return byKey.get(m.key)
+    const i = fresh.findIndex(l => leafIdentity(c, l) === leafIdentity(c, m))
+    if (i < 0) return undefined
+    const [l] = fresh.splice(i, 1)
+    return byKey.get(l.key)
+  }
+  const at = movers.map(target)
+  const cands = movers.map((m, i) => {
+    const name = `where_${q[m.key]}`, keys: string[] = opts[name] || []
+    const t = at[i]
+    if (stay.has(m.key) && keys.includes('not_stated')) return ['not_stated']
+    const out: string[] = []
+    const put = (x: string) => { if (keys.includes(x) && !out.includes(x)) out.push(x) }
+    if (m.replaces) put('not_stated')
+    if (t) {
+      const same = W.filter(l => l.at === t.at)
+      const j = same.findIndex(l => l.key === t.key)
+      if (t.row) for (let k = j - 1; k >= 0 && same[k].row === t.row; k--) put(`beside:${same[k].key}`)
+      // a pinned part goes first in its row whichever side it joined
+      if (t.row) for (let k = j + 1; k < same.length && same[k].row === t.row; k++) put(`beside:${same[k].key}`)
+      const n = out.length
+      for (let k = j - 1; k >= 0 && out.length === n; k--) if (same[k].row !== t.row || !t.row) put(`below:${same[k].key}`)
+      const n2 = out.length
+      for (let k = j + 1; k < same.length && out.length === n2; k++) if (same[k].row !== t.row || !t.row) put(`above:${same[k].key}`)
+      if (t.at === `${wantLayout.root}:${ROOT_SLOT}`) { if (j === 0) put('top'); if (j === same.length - 1) put(m.exists ? 'bottom' : 'not_stated') }
+      else for (const x of keys) if (x.startsWith('into:') && x.endsWith(`:${t.at.slice(t.at.lastIndexOf(':') + 1)}`)) put(x)
+      // pins reorder a slot after the edit: the far anchors and the page's ends too
+      for (let k = j - 1; k >= 0; k--) put(`below:${same[k].key}`)
+      for (let k = j + 1; k < same.length; k++) put(`above:${same[k].key}`)
+      put('top')
+      put('bottom')
+    }
+    put('not_stated')
+    return out.slice(0, 10)
+  })
+  const picks: any = {}
+  const dfs = (i: number): boolean => {
+    if (i === movers.length) return budget.n-- > 0 && ok(picks)
+    for (const x of cands[i]) {
+      if (budget.n <= 0) return false
+      picks[`where_${q[movers[i].key]}`] = x
+      if (dfs(i + 1)) return true
+    }
+    return false
+  }
+  return dfs(0) ? spread(step, picks) : null
+}
+
+/**
+ * The sets of nodes to move, smallest first (up to 4 nodes), for which the nodes that stay can stay:
+ * each keeps its slot (or its container is gone), stays row-mates with exactly the nodes that stay it
+ * shared a row with, and keeps its order in its slot; then every node.
+ */
+/** a layout's parts and containers (not rows) in reading order, with the container key + slot they are in */
+function unitsOf(layout: any) {
+  const out: Array<{key: string; at: string}> = []
+  const nodes = layout?.nodes || {}
+  const visit = (k: string, at: string) => {
+    const n = nodes[k]
+    if (!n) return
+    if (n.part !== ROW) out.push({key: k, at})
+    for (const [s, list] of Object.entries<any>(n.slots || {})) for (const x of list || []) visit(x, n.part === ROW ? at : `${k}:${s}`)
+  }
+  for (const x of nodes[layout?.root]?.slots?.[ROOT_SLOT] || []) visit(x, `${layout.root}:${ROOT_SLOT}`)
+  return out
+}
+
+function moveSets(leaves: Leaf[], W: Leaf[], previous: any, want: any) {
+  const wantBy = new Map(W.map(l => [l.key, l]))
+  const surv = leaves.filter(l => wantBy.get(l.key)?.part === l.part)
+  const prevIdx = new Map(leaves.map((l, i) => [l.key, i]))
+  const prevUnit = new Map(unitsOf(previous).map((u, i) => [u.key, i]))
+  const wantUnits = unitsOf(want)
+  const box = (at: string) => at.slice(0, at.lastIndexOf(':'))
+  const boxes = new Set(W.map(t => box(t.at)))
+  const valid = (moved: Set<string>) => {
+    const stay = surv.filter(l => !moved.has(l.key))
+    for (const l of stay) { const t = wantBy.get(l.key)!; if (t.at !== l.at && boxes.has(box(l.at))) return false }
+    for (let i = 0; i < stay.length; i++) for (let j = i + 1; j < stay.length; j++) {
+      const a = stay[i], b = stay[j], ta = wantBy.get(a.key)!, tb = wantBy.get(b.key)!
+      if ((!!a.row && a.row === b.row) !== (!!ta.row && ta.row === tb.row)) return false
+    }
+    // a row of the target needs a node that stays in it (`beside` anchors on a node that doesn't move)
+    const rows = new Set(W.filter(t => t.row).map(t => t.row))
+    for (const r of rows) if (!W.some(t => t.row === r && prevIdx.has(t.key) && !moved.has(t.key))) return false
+    // in every slot, the nodes that stay and the containers that were there keep their order
+    const last = new Map<string, number>()
+    for (const u of wantUnits) {
+      if (!prevUnit.has(u.key) || moved.has(u.key) || (wantBy.has(u.key) && !prevIdx.has(u.key))) continue
+      const i = prevUnit.get(u.key)!
+      if ((last.get(u.at) ?? -1) > i) return false
+      last.set(u.at, i)
+    }
+    return true
+  }
+  const keys = surv.map(l => l.key)
+  const out: string[][] = []
+  const pick = (from: number, k: number, acc: string[]) => {
+    if (out.length >= 24) return
+    if (!k) { if (valid(new Set(acc))) out.push(acc); return }
+    for (let i = from; i <= keys.length - k; i++) pick(i + 1, k - 1, [...acc, keys[i]])
+  }
+  for (let k = 0; k <= Math.min(4, keys.length); k++) pick(0, k, [])
+  if (!out.some(m => m.length === keys.length)) out.push(keys)
+  return out
+}
+
+/** the reply for the pending edit step (`edit` or `where`) that reads as `wantLayout`; null when no answers reach it */
+function fakeEditReply(c: any, state: any, pending: any, wantLayout: any, stepOf: (p: any) => any, read: (p: any, reply: any) => any) {
+  const W = editLeaves(c, wantLayout, state)
+  const same = (l: any) => !!l && show(canon(toTree(l))) === show(canon(toTree(wantLayout)))
+  const budget = {n: 1500}
+  const tryWhere = (p2: any, moved: string[]) => {
+    const step2 = stepOf(p2)
+    const ok = (picks: any) => { const r = read(p2, answersFor(step2.questions, picks)); return !r.error && same(r.layout) }
+    // the movers that are meant to stay answer not_stated (the `placed` gate made every node a mover)
+    const stay = new Set<string>(p2.plan.moved.filter((k: string) => !moved.includes(k)))
+    return wherePicks(c, p2, step2, wantLayout, (picks: any) => ok(spread(step2, picks)), stay, budget)
+  }
+  const sets = moveSets(pending.leaves, W, pending.previous, wantLayout)
+  if (pending.step === 'where') {
+    const step2 = stepOf(pending)
+    for (const moved of sets) {
+      if (!moved.every(k => pending.plan.moved.includes(k))) continue
+      const picks = tryWhere(pending, moved)
+      if (picks) return answersFor(step2.questions, picks)
+    }
+    return null
+  }
+  const step1 = stepOf(pending)
+  // nothing fits (an empty target) or no change: the empty plan (status 'unavailable', the layout kept)
+  if (!W.length || same(pending.previous)) return answersFor(step1.questions, spread(step1, editPicks(c, pending, pending.leaves, {moved: [], swap: false})))
+  const prevKeys = new Set(pending.leaves.map((l: Leaf) => l.key))
+  const swaps = pending.leaves.filter((l: Leaf) => !W.some(t => t.key === l.key)).length === 1 && W.filter(t => !prevKeys.has(t.key)).length === 1 ? [true, false] : [false]
+  for (const moved of sets) {
+    for (const swap of swaps) {
+      if (budget.n <= 0) return null
+      const picks = editPicks(c, pending, W, {moved, swap})
+      if (!picks) return null
+      const reply = answersFor(step1.questions, spread(step1, picks))
+      const out = read(pending, reply)
+      if (out.error) continue
+      if (!out.request) { if (same(out.layout)) return reply; continue }
+      if (tryWhere(JSON.parse(JSON.stringify(out.pending)), moved)) return reply
+    }
+  }
+  return null
+}
+
+// ---------- the backend ----------
+export interface DecisionsOptions {
+  url?: string
+  model?: string
+  key?: string
+  rowMean?: number
+  prefilter?: boolean | 'auto'
+  maxOptions?: number
+  profile?: 'small'
+  maxParts?: number
+  /** passed to every decide() request (D472: a large step goes as parallel sub-requests, one merged reply) */
+  maxQuestions?: number
+  maxPromptTokens?: number
+  split?: boolean
+}
+
+/**
+ * B-5: `prefilter: 'auto'` (the default) asks the category step first when the catalog has
+ * categories and the select step would ask about more parts than this (Jev: the ops console's 50
+ * parts compose as well with it, at about half the tokens and one more call, ~+0.2 s)
+ */
+export const PREFILTER_AT = 60
+/** the same for profile 'small' (a local model: input tokens are most of its time) */
+export const PREFILTER_AT_SMALL = 30
+/** profile 'small': the most parts one composition selects (Jev and others: the catalog's limits.maxParts, 12) */
+const SMALL_MAX_PARTS = 8
+
+const isOllama = (url: string) => /:11434\b|ollama/i.test(url)
+
+export function decisions({url = '/api/decide', model, key, rowMean = 0.25, prefilter = 'auto', maxOptions, profile, maxParts, maxQuestions, maxPromptTokens, split}: DecisionsOptions = {}) {
+  // profile 'small' (a local 9B decision model such as Ollama's nimble, G-755): pairwise order
+  // questions asked in both option orders (it prefers the first option), and near-ties ordered by
+  // where the request names the elements
+  const small = profile === 'small'
+  const debias = small
+  // B-5: profile 'small' selects at most 8 parts (fewer, surer picks); an explicit maxParts wins
+  const partsCap = maxParts ?? (small ? SMALL_MAX_PARTS : undefined)
+  /** whether a fresh composition asks the category step first */
+  const usePrefilter = (catalog: any) => !!categoriesOf(catalog).length && (prefilter === true ||
+    (prefilter === 'auto' && selectable(catalog).length > (small ? PREFILTER_AT_SMALL : PREFILTER_AT)))
+  // a decide() server picks no default model: every request needs one (SYG681, the contract's
+  // backend option problem; compose.llm() doesn't report it: a chat transport has its own default)
+  if (typeof model != 'string' || !model) dev('SYG681', "compose.decisions() needs a `model` (the decision model's id, e.g. compose.decisions({ model: 'jev-latest' })); its requests go without one", 'error')
+  // Ollama's /v1/systemone takes 2–26 candidates per choice, TypeSafe 255; at least 4 (a where's head is 3)
+  const max = Math.max(4, maxOptions ?? (isOllama(url) ? 25 : 255))
+  const request = (names: any, step: any) => decide({
+    url, model, state: step.state, questions: step.questions,
+    key: key ?? names?.key, latest: true, ok: names?.ok, error: names?.error,
+    ...(maxQuestions !== undefined && {maxQuestions}), ...(maxPromptTokens !== undefined && {maxPromptTokens}), ...(split !== undefined && {split}),
+  } as any)
+  const answersOf = (reply: any) => (reply && typeof reply == 'object' ? reply.answers : undefined)
+
+  /** the questions of a pending step (rebuilt from it, as sent) */
+  function stepOf(catalog: any, pending: any) {
+    if (pending.step === 'categories') return categoryStep(catalog, pending.prompt)
+    if (pending.step === 'select') return selectStep(catalog, pending.prompt, {categories: pending.categories, records: pending.records, max})
+    if (pending.step === 'edit') return editStep(catalog, pending, max)
+    if (pending.step === 'where') return whereStep(catalog, pending, max)
+    return layoutStep(catalog, pending.prompt, {items: pending.items, row: pending.row}, max, debias)
+  }
+  function selectPending(catalog: any, state: any, prompt: string, categories: string[] | null, base: any) {
+    const records = prefilterRecords(catalog, state, prompt, categories, max)
+    return {...base, step: 'select', prompt, categories, records}
+  }
+  const done = (catalog: any, state: any, tree: any[], previous: any) => finish(catalog, fromTree(catalog, tree, previous), state)
+
+  /** a reply → the backend's result (pure; fake() reads with it too) */
+  function read({catalog, state, pending, reply, names}: any) {
+    const step = stepOf(catalog, pending)
+    const body = answersOf(reply)
+    // a reply that can't be read: the behavior's status 'error' (contract), not a throw
+    if (!body || typeof body != 'object' || Array.isArray(body)) return {error: 'compose.decisions(): the decision reply has no answers'}
+    const {answers: raw, bad} = validate(step.questions, body)
+    if (bad && !Object.keys(raw).length) return {error: `compose.decisions(): every answer of the ${pending.step} step is outside its question's options (SYG682)`}
+    const decisions = {...(pending.decisions || {}), [pending.step]: raw}
+    const a = unchunk(raw, step.meta)
+    const base = {previous: pending.previous ?? null, decisions}
+    // an edit (B-4): keys come from the previous layout (`keyed`: the behavior doesn't re-key it)
+    if (pending.step === 'edit') {
+      const next = {...base, step: 'where', prompt: pending.prompt, leaves: pending.leaves, records: pending.records, plan: readEdit(catalog, pending, a)}
+      const pl = next.plan
+      // nothing to remove, change, move or add: nothing in the request applies (the layout is kept)
+      if (!pl.removed.length && !pl.moved.length && !pl.added.length && !Object.keys(pl.params).length) return {layout: null, unavailable: true as const, decisions}
+      const now = applyEdit(catalog, next, {}, state)
+      if (!editSets(catalog, next).movers.length) return {layout: now, keyed: true, decisions}
+      return {preview: now, request: request(names, stepOf(catalog, next)), pending: next, keyed: true, decisions}
+    }
+    if (pending.step === 'where') return {layout: applyEdit(catalog, pending, a, state), keyed: true, decisions}
+    if (pending.step === 'categories') {
+      const chosen = categoriesOf(catalog).filter(id => a[`cat_${id}`]?.choice === 'use')
+      const open = partIds(catalog).some(id => !partOf(catalog, id).required && partOf(catalog, id).category == null)
+      if (!chosen.length && !open) return {layout: null, unavailable: true as const, decisions}
+      const next = selectPending(catalog, state, pending.prompt, chosen, base)
+      return {request: request(names, stepOf(catalog, next)), pending: next, decisions}
+    }
+    if (pending.step === 'select') {
+      const sel = readSelect(catalog, a, {categories: pending.categories, records: pending.records, maxParts: partsCap})
+      if (sel.unavailable) return {layout: null, unavailable: true as const, decisions}
+      const p = plan(catalog, sel)
+      if (!needsLayout(p)) return {layout: done(catalog, state, readLayout(catalog, sel, {}, {rowMean, prompt: small ? pending.prompt : null}), pending.previous), decisions}
+      const next = {...base, step: 'layout', prompt: pending.prompt, items: sel.items, row: sel.row}
+      const preview = done(catalog, state, sel.items.map((i: any) => ({part: i.part, ...(i.params && {params: i.params})})), pending.previous)
+      return {preview, request: request(names, stepOf(catalog, next)), pending: next, decisions}
+    }
+    const tree = readLayout(catalog, {items: pending.items, row: pending.row}, a, {rowMean, prompt: small ? pending.prompt : null})
+    return {layout: done(catalog, state, tree, pending.previous), decisions}
+  }
+
+  return {
+    sink: 'HTTP',
+    kind: 'decisions',
+    start({catalog, state, prompt, previous, names}: any) {
+      const base = previous ? {previous} : {}
+      // a layout with parts on it: an edit (2 calls at most); `fresh: true` passes previous = null
+      const leaves = previous ? editLeaves(catalog, previous, state) : []
+      if (leaves.length) {
+        const pending = {...base, step: 'edit', prompt, leaves, records: addRecords(catalog, state, prompt, leaves, max)}
+        return {request: request(names, stepOf(catalog, pending)), pending}
+      }
+      const pending = usePrefilter(catalog)
+        ? {...base, step: 'categories', prompt}
+        : selectPending(catalog, state, prompt, null, base)
+      return {request: request(names, stepOf(catalog, pending)), pending}
+    },
+    reply: read,
+    /** the reply body that makes the pending step read as `target` (for composeWith); throws when it can't */
+    fake({catalog, state, pending, target}: any) {
+      const step = stepOf(catalog, pending)
+      if (pending.step === 'edit' || pending.step === 'where') {
+        const want = finish(catalog, fromTree(catalog, target || [], pending.previous), state)
+        const reply = fakeEditReply(catalog, state, pending, want, (p: any) => stepOf(catalog, p), (p: any, reply: any) => read({catalog, state, pending: p, reply, names: {}}))
+        if (!reply) throw new Error(`[Sygnal] compose.decisions() fake: can't reach the target ${show(toTree(want))} as an edit of ${show(toTree(pending.previous))} (an edit removes, changes, moves up to any number of parts and adds parts beside, above, below or into others; compose it with { fresh: true } instead)`)
+        return reply
+      }
+      const want = toTree(finish(catalog, fromTree(catalog, target || [], pending.previous ?? undefined), state))
+      const picks = fakePicks(catalog, pending, step, want)
+      const reply = answersFor(step.questions, picks)
+      check(catalog, state, pending, want, read({catalog, state, pending, reply, names: {}}))
+      return reply
+    },
+  }
+}
+
+// ---------- fake: answers that read as a target tree (structure/evals/selftest.mjs) ----------
+/** the target's leaves (DFS order) and containers, with their places */
+function walkTarget(c: any, tree: any[]) {
+  const leaves: any[] = [], containers: any = {}, rows: any[] = []
+  const visit = (list: any[], where: string, row: any) => {
+    for (const n of list || []) {
+      if (n.part === ROW) {
+        const r: any[] = []
+        rows.push(r)
+        visit(Array.isArray(n.children) ? n.children : n.children?.[ROOT_SLOT] || [], where, r)
+      } else if (containerOf(c, n.part)) {
+        containers[n.part] = where
+        if (Array.isArray(n.children)) visit(n.children, `${n.part}:${ROOT_SLOT}`, null)
+        else for (const [s, l] of Object.entries<any>(n.children || {})) visit(l, `${n.part}:${s}`, null)
+      } else {
+        const leaf = {part: n.part, params: n.params || {}, where, row, i: leaves.length}
+        leaves.push(leaf)
+        row?.push(leaf)
+      }
+    }
+  }
+  visit(tree, `${ROOT}:${ROOT_SLOT}`, null)
+  return {leaves, containers, rows}
+}
+const one = (choice: string) => ({choice, probabilities: {[choice]: 1}})
+
+/** the options of a (possibly chunked) question, by its base name */
+function optionsAt(step: any) {
+  const out: any = {}
+  for (const [name, m] of Object.entries<any>(step.meta)) {
+    const q = step.questions[name]
+    if (q?.type !== 'choice') continue
+    const base = m.base ?? name
+    const have: string[] = out[base] || []
+    out[base] = [...have, ...Object.keys(q.criteria).filter(k => !have.includes(k))]
+  }
+  return out
+}
+/** fake answers by base name → picks per question (a chunk without the wanted option answers its head, else a 1% option) */
+function spread(step: any, wanted: any) {
+  const picks: any = {}
+  for (const [name, m] of Object.entries<any>(step.meta)) {
+    const q = step.questions[name], w = wanted[m.base ?? name]
+    if (w === undefined || !q) continue
+    if (q.type !== 'choice') { picks[name] = w; continue }
+    const keys = Object.keys(q.criteria)
+    if (keys.includes(String(w))) picks[name] = one(String(w))
+    else if (m.head?.length) picks[name] = one(m.head[0])
+    else picks[name] = {choice: keys[0], probabilities: {[keys[0]]: 0.01}}
+  }
+  return picks
+}
+/** each question's meta once, by base name */
+const metasOf = (step: any) => {
+  const seen = new Set<string>()
+  return Object.entries<any>(step.meta).filter(([name, m]) => { const b = m.base ?? name; if (seen.has(b)) return false; seen.add(b); return true }).map(([name, m]) => [m.base ?? name, m] as [string, any])
+}
+
+function fakePicks(c: any, pending: any, step: any, want: any[]) {
+  const {leaves, containers} = walkTarget(c, want)
+  const picks: any = {}
+  const opts = optionsAt(step)
+  const has = (id: string) => leaves.filter(l => l.part === id)
+  if (pending.step === 'categories' || pending.step === 'select') {
+    for (const [name, m] of metasOf(step)) {
+      const keys: string[] = opts[name] || []
+      if (m.kind === 'cat') picks[name] = leaves.some(l => partOf(c, l.part)?.category === m.category) ? 'use' : 'omit'
+      else if (m.kind === 'use') picks[name] = has(m.part).length ? 'use' : 'omit'
+      else if (m.kind === 'count') picks[name] = String(Math.min(has(m.part).length, maxUses(partOf(c, m.part))))
+      else if (m.kind === 'pick') picks[name] = m.members.find((id: string) => has(id).length) ?? 'omit'
+      else if (m.kind === 'rec') {
+        const rp = recordParam(partOf(c, m.part))
+        const values = has(m.part).map(l => String(l.params?.[rp as string]))
+        const v = values[m.n - 1]
+        picks[name] = v !== undefined && keys.includes(v) ? v : 'none'
+      } else if (m.kind === 'param') {
+        const v = has(m.part).map(l => l.params?.[m.param]).find(x => x !== undefined)
+        const s = v === undefined ? 'not_stated' : String(v)
+        picks[name] = keys.includes(s) ? s : 'not_stated'
+      } else if (m.kind === 'row') picks[name] = leaves.some(l => l.row)
+    }
+    return spread(step, picks)
+  }
+  // layout: match the selected items to the target's leaves (part + record, in order)
+  const items = pending.items
+  const taken = new Set<any>()
+  const leafOf: any = {}
+  for (const it of items) {
+    const rp = recordParam(partOf(c, it.part))
+    const l = leaves.find(l => !taken.has(l) && l.part === it.part && (!rp || String(l.params?.[rp]) === String(it.params?.[rp])))
+    if (l) { taken.add(l); leafOf[it.key] = l }
+  }
+  const pos = (k: string) => leafOf[k]?.i ?? Infinity
+  for (const [name, m] of metasOf(step)) {
+    const keys: string[] = opts[name] || []
+    if (m.kind === 'parent') {
+      const where = leafOf[m.key]?.where ?? containers[m.key]
+      picks[name] = keys.includes(where) ? where : keys[0]
+    } else if (m.kind === 'beside') {
+      const row = leafOf[m.key]?.row
+      if (!row) { picks[name] = 'none'; continue }
+      // a ring: each member names the next one (the last names the first), so average-linkage keeps
+      // the row together at rowMean 0.25 for up to 6 members
+      const mates = row.map((l: any) => Object.keys(leafOf).find(k => leafOf[k] === l))
+      const next = mates[(mates.indexOf(m.key) + 1) % mates.length]
+      picks[name] = keys.includes(next) ? next : 'none'
+    } else if (m.kind === 'same') picks[name] = !!leafOf[m.a]?.row && leafOf[m.a].row === leafOf[m.b]?.row
+    else if (m.kind === 'left' || m.kind === 'first') picks[name] = pos(m.a) <= pos(m.b) ? m.a : m.b
+    else if (m.kind === 'gap') {
+      const g = leaves.filter(l => l.part === m.part && l.i < pos(m.key)).length
+      picks[name] = String(Math.min(g, keys.length - 1))
+    }
+  }
+  return spread(step, picks)
+}
+
+const canon = (x: any): any => Array.isArray(x) ? x.map(canon)
+  : x && typeof x == 'object' ? Object.fromEntries(Object.keys(x).sort().map(k => [k, canon(x[k])])) : x
+const show = (t: any) => JSON.stringify(t)
+
+/** throws when reading the fake's answers doesn't give the target (an unreachable target) */
+function check(c: any, state: any, pending: any, want: any[], out: any) {
+  const fail = (why: string) => { throw new Error(`[Sygnal] compose.decisions() fake: can't reach the target ${show(want)}: ${why}`) }
+  if (pending.step === 'select') {
+    for (const l of walkTarget(c, want).leaves) {
+      const rp = recordParam(partOf(c, l.part))
+      if (rp && !(pending.records?.[l.part] || []).some((r: any) => String(r.value) === String(l.params?.[rp]))) {
+        fail(`the prompt ${JSON.stringify(pending.prompt)} doesn't name the ${l.part} record ${JSON.stringify(l.params?.[rp])} (records are found by name or alias in the prompt)`)
+      }
+    }
+  }
+  if (out.request) {
+    if (pending.step !== 'select') return
+    const got = out.pending.items.map((i: any) => show(canon({part: i.part, params: i.params || {}}))).sort()
+    const exp = walkTarget(c, want).leaves.map(l => show(canon({part: l.part, params: l.params || {}}))).sort()
+    if (show(got) !== show(exp)) fail(`the select step reads as ${got.join(' ')}`)
+    return
+  }
+  if (out.unavailable) {
+    // nothing fits: the target holds nothing but required parts (which finish() adds anyway)
+    if (walkTarget(c, want).leaves.some(l => !partOf(c, l.part)?.required)) fail('the answers read as "nothing fits"')
+    return
+  }
+  const got = toTree(out.layout)
+  if (show(canon(got)) !== show(canon(want))) fail(`the answers read as ${show(got)}`)
+}