@cspeach/cli 1.1.17 → 1.1.19

package/dist/tools/fiori/ui5-version.js

@@ -0,0 +1,16 @@
+// cspeach-cli/src/tools/fiori/ui5-version.ts
+//
+// THE one pinned UI5 version: the default both scaffolds write into
+// manifest.json (minUI5Version) and the version the offline smoke harness
+// serves (test-harness/fe-draft/routes.ts imports it as its "newest" pin).
+//
+// Why an exact, hosted patch and never an `x.y.0` guess: fiori-tools-proxy
+// fetches `https://ui5.sap.com/<minUI5Version>/resources/...` verbatim, and SAP
+// removes old patch releases from that CDN. The old default `1.120.0` was gone
+// on 2026-09-21 (sap/m/library.js → 404): every freshly scaffolded app booted
+// to a blank page. When SAP retires this patch too, bump the patch — the
+// smoke-e2e run fails with a message pointing here.
+//
+// Why 1.120: the S/4HANA 2023-era LTS; it parses the hyphenated
+// `data-sap-ui-on-init` bootstrap attribute the writers emit (1.71 does not).
+export const PINNED_UI5_VERSION = '1.120.51';

package/dist/tools/index.js

@@ -20,6 +20,14 @@ export function listTools() {
     // always returned, preserving today's listTools() semantics exactly.
     return Array.from(registry.values()).filter((t) => !t.flagGated || isToolFlagOn(t.name));
 }
+/**
+ * Every registered tool, flag-gated ones included (no visibility filter).
+ * For coverage checks (e.g. every tool has a transcript label); callers that
+ * send tools to the model must keep using listTools().
+ */
+export function listAllTools() {
+    return Array.from(registry.values());
+}
 /**
  * Reserved alias for standalone mode — CSPeach running with no SAP system.
  * Set at the single ctx-construction site in repl.tsx / one-shot.ts alongside

package/dist/tools/local-build.js

@@ -12,6 +12,9 @@
  *   shell:      shell_exec
  *   fiori:      fiori_scaffold, fiori_apply, fiori_list, fiori_deploy_config,
  *               fiori_scaffold_fe, fiori_fe_extend, fiori_render_smoke,
+ *               fiori_preview (L1-6 — the preview server every browser check
+ *               depends on), fiori_metadata_audit, fiori_draft_smoke
+ *               (L1-5b — a SAP write, approval-gated like every write),
  *               fiori_sample_search, fiori_sample_get
  *   extend:     extend_model_insert (anchored CDS/DDLX edit — abap-extend-model)
  *   subagent:   agent_run (Task 7, 2026-07-03 — customers get subagent
@@ -63,6 +66,9 @@ export const LOCAL_BUILD_TOOLS = [
     'fiori_scaffold_fe',
     'fiori_fe_extend',
     'fiori_render_smoke',
+    'fiori_preview',
+    'fiori_metadata_audit',
+    'fiori_draft_smoke',
     'fiori_sample_search',
     'fiori_sample_get',
     'extend_model_insert',

package/dist/tools/sap-read.js

@@ -22,6 +22,8 @@
  *   badiList(query, enhancementSpot?, maxResults?)
  */
 import { registerTool } from './index.js';
+import { normaliseSyntaxResult, checkSyntax } from './verify.js';
+import { recordSyntaxCheck } from './syntax-state.js';
 // -----------------------------------------------------------------------
 // 1. sap_get_source
 // -----------------------------------------------------------------------
@@ -455,7 +457,20 @@ registerTool({
     },
     handler: async (args, ctx) => {
         // syntaxCheck(type, name) — type first
-        const result = await ctx.adt.syntaxCheck(args.type, args.name);
+        // Fails closed (fix round 7, item 1): the model must never read a
+        // syntax error as clean — see normaliseSyntaxResult.
+        let raw;
+        try {
+            raw = await checkSyntax(ctx.adt, args.type, args.name); // A-I2: notProcessed retry
+        }
+        catch (err) {
+            // Re-review note — a check that did not run is "not clean": never leave
+            // an older clean result in the syntax state.
+            recordSyntaxCheck(args.type, args.name, true);
+            throw err;
+        }
+        const result = normaliseSyntaxResult(raw);
+        recordSyntaxCheck(args.type, args.name, result.hasErrors); // round 7 item 8e
         return { content: JSON.stringify(result, null, 2) };
     },
 });

package/dist/tools/sap-write.js

@@ -22,12 +22,17 @@
  * auditLog aliased from safety/audit-log.ts#log via sap-client/src/index.ts.
  */
 import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { registerTool } from './index.js';
 import { verifyAndSpendApprovalId } from '../approvals/jwt.js';
 import { autoSnapshot, autoSnapshotClassInclude } from './snapshot.js';
 import { includeSnapshotType } from './include-snapshot.js';
 import { buildWriteChainLine } from '../renderer/verify-chain.js';
+import { buildChangeCard } from '../renderer/change-card.js';
+import { getLook } from '../renderer/look.js';
+import { getEffectiveBodyWidth } from '../renderer/tty.js';
 import { verifySyntax, verifyActive } from './verify.js';
+import { hasRecordedSyntaxErrorsByName, clearSyntaxErrorsAfterActivation } from './syntax-state.js';
 import { appendPending, finalizeToolCall } from '../session/pending.js';
 import { auditLog } from '@cspeach/sap-client';
 import { ERR } from '../errors/codes.js';
@@ -79,9 +84,70 @@ function snapshotChainState(snap) {
     }
     return { snapshot: 'best_effort_failed' };
 }
-/** Compact ①②③④ pipeline summary — derived from the real gate results. */
+/**
+ * Review r7 I-3 — sap-client 0.1.15's setSource/updateMethod run their own
+ * (correct) syntax check and, on errors, return a 2xx writeStatus with
+ * `syntaxResult.hasErrors` and `error: 'Syntax check found errors —
+ * activation skipped'`. The source IS written (an inactive version exists):
+ * that is written-with-errors — the normal Rule 10 gate below reports it —
+ * never write_failed.
+ */
+function writtenWithSyntaxErrors(r) {
+    return r.writeStatus !== undefined && r.writeStatus >= 200 && r.writeStatus < 300 && r.syntaxResult?.hasErrors === true;
+}
+async function verifyWriteActivation(ctx, r, name, type) {
+    const a = r.activationResult;
+    if (!a)
+        return undefined;
+    const errors = (a.messages ?? []).filter((m) => m.severity === 'error').map((m) => m.shortText ?? '').filter(Boolean).slice(0, 5);
+    if (!a.success)
+        return { success: false, verified: false, errors };
+    const v = await verifyActive(ctx.adt, name, type);
+    if (v.verifyError !== undefined)
+        return { success: true, verified: false, errors, verifyError: v.verifyError };
+    return v.active ? { success: true, verified: true, errors } : { success: true, verified: false, errors, stillInactive: true };
+}
+/** Round 8 item 5 + A-I1 — the change-frame state from the verified activation. */
+function chainActivation(w) {
+    if (!w)
+        return undefined;
+    if (!w.success)
+        return { state: 'failed', detail: w.errors[0] };
+    if (w.verified)
+        return { state: 'active' };
+    return w.stillInactive ? { state: 'still_inactive' } : { state: 'unverified' };
+}
+function activatedByWrite(w) {
+    if (!w)
+        return {};
+    return { activated_by_write: { success: w.success, verified: w.verified, errors: w.errors } };
+}
+/** A-I1 minor — after a verified activation on write, say so instead of "activation_allowed". */
+function nextStepAfterWrite(syntaxOk, w) {
+    if (!syntaxOk)
+        return 'activation_blocked_until_syntax_errors_fixed';
+    if (w?.success && w.verified)
+        return 'already activated by the write — verify with sap_inactive_objects before reporting it active';
+    return 'activation_allowed';
+}
+/** Compact ①②③④ pipeline summary — derived from the real gate results.
+ *  Panels look: a change card (same honest chain in its footer). */
 function emitWriteChain(ctx, input) {
-    ctx.chunkEmitter?.emit('chunk', buildWriteChainLine(input) + '\n');
+    const text = getLook() === 'panels' && input.card
+        ? buildChangeCard(input, getEffectiveBodyWidth())
+        : buildWriteChainLine(input);
+    ctx.chunkEmitter?.emit('chunk', text + '\n');
+}
+/** Old source for the change card: ONLY from a snapshot actually taken. */
+function snapshotSource(snap) {
+    if (!snap?.taken || !snap.entry?.filePath)
+        return undefined;
+    try {
+        return readFileSync(snap.entry.filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
 }
 registerTool({
     name: 'sap_set_source',
@@ -165,6 +231,7 @@ registerTool({
                 what_will_happen: 'Overwrites full object source; snapshot is taken first.',
                 rollback_available: true,
                 transport: resolved.transport ?? ctx.currentTransport?.get() ?? '',
+                args: { ...args },
             });
             if (!r.confirmed) {
                 return {
@@ -201,7 +268,7 @@ registerTool({
                 is_error: true,
             };
         }
-        if (writeResult.error || (writeResult.writeStatus !== undefined && writeResult.writeStatus >= 400)) {
+        if ((writeResult.error && !writtenWithSyntaxErrors(writeResult)) || (writeResult.writeStatus !== undefined && writeResult.writeStatus >= 400)) {
             const detail = writeResult.error ?? `Write returned HTTP ${writeResult.writeStatus} but did not throw`;
             await finalizeToolCall(ctx.session, toolUseId, detail, true, Date.now() - startedAt);
             return {
@@ -218,11 +285,22 @@ registerTool({
         // ── Gate 4: Verify — syntax check (Rule 10) ──────────────────────────────
         const syntax = await verifySyntax(ctx.adt, args.name, args.type);
         await finalizeToolCall(ctx.session, toolUseId, JSON.stringify({ written: true, syntax }), false, Date.now() - startedAt);
+        const writeActivation = await verifyWriteActivation(ctx, writeResult, args.name, args.type);
         // Tour slide-7 chain — derived from the gates that actually ran.
+        // Old source is read (once) only for the panels card; legacy reads nothing extra.
+        const oldSource = getLook() === 'panels' ? snapshotSource(snapOutcome) : undefined;
         emitWriteChain(ctx, {
             ...snapshotChainState(snapOutcome),
             written: true,
             syntax: { ok: syntax.ok, errors: syntax.errors },
+            activation: chainActivation(writeActivation),
+            card: {
+                object: args.name,
+                what: 'source',
+                transport: resolved.transport,
+                oldSource,
+                newSource: oldSource !== undefined ? args.source : undefined,
+            },
         });
         return {
             content: JSON.stringify({
@@ -230,10 +308,9 @@ registerTool({
                 syntax_ok: syntax.ok,
                 errors: syntax.errors,
                 warnings: syntax.warnings,
+                ...activatedByWrite(writeActivation),
                 ...(resolved.owning ? { transport_used: resolved.owning, transport_note: resolved.note } : {}),
-                next_step: syntax.ok
-                    ? 'activation_allowed'
-                    : 'activation_blocked_until_syntax_errors_fixed',
+                next_step: nextStepAfterWrite(syntax.ok, writeActivation),
             }),
         };
     },
@@ -395,7 +472,7 @@ registerTool({
                 is_error: true,
             };
         }
-        if (updateResult.error || (updateResult.writeStatus !== undefined && updateResult.writeStatus >= 400)) {
+        if ((updateResult.error && !writtenWithSyntaxErrors(updateResult)) || (updateResult.writeStatus !== undefined && updateResult.writeStatus >= 400)) {
             const detail = updateResult.error ?? `Update returned HTTP ${updateResult.writeStatus} but did not throw`;
             await finalizeToolCall(ctx.session, toolUseId, detail, true, Date.now() - startedAt);
             return {
@@ -412,11 +489,14 @@ registerTool({
         // ── Gate 4: Verify — syntax check (Rule 10) ──────────────────────────────
         const syntax = await verifySyntax(ctx.adt, args.class_name, 'CLAS');
         await finalizeToolCall(ctx.session, toolUseId, JSON.stringify({ updated: true, syntax }), false, Date.now() - startedAt);
+        const writeActivation = await verifyWriteActivation(ctx, updateResult, args.class_name, 'CLAS');
         // Tour slide-7 chain — derived from the gates that actually ran.
         emitWriteChain(ctx, {
             ...snapshotChainState(snapOutcome),
             written: true,
             syntax: { ok: syntax.ok, errors: syntax.errors },
+            activation: chainActivation(writeActivation),
+            card: { object: args.class_name, what: `method ${args.method_name}`, transport: resolved.transport },
         });
         return {
             content: JSON.stringify({
@@ -424,10 +504,9 @@ registerTool({
                 syntax_ok: syntax.ok,
                 errors: syntax.errors,
                 warnings: syntax.warnings,
+                ...activatedByWrite(writeActivation),
                 ...(resolved.owning ? { transport_used: resolved.owning, transport_note: resolved.note } : {}),
-                next_step: syntax.ok
-                    ? 'activation_allowed'
-                    : 'activation_blocked_until_syntax_errors_fixed',
+                next_step: nextStepAfterWrite(syntax.ok, writeActivation),
             }),
         };
     },
@@ -496,6 +575,7 @@ registerTool({
                 what_will_happen: 'Deletes object from SAP; snapshot is taken first; recovery via sap_snapshot_read + sap_set_source (LLM composes the rollback).',
                 rollback_available: true,
                 transport: resolved.transport ?? ctx.currentTransport?.get() ?? '',
+                args: { ...args },
             });
             if (!r.confirmed) {
                 return {
@@ -785,6 +865,7 @@ registerTool({
             ...snapshotChainState(snapOutcome),
             written: true,
             syntax: 'not_checked',
+            card: { object: args.className, what: `include ${args.includeType}`, transport: resolved.transport },
         });
         return {
             content: JSON.stringify({
@@ -1107,6 +1188,33 @@ registerTool({
                 is_error: true,
             };
         }
+        // Round 7 item 8e — an approval auto_approve minted (no human saw it)
+        // never activates an object whose last syntax check found errors. Any
+        // approval minted after the errors went through the card (risk floor).
+        // Final review A M-1 — match by NAME, like the risk floor: a type word can
+        // map to a different code (DDLS recorded, activated as VIEW). Over-block,
+        // never under-block; an auto approval can always be asked for again.
+        const broken = args.objects
+            .filter((o) => hasRecordedSyntaxErrorsByName(o.name)).map((o) => o.name.toUpperCase());
+        if (verify.payload.auto) {
+            if (broken.length > 0) {
+                ctx.chunkEmitter?.emit('warn', `Activation blocked · syntax errors in ${broken.join(', ')}`);
+                return {
+                    content: JSON.stringify({
+                        error: 'activation_blocked_syntax_errors',
+                        objects: broken,
+                        detail: 'The last syntax check of these objects found errors and this activation was auto-approved before that. '
+                            + 'Fix the errors (sap_syntax_check shows them) or ask for approval again.',
+                    }),
+                    is_error: true,
+                };
+            }
+        }
+        // Review r7 M-6 — a human-approved activation stays allowed (a mass
+        // activation can clear cross-object errors), but it is never silent.
+        for (const n of broken) {
+            ctx.chunkEmitter?.emit('warn', `Activating ${n} · its last syntax check found errors · SAP will refuse it unless they are resolved`);
+        }
         const toolUseId = ctx.toolUseId ?? crypto.randomUUID();
         const startedAt = Date.now();
         // ── WAL: record pending entry ────────────────────────────────────────────
@@ -1149,6 +1257,10 @@ registerTool({
             else if (!v.active) {
                 stillInactive.push(`${obj.type}/${obj.name}`);
             }
+            else if (activationResults.find((r) => r.name === obj.name && r.type === obj.type)?.success) {
+                // Final review A M-2 — activated AND verified: the source compiles.
+                clearSyntaxErrorsAfterActivation(obj.name);
+            }
         }
         const overallSuccess = !anyError && stillInactive.length === 0 && unverifiable.length === 0;
         await finalizeToolCall(ctx.session, toolUseId, JSON.stringify({ overallSuccess, activationResults, stillInactive, unverifiable }), anyError, Date.now() - startedAt);

package/dist/tools/shell/shell_exec.js

@@ -45,7 +45,10 @@ import * as path from 'node:path';
 import { registerTool } from '../index.js';
 import { resolveSafePath, PathOutsideRootError } from '../_filesystem-shared.js';
 import { loadSafelist, buildSafeEnv, resolveExecutable, validateArgv, rejectPathSeparator, DEFAULT_SAFELIST, KILL_GRACE_MS, } from '../_command-shared.js';
+import { killProcessTree } from '../fiori/preview/registry.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
+/** After the kill's grace: how long to wait for the pipes before returning anyway. */
+const ORPHAN_WAIT_MS = 3_000;
 const MAX_TIMEOUT_MS = 300_000;
 const MAX_OUTPUT_BYTES = 1_000_000; // per stream
 export async function shellExecHandler(args, ctx) {
@@ -171,18 +174,38 @@ export async function shellExecHandler(args, ctx) {
                 stderrTrunc = true;
             }
         });
+        const timedOutResult = () => {
+            const tail = (stdoutBuf ? `stdout (partial):\n${stdoutBuf}\n${stdoutTrunc ? '[truncated]\n' : ''}` : '') +
+                (stderrBuf ? `stderr (partial):\n${stderrBuf}\n${stderrTrunc ? '[truncated]\n' : ''}` : '');
+            return { content: `error: command timed out after ${timeoutMs} ms — child killed.\n${tail}`, is_error: true };
+        };
         const timer = setTimeout(() => {
             timedOut = true;
-            try {
-                child.kill('SIGTERM');
+            if (process.platform === 'win32') {
+                // Dry run 2026-09-25: `npm start` = npm.cmd → cmd.exe → node. Killing the
+                // direct child left the server alive holding our pipes; 'close' never
+                // fired and a 45 s call returned after 21 minutes. Kill the whole tree.
+                void killProcessTree(child.pid, child);
             }
-            catch { /* ignore */ }
-            setTimeout(() => {
+            else {
                 try {
-                    child.kill('SIGKILL');
+                    child.kill('SIGTERM');
                 }
                 catch { /* ignore */ }
-            }, KILL_GRACE_MS).unref();
+                setTimeout(() => {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch { /* ignore */ }
+                }, KILL_GRACE_MS).unref();
+            }
+            // Never wait on an orphan: if the pipes are still open after the kill
+            // had its grace, stop reading and return the timeout result anyway.
+            setTimeout(() => {
+                child.stdout?.destroy();
+                child.stderr?.destroy();
+                settle(timedOutResult());
+            }, KILL_GRACE_MS + ORPHAN_WAIT_MS).unref();
         }, timeoutMs);
         timer.unref();
         child.on('error', (err) => {
@@ -192,12 +215,7 @@ export async function shellExecHandler(args, ctx) {
         child.on('close', (code, signal) => {
             clearTimeout(timer);
             if (timedOut) {
-                const tail = (stdoutBuf ? `stdout (partial):\n${stdoutBuf}\n${stdoutTrunc ? '[truncated]\n' : ''}` : '') +
-                    (stderrBuf ? `stderr (partial):\n${stderrBuf}\n${stderrTrunc ? '[truncated]\n' : ''}` : '');
-                settle({
-                    content: `error: command timed out after ${timeoutMs} ms — child killed.\n${tail}`,
-                    is_error: true,
-                });
+                settle(timedOutResult());
                 return;
             }
             const stdoutSection = `stdout:\n${stdoutBuf}${stdoutTrunc ? '\n[truncated — exceeded 1 MB cap]' : ''}`;

package/dist/tools/syntax-state.js

@@ -0,0 +1,67 @@
+/**
+ * Round 7 item 8e — which objects' LAST syntax check found errors (this CLI
+ * process). Written by every syntax check the CLI runs (the Rule 10 write
+ * gate and the sap_syntax_check tool); read by the approval risk floor (such
+ * an object never auto-approves) and by sap_activate (an automatically minted
+ * approval never activates it). A clean check clears the object.
+ *
+ * Review r7 M-3 — keyed by object TYPE and name: a PROG and a CLAS with the
+ * same name never share the flag. `PROG/P` and `PROG` are the same type.
+ *
+ * Re-review 2 item 2 — a name index of flagged objects. When either side's
+ * type is not a known ADT code (a recorded "ABAP CLASS", a queried "some
+ * thing"), the object is matched by name alone: over-match, never miss.
+ */
+import { normaliseAdtType } from '../approvals/adt-type.js';
+const UNKNOWN = '?';
+/** name → the type codes (or UNKNOWN) flagged under that name. */
+const byName = new Map();
+const nameOf = (name) => name.trim().toUpperCase();
+const codeOf = (type) => normaliseAdtType(type) ?? UNKNOWN;
+export function recordSyntaxCheck(type, name, hasErrors) {
+    const n = nameOf(name);
+    const c = codeOf(type);
+    const set = byName.get(n) ?? new Set();
+    if (hasErrors)
+        set.add(c);
+    else {
+        set.delete(c);
+        // Final review A M-3 — a clean check under a KNOWN code also clears an
+        // entry recorded under an unknown type word for the same name.
+        if (c !== UNKNOWN)
+            set.delete(UNKNOWN);
+    }
+    if (set.size > 0)
+        byName.set(n, set);
+    else
+        byName.delete(n);
+}
+export function hasRecordedSyntaxErrors(type, name) {
+    const set = byName.get(nameOf(name));
+    if (!set || set.size === 0)
+        return false;
+    const c = codeOf(type);
+    return c === UNKNOWN || set.has(c) || set.has(UNKNOWN);
+}
+/** Final review A M-1 — any flagged entry with this name, whatever its type. */
+export function hasRecordedSyntaxErrorsByName(name) {
+    return (byName.get(nameOf(name))?.size ?? 0) > 0;
+}
+/**
+ * Final review A M-2 — a successful activation verified against the
+ * inactive-objects list proves the current source compiles: clear the name.
+ */
+export function clearSyntaxErrorsAfterActivation(name) {
+    byName.delete(nameOf(name));
+}
+/** `TYPE:NAME` keys (TYPE is an ADT code, or `?` when the type word was unknown). */
+export function objectsWithSyntaxErrors() {
+    const out = [];
+    for (const [n, set] of byName)
+        for (const c of set)
+            out.push(`${c}:${n}`);
+    return out;
+}
+export function resetSyntaxStateForTest() {
+    byName.clear();
+}

package/dist/tools/todo.js

@@ -7,14 +7,14 @@
  *
  * Semantics: FULL-LIST REPLACE on every call — never a delta. 1..20 items.
  *
- * Transcript render (CC-style, 2026-07): on every successful set the
- * handler also emits the FULL checklist as a scrollback block via
- * ctx.chunkEmitter (renderer/todo-block.ts). The raw ⏺/⎿ todo_set rows are
- * widget-suppressed (renderer/tool-widget.ts) so the block is the sole
- * visible representation — the transcript now shows the whole plan
- * advancing, not a raw `⏺ todo_set({"todos":[…])` JSON line. This is the
- * Claude-Code parity the owner asked for; the turn-status strip (single ▶
- * row) and Ctrl+T panel stay exactly as they were.
+ * Transcript render (piece 2, spec §4 — was CC-style 2026-07): WHERE the
+ * checklist is drawn depends on the render mode (renderer/checklist-format.ts
+ * checklistRenderMode). Ink draws a LIVE checklist (ui/checklist.tsx) that
+ * redraws in place, with one close line at turn end; classic interactive
+ * prints the block once at turn end (repl/plan-turn-end.ts); only headless /
+ * one-shot emit the per-set scrollback block (renderer/todo-block.ts) via
+ * ctx.chunkEmitter, so CI logs keep the progression. The raw ⏺/⎿ todo_set
+ * rows are widget-suppressed (renderer/tool-widget.ts) in every mode.
  *
  * Session-write route (chosen with evidence, 2026-07-05): the tool mutates
  * `ctx.session.todos` directly. ToolContext.session IS the live
@@ -45,6 +45,8 @@
  */
 import { registerTool } from './index.js';
 import { formatTodoChecklistBlock } from '../renderer/todo-block.js';
+import { checklistRenderMode } from '../renderer/checklist-format.js';
+import { markTodoSetThisTurn } from '../ui/todo-emitter.js';
 /** Hard cap on list length — past this the list stops being a glanceable plan. */
 export const TODO_MAX_ITEMS = 20;
 const VALID_STATUSES = new Set(['pending', 'in_progress', 'completed']);
@@ -85,16 +87,19 @@ export async function todoSetHandler(args, ctx) {
     // copy so a consumer mutating the payload can never corrupt the
     // persisted session state.
     ctx.todoEmitter?.emit('update', todos.map((t) => ({ ...t })));
-    // Transcript render (CC-style, 2026-07): drop the FULL checklist into
-    // scrollback on every successful set. The raw ⏺/⎿ todo_set rows are
-    // widget-suppressed (renderer/tool-widget.ts), so this block is the sole
-    // visible representation — mirroring ask_question. ctx.chunkEmitter routes
-    // to Ink Static scrollback AND the classic 'chunk'→stdout path
-    // (renderer/notices.ts). Subagent ctxs deliberately omit chunkEmitter
-    // (tools/subagent/agent_run.ts), so a child turn's todo_set can never
-    // print its checklist into the PARENT transcript — same seam as the
-    // todoEmitter suppression above.
-    ctx.chunkEmitter?.emit('chunk', formatTodoChecklistBlock(todos));
+    // Piece 2 (spec §4) — where the checklist is drawn depends on the mode.
+    // Ink: the live checklist (ui/checklist.tsx) redraws in place — no
+    // scrollback reprint per update; one close line lands at turn end
+    // (repl/plan-turn-end.ts). Classic interactive: the block prints once, at
+    // turn end. Headless / one-shot: the block still prints on EVERY update so
+    // CI logs keep the progression. The raw ⏺/⎿ todo_set rows stay
+    // widget-suppressed (renderer/tool-widget.ts). Subagent ctxs omit both
+    // emitters, so a child todo_set never reaches the parent's transcript.
+    if (checklistRenderMode() === 'per-update') {
+        ctx.chunkEmitter?.emit('chunk', formatTodoChecklistBlock(todos));
+    }
+    if (ctx.todoEmitter)
+        markTodoSetThisTurn();
     const result = {
         count: todos.length,
         // LAST-wins, matching the app strip and Ctrl+T panel (both `.at(-1)`).