@cspeach/cli 1.1.2 → 1.1.4

package/dist/sap/standalone-profile.js

@@ -0,0 +1,237 @@
+/**
+ * Standalone-mode SAP profile — the "what system would this land on?" facts a
+ * prospect gives us ONCE when they run CSPeach without a SAP connection
+ * (`--no-sap` / `no_sap = true`).
+ *
+ * This module is PURE: types, whitelists, derivations and rendering only. The
+ * interactive wizard lives in `standalone-onboarding.ts` so tests never pull in
+ * `@inquirer/prompts`, and `config/loader.ts` can import the shape + sanitiser
+ * without a prompt dependency.
+ *
+ * The rendered element deliberately reuses the CONNECTED `<sap_system …/>`
+ * shape (see sap/system-info.ts `renderSapSystemBlock`) so skills read one
+ * element in both modes and need no change.
+ */
+export const STANDALONE_PLATFORMS = [
+    'ECC',
+    'S/4HANA',
+    'S/4HANA Cloud Private',
+    'S/4HANA Cloud Public',
+    'BTP ABAP Environment',
+];
+export const STANDALONE_DATABASES = ['HANA', 'other'];
+export const STANDALONE_DEPLOYMENTS = ['on-prem', 'private-cloud', 'public-cloud'];
+export const STANDALONE_IDES = ['ADT', 'SE80', 'both'];
+/** The three platforms that are "cloud" for defaulting purposes. */
+const CLOUD_PLATFORMS = new Set([
+    'S/4HANA Cloud Private',
+    'S/4HANA Cloud Public',
+    'BTP ABAP Environment',
+]);
+export function isStandalonePlatform(v) {
+    return typeof v === 'string' && STANDALONE_PLATFORMS.includes(v);
+}
+/**
+ * Deployment implied by the platform. `null` means "the platform doesn't decide
+ * it — ask the user" (ECC and on-prem S/4HANA can both be on-prem or hosted in
+ * a private cloud).
+ */
+export function deriveDeployment(platform) {
+    switch (platform) {
+        case 'S/4HANA Cloud Public':
+        case 'BTP ABAP Environment':
+            return 'public-cloud';
+        case 'S/4HANA Cloud Private':
+            return 'private-cloud';
+        default:
+            return null;
+    }
+}
+/**
+ * Database implied by the platform. S/4HANA (any edition) and BTP ABAP are
+ * HANA by definition; only ECC can sit on something else. `null` = ask.
+ */
+export function deriveDatabase(platform) {
+    return platform === 'ECC' ? null : 'HANA';
+}
+/** Default answer to "must new code be ABAP Cloud / clean-core compliant?". */
+export function defaultAbapCloudOnly(platform) {
+    return CLOUD_PLATFORMS.has(platform);
+}
+/** Release examples shown in the wizard prompt, per platform. */
+export function releaseExamples(platform) {
+    switch (platform) {
+        case 'ECC':
+            return '6.0 EhP8 / NW 7.50';
+        case 'S/4HANA':
+            return '2023 FPS01 / 2022 / 2021 / 1909';
+        case 'S/4HANA Cloud Private':
+            return '2023 FPS01 / 2022 / current';
+        default:
+            return 'current';
+    }
+}
+/** Pre-filled answer for the release prompt, per platform. */
+export function defaultRelease(platform) {
+    switch (platform) {
+        case 'ECC':
+            return '6.0 EhP8';
+        case 'S/4HANA':
+        case 'S/4HANA Cloud Private':
+            return '2023';
+        default:
+            return 'current';
+    }
+}
+/** S/4HANA release year → SAP_BASIS / ABAP language version. */
+const S4_YEAR_TO_ABAP = {
+    '1909': '7.54',
+    '2020': '7.55',
+    '2021': '7.56',
+    '2022': '7.57',
+    '2023': '7.58',
+    '2025': '7.59',
+};
+function releaseYear(release) {
+    for (const year of Object.keys(S4_YEAR_TO_ABAP)) {
+        // Word-boundary match so "2023 FPS01" and "S/4HANA 2022 FPS02" both land.
+        if (new RegExp(`(^|\\D)${year}(\\D|$)`).test(release))
+            return year;
+    }
+    return undefined;
+}
+/**
+ * Map platform + release to the `abap_version` attribute skills already read
+ * from the connected `<sap_system>` element.
+ *
+ * Note on S/4HANA Cloud Private: it runs the SAME on-prem code line, so when
+ * the user states a release year we report the real ABAP version (2023 → 7.58)
+ * instead of the generic "ABAP Cloud" marker. Only a year-less answer
+ * ("current") falls back to "ABAP Cloud".
+ */
+export function mapAbapVersion(platform, release) {
+    switch (platform) {
+        case 'ECC':
+            return '7.50 (classic ABAP, no ABAP Cloud)';
+        case 'S/4HANA': {
+            const y = releaseYear(release);
+            return y ? S4_YEAR_TO_ABAP[y] : 'unknown';
+        }
+        case 'S/4HANA Cloud Private': {
+            const y = releaseYear(release);
+            return y ? S4_YEAR_TO_ABAP[y] : 'ABAP Cloud';
+        }
+        default:
+            return 'ABAP Cloud';
+    }
+}
+/** Map the profile's deployment onto the existing `SapDeployment` values. */
+export function mapSapDeployment(deployment) {
+    return deployment === 'public-cloud' ? 'public-cloud' : 'on-prem-or-private-cloud';
+}
+/**
+ * Coerce a possibly-hand-edited `[standalone]` TOML table into a valid profile.
+ *
+ * The platform is load-bearing (every other default derives from it), so an
+ * unrecognised platform drops the WHOLE table — better a clean "profile not
+ * set" than a confident wrong release rendered into every prompt. Individual
+ * bad sub-fields are repaired from the platform defaults.
+ */
+export function sanitiseStandaloneProfile(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const r = raw;
+    if (!isStandalonePlatform(r.platform))
+        return undefined;
+    const platform = r.platform;
+    const release = typeof r.release === 'string' && r.release.trim().length > 0
+        ? r.release.trim()
+        : defaultRelease(platform);
+    const database = typeof r.database === 'string' && STANDALONE_DATABASES.includes(r.database)
+        ? r.database
+        : (deriveDatabase(platform) ?? 'HANA');
+    const deployment = typeof r.deployment === 'string' && STANDALONE_DEPLOYMENTS.includes(r.deployment)
+        ? r.deployment
+        : (deriveDeployment(platform) ?? 'on-prem');
+    const ide = typeof r.ide === 'string' && STANDALONE_IDES.includes(r.ide)
+        ? r.ide
+        : 'ADT';
+    const profile = {
+        platform,
+        release,
+        database,
+        deployment,
+        ide,
+        abap_cloud_only: typeof r.abap_cloud_only === 'boolean' ? r.abap_cloud_only : defaultAbapCloudOnly(platform),
+    };
+    if (typeof r.notes === 'string' && r.notes.trim().length > 0)
+        profile.notes = r.notes.trim();
+    return profile;
+}
+function escapeAttr(s) {
+    return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/** Hard cap on the free-text `notes` attribute, so one long line can't bloat every turn. */
+export const STANDALONE_NOTES_MAX_CHARS = 200;
+/**
+ * Render the standalone `<sap_system …/>` element — the SAME element name the
+ * connected path emits, with `connected="false" mode="standalone"` plus the
+ * three extra facts the profile knows (database / ide / abap_cloud_only).
+ *
+ * With no profile every fact renders as "unknown" rather than being omitted:
+ * a uniform attribute set is easier for a skill to read than a shape that
+ * changes depending on what the user answered.
+ */
+export function renderStandaloneSapSystemBlock(profile) {
+    const platform = profile ? profile.platform : 'unknown';
+    const release = profile ? profile.release : 'unknown';
+    const abapVersion = profile ? mapAbapVersion(profile.platform, profile.release) : 'unknown';
+    const deployment = profile ? mapSapDeployment(profile.deployment) : 'unknown';
+    const database = profile ? profile.database : 'unknown';
+    const ide = profile ? profile.ide : 'unknown';
+    const cloudOnly = profile ? String(profile.abap_cloud_only ?? defaultAbapCloudOnly(profile.platform)) : 'unknown';
+    const attrs = [
+        `platform="${escapeAttr(platform)}"`,
+        `release="${escapeAttr(release)}"`,
+        `abap_version="${escapeAttr(abapVersion)}"`,
+        `deployment="${escapeAttr(deployment)}"`,
+        `connected="false"`,
+        `mode="standalone"`,
+        `database="${escapeAttr(database)}"`,
+        `ide="${escapeAttr(ide)}"`,
+        `abap_cloud_only="${escapeAttr(cloudOnly)}"`,
+    ];
+    // `notes` is the user's own free-text constraint ("no BTP", "transports via
+    // ChaRM") — worth giving the model, but only when they actually answered:
+    // the attribute is OMITTED entirely rather than rendered empty/"unknown".
+    const notes = profile?.notes?.trim();
+    if (notes) {
+        attrs.push(`notes="${escapeAttr(notes.slice(0, STANDALONE_NOTES_MAX_CHARS))}"`);
+    }
+    return `<sap_system ${attrs.join(' ')}/>`;
+}
+/**
+ * The manual-implementation hand-off rule. Standalone cannot create or activate
+ * anything, so every would-be write has to end as instructions the developer
+ * can follow by hand — on disk when the file tools are available, otherwise in
+ * the reply — plus the rule for repairing a single failed step.
+ */
+export const STANDALONE_NOTE = '<standalone_note>No SAP system is connected (standalone mode). Do not call SAP tools. ' +
+    'Work from code the user pastes or describes; when a task needs system data (source, table definitions, ATC output, dumps), ask the user to paste it. ' +
+    'Target the platform and release in sap_system exactly — use only syntax and APIs available on that release. ' +
+    'Because nothing can be created or activated here, every task that would normally write to SAP must instead end with a "Manual Implementation Guide": ' +
+    'numbered steps in dependency order, one object per step, each stating the object type and name, where to create it (ADT wizard path, or SE80/SE11/SE24/SE38 transaction for SE80 teams), ' +
+    'the exact source to paste, the activation step, and any prerequisite (package, transport, number range, message class). ' +
+    'Finish with a short verification checklist (syntax check, activation, ATC, unit test) the user can run themselves.\n' +
+    'File outputs: when file tools are available (local build is on), also write every produced object to the working folder as ./cspeach-out/<yyyy-mm-dd>-<short-task-name>/NN-<OBJECT_NAME>.<abap|ddls|bdef|srvd|srvb|ddlx|dcls|txt> in dependency order, and write the Manual Implementation Guide to GUIDE.md in the same folder, with each step pointing at its file. Tell the user the folder path once. If file tools are not available, say so once and keep everything in the reply.\n' +
+    'Step failures: when the user reports a failure at a step ("step 3 failed" plus an error message or screenshot), ask only for what is missing to diagnose it, fix only the affected object, rewrite its file, re-issue that step and any step that depends on it, and state which steps are unchanged. Never restart the whole guide.</standalone_note>';
+/**
+ * The full standalone contribution to `<session_context>`: the sap_system
+ * element followed by the hand-off note.
+ *
+ * `formatFactBlock` (router/intent-extractor.ts) indents only the FIRST line of
+ * the block it is handed, so every following line carries its own two spaces.
+ */
+export function renderStandaloneContextBlock(profile) {
+    return `${renderStandaloneSapSystemBlock(profile)}\n  ${STANDALONE_NOTE}`;
+}

package/dist/session/audit-export.js

@@ -31,6 +31,7 @@
 // never an invented approval.
 import { summarise } from '../cost/cost-log.js';
 import { CLI_VERSION } from '../lib/version.js';
+import { creditsActive, formatCredits } from '../cost/credits.js';
 /**
  * Object-mutating tools — one row per completed call in the Writes table.
  * Kept as a literal name set (not the tool registry) so this pure builder
@@ -319,7 +320,7 @@ function transportsSeen(toolCalls, sessionTransport) {
 }
 // ── Main builder ──────────────────────────────────────────────────────────
 export function buildAuditReport(input) {
-    const { session, costEntries, transport } = input;
+    const { session, costEntries, transport, credits } = input;
     const calls = session.toolCalls;
     const completed = calls.filter((c) => c.completed === true);
     const approvals = parseApprovals(calls);
@@ -437,15 +438,33 @@ export function buildAuditReport(input) {
     const cost = summarise(costEntries);
     const auditEntries = costEntries.filter((e) => e.label);
     const auditCost = Math.round(auditEntries.reduce((s, e) => s + e.cost, 0) * 10000) / 10000;
-    L(`- **Total:** $${cost.totalCost.toFixed(4)} over ${cost.turns} turn${cost.turns === 1 ? '' : 's'}`);
+    const inCredits = creditsActive();
+    if (inCredits) {
+        const unit = credits?.unitLabel ?? 'credits';
+        const logged = costEntries.reduce((s, e) => s + (typeof e.credits_charged === 'number' ? e.credits_charged : 0), 0);
+        const total = credits && credits.sessionTotal > 0 ? credits.sessionTotal : logged;
+        L(`- **Total:** ${formatCredits(total, unit)} over ${cost.turns} turn${cost.turns === 1 ? '' : 's'}`);
+    }
+    else {
+        L(`- **Total:** $${cost.totalCost.toFixed(4)} over ${cost.turns} turn${cost.turns === 1 ? '' : 's'}`);
+    }
     L(`- **Tokens:** ${cost.totalTokens.input.toLocaleString('en-US')} in · ${cost.totalTokens.output.toLocaleString('en-US')} out · ${cost.totalTokens.cacheRead.toLocaleString('en-US')} cache-read · ${cost.totalTokens.cacheCreate.toLocaleString('en-US')} cache-write`);
+    if (inCredits && credits?.balance != null) {
+        L(`- **Remaining:** balance ${Math.round(credits.balance).toLocaleString('en-US')}`);
+    }
     if (auditEntries.length > 0) {
-        L(`- **Includes** ${auditEntries.length} labelled audit turn${auditEntries.length === 1 ? '' : 's'}: $${auditCost.toFixed(4)}`);
+        // Credits mode: the labelled-audit turn COUNT is still useful provenance;
+        // its USD cost is not ours to publish to a customer.
+        L(inCredits
+            ? `- **Includes** ${auditEntries.length} labelled audit turn${auditEntries.length === 1 ? '' : 's'}`
+            : `- **Includes** ${auditEntries.length} labelled audit turn${auditEntries.length === 1 ? '' : 's'}: $${auditCost.toFixed(4)}`);
     }
     if (cost.byModel.length > 1) {
         L('- **By model:**');
         for (const m of cost.byModel) {
-            L(`  - ${m.model}: ${m.turns} turn${m.turns === 1 ? '' : 's'} · $${m.cost.toFixed(4)}`);
+            L(inCredits
+                ? `  - ${m.model}: ${m.turns} turn${m.turns === 1 ? '' : 's'}`
+                : `  - ${m.model}: ${m.turns} turn${m.turns === 1 ? '' : 's'} · $${m.cost.toFixed(4)}`);
         }
     }
     else if (cost.byModel[0]) {

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);
 }