@cspeach/cli 1.1.39 → 1.1.41

package/dist/agent/loop.js

@@ -57,6 +57,8 @@ import { expandTextFileAttachments } from '../projects/workspace.js';
 import { expandImageAttachments, buildUserContent, trimHistoryImages } from '../projects/image-attachments.js';
 import { expandImageChips } from '../ui/clipboard-image.js';
 import { getSapSystemInfo, renderSapSystemBlock } from '../sap/system-info.js';
+import { getSystemProfile, renderSapProfileBlock } from '../sap/system-profile.js';
+import { pinHiddenTools, withoutTools } from '../sap/profile-gate.js';
 import { renderStandaloneContextBlock } from '../sap/standalone-profile.js';
 import { renderStandardsBlock } from '../standards/standards-file.js';
 import { composeSessionContextBlock } from './session-context.js';
@@ -820,6 +822,7 @@ ${imageExpansion.error}`));
     // SAP block is then empty and the rest of enrichment proceeds as
     // before — no behavioral regression.
     let sapSystemBlock = '';
+    let sapProfileBlock = '';
     let sapSystemInfo = null;
     const standaloneTurn = isStandalone(params.ctx);
     if (standaloneTurn) {
@@ -828,10 +831,17 @@ ${imageExpansion.error}`));
         // so skills read one element in both modes — plus the manual-
         // implementation hand-off note.
         sapSystemBlock = renderStandaloneContextBlock(cfg.standalone);
+        params.ctx.systemProfile = null;
     }
     else if (params.ctx.adt && params.ctx.sapAlias) {
         sapSystemInfo = await getSapSystemInfo(params.ctx.adt, params.ctx.sapAlias);
+        // ADT gap program, Part 1 — the system profile rides the same lazy probe.
+        // Null (kill switch, no discovery and no CVERS) = today's behaviour.
+        // Part 2a D14: the turn's signal cancels the build's reads on Esc (null
+        // for this turn, nothing cached).
+        params.ctx.systemProfile = await getSystemProfile(params.ctx.adt, params.ctx.sapAlias, sapSystemInfo, { signal: params.signal });
         sapSystemBlock = renderSapSystemBlock(sapSystemInfo);
+        sapProfileBlock = renderSapProfileBlock(params.ctx.systemProfile);
     }
     // Customer development standards — opt-in, both modes. Renders '' when the
     // user has no standards file, so the composed block (and therefore the whole
@@ -842,7 +852,7 @@ ${imageExpansion.error}`));
     const switchNote = session.systemSwitchNote
         ? `<system_switch>${session.systemSwitchNote}</system_switch>`
         : '';
-    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, standardsBlock, switchNote]);
+    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, sapProfileBlock, standardsBlock, switchNote]);
     // Deterministically extract structured facts from the user's prompt
     // (package, transport, object names, environment hint, create intent)
     // and prepend them as an XML `<session_context>` block. The model reads
@@ -926,7 +936,14 @@ ${imageExpansion.error}`));
         env: process.env,
         served: servedToolLoading(),
     });
-    const contextTools = toolsForContext(listTools(), params.ctx);
+    // Part 1 (D4, R7) — the hidden set is pinned per alias on the first
+    // connected turn and reused, so tools[] stays byte-stable; [] pinned = same
+    // array as today. A standalone or unconnected turn pins nothing.
+    const connectedTurn = !standaloneTurn && !!params.ctx.adt && !!params.ctx.sapAlias;
+    const hiddenSapTools = connectedTurn
+        ? pinHiddenTools(session, params.ctx.sapAlias, listTools(), params.ctx.systemProfile ?? null)
+        : [];
+    const contextTools = withoutTools(toolsForContext(listTools(), params.ctx), hiddenSapTools);
     // Task 18 fixes M4 / M5 — no read_agent for an agent_run child, and none
     // when a reader would have no real read tool (standalone, file tools off).
     const visibleTools = params.ctx.subagent || !hasReaderReadTools(new Set(contextTools.map((t) => t.name)))

package/dist/agent/tool-dispatch.js

@@ -9,6 +9,8 @@ import { shouldGateRule8, recordWriteOp, renderPlanSummary, getWriteOpsThisTurn,
 import { isCredentialHandoverApproved, markCredentialHandoverApproved, } from '../repl/credential-handover-gate.js';
 import { READER_TOOLS } from '../tools/subagent/reader-prompt.js';
 import { riskOf } from './risk-gate.js';
+import { NOT_ON_THIS_RELEASE, gateWithVerify } from '../sap/profile-gate.js';
+import { INTERRUPTED_TOOL_RESULT } from './repair-partial.js';
 const READER_TOOL_SET = new Set(READER_TOOLS);
 export async function dispatchTool(name, args, ctx) {
     const tool = getTool(name);
@@ -36,6 +38,21 @@ export async function dispatchTool(name, args, ctx) {
             is_error: true,
         };
     }
+    // ADT gap program, Part 1 (D4) — a definite "not on this release" is
+    // answered here, before any SAP call, as a normal tool error. Unknown or
+    // no profile: today's path, untouched. Part 2a D11 — a `no` is verified
+    // against a fresh profile once per alias before it is believed.
+    const gate = await gateWithVerify(tool, args, ctx);
+    if (gate) {
+        return {
+            content: JSON.stringify({ error: NOT_ON_THIS_RELEASE, feature: gate.feature, message: gate.message }),
+            is_error: true,
+        };
+    }
+    // Final review I-3 — the D11 re-check can take seconds of SAP reads; an Esc
+    // in that window must stop the call here, not let the handler run "as unknown".
+    if (ctx.signal?.aborted)
+        return { content: INTERRUPTED_TOOL_RESULT, is_error: true };
     // L1-6 R1-6 (owner decision 2026-09-21) — a call that hands the stored SAP
     // login to a local child process ALWAYS asks a human, once per session per
     // alias, even as the first mutating call of a turn (where Rule 8 below stays

package/dist/sap/profile-features.js

@@ -0,0 +1,42 @@
+const A = '/sap/bc/adt';
+export const FEATURES = Object.freeze({
+    'cds.ddls': { label: 'CDS data definitions', collection: `${A}/ddic/ddl/sources`, since: { basis: 740, sp: 5, label: 'ABAP 7.40 SP05' }, provenOnOurBox: true },
+    'cds.viewEntity': { label: 'CDS view entities (define view entity)', since: { basis: 755, label: 'S/4HANA 2020 (ABAP 7.55)' }, provenOnOurBox: true },
+    'cds.tableEntity': { label: 'CDS table entities (define table entity)', since: { basis: 816, label: 'S/4HANA 2025 (ABAP 8.16)' }, provenOnOurBox: false },
+    'cds.ddlx': { label: 'CDS metadata extensions', collection: `${A}/ddic/ddlx/sources`, since: { basis: 751, label: 'ABAP 7.51' }, provenOnOurBox: true },
+    'cds.dcls': { label: 'CDS access controls (DCL)', collection: `${A}/acm/dcl/sources`, since: { basis: 740, sp: 10, label: 'ABAP 7.40 SP10' }, provenOnOurBox: true },
+    'rap.bdef': { label: 'Behavior definitions (RAP)', collection: `${A}/bo/behaviordefinitions`, since: { basis: 753, label: 'S/4HANA 1809 (ABAP 7.53)' }, provenOnOurBox: true },
+    // Final review I1 (owner rule: a wrong no is worse than unknown): the next six
+    // rows had release floors with no cited source (gap table §3.1 gives one date
+    // for five RAP/CDS objects; "1709" for table/structure; "1610 / 7.50" for
+    // domain/data element). Dropped: listed = yes, else unknown, never no. Add a
+    // floor back only with a citation (SAP Help release line or ADT feature matrix).
+    'rap.srvd': { label: 'Service definitions', collection: `${A}/ddic/srvd/sources`, provenOnOurBox: true },
+    'rap.srvb': { label: 'Service bindings', collection: `${A}/businessservices/bindings`, provenOnOurBox: true },
+    'ddic.tables': { label: 'Tables in ADT', collection: `${A}/ddic/tables`, provenOnOurBox: true },
+    'ddic.structures': { label: 'Structures in ADT', collection: `${A}/ddic/structures`, provenOnOurBox: true },
+    'ddic.domains': { label: 'Domains in ADT', collection: `${A}/ddic/domains`, provenOnOurBox: true },
+    'ddic.dataelements': { label: 'Data elements in ADT', collection: `${A}/ddic/dataelements`, provenOnOurBox: true },
+    'generator.repository': { label: "SAP's RAP generator", collection: `${A}/repository/generators`, since: { basis: 757, label: 'S/4HANA 2022 (ABAP 7.57)' }, absentMeansNo: true, provenOnOurBox: true },
+    'atc.worklists': { label: 'ATC checks', collection: `${A}/atc/worklists`, since: { basis: 740, label: 'ABAP 7.40' }, provenOnOurBox: true },
+    'unit.testruns': { label: 'ABAP Unit runs', collection: `${A}/abapunit/testruns`, provenOnOurBox: true },
+    'text.programs': { label: 'Text elements of programs', collection: `${A}/textelements/programs`, since: { basis: 740, sp: 8, label: 'ABAP 7.40 SP08' }, provenOnOurBox: true },
+    // No `since` (R4): the profile's own CVERS reads use this endpoint, so a
+    // release-based `no` could only ever be wrong. Listed = yes, else unknown.
+    'datapreview.freestyle': { label: 'SQL data preview', collection: `${A}/datapreview/freestyle`, provenOnOurBox: true },
+    'msag': { label: 'Message classes', collection: `${A}/messageclass`, provenOnOurBox: true },
+    'nrob': { label: 'Number range objects', collection: `${A}/numberranges/objects`, provenOnOurBox: true },
+});
+export const FEATURE_IDS = Object.freeze(Object.keys(FEATURES));
+export function isFeatureId(s) {
+    return Object.prototype.hasOwnProperty.call(FEATURES, s);
+}
+/** url-mapper type token (upper case) → the feature it needs. Unlisted types need nothing. */
+export const OBJECT_TYPE_FEATURE = Object.freeze({
+    BDEF: 'rap.bdef', SRVD: 'rap.srvd', SRVB: 'rap.srvb',
+    DDLS: 'cds.ddls', CDS: 'cds.ddls', DDLX: 'cds.ddlx', DCLS: 'cds.dcls',
+    TABL: 'ddic.tables', STRU: 'ddic.structures', DOMA: 'ddic.domains', DTEL: 'ddic.dataelements',
+    MSAG: 'msag', NROB: 'nrob',
+});
+/** The RAP/CDS subset: the only types a READ is ever refused for (R6). */
+export const READ_GATED_TYPES = new Set(['BDEF', 'SRVD', 'SRVB', 'DDLS', 'CDS', 'DDLX', 'DCLS']);

package/dist/sap/profile-gate.js

@@ -0,0 +1,105 @@
+import { FEATURES, OBJECT_TYPE_FEATURE, READ_GATED_TYPES } from './profile-features.js';
+import { getSystemProfile, supports, systemLabel } from './system-profile.js';
+import { getSapSystemInfo } from './system-info.js';
+export const NOT_ON_THIS_RELEASE = 'not_on_this_release';
+/** For tools whose `type` argument names an object type (url-mapper token). */
+export function byObjectType(args) {
+    const t = typeof args?.type === 'string' ? args.type.trim().toUpperCase() : '';
+    return t && Object.prototype.hasOwnProperty.call(OBJECT_TYPE_FEATURE, t) ? OBJECT_TYPE_FEATURE[t] : null;
+}
+/**
+ * R6 — reads refuse only RAP/CDS types (they cannot exist below their release).
+ * DDIC types carry no release floor at all (final review I1); a DDIC read was never proven to fail, and a
+ * wrong read costs one 404 while a wrong `no` costs the user's work.
+ */
+export function byObjectTypeForRead(args) {
+    const t = typeof args?.type === 'string' ? args.type.trim().toUpperCase() : '';
+    return READ_GATED_TYPES.has(t) ? byObjectType(args) : null;
+}
+export function requiredFeature(tool, args) {
+    const r = tool.requires;
+    if (!r)
+        return null;
+    return typeof r === 'function' ? r(args) : r;
+}
+export function profileGate(tool, args, profile) {
+    if (!profile)
+        return null;
+    const feature = requiredFeature(tool, args);
+    if (!feature)
+        return null;
+    const v = supports(profile, feature);
+    if (v.answer !== 'no')
+        return null;
+    // I2 — name when the facts were read: the profile is kept up to 30 days.
+    return { feature, message: `${FEATURES[feature].label}: ${v.reason}. This system: ${systemLabel(profile)}, read ${profile.builtAt.slice(0, 10)}.` };
+}
+/** Names of the tools whose FIXED feature is a definite no. [] for no profile. */
+export function hiddenByProfile(tools, profile) {
+    if (!profile)
+        return [];
+    return tools.filter((t) => typeof t.requires === 'string' && supports(profile, t.requires).answer === 'no').map((t) => t.name);
+}
+/** Drop the named tools. Same array back when nothing changes (byte-identical path). */
+export function withoutTools(tools, hidden) {
+    if (hidden.length === 0)
+        return tools;
+    const set = new Set(hidden);
+    const kept = tools.filter((t) => !set.has(t.name));
+    return kept.length === tools.length ? tools : kept;
+}
+export function toolsForProfile(tools, profile) {
+    return withoutTools(tools, hiddenByProfile(tools, profile));
+}
+/**
+ * R7 / D4 — tools[] must be byte-stable for the session (prompt cache,
+ * preserved thinking), but it is rebuilt every turn. The hidden set is pinned
+ * on the session the first time an alias is seen — whatever the profile was
+ * on that turn (null pins []) — and reused after that. Another alias re-pins.
+ * A profile that arrives later refuses per call at dispatch instead.
+ */
+export function pinHiddenTools(session, alias, tools, profile) {
+    const pinned = session.profile_hidden_tools;
+    if (pinned && pinned.alias === alias)
+        return pinned.names;
+    const names = hiddenByProfile(tools, profile);
+    session.profile_hidden_tools = { alias, names };
+    return names;
+}
+// ── Part 2a — the three profile gates (owner decisions D11–D13) ────────────
+const verifiedThisProcess = new Set(); // alias → a fresh rebuild returned a profile after a `no`
+export function _resetVerifiedForTests() { verifiedThisProcess.clear(); }
+/**
+ * D11 — a definite `no` is checked against a fresh profile once per alias per
+ * process before it is believed: the cache is up to 30 days old and the system
+ * may have been upgraded. The pinned tool list is not touched (R7).
+ */
+export async function gateWithVerify(tool, args, ctx) {
+    const first = profileGate(tool, args, ctx.systemProfile ?? null);
+    if (!first || verifiedThisProcess.has(ctx.sapAlias))
+        return first;
+    const info = await getSapSystemInfo(ctx.adt, ctx.sapAlias, { fresh: true });
+    ctx.systemProfile = await getSystemProfile(ctx.adt, ctx.sapAlias, info, { fresh: true, signal: ctx.signal });
+    // Only a rebuild that returned a profile counts as verified. An aborted or
+    // failed one leaves the alias unmarked (this call runs as unknown), so the
+    // next refusal of a stale cached `no` re-checks: one attempt per refusal.
+    if (ctx.systemProfile)
+        verifiedThisProcess.add(ctx.sapAlias);
+    return profileGate(tool, args, ctx.systemProfile ?? null);
+}
+/** D12 — the changes of a request_approval call whose type's feature is a definite no (after verify). */
+export async function approvalRefusedByProfile(changes, ctx) {
+    const out = [];
+    for (const c of changes) {
+        if (!['create', 'modify', 'delete'].includes(c.op))
+            continue;
+        const g = await gateWithVerify({ name: 'request_approval', requires: byObjectType }, { type: c.type }, ctx);
+        if (g)
+            out.push({ object: c.object, type: String(c.type ?? ''), message: g.message });
+    }
+    return out;
+}
+/** D13 — a resumed session pins its hidden tools again on its first turn. */
+export function clearProfilePin(session) {
+    delete session.profile_hidden_tools;
+}

package/dist/sap/system-info.js

@@ -30,16 +30,21 @@ const memCache = new Map();
  * Top-level entry point. Returns cached info when available, queries
  * CVERS once otherwise, persists the result, returns null on any error.
  */
-export async function getSapSystemInfo(adt, alias) {
-    // Layer 1 — process memory
-    const cached = memCache.get(alias);
-    if (cached)
-        return cached;
-    // Layer 2 — disk
-    const fromDisk = readDiskCache(alias);
-    if (fromDisk) {
-        memCache.set(alias, fromDisk);
-        return fromDisk;
+export async function getSapSystemInfo(adt, alias, opts = {}) {
+    // Part 2a D11 — `fresh` skips layers 1 and 2 (a definite "no" is checked
+    // against the live system before it is believed); the live path below is
+    // unchanged and refreshes both caches on success.
+    if (!opts.fresh) {
+        // Layer 1 — process memory
+        const cached = memCache.get(alias);
+        if (cached)
+            return cached;
+        // Layer 2 — disk
+        const fromDisk = readDiskCache(alias);
+        if (fromDisk) {
+            memCache.set(alias, fromDisk);
+            return fromDisk;
+        }
     }
     // Layer 3 — live query
     const startedAt = Date.now();
@@ -535,6 +540,6 @@ export function renderSapSystemBlock(info) {
     ].join(' ');
     return `<sap_system ${attrs} />`;
 }
-function escapeAttr(s) {
+export function escapeAttr(s) {
     return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }

package/dist/sap/system-profile.js

@@ -0,0 +1,337 @@
+// cspeach-cli/src/sap/system-profile.ts
+/**
+ * System profile (ADT gap program, Part 1; spec §2.1).
+ *
+ * One profile per connected SAP system, built from the facts the CLI already
+ * has (system-info: CVERS release) plus two reads cached for 30 days: the ADT
+ * discovery document and the SAP_BASIS support pack. `supports()` answers
+ * yes / no / unknown with a plain reason. Unknown changes nothing: tools run
+ * as today and fail at HTTP time if the feature is missing. Only a definite
+ * `no` stops a call before it reaches SAP.
+ *
+ * Evidence rules (owner decision D1): a collection LISTED by discovery is a
+ * yes; an unlisted one proves nothing (our S/4HANA 2023 box omits endpoints
+ * that work). A `no` comes from the release table alone, except the generator,
+ * which keeps today's getGeneratorFact reading (absent = no = CSPeach writer).
+ */
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { auditLog } from '@cspeach/sap-client';
+import { cspeachRoot } from '../config/paths.js';
+import { escapeAttr } from './system-info.js';
+import { FEATURES, FEATURE_IDS } from './profile-features.js';
+export function releaseAtLeast(p, min) {
+    if (p.basis === null)
+        return null;
+    if (p.basis > min.basis)
+        return true;
+    if (p.basis < min.basis)
+        return false;
+    if (min.sp === undefined)
+        return true;
+    if (p.sp === null)
+        return null;
+    return p.sp >= min.sp;
+}
+export function systemLabel(p) {
+    if (p.basis === null && p.release === 'unknown')
+        return 'unknown release';
+    const sp = p.sp === null ? '' : ` SP${String(p.sp).padStart(2, '0')}`;
+    const abap = p.abapVersion === 'unknown' ? '' : ` (ABAP ${p.abapVersion})`;
+    return `${p.release}${sp}${abap}`;
+}
+export function supports(p, id) {
+    const rule = FEATURES[id];
+    if (!p)
+        return { answer: 'unknown', reason: 'system profile not available' };
+    const listed = !!rule.collection && p.discovery.read && p.discovery.collections.includes(rule.collection);
+    if (listed)
+        return { answer: 'yes', reason: 'listed by this system' };
+    const byRelease = rule.since ? releaseAtLeast(p, rule.since) : null;
+    if (rule.since && byRelease === false)
+        return { answer: 'no', reason: `needs ${rule.since.label} or later` };
+    // R3 — the generator must agree with getGeneratorFact for the same body:
+    // list unread = fact unknown (HTTP ≥ 400) or no (HTML page), never a yes by release.
+    if (rule.absentMeansNo && rule.collection && !p.discovery.read)
+        return { answer: 'unknown', reason: 'the system list could not be read' };
+    if (rule.absentMeansNo && rule.collection && p.discovery.read)
+        return { answer: 'no', reason: 'not offered by this system' };
+    if (rule.since && byRelease === true)
+        return { answer: 'yes', reason: `${systemLabel(p)} has it` };
+    if (rule.since && p.basis !== null && p.basis === rule.since.basis && p.sp === null) {
+        return { answer: 'unknown', reason: `needs ${rule.since.label}; this system is ${p.abapVersion} with an unknown support pack` };
+    }
+    if (!p.discovery.read && rule.collection)
+        return { answer: 'unknown', reason: 'the system list could not be read' };
+    return { answer: 'unknown', reason: 'no release fact covers it' };
+}
+function basisOf(info) {
+    const raw = info?.components?.['SAP_BASIS'];
+    if (!raw || !/^\d{3}$/.test(raw.trim()))
+        return null;
+    return Number(raw.trim());
+}
+export function profileFrom(i) {
+    if (!i.info && !i.discovery)
+        return null;
+    const basis = basisOf(i.info);
+    return {
+        alias: i.alias,
+        baseUrl: i.baseUrl,
+        platform: i.info?.platform ?? 'unknown',
+        release: i.info?.release ?? 'unknown',
+        abapVersion: i.info?.abapVersion ?? 'unknown',
+        basis,
+        sp: basis === null ? null : i.sp,
+        cloud: i.info && Object.keys(i.info.components).length > 0 ? 'no' : 'unknown',
+        discovery: i.discovery
+            ? { read: true, collections: Object.keys(i.discovery.collections).sort() }
+            : { read: false, collections: [] },
+        builtAt: i.now.toISOString(),
+    };
+}
+const CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+/** Bump when the stored shape or its meaning changes. */
+const CACHE_VERSION = 1;
+const SP_SQL = "SELECT COMPONENT, RELEASE, EXTRELEASE FROM CVERS WHERE COMPONENT = 'SAP_BASIS'";
+/**
+ * Final review I4 — an incomplete build (list or SP not read) is never written
+ * as a profile (R2), so without this it would cost both reads on every CLI
+ * start. The ATTEMPT is remembered per alias for a day (when, and against
+ * which system — no answers), and each read is bounded in time.
+ */
+const ATTEMPT_TTL_MS = 24 * 60 * 60 * 1000;
+const READ_TIMEOUT_MS = 15_000;
+/** Last build per alias for this process — null included (X3: a failed turn is not retried every turn). */
+const memCache = new Map();
+export function _resetSystemProfileCache() {
+    memCache.clear();
+}
+/**
+ * The SAP_BASIS support pack from the column-major data preview ('0002' → 2).
+ * Sibling of parseCvers (system-info.ts), which reads the same shape into
+ * component → release; that function and its SQL stay untouched (D2).
+ */
+export function parseExtRelease(xml) {
+    const colsRe = /<(?:[\w:]+:)?columns\b[^>]*>([\s\S]*?)<\/(?:[\w:]+:)?columns\s*>/g;
+    let m;
+    while ((m = colsRe.exec(xml)) !== null) {
+        const block = m[1];
+        const name = /<(?:[\w:]+:)?metadata\b[^>]*?\b(?:[\w:]+:)?name="([^"]+)"/i.exec(block)?.[1];
+        if (!name || name.toUpperCase() !== 'EXTRELEASE')
+            continue;
+        const value = /<(?:[\w:]+:)?data\b(?:\s[^>]*?)?>([\s\S]*?)<\/(?:[\w:]+:)?data\s*>/.exec(block)?.[1]?.trim() ?? '';
+        const digits = /(\d+)\s*$/.exec(value)?.[1];
+        return digits ? Number(digits) : null;
+    }
+    return null;
+}
+export async function getSystemProfile(adt, alias, info, opts = {}) {
+    const env = opts.env ?? process.env;
+    if ((env['CSPEACH_SYSTEM_PROFILE'] ?? '').trim().toLowerCase() === 'off')
+        return null;
+    const now = opts.now ?? (() => new Date());
+    const conn = adt.connection;
+    const baseUrl = conn?.getBaseUrl?.() ?? '';
+    if (!opts.fresh) {
+        if (memCache.has(alias)) {
+            const hit = memCache.get(alias) ?? null;
+            if (hit === null || sameSystem(hit, baseUrl, info))
+                return hit;
+        }
+        const fromDisk = readDiskCache(alias, now());
+        if (fromDisk && sameSystem(fromDisk, baseUrl, info)) {
+            memCache.set(alias, fromDisk);
+            return fromDisk;
+        }
+        // I4 — an incomplete build was tried for this system within the day: no
+        // profile this start (unknown everywhere = today's behaviour), no requests.
+        if (recentAttempt(alias, baseUrl, info, now())) {
+            memCache.set(alias, null);
+            return null;
+        }
+    }
+    const timeoutMs = opts.readTimeoutMs ?? READ_TIMEOUT_MS;
+    // Part 2a D14 — an abort is not a result. Esc during the build returns null
+    // and touches NOTHING (no memory cache, no disk cache, no attempt marker,
+    // no audit row), so the next turn builds again. Any other failure keeps the
+    // path below exactly.
+    const signal = opts.signal;
+    if (signal?.aborted)
+        return null;
+    const startedAt = Date.now();
+    try {
+        let discovery = null;
+        // The GET carries a socket timeout and the turn's signal, so Esc (or a
+        // dead socket) frees the connection's request slot; `bounded` stays as the
+        // outer wall-clock guard for an adt that does not honour either.
+        try {
+            discovery = await bounded(adt.discovery({ timeoutMs, signal }), timeoutMs);
+        }
+        catch (err) {
+            if (isAbort(err, signal))
+                return null;
+            discovery = null;
+        }
+        if (signal?.aborted)
+            return null;
+        let sp = null;
+        if (info?.components?.['SAP_BASIS'] && conn?.post) {
+            try {
+                // The signal rides post's 6th argument with no timeoutMs (the default
+                // socket timeout, as before). Without a signal the call is unchanged.
+                const spArgs = ['/sap/bc/adt/datapreview/freestyle?rowNumber=5', SP_SQL, 'text/plain', 'application/vnd.sap.adt.datapreview.table.v1+xml'];
+                const resp = await bounded(signal ? conn.post(...spArgs, undefined, signal) : conn.post(...spArgs), timeoutMs);
+                if (resp && resp.status === 200)
+                    sp = parseExtRelease(resp.body);
+            }
+            catch (err) {
+                if (isAbort(err, signal))
+                    return null;
+                sp = null;
+            }
+            if (signal?.aborted)
+                return null;
+        }
+        const profile = profileFrom({ alias, baseUrl, info, sp, discovery, now: now() });
+        if (!profile) {
+            memCache.set(alias, null);
+            writeAttempt(alias, baseUrl, info, now());
+            await auditLog('sapProfile', 'ALIAS', alias, 'error', Date.now() - startedAt, 'no discovery and no system info');
+            return null;
+        }
+        memCache.set(alias, profile);
+        // R2 — same rule as system-info's failed probe: never persist what was not
+        // read. Complete = list read, and the SP read (or no SAP_BASIS to read it for).
+        const complete = profile.discovery.read && (profile.sp !== null || profile.basis === null);
+        if (complete) {
+            writeDiskCache(alias, profile);
+            clearAttempt(alias);
+        }
+        else
+            writeAttempt(alias, baseUrl, info, now());
+        await auditLog('sapProfile', 'ALIAS', alias, 'success', Date.now() - startedAt, `release=${profile.release} sp=${profile.sp ?? 'unknown'} discovery=${profile.discovery.read ? profile.discovery.collections.length : 'not read'} cached=${complete ? 'disk' : 'memory'}`);
+        return profile;
+    }
+    catch (err) {
+        memCache.set(alias, null);
+        writeAttempt(alias, baseUrl, info, now());
+        await auditLog('sapProfile', 'ALIAS', alias, 'error', Date.now() - startedAt, `threw: ${err.message}`);
+        return null;
+    }
+}
+/** True for an `AbortError` from the request, or once the turn's signal has fired. */
+function isAbort(err, signal) {
+    return signal?.aborted === true || err?.name === 'AbortError';
+}
+function sameSystem(p, baseUrl, info) {
+    if (baseUrl && p.baseUrl && p.baseUrl !== baseUrl)
+        return false;
+    if (!info)
+        return true;
+    return p.release === info.release && p.abapVersion === info.abapVersion;
+}
+function cacheFile(alias, kind = 'profile') {
+    const safe = alias.replace(/[^A-Za-z0-9._-]/g, '_');
+    return join(cspeachRoot(), 'sap-cache', `${safe}.${kind}.json`);
+}
+/** Resolves to null when the read takes longer than `ms` (the request itself is left to finish). */
+function bounded(p, ms) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), ms);
+        timer.unref?.();
+    });
+    return Promise.race([p, timeout]).finally(() => { if (timer)
+        clearTimeout(timer); });
+}
+function recentAttempt(alias, baseUrl, info, now) {
+    try {
+        const path = cacheFile(alias, 'profile-attempt');
+        if (!existsSync(path))
+            return false;
+        const a = JSON.parse(readFileSync(path, 'utf8'));
+        const at = new Date(a.attemptedAt).getTime();
+        if (!Number.isFinite(at) || now.getTime() - at > ATTEMPT_TTL_MS || now.getTime() < at)
+            return false;
+        if (a.baseUrl !== baseUrl)
+            return false;
+        return a.release === (info?.release ?? 'unknown') && a.abapVersion === (info?.abapVersion ?? 'unknown');
+    }
+    catch {
+        return false;
+    }
+}
+function writeAttempt(alias, baseUrl, info, now) {
+    try {
+        const dir = join(cspeachRoot(), 'sap-cache');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const a = { attemptedAt: now.toISOString(), baseUrl, release: info?.release ?? 'unknown', abapVersion: info?.abapVersion ?? 'unknown' };
+        writeFileSync(cacheFile(alias, 'profile-attempt'), JSON.stringify(a, null, 2), 'utf8');
+    }
+    catch {
+        // best effort — at worst the next start tries the build again
+    }
+}
+function clearAttempt(alias) {
+    try {
+        rmSync(cacheFile(alias, 'profile-attempt'), { force: true });
+    }
+    catch { /* best effort */ }
+}
+function readDiskCache(alias, now) {
+    try {
+        const path = cacheFile(alias);
+        if (!existsSync(path))
+            return null;
+        const raw = JSON.parse(readFileSync(path, 'utf8'));
+        if (raw.cacheVersion !== CACHE_VERSION || !raw.builtAt)
+            return null;
+        if (now.getTime() - new Date(raw.builtAt).getTime() > CACHE_TTL_MS)
+            return null;
+        const { cacheVersion: _v, ...profile } = raw;
+        return profile;
+    }
+    catch {
+        return null;
+    }
+}
+function writeDiskCache(alias, profile) {
+    try {
+        const dir = join(cspeachRoot(), 'sap-cache');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(cacheFile(alias), JSON.stringify({ ...profile, cacheVersion: CACHE_VERSION }, null, 2), 'utf8');
+    }
+    catch {
+        // best effort — the memory result is still returned
+    }
+}
+/** The one-line summary for <session_context>; '' when there is no profile. */
+export function renderSapProfileBlock(p) {
+    if (!p)
+        return '';
+    const answer = (id) => supports(p, id).answer;
+    const viewEntity = answer('cds.viewEntity');
+    const cdsSyntax = viewEntity === 'yes' ? 'define view entity' : viewEntity === 'no' ? 'define view' : 'unknown';
+    const notAvailable = FEATURE_IDS
+        .map((id) => ({ id, v: supports(p, id) }))
+        .filter((x) => x.v.answer === 'no')
+        .map((x) => `${FEATURES[x.id].label}: ${x.v.reason}`)
+        .join('; ') || 'none known';
+    const attrs = [
+        `release="${escapeAttr(p.release)}"`,
+        `sp="${p.sp === null ? 'unknown' : `SP${String(p.sp).padStart(2, '0')}`}"`,
+        `abap="${escapeAttr(p.abapVersion)}"`,
+        `cloud="${p.cloud}"`,
+        `cds_view_syntax="${cdsSyntax}"`,
+        `rap="${answer('rap.bdef')}"`,
+        `rap_generator="${answer('generator.repository')}"`,
+        `table_entity="${answer('cds.tableEntity')}"`,
+        `discovery="${p.discovery.read ? 'read' : 'not read'}"`,
+        `built="${p.builtAt.slice(0, 10)}"`,
+        `not_available="${escapeAttr(notAvailable)}"`,
+    ];
+    return `<sap_profile ${attrs.join(' ')} />`;
+}

package/dist/session/resume.js

@@ -14,6 +14,7 @@ import { interruptedPickerLine } from './interrupt-reason.js';
 import stringWidth from 'string-width';
 import { STANDALONE_ALIAS } from '../tools/index.js';
 import { loadConfig, resolveStandalone } from '../config/loader.js';
+import { clearProfilePin } from '../sap/profile-gate.js';
 /** inquirer's Ctrl+C / force-close rejection. */
 function isPromptCancel(err) {
     return err?.name === 'ExitPromptError';
@@ -99,6 +100,8 @@ export async function runResume(id, opts = {}) {
     let session;
     try {
         session = await loadSession(targetId);
+        // Part 2a D13 — re-pin the hidden tools on the first connected turn.
+        clearProfilePin(session);
     }
     catch (err) {
         console.error('\n' + formatFailure({ what: 'Could not load the session', detail: [err.message], next: 'cspeach --resume  (pick from the list)' }));

package/dist/tools/approval.js

@@ -27,6 +27,7 @@ import { markPlanGateApproved } from '../repl/rule8-detector.js';
 import { getEffectiveWriteMode } from '../repl/mode-cycle.js';
 import { getCurrentTransport } from '../repl/current-transport.js';
 import { displayTransport } from '../approvals/op-labels.js';
+import { NOT_ON_THIS_RELEASE, approvalRefusedByProfile } from '../sap/profile-gate.js';
 import { isGuardedRunActive, getCurrentPhaseWrites, notePlanDeviation, PLAN_DEVIATION_DETAIL, } from '../commands/plan-gate.js';
 /**
  * Advisory-only replacement for the per-change approval gauntlet.
@@ -184,6 +185,17 @@ registerTool({
                 is_error: true,
             };
         }
+        // Part 2a D12 — never draw a card for a write this release cannot take.
+        if (ctx.systemProfile) {
+            const refused = await approvalRefusedByProfile(args.changes ?? [], ctx);
+            if (refused.length > 0) {
+                return {
+                    content: JSON.stringify({ error: NOT_ON_THIS_RELEASE, approved: false, changes: refused,
+                        message: `This system cannot take ${refused.length === 1 ? 'this change' : 'these changes'}: ${refused.map((r) => `${r.type} ${r.object} — ${r.message}`).join('; ')}` }),
+                    is_error: true,
+                };
+            }
+        }
         let cfg = await loadConfig();
         // Task 2 (ux-wave1) — the approval flow reads the EFFECTIVE write mode:
         // config overlaid by the session override, clamped to the active alias's