@cspeach/cli 1.1.2 → 1.1.3

package/dist/doctor/run.js

@@ -12,6 +12,7 @@ import { checkWriteMode } from './checks/write-mode.js';
 import { checkLlmMode } from './checks/llm-mode.js';
 import { checkForgeRules } from './checks/forge-rules.js';
 import { checkSystemRoles } from './checks/system-roles.js';
+import { checkStandards } from './checks/standards.js';
 export async function runDoctor() {
     console.log(chalk.cyan.bold('\nCSPeach — doctor\n'));
     const cfg = await loadConfig();
@@ -28,6 +29,7 @@ export async function runDoctor() {
     checks.push(await checkSkill());
     checks.push(await checkKeychainFallback());
     checks.push(await checkForgeRules());
+    checks.push(await checkStandards());
     let failed = 0;
     for (const c of checks) {
         const icon = c.skipped

package/dist/one-shot.js

@@ -1,5 +1,7 @@
 import chalk from 'chalk';
-import { loadConfig, resolveLocalBuild } from './config/loader.js';
+import { loadConfig, resolveLocalBuild, resolveStandalone } from './config/loader.js';
+import { createOfflineAdtClient } from './sap/offline-adt-client.js';
+import { STANDALONE_ALIAS } from './tools/index.js';
 import { getStore } from './auth/api-key.js';
 import { getConnection } from './sap/connection-manager.js';
 import { AdtClient } from '@cspeach/sap-client';
@@ -50,6 +52,9 @@ import './tools/subagent/schedule_draft_create.js';
 import './tools/subagent/agent_run.js';
 export async function runOneShot(prompt, opts) {
     const cfg = await loadConfig();
+    // Standalone (2026-09-16) — run with no SAP system at all: no connection, no
+    // AdtClient, SAP tools hidden. `--no-sap` for this run, or `no_sap = true`.
+    const standalone = resolveStandalone(cfg, opts?.noSap === true);
     setRenderingOverride(cfg.ui.rendering);
     // model-governance step 2d — fire-and-forget fetch of the served model-config
     // (managed mode only, never blocks). A turn that starts before it lands uses
@@ -70,7 +75,9 @@ export async function runOneShot(prompt, opts) {
     // says gated/auto — the banner must say so. No role ⇒ effective === config
     // (byte-identical). Alias absent (no SAP configured) ⇒ error out below,
     // same as before.
-    const oneShotAlias = opts?.sapAlias ?? Object.keys(cfg.sap)[0];
+    // Standalone has no alias, so no role clamp applies — the configured
+    // write_mode stands on its own.
+    const oneShotAlias = standalone ? undefined : (opts?.sapAlias ?? Object.keys(cfg.sap)[0]);
     const oneShotRole = oneShotAlias !== undefined ? cfg.sap[oneShotAlias]?.role : undefined;
     if (getEffectiveWriteMode(cfg.write_mode, oneShotRole) === 'advisory-only') {
         console.log(chalk.yellow('⚠  Advisory mode: writes will be proposed, not executed.'));
@@ -91,17 +98,35 @@ export async function runOneShot(prompt, opts) {
         return 1;
     }
     const aliases = Object.keys(cfg.sap);
-    if (aliases.length === 0) {
-        console.error('No SAP system configured. Run `cspeach config add-sap` first.');
-        return 1;
+    let alias;
+    let adt;
+    if (standalone) {
+        // No wizard, no picker, no getConnection. The offline stand-in rejects
+        // every call with an actionable message if anything slips past the tool
+        // filter + dispatch guard.
+        alias = STANDALONE_ALIAS;
+        adt = createOfflineAdtClient();
+        console.log(chalk.dim('Standalone mode: no SAP system connected — skills work from pasted code. ' +
+            'Connect later with: cspeach config add-sap'));
+        // One-shot is headless by design (no prompts), so an unanswered standalone
+        // profile can't be filled in here — say how, and carry on with "unknown".
+        if (!cfg.standalone) {
+            console.log(chalk.dim('Standalone profile not set — run: cspeach config set standalone.platform ...'));
+        }
     }
-    // C.1 — --sap-alias flag override
-    const alias = opts?.sapAlias ?? aliases[0];
-    if (opts?.sapAlias) {
-        console.log(chalk.dim(`Using --sap-alias ${opts.sapAlias}`));
+    else {
+        if (aliases.length === 0) {
+            console.error('No SAP system configured. Run `cspeach config add-sap` first.');
+            return 1;
+        }
+        // C.1 — --sap-alias flag override
+        alias = opts?.sapAlias ?? aliases[0];
+        if (opts?.sapAlias) {
+            console.log(chalk.dim(`Using --sap-alias ${opts.sapAlias}`));
+        }
+        const conn = await getConnection(alias, cfg.sap[alias]);
+        adt = new AdtClient(conn);
     }
-    const conn = await getConnection(alias, cfg.sap[alias]);
-    const adt = new AdtClient(conn);
     const session = newSession(makeSessionId(), alias, null, resolveModelRole('session_default', cfg));
     await saveSession(session);
     const parsed = parseShortcut(prompt);

package/dist/repl.js

@@ -7,7 +7,9 @@ import chalk from 'chalk';
 // 'node:readline' directly for that specific operation.
 import * as readline from 'node:readline/promises';
 import { select, password as promptPassword } from '@inquirer/prompts';
-import { loadConfig, resolveLocalBuild } from './config/loader.js';
+import { loadConfig, resolveLocalBuild, resolveStandalone } from './config/loader.js';
+import { createOfflineAdtClient } from './sap/offline-adt-client.js';
+import { STANDALONE_ALIAS } from './tools/index.js';
 import { getStore } from './auth/api-key.js';
 import { readAuthFile } from './auth/auth-file.js';
 import { fetchMe } from './auth/me.js';
@@ -373,7 +375,26 @@ export async function runRepl(opts) {
     let cfg = await loadConfig();
     // Apply user-configured rendering override BEFORE any shouldUseInk() call.
     setRenderingOverride(cfg.ui.rendering);
-    if (Object.keys(cfg.sap).length === 0) {
+    // Standalone (2026-09-16) — run with no SAP system at all. Decided BEFORE
+    // the onboarding wizard: someone who asked for --no-sap (or persisted
+    // no_sap) must never be pushed through the SAP setup they don't have.
+    // Having aliases configured does NOT override the request.
+    // A session that WAS standalone stays standalone on `--resume`: its
+    // sap_system is the reserved 'none' alias, which has no entry in cfg.sap.
+    const standalone = resolveStandalone(cfg, opts?.noSap === true) ||
+        opts?.resumedSession?.sap_system === STANDALONE_ALIAS;
+    if (standalone) {
+        console.log(chalk.dim('\nStandalone mode: no SAP system connected — skills work from pasted code. ' +
+            'Connect later with: cspeach config add-sap'));
+        // Ask the profile questions ONCE — they become the <sap_system> element
+        // every skill reads, so without them a design would target "unknown".
+        if (!cfg.standalone) {
+            const { runStandaloneProfileWizard } = await import('./sap/standalone-onboarding.js');
+            await runStandaloneProfileWizard({ cwd: process.cwd() });
+            cfg = await loadConfig();
+        }
+    }
+    else if (Object.keys(cfg.sap).length === 0) {
         console.log(chalk.yellow('\nNo SAP systems configured. Starting onboarding wizard.'));
         await runAddSapWizard();
         cfg = await loadConfig();
@@ -418,7 +439,12 @@ export async function runRepl(opts) {
     const aliases = Object.keys(cfg.sap);
     // C.1 — --sap-alias flag override skips the interactive picker
     let selectedAlias;
-    if (opts?.sapAlias) {
+    if (standalone) {
+        // No picker: there is nothing to pick. The reserved 'none' alias is what
+        // isStandalone(ctx) reads downstream.
+        selectedAlias = STANDALONE_ALIAS;
+    }
+    else if (opts?.sapAlias) {
         console.log(chalk.dim(`Using --sap-alias ${opts.sapAlias}`));
         selectedAlias = opts.sapAlias;
     }
@@ -461,8 +487,11 @@ export async function runRepl(opts) {
             console.log(chalk.gray(`Write mode: ${startupWriteMode}${capped}\n`));
         }
     }
-    const conn = await getConnection(selectedAlias, cfg.sap[selectedAlias]);
-    const adt = new AdtClient(conn);
+    // Standalone: the offline stand-in rejects every call with an actionable
+    // message. This is the single construction site the AdtClient cast lives at.
+    const adt = standalone
+        ? createOfflineAdtClient()
+        : new AdtClient(await getConnection(selectedAlias, cfg.sap[selectedAlias]));
     // Phase A #3 (2026-05-16) — sidebar SAP-state wire, trigger 1 of 4.
     // Push system + user the moment we know the alias. Before this commit
     // the sidebar showed "no system / user: —" forever because the store
@@ -475,8 +504,8 @@ export async function runRepl(opts) {
     // superseded (unmounted) header.tsx — so nothing else loses the host;
     // the connection banner above already printed it once to scrollback.
     sapStateStore.update({
-        system: selectedAlias,
-        user: cfg.sap[selectedAlias].username,
+        system: standalone ? 'standalone' : selectedAlias,
+        user: standalone ? '' : cfg.sap[selectedAlias].username,
         writeMode: startupWriteMode,
     });
     // v0.6 — when resuming, adopt the on-disk SessionState verbatim. This

package/dist/sap/offline-adt-client.js

@@ -0,0 +1,58 @@
+/**
+ * Offline AdtClient stand-in for standalone mode (`--no-sap` / `no_sap = true`).
+ *
+ * `ToolContext.adt` is typed as a live `AdtClient` and read unconditionally at
+ * many call sites. Rather than widen that type across the codebase (and force
+ * every handler to grow a null-check), standalone injects a Proxy whose every
+ * method call returns a rejected Promise carrying `CspeachNotConnectedError`.
+ *
+ * The model should never get here — SAP-dependent tools are filtered out of the
+ * tool list (`requiresSap`, tools/index.ts) and blocked again at dispatch
+ * (agent/tool-dispatch.ts). This is the third, last-resort layer: if anything
+ * slips through it fails with an actionable message instead of a TypeError.
+ */
+export const NOT_CONNECTED_MESSAGE = 'No SAP system connected (standalone mode). Paste the ABAP source or describe the object, or run: cspeach config add-sap';
+export class CspeachNotConnectedError extends Error {
+    constructor(message = NOT_CONNECTED_MESSAGE) {
+        super(message);
+        this.name = 'CspeachNotConnectedError';
+    }
+}
+/**
+ * Property names that must resolve to `undefined` rather than to a callable.
+ *
+ * `then` is the important one: returning a function for it would make the proxy
+ * a thenable, so `await client` (or any `Promise.resolve(client)`) would invoke
+ * it as a resolver and never settle. The rest are inspection / serialisation
+ * hooks that Node, vitest and JSON.stringify probe on arbitrary objects.
+ */
+const NON_CALLABLE = new Set([
+    'then',
+    'catch',
+    'finally',
+    'toJSON',
+    'constructor',
+    'inspect',
+    'nodeType',
+    '$$typeof',
+]);
+/**
+ * Build the standalone stand-in. Cast to `AdtClient` at the single construction
+ * site in the caller — the shape is intentionally structural, not a subclass,
+ * so a new sap-client method needs no change here.
+ */
+export function createOfflineAdtClient() {
+    const target = {};
+    return new Proxy(target, {
+        get(_t, prop) {
+            if (typeof prop === 'symbol')
+                return undefined;
+            if (NON_CALLABLE.has(prop))
+                return undefined;
+            return (..._args) => Promise.reject(new CspeachNotConnectedError());
+        },
+        has() {
+            return true;
+        },
+    });
+}

package/dist/sap/standalone-onboarding.js

@@ -0,0 +1,118 @@
+/**
+ * Standalone profile wizard — asked ONCE the first time CSPeach starts without
+ * a SAP system (`--no-sap` / `no_sap = true`), and re-runnable via
+ * `cspeach config standalone`.
+ *
+ * With nothing to probe, these answers ARE the system context: they become the
+ * `<sap_system …/>` element every skill reads (see standalone-profile.ts), so a
+ * generated design targets the customer's real release instead of guessing.
+ *
+ * Prompts are injected so the flow is unit-testable without a TTY; the default
+ * implementation uses the same `@inquirer/prompts` primitives as the SAP
+ * onboarding wizard.
+ */
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from '../config/loader.js';
+import { runStandardsInit } from '../standards/standards-init.js';
+import { STANDALONE_PLATFORMS, STANDALONE_DATABASES, STANDALONE_DEPLOYMENTS, STANDALONE_IDES, deriveDatabase, deriveDeployment, defaultAbapCloudOnly, defaultRelease, releaseExamples, } from './standalone-profile.js';
+async function defaultPrompts() {
+    const { input, select, confirm } = await import('@inquirer/prompts');
+    return {
+        select: (o) => select({ message: o.message, choices: o.choices, default: o.default }),
+        input: (o) => input({ message: o.message, default: o.default }),
+        confirm: (o) => confirm({ message: o.message, default: o.default }),
+    };
+}
+/**
+ * Ask the standalone profile questions, persist `[standalone]`, and return the
+ * profile. Questions the platform already answers (database on any S/4HANA or
+ * BTP system, deployment on the cloud editions) are derived, not asked.
+ */
+export async function runStandaloneProfileWizard(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const p = opts.prompts ?? (await defaultPrompts());
+    console.log(chalk.cyan.bold('\nCSPeach — standalone setup\n'));
+    console.log(chalk.dim('No SAP system is connected, so tell CSPeach what system your code will land on.\n'));
+    // 1 — platform
+    const platform = (await p.select({
+        key: 'platform',
+        message: 'Which SAP platform do you develop for?',
+        choices: STANDALONE_PLATFORMS.map((v) => ({ value: v, name: v })),
+        default: 'S/4HANA',
+    }));
+    // 2 — release (free text, platform-appropriate examples + default)
+    const release = (await p.input({
+        key: 'release',
+        message: `Release (e.g. ${releaseExamples(platform)}):`,
+        default: defaultRelease(platform),
+    })).trim() || defaultRelease(platform);
+    // 3 — database (only ECC can be something other than HANA)
+    const derivedDb = deriveDatabase(platform);
+    const database = (derivedDb ??
+        (await p.select({
+            key: 'database',
+            message: 'Database:',
+            choices: STANDALONE_DATABASES.map((v) => ({ value: v, name: v })),
+            default: 'HANA',
+        })));
+    // 4 — deployment (derived for the cloud editions)
+    const derivedDeployment = deriveDeployment(platform);
+    const deployment = (derivedDeployment ??
+        (await p.select({
+            key: 'deployment',
+            message: 'Where does it run?',
+            choices: [
+                { value: 'on-prem', name: 'on-prem' },
+                { value: 'private-cloud', name: 'private-cloud (hosted / RISE private edition)' },
+            ].filter((c) => STANDALONE_DEPLOYMENTS.includes(c.value)),
+            default: 'on-prem',
+        })));
+    // 5 — IDE the team uses (drives where a Manual Implementation Guide points)
+    const ide = (await p.select({
+        key: 'ide',
+        message: 'Which IDE does the team use?',
+        choices: STANDALONE_IDES.map((v) => ({
+            value: v,
+            name: v === 'both' ? 'both ADT and SE80' : v,
+        })),
+        default: 'ADT',
+    }));
+    // 6 — clean-core requirement
+    const abapCloudOnly = await p.confirm({
+        key: 'abap_cloud_only',
+        message: 'Must new code be ABAP Cloud / clean-core compliant?',
+        default: defaultAbapCloudOnly(platform),
+    });
+    // 7 — optional one-liner
+    const notes = (await p.input({
+        key: 'notes',
+        message: 'Anything else in one line (e.g. "no BTP", "transports via ChaRM")? Enter to skip:',
+        default: '',
+    })).trim();
+    const profile = {
+        platform,
+        release,
+        database,
+        deployment,
+        ide,
+        abap_cloud_only: abapCloudOnly,
+    };
+    if (notes.length > 0)
+        profile.notes = notes;
+    const cfg = await loadConfig();
+    cfg.standalone = profile;
+    // Mark the table explicit so sparse serialisation keeps it.
+    if (!Array.isArray(cfg.file_keys))
+        cfg.file_keys = [];
+    if (!cfg.file_keys.includes('standalone'))
+        cfg.file_keys.push('standalone');
+    await saveConfig(cfg);
+    console.log(chalk.green(`\n✓ Standalone profile saved: ${platform} ${release} (${deployment}, ${ide}` +
+        `${abapCloudOnly ? ', ABAP Cloud only' : ''})`));
+    console.log(chalk.dim('  Change it any time: cspeach config set standalone.<key> <value>\n'));
+    // 8 — development standards (the last question; also `cspeach standards init`)
+    if (!opts.skipStandards) {
+        await runStandardsInit(cwd, p);
+    }
+    return profile;
+}

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}`;
+}