@cspeach/cli 1.1.34 → 1.1.35

package/dist/agent/loop.js

@@ -227,50 +227,140 @@ export async function inkAwareConfirm(q, opts) {
     return 'n';
 }
 /**
- * Choices picker for an answer-blocker that carries `options`. Renders the
- * native Ink AskCard (the same CC-style picker the ask_question tool
- * uses) with the candidate answers plus "Write my own" and "Skip" escapes.
+ * The picker for one spec-gap blocker (Task 3, 2026-10-12). It asks through
+ * the normal question path: a one-question v2 form, the same shape the
+ * ask_question tool sends, drawn by AskCard.
  *
- * - headless  → skip (never blocks on stdin)
- * - classic (non-Ink) → 'write' so the caller falls back to the free-text box
- * - Ink → choice/multi modal; Esc or empty selection → skip
+ * - "Blocker 2 of 4" on the card frame's top edge (Task 4); the question is the bare text
+ * - Ctrl+C on the card → { kind: 'stop' }: the remaining blockers are not asked
+ * - options show in sentence case (the stored answer keeps the words as
+ *   written), then a plain "Skip for now" option; the card's own inline
+ *   "Type something else…" row takes a typed answer, so no second text card
+ * - a blocker with no options is a free-text form question (Esc skips)
+ * - asked under the card-slot focus claim; one scrollback line per answer
+ *   ("Blocker 2 of 4 → <answer>"), so answered blockers stay on screen
+ * - headless → skip (never blocks); classic (non-Ink) → 'write' (free text)
  *
- * The two sentinels are filtered out of any real picked answer; for multi-select
- * the modal returns comma-joined values, so Write/Skip win over any co-selected
- * options.
+ * Option values are index ids (o0, o1…) so an option with a comma survives a
+ * multi-select answer (comma-joined values).
  */
-const CHOOSE_WRITE = '__cspeach_write__';
 const CHOOSE_SKIP = '__cspeach_skip__';
+const SKIP_LABEL = 'Skip for now';
+const SKIP_DESCRIPTION = 'Stays open. Answer it later at cspeach.dev/edit.';
+const SKIPPED_TRACE = 'skipped for now';
+const STOPPED_TRACE = 'stopped';
+/**
+ * A first word that is a name, not prose (Task 4, m1): it holds _ / digits /
+ * a slash (zcl_foo, s4hk903359, zfin/pkg), is all capitals (ZTEST_LAS, ERDAT)
+ * or has a capital after its first letter (eTag). Such a word is never recased.
+ */
+const Z_Y_ENGLISH = new Set(['yes', 'you', 'your', 'yours', 'yet', 'year', 'years', 'yearly', 'yield', 'zero', 'zone', 'zones', 'zoom']);
+function looksLikeIdentifier(word) {
+    if (/[_\d/]/.test(word))
+        return true;
+    // A Z/Y customer-namespace name (zfin, ytools) unless it is a common English word.
+    if (/^[zy][a-z0-9_]{2,}$/i.test(word) && !Z_Y_ENGLISH.has(word.toLowerCase()))
+        return true;
+    if (/[A-Z]/.test(word.slice(1)))
+        return true;
+    return word.length > 1 && /[A-Z]/.test(word) && word === word.toUpperCase();
+}
+/** First letter upper case when it is a lower-case letter; the rest as written. Identifiers stay as written. */
+function sentenceCase(label) {
+    const first = label.charAt(0);
+    if (first === first.toUpperCase())
+        return label;
+    if (looksLikeIdentifier(label.split(/\s/, 1)[0] ?? ''))
+        return label;
+    return first.toUpperCase() + label.slice(1);
+}
 export async function inkAwareChoose(a) {
     const { shouldUseInk, isHeadless } = await import('../renderer/tty.js');
     if (isHeadless())
         return { kind: 'skip' };
     if (!shouldUseInk())
         return { kind: 'write' }; // classic REPL → free-text fallback
-    const choices = [
-        ...a.options.map((o) => ({ value: o, label: o })),
-        { value: CHOOSE_WRITE, label: '✏️  Write my own…' },
-        { value: CHOOSE_SKIP, label: '↷  Skip (leave for the viewer)' },
+    const header = `Blocker ${a.index + 1} of ${a.total}`;
+    const freeText = a.options.length === 0;
+    const options = freeText ? [] : [
+        ...a.options.map((o, i) => ({ value: `o${i}`, label: sentenceCase(o) })),
+        { value: CHOOSE_SKIP, label: SKIP_LABEL, description: SKIP_DESCRIPTION },
     ];
     const { askQuestionEmitter } = await import('../ui/ask-question-emitter.js');
-    const res = await askQuestionEmitter.request({
-        id: 'answer-blocker',
-        question: `Blocker ${a.index + 1}/${a.total}: ${a.question}`,
-        context: a.multiSelect ? 'Space to toggle one or more · Enter to submit' : undefined,
-        kind: a.multiSelect ? 'multi' : 'choice',
-        choices,
-    });
-    if (res.cancelled || res.answer == null)
-        return { kind: 'skip' };
-    const values = res.answer.split(',');
-    if (values.includes(CHOOSE_WRITE))
-        return { kind: 'write' };
-    if (values.includes(CHOOSE_SKIP))
+    const { withFocusClaim } = await import('../ui/card-slot.js');
+    const { emitTrace, formatAnswerTrace } = await import('../renderer/trace.js');
+    const { uiWidth } = await import('../renderer/ui-width.js');
+    let stopped = false;
+    const res = await withFocusClaim(() => askQuestionEmitter.requestForm({
+        formId: 'answer-blocker',
+        // Task 4 (m4): the counter sits on the frame's top edge.
+        frameHeader: header,
+        // Task 4 (m2): Ctrl+C stops the remaining blocker cards.
+        onInterrupt: () => { stopped = true; },
+        questions: [{
+                id: 'answer-blocker',
+                question: a.question,
+                ...(freeText ? { context: 'Esc skips it for now' } : {}),
+                header,
+                multiSelect: !freeText && a.multiSelect,
+                freeText,
+                options,
+            }],
+    }));
+    const skip = () => {
+        emitTrace(formatAnswerTrace(header, SKIPPED_TRACE, uiWidth()));
         return { kind: 'skip' };
-    const real = values.filter((v) => v !== CHOOSE_WRITE && v !== CHOOSE_SKIP);
-    if (real.length === 0)
-        return { kind: 'skip' };
-    return { kind: 'picked', answer: real.join(', ') };
+    };
+    if (stopped) {
+        emitTrace(formatAnswerTrace(header, STOPPED_TRACE, uiWidth()));
+        return { kind: 'stop' };
+    }
+    const ans = res.cancelled ? undefined : res.answers[0];
+    if (!ans || ans.answer == null)
+        return skip();
+    let answer;
+    let shown;
+    if (freeText) {
+        answer = ans.answer.trim();
+        shown = answer;
+    }
+    else if (ans.custom) {
+        // Task 4 (m3): a multi-select typed answer arrives as the ticked labels
+        // (in option order), then the typed words. The labels go back to the
+        // options as written; a ticked "Skip for now" gives way to the answer.
+        let rest = ans.answer.trim();
+        const parts = [];
+        const shownParts = [];
+        if (a.multiSelect) {
+            for (const o of options) {
+                if (!rest.startsWith(`${o.label}, `))
+                    continue;
+                rest = rest.slice(o.label.length + 2);
+                const i = /^o(\d+)$/.exec(o.value);
+                if (i) {
+                    parts.push(a.options[Number(i[1])]);
+                    shownParts.push(o.label);
+                }
+            }
+        }
+        answer = [...parts, rest].join(', ');
+        shown = [...shownParts, rest].join(', ');
+    }
+    else {
+        const values = ans.answer.split(',');
+        if (values.includes(CHOOSE_SKIP))
+            return skip();
+        const picked = values
+            .map((v) => /^o(\d+)$/.exec(v))
+            .map((m) => (m ? a.options[Number(m[1])] : undefined))
+            .filter((o) => o !== undefined);
+        answer = picked.join(', ');
+        shown = picked.map(sentenceCase).join(', ');
+    }
+    if (answer.length === 0)
+        return skip();
+    emitTrace(formatAnswerTrace(header, shown, uiWidth()));
+    return { kind: 'picked', answer };
 }
 export async function maybeOfferSave(p) {
     if (p.assistantText.trim().length === 0)

package/dist/lib/graceful-exit.js

@@ -31,6 +31,20 @@ function call(fn, self) {
         return Promise.reject(e);
     }
 }
+/**
+ * 2026-10-13 — async work that must run on the way out, before the sockets
+ * close (ending the stateful SAP session, so its locks leave SM12). Capped as
+ * a whole; a task that throws or hangs never blocks the exit.
+ */
+const exitTasks = new Set();
+/** Register an async exit task. Returns an unregister. */
+export function registerExitTask(task) {
+    exitTasks.add(task);
+    return () => { exitTasks.delete(task); };
+}
+export function __resetExitTasksForTests() {
+    exitTasks.clear();
+}
 export async function gracefulExit(code, opts = {}) {
     const exit = opts.exit ?? ((c) => process.exit(c));
     const graceMs = opts.graceMs ?? 250;
@@ -38,6 +52,9 @@ export async function gracefulExit(code, opts = {}) {
     const guard = () => { };
     process.on('unhandledRejection', guard);
     try {
+        if (exitTasks.size > 0) {
+            await capped(Promise.allSettled([...exitTasks].map((t) => call(t, {}))), opts.exitTaskMs ?? 3_500);
+        }
         const dispatcher = globalThis[UNDICI_DISPATCHER];
         if (dispatcher) {
             let done = false;

package/dist/projects/answer-blockers.js

@@ -59,6 +59,9 @@ export function applyBlockerAnswers(env, answers, answerer, nowIso) {
         lastEditedBy: answerer,
     };
 }
+function plural(n, word) {
+    return `${n} ${word}${n === 1 ? '' : 's'}`;
+}
 function affirmative(reply) {
     const v = reply.trim().toLowerCase();
     return v === 'y' || v === 'yes';
@@ -83,7 +86,9 @@ export async function offerAnswerBlockers(args) {
     if (blockers.length === 0)
         return null;
     const reply = await askYesNo({
-        question: `Answer the ${blockers.length} unanswered blocker(s) now?`,
+        question: blockers.length === 1
+            ? 'Answer the open blocker now?'
+            : `Answer the ${blockers.length} open blockers now?`,
         confirm: args.confirm,
         prompt: args.prompt,
     });
@@ -92,16 +97,15 @@ export async function offerAnswerBlockers(args) {
     const answers = new Map();
     for (let i = 0; i < blockers.length; i++) {
         const b = blockers[i];
-        // 2026-09-17 — the "Blocker i/n: …" line is printed only on the free-text
-        // path below. When a picker handles the question it shows the same text
-        // itself, and printing it here too showed every blocker twice.
-        // Choices first, where the question has them and a picker is available.
+        // The "Blocker i of n: …" line is printed only on the free-text fallback
+        // below. The picker shows the question itself and leaves its own trace.
+        // The picker first, for every blocker (options or free text).
         // 'write' falls through to the text box; 'skip' leaves the blocker open.
         let askText = true;
-        if (b.options && b.options.length > 0 && args.choose) {
+        if (args.choose) {
             const c = await args.choose({
                 question: b.text,
-                options: b.options,
+                options: b.options ?? [],
                 multiSelect: !!b.multiSelect,
                 index: i,
                 total: blockers.length,
@@ -114,19 +118,26 @@ export async function offerAnswerBlockers(args) {
             else if (c.kind === 'skip') {
                 askText = false;
             }
+            else if (c.kind === 'stop') {
+                // Ctrl+C (Task 4, m2): ask none of the rest. Answers already given
+                // are kept and saved below; the others stay open.
+                break;
+            }
             // c.kind === 'write' → askText stays true
         }
         if (askText) {
             args.log('');
-            args.log(`Blocker ${i + 1}/${blockers.length}: ${b.text}`);
-            const a = (await args.prompt('  Your answer (Enter to skip): ')).trim();
+            args.log(`Blocker ${i + 1} of ${blockers.length}: ${b.text}`);
+            const a = (await args.prompt('Your answer (Enter to skip): ')).trim();
             if (a.length > 0)
                 answers.set(b.id, a);
         }
     }
     if (answers.size === 0) {
         args.log('');
-        args.log('No answers entered — all blockers left open for the viewer.');
+        args.log(blockers.length === 1
+            ? 'No answer entered. The blocker stays open. Answer it later at cspeach.dev/edit.'
+            : `No answers entered. The ${blockers.length} blockers stay open. Answer them later at cspeach.dev/edit.`);
         return null;
     }
     const nowIso = (args.now ?? (() => new Date().toISOString()))();
@@ -139,7 +150,9 @@ export async function offerAnswerBlockers(args) {
     writeFileSync(args.path, JSON.stringify(revised, null, 2), 'utf8');
     const stillOpen = blockers.length - answers.size;
     args.log('');
-    args.log(`Recorded ${answers.size} answer(s) in the file`
-        + (stillOpen > 0 ? ` — ${stillOpen} blocker(s) still open for the viewer.` : '.'));
+    args.log(`Recorded ${plural(answers.size, 'answer')} in the file.`
+        + (stillOpen === 0 ? ''
+            : stillOpen === 1 ? ' 1 blocker is still open. Answer it later at cspeach.dev/edit.'
+                : ` ${stillOpen} blockers are still open. Answer them later at cspeach.dev/edit.`));
     return answers.size;
 }

package/dist/renderer/change-card.js

@@ -6,10 +6,11 @@
 import { diffLines } from 'diff';
 import { paint } from './theme.js';
 import { getBoxChars } from '../ui/ascii-chars.js';
+import { ERROR_DETAIL_ROWS, SNAPSHOT_DETAIL_ROWS } from './verify-chain.js';
 import { ANSI_RE } from './tool-labels.js';
+import { wrapRows } from './wrap-rows.js';
 export const MIN_CARD_WIDTH = 40;
 const DIFF_LINES = 6;
-const DETAIL_MAX = 60;
 /** Myers diff is O(N·D) and synchronous: past this budget we show no diff
  *  at all (object + footer only), never a partial one. */
 const DIFF_TIMEOUT_MS = 200;
@@ -33,7 +34,7 @@ function footerParts(input) {
     else if (input.snapshot === 'new_object')
         parts.push(paint('dim', '– snapshot (new object)'));
     else if (input.snapshot === 'source_read_failed')
-        parts.push(paint('dim', `– snapshot (no source read${input.snapshotDetail ? ': ' + cut(flat(clean(input.snapshotDetail)), 40) : ''})`));
+        parts.push(paint('dim', '– snapshot (no source read)'));
     else
         parts.push(paint('dim', '– snapshot (skipped)'));
     parts.push(input.written ? `${paint('ok', '✓')} written` : `${paint('bad', '✗')} written`);
@@ -54,15 +55,35 @@ function footerParts(input) {
         else if (a.state === 'unverified')
             parts.push(paint('warn', '· activation unverified'));
         else
-            parts.push(`${paint('bad', '✗')} activation${a.detail ? ' ' + paint('bad', `(${cut(flat(clean(a.detail)), DETAIL_MAX)})`) : ''}`);
+            parts.push(`${paint('bad', '✗')} activation`);
     }
     else {
         // Activation is blocked — say so; a pending step would lie.
-        parts.push(`${paint('bad', '✗')} syntax ${paint('bad', `(${cut(flat(clean(input.syntax.errors[0] ?? 'syntax errors')), DETAIL_MAX)})`)}`);
+        parts.push(`${paint('bad', '✗')} syntax`);
         parts.push(paint('dim', '· activation blocked'));
     }
     return parts;
 }
+/**
+ * Fix batch 2026-10-12 (Task 2): the reasons behind a failed step — the
+ * snapshot read failure, the first syntax error, SAP's activation refusal —
+ * are what the user needs, so they are rows of their own (wrapped at word
+ * breaks to `cells`, up to the verify-chain caps), never cut on the footer.
+ */
+function detailLines(input, cells) {
+    const out = [];
+    const wrap = (text, rows) => wrapRows(flat(clean(text)), Math.max(1, cells), rows);
+    if (input.snapshot === 'source_read_failed' && input.snapshotDetail) {
+        out.push(...wrap(`No source read: ${input.snapshotDetail}`, SNAPSHOT_DETAIL_ROWS).map((r) => paint('dim', r)));
+    }
+    if (input.syntax !== 'not_checked' && !input.syntax.ok) {
+        out.push(...wrap(input.syntax.errors[0] ?? 'syntax errors', ERROR_DETAIL_ROWS).map((r) => paint('bad', r)));
+    }
+    else if (input.syntax !== 'not_checked' && input.activation?.state === 'failed' && input.activation.detail) {
+        out.push(...wrap(input.activation.detail, ERROR_DETAIL_ROWS).map((r) => paint('bad', r)));
+    }
+    return out;
+}
 /** Changed lines for the card. Exported for tests only. */
 export function diffBody(card, differ = defaultDiffer) {
     if (card.oldSource === undefined || card.newSource === undefined)
@@ -99,6 +120,7 @@ export function buildChangeCard(input, width, box = getBoxChars()) {
         // cut to the width so nothing wraps (colour dropped only on a cut part).
         for (const p of parts)
             out.push(visibleLen(p) > width ? cut(p.replace(ANSI, ''), width) : p);
+        out.push(...detailLines(input, width));
         if (card.transport)
             out.push(paint('dim', cut(`· ${clean(card.transport)}`, width)));
         return out.join('\n');
@@ -117,6 +139,8 @@ export function buildChangeCard(input, width, box = getBoxChars()) {
         lines.push(row(paint(l.startsWith('+') ? 'ok' : 'bad', cut(l, inner))));
     if (body.hidden > 0)
         lines.push(row(paint('dim', `  … +${body.hidden} lines`)));
+    for (const d of detailLines(input, inner))
+        lines.push(row(d));
     lines.push(...footerLines(parts, chain, transportText, width, b, row));
     return lines.join('\n');
 }

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

@@ -177,7 +177,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: '' }),
@@ -257,7 +263,7 @@ const PRESENT = {
     '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');
 }