@cspeach/cli 1.1.41 → 1.1.42

package/.cspeach/project.json

@@ -0,0 +1,4 @@
+{
+  "id": "1a6ac3e6",
+  "createdAt": "2026-10-16T13:54:35.800Z"
+}

package/dist/approvals/op-labels.js

@@ -1,3 +1,5 @@
+import { typeCode } from './risk-floor.js';
+import { sanitizeControlChars } from '../renderer/sanitize.js';
 /**
  * Human-readable operation + object labels for the approval surfaces.
  *
@@ -36,7 +38,8 @@ const TYPE_WORDS = {
     TTYP: 'table type',
     MSAG: 'message class',
     DEVC: 'package',
-    ENHO: 'enhancement',
+    ENHO: 'BAdI implementation',
+    ENHS: 'BAdI enhancement spot',
     XSLT: 'transformation',
     SHLP: 'search help',
 };
@@ -49,6 +52,11 @@ export function humanType(type) {
     const key = type.trim().toUpperCase();
     if (TYPE_WORDS[key])
         return TYPE_WORDS[key];
+    // Part 2b D7 — the BAdI types read the same with a subtype ('ENHO/XHB').
+    // Every other type keeps today's label.
+    const code = typeCode(type);
+    if (code === 'ENHO' || code === 'ENHS')
+        return TYPE_WORDS[code];
     // Already a word (has a lowercase letter or a space)? use it verbatim.
     if (/[a-z ]/.test(type))
         return type;
@@ -60,6 +68,15 @@ export function verbLine(change) {
         .filter(Boolean)
         .join(' ');
 }
+/**
+ * Part 2b D7 — "Affects: <process>" for a change that names the standard SAP
+ * process it runs in (a BAdI implementation); null when it names none. The
+ * text comes from the model: control characters are removed.
+ */
+export function affectsLine(change) {
+    const t = sanitizeControlChars(String(change.affects ?? '')).trim();
+    return t ? `Affects: ${t}` : null;
+}
 /**
  * The transport to DISPLAY on the approval surface for one change — mirrors
  * how the write tools actually resolve it (traced in sap-write.ts, 2026-07-05

package/dist/approvals/render.js

@@ -1,7 +1,7 @@
 import { select, input } from '@inquirer/prompts';
 import chalk from 'chalk';
 import { riskReasonText, shownRiskReasons } from './risk-floor.js';
-import { verbLine, viewAffordance, toSourceLines } from './op-labels.js';
+import { verbLine, viewAffordance, toSourceLines, affectsLine } from './op-labels.js';
 import { shouldUseInk } from '../renderer/tty.js';
 import { approvalEmitter } from '../ui/approval-emitter.js';
 import { withInquirer } from '../repl/inquirer-guard.js';
@@ -114,15 +114,29 @@ export async function renderPlanGate(summary, changes, transport, effectiveRisk,
         if (shownReasons.length > 0) {
             facts.push(`Risk raised to ${effectiveRisk.level}: ${shownReasons.map(riskReasonText).join('; ')}`);
         }
-        const steps = visibleChanges.map((c, i) => `${i + 1}. ${verbLine(c)}`);
-        if (steps.length > MAX_STEPS) {
+        // Part 2b D7 — a step that names the process it runs in (a BAdI
+        // implementation) carries its "Affects:" row right under it. The card's
+        // step budget counts rows, and a step is never shown without its row.
+        // No affects anywhere: one row per step, exactly as before.
+        const steps = visibleChanges.map((c, i) => {
+            const affects = affectsLine(c);
+            return [`${i + 1}. ${verbLine(c)}`, ...(affects ? [`   ${affects}`] : [])];
+        });
+        const totalRows = steps.reduce((n, s) => n + s.length, 0);
+        if (totalRows > MAX_STEPS) {
             // Object names are model-supplied: neutralise control characters
             // before they reach scrollback (the card sanitises its own rows).
-            emitTrace(sanitizeControlChars(['Plan', ...steps.map((s) => `  ${s}`)].join('\n')));
-            facts.push(...steps.slice(0, MAX_STEPS), `${getGlyphs().more} ${steps.length - MAX_STEPS} more steps, listed above`);
+            emitTrace(sanitizeControlChars(['Plan', ...steps.flat().map((s) => `  ${s}`)].join('\n')));
+            let shown = 0;
+            let rows = 0;
+            while (shown < steps.length && (shown === 0 || rows + steps[shown].length <= MAX_STEPS)) {
+                rows += steps[shown].length;
+                shown += 1;
+            }
+            facts.push(...steps.slice(0, shown).flat(), `${getGlyphs().more} ${steps.length - shown} more steps, listed above`);
         }
         else {
-            facts.push(...steps);
+            facts.push(...steps.flat());
         }
         const res = await askConfirm({
             id: 'plan-gate',
@@ -162,6 +176,10 @@ async function classicPlanGate(summary, visibleChanges, transport, effectiveRisk
     }
     visibleChanges.forEach((c, i) => {
         console.log(`        ${chalk.dim(`${i + 1}.`)} ${verbLine(c)}`);
+        // Part 2b D7 — the process a BAdI implementation runs in, under its line.
+        const affects = affectsLine(c);
+        if (affects)
+            console.log(`           ${chalk.dim(affects)}`);
     });
     console.log('');
     const choice = await withInquirer(() => select({
@@ -193,8 +211,10 @@ export async function renderPerChangeApproval(change, effectiveRisk, transport)
     if (aff)
         choices.push({ value: 'diff', name: aff.label });
     choices.push({ value: 'skip', name: 'Skip (tell model why)' }, { value: 'cancel', name: 'Cancel turn' });
+    // Part 2b D7 — the process a BAdI implementation runs in, under the verb line.
+    const affects = affectsLine(change);
     const choice = await withInquirer(() => select({
-        message: `${objLabel} — apply?`,
+        message: `${objLabel} — apply?${affects ? `\n  ${chalk.dim(affects)}` : ''}`,
         default: 'apply',
         theme: inquirerTheme,
         choices,

package/dist/approvals/risk-floor.js

@@ -1,3 +1,11 @@
+/**
+ * Part 2b D7 — the type code of a change or id: trimmed, upper case, without a
+ * `/subtype` ('enho/xhb' → 'ENHO'). The ENHO risk floor, the affects_required
+ * refusal and the write tool's type binding all use it, so they always agree.
+ */
+export function typeCode(type) {
+    return String(type ?? '').trim().toUpperCase().split('/')[0].trim();
+}
 export function effectiveRisk(declared, changes, ctx) {
     let floor = declared;
     const raisedBy = [];
@@ -28,6 +36,13 @@ export function effectiveRisk(declared, changes, ctx) {
                 raisedBy.push('syntax_errors');
         }
     }
+    // Part 2b D7 — a BAdI implementation runs inside a standard SAP process:
+    // high (never auto-approved), and the reason is always shown.
+    if (changes.some((c) => typeCode(c.type) === 'ENHO')) {
+        raise('high', 'standard_process');
+        if (!raisedBy.includes('standard_process'))
+            raisedBy.push('standard_process');
+    }
     if (changes.some((c) => c.op === 'delete'))
         raise('medium', 'delete_op');
     // Round 4 item 8a — these were both labelled 'shared_transport', so a plan
@@ -58,6 +73,7 @@ const RISK_REASON_TEXT = {
     escalated_in_session: 'more than 5 changes in one plan',
     prod_namespace: 'the object is in a production namespace',
     syntax_errors: 'the last syntax check of this object found errors',
+    standard_process: 'this code runs inside a standard SAP process (a BAdI implementation)',
 };
 /** Round 8 item 4 — every code the floor can raise (each has plain words above). */
 export const RISK_REASON_CODES = Object.keys(RISK_REASON_TEXT);

package/dist/renderer/tool-labels.js

@@ -167,6 +167,9 @@ const RULES = {
     rules_propose: () => ({ verb: 'Check a proposed decision rule', object: 'nothing is saved' }),
     team_estate: (a) => ({ verb: 'Read estate inventory', object: str(a['packages']) ?? 'all packages' }),
     sap_badi_list: (a) => ({ verb: 'Searched BAdIs', object: shortRight(`"${str(a['query']) ?? ''}"`) }),
+    sap_badi_read: (a) => ({ verb: 'Read BAdI', object: shortRight([str(a['kind']), str(a['name'])].filter(Boolean).join(' ')) }),
+    sap_enhancement_options: (a) => ({ verb: 'Read enhancement options', object: shortRight([str(a['type']), str(a['name'])].filter(Boolean).join(' ')) }),
+    sap_create_badi_implementation: sapObject('Created BAdI implementation'),
     sap_snapshot_list: (a) => ({ verb: 'Listed snapshots', object: shortRight(str(a['name']) ?? '') }),
     sap_snapshot_read: sapObject('Read snapshot'),
     sap_snapshot_cleanup: () => ({ verb: 'Cleaned snapshots', object: '' }),
@@ -265,7 +268,7 @@ const PRESENT = {
     'Read snapshot': 'Reading snapshot of', 'Cleaned snapshots': 'Cleaning snapshots',
     'Created transport': 'Creating transport', 'Transport for': 'Finding transport for',
     'Listed transports': 'Listing transports', Released: 'Releasing', 'Created domain': 'Creating domain',
-    'Created data element': 'Creating data element', Locked: 'Locking', Unlocked: 'Unlocking',
+    'Created data element': 'Creating data element', 'Read BAdI': 'Reading BAdI', 'Read enhancement options': 'Reading enhancement options of', 'Created BAdI implementation': 'Creating BAdI implementation', Locked: 'Locking', Unlocked: 'Unlocking',
     Published: 'Publishing', Unpublished: 'Unpublishing', Messages: 'Maintaining messages in',
     'Number range': 'Maintaining number range', Question: 'Asking', 'Updated todos': 'Updating todos',
     'Ran skill': 'Running skill', 'Read document': 'Reading document', Fetched: 'Fetching',

package/dist/sap/profile-features.js

@@ -26,6 +26,10 @@ export const FEATURES = Object.freeze({
     'datapreview.freestyle': { label: 'SQL data preview', collection: `${A}/datapreview/freestyle`, provenOnOurBox: true },
     'msag': { label: 'Message classes', collection: `${A}/messageclass`, provenOnOurBox: true },
     'nrob': { label: 'Number range objects', collection: `${A}/numberranges/objects`, provenOnOurBox: true },
+    // Part 2b: no `since`. The gap table's "enhancement editor 1809, BAdI editor
+    // 2020" has no cited source (Part 1 I1 rule): listed = yes, else unknown.
+    'enh.badiImplementations': { label: 'BAdI implementations', collection: `${A}/enhancements/enhoxhb`, provenOnOurBox: true },
+    'enh.badiSpots': { label: 'BAdI enhancement spots', collection: `${A}/enhancements/enhsxsb`, provenOnOurBox: true },
 });
 export const FEATURE_IDS = Object.freeze(Object.keys(FEATURES));
 export function isFeatureId(s) {
@@ -37,6 +41,7 @@ export const OBJECT_TYPE_FEATURE = Object.freeze({
     DDLS: 'cds.ddls', CDS: 'cds.ddls', DDLX: 'cds.ddlx', DCLS: 'cds.dcls',
     TABL: 'ddic.tables', STRU: 'ddic.structures', DOMA: 'ddic.domains', DTEL: 'ddic.dataelements',
     MSAG: 'msag', NROB: 'nrob',
+    ENHO: 'enh.badiImplementations', ENHS: 'enh.badiSpots',
 });
 /** The RAP/CDS subset: the only types a READ is ever refused for (R6). */
 export const READ_GATED_TYPES = new Set(['BDEF', 'SRVD', 'SRVB', 'DDLS', 'CDS', 'DDLX', 'DCLS']);

package/dist/tools/approval.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { registerTool } from './index.js';
 import { isHeadless, shouldUseInk } from '../renderer/tty.js';
-import { effectiveRisk, riskReasonText } from '../approvals/risk-floor.js';
+import { effectiveRisk, riskReasonText, typeCode } from '../approvals/risk-floor.js';
 import { objectsWithSyntaxErrors } from './syntax-state.js';
 import { noteWriteTransport } from '../repl/current-transport.js';
 /**
@@ -140,6 +140,7 @@ registerTool({
                         type: { type: 'string' },
                         diff: { type: 'string', description: 'For a CREATE op this MUST be the exact, complete source that will be written — verbatim, character-for-character, NOT a description, summary, or paraphrase. It is shown to the developer in the approval box as the exact thing they are approving, so a one-line summary here means they approve a write they cannot inspect. For a MODIFY op, the real unified diff of the change (again verbatim, not a description).' },
                         package: { type: 'string', description: 'Target package (development class) for the object, if known — shown on the approval box' },
+                        affects: { type: 'string', description: 'The standard SAP process this change runs inside, in plain words — REQUIRED for type ENHO (a BAdI implementation): name the BAdI, its spot and what calls it, e.g. "purchase order check before save (BAdI ME_PROCESS_PO_CUST, spot ES_MM_PO)". Shown on the approval card.' },
                     },
                     required: ['op', 'object', 'type'],
                 },
@@ -196,6 +197,12 @@ registerTool({
                 };
             }
         }
+        // Part 2b D7 — an enhancement change never reaches a card without naming the process it runs in.
+        const unnamed = (args.changes ?? []).filter((c) => typeCode(c.type) === 'ENHO' && !String(c.affects ?? '').trim());
+        if (unnamed.length > 0) {
+            return { content: JSON.stringify({ error: 'affects_required', approved: false, changes: unnamed.map((c) => c.object),
+                    message: 'A BAdI implementation changes a standard SAP process. Say which one in changes[].affects (the BAdI, its spot and what calls it), then ask again.' }), is_error: true };
+        }
         let cfg = await loadConfig();
         // Task 2 (ux-wave1) — the approval flow reads the EFFECTIVE write mode:
         // config overlaid by the session override, clamped to the active alias's

package/dist/tools/sap-read.js

@@ -20,12 +20,15 @@
  *   runUnitTest(type, name)
  *   odataTest(servicePath, entity?, method?)
  *   badiList(query, enhancementSpot?, maxResults?)
+ *   readBadiSpot(name) / readBadiImplementation(name)   (Part 2b)
+ *   enhancementOptions(type, name)                      (Part 2b)
  */
 import { registerTool } from './index.js';
 import { byObjectTypeForRead } from '../sap/profile-gate.js';
 import { normaliseSyntaxResult, checkSyntax } from './verify.js';
 import { recordSyntaxCheck } from './syntax-state.js';
 import { spillToolResult } from './result-spill.js';
+import { SapError } from '@cspeach/sap-client';
 // -----------------------------------------------------------------------
 // Task 17 (spec D12, ruling F18) — model-facing formats.
 // -----------------------------------------------------------------------
@@ -746,7 +749,7 @@ registerTool({
 // -----------------------------------------------------------------------
 registerTool({
     name: 'sap_badi_list',
-    description: 'Search for BAdI definitions and enhancement spots by name pattern (supports * wildcard), with optional enhancement-spot drill-down.',
+    description: 'Search for BAdI definitions and enhancement spots by name pattern (supports * wildcard), with optional enhancement-spot drill-down. Classic SE19 implementations are not available through ADT.',
     isMutating: false,
     requiresSap: true,
     input_schema: {
@@ -772,3 +775,78 @@ registerTool({
         return { content: JSON.stringify(result, null, 2) };
     },
 });
+// -----------------------------------------------------------------------
+// 19. sap_badi_read (Part 2b) — one new-style spot or implementation
+// -----------------------------------------------------------------------
+const isSapNotFound = (e) => e instanceof SapError && e.httpStatus === 404;
+const notFound = (detail) => ({ content: JSON.stringify({ error: 'not_found', detail }), is_error: true });
+registerTool({
+    name: 'sap_badi_read',
+    description: 'Read one new-style BAdI enhancement spot (its BAdI definitions and their interfaces) or one BAdI implementation '
+        + '(its spot, BAdI definition and implementing class). Classic SE18/SE19 objects are not available through ADT.',
+    isMutating: false,
+    requiresSap: true,
+    input_schema: {
+        type: 'object',
+        properties: {
+            kind: { type: 'string', enum: ['spot', 'implementation'], description: 'spot = an enhancement spot; implementation = a BAdI implementation' },
+            name: { type: 'string', description: 'Name of the spot or implementation' },
+        },
+        required: ['kind', 'name'],
+    },
+    handler: async (args, ctx) => {
+        const name = String(args.name ?? '').trim().toUpperCase();
+        const spot = args.kind === 'spot';
+        try {
+            const info = spot ? await ctx.adt.readBadiSpot(args.name) : await ctx.adt.readBadiImplementation(args.name);
+            return { content: JSON.stringify(info, null, 2) };
+        }
+        catch (e) {
+            if (!isSapNotFound(e))
+                throw e;
+            return notFound(spot
+                ? `${name} is not a new-style BAdI enhancement spot. Classic BAdI definitions (SE18 without an enhancement spot) are not available through ADT.`
+                : `${name} is not a new-style BAdI implementation. A classic SE19 implementation is not available through ADT; CSPeach does not create or change those.`);
+        }
+    },
+});
+// -----------------------------------------------------------------------
+// 20. sap_enhancement_options (Part 2b) — implicit enhancement options, read only
+// -----------------------------------------------------------------------
+registerTool({
+    name: 'sap_enhancement_options',
+    description: 'List the implicit enhancement options of a program, class or function group (full name, description, mode). '
+        + 'Read only: CSPeach does not write implicit enhancements.',
+    isMutating: false,
+    requiresSap: true,
+    input_schema: {
+        type: 'object',
+        properties: {
+            type: { type: 'string', enum: ['PROG', 'CLAS', 'FUGR'], description: 'Object type: PROG, CLAS or FUGR' },
+            name: { type: 'string', description: 'Object name' },
+            max: { type: 'number', description: 'Most options to return (default 200)' },
+        },
+        required: ['type', 'name'],
+    },
+    handler: async (args, ctx) => {
+        const type = String(args.type ?? '').trim().toUpperCase();
+        const name = String(args.name ?? '').trim().toUpperCase();
+        const max = Number.isFinite(args.max) && args.max >= 1 ? Math.floor(args.max) : 200;
+        let all;
+        try {
+            all = await ctx.adt.enhancementOptions(type, args.name);
+        }
+        catch (e) {
+            if (!isSapNotFound(e))
+                throw e;
+            return notFound(`${type} ${name} does not exist.`);
+        }
+        return {
+            content: JSON.stringify({
+                object: name, type, count: all.length,
+                options: all.slice(0, max).map((o) => ({ full_name: o.fullName, description: o.description, mode: o.mode })),
+                ...(all.length > max ? { truncated: true } : {}),
+            }),
+        };
+    },
+});

package/dist/tools/sap-write.js

@@ -32,7 +32,7 @@ import { hasRecordedSyntaxErrorsByName, clearSyntaxErrorsAfterActivation } from
 import { teamFixOffers, cspeachWritesThisSession } from '../register/offer.js';
 import { appendPending, finalizeToolCall } from '../session/pending.js';
 import { checkTransportFit, reusedRequestRefusal } from './transport-fit-check.js';
-import { auditLog } from '@cspeach/sap-client';
+import { auditLog, SapError } from '@cspeach/sap-client';
 import { ERR } from '../errors/codes.js';
 import { interceptUpdateMethod, CancelledByUserError, } from './update-method-intercept.js';
 // F-L2-1: statusline-only wire — records the transport a write ACTUALLY
@@ -1253,3 +1253,161 @@ registerTool({
         };
     },
 });
+// ── sap_create_badi_implementation (Part 2b, D1/D5) ─────────────────────────
+//
+// One new-style BAdI implementation (ENHO) for a BAdI definition in an
+// enhancement spot, on the shared write pipeline. sap-client composes shell
+// POST → locked PUT → activate → read back in one call. The implementing
+// class must already exist, be ACTIVE and list the BAdI interface: SAP
+// activates an implementation even when its class is broken, and the standard
+// process that calls it would then fail (D5). Those checks run in preGate —
+// after the approval check, before the WAL and before anything changes in
+// SAP. A create approval is reusable for its object, so a refusal here never
+// uses it up (sap-badi-tools.test.ts proves it with a real id).
+/** SAP's own message in plain words: no "Object not found:" prefix, no internal method name, never a stack. */
+export function plainSapText(e) {
+    if (!(e instanceof SapError))
+        return e instanceof Error ? e.message : String(e);
+    const t = e.message
+        .replace(/^(?:Object not found|Object locked by another user|Authentication failed|CSRF rejected): /, '')
+        .replace(/^SAP HTTP \d+: /, '')
+        .replace(/^[a-z][A-Za-z]*\([^)]*\)(?:\s+—\s+)?/, '')
+        .trim();
+    return t || `SAP answered HTTP ${e.httpStatus}`;
+}
+/** The first error text of an activation, or a plain default. */
+export function firstError(a) {
+    return a?.messages?.find((m) => m.severity === 'error' && m.shortText)?.shortText ?? 'SAP did not activate it';
+}
+/**
+ * Does the class definition list the interface in an INTERFACES statement
+ * (single, or chained with a colon; case-insensitive, whole name)? Comment
+ * lines and end-of-line comments are ignored.
+ */
+export function classListsInterface(source, interfaceName) {
+    const want = interfaceName.trim().toUpperCase();
+    const code = source.split(/\r?\n/)
+        .filter((l) => !l.startsWith('*'))
+        .map((l) => l.replace(/".*$/, ''))
+        .join('\n');
+    for (const m of code.matchAll(/(?<![A-Za-z0-9_/~-])INTERFACES\s*:?\s*([^.]*)\./gi)) {
+        for (const part of m[1].split(',')) {
+            if ((part.trim().split(/\s+/)[0] ?? '').toUpperCase() === want)
+                return true;
+        }
+    }
+    return false;
+}
+const upperOf = (v) => String(v ?? '').trim().toUpperCase();
+const CREATE_BADI_IMPL_SPEC = {
+    tool: 'sap_create_badi_implementation',
+    approval: {
+        object: (a) => a.name, op: 'create',
+        // D7: only an id from the ENHO card (high risk, Affects line) writes a BAdI implementation.
+        boundType: 'ENHO',
+        claims: (a, ctx) => ({ type: 'ENHO', package: a.package, transport: a.transport ?? ctx.currentTransport?.get() ?? null }),
+    },
+    transport: { mode: 'three-tier' },
+    snapshot: { kind: 'none', reason: 'a new enhancement implementation has no prior document' },
+    // D5 — refuse before the WAL: spot readable, definition in it, class active and implementing the interface.
+    preGate: async (a, ctx) => {
+        let spot;
+        try {
+            spot = await ctx.adt.readBadiSpot(a.enhancement_spot);
+        }
+        catch (e) {
+            return { error: { error: 'spot_not_found', detail: plainSapText(e), next: 'Check the enhancement spot name with sap_badi_list. Classic BAdI definitions (SE18 without an enhancement spot) are not available through ADT.' } };
+        }
+        const def = spot.definitions.find((d) => d.name === upperOf(a.badi_definition));
+        if (!def) {
+            return { error: { error: 'badi_definition_not_in_spot', detail: `Spot ${spot.name} has no BAdI definition ${upperOf(a.badi_definition)}. It has: ${spot.definitions.map((d) => d.name).join(', ') || 'none'}.` } };
+        }
+        if (!def.interfaceName?.trim()) {
+            return { error: { error: 'badi_definition_without_interface', detail: `BAdI ${def.name} in spot ${spot.name} names no interface, so the implementing class cannot be checked. Check the BAdI definition in ADT.` } };
+        }
+        const cls = upperOf(a.implementing_class);
+        const state = await verifyActive(ctx.adt, cls, 'CLAS'); // the read-only check (inactive list by uri)
+        if (state.verifyError !== undefined)
+            return { error: { error: 'class_state_unknown', detail: state.verifyError } };
+        let source;
+        try {
+            source = await ctx.adt.getSource('CLAS', cls);
+        }
+        catch (e) {
+            const why = e instanceof SapError && e.httpStatus === 404 ? `Class ${cls} does not exist.` : `Class ${cls} could not be read: ${plainSapText(e)}.`;
+            return { error: { error: 'class_not_found', detail: `${why} Create and activate the implementing class first.` } };
+        }
+        if (!state.active) {
+            return { error: { error: 'class_not_active', detail: `Class ${cls} is not active. Activate it first; a BAdI implementation that points at an inactive class would fail inside the standard process that calls it.` } };
+        }
+        if (!classListsInterface(source, def.interfaceName)) {
+            return { error: { error: 'class_lacks_interface', detail: `Class ${cls} does not list INTERFACES ${def.interfaceName} (the interface of BAdI ${def.name}). Add it, activate the class, then try again.` } };
+        }
+        return { ok: true, extra: { interface_name: def.interfaceName } };
+    },
+    walArgs: (a) => ({ name: a.name, type: 'ENHO', package: a.package, enhancement_spot: a.enhancement_spot, badi_definition: a.badi_definition, implementing_class: a.implementing_class }),
+    call: (a, ctx, pre) => ctx.adt.createBadiImplementation({
+        name: a.name, description: a.description, packageName: a.package,
+        enhancementSpot: a.enhancement_spot, badiDefinition: a.badi_definition, implementingClass: a.implementing_class,
+    }, pre.transport),
+    errorCode: 'create_failed',
+    // SAP's own answers decide "landed"; whether it is really ACTIVE is Gate 4's
+    // (verify.activation) — one rule for every write (preflight F-05).
+    landed: (r) => (r.status === 'created' && r.written && r.activated
+        ? { ok: true }
+        : {
+            ok: false,
+            detail: r.error ?? (!r.created ? 'SAP did not create the implementation'
+                : !r.written ? 'the implementation document was not written'
+                    : `activation failed: ${firstError(r.activationResult)}`),
+            extra: {
+                created: r.created, written: r.written, activated: r.activated,
+                ...(r.activationResult?.messages?.length ? { activation_messages: r.activationResult.messages.map((m) => m.shortText) } : {}),
+            },
+            audit: { status: 'error', reason: r.error ?? 'not activated' },
+        }),
+    audit: {
+        method: 'createBadiImplementation', type: () => 'ENHO', name: (a) => a.name,
+        detail: (a) => `badi=${upperOf(a.badi_definition)} spot=${upperOf(a.enhancement_spot)} class=${upperOf(a.implementing_class)}`,
+    },
+    // verifyWriteActivation reads r.activationResult, then the inactive list by uri (ENHO row → toObjectUrl).
+    verify: { syntax: false, activation: true },
+    walResult: (_a, r) => ({ created: true, activated: r.activated }),
+    chain: (a, pre, _syntax, act) => ({
+        snapshot: 'new_object', written: true, syntax: 'not_checked', activation: chainActivation(act),
+        card: { object: upperOf(a.name), what: `BAdI implementation of ${upperOf(a.badi_definition)} (spot ${upperOf(a.enhancement_spot)})`, transport: pre.transport },
+    }),
+    envelope: (a, r, pre, _syntax, act) => ({
+        created: true, object: r.objectName, type: 'ENHO', package: r.packageName,
+        badi_definition: upperOf(a.badi_definition), enhancement_spot: upperOf(a.enhancement_spot), implementing_class: upperOf(a.implementing_class),
+        ...activatedByWrite(act), ...(pre.transport ? { transport: pre.transport } : {}),
+        next_step: act?.success && act.verified
+            ? 'the implementation is active: the standard process now calls it on this system — test it there'
+            : 'activation is not confirmed: check sap_inactive_objects and activate before reporting it active',
+    }),
+};
+registerTool({
+    name: 'sap_create_badi_implementation',
+    requires: 'enh.badiImplementations',
+    description: 'Create and activate a new-style BAdI implementation (enhancement implementation, ENHO) for a BAdI definition in an enhancement spot. '
+        + 'The implementing class must already exist, be ACTIVE and list the BAdI interface (create it with sap_create_object CLAS + sap_set_source and activate it first). '
+        + 'Requires approval_id from a request_approval whose change names type ENHO, the BAdI definition, its enhancement spot and the standard process it affects. '
+        + 'Classic SE19 implementations are not available through ADT.',
+    isMutating: true,
+    requiresSap: true,
+    input_schema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Name of the new BAdI implementation (Z*/Y*)' },
+            description: { type: 'string', description: 'Short description' },
+            package: { type: 'string', description: 'Development package (Z*/Y* or $TMP)' },
+            enhancement_spot: { type: 'string', description: 'The enhancement spot that holds the BAdI definition' },
+            badi_definition: { type: 'string', description: 'The BAdI definition to implement (inside that spot)' },
+            implementing_class: { type: 'string', description: 'The active class that implements the BAdI interface' },
+            transport: { type: 'string', description: 'Target transport (optional — required for workbench packages)' },
+            approval_id: { type: 'string', description: 'JWT from request_approval' },
+        },
+        required: ['name', 'description', 'package', 'enhancement_spot', 'badi_definition', 'implementing_class', 'approval_id'],
+    },
+    handler: writeToolHandler(CREATE_BADI_IMPL_SPEC),
+});

package/dist/tools/write-pipeline.js

@@ -27,6 +27,7 @@ import { readFileSync } from 'node:fs';
 import { auditLog, SapError } from '@cspeach/sap-client';
 import { verifyAndSpendApprovalId } from '../approvals/jwt.js';
 import { grantClaimMismatch, grantOwningTransportMismatch, grantOwningTransportDetail } from '../approvals/grant-claims.js';
+import { typeCode } from '../approvals/risk-floor.js';
 import { autoSnapshot, autoSnapshotClassInclude, autoSnapshotMessageClass } from './snapshot.js';
 import { includeSnapshotType } from './include-snapshot.js';
 import { buildWriteChainLine } from '../renderer/verify-chain.js';
@@ -297,6 +298,10 @@ export async function runWritePipeline(args, ctx, spec) {
     const verify = await verifyAndSpendApprovalId(raw.approval_id, spec.approval.object(args), spec.approval.op);
     if (!verify.ok)
         return refuse({ error: ERR.APPROVAL_INVALID, reason: verify.reason });
+    // Part 2b D7 — the id must come from a card for this exact type.
+    if (spec.approval.boundType && typeCode(verify.payload.type) !== spec.approval.boundType) {
+        return refuse({ error: ERR.APPROVAL_INVALID, reason: 'type_mismatch' });
+    }
     // 2026-10-04 — a plan-grant id holds the write to its claims (type, package, transport).
     if (spec.approval.claims) {
         const claim = grantClaimMismatch(verify.payload, spec.approval.claims(args, ctx));

package/dist/ui/approval-modal.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef, useState } from 'react';
 import { Box, Text, useInput, useStdout } from 'ink';
 import { riskReasonText, shownRiskReasons } from '../approvals/risk-floor.js';
-import { verbLine, viewAffordance, toSourceLines } from '../approvals/op-labels.js';
+import { verbLine, viewAffordance, toSourceLines, affectsLine } from '../approvals/op-labels.js';
 // BUG-1 (2026-07-05 live smoke): the interactive approval modal mounted
 // DEAD — every keypress ignored — when it appeared after a guarded
 // /abap-plan turn. Root cause is identical to the one AskCard
@@ -34,6 +34,16 @@ function riskText(effectiveRisk) {
 export function riskRows(effectiveRisk, width) {
     return wrapRows(riskText(effectiveRisk), Math.max(1, width - MODAL_CHROME_COLS), RISK_MAX_ROWS);
 }
+/**
+ * Part 2b D7 — the standard SAP process a BAdI implementation runs in is a
+ * decision input too: its "Affects:" text wraps onto up to this many rows.
+ */
+export const AFFECTS_MAX_ROWS = 2;
+/** The "Affects: …" rows under the verb line; none when the change names no process. */
+export function affectsRows(change, width) {
+    const line = affectsLine(change);
+    return line ? wrapRows(line, Math.max(1, width - MODAL_CHROME_COLS), AFFECTS_MAX_ROWS) : [];
+}
 /**
  * The collapsed card's rendered height at `width` (the live-area budget; the
  * App adds its own one-row top margin). Panels: border 2 + paddingY 2 + verb
@@ -42,7 +52,7 @@ export function riskRows(effectiveRisk, width) {
  */
 export function estimateApprovalModalRows(p, width = uiWidth()) {
     const meta = p.change.package || p.transport ? 1 : 0;
-    const body = 1 + meta + riskRows(p.effectiveRisk, width).length + 2;
+    const body = 1 + affectsRows(p.change, width).length + meta + riskRows(p.effectiveRisk, width).length + 2;
     return 4 + body + (getLook() === 'panels' ? 0 : 2);
 }
 // Legacy look: today's literal names (bytes unchanged while colour is on).
@@ -180,6 +190,8 @@ export function ApprovalModal({ change, effectiveRisk, transport, onApply, onSki
     }
     // Pre-wrapped rows, never Ink soft-wrap (Wave-1 rule): every row is counted.
     const risks = riskRows(effectiveRisk, cardWidth);
+    // Part 2b D7 — "Affects: …" under the verb line (none for other changes).
+    const affects = affectsRows(change, cardWidth);
     // Meta line: Package · Transport — each segment only when genuinely known.
     // The handler resolves `transport` per op (see op-labels displayTransport:
     // create-family may fall back to the session transport because the create
@@ -206,7 +218,7 @@ export function ApprovalModal({ change, effectiveRisk, transport, onApply, onSki
     if (getLook() === 'panels') {
         const risk = roleProps(riskRole(effectiveRisk.level));
         const tag = inkChip('APPROVAL');
-        return (_jsxs(Box, { flexDirection: "column", width: cardWidth, borderStyle: "round", borderColor: risk.color, paddingX: 2, paddingY: 1, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { ...tag.props, children: tag.text }), _jsx(Text, { children: '  ' }), _jsx(Text, { ...(change.op === 'delete' ? roleProps('bad') : {}), bold: true, children: verb }), change.op === 'create' ? _jsx(Text, { ...roleProps('dim'), children: "  (new object)" }) : null] }), metaSegs.length > 0 && _jsx(Text, { ...roleProps('dim'), wrap: "truncate-end", children: metaSegs.join(' · ') }), risks.map((row, i) => _jsx(Text, { ...risk, wrap: "truncate-end", children: row }, `risk-${i}`)), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { ...roleProps('sap', { bold: true }), children: keys[0] }), _jsx(Text, { children: '   ' + keys.slice(1).join('   ') })] }) })] }));
+        return (_jsxs(Box, { flexDirection: "column", width: cardWidth, borderStyle: "round", borderColor: risk.color, paddingX: 2, paddingY: 1, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { ...tag.props, children: tag.text }), _jsx(Text, { children: '  ' }), _jsx(Text, { ...(change.op === 'delete' ? roleProps('bad') : {}), bold: true, children: verb }), change.op === 'create' ? _jsx(Text, { ...roleProps('dim'), children: "  (new object)" }) : null] }), affects.map((row, i) => _jsx(Text, { ...roleProps('dim'), wrap: "truncate-end", children: row }, `affects-${i}`)), metaSegs.length > 0 && _jsx(Text, { ...roleProps('dim'), wrap: "truncate-end", children: metaSegs.join(' · ') }), risks.map((row, i) => _jsx(Text, { ...risk, wrap: "truncate-end", children: row }, `risk-${i}`)), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { ...roleProps('sap', { bold: true }), children: keys[0] }), _jsx(Text, { children: '   ' + keys.slice(1).join('   ') })] }) })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", width: cardWidth, borderStyle: "round", borderColor: legacyInkColor(riskColor(effectiveRisk.level)), paddingX: 2, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Write approval" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: verbColor, children: verb }), change.op === 'create' ? _jsx(Text, { dimColor: true, children: "  (new object)" }) : null] }) }), metaSegs.length > 0 && (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: metaSegs.join(' · ') })), risks.map((row, i) => (_jsx(Text, { color: legacyInkColor(riskColor(effectiveRisk.level)), wrap: "truncate-end", children: row }, `risk-${i}`))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { wrap: "truncate-end", children: keys.join('   ') }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", width: cardWidth, borderStyle: "round", borderColor: legacyInkColor(riskColor(effectiveRisk.level)), paddingX: 2, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Write approval" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: verbColor, children: verb }), change.op === 'create' ? _jsx(Text, { dimColor: true, children: "  (new object)" }) : null] }) }), affects.map((row, i) => (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: row }, `affects-${i}`))), metaSegs.length > 0 && (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: metaSegs.join(' · ') })), risks.map((row, i) => (_jsx(Text, { color: legacyInkColor(riskColor(effectiveRisk.level)), wrap: "truncate-end", children: row }, `risk-${i}`))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { wrap: "truncate-end", children: keys.join('   ') }) })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.41",
+  "version": "1.1.42",
   "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.26",
+    "@cspeach/sap-client": "0.1.27",
     "@iarna/toml": "^2.2.5",
     "@inkjs/ui": "^2.0.0",
     "@inquirer/prompts": "^7.0.0",