@cspeach/cli 1.1.1 → 1.1.3

package/dist/doctor/checks/forge-rules.js

@@ -18,11 +18,17 @@
 import { loadConfig } from '../../config/loader.js';
 import { getConnection } from '../../sap/connection-manager.js';
 import { AdtClient, snapshots } from '@cspeach/sap-client';
+import { sapChecksSkipped, standaloneSkip } from './_standalone-skip.js';
 const PROBE_NAME = 'Z_CSPEACH_DOCTOR_PROBE';
 const PROBE_PACKAGE = '$TMP';
 const PROBE_SOURCE = `REPORT ${PROBE_NAME}.\nWRITE / 'cspeach doctor probe — safe to delete'.`;
 export async function checkForgeRules() {
     const cfg = await loadConfig();
+    // Standalone mode ONLY — the Rule 7/10 probe needs a live system, and an
+    // opted-in paste-mode user has none. Everything below (including the
+    // no-alias skip) is unchanged.
+    if (sapChecksSkipped(cfg))
+        return standaloneSkip('forge-rules');
     const aliases = Object.keys(cfg.sap);
     if (aliases.length === 0) {
         return {

package/dist/doctor/checks/sap.js

@@ -1,8 +1,13 @@
 import { readFile } from 'node:fs/promises';
 import { loadConfig, resolveSapTls } from '../../config/loader.js';
 import { probeGet } from './_http-probe.js';
+import { sapChecksSkipped, standaloneSkip } from './_standalone-skip.js';
 export async function checkSap() {
     const cfg = await loadConfig();
+    // Standalone mode ONLY — an opted-in paste-mode user has nothing to probe.
+    // Everything below (including the no-alias failure) is unchanged.
+    if (sapChecksSkipped(cfg))
+        return standaloneSkip('sap');
     const systems = Object.entries(cfg.sap);
     if (systems.length === 0)
         return { name: 'sap', ok: false, message: 'no SAP systems configured', hint: 'Run: cspeach config add-sap' };

package/dist/doctor/checks/standards.js

@@ -0,0 +1,27 @@
+/**
+ * Doctor check: standards (2026-09-16).
+ *
+ * Purely informational — surfaces WHICH development-standards document the
+ * session context is carrying, so a team that thinks their rules are being
+ * followed can confirm it at a glance. Having none is a normal state (CSPeach's
+ * built-in conventions apply), so it renders as a neutral `-` line, never a
+ * failure.
+ */
+import { resolveStandardsFile, displayStandardsPath } from '../../standards/standards-file.js';
+export async function checkStandards() {
+    const cwd = process.cwd();
+    const file = await resolveStandardsFile(cwd);
+    if (!file) {
+        return {
+            name: 'standards',
+            ok: false,
+            skipped: true,
+            message: 'none (run: cspeach standards init)',
+        };
+    }
+    return {
+        name: 'standards',
+        ok: true,
+        message: displayStandardsPath(file.path, cwd),
+    };
+}

package/dist/doctor/checks/system-roles.js

@@ -1,3 +1,4 @@
+import { sapChecksSkipped, standaloneSkip } from './_standalone-skip.js';
 /**
  * Doctor check: system-roles (UX Wave 1, Task 1).
  *
@@ -11,6 +12,10 @@
  * never counts toward the doctor's failed total. Pure — no I/O beyond cfg.
  */
 export async function checkSystemRoles(cfg) {
+    // Standalone mode ONLY — nothing to put a write-mode ceiling on. Everything
+    // below (including the no-alias skip) is unchanged.
+    if (sapChecksSkipped(cfg))
+        return standaloneSkip('system-roles');
     const entries = Object.entries(cfg.sap ?? {});
     if (entries.length === 0) {
         return {

package/dist/doctor/checks/zcspeach.js

@@ -2,9 +2,14 @@ import keytar from 'keytar';
 import { readFile } from 'node:fs/promises';
 import { loadConfig, resolveSapTls } from '../../config/loader.js';
 import { probeGet } from './_http-probe.js';
+import { sapChecksSkipped, standaloneSkip } from './_standalone-skip.js';
 const SAP_SERVICE = 'cspeach-sap';
 export async function checkZcspeach() {
     const cfg = await loadConfig();
+    // Standalone mode ONLY — an opted-in paste-mode user has nothing to probe.
+    // Everything below (including the no-alias failure) is unchanged.
+    if (sapChecksSkipped(cfg))
+        return standaloneSkip('zcspeach');
     const systems = Object.entries(cfg.sap);
     if (systems.length === 0) {
         return {

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/renderer/abap-inline.js

@@ -7,6 +7,7 @@
  *   ```abap  → existing ABAP regex logic (unchanged)
  *   ```cds   → cli-highlight CDS grammar (via syntax.ts)
  *   ```bdef  → cli-highlight BDEF grammar (via syntax.ts)
+ *   ```ddl   → cli-highlight CDS grammar (ddl is a CDS alias; via syntax.ts)
  *   ```<any other or empty> → pass through (no highlight)
  *
  * The function is renamed `applyCodeHighlight`. A deprecation re-export
@@ -64,7 +65,7 @@ export function applyCodeHighlight(text) {
                 // dependency for the hottest fenced-block type.
                 out.push(highlightAbapBlock(body));
             }
-            else if (lang === 'cds' || lang === 'bdef') {
+            else if (lang === 'cds' || lang === 'bdef' || lang === 'ddl') {
                 // cli-highlight grammars via the Task 5 dispatcher.
                 out.push(highlightCodeBlock(body, lang));
             }

package/dist/renderer/syntax.js

@@ -47,7 +47,13 @@ const hljs = createRequire(require.resolve('cli-highlight'))('highlight.js');
 hljs.registerLanguage('abap', () => abapGrammar);
 hljs.registerLanguage('cds', () => cdsGrammar);
 hljs.registerLanguage('bdef', () => bdefGrammar);
-const SUPPORTED = new Set(['abap', 'cds', 'bdef']);
+// `ddl` is an alias of the CDS grammar: ```ddl fences carry CDS DDL source
+// (the abap-rap templates emit them). Registering it on the same hljs
+// instance also silences marked-terminal's "Could not find the language
+// 'ddl'" warning, since marked-terminal calls cli-highlight directly with
+// the raw fence lang and never goes through highlightCodeBlock().
+hljs.registerLanguage('ddl', () => cdsGrammar);
+const SUPPORTED = new Set(['abap', 'cds', 'bdef', 'ddl']);
 /**
  * Highlight a code block body (without fence markers).
  *

package/dist/repl/current-transport.js

@@ -15,12 +15,23 @@
  * Module-scope singleton per CLI process. Tests must call clearCurrentTransport()
  * in beforeEach to avoid leakage across Vitest test files.
  *
- * Task 9 (ux-wave1) — this setter is ALSO the single statusline wire for the
+ * Task 9 (ux-wave1) — this setter is ALSO a statusline wire for the
  * `tr <TRKORR>` segment: every path that changes the session transport
  * (sap_transport create success, owning-transport adoption in the create
  * guard, /transport slash command) funnels through set/clear here, so the
  * globalStore push lives HERE rather than scattered across tool handlers.
  * Store writes are harmless in classic mode (nothing subscribes there).
+ *
+ * F-L2-1 (2026-08-11) — that wire alone is not enough, so this module now
+ * carries a SECOND, write-side wire: noteWriteTransport(). The session flow
+ * above is the only writer of `store.transport`, but a per-write `corrNr`
+ * coming from a prompt or a plan never travels through it — live evidence: a
+ * whole session's writes stamped S4HK903635 while the statusline read
+ * `tr none`. noteWriteTransport records what a write ACTUALLY stamped into a
+ * SEPARATE store field (`lastWriteTransport`) that the statusline falls back
+ * to. It deliberately does NOT touch the session pointer below: that pointer
+ * feeds the 3-tier write-transport fallback, and moving it would change write
+ * behaviour, not just the display.
  */
 import { globalStore } from '../ui/sap-state-store.js';
 let currentTransport = null;
@@ -35,6 +46,17 @@ export function clearCurrentTransport() {
     currentTransport = null;
     globalStore.update({ transport: null });
 }
+/**
+ * Statusline-only wire (F-L2-1): record the transport actually stamped on the
+ * last successful write. Never touches the session transport pointer — see the
+ * module doc. No-op on a falsy trkorr (local / $TMP objects write without one,
+ * and blanking the display there would lose the last real datapoint).
+ */
+export function noteWriteTransport(trkorr) {
+    if (!trkorr)
+        return;
+    globalStore.update({ lastWriteTransport: trkorr });
+}
 /**
  * Handles the `/transport [<trkorr>|clear]` slash command. Returns user-facing
  * status text. Mirrors the shape of handleSafetyModeCommand in safety-mode-state.ts.

package/dist/repl/post-turn-status.js

@@ -18,6 +18,7 @@
  * primary per-turn status surface.
  */
 import { computeCost } from '../cost/pricing.js';
+import { computeSessionCost } from '../cost/session-cost.js';
 import { globalStore } from '../ui/sap-state-store.js';
 import { printStatusFooter, formatStatusFooter } from '../renderer/status-footer.js';
 import { shouldUseInk } from '../renderer/tty.js';
@@ -43,12 +44,9 @@ export function pushPostTurnStatus(params) {
         cacheCreate: (session.usage.cache_creation_input_tokens ?? 0) - snapshot.cacheCreate,
     };
     const turnCost = computeCost(turnModel ?? session.model, turnCostTokens);
-    const sessionCost = computeCost(session.model, {
-        input: session.usage.input_tokens,
-        output: session.usage.output_tokens,
-        cacheRead: session.usage.cache_read_input_tokens,
-        cacheCreate: session.usage.cache_creation_input_tokens ?? 0,
-    });
+    // F-L2-2: extracted to cost/session-cost.ts so the agent loop can push the
+    // SAME total mid-stream. This call site is unchanged in behaviour.
+    const sessionCost = computeSessionCost(session);
     // Task 9 (ux-wave1) — statusline spend wire. Honest semantics note: the
     // store field is named `dollarSpendToday` (legacy sidebar naming, kept to
     // avoid rename churn) but the value written is SESSION-scoped — the same
@@ -56,6 +54,11 @@ export function pushPostTurnStatus(params) {
     // lifetime session.usage at session.model rates (mixed-model turns are an
     // approximation, same caveat as the footer's session line). There is no
     // day-spanning ledger; the statusline shows session spend.
+    //
+    // F-L2-2 (2026-08-11): the agent loop now pushes the same value mid-stream
+    // so the segment ticks DURING a turn, not only between turns. This push
+    // stays as the authoritative end-of-turn settle (the loop's pushes are
+    // gated to REPL turns; this one runs on every path that reaches here).
     globalStore.update({ dollarSpendToday: sessionCost });
     const statusPayload = {
         sessionId: session.id,

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
@@ -822,6 +851,7 @@ export async function runRepl(opts) {
                         skill: rr.skill,
                         ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                         chunkEmitter,
+                        pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                     });
                 }
                 finally {
@@ -1254,6 +1284,7 @@ export async function runRepl(opts) {
                     skill: skill,
                     ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                     chunkEmitter,
+                    pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                     signal: currentTurnAbort.signal,
                     suppressSaveHook: planResume !== null || planContinue !== null,
                     // A4 — undefined on every non-plan turn (and when tiering is off).
@@ -2270,6 +2301,7 @@ export async function runRepl(opts) {
                 userMessage: rr.prompt,
                 skill: rr.skill,
                 ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
             });
             continue;
         }
@@ -2797,6 +2829,7 @@ export async function runRepl(opts) {
                 userMessage: prompt,
                 skill: skill,
                 ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                 signal: turnAbort.signal,
                 suppressSaveHook: planResume !== null || planContinue !== null,
                 // A4 — undefined on every non-plan turn (and when tiering is off).

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