@cspeach/cli 1.1.35 → 1.1.36

package/dist/tools/rap/generate-objects.js

@@ -0,0 +1,317 @@
+// cspeach-cli/src/tools/rap/generate-objects.ts
+//
+// RAP generator plan, Task 9 — `sap_generate_objects` (spec 2026-10-14 §5).
+// Runs SAP's RAP generator (uiservice) for a skeleton phase whose decision
+// says sap-generator, under the usual write gates:
+//   decision file → approvals (one per planned object) → transport fit →
+//   table ready → generator offered → validate again → preview again →
+//   pending entry → generate → read back (active, on the plan's transport) →
+//   audit + finalize.
+// A failure stops and returns a plain-words error. A failed generate (an SAP
+// error answer OR a throw) or a failed read back shows a card listing the
+// objects that now exist; nothing switches path silently.
+import crypto from 'node:crypto';
+import { auditLog } from '@cspeach/sap-client';
+import { registerTool } from '../index.js';
+import fsp from 'node:fs/promises';
+import nodePath from 'node:path';
+import { planPinRoots } from '../../projects/plan-lane.js';
+import { getActivePlanPath } from '../../commands/plan-gate.js';
+import { cardLine } from '../../lane/card.js';
+import { readSkeletonDecision } from '../../rap/skeleton-store.js';
+import { verifyAndSpendApprovalId } from '../../approvals/jwt.js';
+import { grantClaimMismatch } from '../../approvals/grant-claims.js';
+import { checkTransportFit } from '../transport-fit-check.js';
+import { appendPending, finalizeToolCall } from '../../session/pending.js';
+import { noteWriteTransport } from '../../repl/current-transport.js';
+import { askConfirm } from '../../ui/confirm-request.js';
+import { cardSlotEmitter } from '../../ui/card-slot.js';
+import { isHeadless } from '../../renderer/tty.js';
+const TS_FIELDS = [/:\s*abp_locinst_lastchange_tstmpl\b/i, /:\s*abp_lastchange_tstmpl\b/i];
+const REPLAN = 'Run /abap-plan again.';
+/** Fix round 1 (M3): said on every pre-write stop after the approvals were checked. */
+const SPENT = 'Your approvals for this run were used; you will be asked again.';
+const spent = (next) => `${next} ${SPENT}`;
+const NEXT_BY_CHOICE = {
+    'delete-retry': 'Delete them with sap_delete_object in this order (each asks for approval), then call sap_generate_objects again.',
+    'delete-switch': 'Delete them in this order, then re-run /abap-plan and choose the CSPeach writer on the skeleton card.',
+    stop: 'Stopped. Nothing else was changed.',
+};
+const code = (t) => String(t ?? '').toUpperCase().split('/')[0].trim();
+const up = (s) => String(s ?? '').trim().toUpperCase();
+const label = (o) => `${code(o.type)} ${o.name}`;
+const sameObj = (a, b) => code(a.type) === code(b.type) && up(a.name) === up(b.name);
+/** Spec §5: binding → service definition → DDLX → projection BDEF/view → behavior pool → root BDEF/view → draft table. */
+const REVERSE_ORDER = (n) => [
+    { type: 'SRVB', name: n.serviceBinding }, { type: 'SRVD', name: n.serviceDefinition },
+    { type: 'DDLX', name: n.projection }, { type: 'BDEF', name: n.projection }, { type: 'DDLS', name: n.projection },
+    { type: 'CLAS', name: n.behaviorPool }, { type: 'BDEF', name: n.root }, { type: 'DDLS', name: n.root },
+    { type: 'TABL', name: n.draftTable },
+];
+function failureCardRequest(created, why) {
+    return {
+        id: 'rap-generate-failed',
+        tag: 'SAFETY CHECK',
+        title: "SAP's generator did not finish",
+        facts: [cardLine(why), ...(created.length
+                ? [cardLine('These objects now exist:'), ...created.map((o) => cardLine(label(o)))]
+                : [cardLine('No objects were created.')]),
+            cardLine('They are new, so there is nothing to restore if they are deleted.')],
+        choices: [
+            { value: 'delete-retry', label: cardLine('Delete them and try again') },
+            { value: 'delete-switch', label: cardLine('Delete them and build with the CSPeach writer instead') },
+            { value: 'stop', label: cardLine('Leave them and stop') },
+        ],
+        initial: 2,
+    };
+}
+function defaultHeadless() {
+    return isHeadless() || cardSlotEmitter.listenerCount('confirm') === 0;
+}
+const errorResult = (error, message, next, extras = {}) => ({
+    content: JSON.stringify({ error, message, next, ...extras }),
+    is_error: true,
+});
+/**
+ * Final review M1 — the root the decision file is read from, resolved like the
+ * plan's lane file (projects/plan-lane.ts readPlanLane): the running plan's own
+ * root first, then the lane root for cwd. The first root that HAS the file
+ * decides; with none, the last (cwd's lane root) gives the usual "missing".
+ */
+async function decisionRoot(cwd, rel) {
+    const roots = await planPinRoots(cwd, getActivePlanPath() ?? undefined);
+    const norm = rel.replace(/\\/g, '/');
+    for (const root of roots.slice(0, -1)) {
+        if (await fsp.stat(nodePath.join(root, norm)).then(() => true, () => false))
+            return root;
+    }
+    return roots[roots.length - 1];
+}
+const errText = (e) => (e instanceof Error ? e.message : String(e)).slice(0, 300);
+export async function sapGenerateObjectsHandler(args, ctx, deps = {}) {
+    // ── 1. Decision file ──────────────────────────────────────────────────────
+    let rec;
+    {
+        let read;
+        try {
+            read = await readSkeletonDecision(await decisionRoot(ctx.cwd, String(args?.decisionPath ?? '')), String(args?.decisionPath ?? ''), String(args?.decisionSha256 ?? ''));
+        }
+        catch {
+            read = { ok: false, message: 'The skeleton decision file could not be read. Run /abap-plan again.' };
+        }
+        if (!read.ok)
+            return errorResult('decision_invalid', read.message, REPLAN);
+        rec = read.rec;
+    }
+    if (rec.decision?.by !== 'sap-generator' || !rec.content || !Array.isArray(rec.objects) || rec.objects.length === 0) {
+        return errorResult('not_generator_path', "This skeleton is built by the CSPeach writer, not SAP's generator.", 'Build the skeleton with the normal create tools, as the plan says.');
+    }
+    const effective = up(args?.transport) || up(ctx.currentTransport?.get()) || '';
+    // ── 2. Approvals: one per planned object, same order ─────────────────────
+    const ids = Array.isArray(args?.approval_ids) ? args.approval_ids.map((x) => String(x ?? '')) : [];
+    if (ids.length !== rec.objects.length) {
+        return errorResult('approval_invalid', `${rec.objects.length} approvals are needed, one for each planned object. ${ids.length} were given.`, 'Request one create approval per planned object, in the plan order, then call this again.');
+    }
+    // One pass in order; stops at the first failure. A partly spent set is fine:
+    // no SAP write has happened and the run stops.
+    const payloads = [];
+    for (let i = 0; i < ids.length; i++) {
+        const o = rec.objects[i];
+        const v = await verifyAndSpendApprovalId(ids[i], o.name, 'create');
+        if (!v.ok) {
+            // Final review M6 — ids before this one were spent: ask for the whole set again, never just one.
+            return errorResult('approval_invalid', `The approval for ${label(o)} is not valid.`, spent('Request one create approval per planned object, in the plan order, then call this again.'), { reason: v.reason, object: label(o) });
+        }
+        payloads.push(v.payload);
+    }
+    for (let i = 0; i < payloads.length; i++) {
+        const o = rec.objects[i];
+        const claim = grantClaimMismatch(payloads[i], { type: o.type, package: rec.package, transport: effective || null });
+        if (claim) {
+            return errorResult('approval_invalid', `The approval for ${label(o)} does not match this write.`, spent("Request one create approval per planned object on the plan's transport, in the plan order, then call this again."), { reason: claim, object: label(o) });
+        }
+    }
+    // ── 3. Transport ──────────────────────────────────────────────────────────
+    if (!effective) {
+        return errorResult('transport_missing', 'No transport is set for this write.', spent('Pass the plan\'s transport, or set one with /transport, then call this again.'));
+    }
+    const fit = await checkTransportFit(ctx.adt, { type: 'DDLS', name: rec.names.root, pkg: rec.package, transport: effective });
+    if (!fit.ok)
+        return { content: JSON.stringify({ ...fit.refusal, next: SPENT }), is_error: true };
+    // ── 4–7. SAP reads before the write. A read that throws stops cleanly. ────
+    const tableUri = `/sap/bc/adt/ddic/tables/${rec.table.toLowerCase()}`;
+    let entry;
+    try {
+        // 4. Table is ready.
+        let src = null;
+        try {
+            src = await ctx.adt.getSource('TABL', rec.table);
+        }
+        catch (e) {
+            if (e?.httpStatus !== 404)
+                throw e;
+        }
+        if (src === null || !TS_FIELDS.every((re) => re.test(src))) {
+            return errorResult('table_not_ready', src === null
+                ? `Table ${rec.table} does not exist, so SAP's generator cannot run. Re-run /abap-plan: CSPeach will choose its own writer.`
+                : `Table ${rec.table} lacks the fields SAP's generator needs. Re-run /abap-plan: CSPeach will choose its own writer.`, spent('Re-run /abap-plan.'));
+        }
+        // 5. Generator entry.
+        const found = (await ctx.adt.listGenerators(tableUri)).find((g) => g.id === 'uiservice');
+        if (!found) {
+            return errorResult('generator_not_offered', `SAP's generator isn't offered for table ${rec.table}.`, spent('Re-run /abap-plan: CSPeach will choose its own writer.'));
+        }
+        entry = found;
+        // 6. Validate again (Review Focus 2) — before preview: preview does not check names.
+        const v = await ctx.adt.validateGenerator(entry, rec.content);
+        if (!v.ok) {
+            return errorResult('name_clash', `SAP's generator refused the planned names: ${cardLine(v.text || v.severity || 'no reason given')}`, spent('Choose new names: re-run /abap-plan. The object list changes, so you will approve it again.'));
+        }
+        // 7. Preview again (Review Focus 1).
+        const preview = (await ctx.adt.previewGenerator(entry, rec.content)).map((p) => ({ type: p.type, name: p.name }));
+        const missing = rec.objects.filter((o) => !preview.some((p) => sameObj(p, o)));
+        const extra = preview.filter((p) => !rec.objects.some((o) => sameObj(p, o)));
+        if (missing.length || extra.length) {
+            const parts = [
+                ...(missing.length ? [`Planned but not in SAP's preview: ${missing.map(label).join(', ')}.`] : []),
+                ...(extra.length ? [`In SAP's preview but not planned: ${extra.map(label).join(', ')}.`] : []),
+            ];
+            return errorResult('preview_differs', `SAP's generator would not build what the plan lists. ${parts.join(' ')}`, spent('Re-run /abap-plan. The object list changes, so you will approve it again.'), { missing: missing.map((o) => ({ type: code(o.type), name: o.name })), extra: extra.map((o) => ({ type: code(o.type), name: o.name })) });
+        }
+    }
+    catch (e) {
+        return errorResult('sap_read_failed', `Could not read from SAP before generating: ${cardLine(errText(e))}. Nothing was changed.`, spent('Check the connection to SAP, then call this again.'));
+    }
+    // ── 8. Write-ahead entry ──────────────────────────────────────────────────
+    const toolUseId = ctx.toolUseId ?? crypto.randomUUID();
+    const startedAt = Date.now();
+    await appendPending(ctx.session, {
+        tool_use_id: toolUseId,
+        tool: 'sap_generate_objects',
+        args: { decisionPath: String(args.decisionPath), table: rec.table, package: rec.package, transport: effective },
+        started_at: new Date().toISOString(),
+    });
+    const planned = rec.objects.map((o) => ({ type: code(o.type), name: o.name }));
+    const inDeleteOrder = (created) => REVERSE_ORDER(rec.names).filter((r) => created.some((c) => sameObj(c, r)));
+    /** Card (or headless stop), finalize, error result. */
+    const failWithCard = async (error, message, created, extras = {}) => {
+        let choice = 'stop';
+        if (!(deps.headless ?? defaultHeadless)()) {
+            try {
+                const res = await (deps.confirm ?? ((r) => askConfirm(r)))(failureCardRequest(created, message));
+                if (res.value === 'delete-retry' || res.value === 'delete-switch')
+                    choice = res.value;
+            }
+            catch {
+                choice = 'stop';
+            }
+        }
+        const out = errorResult(error, message, NEXT_BY_CHOICE[choice], { created, delete_in_order: inDeleteOrder(created), choice, ...extras });
+        // Fix round 1 (M2): every stop after the pending entry leaves an error row.
+        await auditLog('generateObjects', 'GENR', rec.names.root, 'error', Date.now() - startedAt, `${error} created=${created.length} transport=${effective}`);
+        await finalizeToolCall(ctx.session, toolUseId, out.content, true, Date.now() - startedAt);
+        return out;
+    };
+    /** Which planned objects exist: exact name AND the planned type code (M4: an SRVD hit is not the SRVB). */
+    const findExisting = async () => {
+        const found = [];
+        const unchecked = [];
+        for (const o of planned) {
+            try {
+                const hits = await ctx.adt.searchObject(o.name, o.type, 5);
+                if (hits.some((h) => up(h.name) === up(o.name) && code(h.type) === o.type))
+                    found.push(o);
+            }
+            catch {
+                unchecked.push(o);
+            }
+        }
+        return { found, unchecked };
+    };
+    // ── 9. Generate. An error answer and a throw are handled the same way. ───
+    let failure = null;
+    try {
+        const run = await ctx.adt.runGenerator(entry, rec.content, effective);
+        if (!(run.status >= 200 && run.status < 300))
+            failure = run.error || `SAP answered HTTP ${run.status}.`;
+    }
+    catch (e) {
+        failure = `The request to SAP failed: ${errText(e)}`;
+    }
+    if (failure !== null) {
+        // Which planned objects now exist (exact name, same type)?
+        const { found: created, unchecked } = await findExisting();
+        const note = unchecked.length ? ` Could not check: ${unchecked.map(label).join(', ')}.` : '';
+        return failWithCard('generate_failed', `SAP's generator failed. ${cardLine(failure)}${note}`, created, unchecked.length ? { unchecked } : {});
+    }
+    // ── 10. Read back: every object exists, is active and is on the plan's transport (spec §5 step 6).
+    {
+        const { found, unchecked } = await findExisting();
+        if (unchecked.length) {
+            return failWithCard('readback_failed', `The objects were generated, but CSPeach could not check that these exist: ${unchecked.map(label).join(', ')}.`, planned);
+        }
+        const missing = planned.filter((o) => !found.some((f) => sameObj(f, o)));
+        if (missing.length) {
+            return failWithCard('missing_after_generate', `SAP's generator reported success, but these objects do not exist: ${missing.map(label).join(', ')}.`, found, { missing });
+        }
+    }
+    try {
+        const inactive = await ctx.adt.inactiveObjects();
+        const stillInactive = planned.filter((o) => inactive.some((i) => sameObj(i, o)));
+        if (stillInactive.length) {
+            return failWithCard('inactive_after_generate', `SAP's generator left these objects inactive: ${stillInactive.map(label).join(', ')}.`, planned, { inactive: stillInactive });
+        }
+        const wrong = [];
+        const capped = [];
+        for (const o of planned) {
+            const t = await ctx.adt.transportForObject(o.type, o.name);
+            const candidates = (Array.isArray(t.candidates) ? t.candidates : []).map(up);
+            if (t.capped)
+                capped.push(o);
+            else if (t.transport && up(t.transport) !== effective)
+                wrong.push({ ...o, transport: up(t.transport) });
+            // Split ownership (M1): no single owner, and the plan's request is not among the owners.
+            else if (!t.transport && candidates.length && !candidates.includes(effective))
+                wrong.push({ ...o, transport: candidates.join(', ') });
+            // Null with no candidates: in no open request; existence was proven above.
+        }
+        if (capped.length) {
+            return failWithCard('readback_failed', `The objects were generated, but CSPeach could not check the transport of: ${capped.map(label).join(', ')}.`, planned);
+        }
+        if (wrong.length) {
+            return failWithCard('wrong_transport', `These objects landed on another transport, not ${effective}: ${wrong.map((w) => `${label(w)} on ${w.transport}`).join(', ')}.`, planned, { wrong });
+        }
+    }
+    catch (e) {
+        return failWithCard('readback_failed', `The objects were generated, but CSPeach could not check them: ${cardLine(errText(e))}`, planned);
+    }
+    // ── 11. Finish up ─────────────────────────────────────────────────────────
+    await auditLog('generateObjects', 'GENR', rec.names.root, 'success', Date.now() - startedAt, `generator=uiservice objects=${planned.length} transport=${effective}`);
+    noteWriteTransport(effective);
+    const result = JSON.stringify({ generated: true, objects: planned, transport: effective, next: 'finish' });
+    await finalizeToolCall(ctx.session, toolUseId, result, false, Date.now() - startedAt);
+    return { content: result };
+}
+registerTool({
+    name: 'sap_generate_objects',
+    description: "Run SAP's RAP generator for a skeleton phase whose Plan block says sap-generator. Pass the decision path and "
+        + 'sha256 from the plan block, and one approval_id per planned object in the same order (request_approval with '
+        + 'op create for each). CSPeach validates, previews, generates, then checks every object is active and on the '
+        + 'transport. Never call it for a CSPeach-writer skeleton.',
+    isMutating: true,
+    requiresSap: true,
+    input_schema: {
+        type: 'object',
+        properties: {
+            decisionPath: { type: 'string', description: 'Skeleton decision path from the Plan block' },
+            decisionSha256: { type: 'string', description: 'Skeleton decision sha256 from the Plan block' },
+            approval_ids: {
+                type: 'array', items: { type: 'string' },
+                description: 'One create approval id per planned object, in the plan order',
+            },
+            transport: { type: 'string', description: "The plan's transport (optional: defaults to the session transport)" },
+        },
+        required: ['decisionPath', 'decisionSha256', 'approval_ids'],
+    },
+    handler: (args, ctx) => sapGenerateObjectsHandler(args, ctx),
+});

package/dist/tools/rap/skeleton-resolve.js

@@ -0,0 +1,283 @@
+// cspeach-cli/src/tools/rap/skeleton-resolve.ts
+//
+// RAP generator plan, Task 7 — `rap_skeleton_resolve`. Spec 2026-10-14 §3.2/§4:
+// the CLI picks the skeleton builder (SAP's generator or the CSPeach writer),
+// shows the skeleton card, writes the sha-pinned decision file and returns the
+// block the plan copies. The model never picks.
+//
+// Every SAP read here is best-effort: a read that throws (other than the
+// table's own 404) makes the generator fact 'unknown', so the CSPeach writer
+// is chosen (row 3). The tool never crashes on a SAP read.
+import { SapError } from '@cspeach/sap-client';
+import { isStandalone, registerTool } from '../index.js';
+import { assertNotCliHome, laneRootFor } from '../../lane/roots.js';
+import { setLatestSkeletonDecision } from '../../rap/skeleton-session.js';
+import { factsFromSystemInfo } from '../../lane/inputs.js';
+import { cardLine } from '../../lane/card.js';
+import { getSapSystemInfo } from '../../sap/system-info.js';
+import { getGeneratorFact } from '../../sap/generator-fact.js';
+import { decideSkeleton, generatorBlockers, } from '../../rap/skeleton-rules.js';
+import { buildUiserviceContent, generatorPlannedObjects, namesFitLimits, proposeNames, } from '../../rap/generator-names.js';
+import { writeSkeletonDecision } from '../../rap/skeleton-store.js';
+import { SKELETON_WHO, skeletonCardRequest } from '../../rap/skeleton-card.js';
+import { PKG_RE } from '../../projects/plan-objects.js';
+import { askConfirm } from '../../ui/confirm-request.js';
+import { cardSlotEmitter } from '../../ui/card-slot.js';
+import { isHeadless } from '../../renderer/tty.js';
+const fail = (m) => ({ content: `error: ${m}`, is_error: true });
+const NOT_CHOSEN = 'Skeleton not chosen. Nothing was saved.';
+const TABLE_RE = /^[ZY][A-Z0-9_]{1,15}$/;
+const BINDINGS = new Set(['odata-v4-ui', 'odata-v2-ui', 'odata-v4-api', 'odata-v2-api']);
+const RAP_TIER = (t) => t === 's4-2020-plus' || t === 'unknown';
+const TS_FIELDS = [/:\s*abp_locinst_lastchange_tstmpl\b/i, /:\s*abp_lastchange_tstmpl\b/i];
+function parseRequest(r) {
+    if (!r || typeof r !== 'object')
+        return null;
+    const o = r;
+    if (typeof o.entities !== 'number' || !Number.isInteger(o.entities) || o.entities < 1)
+        return null;
+    if (o.implementation !== 'managed' && o.implementation !== 'unmanaged')
+        return null;
+    if (typeof o.draft !== 'boolean' || typeof o.binding !== 'string' || !BINDINGS.has(o.binding))
+        return null;
+    return {
+        entities: o.entities, implementation: o.implementation, draft: o.draft,
+        binding: o.binding,
+    };
+}
+async function defaultTier(ctx) {
+    return { tier: factsFromSystemInfo(await getSapSystemInfo(ctx.adt, ctx.sapAlias)).tier };
+}
+function defaultHeadless() {
+    return isHeadless() || cardSlotEmitter.listenerCount('confirm') === 0;
+}
+const SUFFIXES = ['', '2', '3', '4', '5', '6', '7', '8', '9'];
+const RENAMED_NOTE = 'Some names were taken, so CSPeach picked free ones';
+const takenMessage = (name) => `${name} already exists in the system. Choose another table or app name, then run /abap-plan again.`;
+/** The name a SAP validation text says is taken, when it is one of ours. */
+function clashInValidation(text, objects) {
+    if (!/already exist/i.test(text))
+        return null;
+    const up = text.toUpperCase();
+    const hit = objects.find((o) => {
+        const at = up.indexOf(o.name);
+        if (at < 0)
+            return false;
+        const before = at === 0 ? '' : up[at - 1];
+        const after = up[at + o.name.length] ?? '';
+        return !/[A-Z0-9_]/.test(before) && !/[A-Z0-9_]/.test(after);
+    });
+    return hit ? hit.name : null;
+}
+/** First of `objects` that already exists (exact name), or null. Throws what searchObject throws. */
+async function searchClash(ctx, objects) {
+    for (const o of objects) {
+        const hits = await ctx.adt.searchObject(o.name, o.type, 5);
+        if (hits.some((h) => String(h.name).toUpperCase() === o.name))
+            return o.name;
+    }
+    return null;
+}
+/**
+ * Fills the table facts (rows 5–7) from SAP for one candidate name set and
+ * returns the name of one of OUR objects that is already taken, or null.
+ * Throws only what the caller maps to generator 'unknown'; a 404 on the table
+ * means "not created yet".
+ */
+async function probeTable(ctx, facts, names, objects9, content, cache) {
+    if (cache.src === undefined) {
+        try {
+            cache.src = await ctx.adt.getSource('TABL', names.table);
+        }
+        catch (e) {
+            if (!(e instanceof SapError && e.httpStatus === 404))
+                throw e;
+            cache.src = null;
+        }
+    }
+    if (cache.src !== null) {
+        const text = cache.src;
+        facts.tableExists = true;
+        facts.tableHasTimestamps = TS_FIELDS.every((re) => re.test(text));
+        if (!facts.tableHasTimestamps)
+            return null;
+        if (cache.ui === undefined) {
+            const list = await ctx.adt.listGenerators(`/sap/bc/adt/ddic/tables/${names.table.toLowerCase()}`);
+            cache.ui = list.find((g) => g.id === 'uiservice') ?? null;
+        }
+        facts.uiserviceOffered = !!cache.ui;
+        if (cache.ui) {
+            const v = await ctx.adt.validateGenerator(cache.ui, content);
+            // Final review I3 — a clash on one of our names is renamed, not a row-7 stop.
+            const clash = v.ok ? null : clashInValidation(v.text, objects9);
+            if (clash)
+                return clash;
+            facts.validation = { ok: v.ok, text: v.text };
+        }
+        return null;
+    }
+    // Not created yet: SAP's own validation needs the table, so check the 9 names here.
+    return searchClash(ctx, objects9);
+}
+/** The objects the CSPeach writer builds under the record's names (no draft table without draft). */
+function writerObjects(objects9, request) {
+    return request.draft ? objects9 : objects9.filter((o) => o.type !== 'TABL');
+}
+export async function rapSkeletonResolveHandler(args, ctx, deps = {}) {
+    // 1. Arguments.
+    const table = String(args?.table ?? '').trim().toUpperCase();
+    if (!TABLE_RE.test(table))
+        return fail('table must be a Z/Y table name of at most 16 characters.');
+    const pkg = String(args?.package ?? '').trim().toUpperCase();
+    if (!PKG_RE.test(pkg))
+        return fail('package must be a valid package name.');
+    const request = parseRequest(args?.request);
+    if (!request) {
+        return fail('request must be { entities, implementation: managed|unmanaged, draft, binding: odata-v4-ui|odata-v2-ui|odata-v4-api|odata-v2-api }.');
+    }
+    const description = (String(args?.description ?? '').trim() || table).slice(0, 60);
+    // 2. System facts. Final review I1 — standalone (or no SAP client): no SAP read at all.
+    const connected = !isStandalone(ctx) && !!ctx.adt;
+    const { tier } = connected
+        ? await (deps.facts ?? defaultTier)(ctx).catch(() => ({ tier: 'unknown' }))
+        : { tier: 'unknown' };
+    let generator = connected
+        ? await (deps.generatorFact ?? ((c) => getGeneratorFact(c.adt, c.sapAlias)))(ctx)
+            .catch(() => 'unknown')
+        : 'unknown';
+    // 3–4. Names, then the table facts. Final review I3 — a taken name is never
+    // handed on: each candidate set (base, base2 … base9) is checked the same way
+    // and the first free set wins. When SAP can't be searched the names stay unchecked.
+    const cache = {};
+    let chosen = null;
+    let firstTaken = null;
+    for (const suffix of SUFFIXES) {
+        const names = proposeNames(table, suffix);
+        const facts = {
+            tier, generator, tableExists: false, tableHasTimestamps: null, uiserviceOffered: null, validation: null,
+            namesFit: namesFitLimits(names), connected, localPackage: pkg.startsWith('$'),
+        };
+        const objects9 = generatorPlannedObjects(names, pkg);
+        const content = buildUiserviceContent(names, pkg, description);
+        let taken = null;
+        // Only when the generator could still be chosen.
+        if (RAP_TIER(tier) && generator === 'yes' && !generatorBlockers(request, facts)) {
+            try {
+                taken = await probeTable(ctx, facts, names, objects9, content, cache);
+            }
+            catch {
+                generator = 'unknown';
+                facts.generator = 'unknown';
+            }
+        }
+        // The CSPeach writer builds the same names: check them when it is the one deciding.
+        if (!taken && connected && RAP_TIER(tier) && generatorBlockers(request, facts)) {
+            try {
+                taken = await searchClash(ctx, writerObjects(objects9, request));
+            }
+            catch {
+                taken = null; // SAP can't be searched: the names stay unchecked (the build reports a clash).
+            }
+        }
+        if (!taken) {
+            chosen = { names, facts, objects9, content };
+            break;
+        }
+        firstTaken ??= taken;
+    }
+    if (!chosen)
+        return { content: takenMessage(firstTaken ?? table) };
+    const { names, facts, objects9, content } = chosen;
+    const renamed = names.base !== proposeNames(table).base;
+    const noted = (d) => (renamed && d.by !== null ? { ...d, reason: `${d.reason}. ${RENAMED_NOTE}` } : d);
+    // 5. Decide.
+    let decision = noted(decideSkeleton(request, facts));
+    if (decision.by === null)
+        return { content: `${decision.reason}. Nothing was saved.` };
+    const blocked = generatorBlockers(request, facts);
+    // 6. Card, or the rules when no card can be shown.
+    if ((deps.headless ?? defaultHeadless)()) {
+        ctx.chunkEmitter?.emit('info', `RAP skeleton chosen by the rules (no confirm card here): ${SKELETON_WHO[decision.by]}.`);
+    }
+    else {
+        const card = skeletonCardRequest(decision, blocked?.reason ?? null, names, objects9);
+        const res = await (deps.confirm ?? ((r) => askConfirm(r)))(card);
+        const value = res.value;
+        const offered = new Set(card.choices.map((c) => c.value));
+        if (!value || value === 'cancel' || !offered.has(value))
+            return { content: NOT_CHOSEN };
+        if (value.startsWith('switch:')) {
+            decision = noted(decideSkeleton(request, facts, value.slice('switch:'.length)));
+        }
+        else if (value !== 'confirm') {
+            return { content: NOT_CHOSEN };
+        }
+    }
+    const by = decision.by;
+    if (by === null)
+        return { content: NOT_CHOSEN };
+    // 7. The decision file.
+    const objects = by === 'sap-generator' ? objects9 : [];
+    let written;
+    try {
+        const laneRoot = await laneRootFor(ctx.cwd);
+        await assertNotCliHome(laneRoot);
+        written = await writeSkeletonDecision(laneRoot, {
+            table, package: pkg, names, request, decision, objects,
+            ...(by === 'sap-generator' ? { content } : {}),
+        });
+    }
+    catch (e) {
+        return fail(`the skeleton decision could not be saved: ${cardLine(e instanceof Error ? e.message : 'write failed')}`);
+    }
+    // Task 8 fix round 1 — the plan save accepts only this, the newest decision.
+    if (ctx.session)
+        setLatestSkeletonDecision(ctx.session, written);
+    // 8. The result.
+    const block = { skeleton: { by, decision: { path: written.path, sha256: written.sha256 } }, plannedObjects: objects };
+    return {
+        content: [
+            `Skeleton: ${SKELETON_WHO[by]} — ${cardLine(decision.reason)}`,
+            `Decision file: ${written.path}`,
+            `Plan block: ${JSON.stringify(block)}`,
+            // Final review I3 — the writer builds the record's names (checked free, renamed when taken).
+            ...(by === 'cspeach'
+                ? [`Names: ${[names.root, names.projection, names.behaviorPool, ...(request.draft ? [names.draftTable] : []), names.serviceBinding].join(', ')} `
+                        + '(service definition and binding). Use exactly these names for the skeleton objects.']
+                : []),
+            "Copy the plan block into the skeleton phase's work exactly as given. Do not change it.",
+        ].join('\n'),
+    };
+}
+registerTool({
+    name: 'rap_skeleton_resolve',
+    description: "RAP apps only, at plan time. Decides how the RAP skeleton is built: SAP's generator or the CSPeach writer. "
+        + 'Pass the persistence table name (it may not exist yet), the package, a short description and the request '
+        + '{ entities (number of entities incl. children), implementation managed|unmanaged, draft, binding '
+        + 'odata-v4-ui|odata-v2-ui|odata-v4-api|odata-v2-api }. CSPeach checks the system and the table, shows the '
+        + "skeleton card, saves the decision and returns a Plan block. Copy that block into the skeleton phase's "
+        + 'work exactly. Never choose the builder yourself.',
+    isMutating: false,
+    // Final review I1 — usable standalone: no SAP reads, the CSPeach writer ("Not connected to SAP").
+    requiresSap: false,
+    input_schema: {
+        type: 'object',
+        properties: {
+            table: { type: 'string', description: 'Persistence table name (Z/Y, at most 16 characters)' },
+            package: { type: 'string', description: 'Target package' },
+            description: { type: 'string', description: 'Short business description, e.g. "Equipment downtime log"' },
+            request: {
+                type: 'object',
+                properties: {
+                    entities: { type: 'integer', minimum: 1 },
+                    implementation: { type: 'string', enum: ['managed', 'unmanaged'] },
+                    draft: { type: 'boolean' },
+                    binding: { type: 'string', enum: ['odata-v4-ui', 'odata-v2-ui', 'odata-v4-api', 'odata-v2-api'] },
+                },
+                required: ['entities', 'implementation', 'draft', 'binding'],
+            },
+        },
+        required: ['table', 'package', 'description', 'request'],
+    },
+    handler: (args, ctx) => rapSkeletonResolveHandler(args, ctx),
+});

package/dist/tools/tool-loading.js

@@ -70,7 +70,13 @@ export const SKILL_STARTERS = Object.freeze({
     'abap-eml': ['sap_run_unit_test'],
     'abap-test': ['sap_run_unit_test', 'sap_set_class_include'],
     'abap-extend-model': ['extend_model_insert', 'sap_snapshot_take', 'sap_service_binding_publish', 'sap_set_class_include'],
-    'abap-rap': ['sap_set_class_include', 'sap_service_binding_publish', 'sap_class_includes'],
+    // RAP generator (2026-10-14): SAP's generator writes the stack; the finish check proves F1–F5.
+    // Final review M5 — standalone /abap-rap calls rap_skeleton_resolve before it builds.
+    'abap-rap': ['sap_set_class_include', 'sap_service_binding_publish', 'sap_class_includes', 'rap_skeleton_resolve', 'sap_generate_objects', 'rap_finish_check'],
+    // Plan steps load tools by the PLAN skill (session.tool_set_skill / params.skill), not the
+    // delegate (which only rides as the X-CSPeach-Delegate-Skill header), so the RAP
+    // skeleton + finish phases need the generator and the finish check here too.
+    'abap-plan': ['rap_skeleton_resolve', 'sap_generate_objects', 'rap_finish_check'],
     'abap-modernize': ['sap_api_state', 'sap_snapshot_take', 'sap_service_binding_publish', 'sap_atc_run', 'sap_transport_create'],
     'abap-segw': ['sap_snapshot_take', 'sap_odata_test'],
     'abap-upgrade-fix': ['sap_snapshot_take', 'glob'],

package/dist/tools/write-mode.js

@@ -21,6 +21,8 @@ export const WRITE_TOOLS = new Set([
     'sap_service_binding_publish',
     'sap_service_binding_unpublish',
     'sap_transport_release',
+    // Final review I2 — SAP's RAP generator creates the skeleton objects.
+    'sap_generate_objects',
 ]);
 export function isWriteTool(name) {
     return WRITE_TOOLS.has(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.35",
+  "version": "1.1.36",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, signed skills, safety gates.",
   "keywords": [
     "abap",
@@ -54,7 +54,7 @@
     "@anthropic-ai/sdk": "^0.90.0",
     "@azure/msal-node": "6.0.1",
     "@cspeach/register-core": "0.4.0",
-    "@cspeach/sap-client": "0.1.20",
+    "@cspeach/sap-client": "0.1.21",
     "@iarna/toml": "^2.2.5",
     "@inkjs/ui": "^2.0.0",
     "@inquirer/prompts": "^7.0.0",