@cspeach/cli 1.1.2 → 1.1.3

package/dist/standards/standards-file.js

@@ -0,0 +1,107 @@
+/**
+ * Customer development standards — the team's own ABAP conventions, injected
+ * into every turn's `<session_context>` so skills follow the customer's rules
+ * instead of CSPeach's defaults.
+ *
+ * Entirely opt-in: when no standards file exists this module renders NOTHING,
+ * so an existing user's prompts are byte-identical to before the feature.
+ *
+ * Lookup order (first hit wins):
+ *   1. `<cwd>/CSPEACH-STANDARDS.md`   — checked in next to the code
+ *   2. `<cwd>/.cspeach/standards.md`  — project-local, gitignorable
+ *   3. `~/.cspeach/standards.md`      — per-developer default
+ *
+ * Applies in BOTH standalone and connected mode. The system prompt is assembled
+ * server-side by the proxy, so the override rule travels inside the element
+ * rather than in a CLI-side preamble constant.
+ */
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+/** Hard cap on how much of the document travels in each turn's context. */
+export const STANDARDS_MAX_CHARS = 8000;
+/** Standard file name a team checks in beside their code. */
+export const STANDARDS_REPO_FILENAME = 'CSPEACH-STANDARDS.md';
+/**
+ * First line inside `<development_standards>`. CSPeach's own conventions ship
+ * in the server-side system prompt; this tells the model which wins.
+ */
+export const STANDARDS_OVERRIDE_RULE = "Rule: these customer standards override CSPeach's default conventions. If a default conflicts, follow the customer standard and say so once.";
+/** Per-process cache, keyed by cwd. Mirrors the project-context cache. */
+const cache = new Map();
+/** Test hook — drop the per-process cache. */
+export function resetStandardsCache() {
+    cache.clear();
+}
+/** The candidate paths, in precedence order, for a given cwd. */
+export function standardsCandidates(cwd) {
+    return [
+        path.join(cwd, STANDARDS_REPO_FILENAME),
+        path.join(cwd, '.cspeach', 'standards.md'),
+        path.join(cspeachRoot(), 'standards.md'),
+    ];
+}
+/**
+ * Find the active standards file for `cwd`, or null when the user has none.
+ * Best-effort: an unreadable candidate is skipped, never thrown.
+ */
+export async function resolveStandardsFile(cwd) {
+    if (cache.has(cwd))
+        return cache.get(cwd);
+    let found = null;
+    for (const candidate of standardsCandidates(cwd)) {
+        try {
+            const raw = await fs.readFile(candidate, 'utf8');
+            const content = raw.trim();
+            // A present-but-empty file means "nothing to say" — keep looking, and if
+            // nothing else turns up render no element at all.
+            if (content.length === 0)
+                continue;
+            found = { path: candidate, content };
+            break;
+        }
+        catch {
+            // ENOENT / EACCES / EISDIR — try the next candidate.
+        }
+    }
+    cache.set(cwd, found);
+    return found;
+}
+/**
+ * Display form of a standards path: relative when it sits under cwd, `~`-
+ * prefixed when it sits under the home directory, absolute otherwise.
+ */
+export function displayStandardsPath(filePath, cwd) {
+    const rel = path.relative(cwd, filePath);
+    if (rel && !rel.startsWith('..') && !path.isAbsolute(rel))
+        return rel;
+    const home = os.homedir();
+    const relHome = path.relative(home, filePath);
+    if (relHome && !relHome.startsWith('..') && !path.isAbsolute(relHome)) {
+        return '~' + path.sep + relHome;
+    }
+    return filePath;
+}
+/**
+ * Render the `<development_standards>` element for `<session_context>`, or ''
+ * when the user has no standards file (the no-regression path).
+ */
+export async function renderStandardsBlock(cwd) {
+    const file = await resolveStandardsFile(cwd);
+    if (!file)
+        return '';
+    let body = file.content;
+    if (body.length > STANDARDS_MAX_CHARS) {
+        body = body.slice(0, STANDARDS_MAX_CHARS) + `\n[truncated — full document at ${file.path}]`;
+    }
+    return [
+        `<development_standards source="${escapeAttr(displayStandardsPath(file.path, cwd))}">`,
+        STANDARDS_OVERRIDE_RULE,
+        body,
+        '</development_standards>',
+    ].join('\n');
+}
+function escapeAttr(s) {
+    return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}

package/dist/standards/standards-init.js

@@ -0,0 +1,194 @@
+/**
+ * `cspeach standards init` — capture the team's ABAP development standards
+ * once, as a Markdown file the session context then carries into every turn
+ * (see standards-file.ts).
+ *
+ * Three routes:
+ *   a) import  — point at an existing .md/.txt and copy it in with a header
+ *   b) answer  — a short interview, written as one `## ` section per answer
+ *   c) defaults— write nothing; CSPeach's built-in conventions apply
+ *
+ * Also runs as the LAST question of the standalone profile wizard.
+ *
+ * Prompts are injected so the flow is unit-testable without a TTY; the default
+ * implementation uses the same `@inquirer/prompts` primitives as the SAP wizard.
+ */
+import chalk from 'chalk';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+import { STANDARDS_REPO_FILENAME, displayStandardsPath, resetStandardsCache, } from './standards-file.js';
+/**
+ * The interview. Every question is OPTIONAL — an empty answer means the team
+ * has no rule there, and no section is written for it.
+ */
+export const STANDARDS_INTERVIEW_QUESTIONS = [
+    {
+        key: 'namespace',
+        heading: 'Namespace / prefix',
+        message: 'Namespace or prefix for custom objects (Enter to skip):',
+        default: 'Z',
+    },
+    {
+        key: 'packages',
+        heading: 'Packages for new objects',
+        message: 'Package(s) new objects belong in, e.g. ZFI_CORE (Enter to skip):',
+    },
+    {
+        key: 'naming',
+        heading: 'Naming style',
+        message: 'Naming style for classes / methods / variables — e.g. "zcl_<area>_<noun>", Hungarian lv_/ls_/lt_ (Enter to skip):',
+    },
+    {
+        key: 'forbidden',
+        heading: 'Forbidden or discouraged statements',
+        message: 'Forbidden or discouraged statements, e.g. "no SELECT *", "no CALL TRANSACTION" (Enter to skip):',
+    },
+    {
+        key: 'atc_variant',
+        heading: 'ATC check variant',
+        message: 'ATC check variant name (Enter to skip):',
+    },
+    {
+        key: 'clean_core',
+        heading: 'Clean core',
+        message: 'Clean-core requirement:',
+        choices: ['ABAP Cloud only', 'released APIs preferred', 'classic allowed', '(skip)'],
+    },
+    {
+        key: 'transport_process',
+        heading: 'Transport / change process',
+        message: 'Transport / change process, e.g. "ChaRM, one TR per ticket" (Enter to skip):',
+    },
+    {
+        key: 'header_template',
+        heading: 'Code header template',
+        message: 'Required code header / comment template (Enter to skip):',
+    },
+    {
+        key: 'unit_tests',
+        heading: 'Unit tests',
+        message: 'Unit-test expectation:',
+        choices: ['required for all classes', 'business logic only', 'none', '(skip)'],
+    },
+    {
+        key: 'other',
+        heading: 'Anything else',
+        message: 'Anything else CSPeach should follow (Enter to skip):',
+    },
+];
+/** Header written at the top of an IMPORTED standards document. */
+export function importedStandardsHeader(sourcePath, when = new Date()) {
+    const date = when.toISOString().slice(0, 10);
+    return `# Development standards (imported from ${sourcePath} on ${date})`;
+}
+/**
+ * Render the interview answers as Markdown — one `## ` section per ANSWERED
+ * item, in question order. Returns '' when nothing was answered, so the caller
+ * can skip writing a file that would say nothing.
+ */
+export function renderStandardsMarkdown(answers) {
+    const sections = [];
+    for (const q of STANDARDS_INTERVIEW_QUESTIONS) {
+        const raw = answers[q.key];
+        const value = typeof raw === 'string' ? raw.trim() : '';
+        if (value.length === 0 || value === '(skip)')
+            continue;
+        sections.push(`## ${q.heading}\n\n${value}`);
+    }
+    if (sections.length === 0)
+        return '';
+    return `# Development standards\n\n${sections.join('\n\n')}\n`;
+}
+/**
+ * Write the standards document. Prefers `<cwd>/CSPEACH-STANDARDS.md` so the
+ * team can check it in; falls back to `~/.cspeach/standards.md` when cwd is not
+ * writable (read-only checkout, a directory the user doesn't own).
+ * Returns the path actually written.
+ */
+export async function writeStandardsFile(cwd, content) {
+    const repoPath = path.join(cwd, STANDARDS_REPO_FILENAME);
+    try {
+        await fs.writeFile(repoPath, content, 'utf8');
+        resetStandardsCache();
+        return repoPath;
+    }
+    catch {
+        const homePath = path.join(cspeachRoot(), 'standards.md');
+        await fs.mkdir(path.dirname(homePath), { recursive: true });
+        await fs.writeFile(homePath, content, 'utf8');
+        resetStandardsCache();
+        return homePath;
+    }
+}
+async function defaultPrompts() {
+    const { input, select } = await import('@inquirer/prompts');
+    return {
+        select: (opts) => select({ message: opts.message, choices: opts.choices, default: opts.default }),
+        input: (opts) => input({ message: opts.message, default: opts.default }),
+    };
+}
+/**
+ * Ask whether the team has development standards, and capture them.
+ * Never throws on a bad answer — a missing import path degrades to 'defaults'
+ * with a printed hint, because this runs inside startup wizards.
+ */
+export async function runStandardsInit(cwd, prompts) {
+    const p = prompts ?? (await defaultPrompts());
+    const route = await p.select({
+        key: 'route',
+        message: 'Does your team have ABAP development standards?',
+        choices: [
+            { value: 'import', name: 'Point me to the document' },
+            { value: 'interview', name: 'Answer a few questions' },
+            { value: 'defaults', name: 'Use CSPeach defaults for now' },
+        ],
+        default: 'defaults',
+    });
+    if (route === 'import') {
+        const src = (await p.input({
+            key: 'source',
+            message: 'Path to the standards document (.md or .txt):',
+        })).trim();
+        try {
+            const body = await fs.readFile(src, 'utf8');
+            const content = `${importedStandardsHeader(src)}\n\n${body.trim()}\n`;
+            const written = await writeStandardsFile(cwd, content);
+            console.log(chalk.green(`✓ Standards imported to ${displayStandardsPath(written, cwd)}`));
+            return { action: 'import', path: written };
+        }
+        catch (e) {
+            console.log(chalk.yellow(`  Could not read "${src}" (${e.message}). Keeping CSPeach defaults.`));
+            printHowToAddLater(cwd);
+            return { action: 'defaults' };
+        }
+    }
+    if (route === 'interview') {
+        const answers = {};
+        for (const q of STANDARDS_INTERVIEW_QUESTIONS) {
+            const answer = q.choices
+                ? await p.select({
+                    key: q.key,
+                    message: q.message,
+                    choices: q.choices.map((c) => ({ value: c, name: c })),
+                    default: '(skip)',
+                })
+                : await p.input({ key: q.key, message: q.message, default: q.default });
+            answers[q.key] = answer;
+        }
+        const md = renderStandardsMarkdown(answers);
+        if (md.length === 0) {
+            console.log(chalk.dim('  Nothing answered — keeping CSPeach defaults.'));
+            printHowToAddLater(cwd);
+            return { action: 'defaults' };
+        }
+        const written = await writeStandardsFile(cwd, md);
+        console.log(chalk.green(`✓ Standards written to ${displayStandardsPath(written, cwd)}`));
+        return { action: 'interview', path: written };
+    }
+    printHowToAddLater(cwd);
+    return { action: 'defaults' };
+}
+function printHowToAddLater(cwd) {
+    console.log(chalk.dim(`  Add standards later: drop a ${STANDARDS_REPO_FILENAME} in ${cwd}, or run: cspeach standards init`));
+}

package/dist/tools/capability/tool.js

@@ -57,6 +57,8 @@ registerTool({
         + 'the feature consulted, the matrix column used, the reason, and (only for with-fallback) a concrete '
         + 'fallback instruction. Read-only — never writes to SAP.',
     isMutating: false,
+    // Probes the CONNECTED release via getSapSystemInfo(ctx.adt, …).
+    requiresSap: true,
     category: 'sap',
     flagGated: true,
     input_schema: {

package/dist/tools/index.js

@@ -20,6 +20,31 @@ export function listTools() {
     // always returned, preserving today's listTools() semantics exactly.
     return Array.from(registry.values()).filter((t) => !t.flagGated || isToolFlagOn(t.name));
 }
+/**
+ * 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
+ * the offline AdtClient stand-in (sap/offline-adt-client.ts).
+ */
+export const STANDALONE_ALIAS = 'none';
+/** True when this context has no SAP system behind it. */
+export function isStandalone(ctx) {
+    return ctx.sapAlias === STANDALONE_ALIAS;
+}
+/**
+ * Narrow a tool list to what the given context can actually run: in standalone
+ * mode every `requiresSap` tool is hidden from the LLM, because calling one
+ * could only ever fail.
+ *
+ * Deliberately NOT folded into `listTools()` — other callers (the local_build
+ * startup hook, tool-count diagnostics, the doctor) must keep seeing the whole
+ * registry. When not standalone this returns the SAME array reference it was
+ * given, so the connected path does no work and stays byte-identical.
+ */
+export function toolsForContext(tools, ctx) {
+    if (!isStandalone(ctx))
+        return tools;
+    return tools.filter((t) => !t.requiresSap);
+}
 export function getToolsByCategory(category) {
     return listTools().filter((t) => t.category === category);
 }

package/dist/tools/sap-read.js

@@ -36,6 +36,7 @@ registerTool({
         + 'created object with NO active version yet, the inactive (working) '
         + 'source is returned with version="inactive" and an honest note.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -130,6 +131,7 @@ registerTool({
     name: 'sap_object_structure',
     description: 'Retrieve metadata and structural information for an ABAP repository object (package, description, lock state, etc.).',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -165,6 +167,7 @@ registerTool({
     name: 'sap_search_object',
     description: 'Search the SAP repository by object name pattern. Supports wildcard * (e.g. ZCL_ORDER*).',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -192,6 +195,7 @@ registerTool({
     name: 'sap_change_log',
     description: 'Retrieve the version history (change log) of an ABAP object — date, author, description per revision.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -214,6 +218,7 @@ registerTool({
         + 'Dialect limits (violations return an opaque "SAP HTTP 400: sqlQuery"): no IN-lists and at most one LIKE per WHERE clause '
         + '(multi-OR LIKE chains are rejected) — use a single LIKE or split into separate queries.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -237,6 +242,7 @@ registerTool({
         + 'result includes a `coverage` line stating exactly which window was fetched — trust it '
         + 'over assumptions. With dumpId returns the full diagnostic detail.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -293,6 +299,7 @@ registerTool({
     name: 'sap_atc_run',
     description: 'Run ABAP Test Cockpit (ATC) checks on a specific object and return all findings.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -318,6 +325,7 @@ registerTool({
     name: 'sap_usage_references',
     description: 'Find all places where a given ABAP object is referenced (where-used list).',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -339,6 +347,7 @@ registerTool({
     name: 'sap_api_state',
     description: 'Check the ABAP Cloud / clean-core release state of SAP objects. Pass comma-separated TYPE:NAME pairs, e.g. "CLAS:CL_GUI_ALV_GRID,FUNC:BAPI_SALESORDER_GETLIST".',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -362,6 +371,7 @@ registerTool({
     name: 'sap_abap_docu',
     description: 'Retrieve official ABAP language documentation from the SAP system for a keyword, class, or function module.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -384,6 +394,7 @@ registerTool({
     name: 'sap_class_includes',
     description: 'List the includes of an ABAP class, or read one specific include source (testclasses, locals_def, locals_imp, macros).',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -415,6 +426,7 @@ registerTool({
     name: 'sap_inactive_objects',
     description: 'List all ABAP objects that are currently inactive (not yet activated) in the system.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {},
@@ -432,6 +444,7 @@ registerTool({
     name: 'sap_syntax_check',
     description: 'Run a syntax check on an ABAP object and return any errors or warnings without activating it.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -453,6 +466,7 @@ registerTool({
     name: 'sap_diff',
     description: 'Compute a unified diff for an ABAP object between two optional source strings; if omitted, diffs the current version against the previous from the change log.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -482,6 +496,7 @@ registerTool({
     name: 'sap_preview_change',
     description: 'Preview a proposed source change for an ABAP object as a unified diff without writing anything to the system.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -507,6 +522,7 @@ registerTool({
     name: 'sap_run_unit_test',
     description: 'Execute ABAP Unit tests for an object and return a structured pass/fail report with method-level results.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -553,6 +569,7 @@ registerTool({
     name: 'sap_odata_test',
     description: 'Test an OData service endpoint (V2 or V4). Fetches $metadata or reads an entity set and returns the real HTTP status, the request URL/Accept actually used, and the response body. Works on draft-enabled OData V4 RAP services: V4 is auto-detected from /odata4/ paths, $metadata gets an XML Accept, and data reads use a JSON Accept without the V2-only $format option. System query options ($metadata, $top, $filter, $select, $expand, $count) are preserved literally.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -593,6 +610,7 @@ registerTool({
     name: 'sap_badi_list',
     description: 'Search for BAdI definitions and enhancement spots by name pattern (supports * wildcard), with optional enhancement-spot drill-down.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {

package/dist/tools/sap-write.js

@@ -89,6 +89,7 @@ registerTool({
         + 'a single method body. For method-body-only edits use sap_update_method (Rule 7a). '
         + 'The transport auto-resolves to the owning request if the object is already locked.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -252,6 +253,7 @@ registerTool({
         + 'method_source must be the lines between METHOD x. and ENDMETHOD. (no wrappers). '
         + 'The transport auto-resolves to the owning request if the class is already locked.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -441,6 +443,7 @@ registerTool({
         + 'Post-check: confirms the object no longer exists. '
         + 'The transport auto-resolves to the owning request if the object is already locked.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -563,6 +566,7 @@ registerTool({
         + 'Requires approval_id. No snapshot needed (new object). '
         + 'Write source separately via sap_set_source, then call sap_activate.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -670,6 +674,7 @@ registerTool({
         + 'After writing, activate the class via sap_activate. '
         + 'The transport auto-resolves to the owning request if the class is already locked.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -792,6 +797,7 @@ registerTool({
         + 'Requires approval_id. No snapshot needed (new object). '
         + 'Use the domain in a data element via sap_create_data_element.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -926,6 +932,7 @@ registerTool({
         + 'activate and verify it. Requires approval_id. No snapshot needed (new object). '
         + 'Use the data element as a table/structure field type.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -1054,6 +1061,7 @@ registerTool({
         + 'sap_update_method / sap_create_object (Rule 10). '
         + 'Post-check: objects must no longer appear in the inactive-objects list.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -1169,6 +1177,7 @@ registerTool({
     name: 'sap_lock',
     description: 'RARELY needed. Returns a lock handle but other write tools cannot consume it — sap_set_source / sap_update_method / sap_delete_object each acquire their OWN lock internally. Calling sap_lock as a recovery step after a write failure CREATES A STALE LOCK that blocks the next write attempt; do not do that. Only call this when you need to inspect lock state or hold a lock for a coordinated multi-step ABAP workbench operation outside of CSPeach.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -1190,6 +1199,7 @@ registerTool({
     name: 'sap_unlock',
     description: 'Release an ADT edit lock on an ABAP object using the lockHandle from sap_lock.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -1212,6 +1222,7 @@ registerTool({
     name: 'sap_service_binding_publish',
     description: 'Publish an ADT service binding so its OData endpoint becomes active and reachable.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -1235,6 +1246,7 @@ registerTool({
     description: 'Unpublish an ADT service binding so its OData endpoint is removed. '
         + 'Required before deleting a published binding (SAP returns HTTP 412 "is published" otherwise).',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -1257,6 +1269,7 @@ registerTool({
         + 'Maintaining MSAG message-class entries via ADT requires XML message-class-format '
         + 'parsing not yet implemented in @cspeach/sap-client.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -1287,6 +1300,7 @@ registerTool({
         + 'Writing NROB number-range intervals via ADT requires NR-object XML format '
         + 'not yet implemented in @cspeach/sap-client.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {

package/dist/tools/snapshot.js

@@ -30,6 +30,9 @@ registerTool({
     name: 'sap_snapshot_take',
     description: "Take a snapshot of an object's current source before modification. Usually invoked automatically by the CLI before any write — rarely called directly by the model.",
     isMutating: false,
+    // Reads the live source via ctx.adt.getSource — the only snapshot tool that
+    // needs SAP. list / read / cleanup work purely on the local snapshot store.
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {

package/dist/tools/transport.js

@@ -63,6 +63,7 @@ registerTool({
         + 'approval mismatch failure mode observed live 2026-05-07). '
         + 'Requires approval_id. Returns the transport number to use in subsequent writes.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -260,6 +261,7 @@ registerTool({
         + 'locked → use the returned owning transport; not locked → a new or '
         + 'existing transport may be used.',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -330,6 +332,7 @@ registerTool({
     description: 'List SAP CTS transport requests. '
         + 'Optionally filter by owner (user) or status (modifiable | released).',
     isMutating: false,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {
@@ -377,6 +380,7 @@ registerTool({
         + 'All objects must be syntax-clean and ATC-clean before releasing (Rule 9). '
         + 'Requires approval_id.',
     isMutating: true,
+    requiresSap: true,
     input_schema: {
         type: 'object',
         properties: {