@cspeach/cli 1.1.40 → 1.1.41

package/dist/tools/verify.js

@@ -11,7 +11,7 @@
  * (Confirmed from sap-client/src/adt-client.ts lines 82-87, 224-228, 547.)
  */
 import { recordSyntaxCheck } from './syntax-state.js';
-import { toObjectUrl, xmlParser } from '@cspeach/sap-client';
+import { fromObjectUrl, toObjectUrl, xmlParser } from '@cspeach/sap-client';
 import * as sapClient from '@cspeach/sap-client';
 /** Line for display: the parsed line, else the `#start=L,C` fragment of the
  *  checkruns uri (sap-client <= 0.1.14 left line at 0 for checkruns). */
@@ -150,22 +150,66 @@ export function inactiveBodyMentions(body, type, name) {
     catch { /* unknown type word: the name check stands */ }
     return byName || byUri;
 }
+/**
+ * Task 10 / D6 — is this same-named inactive-list entry provably ANOTHER
+ * object? In a RAP stack the DDLS, BDEF and DDLX share one name, so a
+ * name-only match read a clean object as "still inactive".
+ *
+ * SAFE side: true ONLY when the entry's uri is present and resolves (after
+ * dropping `#…`/`?…`) to a known object that differs from ours. Both sides go
+ * through fromObjectUrl, so case, %2F-encoded namespaces, the CDS alias and a
+ * class include (→ its class) all compare as the same object. A missing uri,
+ * one fromObjectUrl cannot vouch for, or an unknown type word → false: the
+ * entry keeps blocking by name, as before.
+ */
+export function isOtherObject(entry, type, name) {
+    const uri = typeof entry.uri === 'string' ? entry.uri.trim() : '';
+    if (!uri)
+        return false;
+    const theirs = fromObjectUrl(uri.split(/[#?]/)[0]);
+    if (!theirs)
+        return false;
+    let ours;
+    try {
+        ours = fromObjectUrl(toObjectUrl(type, name));
+    }
+    catch {
+        return false;
+    }
+    if (!ours)
+        return false;
+    return theirs.type.toUpperCase() !== ours.type.toUpperCase()
+        || theirs.name.toUpperCase() !== ours.name.toUpperCase();
+}
+/** The same-named entries of the parsed list, and whether any of them may be
+ *  ours (any entry that is not provably another object blocks). */
+function sameNamed(inactive, type, name) {
+    const upper = name.toUpperCase();
+    const same = inactive.filter((o) => String(o.name ?? '').toUpperCase() === upper);
+    return { any: same.length > 0, blocks: same.some((o) => !isOtherObject(o, type, name)) };
+}
 async function checkActiveVersion(adt, type, name) {
     const upper = name.toUpperCase();
     const conn = connOf(adt);
     if (!conn || typeof conn.post !== 'function' || typeof conn.get !== 'function')
         return undefined;
-    // Parser-independent guard: never check the old active source while an
-    // inactive version may exist.
-    const list = await conn.get(INACTIVE_URL);
-    if (list.status < 200 || list.status >= 300)
-        return undefined;
-    const body = list.body ?? '';
-    if (inactiveBodyMentions(body, type, upper))
-        return undefined;
+    // Never check the old active source while an inactive version may exist.
+    // Task 10 / D6: the parsed list first (an unreadable list throws → the
+    // caller refuses the retry). A same-named entry blocks unless its uri proves
+    // it is another object; when every same-named entry is another object, the
+    // raw-body name mention is explained by them and is not read.
     const inactive = await adt.inactiveObjects();
-    if (inactive.some((o) => o.name.toUpperCase() === upper))
+    const same = sameNamed(inactive, type, upper);
+    if (same.blocks)
         return undefined;
+    if (!same.any) {
+        // Parser-independent guard (0.1.15 misses names on a child <ioc:ref>).
+        const list = await conn.get(INACTIVE_URL);
+        if (list.status < 200 || list.status >= 300)
+            return undefined;
+        if (inactiveBodyMentions(list.body ?? '', type, upper))
+            return undefined;
+    }
     // Controller ruling: no "body has refs but parses to nothing" rule — with the
     // 0.1.15 parser bug it refused the retry whenever the user had ANY other
     // inactive object, re-blocking every clean BDEF/DDLX/SRVD/TABL write. The
@@ -222,13 +266,18 @@ export async function verifyActive(adt, name, type) {
     }
     // Re-review of the final fix wave, item 1 — the list carries ADT codes with
     // a slash (PROG/P, CLAS/OC, DDLS/DF), so an exact type compare never matched
-    // and still-inactive objects read as active. Match by object NAME: a
-    // same-named object of another type only errs on the safe side.
-    let stillInactive = inactive.some((o) => o.name.toUpperCase() === name.toUpperCase());
+    // and still-inactive objects read as active. Match by object NAME.
+    // Task 10 / D6 — a same-named entry is set aside ONLY when its uri proves it
+    // is another object (RAP: DDLS, BDEF and DDLX share one name); a missing,
+    // unknown or odd uri still blocks by name.
+    const same = sameNamed(inactive, type, name);
+    let stillInactive = same.blocks;
     // Re-review item 2 — parser-independent: the raw body mentioning the object
     // also means still inactive (0.1.15 misses names on a child <ioc:ref>).
+    // Skipped when every same-named entry is another object: they explain the
+    // mention.
     const conn = connOf(adt);
-    if (!stillInactive && conn && typeof conn.get === 'function') {
+    if (!same.any && conn && typeof conn.get === 'function') {
         try {
             const list = await conn.get(INACTIVE_URL);
             if (list.status >= 200 && list.status < 300)

package/dist/tools/write-pipeline.js

@@ -0,0 +1,437 @@
+/**
+ * The CLI write pipeline (ADT gap program Part 2a, D8).
+ *
+ * Every CLI write tool used to carry its own copy of the safety gates. Here
+ * they run once, in one fixed order, and a tool is a declaration
+ * (`WriteToolSpec`) — so a new tool cannot skip a gate:
+ *
+ *   (beforeApproval) → approval id → plan-grant claims → Rule 9 conflict warning → transport
+ *   (owning-transport resolve, session fallback then resolve, or the
+ *   three-tier fallback) → grant owning
+ *   mismatch → Rule 7 snapshot → safety card → preGate → WAL pending →
+ *   walGate → call → onThrow / landed → (noWrite: WAL closed, envelope) → noteWriteTransport → Rule 10 syntax check →
+ *   audit row (D7: after the check, status follows the verified outcome) →
+ *   WAL finalize → verified activation → chain / change card → after → envelope
+ *
+ * The result envelope is the tool's own `envelope` — byte-identical to what
+ * the hand-written handler returned (pinned in sap-write-envelopes.test.ts).
+ * The human-stream lines (snapshot notice, new-shell note, chain line, change
+ * card) are emitted here with the same text as before
+ * (sap-write-transcript.test.ts).
+ *
+ * The Part 1 profile gates (profileGate / gateWithVerify / D12) run in
+ * dispatchTool and request_approval, before any handler: untouched here.
+ */
+import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { auditLog, SapError } from '@cspeach/sap-client';
+import { verifyAndSpendApprovalId } from '../approvals/jwt.js';
+import { grantClaimMismatch, grantOwningTransportMismatch, grantOwningTransportDetail } from '../approvals/grant-claims.js';
+import { autoSnapshot, autoSnapshotClassInclude, autoSnapshotMessageClass } 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 { teamFixOffers } from '../register/offer.js';
+import { isJourneyActive } from '../journey/flow.js';
+import { appendPending, finalizeToolCall } from '../session/pending.js';
+import { ERR } from '../errors/codes.js';
+import { resolveWriteTransport } from './transport-resolution.js';
+import { noteWriteTransport } from '../repl/current-transport.js';
+import { presentSafetyConfirmation } from '../repl/safety-confirm.js';
+import { isSafetyConfirmEnabled } from '../repl/safety-mode-state.js';
+// ── Transcript visibility helpers (D16-display + tour slide-7, 2026-06-12) ──
+//
+// Rule 7 auto-snapshots always fired but the transcript never said so
+// (battery D16-display). And the tour shows writes as
+// "① snapshot ✓ ② written ✓ ③ syntax ✓ ④ activated ✓" while real
+// transcripts showed an opaque tool row. Both lines below are HUMAN-stream
+// only (ctx.chunkEmitter) — tool RESULT payloads the model sees are
+// unchanged, and subagent ctxs (no chunkEmitter) stay silent.
+/** Dim one-liner when the Rule 7 auto-snapshot actually captured source. */
+export function emitSnapshotNotice(ctx, snap, type, name) {
+    if (snap?.taken && snap.entry) {
+        ctx.chunkEmitter?.emit('info', `snapshot ✓ ${type} ${name} ${snap.entry.timestamp}`);
+    }
+}
+/** Distinct LOUD note when the write proceeds against a fresh/never-activated
+ *  shell that has no committed active version — nothing to snapshot (Rule 7 is
+ *  satisfied because there is no prior source to protect). Kept separate from
+ *  the 'new_object' (genuine 404) path so the transcript is honest about which
+ *  case it was — this is the RAP behaviour-pool ZBP first-write. */
+export function emitNewShellNote(ctx, type, name) {
+    ctx.chunkEmitter?.emit('warn', `${type} ${name}: new/empty shell — no active version, no prior source to snapshot; proceeding with first write`);
+}
+/** Map the snapshot-gate outcome onto the chain line's honest states.
+ *  `undefined` covers the best-effort gates whose failure was swallowed.
+ *  'object_not_found' is a genuine ADT 404 only; any other read failure maps
+ *  to 'source_read_failed' (+ short detail) — never to "(new object)".
+ *  'new_shell' (exists but no active version — nothing to save) reuses the
+ *  'new_object' chain glyph; the honest which-case distinction is carried by
+ *  the LOUD emitNewShellNote line, not the compact chain. */
+export function snapshotChainState(snap) {
+    if (snap?.taken)
+        return { snapshot: 'taken' };
+    if (snap?.reason === 'object_not_found' || snap?.reason === 'new_shell') {
+        return { snapshot: 'new_object' };
+    }
+    if (snap?.reason === 'source_read_failed') {
+        return { snapshot: 'source_read_failed', snapshotDetail: snap.detail };
+    }
+    return { snapshot: 'best_effort_failed' };
+}
+/**
+ * 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.
+ */
+export function writtenWithSyntaxErrors(r) {
+    return r.writeStatus !== undefined && r.writeStatus >= 200 && r.writeStatus < 300 && r.syntaxResult?.hasErrors === true;
+}
+export 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. */
+export 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' };
+}
+/** Guided clean-core journey on: the fix lines in solo words (register/offer.ts). */
+export const journeyWording = (ctx) => (isJourneyActive(ctx.session) ? { wording: 'journey' } : {});
+/**
+ * 1.1.31 — the write itself activated and verified an object of the joined team
+ * project: CSPeach wrote it, so the fix is recorded for the developer (rehearsal
+ * 2026-10-07: the refactor's write activated the class; no separate sap_activate
+ * ran, so the hook in sap_activate alone never fired).
+ */
+export function recordOwnFixAfterWrite(ctx, type, name, transport, w) {
+    if (!w?.success || !w.verified)
+        return;
+    const written = new Map([[String(name).trim().toUpperCase(), String(transport ?? '').trim().toUpperCase()]]);
+    for (const line of teamFixOffers([{ type, name }], { written, ...journeyWording(ctx) }))
+        ctx.chunkEmitter?.emit('info', line);
+}
+export 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". */
+export 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). */
+export function emitWriteChain(ctx, input) {
+    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. */
+export function snapshotSource(snap) {
+    if (!snap?.taken || !snap.entry?.filePath)
+        return undefined;
+    try {
+        return readFileSync(snap.entry.filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+const refuse = (body) => ({ content: JSON.stringify(body), is_error: true });
+/** Rule 7 recovery text for a hard source snapshot that could not read the object. */
+const SOURCE_READ_RECOVERY = 'Pre-write source read failed (non-404) and no committed active version could be confirmed — the object may exist with source we could not read, so no snapshot was possible. If this is a live connection/auth problem, fix it and retry. If this is a freshly-created shell that got edit-locked by an earlier aborted write, recover it directly: unlock it (or activate the empty shell, then delete it) and re-run the create+write. Do not bypass Rule 7 by writing over source you never read.';
+/** Refuses a spec that would skip a gate without saying why. */
+export function validateWriteToolSpec(spec) {
+    if (spec.snapshot.kind === 'none' && !String(spec.snapshot.reason ?? '').trim()) {
+        throw new Error(`${spec.tool}: snapshot 'none' skips Rule 7 — a reason is required`);
+    }
+}
+/** The registered handler for a spec. Validates the spec now (registration time). */
+export function writeToolHandler(spec) {
+    validateWriteToolSpec(spec);
+    return (args, ctx) => runWritePipeline(args, ctx, spec);
+}
+/** Rule 7 — runs the spec's snapshot gate. A ToolResult means: refused, stop. */
+async function snapshotGate(a, ctx, spec, pre) {
+    const s = spec.snapshot;
+    if (s.kind === 'none')
+        return undefined;
+    if (s.kind === 'source') {
+        const type = s.type(a);
+        const name = s.name(a);
+        if (!s.hard) {
+            // Best-effort: the object may be a shell with no readable source.
+            try {
+                pre.snapshot = await autoSnapshot(name, type, ctx.adt);
+            }
+            catch { /* swallowed, as before */ }
+            emitSnapshotNotice(ctx, pre.snapshot, type, name);
+            return undefined;
+        }
+        // HARD gate: only a genuine 404 (new object) may proceed snapshot-less. A
+        // read failure on a possibly-EXISTING object means no recovery copy → block.
+        try {
+            pre.snapshot = await autoSnapshot(name, type, ctx.adt);
+        }
+        catch (err) {
+            return refuse({ error: ERR.SNAPSHOT_FAILED, detail: String(err) });
+        }
+        if (pre.snapshot?.reason === 'source_read_failed') {
+            return refuse({
+                error: ERR.SNAPSHOT_FAILED,
+                reason: 'source_read_failed',
+                detail: pre.snapshot.detail,
+                recovery: s.recovery ?? SOURCE_READ_RECOVERY,
+            });
+        }
+        // Fresh/never-activated shell (no active version → nothing to snapshot):
+        // proceed like a new object, but say so LOUDLY and distinctly.
+        if (pre.snapshot?.reason === 'new_shell')
+            emitNewShellNote(ctx, type, name);
+        emitSnapshotNotice(ctx, pre.snapshot, type, name);
+        return undefined;
+    }
+    if (s.kind === 'include') {
+        // Of the INCLUDE being overwritten; non-blocking, but a missing restore
+        // point is said out loud.
+        const className = s.className(a);
+        const includeType = s.includeType(a);
+        try {
+            pre.snapshot = await autoSnapshotClassInclude(className, includeType, ctx.adt);
+        }
+        catch (err) {
+            pre.snapshot = { taken: false, reason: 'source_read_failed', detail: String(err) };
+        }
+        emitSnapshotNotice(ctx, pre.snapshot, includeSnapshotType(includeType), className);
+        if (pre.snapshot?.reason === 'source_read_failed') {
+            ctx.chunkEmitter?.emit('warn', `CLAS ${className} ${includeType}: could not snapshot the include before writing `
+                + `(${pre.snapshot.detail ?? 'read failed'}) — this write has NO restore point; rewind cannot undo it`);
+        }
+        return undefined;
+    }
+    // messages — HARD gate, of the whole message class.
+    const name = s.name(a);
+    let snap;
+    try {
+        snap = await autoSnapshotMessageClass(name, ctx.adt);
+    }
+    catch (err) {
+        return refuse({ error: ERR.SNAPSHOT_FAILED, detail: String(err) });
+    }
+    pre.snapshot = snap;
+    if (snap.reason === 'object_not_found') {
+        return refuse({
+            error: 'message_class_not_found',
+            detail: `Message class ${name} does not exist. Create it first with sap_create_object type MSAG, then add the messages.`,
+        });
+    }
+    if (!snap.taken) {
+        return refuse({
+            error: ERR.SNAPSHOT_FAILED,
+            reason: snap.reason ?? 'source_read_failed',
+            detail: snap.detail,
+            recovery: 'The message class could not be read, so no snapshot was possible and nothing was written. If this is a connection or sign-in problem, fix it and try again.',
+        });
+    }
+    emitSnapshotNotice(ctx, snap, 'MSAG', name);
+    return undefined;
+}
+/** True only for SAP's own 404: the object is not there. Anything else is no proof. */
+const isNotFound = (err) => err instanceof SapError && err.httpStatus === 404;
+/**
+ * D7 — the audit row's status and reason from the verified outcome.
+ * `postCheckError`: the delete post-check could not run, so nothing proves the
+ * object is gone (final review I-1).
+ */
+function auditOutcome(syntax, stillExists, postCheckError) {
+    if (syntax && !syntax.ok) {
+        const why = syntax.didNotRun !== undefined
+            ? `syntax check did not run: ${syntax.didNotRun}`
+            : `syntax check found errors: ${syntax.errors.slice(0, 3).join('; ')}`;
+        return { status: 'error', reason: why };
+    }
+    if (stillExists === true)
+        return { status: 'error', reason: 'object still exists after the delete' };
+    if (postCheckError !== undefined)
+        return { status: 'error', reason: `delete not confirmed: ${postCheckError}` };
+    return { status: 'success' };
+}
+/**
+ * Runs one write through every gate, in the fixed order. Never throws for a
+ * SAP failure: each refusal is the envelope the tool always returned.
+ */
+export async function runWritePipeline(args, ctx, spec) {
+    const raw = args;
+    // ── Before the approval is spent (input / capability checks) ──────────────
+    if (spec.beforeApproval) {
+        const refusal = spec.beforeApproval(args, ctx);
+        if (refusal)
+            return refuse(refusal);
+    }
+    // ── Gate 1: Approval ──────────────────────────────────────────────────────
+    const verify = await verifyAndSpendApprovalId(raw.approval_id, spec.approval.object(args), spec.approval.op);
+    if (!verify.ok)
+        return refuse({ error: ERR.APPROVAL_INVALID, reason: verify.reason });
+    // 2026-10-04 — a plan-grant id holds the write to its claims (type, package, transport).
+    if (spec.approval.claims) {
+        const claim = grantClaimMismatch(verify.payload, spec.approval.claims(args, ctx));
+        if (claim)
+            return refuse({ error: ERR.APPROVAL_INVALID, reason: claim });
+    }
+    const pre = { toolUseId: ctx.toolUseId ?? crypto.randomUUID(), startedAt: Date.now(), extra: {} };
+    // ── Rule 9 conflict warning ───────────────────────────────────────────────
+    // The LLM passed an explicit transport that differs from the session
+    // current-transport. Informational only; the caller's intent wins.
+    {
+        const sessionTransport = ctx.currentTransport?.get() ?? null;
+        if (raw.transport && sessionTransport && raw.transport !== sessionTransport) {
+            ctx.chunkEmitter?.emit('warn', `LLM passed transport=${raw.transport} but session current-transport=${sessionTransport}`);
+        }
+    }
+    // ── Rule 9 transport ──────────────────────────────────────────────────────
+    if (spec.transport.mode === 'resolve' || spec.transport.mode === 'fallback-resolve') {
+        // D15/D20 — an object already locked in an open request is written under
+        // THAT request; any other transport is a guaranteed CTS lock conflict.
+        const supplied = spec.transport.mode === 'fallback-resolve'
+            ? raw.transport ?? ctx.currentTransport?.get() ?? undefined
+            : raw.transport;
+        const resolved = await resolveWriteTransport(ctx, spec.transport.type(args), spec.transport.name(args), supplied);
+        pre.transport = resolved.transport;
+        pre.owning = resolved.owning;
+        pre.note = resolved.note;
+        // 2026-10-04 — a plan-grant id never writes into a transport other than the grant's.
+        if (spec.transport.grantMismatch && grantOwningTransportMismatch(verify.payload, resolved.owning)) {
+            return refuse({
+                error: ERR.APPROVAL_INVALID, reason: 'transport_mismatch',
+                detail: grantOwningTransportDetail(spec.transport.name(args), resolved.owning),
+            });
+        }
+    }
+    else {
+        // Three-tier fallback: explicit arg → session current-transport → none.
+        pre.transport = raw.transport ?? ctx.currentTransport?.get() ?? undefined;
+    }
+    // ── Gate 2: Snapshot (Rule 7) ─────────────────────────────────────────────
+    const snapRefusal = await snapshotGate(args, ctx, spec, pre);
+    if (snapRefusal)
+        return snapRefusal;
+    // ── Gate 3: Safety confirmation (Rule 7) ──────────────────────────────────
+    if (spec.safetyConfirm && isSafetyConfirmEnabled()) {
+        const r = await presentSafetyConfirmation(spec.safetyConfirm(args, pre.transport ?? ctx.currentTransport?.get() ?? ''));
+        if (!r.confirmed)
+            return refuse({ error: 'cancelled_by_user', reason: r.reason });
+    }
+    // ── preGate (preview, transport fit, package prepare) ─────────────────────
+    if (spec.preGate) {
+        const g = await spec.preGate(args, ctx, pre);
+        if ('error' in g)
+            return refuse(g.error);
+        if (g.extra)
+            Object.assign(pre.extra, g.extra);
+    }
+    // ── WAL: record pending entry ─────────────────────────────────────────────
+    await appendPending(ctx.session, {
+        tool_use_id: pre.toolUseId,
+        tool: spec.tool,
+        args: spec.walArgs(args),
+        started_at: new Date().toISOString(),
+    });
+    // ── walGate (a step that changes SAP before the call; inside the entry) ───
+    if (spec.walGate) {
+        const g = await spec.walGate(args, ctx, pre);
+        if ('error' in g) {
+            await finalizeToolCall(ctx.session, pre.toolUseId, g.log, true, Date.now() - pre.startedAt);
+            return refuse(g.error);
+        }
+        if (g.extra)
+            Object.assign(pre.extra, g.extra);
+    }
+    // ── The write ─────────────────────────────────────────────────────────────
+    // sap-client write methods THROW only for catastrophic errors; an HTTP
+    // failure comes back in the result, so `landed` must look at it — without
+    // it a failed write reads as success (memory/project_phase3_lite_regression.md).
+    let result;
+    try {
+        result = await spec.call(args, ctx, pre);
+    }
+    catch (err) {
+        const errStr = String(err);
+        await finalizeToolCall(ctx.session, pre.toolUseId, spec.throwLog ? spec.throwLog(err) : errStr, true, Date.now() - pre.startedAt);
+        return refuse(spec.onThrow?.(err, args, pre) ?? { error: spec.errorCode, detail: errStr });
+    }
+    const landed = spec.landed(result, pre);
+    if (!landed.ok) {
+        if (landed.audit) {
+            await auditLog(spec.audit.method, spec.audit.type(args), spec.audit.name(args), landed.audit.status, Date.now() - pre.startedAt, landed.audit.reason);
+        }
+        await finalizeToolCall(ctx.session, pre.toolUseId, landed.log ?? landed.detail ?? '', true, Date.now() - pre.startedAt);
+        return refuse(landed.body ?? { error: spec.errorCode, detail: landed.detail, ...(landed.extra ?? {}) });
+    }
+    const none = spec.noWrite?.(args, result, pre);
+    if (none) {
+        await finalizeToolCall(ctx.session, pre.toolUseId, JSON.stringify(none.walResult), false, Date.now() - pre.startedAt);
+        return { content: JSON.stringify(none.envelope) };
+    }
+    noteWriteTransport(pre.transport); // F-L2-1 statusline wire
+    // ── Gate 4: Verify (Rule 10) ──────────────────────────────────────────────
+    const type = spec.audit.type(args);
+    const name = spec.audit.name(args);
+    const syntax = spec.verify.syntax ? await verifySyntax(ctx.adt, name, type) : undefined;
+    let stillExists;
+    let postCheckError;
+    if (spec.verify.deletedCheck) {
+        // The envelope reads a failed check as "gone" (as it always has); only a
+        // 404 proves it, so any other failure keeps the audit row off success.
+        stillExists = await ctx.adt.objectStructure(type, name).then(() => true).catch((err) => {
+            if (!isNotFound(err))
+                postCheckError = String(err);
+            return false;
+        });
+        pre.extra['still_exists'] = stillExists;
+    }
+    // ── D7: the audit row, after the check; its status follows the verified outcome.
+    {
+        const outcome = auditOutcome(syntax, stillExists, postCheckError);
+        const detail = [spec.audit.detail?.(args, result), outcome.reason].filter((x) => !!x).join(' | ');
+        await auditLog(spec.audit.method, type, name, outcome.status, Date.now() - pre.startedAt, detail || undefined);
+    }
+    await finalizeToolCall(ctx.session, pre.toolUseId, JSON.stringify(spec.walResult ? spec.walResult(args, result, pre, syntax, stillExists)
+        : spec.verify.deletedCheck ? { deleted: !stillExists }
+            : syntax ? { written: true, syntax }
+                : { written: true }), false, Date.now() - pre.startedAt);
+    const act = spec.verify.activation
+        ? await verifyWriteActivation(ctx, result, name, type)
+        : undefined;
+    // Tour slide-7 chain — derived from the gates that actually ran.
+    if (spec.chain)
+        emitWriteChain(ctx, spec.chain(args, pre, syntax, act));
+    spec.after?.(args, result, pre, ctx);
+    if (spec.verify.activation)
+        recordOwnFixAfterWrite(ctx, type, name, pre.owning ?? pre.transport, act);
+    return { content: JSON.stringify(spec.envelope(args, result, pre, syntax, act)) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.40",
+  "version": "1.1.41",
   "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.0",
-    "@cspeach/sap-client": "0.1.25",
+    "@cspeach/sap-client": "0.1.26",
     "@iarna/toml": "^2.2.5",
     "@inkjs/ui": "^2.0.0",
     "@inquirer/prompts": "^7.0.0",