@cspeach/cli 1.1.34 → 1.1.36

package/dist/renderer/notices.js

@@ -36,13 +36,18 @@ import stringWidth from 'string-width';
 import { getLook } from './look.js';
 import { getGlyphs } from './glyphs.js';
 import { truncateToWidth, uiWidth } from './ui-width.js';
+import { wrapRows } from './wrap-rows.js';
+import { paint } from './theme.js';
+import chalk from 'chalk';
 import { getNoticeLogPath, recordFullNotice } from './notice-log.js';
 import { getEffectiveBodyWidth, isDeclaredOneShot } from './tty.js';
 import { EventEmitter } from 'node:events';
+/** Fix batch 2026-10-12 — a panels notice wraps onto at most this many rows. */
+export const NOTICE_MAX_ROWS = 3;
 /**
- * Format one notice as a single terminal line (trailing newline included).
- * Multi-line messages are collapsed to one line — notices are glanceable
- * margin notes, not documents; anything long belongs in the tool result.
+ * Format one notice (trailing newline included). Multi-line messages are
+ * collapsed to one line of text; in the panels look that text then wraps
+ * onto up to NOTICE_MAX_ROWS screen rows (fix batch 2026-10-12).
  *
  * Piece 2 §9: warn → the attention shape ("! message"), info → the info
  * shape ("· message", dim). Same glyphs as every other notice.
@@ -50,10 +55,11 @@ import { EventEmitter } from 'node:events';
 export function formatNoticeLine(level, message) {
     // Live fix 2026-09-26: a SAP HTML error page must never leak tags/CSS here.
     const readable = looksLikeMarkup(message) ? cleanErrorText(message, 400) : message;
-    let oneLine = readable.replace(/\s*\r?\n\s*/g, ' ').trim();
-    // Live fix 2026-09-26 (panels): never wrap mid-word — cut to one screen
-    // line ("<glyph> " + text ≤ uiWidth) and keep the full text in the
-    // session's notice log. Legacy stays byte-identical.
+    const oneLine = readable.replace(/\s*\r?\n\s*/g, ' ').trim();
+    // Live fix 2026-09-26 (panels): never let the terminal wrap mid-word —
+    // the text is pre-wrapped at word breaks inside uiWidth (below) and a cut
+    // notice keeps its full text in the session's notice log. Legacy stays
+    // byte-identical.
     // Review I3: only when a screen is there to wrap (stdout is a TTY) or the
     // full text has somewhere to go (a notice log). One-shot / piped output
     // keeps the whole single line — nothing else would record it.
@@ -61,15 +67,23 @@ export function formatNoticeLine(level, message) {
     // keeps the whole line too.
     const wrapsOnScreen = process.stdout.isTTY === true && !isDeclaredOneShot();
     if (getLook() === 'panels' && (wrapsOnScreen || getNoticeLogPath() !== undefined)) {
+        // Fix batch 2026-10-12 (Task 2): a notice may carry what the user must
+        // act on (a transport number, SAP's reason), so it wraps at word breaks
+        // onto up to NOTICE_MAX_ROWS rows — further rows indented two spaces, the
+        // notice shape — instead of being cut to one. Only a longer notice is
+        // cut; its full text goes to the notice log and the screen says so.
         const g = getGlyphs();
         const room = Math.min(uiWidth(), getEffectiveBodyWidth()) - stringWidth(level === 'warn' ? g.attention : g.info) - 1;
-        const cut = truncateToWidth(oneLine, room);
-        // Review M10: truncateToWidth turns tabs into two spaces — compare against
-        // the same normalisation so only a real cut is logged.
-        if (cut !== oneLine.replace(/\t/g, '  ')) {
+        const rows = wrapRows(oneLine, room, NOTICE_MAX_ROWS);
+        const cut = wrapRows(oneLine, room, NOTICE_MAX_ROWS + 1).length > NOTICE_MAX_ROWS;
+        const logPath = getNoticeLogPath();
+        if (cut)
             recordFullNotice(level, message);
-            oneLine = cut;
-        }
+        const head = level === 'warn' ? formatAttention({ text: rows[0] }) : formatInfo(rows[0]);
+        const more = rows.slice(1).map((r) => (level === 'warn' ? `  ${chalk.bold(r)}` : paint('dim', `  ${r}`)));
+        if (cut && logPath)
+            more.push(paint('dim', truncateToWidth(`  Full text: ${logPath}`, room + 2)));
+        return head + more.map((r) => `${r}\n`).join('');
     }
     return level === 'warn' ? formatAttention({ text: oneLine }) : formatInfo(oneLine);
 }

package/dist/renderer/progress-chatter.js

@@ -165,7 +165,9 @@ const MESSAGES = {
         'Walking enhancement spots…',
     ],
     sap_message_maintain: [
-        '(stub — short-circuit)',
+        'Reading the message class…',
+        'Writing the messages…',
+        'Reading the messages back…',
     ],
     sap_number_range_intervals: [
         '(stub — short-circuit)',

package/dist/renderer/tool-labels.js

@@ -160,6 +160,9 @@ const RULES = {
     sap_link: (a) => ({ verb: 'SAP link', object: str(a['action']) ?? '' }),
     cap_link_smoke: (a) => ({ verb: 'S/4 link check', object: str(a['s4']?.['entitySet']) ?? '' }),
     app_lane_resolve: (a) => ({ verb: 'Chose lane', object: shortLeft(str(a['specPath']) ?? '') }),
+    rap_skeleton_resolve: (a) => ({ verb: 'Chose skeleton', object: str(a['table']) ?? '' }),
+    sap_generate_objects: () => ({ verb: 'Ran SAP generator', object: 'RAP skeleton' }),
+    rap_finish_check: (a) => ({ verb: 'Checked finish', object: str(a['root']) ?? '' }),
     team_findings: (a) => ({ verb: 'Read team findings', object: str(a['lane']) ?? str(a['packages']) ?? 'all objects' }),
     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' }),
@@ -177,7 +180,13 @@ const RULES = {
     sap_unlock: sapObject('Unlocked'),
     sap_service_binding_publish: sapObject('Published'),
     sap_service_binding_unpublish: sapObject('Unpublished'),
-    sap_message_maintain: (a) => ({ verb: 'Message', object: shortRight([str(a['messageClass']), str(a['messageNumber'])].filter(Boolean).join(' ')) }),
+    sap_message_maintain: (a) => {
+        const n = Array.isArray(a['messages']) ? a['messages'].length : 0;
+        if (n > 0) {
+            return { verb: 'Messages', object: shortRight(str(a['messageClass']) ?? ''), detail: n === 1 ? '1 message' : `${n} messages` };
+        }
+        return { verb: 'Messages', object: shortRight([str(a['messageClass']), str(a['messageNumber'])].filter(Boolean).join(' ')) };
+    },
     sap_number_range_intervals: (a) => ({ verb: 'Number range', object: shortRight(str(a['nrObject']) ?? '') }),
     ask_question: (a) => ({ verb: 'Question', object: shortRight(str(a['question']) ?? '') }),
     todo_set: () => ({ verb: 'Updated todos', object: '' }),
@@ -252,12 +261,12 @@ const PRESENT = {
     Structure: 'Reading structure of', 'Change log': 'Reading change log of', 'Read dumps': 'Reading dumps',
     'API state': 'Checking API state of', 'ABAP docs': 'Reading ABAP docs for', 'Read includes': 'Reading includes of',
     Compared: 'Comparing', 'Previewed change': 'Previewing change to', 'Ran unit tests': 'Running unit tests on',
-    'OData test': 'Testing OData', 'Service catalog': 'Reading service catalog', 'Import metadata': 'Importing metadata', 'SAP link': 'SAP link', 'S/4 link check': 'Checking S/4 link', 'Chose lane': 'Choosing build lane', 'Searched BAdIs': 'Searching BAdIs', 'Listed snapshots': 'Listing snapshots',
+    'OData test': 'Testing OData', 'Service catalog': 'Reading service catalog', 'Import metadata': 'Importing metadata', 'SAP link': 'SAP link', 'S/4 link check': 'Checking S/4 link', 'Chose lane': 'Choosing build lane', 'Chose skeleton': 'Choosing RAP skeleton builder', 'Ran SAP generator': 'Running SAP generator', 'Checked finish': 'Checking finish items', 'Searched BAdIs': 'Searching BAdIs', 'Listed snapshots': 'Listing snapshots',
     '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',
-    Published: 'Publishing', Unpublished: 'Unpublishing', Message: 'Maintaining message',
+    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',
     'Searched web': 'Searching web', 'Read project context': 'Reading project context',

package/dist/renderer/verify-chain.js

@@ -8,13 +8,15 @@
  * never synthesized. States render truthfully:
  *   - snapshot 'new_object'  → "① snapshot – (new object)" (genuine ADT 404 —
  *     nothing to save; NEVER used for other read failures)
- *   - snapshot 'source_read_failed' → "① snapshot – (no source read: <msg>)" —
+ *   - snapshot 'source_read_failed' → "① snapshot – (no source read)" and the
+ *     reason on its own row under the chain —
  *     the pre-write read failed for a non-404 reason; the object may exist
  *     but there is no recovery copy. Hard-gate tools block instead of
  *     emitting this; it only appears on soft (best-effort) gates.
  *   - snapshot 'best_effort_failed' → "① snapshot – (skipped)" (write tools
  *     where the gate is soft, e.g. class includes)
- *   - syntax fail → "③ syntax ✗ (L12: MESSAGE …)" AND no ④ at all —
+ *   - syntax fail → "③ syntax ✗", the first error whole on the rows under
+ *     the chain (fix batch 2026-10-12: no 60-character cut) AND no ④ at all —
  *     activation is blocked, so we don't show a fake pending step
  *   - syntax 'not_checked' → "③ syntax – (checked at activation)" —
  *     sap_set_class_include has no standalone syntax gate
@@ -28,21 +30,43 @@
  * result row in both renderers.
  */
 import chalk from 'chalk';
+import { wrapRows } from './wrap-rows.js';
+import { uiWidth } from './ui-width.js';
 const pass = (s) => `${s} ${chalk.green('✓')}`;
 const fail = (s, detail) => `${s} ${chalk.red('✗')}${detail ? ' ' + chalk.red(`(${detail})`) : ''}`;
 const skip = (s, why) => chalk.dim(`${s} – (${why})`);
-const ERROR_DETAIL_MAX = 60;
-const SNAPSHOT_DETAIL_MAX = 40;
-const truncate = (s, max) => {
-    const flat = s.replace(/\s+/g, ' ').trim();
-    return flat.length > max ? flat.substring(0, max - 1) + '…' : flat;
-};
+/**
+ * Fix batch 2026-10-12 (Task 2): the SAP error is what the user needs, so it
+ * is never cut to a few characters. Details go on their own rows under the
+ * chain, wrapped at word breaks inside the width, up to these many rows (the
+ * last ends with … only when even that is not enough; the model gets the
+ * full text in the tool result).
+ */
+export const ERROR_DETAIL_ROWS = 4;
+export const SNAPSHOT_DETAIL_ROWS = 2;
+/** Detail rows sit under the chain: its two-space indent plus two. */
+const DETAIL_INDENT = '    ';
+const flatDetail = (s) => s.replace(/\s+/g, ' ').trim();
+/** Detail rows: indented, wrapped inside `width`, at most `maxRows`. */
+export function detailRows(text, width, maxRows) {
+    return wrapRows(flatDetail(text), Math.max(1, width - DETAIL_INDENT.length), maxRows).map((r) => `${DETAIL_INDENT}${r}`);
+}
+/**
+ * Detail-row width: the UI width less the Ink body's 4-cell border overhead
+ * (tty.ts BORDER_OVERHEAD), so a row never reaches the body edge in either
+ * renderer. Pure (no tty import): many tool tests mock tty.js partially.
+ */
+export function chainWidth() {
+    return Math.max(20, uiWidth() - 4);
+}
 /**
  * Build the chain line (no trailing newline). Returns the full line
- * including the two-space indent that aligns with the ⎿ result row.
+ * including the two-space indent that aligns with the ⎿ result row, then
+ * any detail rows (snapshot read failure, first syntax error) under it.
  */
-export function buildWriteChainLine(input) {
+export function buildWriteChainLine(input, width = chainWidth()) {
     const parts = [];
+    const details = [];
     // ① snapshot
     if (input.snapshot === 'taken')
         parts.push(pass('① snapshot'));
@@ -51,10 +75,10 @@ export function buildWriteChainLine(input) {
     else if (input.snapshot === 'source_read_failed') {
         // Honest: the read failed — we do NOT know the object is new, and there
         // is no recovery copy. Never render this as "(new object)".
-        const why = input.snapshotDetail
-            ? `no source read: ${truncate(input.snapshotDetail, SNAPSHOT_DETAIL_MAX)}`
-            : 'no source read';
-        parts.push(skip('① snapshot', why));
+        parts.push(skip('① snapshot', 'no source read'));
+        if (input.snapshotDetail) {
+            details.push(...detailRows(`No source read: ${input.snapshotDetail}`, width, SNAPSHOT_DETAIL_ROWS).map((r) => chalk.dim(r)));
+        }
     }
     else
         parts.push(skip('① snapshot', 'skipped'));
@@ -70,10 +94,9 @@ export function buildWriteChainLine(input) {
         parts.push(chalk.dim('④ activate pending'));
     }
     else {
-        const first = (input.syntax.errors[0] ?? 'syntax errors').replace(/\s+/g, ' ').trim();
-        const detail = first.length > ERROR_DETAIL_MAX ? first.substring(0, ERROR_DETAIL_MAX - 1) + '…' : first;
-        parts.push(fail('③ syntax', detail));
+        parts.push(fail('③ syntax'));
+        details.push(...detailRows(input.syntax.errors[0] ?? 'syntax errors', width, ERROR_DETAIL_ROWS).map((r) => chalk.red(r)));
         // No ④ — activation is blocked; rendering a pending step would lie.
     }
-    return '  ' + parts.join('  ');
+    return ['  ' + parts.join('  '), ...details].join('\n');
 }

package/dist/renderer/wrap-rows.js

@@ -0,0 +1,87 @@
+// src/renderer/wrap-rows.ts
+//
+// The one wrap helper for card content (fix batch 2026-10-12, Task 2).
+//
+// THE RULE: card content wraps; chrome may cut. Text a person reads to make
+// a decision — card titles, facts, option labels and descriptions, risk and
+// failure reasons, SAP error details — is pre-wrapped here into a KNOWN
+// number of rows. Ink never soft-wraps a live-frame row (its erase
+// accounting counts rows), so callers draw each returned row as its own
+// truncate-end <Text> and count every row in their height estimate. Status
+// rows, hints, palettes, spinners, traces and "… N more" counters stay one
+// row and cut with truncateToWidth.
+//
+// Replaces factRows (confirm-card) and wrapCardText (ask-card), which did the
+// same job twice.
+import stringWidth from 'string-width';
+import { truncateToWidth } from './ui-width.js';
+import { sanitizeControlChars } from './sanitize.js';
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** The longest grapheme-whole prefix of `word` that fits `cells` (at least one grapheme). */
+function takeCells(word, cells) {
+    let out = '';
+    let used = 0;
+    for (const { segment } of GRAPHEMES.segment(word)) {
+        const w = stringWidth(segment);
+        if (used + w > cells && out.length > 0)
+            break;
+        out += segment;
+        used += w;
+        if (used >= cells)
+            break;
+    }
+    return out;
+}
+/**
+ * `text` as the rows it is drawn on, each at most `cells` terminal cells.
+ * Control characters are neutralised, tabs become two spaces and newlines
+ * one space. Text that fits is one row, unchanged. Otherwise it wraps at
+ * spaces (a word wider than the row is cut where it must be; wide characters
+ * count two cells and are never split) onto at most `maxRows` rows; when
+ * more is left, the last row ends with the `more` glyph (… / ...). With
+ * `maxRows` 1 this is truncateToWidth: one row, cut.
+ */
+export function wrapRows(text, cells, maxRows = 1) {
+    const flat = sanitizeControlChars(text).replace(/\t/g, '  ').replace(/\r?\n/g, ' ');
+    const width = Math.max(1, cells);
+    const max = Math.max(1, Math.floor(maxRows));
+    if (stringWidth(flat) <= width)
+        return [flat];
+    if (max === 1)
+        return [truncateToWidth(flat, width)];
+    const indent = /^ */.exec(flat)[0].slice(0, Math.max(0, width - 1));
+    const rows = [];
+    let cur = indent;
+    const curEmpty = () => cur.length === 0 || cur === indent;
+    for (let word of flat.trim().split(/ +/).filter((w) => w.length > 0)) {
+        while (stringWidth(word) > width) {
+            if (!curEmpty()) {
+                rows.push(cur);
+                cur = '';
+            }
+            const head = takeCells(word, width - stringWidth(cur));
+            rows.push(cur + head);
+            cur = '';
+            word = word.slice(head.length);
+        }
+        if (word.length === 0)
+            continue;
+        if (curEmpty())
+            cur += word;
+        else if (stringWidth(cur) + 1 + stringWidth(word) <= width)
+            cur += ` ${word}`;
+        else {
+            rows.push(cur);
+            cur = word;
+        }
+    }
+    if (!curEmpty() || rows.length === 0)
+        rows.push(cur);
+    if (rows.length <= max)
+        return rows;
+    const kept = rows.slice(0, max);
+    // The trailing space guarantees a cut (and so the more glyph) even when the
+    // joined rest would happen to fit.
+    kept[max - 1] = truncateToWidth(`${rows.slice(max - 1).join(' ')} `, width);
+    return kept;
+}

package/dist/repl/rule8-detector.js

@@ -32,12 +32,13 @@ export function setRule8BatchApprovedProvider(fn) {
 }
 /**
  * True for a tool that cannot run without an approval id from request_approval
- * (its schema requires `approval_id`): each such call is already approved one
+ * (its schema requires `approval_id`, or `approval_ids` for a multi-object write): each such call is already approved one
  * by one. Shell, file and other tools without an id are never in this set.
  */
 export function toolSpendsApprovalId(tool) {
     const req = tool.input_schema?.required;
-    return Array.isArray(req) && req.includes('approval_id');
+    // RAP generator final review M4 — sap_generate_objects spends one id per object (`approval_ids`).
+    return Array.isArray(req) && (req.includes('approval_id') || req.includes('approval_ids'));
 }
 /**
  * Returns true on the 2nd (and later) mutating call of the turn — the gate

package/dist/repl.js

@@ -144,6 +144,7 @@ import { maybeExpandNumberSelection, lastAssistantText } from './repl/numbered-m
 import { attachEarlyLineBuffer, noopEarlyLineBuffer } from './repl/early-line-buffer.js';
 import { createRestoreGuard } from './repl/restore-guard.js';
 import { gracefulExit } from './lib/graceful-exit.js';
+import { endSapSessionAfterTurn } from './sap/session-end.js';
 import { snapshotTurnStart, pushPostTurnStatus, seedFooterSpend } from './repl/post-turn-status.js';
 import { looksLikeCspeachShellCommand, CSPEACH_SHELL_NUDGE } from './repl/cspeach-shell-detect.js';
 import { applyLocalBuildConfig, applyStandaloneFileTools } from './tools/local-build.js';
@@ -171,6 +172,9 @@ import './tools/cap/metadata-import.js';
 import './tools/cap/sap-link-tool.js';
 import './tools/cap/link-smoke.js';
 import './tools/lane/app-lane-resolve.js';
+import './tools/rap/skeleton-resolve.js';
+import './tools/rap/generate-objects.js';
+import './tools/rap/finish-check.js';
 import './tools/extend-model/tool.js';
 import './tools/text-elements/tools.js';
 import './tools/capability/tool.js';
@@ -1979,7 +1983,7 @@ export async function runRepl(opts) {
                     // Task 7 — plan-phase subagent read-only enforcement: set for EVERY
                     // plan-resume phase turn regardless of mode (guarded AND step);
                     // agent_run consults the flag and forces its read-only tool filter.
-                    setPlanPhaseActive(true, planPhaseCtx.envelope.id);
+                    setPlanPhaseActive(true, planPhaseCtx.envelope.id, planPhaseCtx.path);
                     // Task 10 — the writes declaration of the phase EXECUTING this turn
                     // (fail-safe: undefined ⇒ true, the deviation backstop never fires).
                     // request_approval consults it in guarded mode to deny undeclared
@@ -2118,6 +2122,9 @@ export async function runRepl(opts) {
                         planSubagentDispatches = getAndResetPlanPhaseSubagentDispatches();
                     }
                 }
+                // 2026-10-13 — end the stateful SAP session between turns, so a lock
+                // a failed write left behind does not outlive the turn (SM12).
+                await endSapSessionAfterTurn(adt);
             }
             // B3 — persist the plan revision from the resume turn's manifest
             // block (runs even after a turn error: partial assistant content is
@@ -3994,7 +4001,7 @@ export async function runRepl(opts) {
                 const { setPlanPhaseActive, setGuardedRunActive, setCurrentPhaseWrites, getAndResetPlanDeviation } = await import('./commands/plan-gate.js');
                 // Task 7 — plan-phase subagent read-only enforcement (classic mirror):
                 // set for EVERY plan-resume phase turn regardless of mode.
-                setPlanPhaseActive(true, planPhaseCtx.envelope.id);
+                setPlanPhaseActive(true, planPhaseCtx.envelope.id, planPhaseCtx.path);
                 // Task 10 — executing phase's writes declaration for the deviation
                 // backstop + stale-flag discard (classic mirror; see Ink path note).
                 setCurrentPhaseWrites(planPhaseCtx.nextPhaseWrites ?? true);
@@ -4117,6 +4124,8 @@ export async function runRepl(opts) {
                     planSubagentDispatches = getAndResetPlanPhaseSubagentDispatches();
                 }
             }
+            // 2026-10-13 — end the stateful SAP session between turns (Ink mirror).
+            await endSapSessionAfterTurn(adt);
         }
         // B3 — persist the plan revision from the resume turn's manifest block.
         // FALLBACK: skipped when the mid-turn onPlanManifest hook already saved it

package/dist/sap/connection-manager.js

@@ -3,8 +3,22 @@ import { SapConnection } from '@cspeach/sap-client';
 import { resolveSapTls } from '../config/loader.js';
 import { password as promptPassword } from '@inquirer/prompts';
 import { isHeadless } from '../renderer/tty.js';
+import { registerExitTask } from '../lib/graceful-exit.js';
+import { endSapSessions } from './session-end.js';
 const SAP_SERVICE = 'cspeach-sap';
 const cache = new Map();
+let exitTaskRegistered = false;
+/**
+ * 2026-10-13 — on exit, end the stateful SAP session of every connection this
+ * process opened, so locks left in it leave SM12 now instead of when SAP times
+ * the session out. Registered once, on the first connection.
+ */
+function registerSessionEndOnExit() {
+    if (exitTaskRegistered)
+        return;
+    exitTaskRegistered = true;
+    registerExitTask(() => endSapSessions(cache.values()));
+}
 /**
  * The single place that reads an SAP alias password: keychain first, then a
  * masked prompt when interactive. Headless callers (and the SAP link, which
@@ -69,6 +83,7 @@ export async function getConnection(alias, cfg) {
     // our existing cookies belong to a different one.
     await conn.login();
     cache.set(alias, conn);
+    registerSessionEndOnExit();
     return conn;
 }
 export function clearConnectionCache() {

package/dist/sap/generator-fact.js

@@ -0,0 +1,21 @@
+const cache = new Map();
+export async function getGeneratorFact(adt, alias) {
+    const hit = cache.get(alias);
+    if (hit)
+        return hit;
+    let r;
+    try {
+        r = await adt.hasRepositoryGenerators();
+    }
+    catch {
+        return 'unknown';
+    }
+    if (r === null)
+        return 'unknown';
+    const fact = r ? 'yes' : 'no';
+    cache.set(alias, fact);
+    return fact;
+}
+export function resetGeneratorFactCache() {
+    cache.clear();
+}

package/dist/sap/session-end.js

@@ -0,0 +1,66 @@
+/**
+ * Ending CSPeach's stateful SAP session (live finding 2026-10-13).
+ *
+ * Lock chains open a stateful ADT session on SAP. Nothing ended it, so any
+ * lock left inside it — after a failed write, or from a unit-test run — stayed
+ * in SM12 until SAP timed the session out, even after the CLI exited.
+ *
+ * When it is ended:
+ *   - after every TOP-LEVEL turn (the REPL), so a lock left by a failed write
+ *     never outlives the turn — except while a manual `sap_lock` is held,
+ *     because ending the session would silently drop that lock;
+ *   - on exit, for every connection, always (the process is going away).
+ *
+ * Both are capped so a slow or unreachable SAP never holds up the prompt or
+ * the exit, and neither ever throws. The next lock chain simply opens a fresh
+ * session (sap-client forgets the context cookie when it ends one).
+ */
+/** Longest we wait for SAP to confirm the session ended. */
+export const END_SESSION_CAP_MS = 3_000;
+let manualLocks = 0;
+/** A `sap_lock` call returned a handle. */
+export function noteManualLock() {
+    manualLocks += 1;
+}
+/** A `sap_unlock` call ran. */
+export function noteManualUnlock() {
+    manualLocks = Math.max(0, manualLocks - 1);
+}
+export function __resetManualLocksForTests() {
+    manualLocks = 0;
+}
+function capped(p, onTimeout) {
+    let timer;
+    return Promise.race([
+        p,
+        new Promise((r) => { timer = setTimeout(() => r(onTimeout), END_SESSION_CAP_MS); }),
+    ]).finally(() => { if (timer)
+        clearTimeout(timer); });
+}
+/** After a top-level turn: end the session unless a manual lock is still held. */
+export async function endSapSessionAfterTurn(client) {
+    // Duck-typed: the offline client and an older sap-client have no endSession.
+    const adt = client;
+    if (!adt || typeof adt.endSession !== 'function')
+        return { ended: false, skipped: 'no_client' };
+    if (manualLocks > 0)
+        return { ended: false, skipped: 'manual_lock' };
+    try {
+        return await capped(adt.endSession(), { ended: false, error: 'timeout' });
+    }
+    catch (e) {
+        return { ended: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+/** On exit: end the session of every connection, capped as a whole. */
+export async function endSapSessions(conns) {
+    const all = [...conns].map(async (c) => {
+        if (typeof c.endStatefulSession !== 'function')
+            return;
+        try {
+            await c.endStatefulSession();
+        }
+        catch { /* best effort on the way out */ }
+    });
+    await capped(Promise.all(all).then(() => undefined), undefined);
+}

package/dist/session/audit-export.js

@@ -59,6 +59,9 @@ const WRITE_TOOLS = new Set([
     // wrong silence.
     'sap_transport_create',
     'sap_transport_release',
+    // 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',
 ]);
 /**
  * Non-mutating tools that are interaction/plumbing, not object reads — excluded
@@ -189,6 +192,19 @@ function writeObject(tool, args, result) {
             const inc = str(args.includeType);
             return inc ? `${cls} (${inc})` : cls;
         }
+        case 'sap_generate_objects': {
+            // The generated objects live in the RESULT; a failed call names its decision file.
+            let r = {};
+            try {
+                r = asRecord(JSON.parse(result ?? ''));
+            }
+            catch { /* r stays {} */ }
+            const names = Array.isArray(r.objects) ? r.objects.map((o) => str(asRecord(o).name)).filter(Boolean) : [];
+            if (names.length)
+                return names.join(', ');
+            const d = str(args.decisionPath);
+            return d ? `RAP skeleton (${d})` : 'RAP skeleton';
+        }
         case 'sap_activate': {
             if (Array.isArray(args.objects)) {
                 const names = args.objects.map((o) => str(asRecord(o).name) ?? '?');
@@ -362,7 +378,9 @@ export function buildAuditReport(input) {
         L('| --- | --- | --- | :---: | --- | --- |');
         for (const c of writes) {
             const args = asRecord(c.args);
-            const approvalId = str(args.approval_id);
+            // sap_generate_objects carries one approval per object (approval_ids); pair the first.
+            const approvalId = str(args.approval_id)
+                ?? (Array.isArray(args.approval_ids) ? str(args.approval_ids[0]) : undefined);
             const rec = findApproval(approvalId, approvals);
             const key = snapshotKey(c.tool, args);
             const snap = key ? newestSnapshotBefore(snapIndex.get(key), Date.parse(tsOf(c))) : undefined;

package/dist/tools/ask-question.js

@@ -251,7 +251,7 @@ registerTool({
                         },
                         multiSelect: {
                             type: 'boolean',
-                            description: 'true = the user may pick several options; false/omitted = pick exactly one.',
+                            description: 'true = the user may pick several options; false/omitted = pick exactly one. When the user ticks options and also types an answer, it comes back as free text (custom: true): the ticked labels, then the typed text, comma-separated.',
                         },
                         options: {
                             type: 'array',