@cspeach/cli 1.1.40 → 1.1.41

package/dist/agent/loop.js

@@ -837,7 +837,9 @@ ${imageExpansion.error}`));
         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.
-        params.ctx.systemProfile = await getSystemProfile(params.ctx.adt, params.ctx.sapAlias, sapSystemInfo);
+        // 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);
     }

package/dist/agent/tool-dispatch.js

@@ -9,7 +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, profileGate } from '../sap/profile-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);
@@ -39,14 +40,19 @@ export async function dispatchTool(name, args, ctx) {
     }
     // 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.
-    const gate = profileGate(tool, args, ctx.systemProfile ?? null);
+    // 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-gate.js

@@ -1,5 +1,6 @@
 import { FEATURES, OBJECT_TYPE_FEATURE, READ_GATED_TYPES } from './profile-features.js';
-import { supports, systemLabel } from './system-profile.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) {
@@ -65,3 +66,40 @@ export function pinHiddenTools(session, alias, 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();

package/dist/sap/system-profile.js

@@ -152,25 +152,46 @@ export async function getSystemProfile(adt, alias, info, opts = {}) {
         }
     }
     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);
+            discovery = await bounded(adt.discovery({ timeoutMs, signal }), timeoutMs);
         }
-        catch {
+        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 {
-                const resp = await bounded(conn.post('/sap/bc/adt/datapreview/freestyle?rowNumber=5', SP_SQL, 'text/plain', 'application/vnd.sap.adt.datapreview.table.v1+xml'), timeoutMs);
+                // 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 {
+            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) {
@@ -199,6 +220,10 @@ export async function getSystemProfile(adt, alias, info, opts = {}) {
         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;

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