@cspeach/cli 1.1.1 → 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/fiori/fe-scaffold.js

@@ -62,6 +62,31 @@ export async function scaffoldFioriElements(opts) {
         ui5: { minUI5Version: ui5Version, version: ui5Version },
     };
     await generate(opts.basePath, config, fs);
+    if (!opts.localAnnotations) {
+        // @sap-ux writers force-inject a 'localAnnotationsName: annotation' dataSource for
+        // EDMX services even when none was requested, but only write the XML file when
+        // metadata is passed — leaving a manifest reference that 404s at boot (F-L2-7).
+        const manifestPath = join(opts.basePath, 'webapp', 'manifest.json');
+        const manifest = fs.readJSON(manifestPath);
+        const ds = manifest?.['sap.app']?.dataSources ?? {};
+        const removed = Object.keys(ds).filter((k) => ds[k]?.type === 'ODataAnnotation');
+        if (removed.length > 0) {
+            for (const k of removed)
+                delete ds[k];
+            for (const d of Object.values(ds)) {
+                if (Array.isArray(d?.settings?.annotations)) {
+                    d.settings.annotations = d.settings.annotations.filter((name) => !removed.includes(name));
+                }
+            }
+            fs.writeJSON(manifestPath, manifest);
+            // also drop the orphan empty EDMX if the writer emitted one (metadata path)
+            for (const k of removed) {
+                const orphan = join(opts.basePath, 'webapp', 'annotations', `${k}.xml`);
+                if (fs.exists(orphan))
+                    fs.delete(orphan);
+            }
+        }
+    }
     // Overwrite the writer's empty EDMX skeleton with the caller's real annotations
     // EDMX, in the mem-fs editor, BEFORE commit so the flushed file is the caller's.
     if (opts.localAnnotations) {

package/dist/tools/fiori/smoke/assertions.js

@@ -3,15 +3,21 @@
 // under the gateway/odata4 path. An incidental non-OData 404 (favicon, a
 // analytics beacon) must NOT false-fail an otherwise healthy render.
 const ODATA_URL = /\$metadata|\$batch|\/sap\/opu\/odata|\/odata4?\//i;
+// Unbuilt dev-serve artifacts: `fiori run` 404s Component-preload.js and
+// resources.json on every app that hasn't been through `ui5 build`.
+// Dev-mode noise, not app defects (F-L2-12) — must not fail boot.
+const UNBUILT_DEV_404 = /(Component-preload\.js|resources\.json)/i;
+const LOAD_FAILURE = /(404|failed to load)/i;
 /** Boot check: the app loaded without throwing anything to the console. */
 export function checkBoot(consoleErrors) {
-    const ok = consoleErrors.length === 0;
+    const real = consoleErrors.filter((e) => !(UNBUILT_DEV_404.test(e) && LOAD_FAILURE.test(e)));
+    const ok = real.length === 0;
     return {
         name: 'boot',
         ok,
         detail: ok
             ? 'app booted with no console errors'
-            : `${consoleErrors.length} console error(s) during boot: ${consoleErrors.slice(0, 3).join(' | ')}`,
+            : `${real.length} console error(s) during boot: ${real.slice(0, 3).join(' | ')}`,
     };
 }
 /** OData check: no 4xx/5xx on any $metadata / $batch / entity-set request. */

package/dist/tools/fiori/smoke/driver.js

@@ -74,6 +74,12 @@ export async function openApp(executablePath, url, timeoutMs) {
                 }, name);
                 await page.waitForNetworkIdle({ idleTime: 200, timeout: timeoutMs }).catch(() => { });
             },
+            // F-L2-10A: evidence capture. The caller owns the artifact dir (it is
+            // created before this is called) and owns failure handling — a rejection
+            // here is caught there and the entry omitted, never failing the smoke.
+            screenshot: async (target) => {
+                await page.screenshot({ path: target });
+            },
             close: async () => {
                 await browser.close();
             },

package/dist/tools/fiori/smoke/run-smoke.js

@@ -18,6 +18,9 @@
 //
 // The browser + driver are injectable (RunSmokeDeps) so the unit suite drives
 // every path with fakes and NEVER launches a real browser.
+import { mkdirSync } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
 import { resolveBrowserExecutable } from './browser.js';
 import { openApp as realOpenApp } from './driver.js';
 import { checkBoot, checkOData, checkColumns, checkRows, checkExercise, } from './assertions.js';
@@ -44,6 +47,30 @@ export const SMOKE_SELECTORS = {
 // us to an auth endpoint instead of serving the app.
 const LOGON_URL = /sap-system-login|\/saml2\/|\/logon|\/login/i;
 const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * A filesystem-safe app name for the artifact dir, derived from the preview URL:
+ * the last real path segment (`…/mycourses/index.html` → `mycourses`), falling
+ * back to host+port (`http://localhost:8080/index.html` → `localhost-8080`).
+ */
+function appNameFromUrl(appUrl) {
+    let raw;
+    try {
+        const u = new URL(appUrl);
+        const segs = u.pathname.split('/').filter((s) => s.length > 0 && !s.includes('.'));
+        raw = segs.length > 0 ? segs[segs.length - 1] : u.host;
+    }
+    catch {
+        raw = appUrl;
+    }
+    const slug = raw.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    return slug.length > 0 ? slug : 'app';
+}
+/** Local-time `yyyyMMdd-HHmmss` stamp — one dir per smoke run, sorts naturally. */
+function runStamp(now = new Date()) {
+    const p2 = (n) => String(n).padStart(2, '0');
+    return (`${now.getFullYear()}${p2(now.getMonth() + 1)}${p2(now.getDate())}` +
+        `-${p2(now.getHours())}${p2(now.getMinutes())}${p2(now.getSeconds())}`);
+}
 /** A not-run result: manual verification, a single explanatory skipped check. */
 function skipped(detail) {
     return { verification: 'manual', passed: false, checks: [{ name: 'skipped', ok: false, detail }] };
@@ -111,6 +138,31 @@ export async function runSmoke(spec, deps) {
     catch {
         return skipped(`preview server not reachable at ${spec.appUrl}; run npm run start first`);
     }
+    // F-L2-10A evidence capture. The dir is created LAZILY on the first successful
+    // capture, so a skip path (or a driver with no screenshot capability) writes
+    // nothing at all. Every capture is try/catch-wrapped: a screenshot failure
+    // omits the entry and NEVER fails the smoke.
+    const screenshots = {};
+    const canShoot = typeof page.screenshot === 'function';
+    let shotDir;
+    const capture = async (key, file) => {
+        if (!page.screenshot)
+            return;
+        try {
+            shotDir ??=
+                deps.artifactDir ??
+                    path.join(os.homedir(), '.cspeach', 'smoke', `${appNameFromUrl(spec.appUrl)}-${runStamp()}`);
+            mkdirSync(shotDir, { recursive: true });
+            const target = path.join(shotDir, file);
+            await page.screenshot(target);
+            screenshots[key] = target;
+        }
+        catch {
+            // Evidence is best-effort — a capture problem must never fail the smoke.
+        }
+    };
+    // Hoisted so the finally block can decide whether a failure shot is owed.
+    const checks = [];
     try {
         // Skip path 4 — SAP logon page (deployed BSP / unauthenticated preview).
         // Detect via a logon-redirect URL OR the presence of a logon-form field, and
@@ -120,9 +172,10 @@ export async function runSmoke(spec, deps) {
         if (LOGON_URL.test(url) || logonHits.length > 0) {
             return skipped(`preview served a SAP logon page (not authenticated) at ${url}; run npm run start first`);
         }
+        // The app is open past the logon check — this is the boot evidence shot.
+        await capture('boot', 'boot.png');
         // Real render — assert content. boot + odata always; columns only when the
         // spec asked for them; rows only for a rows-bearing (table) control.
-        const checks = [];
         checks.push(checkBoot(page.consoleErrors()));
         checks.push(checkOData(page.failedRequests()));
         if (spec.expectedColumns && spec.expectedColumns.length > 0) {
@@ -141,9 +194,23 @@ export async function runSmoke(spec, deps) {
             const results = await runExercises(page, spec.exercises);
             checks.push(checkExercise(results));
         }
-        return { verification: 'smoke', passed: checks.every((c) => c.ok), checks };
+        // Post-exercise evidence: the app's final state after every declared
+        // interaction ran (and simply the settled app when the spec declares none).
+        await capture('postExercise', 'post-exercise.png');
+        // `screenshots` is the SAME object the finally block may still add the
+        // failure entry to, so a failing run carries it even though the value is
+        // built here. It rides along only when the driver can shoot at all.
+        return {
+            verification: 'smoke',
+            passed: checks.every((c) => c.ok),
+            checks,
+            ...(canShoot ? { screenshots } : {}),
+        };
     }
     finally {
+        // A failing check earns a failure shot — captured BEFORE the page is closed.
+        if (checks.some((c) => !c.ok))
+            await capture('failure', 'failure.png');
         await page.close();
     }
 }

package/dist/tools/fiori/tools.js

@@ -595,8 +595,10 @@ registerTool({
         'derived one. Derivation notes surface as a `warnings` array in the result. SKIPPABLE BUT NEVER ' +
         'SILENTLY GREEN: when the render_smoke config is off, no browser is found, the preview is unreachable, ' +
         'or the page is a SAP logon form, it returns verification:"manual" + passed:false with a "skipped" ' +
-        'check explaining why — it can never report a passing smoke without a real render. Flag-gated (enabled ' +
-        'with local_build), read-only.',
+        'check explaining why — it can never report a passing smoke without a real render. On a real render it ' +
+        'also saves boot / post-exercise / failure screenshots under ~/.cspeach/smoke/ and returns their absolute ' +
+        'paths in a `screenshots` object (best-effort evidence — a capture failure never fails the smoke). ' +
+        'Flag-gated (enabled with local_build), read-only.',
     isMutating: false,
     category: 'fiori',
     flagGated: true,

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: {