@cspeach/cli 1.1.18 → 1.1.20

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/result-spill.js

@@ -0,0 +1,238 @@
+/**
+ * Task 17 (model control, 2026-09-27, spec D12) — large tool results go to a
+ * file; the history keeps a preview and a path.
+ *
+ * Claude Code's "output too large, saved to file" pattern. Above
+ * SPILL_THRESHOLD_CHARS the full text is written to
+ * ~/.cspeach/streams/<sessionId>/tool-<toolUseId>.txt and the tool_result
+ * carries the first 60 lines (plus the last 20 for source, SQL, shell and file windows),
+ * then one pointer line naming tool_output_read.
+ *
+ * Sizing happens ONCE, when the tool_result is created (the handler's return
+ * value) — never afterwards, so it is not a history edit and the cached
+ * prefix / preserved thinking stay append-only.
+ *
+ * The spill file holds exactly the text the tool would have returned — no
+ * more (no secrets beyond what the tool already produced), and it lives in the
+ * per-session area under ~/.cspeach, never in the user's project.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { streamsRoot } from '../agent/turn-stream.js';
+import { rememberSpillLabel } from '../lib/spill-labels.js';
+export const SPILL_THRESHOLD_CHARS = 8_000;
+export const PREVIEW_HEAD_LINES = 60;
+export const PREVIEW_TAIL_LINES = 20;
+/** One preview line never carries more than this (a minified JSON line must not defeat the preview). */
+export const PREVIEW_LINE_MAX_CHARS = 500;
+/** Character budgets for the head and tail blocks of the preview. */
+export const PREVIEW_HEAD_BUDGET_CHARS = 6_000;
+export const PREVIEW_TAIL_BUDGET_CHARS = 2_000;
+/**
+ * Kinds whose preview also keeps the last lines (the end matters: totals,
+ * exit code, ENDCLASS; for file_read the window's last line). Only search
+ * hits and reports are head-only.
+ */
+const TAIL_KINDS = new Set(['source', 'sql', 'shell', 'file']);
+/** Session ids / tool_use ids become file names: keep them path-inert. */
+function safeSegment(s) {
+    const cleaned = s.replace(/[^A-Za-z0-9_-]/g, '_');
+    return cleaned.length > 0 ? cleaned : '_';
+}
+/** The directory that holds one session's spill files. */
+export function spillDirFor(sessionId) {
+    return path.join(streamsRoot(), safeSegment(sessionId));
+}
+/**
+ * Session id as the tools see it, or undefined when the ctx carries none
+ * (some tests and non-loop call paths). Without a session there is no
+ * private spill dir, so nothing is spilled and tool_output_read refuses —
+ * never a shared fallback directory (fix round 1, minor 3).
+ */
+export function sessionIdOf(ctx) {
+    const id = ctx.session?.id;
+    return typeof id === 'string' && id.length > 0 ? id : undefined;
+}
+/**
+ * Spill file names: `tool-<id>.txt`, or `tool-<id>.n.txt` for text that is
+ * already line-numbered (file_read windows keep the FILE's line numbers, so
+ * tool_output_read shows those lines as they are instead of numbering again —
+ * one numbering space). tool_output_read accepts only these shapes.
+ */
+export const SPILL_FILE_RE = /^tool-[A-Za-z0-9_-]+(\.n)?\.txt$/;
+export const NUMBERED_SPILL_RE = /\.n\.txt$/;
+/** Spill files older than this are deleted at REPL start (like the notice logs). */
+export const SPILL_MAX_AGE_DAYS = 14;
+function clipLine(line) {
+    if (line.length <= PREVIEW_LINE_MAX_CHARS)
+        return line;
+    return `${line.slice(0, PREVIEW_LINE_MAX_CHARS)}… [+${line.length - PREVIEW_LINE_MAX_CHARS} chars]`;
+}
+export function pointerLine(lines, chars, filePath) {
+    return `[${lines} lines / ${chars} chars — full output saved to ${filePath}; read slices with tool_output_read(path, offset, limit)]`;
+}
+/**
+ * Build the preview text for `text` (already known to be large). Pure. Line
+ * numbers in the omitted marker are the spill file's own (1-based, =
+ * tool_output_read offset + 1); for an already-numbered spill the marker names
+ * the offset instead, since the visible numbers belong to the source file.
+ */
+export function buildPreview(text, kind, filePath, opts = {}) {
+    const lines = text.split('\n');
+    const total = lines.length;
+    const head = [];
+    let used = 0;
+    for (let i = 0; i < total && head.length < PREVIEW_HEAD_LINES; i++) {
+        const l = clipLine(lines[i]);
+        if (head.length > 0 && used + l.length + 1 > PREVIEW_HEAD_BUDGET_CHARS)
+            break;
+        head.push(l);
+        used += l.length + 1;
+    }
+    const tail = [];
+    if (TAIL_KINDS.has(kind)) {
+        let tailUsed = 0;
+        for (let i = total - 1; i >= head.length && tail.length < PREVIEW_TAIL_LINES; i--) {
+            const l = clipLine(lines[i]);
+            if (tail.length > 0 && tailUsed + l.length + 1 > PREVIEW_TAIL_BUDGET_CHARS)
+                break;
+            tail.unshift(l);
+            tailUsed += l.length + 1;
+        }
+    }
+    const out = [...head];
+    const omittedFrom = head.length + 1; // 1-based first omitted line
+    const omittedTo = total - tail.length; // 1-based last omitted line
+    if (omittedTo >= omittedFrom) {
+        out.push(opts.numbered
+            ? `[… ${omittedTo - omittedFrom + 1} lines omitted — tool_output_read offset=${omittedFrom - 1} …]`
+            : `[… lines ${omittedFrom}–${omittedTo} omitted …]`);
+    }
+    out.push(...tail);
+    out.push(pointerLine(total, text.length, filePath));
+    return out.join('\n');
+}
+/**
+ * Size a tool result at ingestion. At or below the threshold → unchanged.
+ * Above it → the full text goes to the session spill file and a preview comes
+ * back. A write failure fails OPEN (full text returned, nothing lost).
+ *
+ * `header` (sap_get_source's version line) counts toward the threshold and
+ * leads the preview, but is NOT written to the file: the file is the body
+ * alone, so tool_output_read line k is body line k (fix round 1, I1), and the
+ * pointer's counts describe the body.
+ */
+export function spillIfLarge(i) {
+    const whole = i.header !== undefined ? `${i.header}\n${i.text}` : i.text;
+    if (whole.length <= (i.threshold ?? SPILL_THRESHOLD_CHARS))
+        return { spilled: false, text: whole };
+    const dir = spillDirFor(i.sessionId);
+    const id = safeSegment(i.toolUseId && i.toolUseId.length > 0 ? i.toolUseId : crypto.randomUUID());
+    const filePath = path.join(dir, `tool-${id}${i.numbered ? '.n' : ''}.txt`);
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(filePath, i.text, { encoding: 'utf-8', mode: 0o600 });
+    }
+    catch {
+        return { spilled: false, text: whole };
+    }
+    const preview = buildPreview(i.text, i.kind, filePath, { numbered: i.numbered });
+    return { spilled: true, text: i.header !== undefined ? `${i.header}\n${preview}` : preview, path: filePath };
+}
+/**
+ * Convenience for handlers: size `result.content` with the ctx's session and
+ * tool_use id. With a header, `result.content` is the body and the returned
+ * content is `header\n…`. No session id → never spilled.
+ */
+export function spillToolResult(result, ctx, kind, opts = {}) {
+    const sessionId = sessionIdOf(ctx);
+    const whole = opts.header !== undefined ? `${opts.header}\n${result.content}` : result.content;
+    if (sessionId === undefined)
+        return whole === result.content ? result : { ...result, content: whole };
+    const { label, ...spillOpts } = opts;
+    const s = spillIfLarge({ text: result.content, sessionId, toolUseId: ctx.toolUseId, kind, ...spillOpts });
+    if (s.spilled && s.path && label)
+        rememberSpillLabel(s.path, label);
+    return s.text === result.content ? result : { ...result, content: s.text };
+}
+/**
+ * Delete spill files (tool-*.txt in every session dir under the spill root)
+ * last modified more than SPILL_MAX_AGE_DAYS ago, then any session dir left
+ * empty. Other files (the turn mirrors) are left alone; symlinks and
+ * junctions (root, dirs, files) are never followed. Best effort: never
+ * throws. Returns how many files were deleted.
+ */
+export function pruneSpillFiles(now = Date.now()) {
+    const cutoff = now - SPILL_MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+    let removed = 0;
+    let dirs;
+    try {
+        // Final review tools-I1 — never follow links: a symlinked / junctioned
+        // root, session dir or file is skipped (lstat), so the prune can never
+        // delete outside the CLI's own area.
+        if (!fs.lstatSync(streamsRoot()).isDirectory())
+            return 0;
+        dirs = fs.readdirSync(streamsRoot());
+    }
+    catch {
+        return 0;
+    }
+    for (const d of dirs) {
+        const dir = path.join(streamsRoot(), d);
+        let names;
+        try {
+            const st = fs.lstatSync(dir);
+            if (st.isSymbolicLink() || !st.isDirectory())
+                continue;
+            names = fs.readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!SPILL_FILE_RE.test(name))
+                continue;
+            const p = path.join(dir, name);
+            try {
+                const st = fs.lstatSync(p);
+                if (st.isSymbolicLink() || !st.isFile())
+                    continue;
+                if (st.mtimeMs < cutoff) {
+                    fs.unlinkSync(p);
+                    removed++;
+                }
+            }
+            catch {
+                /* best effort */
+            }
+        }
+        try {
+            if (fs.readdirSync(dir).length === 0)
+                fs.rmdirSync(dir);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    return removed;
+}
+/** True when `child` lies strictly inside `dir`. */
+export function isInside(dir, child) {
+    const rel = path.relative(dir, child);
+    return rel.length > 0 && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+/** `p` and, when it exists, its realpath (8.3 names, /var → /private/var). */
+export function withRealpath(p) {
+    try {
+        const real = fs.realpathSync.native(p);
+        return real === p ? [p] : [p, real];
+    }
+    catch {
+        return [p];
+    }
+}
+/** True when `absPath` (already a realpath) lies under the spill root (any session). */
+export function isUnderSpillRoot(absPath) {
+    return withRealpath(streamsRoot()).some((root) => isInside(root, absPath));
+}

package/dist/tools/sap-read.js

@@ -22,6 +22,50 @@
  *   badiList(query, enhancementSpot?, maxResults?)
  */
 import { registerTool } from './index.js';
+import { normaliseSyntaxResult, checkSyntax } from './verify.js';
+import { recordSyntaxCheck } from './syntax-state.js';
+import { spillToolResult } from './result-spill.js';
+// -----------------------------------------------------------------------
+// Task 17 (spec D12, ruling F18) — model-facing formats.
+// -----------------------------------------------------------------------
+/**
+ * sap_get_source's one-line header: `[version: active]`,
+ * `[version: inactive | <warning>]` (any version may carry the split-state
+ * warning), or `[version: unknown]`. Plan-audit evidence reads the first
+ * 200 chars of the result, so the version leads it.
+ */
+export function formatSourceHeader(version, warning) {
+    return warning ? `[version: ${version} | ${warning.replace(/\s*\n\s*/g, ' ')}]` : `[version: ${version}]`;
+}
+/** Inverse of formatSourceHeader: the version (and warning) back from a result. */
+export function parseSourceHeader(text) {
+    const first = text.split('\n', 1)[0] ?? '';
+    const m = /^\[version: ([a-z]+)(?: \| (.*))?\]$/.exec(first);
+    if (!m)
+        return { version: 'unknown' };
+    return m[2] !== undefined ? { version: m[1], warning: m[2] } : { version: m[1] };
+}
+/** One TSV cell: tabs / newlines inside a value cannot break the grid. */
+const tsvCell = (v) => (v === null || v === undefined ? '' : String(v)).replace(/[\t\r\n]+/g, ' ');
+export function formatSqlTsv(result) {
+    const cols = result.columns ?? [];
+    const rows = result.rows ?? [];
+    const lines = [cols.map(tsvCell).join('\t'), ...rows.map((r) => cols.map((c) => tsvCell(r[c])).join('\t'))];
+    const n = rows.length;
+    const total = typeof result.totalRows === 'number' && result.totalRows > n ? ` of ${result.totalRows}` : '';
+    lines.push(`(${n} ${n === 1 ? 'row' : 'rows'}${total})`);
+    return lines.join('\n');
+}
+/** Search hits, one per line: NAME  TYPE  PACKAGE  DESCRIPTION  URI ("-" for an empty field). */
+export function formatSearchHits(hits) {
+    if (hits.length === 0)
+        return '(no hits)';
+    const f = (v) => {
+        const t = typeof v === 'string' ? v.replace(/\s+/g, ' ').trim() : '';
+        return t.length > 0 ? t : '-';
+    };
+    return hits.map((h) => [h.name, h.type, h.packageName ?? h.package, h.description, h.uri].map(f).join('  ')).join('\n');
+}
 // -----------------------------------------------------------------------
 // 1. sap_get_source
 // -----------------------------------------------------------------------
@@ -34,7 +78,8 @@ registerTool({
         + 'the response is the active source AND a warning is emitted so the '
         + 'caller knows the inactive edits are not visible. For a freshly '
         + 'created object with NO active version yet, the inactive (working) '
-        + 'source is returned with version="inactive" and an honest note.',
+        + 'source is returned with version="inactive" and an honest note. '
+        + 'The first line is a [version: …] header, not part of the source.',
     isMutating: false,
     requiresSap: true,
     input_schema: {
@@ -115,13 +160,13 @@ registerTool({
                 // probe failed — leave resolvedVersion as 'unknown'
             }
         }
-        return {
-            content: JSON.stringify({
-                source,
-                version: resolvedVersion,
-                ...(splitStateWarning ? { split_state_warning: splitStateWarning } : {}),
-            }),
-        };
+        // Fix round 1 (I1): the header leads the result and the preview, but a
+        // spill file holds the source alone — tool_output_read line k is source
+        // line k, matching syntax-check / ATC line numbers.
+        return spillToolResult({ content: String(source) }, ctx, 'source', {
+            header: formatSourceHeader(resolvedVersion, splitStateWarning),
+            label: String(args.name).toUpperCase(),
+        });
     },
 });
 // -----------------------------------------------------------------------
@@ -153,10 +198,11 @@ registerTool({
         // `version` right after name/type puts it inside the excerpt window.
         const versionMatch = /\badtcore:version="([^"]*)"/.exec(result.rawXml ?? '');
         const version = versionMatch?.[1] || 'unknown';
-        // name/type/version lead the serialized JSON (rawXml stays last via the
-        // rest spread), so `version` sits inside the excerpt window while every
-        // ObjectStructure field is preserved.
-        const { name, type, ...rest } = result;
+        // name/type/version lead the serialized JSON, so `version` sits inside
+        // the excerpt window. Task 17: rawXml is parsed above and never sent to
+        // the model (it was the bulk of the result).
+        const { name, type, rawXml, ...rest } = result;
+        void rawXml;
         return { content: JSON.stringify({ name, type, version, ...rest }, null, 2) };
     },
 });
@@ -185,7 +231,7 @@ registerTool({
     },
     handler: async (args, ctx) => {
         const results = await ctx.adt.searchObject(args.query, args.type, args.maxResults ?? 100);
-        return { content: JSON.stringify(results, null, 2) };
+        return spillToolResult({ content: formatSearchHits(results) }, ctx, 'search', { label: `search "${args.query}"` });
     },
 });
 // -----------------------------------------------------------------------
@@ -229,7 +275,7 @@ registerTool({
     },
     handler: async (args, ctx) => {
         const result = await ctx.adt.sqlQuery(args.query, args.maxRows ?? 100);
-        return { content: JSON.stringify(result, null, 2) };
+        return spillToolResult({ content: formatSqlTsv(result) }, ctx, 'sql', { label: 'query result' });
     },
 });
 // -----------------------------------------------------------------------
@@ -455,7 +501,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);