@cspeach/cli 1.1.44 → 1.1.45

package/.cspeach/project.json

@@ -0,0 +1,4 @@
+{
+  "id": "8c2d43d9",
+  "createdAt": "2026-10-17T17:11:58.030Z"
+}

package/dist/agent/parallel-write-guard.js

@@ -33,6 +33,8 @@ export const WRITE_CLASS_TOOLS = new Set([
     'sap_create_object',
     // Final review I2 — SAP's RAP generator creates up to 9 objects in one call.
     'sap_generate_objects',
+    // Part 3 — a run executes code; it never runs beside a write in the same round.
+    'sap_run',
 ]);
 export function isWriteClassTool(name) {
     return WRITE_CLASS_TOOLS.has(name);

package/dist/approvals/jwt.js

@@ -15,6 +15,8 @@ const usedNonces = new Set();
  *   - approving `modify` covers modify → activate (write then activate).
  *   - `delete` / `release` stay single-op (and single-use) — one-shot ops the
  *     user must approve explicitly each time.
+ *   - `run` (Part 3 D2) is single-op and single-use too: one approval runs a
+ *     class or program once.
  *
  * This removes the op_mismatch APPROVAL_INVALID storm (create approval used,
  * then set_source rejected because it's a different op) without weakening the
@@ -26,11 +28,12 @@ const OP_COVERAGE = {
     delete: new Set(['delete']),
     activate: new Set(['activate']),
     release: new Set(['release']),
+    run: new Set(['run']),
 };
 /** create/modify approvals are reusable across their object's lifecycle ops
- *  until TTL; delete/release are genuinely one-shot. */
+ *  until TTL; delete/release/run are genuinely one-shot. */
 function isOneShotOp(op) {
-    return op === 'delete' || op === 'release';
+    return op === 'delete' || op === 'release' || op === 'run';
 }
 export async function mintApprovalId(payload) {
     const nonce = crypto.randomBytes(16).toString('hex');

package/dist/approvals/op-labels.js

@@ -14,6 +14,7 @@ const VERBS = {
     delete: 'Delete',
     activate: 'Activate',
     release: 'Release',
+    run: 'Run',
 };
 /**
  * SAP ADT type codes → plain words. The `type` field is free text supplied by
@@ -45,6 +46,8 @@ const TYPE_WORDS = {
     FUNC: 'function module',
     FINC: 'function group include',
     INCL: 'include',
+    // Part 3 (T1 ruling): the release and the create card both read "transport request".
+    CTS: 'transport request',
 };
 export function humanVerb(op) {
     return VERBS[op] ?? op.charAt(0).toUpperCase() + op.slice(1);
@@ -86,6 +89,38 @@ export function affectsLine(change) {
     const t = sanitizeControlChars(String(change.affects ?? '')).trim();
     return t ? `Affects: ${t}` : null;
 }
+/** Part 3 D12 — the longest request description a release card shows. */
+const RELEASE_DESCRIPTION_MAX = 60;
+const RELEASE_LAST_LINE = 'Cannot be undone. Once released, the request can move to the other systems on the transport route.';
+/** Part 3 D13 — the card a person decides on says what CSPeach checks and where to check it after the release (owner wording 2026-10-17). */
+export const RELEASE_CHECK_LINE = 'CSPeach reads SAP\'s verdict after each step and checks the request afterwards. Check the transport in SE09 after the release.';
+/**
+ * Part 3 D12 — the fixed lines under a release change; [] for any other change
+ * or when no facts are attached. The facts are SAP's (request_approval reads
+ * them from the request before the card is drawn); text from SAP still passes
+ * through sanitizeControlChars. A task owned by someone other than the request
+ * owner is named (preflight F-15: SAP releases it under the caller's
+ * authorization).
+ */
+export function releaseLines(change) {
+    const f = change.releaseFacts;
+    if (change.op !== 'release' || !f)
+        return [];
+    const clean = (v) => sanitizeControlChars(String(v ?? '')).trim();
+    let description = clean(f.description);
+    if (description.length > RELEASE_DESCRIPTION_MAX)
+        description = `${description.slice(0, RELEASE_DESCRIPTION_MAX)}…`;
+    const owner = clean(f.owner);
+    const tasks = Array.isArray(f.tasks) ? f.tasks : [];
+    const others = [...new Set(tasks.map((t) => clean(t.owner)).filter((o) => o && o !== owner))];
+    return [
+        `Request ${clean(f.request)} "${description}" · owner ${owner} · target ${clean(f.target) || 'none'}`,
+        `${tasks.length} ${tasks.length === 1 ? 'task' : 'tasks'}: ${tasks.map((t) => clean(t.number)).join(', ')} · ${f.objects === null || f.objects === undefined ? 'objects: could not count' : `${f.objects} ${f.objects === 1 ? 'object' : 'objects'}`}`
+            + (others.length ? ` · other owners: ${others.join(', ')}` : ''),
+        RELEASE_LAST_LINE,
+        RELEASE_CHECK_LINE,
+    ];
+}
 /**
  * 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
@@ -97,8 +132,8 @@ export function affectsLine(change) {
  *     resolveWriteTransport(args only, + owning-TR override) — NO session
  *     fallback in the actual write, so we only show a transport the request
  *     explicitly carries.
- *   - activate/release: the tools take no transport arg at all — never show
- *     a Transport segment.
+ *   - activate/release/run: the tools take no transport arg at all — never
+ *     show a Transport segment.
  * When nothing is resolvable, return undefined and the caller OMITS the
  * segment — no "new (session)" promise (a $TMP write never creates one).
  */
@@ -109,7 +144,7 @@ export function displayTransport(op, explicit, session) {
         case 'modify':
         case 'delete':
             return explicit;
-        default: // activate / release
+        default: // activate / release / run
             return undefined;
     }
 }
@@ -132,7 +167,7 @@ export function toSourceLines(content) {
  *   - modify  → [d] Show diff (there IS a before/after to diff)
  *   - create  → [v] View source, only when the new source is carried
  *   - delete  → [v] View current source, only when the source is carried
- *   - activate/release → nothing to review (no source in the payload)
+ *   - activate/release/run → nothing to review (no source in the payload)
  */
 export function viewAffordance(change) {
     switch (change.op) {

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, affectsLine } from './op-labels.js';
+import { verbLine, viewAffordance, toSourceLines, affectsLine, releaseLines } from './op-labels.js';
 import { shouldUseInk } from '../renderer/tty.js';
 import { approvalEmitter } from '../ui/approval-emitter.js';
 import { withInquirer } from '../repl/inquirer-guard.js';
@@ -118,22 +118,44 @@ export async function renderPlanGate(summary, changes, transport, effectiveRisk,
         // 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.
+        // Part 3 D12 / F-13 — a release step carries its fact lines the same way:
+        // "Apply all" mints it without its per-change card.
         const steps = visibleChanges.map((c, i) => {
             const affects = affectsLine(c);
-            return [`${i + 1}. ${verbLine(c)}`, ...(affects ? [`   ${affects}`] : [])];
+            return [`${i + 1}. ${verbLine(c)}`, ...(affects ? [`   ${affects}`] : []), ...releaseLines(c).map((l) => `   ${l}`)];
         });
-        const totalRows = steps.reduce((n, s) => n + s.length, 0);
+        // Fix round 1 (owner ruling) — a release step is ALWAYS on the card, with
+        // its fact lines, wherever it sits: its rows have their own budget and
+        // never count toward MAX_STEPS. The other steps keep today's budget, so a
+        // plan without a release renders exactly as before.
+        const isRelease = visibleChanges.map((c) => releaseLines(c).length > 0);
+        const totalRows = steps.reduce((n, s, i) => n + (isRelease[i] ? 0 : 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.flat().map((s) => `  ${s}`)].join('\n')));
+            const shownRows = [];
             let shown = 0;
+            let others = 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`);
+            let full = false;
+            steps.forEach((s, i) => {
+                if (isRelease[i]) {
+                    shownRows.push(...s);
+                    shown += 1;
+                    return;
+                }
+                if (!full && (others === 0 || rows + s.length <= MAX_STEPS)) {
+                    shownRows.push(...s);
+                    rows += s.length;
+                    others += 1;
+                    shown += 1;
+                }
+                else {
+                    full = true;
+                }
+            });
+            facts.push(...shownRows, `${getGlyphs().more} ${steps.length - shown} more steps, listed above`);
         }
         else {
             facts.push(...steps.flat());
@@ -180,6 +202,9 @@ async function classicPlanGate(summary, visibleChanges, transport, effectiveRisk
         const affects = affectsLine(c);
         if (affects)
             console.log(`           ${chalk.dim(affects)}`);
+        // Part 3 D12 / F-13 — a release row's facts, under its line.
+        for (const l of releaseLines(c))
+            console.log(`           ${chalk.dim(l)}`);
     });
     console.log('');
     const choice = await withInquirer(() => select({
@@ -213,8 +238,10 @@ export async function renderPerChangeApproval(change, effectiveRisk, transport)
     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);
+    // Part 3 D12 — a release card's facts, under the verb line.
+    const release = releaseLines(change).map((l) => `\n  ${chalk.dim(l)}`).join('');
     const choice = await withInquirer(() => select({
-        message: `${objLabel} — apply?${affects ? `\n  ${chalk.dim(affects)}` : ''}`,
+        message: `${objLabel} — apply?${affects ? `\n  ${chalk.dim(affects)}` : ''}${release}`,
         default: 'apply',
         theme: inquirerTheme,
         choices,

package/dist/approvals/risk-floor.js

@@ -48,8 +48,18 @@ export function effectiveRisk(declared, changes, ctx) {
     // Round 4 item 8a — these were both labelled 'shared_transport', so a plan
     // on a transport created seconds earlier read "raised … by shared_transport".
     // Each reason now says what actually raised it.
-    if (changes.some((c) => c.op === 'release'))
-        raise('medium', 'transport_release');
+    // Part 3 D2 — a release cannot be undone, and a run executes code on the
+    // system: both are high (never auto-approved), and the reason is always shown.
+    if (changes.some((c) => c.op === 'release')) {
+        raise('high', 'transport_release');
+        if (!raisedBy.includes('transport_release'))
+            raisedBy.push('transport_release');
+    }
+    if (changes.some((c) => c.op === 'run')) {
+        raise('high', 'code_run');
+        if (!raisedBy.includes('code_run'))
+            raisedBy.push('code_run');
+    }
     if (changes.some((c) => c.op === 'activate'))
         raise('medium', 'activation');
     if (ctx.recentAtcFailure && changes.some((c) => ctx.recentAtcFailure.includes(c.object)))
@@ -66,7 +76,7 @@ export function effectiveRisk(declared, changes, ctx) {
 const RISK_REASON_TEXT = {
     non_prod_override: 'auto-approve is set to never on this system (a setting, not a risk)',
     delete_op: 'the plan deletes an object',
-    transport_release: 'the plan releases a transport',
+    transport_release: 'the plan releases a transport; this cannot be undone',
     activation: 'activation makes the change live on the system',
     atc_failed_24h: 'ATC failed on this object in the last 24 hours',
     shared_transport: 'the transport is shared by 3 or more developers',
@@ -74,6 +84,7 @@ const RISK_REASON_TEXT = {
     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)',
+    code_run: 'this runs code on the SAP system',
 };
 /** 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/one-shot.js

@@ -44,6 +44,7 @@ import { globalCredits } from './cost/credits.js';
 import './tools/sap-read.js';
 import './tools/sap-write.js';
 import './tools/transport.js';
+import './tools/sap-run.js';
 import './tools/approval.js';
 import './tools/snapshot.js';
 import './tools/ask-question.js';

package/dist/renderer/progress-chatter.js

@@ -115,8 +115,15 @@ const MESSAGES = {
         'Finding modifiable TRs…',
     ],
     sap_transport_release: [
-        'Releasing transport for QA queue…',
-        'This is irreversible — sending now…',
+        'Releasing the open tasks, then the request…',
+        'Waiting for the release report from SAP…',
+    ],
+    sap_transport_read: [
+        'Reading the transport request…',
+    ],
+    sap_run: [
+        'Running {name} on SAP…',
+        'Waiting for the output…',
     ],
     sap_create_object: [
         'Creating {name}…',

package/dist/renderer/tool-labels.js

@@ -180,6 +180,8 @@ const RULES = {
     sap_transport_for_object: (a) => ({ verb: 'Transport for', object: shortRight(str(a['object_name']) ?? '') }),
     sap_transport_list: (a) => ({ verb: 'Listed transports', object: shortRight(str(a['owner']) ?? '') }),
     sap_transport_release: (a) => ({ verb: 'Released', object: shortRight(str(a['transport']) ?? '') }),
+    sap_transport_read: (a) => ({ verb: 'Read transport request', object: shortRight(str(a['transport']) ?? '') }),
+    sap_run: sapObject('Ran'),
     sap_create_domain: sapObject('Created domain'),
     sap_create_data_element: sapObject('Created data element'),
     sap_lock: sapObject('Locked'),
@@ -271,7 +273,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', 'Read BAdI': 'Reading BAdI', 'Read enhancement options': 'Reading enhancement options of', 'Created BAdI implementation': 'Creating BAdI implementation', 'Created table type': 'Creating table type', 'Read table type': 'Reading table type', 'Listed function group': 'Listing function group', 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', 'Created table type': 'Creating table type', 'Read table type': 'Reading table type', 'Read transport request': 'Reading transport request', 'Listed function group': 'Listing function group', 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/repl.js

@@ -152,6 +152,7 @@ import { applyLocalBuildConfig, applyStandaloneFileTools } from './tools/local-b
 import './tools/sap-read.js';
 import './tools/sap-write.js';
 import './tools/transport.js';
+import './tools/sap-run.js';
 import './tools/approval.js';
 import './tools/snapshot.js';
 import './tools/ask-question.js';

package/dist/sap/profile-features.js

@@ -35,6 +35,11 @@ export const FEATURES = Object.freeze({
     'fugr.modules': { label: 'Function modules and function-group includes', collection: `${A}/functions/groups`, provenOnOurBox: true },
     'prog.includes': { label: 'Program includes', collection: `${A}/programs/includes`, provenOnOurBox: true },
     'ddic.tabletypes': { label: 'Table types', collection: `${A}/ddic/tabletypes`, provenOnOurBox: true },
+    // Part 3 (D15): no `since` (no cited release). The collections and the reads are
+    // proven on our box; the release is not, and these rows are about the collection.
+    'run.classrun': { label: 'Run a class (console)', collection: `${A}/oo/classrun`, provenOnOurBox: true },
+    'run.programrun': { label: 'Run a program', collection: `${A}/programs/programrun`, provenOnOurBox: true },
+    'cts.requests': { label: 'Transport requests (read, release)', collection: `${A}/cts/transportrequests`, provenOnOurBox: true },
 });
 export const FEATURE_IDS = Object.freeze(Object.keys(FEATURES));
 export function isFeatureId(s) {

package/dist/session/audit-export.js

@@ -62,6 +62,8 @@ const WRITE_TOOLS = new Set([
     // Final review I2 — SAP's RAP generator (tools/rap/generate-objects.ts) creates
     // the skeleton objects in one call; its row names them.
     'sap_generate_objects',
+    // Part 3 — a run executes code on the SAP system under an approval: it is audited.
+    'sap_run',
 ]);
 /**
  * Non-mutating tools that are interaction/plumbing, not object reads — excluded
@@ -156,6 +158,29 @@ function approvalCell(rec) {
     return `declined ✗${risk}`;
 }
 // ── Object / snapshot extraction ──────────────────────────────────────────
+/**
+ * The result as JSON, or its first line as JSON (a run's facts line), or the
+ * top-level fields a spilled preview still shows ("status": "stopped" comes
+ * before steps[] in the release envelope). {} when none of these read.
+ */
+function parseResultHead(result) {
+    const text = result ?? '';
+    try {
+        return asRecord(JSON.parse(text));
+    }
+    catch { /* next */ }
+    try {
+        return asRecord(JSON.parse(text.split('\n', 1)[0] ?? ''));
+    }
+    catch { /* next */ }
+    const top = (k) => new RegExp(`^ {2}"${k}": "([^"]+)"`, 'm').exec(text)?.[1];
+    const status = top('status');
+    if (!status)
+        return {};
+    const at = top('stopped_at');
+    const verdict = top('stop_verdict');
+    return { status, ...(at ? { stopped_at: at } : {}), ...(verdict ? { stop_verdict: verdict } : {}) };
+}
 function writeObject(tool, args, result) {
     switch (tool) {
         case 'sap_transport_create': {
@@ -180,8 +205,31 @@ function writeObject(tool, args, result) {
             // Last resort: name the operation, not the raw description.
             return 'transport';
         }
-        case 'sap_transport_release':
-            return str(args.transport) ?? '—';
+        case 'sap_transport_release': {
+            // Part 3 (D17): the row carries SAP's verdict; a stop names its step.
+            const tr = str(args.transport) ?? '—';
+            const r = parseResultHead(result);
+            const status = str(r.status);
+            if (!status)
+                return tr;
+            if (status === 'stopped') {
+                const last = Array.isArray(r.steps) && r.steps.length > 0 ? asRecord(r.steps[r.steps.length - 1]) : {};
+                const at = str(r.stopped_at) ?? str(last.number);
+                const verdict = str(r.stop_verdict) ?? str(last.verdict);
+                if (at && verdict)
+                    return `${tr} · stopped at ${at}: ${verdict}`;
+            }
+            return `${tr} · ${status}`;
+        }
+        case 'sap_run': {
+            // Part 3: `CLAS ZCL_X · ran` or the error code (the facts line is line 1 of a ran result).
+            const r = parseResultHead(result);
+            const what = [str(args.type), str(args.name)].filter(Boolean).join(' ') || '—';
+            if (r.ran === true)
+                return `${what} · ran`;
+            const err = str(r.error);
+            return err ? `${what} · ${err}` : what;
+        }
         case 'sap_update_method': {
             const cls = str(args.class_name) ?? '—';
             const m = str(args.method_name);

package/dist/tools/approval.js

@@ -1,4 +1,6 @@
 import chalk from 'chalk';
+import { notModifiableText } from './release-texts.js';
+import { isModifiable, knownObjectCount } from '@cspeach/sap-client';
 import { registerTool } from './index.js';
 import { isHeadless, shouldUseInk } from '../renderer/tty.js';
 import { effectiveRisk, riskReasonText, typeCode } from '../approvals/risk-floor.js';
@@ -120,6 +122,55 @@ function isPureInfraEscalation(changes) {
         changes.every((c) => c.op === 'create' &&
             INFRA_BASE_OBJECT_TYPES.has((c.type ?? '').trim().toUpperCase())));
 }
+/**
+ * Part 3 D12 — for every release change: drop any model-supplied facts, read
+ * the request from SAP and attach SAP's facts, or return the refusal. There is
+ * no separate "no SAP" branch: standalone's `ctx.adt` is a Proxy whose every
+ * method throws the standalone text, so the throw path IS the standalone path.
+ */
+async function attachReleaseFacts(changes, ctx) {
+    for (const c of changes) {
+        if (!c)
+            continue;
+        // Never the model's facts — on any change.
+        delete c.releaseFacts;
+        if (c.op !== 'release')
+            continue;
+        if (typeCode(c.type) !== 'CTS') {
+            return { error: 'release_type', message: 'A release change has type CTS and names the request number.' };
+        }
+        const asked = String(c.object ?? '').trim();
+        let doc;
+        try {
+            doc = await ctx.adt.transportRead(asked);
+        }
+        catch (e) {
+            const why = e instanceof Error ? e.message : String(e);
+            return {
+                error: 'release_facts_unavailable',
+                message: `CSPeach could not read ${asked}, so it cannot show what a release would send. (${why})`,
+            };
+        }
+        if (doc.kind === 'task') {
+            return {
+                error: 'task_number',
+                message: `${asked} is a task of ${doc.number}. Give the request number; CSPeach releases the tasks first, then the request.`,
+            };
+        }
+        if (!isModifiable(doc.status)) {
+            return { error: 'not_modifiable', message: notModifiableText(doc) };
+        }
+        c.releaseFacts = {
+            request: doc.number, description: doc.description, owner: doc.owner, target: doc.target,
+            status: doc.status, statusText: doc.statusText,
+            tasks: doc.tasks.map((t) => ({ number: t.number, owner: t.owner })),
+            // The largest count the document supports; null = could not count
+            // (the card says so, never "0 objects").
+            objects: knownObjectCount(doc),
+        };
+    }
+    return null;
+}
 registerTool({
     name: 'request_approval',
     description: 'Request user approval for one or more SAP mutations. Returns approval_ids (one per change) to be passed as approval_id on matching mutating tool calls.',
@@ -135,7 +186,7 @@ registerTool({
                 items: {
                     type: 'object',
                     properties: {
-                        op: { type: 'string', enum: ['create', 'modify', 'delete', 'activate', 'release'] },
+                        op: { type: 'string', enum: ['create', 'modify', 'delete', 'activate', 'release', 'run'] },
                         object: { type: 'string' },
                         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).' },
@@ -216,6 +267,13 @@ registerTool({
         if (getEffectiveWriteMode(cfg.write_mode, role) === 'advisory-only') {
             return handleAdvisoryApproval(args, { sapAlias: ctx.sapAlias });
         }
+        // Part 3 D12 — a release card carries SAP's own facts about the request,
+        // read here before any card or nag; never the model's. After the advisory
+        // short-circuit (F-10: advisory mints nothing, so no read is spent on a
+        // card that is never drawn). Every refusal mints nothing.
+        const releaseRefusal = await attachReleaseFacts(args.changes ?? [], ctx);
+        if (releaseRefusal)
+            return { content: JSON.stringify(releaseRefusal), is_error: true };
         let sapCfg = cfg.sap[ctx.sapAlias];
         const riskCtx = {
             sapAlias: ctx.sapAlias,

package/dist/tools/release-texts.js

@@ -0,0 +1,9 @@
+/**
+ * Part 3 — release refusal texts shared by the approval card (approval.ts) and
+ * sap_transport_release (transport.ts). Same words as sap-client's own refusal
+ * in transportRelease; an empty status never prints as an empty string.
+ */
+export function notModifiableText(doc) {
+    return `${doc.number} cannot be released: its status is "${doc.statusText || `status ${doc.status || 'unknown'}`}". `
+        + 'Only a modifiable request can be released. Nothing was sent.';
+}

package/dist/tools/sap-read.js

@@ -29,6 +29,7 @@ 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 { hasManualLocks } from '../sap/session-end.js';
 import { SapError, parseFunctionModuleDocument, parseContainerDocument } from '@cspeach/sap-client';
 // -----------------------------------------------------------------------
 // Task 17 (spec D12, ruling F18) — model-facing formats.
@@ -719,8 +720,11 @@ registerTool({
         required: ['name', 'type'],
     },
     handler: async (args, ctx) => {
-        // runUnitTest(type, name) — type first
-        const result = await ctx.adt.runUnitTest(args.type, args.name);
+        // runUnitTest(type, name, opts) — type first. D18: under a manual lock
+        // (sap_lock) the stateful session is kept, so the lock survives exactly as
+        // before; otherwise sap-client ends an open session first (a stateful
+        // session runs the old load, probe 2026-10-17 §2.3).
+        const result = await ctx.adt.runUnitTest(args.type, args.name, { keepSession: hasManualLocks() });
         // B2 false-green guard: a run in which no test actually ran reads to a
         // caller like "nothing failed → green". Wrap the (still-carried) raw result
         // in an explicit UNVERIFIED envelope when:

package/dist/tools/sap-run.js

@@ -0,0 +1,163 @@
+/**
+ * ADT gap program, Part 3 — sap_run: run one of the person's own classes
+ * (IF_OO_ADT_CLASSRUN) or programs and show the output (plan D1–D8, D18).
+ *
+ * Order (each refusal before anything is spent or sent where it can be):
+ *   0.  Z/Y names only (D3), before the approval.
+ *   0b. Never while a sap_lock lock is held (D18): ending the session would
+ *       drop the lock, keeping it would run the old load. Before the approval.
+ *   1.  One approval of op `run` per run (D2): a plan-grant id never runs, and
+ *       the approval's type must be the type asked for (a CLAS approval never
+ *       runs a PROG of the same name; the jwt checks object/op/nonce only).
+ *   2.  WAL pending entry, as sap_activate writes one.
+ *   3.  runClass / runProgram (sap-client reads SAP's answer: HTTP 200 alone
+ *       is never "ran"; a 500 page is a dump with its window).
+ *   4.  WAL finalized.
+ *   5.  The result: the facts line, then the output, spilled when long (D7).
+ */
+import crypto from 'node:crypto';
+import { registerTool } from './index.js';
+import { verifyAndSpendApprovalId } from '../approvals/jwt.js';
+import { typeCode } from '../approvals/risk-floor.js';
+import { ERR } from '../errors/codes.js';
+import { appendPending, finalizeToolCall } from '../session/pending.js';
+import { hasManualLocks } from '../sap/session-end.js';
+import { spillToolResult } from './result-spill.js';
+import { isCustomerRunnable, notCustomerText, runUrl, SapError } from '@cspeach/sap-client';
+const MANUAL_LOCK_TEXT = 'A lock you took with sap_lock is still held. Unlock it (sap_unlock) first, then ask for the run again.';
+/** Every line right-trimmed (CR included), trailing blank lines dropped. */
+function rightTrimmed(output) {
+    return output.split(/\r?\n/).map((l) => l.trimEnd()).join('\n').trimEnd();
+}
+registerTool({
+    name: 'sap_run',
+    description: 'Run one of your own classes (it must implement IF_OO_ADT_CLASSRUN and be active) or one of your own programs, '
+        + 'and show the output. Only names starting with Z or Y. A program runs with its selection-screen defaults; '
+        + 'values cannot be passed. The run is on the active version. Requires approval_id from a request_approval '
+        + 'change of op `run` (one approval per run; never auto-approved). When SAP answered but did not run anything, '
+        + 'the result says `not_runnable`; when the run dumped, the result says `run_dumped` and gives the window for '
+        + 'sap_short_dump. Long output is saved to a file and previewed.',
+    isMutating: true,
+    requiresSap: true,
+    requires: (a) => (String(a.type ?? '').trim().toUpperCase() === 'PROG' ? 'run.programrun' : 'run.classrun'),
+    input_schema: {
+        type: 'object',
+        properties: {
+            type: { type: 'string', enum: ['CLAS', 'PROG'], description: 'CLAS for a class run (console), PROG for a program run' },
+            name: { type: 'string', description: 'Class or program name, e.g. ZCL_ORDER_DEMO' },
+            approval_id: { type: 'string', description: 'JWT from request_approval (a change of op run)' },
+        },
+        required: ['type', 'name', 'approval_id'],
+    },
+    handler: async (args, ctx) => {
+        const type = String(args.type ?? '').trim().toUpperCase();
+        const rawName = String(args.name ?? '').trim();
+        const name = rawName.toUpperCase();
+        if (type !== 'CLAS' && type !== 'PROG') {
+            return { content: JSON.stringify({ error: 'run_refused', message: 'sap_run runs a class (type CLAS) or a program (type PROG).' }), is_error: true };
+        }
+        // ── 0. Own objects only (D3) — before the approval is spent ────────────
+        // runUrl applies the same rule sap-client applies (and refuses a name that is
+        // not letters, digits and underscores), so nothing it would refuse after the
+        // spend gets past this point.
+        let refusal;
+        if (!rawName || !isCustomerRunnable(rawName))
+            refusal = notCustomerText(rawName);
+        else {
+            try {
+                runUrl(type, rawName);
+            }
+            catch (e) {
+                refusal = e instanceof Error ? e.message : String(e);
+            }
+        }
+        if (refusal) {
+            return { content: JSON.stringify({ error: 'run_refused', message: refusal }), is_error: true };
+        }
+        // ── 0b. Never under a manual lock (D18) — before the approval ──────────
+        if (hasManualLocks()) {
+            return { content: JSON.stringify({ error: 'manual_lock_held', message: MANUAL_LOCK_TEXT }), is_error: true };
+        }
+        // ── 1. The approval: op run, one per run, never a plan grant (D2) ──────
+        const verify = await verifyAndSpendApprovalId(args.approval_id, name, 'run');
+        if (!verify.ok) {
+            return { content: JSON.stringify({ error: ERR.APPROVAL_INVALID, reason: verify.reason }), is_error: true };
+        }
+        if (verify.payload.grant) {
+            return { content: JSON.stringify({ error: ERR.APPROVAL_INVALID, reason: 'grant_cannot_run' }), is_error: true };
+        }
+        if (typeCode(verify.payload.type) !== type) {
+            return { content: JSON.stringify({ error: ERR.APPROVAL_INVALID, reason: 'type_mismatch' }), is_error: true };
+        }
+        // ── 2. WAL ─────────────────────────────────────────────────────────────
+        const toolUseId = ctx.toolUseId ?? crypto.randomUUID();
+        const startedAt = Date.now();
+        await appendPending(ctx.session, {
+            tool_use_id: toolUseId,
+            tool: 'sap_run',
+            args: { type, name },
+            started_at: new Date().toISOString(),
+        });
+        const line = (kind, ms) => ctx.chunkEmitter?.emit('info', `run ${type} ${name} · ${kind} · ${ms} ms`);
+        // ── 3. The run ─────────────────────────────────────────────────────────
+        let r;
+        try {
+            r = type === 'PROG' ? await ctx.adt.runProgram(name) : await ctx.adt.runClass(name);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // sap-client's own Z/Y refusal (400) cannot reach here (step 0 ran first).
+            // Anything else (a lost connection) may have run: say so, never "refused".
+            const refused = err instanceof SapError && err.httpStatus === 400;
+            const body = refused
+                ? { error: 'run_refused', message }
+                : { error: 'run_failed', type, name, detail: message };
+            await finalizeToolCall(ctx.session, toolUseId, JSON.stringify(body), true, Date.now() - startedAt);
+            line(refused ? 'refused' : 'failed', Date.now() - startedAt);
+            return { content: JSON.stringify(body), is_error: true };
+        }
+        // ── 4/5. WAL closed, the result ────────────────────────────────────────
+        if (r.kind === 'ran') {
+            const facts = JSON.stringify({
+                ran: true, type, name: r.name, lines: r.lines, chars: r.outputBytes,
+                elapsed_ms: r.elapsedMs, session_ended: r.sessionEnded,
+            });
+            await finalizeToolCall(ctx.session, toolUseId, facts, false, Date.now() - startedAt);
+            line('ran', r.elapsedMs);
+            // The facts line is the first line of the content (not a spill header):
+            // the file starts with it too, so tool_output_read line 1 is the facts.
+            const out = rightTrimmed(r.output);
+            return spillToolResult({ content: out ? `${facts}\n${out}` : facts }, ctx, 'shell', { label: `run ${r.name}` });
+        }
+        let body;
+        if (r.kind === 'not_runnable') {
+            body = {
+                error: 'not_runnable', type, name: r.name, sap_said: r.sapText, reason: r.reason,
+                next_step: 'activate the object (sap_activate) or fix the name, then ask for a new run approval',
+            };
+        }
+        else if (r.kind === 'dumped') {
+            const d = r.dump;
+            body = {
+                error: 'run_dumped', type, name: r.name, message: d?.message,
+                ...(d?.serverTime ? { sap_server_time: d.serverTime } : {}),
+                ...(d?.window ? { dump_window: { from: d.window.from, to: d.window.to } } : {}),
+                note: 'Output written before the exception is lost; the dump has the stack.',
+                next_step: d?.window
+                    ? `sap_short_dump with fromDate and toDate = dump_window (SAP system time), then operation detail on the newest dump whose program names ${r.name}`
+                    : `sap_short_dump (list), then operation detail on the newest dump whose program names ${r.name}`,
+            };
+        }
+        else {
+            body = {
+                error: r.reason?.startsWith('No answer') ? 'run_timed_out' : 'run_failed', type, name: r.name,
+                ...(r.httpStatus !== undefined ? { http_status: r.httpStatus } : {}),
+                detail: r.reason ?? r.sapText,
+            };
+        }
+        const content = JSON.stringify(body);
+        await finalizeToolCall(ctx.session, toolUseId, content, true, Date.now() - startedAt);
+        line(r.kind, r.elapsedMs);
+        return { content, is_error: true };
+    },
+});

package/dist/tools/tool-loading.js

@@ -41,7 +41,7 @@ const FIORI_FAMILY = [
     'fiori_sample_get', 'fiori_sample_search', 'fiori_scaffold', 'fiori_scaffold_fe',
 ];
 const TRANSPORT_FAMILY = [
-    'sap_transport_create', 'sap_transport_for_object', 'sap_transport_list', 'sap_transport_release',
+    'sap_transport_create', 'sap_transport_for_object', 'sap_transport_list', 'sap_transport_read', 'sap_transport_release',
 ];
 /**
  * Per-skill starter tools: the non-core tools a skill's body names as its
@@ -65,14 +65,15 @@ export const SKILL_STARTERS = Object.freeze({
     'abap-impact': ['sap_usage_references', 'sap_atc_run'],
     'abap-performance': ['sap_usage_references', 'sap_atc_run'],
     'abap-migrate': ['sap_usage_references'],
-    'abap-dump': ['sap_short_dump', 'sap_snapshot_take'],
-    'abap-incident': ['sap_short_dump', 'sap_snapshot_take', 'sap_atc_run', 'sap_run_unit_test', 'sap_api_state', 'sap_diff'],
-    'abap-eml': ['sap_run_unit_test'],
-    'abap-test': ['sap_run_unit_test', 'sap_set_class_include'],
+    // Part 3 — the skills whose body says "run it" (Task 7's run block) also start with sap_run.
+    'abap-dump': ['sap_short_dump', 'sap_snapshot_take', 'sap_run'],
+    'abap-incident': ['sap_short_dump', 'sap_snapshot_take', 'sap_atc_run', 'sap_run_unit_test', 'sap_api_state', 'sap_diff', 'sap_run'],
+    'abap-eml': ['sap_run_unit_test', 'sap_run'],
+    'abap-test': ['sap_run_unit_test', 'sap_set_class_include', 'sap_run'],
     'abap-extend-model': ['extend_model_insert', 'sap_snapshot_take', 'sap_service_binding_publish', 'sap_set_class_include'],
     // 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'],
+    'abap-rap': ['sap_set_class_include', 'sap_service_binding_publish', 'sap_class_includes', 'rap_skeleton_resolve', 'sap_generate_objects', 'rap_finish_check', 'sap_run'],
     // 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.
@@ -84,7 +85,7 @@ export const SKILL_STARTERS = Object.freeze({
     'abap-upgrade-verify': ['sap_atc_run'],
     // Selection texts (2026-10-04): a new PARAMETERS / SELECT-OPTIONS gets its text in the same change.
     'abap-refactor': ['sap_get_text_elements', 'sap_set_text_elements'],
-    'abap-generate': ['sap_get_text_elements', 'sap_set_text_elements'],
+    'abap-generate': ['sap_get_text_elements', 'sap_set_text_elements', 'sap_run'],
 });
 /** The starter tools for a skill; unknown skill (or none) ⇒ []. */
 export function startersForSkill(skill) {

package/dist/tools/transport.js

@@ -7,14 +7,21 @@
  *   transportList(user?, status?)                 → Promise<TransportListResult>  line 1048
  *     TransportListResult { filterUser, filterStatus, transports: TransportEntry[] }
  *     TransportEntry { transportNumber, description?, owner?, status?, type?, target? }
- *   transportRelease(transportNumber)             → Promise<TransportResult>      line 2546
- *     Released status string from SAP is 'released' (not a raw 'R' code).
+ *   transportRead(number)                         → Promise<TransportRequestDoc>    (Part 3)
+ *   transportRelease(number)                      → Promise<TransportReleaseResult> (Part 3)
+ *     status 'released' only on SAP's verdict for every step AND a status read back of R/N.
  */
 import { bindGrantTransport, isPlanGrantInScope } from '../approvals/plan-grant.js';
 import { registerTool } from './index.js';
 import { verifyAndSpendApprovalId } from '../approvals/jwt.js';
-import { auditLog } from '@cspeach/sap-client';
+import { auditLog, SapNotFoundError, isModifiable, knownObjectCount, allObjectNames } from '@cspeach/sap-client';
+import { typeCode } from '../approvals/risk-floor.js';
+import { spillToolResult } from './result-spill.js';
+import { notModifiableText } from './release-texts.js';
+import { RELEASE_CHECK_LINE } from '../approvals/op-labels.js';
 import { ERR } from '../errors/codes.js';
+import { presentSafetyConfirmation } from '../repl/safety-confirm.js';
+import { isSafetyConfirmEnabled } from '../repl/safety-mode-state.js';
 import { setCurrentTransport, noteConfirmedTransport } from '../repl/current-transport.js';
 import { enrichTransportList } from './transport-fit.js';
 import { reusedRequestRefusal } from './transport-fit-check.js';
@@ -472,40 +479,259 @@ registerTool({
         }
     },
 });
+// ── sap_transport_read ───────────────────────────────────────────────────────
+//
+// Part 3 (D16) — one transport request as SAP's transport organizer shows it.
+// Read only, no approval.
+/** The 404 text, never SAP's generic "Object not found". */
+function notFoundText(n) {
+    return `Transport request ${n} does not exist.`;
+}
+/** Gate 0 of the release and the whole of the read: SAP's own document, or the refusal envelope. */
+async function readRequest(ctx, asked) {
+    try {
+        return { doc: await ctx.adt.transportRead(asked) };
+    }
+    catch (err) {
+        const body = err instanceof SapNotFoundError
+            ? { error: 'not_found', detail: notFoundText(asked) }
+            : { error: 'transport_read_failed', detail: err instanceof Error ? err.message : String(err) };
+        return { refusal: { content: JSON.stringify(body), is_error: true } };
+    }
+}
+registerTool({
+    name: 'sap_transport_read',
+    description: 'Read one transport request: status, owner, target, its tasks and how many objects it holds. '
+        + 'A task number answers its request with that task. Read only.',
+    isMutating: false,
+    requiresSap: true,
+    requires: 'cts.requests',
+    input_schema: {
+        type: 'object',
+        properties: {
+            transport: { type: 'string', description: 'Transport request or task number (e.g. DEVK900123)' },
+        },
+        required: ['transport'],
+    },
+    handler: async (args, ctx) => {
+        const asked = String(args.transport ?? '').trim().toUpperCase();
+        const read = await readRequest(ctx, asked);
+        if ('refusal' in read)
+            return read.refusal;
+        const { doc } = read;
+        const objectCount = knownObjectCount(doc);
+        const notes = [];
+        if (doc.kind === 'task')
+            notes.push(`${asked} is a task of ${doc.number}.`);
+        if (objectCount === null)
+            notes.push(`CSPeach could not count the objects of ${doc.number}.`);
+        return {
+            content: JSON.stringify({
+                kind: doc.kind,
+                request: doc.number,
+                description: doc.description,
+                owner: doc.owner,
+                type: doc.type,
+                status: doc.status,
+                status_text: doc.statusText,
+                target: doc.target,
+                tasks: doc.tasks.map((t) => ({
+                    number: t.number, owner: t.owner, status: t.status, status_text: t.statusText, objects: t.objectCount,
+                })),
+                object_count: objectCount,
+                can_release: isModifiable(doc.status) && doc.actions.includes('newreleasejobs'),
+                ...(notes.length ? { note: notes.join(' ') } : {}),
+            }),
+        };
+    },
+});
 // ── sap_transport_release ────────────────────────────────────────────────────
 //
-// 1.1.44 hotfix: not available. The request this tool used to send never
-// released anything (SAP routes it to the create-request handler), and the
-// tool then reported "released". Until the proper release ships, the tool
-// refuses before anything else: no approval spent, no card, no SAP request.
-const RELEASE_UNAVAILABLE = 'Releasing a transport is not available in this version of CSPeach. '
-    + 'Release it in SE09 or Eclipse. Nothing was sent to SAP.';
+// Part 3 (D10–D13, D17) — every open task first, then the request, on SAP's
+// own release verdict (sap-client transportRelease). Gates, in order:
+//   0.  read the request: missing, a task number, not modifiable → refused;
+//   0b. the request's objects (its tasks' too) against the inactive list →
+//       refused (SAP would abort with abortrelinacobj; its consistency check
+//       does not see inactive objects);
+//   1.  the approval (op release, type CTS) — spent only after 0/0b passed;
+//   2.  the safety card (Rule 9) when safety mode is on.
+// The envelope carries every step's verdict, SAP's texts and raw reports, what
+// was never sent, the status read back, and that the release is not yet proven
+// live. sap-client writes the audit rows (one per step and one closing row);
+// the tool writes none of its own, except when sap-client threw before any.
+/** Verdicts that mean "SAP would release it if something were ignored" (D11). */
+const IGNORE_VERDICTS = new Set(['relwithignlock', 'relObjigchkatc', 'relwithignwarning']);
+const NOT_YET_PROVEN = "Built from SAP's own release interface and tested against recorded answers; not yet run in a live release. "
+    + 'Ask the user to check the transport in SE09 after the release.';
 registerTool({
     name: 'sap_transport_release',
-    description: 'Releasing a transport is not available in this version of CSPeach. '
-        + 'This tool sends nothing to SAP; tell the user to release the transport in SE09 or Eclipse.',
+    description: 'Release a transport request: every open task first, then the request. The verdict comes from SAP\'s own release '
+        + 'report, step by step, and the request status is read back; an HTTP answer alone is never taken as released. '
+        + 'Stops at the first step SAP does not release; never ignores locks, object-check errors or warnings (release '
+        + 'those in SE09 or Eclipse). Built from SAP\'s own release interface and tested against recorded answers; not '
+        + 'yet run in a live release, so ask the user to check the transport in SE09 afterwards. Cannot be undone. '
+        + 'Requires approval_id from a request_approval change of op `release`, type CTS (one approval per release; '
+        + 'never auto-approved).',
     isMutating: true,
     requiresSap: true,
+    requires: 'cts.requests',
     input_schema: {
         type: 'object',
         properties: {
             transport: {
                 type: 'string',
-                description: 'Transport request number (e.g. DEVK900123)',
+                description: 'Transport request number to release (e.g. DEVK900123); not a task number',
             },
             approval_id: {
                 type: 'string',
-                description: 'JWT from request_approval (not used: release is not available)',
+                description: 'JWT from request_approval (a change of op release, type CTS)',
             },
         },
-        required: ['transport'],
+        required: ['transport', 'approval_id'],
+    },
+    handler: async (args, ctx) => {
+        const asked = String(args.transport ?? '').trim().toUpperCase();
+        // ── Gate 0: SAP's own facts, read fresh (D10, D12) ──────────────────────
+        const read = await readRequest(ctx, asked);
+        if ('refusal' in read)
+            return read.refusal;
+        const { doc } = read;
+        if (doc.kind === 'task') {
+            return {
+                content: JSON.stringify({
+                    error: 'task_number',
+                    message: `${asked} is a task of ${doc.number}. Give the request number; CSPeach releases the tasks first, then the request.`,
+                }),
+                is_error: true,
+            };
+        }
+        if (!isModifiable(doc.status)) {
+            return {
+                content: JSON.stringify({
+                    error: 'not_modifiable',
+                    message: notModifiableText(doc),
+                }),
+                is_error: true,
+            };
+        }
+        // ── Gate 0b: inactive objects of the request (T14) ──────────────────────
+        let warning;
+        let inactiveNames;
+        try {
+            inactiveNames = new Set((await ctx.adt.inactiveObjects()).map((o) => String(o.name ?? '').trim().toUpperCase()));
+        }
+        catch {
+            warning = 'CSPeach could not read the inactive list; SAP aborts a release that holds inactive objects.';
+        }
+        if (inactiveNames) {
+            const blocked = allObjectNames(doc).filter((n) => inactiveNames.has(n));
+            if (blocked.length > 0) {
+                return {
+                    content: JSON.stringify({
+                        error: 'release_blocked_inactive',
+                        objects: blocked,
+                        message: `These objects of ${doc.number} are inactive: ${blocked.join(', ')}. `
+                            + 'Activate them (sap_activate), then ask again. SAP would abort the release.',
+                    }),
+                    is_error: true,
+                };
+            }
+        }
+        // ── Gate 1: Approval (op release, type CTS) ─────────────────────────────
+        const verify = await verifyAndSpendApprovalId(args.approval_id, args.transport, 'release');
+        if (!verify.ok) {
+            return {
+                content: JSON.stringify({ error: ERR.APPROVAL_INVALID, reason: verify.reason }),
+                is_error: true,
+            };
+        }
+        if (typeCode(verify.payload?.type) !== 'CTS') {
+            return {
+                content: JSON.stringify({ error: ERR.APPROVAL_INVALID, reason: 'type_mismatch' }),
+                is_error: true,
+            };
+        }
+        const startedAt = Date.now();
+        // ── Gate 2: Safety confirmation (Rule 9 — a release cannot be undone) ───
+        if (isSafetyConfirmEnabled()) {
+            const openTasks = doc.tasks.filter((t) => isModifiable(t.status)).map((t) => t.number);
+            const objects = knownObjectCount(doc);
+            const c = await presentSafetyConfirmation({
+                rule: 'RULE_9_TRANSPORT_RELEASE',
+                op: 'transport_release',
+                object: { type: 'TRANSPORT', name: doc.number },
+                what_will_happen: `Releases ${openTasks.length} task(s)${openTasks.length ? ` (${openTasks.join(', ')})` : ''} then request ${doc.number} `
+                    + `(${objects === null ? 'an uncounted number of' : objects} objects, target ${doc.target || 'none'}). `
+                    + `Cannot be undone; the request may move to other systems on the route. ${RELEASE_CHECK_LINE}`,
+                rollback_available: false,
+                transport: doc.number,
+                args: { ...args },
+            });
+            if (!c.confirmed) {
+                return {
+                    content: JSON.stringify({ error: 'cancelled_by_user', reason: c.reason }),
+                    is_error: true,
+                };
+            }
+        }
+        // ── Release: tasks, then the request, on SAP's verdict ──────────────────
+        let r;
+        try {
+            r = await ctx.adt.transportRelease(doc.number);
+        }
+        catch (err) {
+            // sap-client threw before its first step (its own read): it wrote no row.
+            await auditLog('transportRelease', 'CTS', doc.number, 'error', Date.now() - startedAt);
+            return {
+                content: JSON.stringify({ error: 'transport_release_failed', detail: err instanceof Error ? err.message : String(err) }),
+                is_error: true,
+            };
+        }
+        const finalStatus = r.finalStatus?.status;
+        // Never `released: true` beside a status that is not R or N.
+        const released = r.status === 'released' && (finalStatus === 'R' || finalStatus === 'N');
+        let note;
+        switch (r.status) {
+            case 'released':
+                // Worded from `released`, never from r.status alone: "Released." only beside released: true.
+                note = released
+                    ? "Released. SAP's answer for each step is in steps[] and sap_answer[]."
+                    : `SAP reported every step released, but the request reads status ${finalStatus || 'unknown'}. Check it in SE09.`;
+                break;
+            case 'stopped': {
+                const last = r.steps[r.steps.length - 1];
+                note = `${r.error ?? ''} Nothing was sent after that step.`.trim();
+                if (last && IGNORE_VERDICTS.has(last.verdict)) {
+                    note += ' CSPeach does not release with anything ignored. Release it in SE09 or Eclipse if that is what you want.';
+                }
+                break;
+            }
+            case 'refused':
+                note = r.refusal ?? 'Nothing was sent.';
+                break;
+            default:
+                note = r.error ?? `The release ended with status ${r.status}.`;
+        }
+        const detail = r.refusal ?? r.error;
+        const stopStep = r.status === 'stopped' ? r.steps[r.steps.length - 1] : undefined;
+        const envelope = {
+            released,
+            status: r.status,
+            // Near the top so a spilled preview (and the audit row read from it) keeps the stopping step.
+            ...(stopStep ? { stopped_at: stopStep.number, stop_verdict: stopStep.verdict } : {}),
+            transport_number: r.transportNumber,
+            final_status: finalStatus,
+            not_sent: r.notSent ?? [],
+            note,
+            ...(detail ? { error_detail: detail } : {}),
+            ...(warning ? { warning } : {}),
+            not_yet_proven: NOT_YET_PROVEN,
+            steps: r.steps.map(({ rawReports: _raw, ...s }) => s),
+            sap_answer: r.steps.map((s) => ({ step: s.number, raw: s.rawReports ?? '' })),
+        };
+        // Pretty-printed with the facts first: a spilled preview keeps the verdict
+        // lines (a one-line JSON would be cut at the preview's line limit).
+        const failed = r.status === 'stopped' || r.status === 'error' || r.status === 'refused';
+        return spillToolResult({ content: JSON.stringify(envelope, null, 2), ...(failed ? { is_error: true } : {}) }, ctx, 'report', { label: `release ${r.transportNumber}` });
     },
-    handler: async (args) => ({
-        content: JSON.stringify({
-            error: 'release_unavailable',
-            transport: args.transport,
-            message: RELEASE_UNAVAILABLE,
-        }),
-        is_error: true,
-    }),
 });

package/dist/tools/write-mode.js

@@ -23,6 +23,8 @@ export const WRITE_TOOLS = new Set([
     'sap_transport_release',
     // Final review I2 — SAP's RAP generator creates the skeleton objects.
     'sap_generate_objects',
+    // Part 3 — a run executes code on the SAP system; advisory mode never runs it.
+    'sap_run',
 ]);
 export function isWriteTool(name) {
     return WRITE_TOOLS.has(name);

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, affectsLine } from '../approvals/op-labels.js';
+import { verbLine, viewAffordance, toSourceLines, affectsLine, releaseLines } 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
@@ -39,10 +39,18 @@ export function riskRows(effectiveRisk, width) {
  * 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. */
+/**
+ * The rows under the verb line: "Affects: …" (none when the change names no
+ * process), then — Part 3 D12 — a release card's fact lines, each wrapping
+ * onto up to AFFECTS_MAX_ROWS rows. Any other change: exactly as before.
+ */
 export function affectsRows(change, width) {
+    const cols = Math.max(1, width - MODAL_CHROME_COLS);
     const line = affectsLine(change);
-    return line ? wrapRows(line, Math.max(1, width - MODAL_CHROME_COLS), AFFECTS_MAX_ROWS) : [];
+    return [
+        ...(line ? wrapRows(line, cols, AFFECTS_MAX_ROWS) : []),
+        ...releaseLines(change).flatMap((l) => wrapRows(l, cols, AFFECTS_MAX_ROWS)),
+    ];
 }
 /**
  * The collapsed card's rendered height at `width` (the live-area budget; the

package/dist/ui/session-timeline.js

@@ -14,7 +14,7 @@ const MUTATING_TOOLS = new Set([
     'sap_set_source', 'sap_update_method', 'sap_delete_object', 'sap_activate',
     'sap_create_object', 'sap_transport_release', 'sap_message_maintain',
     'sap_number_range_intervals', 'sap_service_binding_publish',
-    'sap_service_binding_unpublish',
+    'sap_service_binding_unpublish', 'sap_run',
 ]);
 export function toTimelineEntry(call) {
     // args shape depends on the tool; extract defensively.

package/package.json

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