@cspeach/cli 1.1.34 → 1.1.36

package/dist/rap/finish-checks.js

@@ -0,0 +1,389 @@
+// cspeach-cli/src/rap/finish-checks.ts
+//
+// RAP generator plan, Task 10 — Finish items F1–F5 (spec 2026-10-14 §6),
+// checked mechanically on the app's sources so the model cannot claim them
+// done. Pure: the tool `rap_finish_check` reads the live sources and calls
+// checkFinish. SAP's real generated skeleton is the failing fixture.
+//
+// Problem texts are short, plain sentences a developer understands; the only
+// ids in them are object and field names.
+//
+// Fix round 1: comments (`//`, `--`, `/* */`) are stripped from the BDEF, CDS,
+// DDLX and table sources before any rule reads them, so commented-out code never
+// passes a check. A view field the parser cannot read is a problem, never a
+// silent skip.
+export const FINISH_TITLES = {
+    F1: 'Authorization',
+    F2: 'Access control',
+    F3: 'Admin fields',
+    F4: 'Labels',
+    F5: 'Coded fields',
+};
+const ADMIN_FIELDS = ['CreatedBy', 'CreatedAt', 'LastChangedBy', 'LastChangedAt', 'LocalLastChangedAt', 'LocalLastChangedBy'];
+const item = (id, problems) => ({ id, ok: problems.length === 0, problems });
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const eqi = (a, b) => a.toLowerCase() === b.toLowerCase();
+const unreadable = (line, object) => `Could not read the field on line ${line} of ${object}; check it by hand`;
+/**
+ * CDS / BDEF source without comments: `// …` and `-- …` to end of line, and
+ * `/* … *\/` blocks. Quoted literals ('…') are kept as they are. Line breaks
+ * inside a block comment are kept, so line numbers do not move.
+ */
+export function stripCdsComments(src) {
+    let out = '';
+    let i = 0;
+    const n = src.length;
+    while (i < n) {
+        const c = src[i];
+        const d = src[i + 1];
+        if (c === "'") {
+            const j = src.indexOf("'", i + 1);
+            const e = j < 0 ? n : j + 1;
+            out += src.slice(i, e);
+            i = e;
+        }
+        else if ((c === '/' && d === '/') || (c === '-' && d === '-')) {
+            while (i < n && src[i] !== '\n' && src[i] !== '\r')
+                i++;
+        }
+        else if (c === '/' && d === '*') {
+            const j = src.indexOf('*/', i + 2);
+            const e = j < 0 ? n : j + 2;
+            out += src.slice(i, e).replace(/[^\r\n]/g, '');
+            i = e;
+        }
+        else {
+            out += c;
+            i++;
+        }
+    }
+    return out;
+}
+/** Annotation lines directly above line index `i` of `lines`, joined. */
+function annotationsAt(lines, i) {
+    const ann = [];
+    let depth = 0;
+    for (let j = i - 1; j >= 0; j--) {
+        const t = lines[j].trim();
+        depth += (t.match(/[\]}]/g)?.length ?? 0) - (t.match(/[[{]/g)?.length ?? 0);
+        if (t === '' && depth <= 0)
+            break;
+        if (depth <= 0 && !t.startsWith('@') && !/^[\]}]/.test(t))
+            break;
+        ann.unshift(t);
+    }
+    return ann.join('\n');
+}
+/** Annotation lines that sit directly above `element` (DDLS or DDLX), joined. Comments are ignored. */
+export function annotationsFor(source, element) {
+    const lines = stripCdsComments(source).split(/\r?\n/);
+    const re = new RegExp(`^\\s*(key\\s+)?([a-z0-9_.]+\\s+as\\s+)?${escapeRe(element)}\\s*[,;]?\\s*$`, 'i');
+    const i = lines.findIndex((l) => re.test(l));
+    return i < 0 ? '' : annotationsAt(lines, i);
+}
+/** Splits an annotation block into single annotations (each starts with '@'). */
+function splitAnnotations(block) {
+    const out = [];
+    for (const line of block.split('\n')) {
+        if (line.startsWith('@') || out.length === 0)
+            out.push(line);
+        else
+            out[out.length - 1] += `\n${line}`;
+    }
+    return out.filter((a) => a.trim() !== '');
+}
+/**
+ * Field labels in an annotation block. Left out: @UI.facet (a section title)
+ * and lineItem/identification entries of `type: #FOR_ACTION` (an action button).
+ */
+function fieldLabels(block) {
+    const labels = [];
+    for (const a of splitAnnotations(block)) {
+        if (/^@UI\.facet\b/i.test(a))
+            continue;
+        const fieldOnly = a.replace(/\{[^{}]*#FOR_ACTION\b[^{}]*\}/gi, '');
+        for (const m of fieldOnly.matchAll(/\blabel\s*:\s*'([^']*)'/gi))
+            labels.push(m[1]);
+    }
+    return labels;
+}
+/**
+ * Fields of a view entity body. Handles `key X`, `X`, `x as X`, `path.x as X`,
+ * `virtual X : …`, and expressions ending in `as X` (`cast( … ) as X`, a
+ * `case … end as X` over several lines). Association exposures (`_Assoc`,
+ * `_Assoc : redirected to …`) are skipped. Anything else, and two fields on
+ * one line, is reported in `unreadable`; it is never skipped silently.
+ */
+export function ddlsElements(source) {
+    const text = stripCdsComments(source);
+    const lines = text.split(/\r?\n/);
+    const def = text.search(/\bdefine\b/i);
+    const open = text.indexOf('{', def < 0 ? 0 : def);
+    const close = text.lastIndexOf('}');
+    if (open < 0 || close <= open)
+        return { elements: [], unreadable: [] };
+    const lineOf = (pos) => text.slice(0, pos).match(/\n/g)?.length ?? 0;
+    const colOf = (pos) => pos - (text.lastIndexOf('\n', pos - 1) + 1);
+    const openLine = lineOf(open);
+    const closeLine = lineOf(close);
+    const body = [];
+    for (let k = openLine; k <= closeLine; k++) {
+        const l = lines[k];
+        const from = k === openLine ? colOf(open) + 1 : 0;
+        const to = k === closeLine ? colOf(close) : l.length;
+        body.push(l.slice(from, to));
+    }
+    // Blank the annotations (they may span lines and contain commas).
+    let depth = 0;
+    for (let k = 0; k < body.length; k++) {
+        const t = body[k].trim();
+        if (depth > 0 || t.startsWith('@')) {
+            const bare = t.replace(/'[^']*'/g, '');
+            depth = Math.max(0, depth + (bare.match(/[[{(]/g)?.length ?? 0) - (bare.match(/[\]})]/g)?.length ?? 0));
+            body[k] = '';
+        }
+    }
+    const chunks = [];
+    let cur = '';
+    let first = -1;
+    let last = -1;
+    let nest = 0;
+    let inQuote = false;
+    const flush = () => {
+        if (cur.trim() !== '')
+            chunks.push({ text: cur, first, last });
+        cur = '';
+        first = -1;
+        last = -1;
+    };
+    for (let k = 0; k < body.length; k++) {
+        for (const ch of `${body[k]}\n`) {
+            if (!/\s/.test(ch)) {
+                if (first < 0)
+                    first = k;
+                last = k;
+            }
+            if (inQuote) {
+                if (ch === "'")
+                    inQuote = false;
+                cur += ch;
+                continue;
+            }
+            if (ch === "'")
+                inQuote = true;
+            else if ('([{'.includes(ch))
+                nest++;
+            else if (')]}'.includes(ch))
+                nest--;
+            else if (ch === ',' && nest === 0) {
+                flush();
+                continue;
+            }
+            cur += ch;
+        }
+    }
+    flush();
+    const usage = new Map();
+    for (const c of chunks)
+        for (let k = c.first; k <= c.last; k++)
+            usage.set(k, (usage.get(k) ?? 0) + 1);
+    const bad = new Set();
+    const elements = [];
+    for (const c of chunks) {
+        const line = openLine + c.first;
+        const shared = [...Array(c.last - c.first + 1).keys()].map((d) => c.first + d).find((k) => (usage.get(k) ?? 0) > 1);
+        if (shared !== undefined) {
+            bad.add(openLine + shared + 1);
+            continue;
+        }
+        const s = c.text.replace(/\s+/g, ' ').trim();
+        if (/^_\w+(\s*:.*)?$/.test(s))
+            continue;
+        const virt = /^(?:key\s+)?virtual\s+([A-Za-z_]\w*)\s*:/i.exec(s);
+        if (virt) {
+            elements.push({ name: virt[1], line });
+            continue;
+        }
+        const m = /^(?:key\s+)?(?:(.+?)\s+as\s+)?([A-Za-z_]\w*)$/i.exec(s);
+        if (!m) {
+            bad.add(line + 1);
+            continue;
+        }
+        elements.push(m[1] && /^[\w.]+$/.test(m[1]) ? { name: m[2], source: m[1], line } : { name: m[2], line });
+    }
+    return { elements, unreadable: [...bad].sort((x, y) => x - y) };
+}
+/** ABAP source without comment lines (`*` in column 1) and end-of-line `"` comments. */
+function stripAbapComments(src) {
+    return src.split(/\r?\n/).filter((l) => !l.startsWith('*')).map((l) => l.replace(/".*$/, '')).join('\n');
+}
+/** F1 — instance authorization with a real AUTHORITY-CHECK. Expects comment-free BDEF. */
+function checkAuth(src, opts) {
+    const problems = [];
+    if (!/authorization\s+master\s*\(\s*instance\s*\)/i.test(src.rootBdef)) {
+        problems.push(/authorization\s+master\s*\(\s*global\s*\)/i.test(src.rootBdef)
+            ? 'Authorization is global; it must be instance'
+            : `${opts.root} has no instance authorization; add authorization master ( instance )`);
+    }
+    const code = stripAbapComments(src.ccimp);
+    const start = /\bMETHOD\s+get_instance_authorizations\s*\./i.exec(code);
+    if (!start) {
+        problems.push('get_instance_authorizations is not implemented');
+        return item('F1', problems);
+    }
+    const rest = code.slice(start.index + start[0].length);
+    const end = /\bENDMETHOD\b/i.exec(rest);
+    const body = end ? rest.slice(0, end.index) : rest;
+    if (!/\bAUTHORITY-CHECK\b/i.test(body)) {
+        problems.push('get_instance_authorizations has no AUTHORITY-CHECK');
+    }
+    else if (opts.authObject && !new RegExp(`\\bOBJECT\\s+'${escapeRe(opts.authObject)}'`, 'i').test(body)) {
+        problems.push(`get_instance_authorizations does not check ${opts.authObject}`);
+    }
+    return item('F1', problems);
+}
+/** F2 — an access control for the root view and for the projection. */
+function checkDcl(src, opts) {
+    const have = new Set(src.dclsNames.map((n) => n.toUpperCase()));
+    const problems = [opts.root, opts.projection]
+        .filter((n) => !have.has(n.toUpperCase()))
+        .map((n) => `No access control for ${n}`);
+    return item('F2', problems);
+}
+const ABP_ADMIN_TYPE = /^abp_(?:creation_(?:user|tstmpl)|lastchange_(?:user|tstmpl)|locinst_\w+)$/i;
+/** Columns of a `define table` source typed with an abp_* admin type (lower-case names). */
+function abpAdminColumns(table) {
+    if (!table)
+        return [];
+    const cols = [];
+    for (const m of table.matchAll(/^\s*(?:key\s+)?([A-Za-z_]\w*)\s*:\s*([A-Za-z_]\w*)/gim)) {
+        if (ABP_ADMIN_TYPE.test(m[2]))
+            cols.push(m[1].toLowerCase());
+    }
+    return cols;
+}
+/** F3 — admin fields read-only; a UUID key uses managed numbering. Expects comment-free sources. */
+function checkAdminReadOnly(src, opts) {
+    const root = ddlsElements(src.rootDdls);
+    const problems = root.unreadable.map((l) => unreadable(l, opts.root));
+    const readonly = new Set();
+    for (const m of src.rootBdef.matchAll(/field\s*\(\s*readonly\s*\)\s*([^;]+);/gi)) {
+        for (const f of m[1].split(','))
+            readonly.add(f.trim().toLowerCase());
+    }
+    const names = new Set(root.elements.map((e) => e.name.toLowerCase()));
+    // Final review M7 — with the table source, the admin fields are also the
+    // columns typed abp_* (creation/lastchange user + timestamp, locinst_*),
+    // under whatever alias the root view gives them. The fixed names stay the fallback.
+    const admin = ADMIN_FIELDS.filter((f) => names.has(f.toLowerCase()));
+    for (const col of abpAdminColumns(src.table)) {
+        const el = root.elements.find((e) => e.source !== undefined && e.source.split('.').pop().toLowerCase() === col);
+        if (el && !admin.some((f) => f.toLowerCase() === el.name.toLowerCase()))
+            admin.push(el.name);
+    }
+    for (const f of admin) {
+        if (!readonly.has(f.toLowerCase()))
+            problems.push(`${f} can be edited; make it read-only`);
+    }
+    const uuidKey = src.table ? /\bkey\s+(\w+)\s*:\s*sysuuid_x16\b/i.exec(src.table) : null;
+    if (uuidKey && !/numbering\s*:\s*managed/i.test(src.rootBdef)) {
+        problems.push(`The key ${uuidKey[1]} is a UUID; add numbering : managed`);
+    }
+    return item('F3', problems);
+}
+/** F4 — every visible field has a real label; the app title is a business name. Expects comment-free sources. */
+function checkLabels(src, opts) {
+    if (src.ddlx === undefined)
+        return item('F4', [`No metadata extension for ${opts.projection}`]);
+    const ddlx = src.ddlx;
+    const proj = ddlsElements(src.projectionDdls);
+    const root = ddlsElements(src.rootDdls).elements;
+    const projLines = src.projectionDdls.split(/\r?\n/);
+    const rootLines = src.rootDdls.split(/\r?\n/);
+    const problems = proj.unreadable.map((l) => unreadable(l, opts.projection));
+    let emptyAttributed = 0;
+    for (const el of proj.elements) {
+        const xBlock = annotationsFor(ddlx, el.name);
+        const pBlock = annotationsAt(projLines, el.line);
+        const rootEl = root.find((r) => eqi(r.name, el.source ?? el.name));
+        const rBlock = rootEl ? annotationsAt(rootLines, rootEl.line) : '';
+        const xLabels = fieldLabels(xBlock);
+        const empties = xLabels.filter((l) => l.trim() === '').length;
+        emptyAttributed += empties;
+        if (empties > 0)
+            problems.push(`${el.name} has an empty label`);
+        if (xLabels.some((l) => l.length > 8 && !/\s/.test(l) && eqi(l, el.name))) {
+            problems.push(`${el.name} label is just the field name`);
+        }
+        const hidden = /@UI\.hidden\s*:\s*true\b/i.test(`${xBlock}\n${pBlock}`);
+        const endUser = (b) => [...b.matchAll(/@EndUserText\.label\s*:\s*'([^']*)'/gi)].map((m) => m[1]);
+        const all = [...xLabels, ...endUser(pBlock), ...endUser(rBlock)];
+        if (!hidden && empties === 0 && !all.some((l) => l.trim() !== ''))
+            problems.push(`${el.name} has no label`);
+    }
+    const emptyTotal = [...ddlx.matchAll(/\blabel\s*:\s*''/gi)].length;
+    if (emptyTotal > emptyAttributed)
+        problems.push('A section of the metadata extension has an empty label');
+    const header = `${ddlx}\n${src.projectionDdls}`;
+    const typeName = /\btypeName\s*:\s*'([^']*)'/i.exec(header)?.[1]?.trim();
+    const plural = /\btypeNamePlural\s*:\s*'([^']*)'/i.exec(header)?.[1]?.trim();
+    if (!typeName)
+        problems.push('The app has no title (headerInfo typeName)');
+    else if (eqi(typeName, opts.entity))
+        problems.push(`The app title is ${typeName}; use the business name`);
+    if (!plural)
+        problems.push('The app has no plural title (headerInfo typeNamePlural)');
+    else if (eqi(plural, opts.entity) || eqi(plural, `${opts.entity}s`)) {
+        problems.push(`The plural app title is ${plural}; use the business name`);
+    }
+    return item('F4', problems);
+}
+/**
+ * F5 — coded fields show a value help and their text, not the raw code. The
+ * text element must be a field of the projection (a path starting with `_` is
+ * accepted), or the field uses @ObjectModel.text.association. Expects comment-free sources.
+ */
+function checkCodedFields(src, opts) {
+    const problems = [];
+    const elements = ddlsElements(src.projectionDdls).elements;
+    const projLines = src.projectionDdls.split(/\r?\n/);
+    for (const f of opts.codedFields ?? []) {
+        const el = elements.find((e) => eqi(e.name, f));
+        if (!el) {
+            problems.push(`${f} is not in ${opts.projection}`);
+            continue;
+        }
+        const ann = `${annotationsAt(projLines, el.line)}\n${src.ddlx ? annotationsFor(src.ddlx, el.name) : ''}`;
+        if (!/@Consumption\.valueHelpDefinition\b/i.test(ann))
+            problems.push(`${f} has no value help`);
+        if (!/@ObjectModel\.text\.association\b/i.test(ann)) {
+            const te = /@ObjectModel\.text\.element\s*:\s*\[\s*'([^']+)'/i.exec(ann)?.[1]?.trim();
+            if (!te)
+                problems.push(`${f} has no text`);
+            else if (!te.startsWith('_') && !elements.some((e) => eqi(e.name, te))) {
+                problems.push(`${f} shows text ${te}, which is not in ${opts.projection}`);
+            }
+        }
+        if (!/#TEXT_ONLY\b/i.test(ann))
+            problems.push(`${f} does not show its text (#TEXT_ONLY)`);
+    }
+    return item('F5', problems);
+}
+/** F1–F5, always five items, in order. Comments are stripped first. */
+export function checkFinish(src, opts) {
+    const clean = {
+        ...src,
+        rootDdls: stripCdsComments(src.rootDdls),
+        projectionDdls: stripCdsComments(src.projectionDdls),
+        rootBdef: stripCdsComments(src.rootBdef),
+        ...(src.ddlx !== undefined ? { ddlx: stripCdsComments(src.ddlx) } : {}),
+        ...(src.table !== undefined ? { table: stripCdsComments(src.table) } : {}),
+    };
+    return [
+        checkAuth(clean, opts),
+        checkDcl(clean, opts),
+        checkAdminReadOnly(clean, opts),
+        checkLabels(clean, opts),
+        checkCodedFields(clean, opts),
+    ];
+}

package/dist/rap/generator-names.js

@@ -0,0 +1,57 @@
+const camel = (base) => base.toLowerCase().split('_').filter(Boolean)
+    .map((p) => p[0].toUpperCase() + p.slice(1)).join('');
+/**
+ * The names both skeleton paths build. `suffix` (final review I3, spec row 7):
+ * a digit appended to the base when a name is taken — every derived name
+ * carries it, and the cuts that keep the limits are made BEFORE it, so the
+ * digit is never cut off. The table name itself never changes.
+ */
+export function proposeNames(table, suffix = '') {
+    const t = table.trim().toUpperCase();
+    const plain = t.replace(/^[ZY]/, '').replace(/^_/, '');
+    const base = `${plain}${suffix}`;
+    // Draft table ≤16 chars; strip ALL trailing underscores so it never ends in '__D'.
+    const draft = `${t.slice(0, 14 - suffix.length).replace(/_+$/, '')}${suffix}_D`;
+    // Service names ≤26 (SRVB limit): shorten the service base only (spec §3: "the plan proposes shorter ones").
+    const svcBase = `ZUI_${base}_O4`.length <= 26 ? base : `${plain.slice(0, 19 - suffix.length).replace(/_+$/, '')}${suffix}`;
+    const svc = `ZUI_${svcBase}_O4`;
+    return {
+        table: t, base, entity: camel(base),
+        root: `ZR_${base}`, projection: `ZC_${base}`, behaviorPool: `ZBP_${base}`,
+        draftTable: draft, serviceDefinition: svc, serviceBinding: svc,
+    };
+}
+export function namesFitLimits(n) {
+    return n.draftTable.length <= 16 && n.serviceBinding.length <= 26
+        && [n.root, n.projection, n.behaviorPool, n.serviceDefinition].every((x) => x.length <= 30);
+}
+/** The 9 objects SAP's uiservice generator creates, in SAP's preview order. */
+export function generatorPlannedObjects(n, pkg) {
+    const p = pkg.toUpperCase();
+    return [
+        { type: 'DDLS', name: n.root, package: p },
+        { type: 'BDEF', name: n.root, package: p },
+        { type: 'CLAS', name: n.behaviorPool, package: p },
+        { type: 'TABL', name: n.draftTable, package: p },
+        { type: 'DDLS', name: n.projection, package: p },
+        { type: 'BDEF', name: n.projection, package: p },
+        { type: 'DDLX', name: n.projection, package: p },
+        { type: 'SRVD', name: n.serviceDefinition, package: p },
+        { type: 'SRVB', name: n.serviceBinding, package: p },
+    ];
+}
+export function buildUiserviceContent(n, pkg, description) {
+    return {
+        metadata: { package: pkg.toUpperCase(), masterLanguage: 'EN' },
+        general: { referenceObjectName: n.table, description: description.slice(0, 60) },
+        businessObject: {
+            dataModelEntity: { cdsName: n.root, entityName: n.entity },
+            behavior: { implementationType: 'Managed', implementationClass: n.behaviorPool, draftTable: n.draftTable },
+        },
+        serviceProjection: { name: n.projection },
+        businessService: {
+            serviceDefinition: { name: n.serviceDefinition },
+            serviceBinding: { name: n.serviceBinding, bindingType: 'OData V4 - UI' },
+        },
+    };
+}

package/dist/rap/skeleton-card.js

@@ -0,0 +1,31 @@
+import { cardLine } from '../lane/card.js';
+import { OBJECT_TYPE_LABELS } from '../projects/plan-objects.js';
+export const SKELETON_WHO = {
+    'sap-generator': "SAP's generator",
+    cspeach: 'CSPeach writer',
+};
+export function skeletonCardRequest(d, blockedReason, n, objects) {
+    const by = d.by ?? 'cspeach';
+    const facts = [
+        `Table: ${n.table}`,
+        `Why: ${d.reason}`,
+        ...(by === 'sap-generator'
+            ? objects.map((o) => `${o.name} · ${OBJECT_TYPE_LABELS[o.type] ?? o.type}`)
+            : [`App shape: ${n.root}, ${n.projection}, ${n.serviceBinding}`]),
+        'Either way, CSPeach then adds security, labels, value helps, logic and tests, and checks them.',
+    ];
+    const choices = [{ value: 'confirm', label: `Build the skeleton with the ${SKELETON_WHO[by]}` }];
+    if (by === 'sap-generator')
+        choices.push({ value: 'switch:cspeach', label: 'Use the CSPeach writer instead' });
+    else if (!blockedReason)
+        choices.push({ value: 'switch:sap-generator', label: "Use SAP's generator instead" });
+    choices.push({ value: 'cancel', label: 'Cancel' });
+    return {
+        id: 'rap-skeleton',
+        tag: 'QUESTION',
+        title: 'How should the RAP skeleton be built?',
+        facts: facts.map(cardLine),
+        choices: choices.map((c) => ({ ...c, label: cardLine(c.label) })),
+        initial: 0,
+    };
+}

package/dist/rap/skeleton-rules.js

@@ -0,0 +1,38 @@
+const RAP_TIERS = new Set(['s4-2020-plus', 'unknown']);
+export function generatorBlockers(req, f) {
+    // Row 3 variant (final review I1): no SAP at all — nothing to check, the CSPeach writer.
+    if (f.connected === false)
+        return { row: 3, reason: 'Not connected to SAP' };
+    if (f.generator === 'no')
+        return { row: 3, reason: 'This system has no RAP generator' };
+    if (f.generator === 'unknown')
+        return { row: 3, reason: "Couldn't confirm a RAP generator on this system" };
+    if (req.entities !== 1 || req.implementation !== 'managed' || !req.draft || req.binding !== 'odata-v4-ui') {
+        return { row: 4, reason: "SAP's generator supports only one table, managed, with draft, V4 UI" };
+    }
+    // Row 4 variant (final review M2): the generator writes to a transport; a $ package has none.
+    if (f.localPackage)
+        return { row: 4, reason: "SAP's generator needs a transport, and a local package has none" };
+    if (f.tableExists && f.tableHasTimestamps === false)
+        return { row: 5, reason: "This table lacks the fields SAP's generator needs" };
+    if (f.tableExists && f.uiserviceOffered === false)
+        return { row: 6, reason: "SAP's generator isn't offered for this table" };
+    if (!f.namesFit)
+        return { row: 7, reason: "These names are too long for SAP's generator" };
+    if (f.tableExists && f.validation && !f.validation.ok) {
+        return { row: 7, reason: `SAP's generator check failed: ${f.validation.text || 'no reason given'}` };
+    }
+    return null;
+}
+export function decideSkeleton(req, f, override) {
+    if (!RAP_TIERS.has(f.tier))
+        return { by: null, row: 2, reason: 'RAP needs S/4HANA 2020 or later', overridden: false };
+    const blocked = generatorBlockers(req, f);
+    if (override === 'cspeach')
+        return { by: 'cspeach', row: 1, reason: 'Chosen by you', overridden: true };
+    if (override === 'sap-generator' && !blocked)
+        return { by: 'sap-generator', row: 1, reason: 'Chosen by you', overridden: true };
+    if (blocked)
+        return { by: 'cspeach', row: blocked.row, reason: blocked.reason, overridden: false };
+    return { by: 'sap-generator', row: 8, reason: "Fits SAP's generator: built in seconds, then finished by CSPeach", overridden: false };
+}

package/dist/rap/skeleton-session.js

@@ -0,0 +1,21 @@
+// cspeach-cli/src/rap/skeleton-session.ts
+//
+// RAP generator plan, Task 8 fix round 1 — the session's latest skeleton
+// decision. rap_skeleton_resolve records the {path, sha256} it just wrote; the
+// plan save then accepts only that decision, so a plan cannot cite an older
+// sha-valid file (e.g. one from before an owner override). Keyed on the session
+// object in a WeakMap, like the app flow (lane/app-flow.ts): two sessions never
+// see each other's decision and nothing outlives its session.
+const latest = new WeakMap();
+/** Record the decision rap_skeleton_resolve just wrote (replaces any earlier one). */
+export function setLatestSkeletonDecision(session, ref) {
+    latest.set(session, { path: ref.path, sha256: ref.sha256 });
+}
+/** A frozen copy of the session's latest decision, or undefined when none was made. */
+export function getLatestSkeletonDecision(session) {
+    const r = latest.get(session);
+    return r ? Object.freeze({ ...r }) : undefined;
+}
+export function clearLatestSkeletonDecision(session) {
+    latest.delete(session);
+}

package/dist/rap/skeleton-store.js

@@ -0,0 +1,40 @@
+// cspeach-cli/src/rap/skeleton-store.ts
+//
+// RAP generator plan, Task 6 — the skeleton decision file, written only by
+// rap_skeleton_resolve, read by the plan-save check and sap_generate_objects.
+// sha-pinned like the lane decision (lane/store.ts): a hand edit is refused.
+import { createHash, randomBytes } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+const DIR = '.cspeach/lane';
+const sha = (s) => createHash('sha256').update(s).digest('hex');
+export async function writeSkeletonDecision(laneRoot, rec) {
+    const full = { kind: 'rap-skeleton', version: 1, ...rec, createdAt: new Date().toISOString() };
+    const body = `${JSON.stringify(full, null, 2)}\n`;
+    const day = full.createdAt.slice(0, 10).replace(/-/g, '');
+    const rel = `${DIR}/skeleton-${day}-${randomBytes(4).toString('hex')}.json`;
+    await fs.mkdir(path.join(laneRoot, DIR), { recursive: true });
+    await fs.writeFile(path.join(laneRoot, rel), body, { encoding: 'utf8', flag: 'wx' });
+    return { path: rel, sha256: sha(body) };
+}
+export async function readSkeletonDecision(laneRoot, relPath, sha256) {
+    const norm = String(relPath ?? '').replace(/\\/g, '/');
+    if (!/^\.cspeach\/lane\/skeleton-\d{8}-[0-9a-f]{8}\.json$/.test(norm)) {
+        return { ok: false, message: 'The skeleton decision path is not a CSPeach decision file. Run /abap-plan again.' };
+    }
+    let body;
+    try {
+        body = await fs.readFile(path.join(laneRoot, norm), 'utf8');
+    }
+    catch {
+        return { ok: false, message: 'The skeleton decision file is missing. Run /abap-plan again.' };
+    }
+    if (sha(body) !== sha256) {
+        return { ok: false, message: 'The skeleton decision file changed after it was saved. Run /abap-plan again.' };
+    }
+    const rec = JSON.parse(body);
+    if (rec.kind !== 'rap-skeleton' || rec.version !== 1) {
+        return { ok: false, message: 'The skeleton decision file is not readable by this CSPeach version. Run /abap-plan again.' };
+    }
+    return { ok: true, rec };
+}

package/dist/renderer/change-card.js

@@ -6,10 +6,11 @@
 import { diffLines } from 'diff';
 import { paint } from './theme.js';
 import { getBoxChars } from '../ui/ascii-chars.js';
+import { ERROR_DETAIL_ROWS, SNAPSHOT_DETAIL_ROWS } from './verify-chain.js';
 import { ANSI_RE } from './tool-labels.js';
+import { wrapRows } from './wrap-rows.js';
 export const MIN_CARD_WIDTH = 40;
 const DIFF_LINES = 6;
-const DETAIL_MAX = 60;
 /** Myers diff is O(N·D) and synchronous: past this budget we show no diff
  *  at all (object + footer only), never a partial one. */
 const DIFF_TIMEOUT_MS = 200;
@@ -33,7 +34,7 @@ function footerParts(input) {
     else if (input.snapshot === 'new_object')
         parts.push(paint('dim', '– snapshot (new object)'));
     else if (input.snapshot === 'source_read_failed')
-        parts.push(paint('dim', `– snapshot (no source read${input.snapshotDetail ? ': ' + cut(flat(clean(input.snapshotDetail)), 40) : ''})`));
+        parts.push(paint('dim', '– snapshot (no source read)'));
     else
         parts.push(paint('dim', '– snapshot (skipped)'));
     parts.push(input.written ? `${paint('ok', '✓')} written` : `${paint('bad', '✗')} written`);
@@ -54,15 +55,35 @@ function footerParts(input) {
         else if (a.state === 'unverified')
             parts.push(paint('warn', '· activation unverified'));
         else
-            parts.push(`${paint('bad', '✗')} activation${a.detail ? ' ' + paint('bad', `(${cut(flat(clean(a.detail)), DETAIL_MAX)})`) : ''}`);
+            parts.push(`${paint('bad', '✗')} activation`);
     }
     else {
         // Activation is blocked — say so; a pending step would lie.
-        parts.push(`${paint('bad', '✗')} syntax ${paint('bad', `(${cut(flat(clean(input.syntax.errors[0] ?? 'syntax errors')), DETAIL_MAX)})`)}`);
+        parts.push(`${paint('bad', '✗')} syntax`);
         parts.push(paint('dim', '· activation blocked'));
     }
     return parts;
 }
+/**
+ * Fix batch 2026-10-12 (Task 2): the reasons behind a failed step — the
+ * snapshot read failure, the first syntax error, SAP's activation refusal —
+ * are what the user needs, so they are rows of their own (wrapped at word
+ * breaks to `cells`, up to the verify-chain caps), never cut on the footer.
+ */
+function detailLines(input, cells) {
+    const out = [];
+    const wrap = (text, rows) => wrapRows(flat(clean(text)), Math.max(1, cells), rows);
+    if (input.snapshot === 'source_read_failed' && input.snapshotDetail) {
+        out.push(...wrap(`No source read: ${input.snapshotDetail}`, SNAPSHOT_DETAIL_ROWS).map((r) => paint('dim', r)));
+    }
+    if (input.syntax !== 'not_checked' && !input.syntax.ok) {
+        out.push(...wrap(input.syntax.errors[0] ?? 'syntax errors', ERROR_DETAIL_ROWS).map((r) => paint('bad', r)));
+    }
+    else if (input.syntax !== 'not_checked' && input.activation?.state === 'failed' && input.activation.detail) {
+        out.push(...wrap(input.activation.detail, ERROR_DETAIL_ROWS).map((r) => paint('bad', r)));
+    }
+    return out;
+}
 /** Changed lines for the card. Exported for tests only. */
 export function diffBody(card, differ = defaultDiffer) {
     if (card.oldSource === undefined || card.newSource === undefined)
@@ -99,6 +120,7 @@ export function buildChangeCard(input, width, box = getBoxChars()) {
         // cut to the width so nothing wraps (colour dropped only on a cut part).
         for (const p of parts)
             out.push(visibleLen(p) > width ? cut(p.replace(ANSI, ''), width) : p);
+        out.push(...detailLines(input, width));
         if (card.transport)
             out.push(paint('dim', cut(`· ${clean(card.transport)}`, width)));
         return out.join('\n');
@@ -117,6 +139,8 @@ export function buildChangeCard(input, width, box = getBoxChars()) {
         lines.push(row(paint(l.startsWith('+') ? 'ok' : 'bad', cut(l, inner))));
     if (body.hidden > 0)
         lines.push(row(paint('dim', `  … +${body.hidden} lines`)));
+    for (const d of detailLines(input, inner))
+        lines.push(row(d));
     lines.push(...footerLines(parts, chain, transportText, width, b, row));
     return lines.join('\n');
 }