@cspeach/cli 1.1.52 → 1.1.53

package/dist/session/fresh-start.js

@@ -10,6 +10,10 @@ export function startFreshConversation(session) {
     // Word export (final-review m-4): the once-per-object save offers and the
     // export records describe the cleared conversation; they go with it.
     clearConversationRecords(session);
+    // Change options (1.1.53): the last document goes too; a level reply then routes as today.
+    session.lastChangeOptions = null;
+    // Task 16: a pending blocker-form note describes the cleared conversation.
+    delete session.blockerAnswersNote;
 }
 /** The one line /new prints. */
 export function freshStartText(lane) {

package/dist/session/user-prompt.js

@@ -35,6 +35,8 @@ export const INJECTED_CONTEXT_TAGS = [
     'session_context', 'project_context',
     // The /export docx conversation list (main, 2026-10-23): one list for both readers.
     'journey', 'lane_decision', 'system_switch', 'sap_system', 'sap_connection',
+    // Task 16 (F-M): the blocker form's note (it rides inside <session_context>).
+    'blocker_answers',
     'skill',
 ];
 /**

package/dist/tools/approval.js

@@ -579,7 +579,18 @@ registerTool({
                 const stopD = stoppedBeforeCard(ctx);
                 if (stopD)
                     return stopD;
-                outcome = await renderPerChangeApprovalV3(c, eff, displayTransport(c.op, args.transport, sessionTransport, c.owningTransport, project));
+                // 1.1.53 item 8 (live F-C): the batch risk put another object's reason
+                // on this card. Each card shows the risk of its own change, plus the
+                // activate of the same object that this card approves with it. One
+                // visible change keeps the batch risk, exactly as before. Display only:
+                // the gates above and the result fields keep `eff`.
+                const cardRisk = visibleCount <= 1 ? eff : effectiveRisk(declared, [
+                    c,
+                    ...((c.op === 'modify' || c.op === 'create')
+                        ? changes.filter((a) => a.op === 'activate' && `${a.type}:${canonicalApprovalObject(a.object)}` === objKey)
+                        : []),
+                ], riskCtx);
+                outcome = await renderPerChangeApprovalV3(c, cardRisk, displayTransport(c.op, args.transport, sessionTransport, c.owningTransport, project));
             }
             if (outcome.approved) {
                 if (c.op === 'modify' || c.op === 'create')

package/dist/tools/project/spec_answers_record.js

@@ -0,0 +1,190 @@
+/**
+ * spec_answers_record — record blocker answers the developer gives in chat
+ * (Task 18, F-O, 2026-10-26).
+ *
+ * Live: after "ok go ahead" the model ran `node -e` to edit the spec-gap
+ * `.cspeach.json` itself, inventing an `answeredBy`, and tripped the risky
+ * command card. This tool is the proper way: it runs the blocker form's own
+ * save step (saveBlockerAnswers: applyBlockerAnswers with the session's
+ * signed-in identity → validateEnvelope → write in place), so an answer
+ * recorded here is the same as one typed into the form.
+ *
+ * Path: resolved like file_read (teamReadTarget), so the folder-relative path
+ * the blocker note gives (`.cspeach/<name>.cspeach.json`) opens and saves the
+ * same file — in a team folder that is the seat copy. Containment and
+ * real-path checks are file_read's. Fix round 1: only a saved result the CLI
+ * writes (`.cspeach/<name>.cspeach.json`, isReadOnlyProjectFile), never the
+ * shared team `.cspeach` (teamReadTarget's fallback there is read-only), and
+ * only a spec-gap envelope.
+ *
+ * Every refusal is one line and writes nothing: a sub-agent or reader child,
+ * a path outside the project, a missing file, a file that is not a spec-gap
+ * envelope in `.cspeach/`, the shared team `.cspeach`, an unknown id, a blank
+ * answer or one over 2,000 characters, an id given twice, a revision that
+ * fails validation. Ruling R18: any question id in the file is accepted.
+ *
+ * Approvals: like file_write for project files — category 'filesystem', so no
+ * card and no Rule 8 batch count (isLocalProjectWork). Never touches SAP, so
+ * the chat lane allows it.
+ */
+import { promises as fs, realpathSync } from 'node:fs';
+import * as path from 'node:path';
+import { registerTool } from '../index.js';
+import { resolveSafePath, assertRealPathContained, PathOutsideRootError, isReadOnlyProjectFile, } from '../_filesystem-shared.js';
+import { pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamReadTarget } from '../_team-work-path.js';
+import { SPEC_ANSWERS_RECORD_TOOL } from '../../projects/blocker-answers-note.js';
+import { readProjectFile } from '../../projects/status.js';
+import { openBlockers, saveBlockerAnswers } from '../../projects/answer-blockers.js';
+export const SPEC_ANSWERS_RECORD = SPEC_ANSWERS_RECORD_TOOL;
+/** Fix round 1 (item 4): the longest answer recorded. */
+export const MAX_ANSWER = 2000;
+const QUESTION_MAX = 80;
+const NOTHING_SAVED = 'Nothing was saved.';
+const fail = (line) => ({ content: `error: ${line}`, is_error: true });
+function clip(text, max) {
+    const one = text.replace(/\s*[\r\n]+\s*/g, ' ').trim();
+    return one.length > max ? `${one.slice(0, max - 1).trimEnd()}…` : one;
+}
+/** The same identity loop.ts gives the blocker form (getAuthorIdentity). */
+async function sessionIdentity() {
+    const { getAuthorIdentity } = await import('../../agent/loop.js');
+    return getAuthorIdentity();
+}
+function realOr(p) {
+    try {
+        return realpathSync.native(p);
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+export async function specAnswersRecordHandler(args, ctx) {
+    // Fix round 1 (item 5): only the main conversation records answers (a child could race the form).
+    if (ctx.subagent || ctx.readerMode)
+        return fail(`answers are recorded in the main conversation only. ${NOTHING_SAVED}`);
+    if (typeof args.path !== 'string' || args.path.trim() === '') {
+        return fail(`give the path of the spec-gap file, for example .cspeach/<name>.cspeach.json. ${NOTHING_SAVED}`);
+    }
+    const given = args.path;
+    // The path as file_read opens it: in a team folder a saved result is the seat copy.
+    const t = teamReadTarget(ctx.cwd, given);
+    let real;
+    try {
+        real = await assertRealPathContained(resolveSafePath(t.root, t.path), t.root);
+    }
+    catch (err) {
+        if (err instanceof PathOutsideRootError)
+            return fail(`that path is outside the project folder. ${NOTHING_SAVED}`);
+        if (err.code === 'ENOENT')
+            return fail(`file not found: ${given}. ${NOTHING_SAVED}`);
+        return fail(`${err instanceof Error ? err.message : String(err)}. ${NOTHING_SAVED}`);
+    }
+    // Fix round 1 (item 2): never the shared team .cspeach — teamReadTarget's
+    // fallback to it is for reading only, as for the write tools.
+    if (pointsIntoSharedCspeach(ctx.cwd, real))
+        return fail(`${SHARED_CSPEACH_REFUSAL} ${NOTHING_SAVED}`);
+    // Fix round 1 (item 3): only a saved result the CLI writes (.cspeach/<name>.cspeach.json),
+    // the same shape file_read's denylist carve-out opens (lane files excluded).
+    if (!isReadOnlyProjectFile(real, t.root) || !/\.cspeach\.json$/i.test(real)) {
+        return fail(`${given} is not a spec-gap file. ${NOTHING_SAVED}`);
+    }
+    if (!(await fs.stat(real)).isFile())
+        return fail(`${given} is not a spec-gap file. ${NOTHING_SAVED}`);
+    let env;
+    try {
+        env = readProjectFile(real);
+    }
+    catch {
+        return fail(`${given} is not a spec-gap file. ${NOTHING_SAVED}`);
+    }
+    if (env.artefactType !== 'spec-gap')
+        return fail(`${given} is not a spec-gap file. ${NOTHING_SAVED}`);
+    // The answers: every id must be a question in the file (ruling R18: any
+    // question, not only blockers), with a non-blank answer of at most MAX_ANSWER.
+    const list = Array.isArray(args.answers) ? args.answers : null;
+    if (!list || list.length === 0)
+        return fail(`give at least one answer as { id, answer }. ${NOTHING_SAVED}`);
+    const knownIds = new Set(env.interaction.items.map((it) => it.id));
+    const answers = new Map();
+    const order = [];
+    const problems = [];
+    for (const entry of list) {
+        const id = entry && typeof entry === 'object' && typeof entry.id === 'string'
+            ? entry.id.trim() : '';
+        const raw = entry && typeof entry === 'object' ? entry.answer : undefined;
+        const answer = typeof raw === 'string' ? raw.trim() : '';
+        if (!id) {
+            problems.push('an answer has no id');
+            continue;
+        }
+        if (order.includes(id)) {
+            problems.push(`${id}: given twice`);
+            continue;
+        }
+        order.push(id);
+        if (!knownIds.has(id)) {
+            problems.push(`${id}: no question with this id in the file`);
+            continue;
+        }
+        if (!answer) {
+            problems.push(`${id}: the answer is blank`);
+            continue;
+        }
+        if (answer.length > MAX_ANSWER) {
+            problems.push(`${id}: the answer is longer than 2,000 characters`);
+            continue;
+        }
+        answers.set(id, answer);
+    }
+    if (problems.length > 0)
+        return fail(`${problems.join('; ')}. ${NOTHING_SAVED}`);
+    // The form's own save step: apply with the session identity, validate, write in place.
+    const saved = saveBlockerAnswers(real, env, answers, await sessionIdentity(), new Date().toISOString());
+    if (!saved.ok)
+        return fail(`the revised file did not validate (${saved.error}). ${NOTHING_SAVED}`);
+    const rel = path.relative(realOr(t.root), real).split(path.sep).join('/');
+    const open = openBlockers(saved.revised);
+    return {
+        content: [
+            `Saved in ${rel}.`,
+            ...order.map((id) => `${id}: recorded.`),
+            open.length === 0
+                ? 'No blockers are still open.'
+                : `Still open: ${open.map((b) => `${b.id} (${clip(b.text, QUESTION_MAX)})`).join(', ')}.`,
+        ].join('\n'),
+    };
+}
+registerTool({
+    name: SPEC_ANSWERS_RECORD,
+    description: 'Record answers the developer gives in chat to spec-gap questions, in the saved spec-gap file '
+        + '(.cspeach/<name>.cspeach.json): blockers or any question in the file. The file exists only once the document has been saved, after your turn. Give each question id as in the file '
+        + '(for example gap-004) with its answer, at most 2,000 characters. '
+        + 'Answering a question that already has an answer replaces it. Nothing is saved if any id or answer is refused. '
+        + 'Never edit .cspeach.json files with shell or file-edit tools. No SAP call.',
+    isMutating: true,
+    category: 'filesystem',
+    requiresSap: false,
+    input_schema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Folder-relative path of the spec-gap file, for example .cspeach/<name>.cspeach.json.',
+            },
+            answers: {
+                type: 'array',
+                description: 'One entry per question answered.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'The question id as in the file, for example gap-004.' },
+                        answer: { type: 'string', description: "The developer's answer, in their words." },
+                    },
+                    required: ['id', 'answer'],
+                },
+            },
+        },
+        required: ['path', 'answers'],
+    },
+    handler: (args, ctx) => specAnswersRecordHandler(args, ctx),
+});

package/dist/tools/tool-loading.js

@@ -63,6 +63,8 @@ export const SKILL_STARTERS = Object.freeze({
     // Both flag-gated (LOCAL_BUILD_TOOLS / STANDALONE_FILE_TOOLS): skipped when off.
     'abap-app': ['app_lane_resolve', 'read_document'],
     'abap-atc-fix': ['sap_atc_run'],
+    // Task 18 (F-O): blocker answers given in chat are recorded with this tool, never a file edit.
+    'abap-spec-gap': ['spec_answers_record'],
     'abap-cca': ['team_estate', 'sap_atc_run', 'sap_usage_references', 'sap_api_state'],
     'abap-clean-core': ['sap_api_state', 'sap_atc_run', 'sap_usage_references', 'team_findings', 'team_lane_move'],
     'abap-data-model': ['sap_create_domain', 'sap_create_data_element', ...SESSION_TRANSPORT],

package/dist/ui/approval-modal.js

@@ -17,6 +17,7 @@ import { useReclaimRawStdin } from './widgets/reclaim-raw-stdin.js';
 import { getLook } from '../renderer/look.js';
 import { roleProps, inkChip, legacyInkColor } from './role-props.js';
 import { wrapRows } from '../renderer/wrap-rows.js';
+import { decodeDisplayBlock } from '../renderer/html-entities.js';
 import { uiWidth } from '../renderer/ui-width.js';
 import { cardBorderStyle } from './ascii-chars.js';
 /**
@@ -109,7 +110,7 @@ export function ApprovalModal({ change, effectiveRisk, transport, onApply, onSki
     const backAt = useRef(0);
     const back = () => { backAt.current = Date.now(); setViewing(false); };
     const viewLines = viewing && aff && change.diff
-        ? (aff.key === 'd' ? change.diff.split('\n') : toSourceLines(change.diff))
+        ? (aff.key === 'd' ? decodeDisplayBlock(change.diff).split('\n') : toSourceLines(change.diff))
         : [];
     const lastTop = Math.max(0, viewLines.length - viewRows);
     useInput((input, key) => {

package/dist/ui/widgets/ask-card.js

@@ -22,7 +22,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * the text input is not focused) · Esc cancels; on the free-text row Esc
  * first returns to the options.
  */
-import { useMemo, useRef, useState } from 'react';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInput from '../text-input.js';
 import { useReclaimRawStdin } from './reclaim-raw-stdin.js';
@@ -34,14 +34,31 @@ import { sanitizeControlChars } from '../../renderer/sanitize.js';
 import { wrapRows } from '../../renderer/wrap-rows.js';
 import { answerDisplayText } from '../ask-answer-text.js';
 import { CardFrame } from './confirm-card.js';
+import { emitTrace } from '../../renderer/trace.js';
 /** Option rows visible at once — the rest scroll. */
 export const VISIBLE_OPTION_ROWS = 5;
 /**
  * Single-key cards (the Yes/No agent confirm) drop keys received in the first
  * GUARD_MS after mount, so a key typed ahead while output streamed cannot
  * answer the card.
+ *
+ * 1.1.53 Task 20 (F-P) — every card, keys or not, also ignores Enter, digit
+ * picks and alias keys for GUARD_MS after each screen appears (the card, each
+ * next question of a form, the Review step), so the Enter of a "pick, then
+ * Enter" habit cannot answer the card that comes next. Typing into the
+ * typed-answer row is never dropped.
  */
 const GUARD_MS = 150;
+/** Task 20 — the per-screen pick window; GUARD_MS outside tests. */
+let pickGuardMs = GUARD_MS;
+/**
+ * Test seam only: interaction tests that drive keys faster than a person can
+ * type set 0; undefined restores GUARD_MS. The window itself is pinned by
+ * ask-card-stray-enter.test.tsx. The y/n mount guard is not affected.
+ */
+export function setAskPickGuardMsForTest(ms) {
+    pickGuardMs = ms ?? GUARD_MS;
+}
 /**
  * Card text is model- or tool-supplied. Tabs and newlines are flattened by
  * truncateToWidth; every OTHER control character is neutralised by the
@@ -56,7 +73,12 @@ const sanitize = sanitizeControlChars;
 function fit(text, cells) {
     return truncateToWidth(sanitize(text), cells);
 }
-/** Round 4 item 8b — the question wraps up to this many rows, then is cut. */
+/**
+ * Round 4 item 8b — the question's base rows. 1.1.53 Task 14: no longer the
+ * cap. With a row budget (App) the current question grows past it to as many
+ * rows as it needs while the card still fits (askCardLayout); without one it
+ * shows whole. Only a question that still does not fit is cut.
+ */
 export const QUESTION_MAX_ROWS = 3;
 /** Context wraps too; it gets at least one row per line and at most this many in all (or its line count, if larger). */
 export const CONTEXT_MAX_ROWS = 6;
@@ -70,6 +92,8 @@ const DESCRIPTION_INDENT = '     ';
 export const CONTEXT_FOLDED_ROWS = 3;
 /** …and then the question to this many. */
 export const QUESTION_FOLDED_ROWS = 2;
+/** 1.1.53 Task 14 — the dim last row of a cut question; the whole question is printed in the scrollback above. */
+export const FULL_QUESTION_NOTE = 'The full question is printed above.';
 /** The question rows (at most `maxRows`), with the multi-select suffix kept whole on the last row. */
 function questionRows(question, suffix, cells, maxRows = QUESTION_MAX_ROWS) {
     if (!suffix)
@@ -87,6 +111,58 @@ function questionRows(question, suffix, cells, maxRows = QUESTION_MAX_ROWS) {
     }
     return rows;
 }
+/**
+ * 1.1.53 Task 14 — the question as plain wrapped text for the scrollback:
+ * each line of it wrapped at `cells`, nothing cut. Printed above the card
+ * when the card has to cut the question, so the person can read it whole.
+ */
+export function fullQuestionText(question, cells) {
+    return question.split(/\r?\n/).map((line) => wrapRows(line, cells, Number.MAX_SAFE_INTEGER).join('\n')).join('\n');
+}
+/** The multi-select suffix, when the width has room for it (kept whole on the question's last row). */
+function questionSuffix(q, cells) {
+    return q.multiSelect && cells - MULTI_SUFFIX.length >= 1 ? MULTI_SUFFIX : '';
+}
+/** Rows the whole question needs (suffix included). */
+function questionNeed(q, cells) {
+    // The layout asks this many times per render (folds, growth, estimate): memoised.
+    const key = `${cells}|${q.multiSelect ? 1 : 0}|${q.question}`;
+    let need = needCache.get(key);
+    if (need === undefined) {
+        need = questionRows(q.question, questionSuffix(q, cells), cells, Number.MAX_SAFE_INTEGER).length;
+        if (needCache.size >= 64)
+            needCache.clear();
+        needCache.set(key, need);
+    }
+    return need;
+}
+const needCache = new Map();
+/** Fix round 2 (I-1) — a cut question gets the pointer row only from this many rows; below, the old cut rows. */
+const POINTER_MIN_ROWS = 3;
+/**
+ * 1.1.53 Task 14 — the question as drawn in at most `cap` rows. It fits: the
+ * same rows as before. It does not: with `cap` of POINTER_MIN_ROWS or more it
+ * is cut to `cap - 1` rows and the last row is the FULL_QUESTION_NOTE pointer;
+ * with fewer (the short-screen fold) it is cut to `cap` rows exactly as
+ * before, no pointer. Either way the block is min(need, cap) rows tall, so
+ * the height math is today's.
+ */
+function questionBlock(q, cells, cap) {
+    // Memoised like questionNeed: the fold and growth loops ask for many caps.
+    const key = `${cells}|${q.multiSelect ? 1 : 0}|${cap}|${q.question}`;
+    const hit = blockCache.get(key);
+    if (hit)
+        return hit;
+    const suffix = questionSuffix(q, cells);
+    const block = questionNeed(q, cells) <= cap
+        ? { lines: questionRows(q.question, suffix, cells, cap), cut: false }
+        : { lines: questionRows(q.question, suffix, cells, cap >= POINTER_MIN_ROWS ? cap - 1 : cap), cut: true };
+    if (blockCache.size >= 256)
+        blockCache.clear();
+    blockCache.set(key, block);
+    return block;
+}
+const blockCache = new Map();
 /**
  * Context rows: every line keeps at least one row; wrapping fills the rest of
  * the budget. Folded (`maxRows` below CONTEXT_MAX_ROWS, Task 4) the context
@@ -108,6 +184,8 @@ function contextRows(context, cells, maxRows = CONTEXT_MAX_ROWS) {
     });
     return out;
 }
+/** The rows question `i` may take at `layout`. */
+const questionCap = (layout, i) => layout.questionRowsFor?.[i] ?? layout.questionRows;
 /**
  * Lay out one option at `inner` cells. The label wraps onto LABEL_MAX_ROWS
  * under its own text; the (recommended) / (default) suffix stays whole on
@@ -151,6 +229,17 @@ export function optionRows(o, idx, q, inner, layout) {
 }
 /** Rows one option takes on the card. */
 const optionHeight = (r) => r.label.length + r.description.length;
+/**
+ * 1.1.53 R16 — the digit 1-9 a key chunk stands for, or 0. Remote desktops,
+ * VDI, ConPTY and key drivers can deliver a digit and Enter as one chunk
+ * ("2\r"): it counts as the digit alone, and the newline goes with it (never
+ * on to a following card). Any other multi-byte chunk ("22", an arrow plus a
+ * digit) is no digit.
+ */
+function digitKey(input) {
+    const m = /^([1-9])[\r\n]*$/.exec(input);
+    return m ? Number(m[1]) : 0;
+}
 export function toCardQuestions(request) {
     if ('questions' in request) {
         return request.questions.map((q) => {
@@ -212,29 +301,31 @@ const suffixText = (r) => (r.rec ? REC : '') + (r.def ? DEFAULT_SUFFIX : '');
 const askInner = (width) => Math.max(1, width - 4);
 /** The frame's top and bottom edges. */
 const FRAME_ROWS = 2;
+/** The rows of one question's screen when its question may take `cap` rows. */
+function screenRows(q, chipRows, inner, layout, cap) {
+    const ctx = contextRows(q.context, inner, layout.contextRows).length;
+    const block = questionBlock(q, inner, cap);
+    const qRows = block.lines.length + (block.cut && cap >= POINTER_MIN_ROWS ? 1 : 0); // + the pointer row
+    let body = 2; // margin + the text input row
+    if (!q.freeText) {
+        // Every wrapped label and description row counts; with more options
+        // than the window shows, the tallest window of VISIBLE_OPTION_ROWS.
+        const heights = q.options.map((o, i) => optionHeight(optionRows(o, i, q, inner, layout)));
+        const span = Math.min(heights.length, VISIBLE_OPTION_ROWS);
+        let tallest = 0;
+        for (let start = 0; start + span <= heights.length; start++) {
+            tallest = Math.max(tallest, heights.slice(start, start + span).reduce((x, y) => x + y, 0));
+        }
+        const arrows = q.options.length > VISIBLE_OPTION_ROWS ? 2 : 0;
+        body = 1 + tallest + arrows + (q.otherRow ? 1 : 0);
+    }
+    return chipRows + qRows + ctx + body + 1 + FRAME_ROWS; // question + body + hint + frame
+}
 /** The card's rows at `layout` — worst case over every question screen, plus the Review screen. */
 function askRowsFor(qs, inner, layout) {
     const chipRows = qs.length > 1 ? 2 : 0; // tab row + its blank line
     let worst = 0;
-    for (const q of qs) {
-        const ctx = contextRows(q.context, inner, layout.contextRows).length;
-        const suffix = q.multiSelect && inner - MULTI_SUFFIX.length >= 1 ? MULTI_SUFFIX : '';
-        const qRows = questionRows(q.question, suffix, inner, layout.questionRows).length;
-        let body = 2; // margin + the text input row
-        if (!q.freeText) {
-            // Every wrapped label and description row counts; with more options
-            // than the window shows, the tallest window of VISIBLE_OPTION_ROWS.
-            const heights = q.options.map((o, i) => optionHeight(optionRows(o, i, q, inner, layout)));
-            const span = Math.min(heights.length, VISIBLE_OPTION_ROWS);
-            let tallest = 0;
-            for (let start = 0; start + span <= heights.length; start++) {
-                tallest = Math.max(tallest, heights.slice(start, start + span).reduce((x, y) => x + y, 0));
-            }
-            const arrows = q.options.length > VISIBLE_OPTION_ROWS ? 2 : 0;
-            body = 1 + tallest + arrows + (q.otherRow ? 1 : 0);
-        }
-        worst = Math.max(worst, chipRows + qRows + ctx + body + 1 + FRAME_ROWS); // question + body + hint + frame
-    }
+    qs.forEach((q, i) => { worst = Math.max(worst, screenRows(q, chipRows, inner, layout, questionCap(layout, i))); });
     if (qs.length > 1) {
         // title + one row per answer + margin + choices + hint + frame
         worst = Math.max(worst, chipRows + 1 + qs.length + 1 + REVIEW_CHOICES.length + 1 + FRAME_ROWS);
@@ -256,10 +347,12 @@ export function askCardLayout(request, showDescriptions, width = uiWidth(), maxR
         contextRows: CONTEXT_MAX_ROWS,
         questionRows: QUESTION_MAX_ROWS,
     };
-    if (maxRows === undefined)
-        return layout;
     const qs = toCardQuestions(request);
     const inner = askInner(width);
+    // 1.1.53 Task 14 — no budget: every question shows whole.
+    if (maxRows === undefined) {
+        return { ...layout, questionRowsFor: qs.map((q) => Math.max(layout.questionRows, questionNeed(q, inner))) };
+    }
     const folds = [
         (l) => { l.labelRows = 1; },
         (l) => { l.descriptionRows = Math.min(l.descriptionRows, 1); },
@@ -272,6 +365,21 @@ export function askCardLayout(request, showDescriptions, width = uiWidth(), maxR
             break;
         fold(layout);
     }
+    // 1.1.53 Task 14 — then each question grows to the rows it needs while its
+    // screen still fits maxRows. What still does not fit stays cut (the AskCard
+    // prints it whole above). The question block is min(need, cap) rows tall
+    // (questionBlock), so the rest of the screen is measured once at the base
+    // and the cap follows directly (fix round 2, I-2 — no per-row re-wrap).
+    const chipRows = qs.length > 1 ? 2 : 0;
+    const base = layout.questionRows;
+    layout.questionRowsFor = qs.map((q) => {
+        const need = questionNeed(q, inner);
+        if (need <= base)
+            return base;
+        const rest = screenRows(q, chipRows, inner, layout, base) - base; // everything but the question
+        const room = maxRows - rest;
+        return need <= room ? need : Math.max(base, room);
+    });
     return layout;
 }
 /**
@@ -320,6 +428,9 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
     // while output streamed must not answer the card.
     const mountGuard = questions.some((qq) => qq.keys !== undefined);
     const mountedAt = useRef(Date.now());
+    // Task 20 — when the current screen appeared (reset on every focus change).
+    const screenAt = useRef(Date.now());
+    const pickGuarded = () => Date.now() - screenAt.current < pickGuardMs;
     const done = useRef(false);
     // Focus slots: 0..n-1 = questions; n = the Review step (2+ questions,
     // reachable only once every question has an answer).
@@ -329,6 +440,16 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
     const [drafts, setDrafts] = useState(() => questions.map(() => ''));
     const [answers, setAnswers] = useState(() => questions.map(() => null));
     const [reviewCursor, setReviewCursor] = useState(0);
+    const firstScreen = useRef(true);
+    useLayoutEffect(() => {
+        if (firstScreen.current) {
+            firstScreen.current = false;
+            return;
+        }
+        screenAt.current = Date.now();
+    }, [focus]);
+    // 1.1.53 Task 14 — questions already printed whole to the scrollback.
+    const printedFull = useRef(new Set());
     const isReview = n > 1 && focus === n;
     const q = isReview ? undefined : questions[focus];
     const cursor = q ? cursors[focus] : 0;
@@ -421,6 +542,8 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
             answerAndAdvance(focus, opt.value);
     };
     const onTextSubmit = (v) => {
+        if (pickGuarded())
+            return; // Task 20 — a stray Enter does not submit the row
         const trimmed = v.trim();
         if (trimmed.length === 0) {
             if (!isForm)
@@ -483,11 +606,15 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
                 setReviewCursor(1);
                 return;
             }
-            if (input === '1' || (key.return && reviewCursor === 0)) {
+            // R16 — "1\r" / "2\n" in one chunk act like the bare digit.
+            const reviewDigit = digitKey(input);
+            if (pickGuarded() && (reviewDigit > 0 || key.return))
+                return; // Task 20
+            if (reviewDigit === 1 || (key.return && reviewCursor === 0)) {
                 submit(answers);
                 return;
             }
-            if (input === '2' || (key.return && reviewCursor === 1)) {
+            if (reviewDigit === 2 || (key.return && reviewCursor === 1)) {
                 cancel();
                 return;
             }
@@ -510,11 +637,14 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
             return;
         // Ctrl+Y / Meta+Y are not "y": only a bare key answers.
         const alias = key.ctrl || key.meta ? undefined : q.keys?.[input.toLowerCase()];
+        // Task 20 — Enter, digit picks and alias keys wait out the screen's window.
+        if (pickGuarded() && (alias !== undefined || digitKey(input) > 0 || key.return))
+            return;
         if (alias !== undefined && q.options.some((o) => o.value === alias)) {
             answerAndAdvance(focus, alias);
             return;
         }
-        const digit = /^[1-9]$/.test(input) ? Number(input) - 1 : -1;
+        const digit = digitKey(input) - 1;
         if (digit >= 0) {
             if (digit >= rowCount)
                 return;
@@ -545,6 +675,19 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
     const frameHeader = isForm ? request.frameHeader : undefined;
     // The same fold as estimateAskCardRows, so the drawn card is the estimated card.
     const layout = askCardLayout(request, showDescriptions, width, maxRows);
+    // 1.1.53 Task 14 — a question the card has to cut is printed whole, once,
+    // to the scrollback just above the card (where answered questions land),
+    // when it becomes the current question. A question that fits prints
+    // nothing. Classic / headless have no trace emitter: emitTrace is a no-op.
+    const block = q ? questionBlock(q, inner, questionCap(layout, focus)) : undefined;
+    const questionCut = block?.cut === true;
+    const showPointer = questionCut && questionCap(layout, focus) >= POINTER_MIN_ROWS;
+    useEffect(() => {
+        if (!q || !questionCut || printedFull.current.has(focus))
+            return;
+        printedFull.current.add(focus);
+        emitTrace(fullQuestionText(q.question, inner));
+    }, [q, questionCut, focus, inner]);
     const chipRow = n > 1 ? (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { wrap: "truncate-end", children: fitSegments([
                 ...questions.map((qq, i) => ({
                     text: `${i > 0 ? '  ' : ''}${answers[i] !== null ? g.answered : g.pending} ${fit(qq.header, inner)}`,
@@ -574,8 +717,7 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
     const hintKind = q.freeText ? 'text' : onOther ? 'other' : q.multiSelect ? 'multi' : 'pick';
     // The multi-select suffix is the card's only multi cue: it stays whole and
     // the question is cut instead (the same rule as "(recommended)" below).
-    const suffix = q.multiSelect && inner - MULTI_SUFFIX.length >= 1 ? MULTI_SUFFIX : '';
-    const questionLines = questionRows(q.question, suffix, inner, layout.questionRows);
+    const questionLines = block.lines;
     const hint = askCardHint(hintKind, {
         multiQuestion: n > 1,
         count: rowCount,
@@ -583,7 +725,7 @@ export function AskCard({ request, width, showDescriptions, maxRows, onResolveV1
     });
     // Task 4 — the same frame as ConfirmCard: QUESTION tag (plus the optional
     // header) on the top edge, the hint right under the options.
-    return (_jsxs(CardFrame, { tag: "QUESTION", header: frameHeader, width: width, children: [chipRow, questionLines.map((line, i) => (_jsx(Text, { bold: true, wrap: "truncate-end", children: line }, `q-${i}`))), contextLines.map((line, i) => (_jsx(Text, { ...dim, wrap: "truncate-end", children: line }, `ctx-${i}`))), q.freeText ? (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { ...roleProps('sap'), children: `${g.cursor} ` }), _jsx(TextInput, { value: drafts[focus], onChange: setDraft, onSubmit: onTextSubmit, maxDisplayWidth: inputWidth })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [winStart > 0 && _jsx(Text, { ...dim, wrap: "truncate-end", children: `  ↑ ${winStart} more` }), visible.map((o, vi) => {
+    return (_jsxs(CardFrame, { tag: "QUESTION", header: frameHeader, width: width, children: [chipRow, questionLines.map((line, i) => (_jsx(Text, { bold: true, wrap: "truncate-end", children: line }, `q-${i}`))), showPointer ? _jsx(Text, { ...dim, wrap: "truncate-end", children: fit(FULL_QUESTION_NOTE, inner) }) : null, contextLines.map((line, i) => (_jsx(Text, { ...dim, wrap: "truncate-end", children: line }, `ctx-${i}`))), q.freeText ? (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { ...roleProps('sap'), children: `${g.cursor} ` }), _jsx(TextInput, { value: drafts[focus], onChange: setDraft, onSubmit: onTextSubmit, maxDisplayWidth: inputWidth })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [winStart > 0 && _jsx(Text, { ...dim, wrap: "truncate-end", children: `  ↑ ${winStart} more` }), visible.map((o, vi) => {
                         const idx = winStart + vi;
                         const cur = !onOther && idx === cursor;
                         const tick = q.multiSelect ? `${ticks[focus].has(o.value) ? g.tickOn : g.tickOff} ` : '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.52",
+  "version": "1.1.53",
   "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.2",
-    "@cspeach/sap-client": "0.1.30",
+    "@cspeach/sap-client": "0.1.31",
     "@iarna/toml": "^2.2.5",
     "@inkjs/ui": "^2.0.0",
     "@inquirer/prompts": "^7.0.0",