@cspeach/cli 1.1.2 → 1.1.4

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';
@@ -17,6 +19,7 @@ import { createClassicOutputEmitter } from './renderer/notices.js';
 import { todoEmitter } from './ui/todo-emitter.js';
 import { applyLocalBuildConfig } from './tools/local-build.js';
 import { getEffectiveWriteMode } from './repl/mode-cycle.js';
+import { initCredits } from './cost/credits-wire.js';
 // Side-effect imports for tool registration.
 import './tools/sap-read.js';
 import './tools/sap-write.js';
@@ -50,6 +53,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 +76,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.'));
@@ -90,18 +98,42 @@ export async function runOneShot(prompt, opts) {
         console.error('No API key configured. Run `cspeach` (interactive) first to set one.');
         return 1;
     }
+    // Credits (2026-09-16) — resolve the display mode before the turn runs, so
+    // the per-turn cost JSONL records the ledger charge and nothing downstream
+    // can print a dollar to a managed customer. One-shot prints no cost figure
+    // of its own today, but the agent loop's cost-log path is shared with the
+    // REPL and must not diverge. Capped + fail-safe; BYOK/local skip the call.
+    await initCredits(cfg, async () => (await store.get()) ?? '');
     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/status-footer.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { formatCost } from '../cost/pricing.js';
+import { creditsActive, formatCreditsLine, CREDITS_PENDING } from '../cost/credits.js';
 const RULE_WIDTH = 72;
 const RULE = chalk.dim('─'.repeat(RULE_WIDTH));
 /**
@@ -40,15 +41,24 @@ export const LARGE_SESSION_THRESHOLD = 100_000;
  * direct stdout (which would corrupt the live Ink frame).
  */
 export function formatStatusFooter(params) {
-    const { sessionId, sapAlias, skill, turnCount, tokens, cachedTokens, elapsedMs, costThisTurn, costSession, sessionInputTokens, variant } = params;
+    const { sessionId, sapAlias, skill, turnCount, tokens, cachedTokens, elapsedMs, costThisTurn, costSession, sessionInputTokens, variant, credits } = params;
     const shortSession = sessionId.slice(0, 8);
     const skillDisplay = skill.startsWith('/') ? skill : `/${skill}`;
     const turns = `${turnCount} turn${turnCount === 1 ? '' : 's'}`;
     const tokStr = tokens.toLocaleString() + ' tok this turn';
     const cachedStr = cachedTokens > 0 ? `${cachedTokens.toLocaleString()} cached` : '';
     const elapsed = elapsedMs > 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : '';
-    const costTurnStr = costThisTurn != null ? formatCost(costThisTurn) : '';
-    const costSessStr = costSession != null ? `session: ${formatCost(costSession)}` : '';
+    // Credits mode: the whole spend story collapses into ONE customer-facing
+    // segment (turn · session · balance) in place of the two dollar segments.
+    // Both variants read `costTurnStr`, so putting the combined line there
+    // covers the slim Ink receipt and the full classic receipt alike.
+    const inCredits = creditsActive();
+    const costTurnStr = inCredits
+        ? (credits ? formatCreditsLine(credits) : CREDITS_PENDING)
+        : (costThisTurn != null ? formatCost(costThisTurn) : '');
+    const costSessStr = inCredits
+        ? ''
+        : (costSession != null ? `session: ${formatCost(costSession)}` : '');
     // Ink turn-receipt (see the variant doc on StatusFooterParams):
     // turn-only facts — everything session-scoped lives in <StatusLine />.
     const parts = variant === 'turn'

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

@@ -20,6 +20,7 @@
 import { computeCost } from '../cost/pricing.js';
 import { computeSessionCost } from '../cost/session-cost.js';
 import { globalStore } from '../ui/sap-state-store.js';
+import { globalCredits } from '../cost/credits.js';
 import { printStatusFooter, formatStatusFooter } from '../renderer/status-footer.js';
 import { shouldUseInk } from '../renderer/tty.js';
 export function snapshotTurnStart(session) {
@@ -71,6 +72,10 @@ export function pushPostTurnStatus(params) {
         costThisTurn: turnCost,
         costSession: sessionCost,
         sessionInputTokens: session.usage.input_tokens,
+        // Credits (2026-09-16): the agent loop already sampled the post-turn
+        // balance, so this snapshot is fresh. formatStatusFooter ignores it
+        // entirely in USD mode — the dollar receipt stays byte-identical.
+        credits: globalCredits.snapshot(),
     };
     if (shouldUseInk() && chunkEmitter) {
         // Push through chunkEmitter so the line lands in Body's <Static>

package/dist/repl/session-spend-line.js

@@ -0,0 +1,20 @@
+/**
+ * The `spend:` row of the /exit session summary (2026-09-16).
+ *
+ * Extracted from repl.tsx's printGoodbye so the credits/USD switch has one
+ * testable home. USD output is byte-identical to the line printed before
+ * credits existed: `  spend:     $1.37`.
+ */
+import { formatCost } from '../cost/pricing.js';
+import { creditsActive, formatCredits, CREDITS_PENDING } from '../cost/credits.js';
+export function formatSessionSpendLine(sessionCostUsd, credits) {
+    if (!creditsActive())
+        return `  spend:     ${formatCost(sessionCostUsd)}`;
+    if (!credits)
+        return `  spend:     ${CREDITS_PENDING}`;
+    const value = formatCredits(credits.sessionTotal, credits.unitLabel);
+    const balance = credits.balance !== null
+        ? ` · balance ${Math.round(credits.balance).toLocaleString('en-US')}`
+        : '';
+    return `  spend:     ${value}${balance}`;
+}

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';
@@ -20,7 +22,10 @@ import { makeSessionId, saveSession } from './session/store.js';
 import { newSession } from './session/schema.js';
 import { resolveModelRole } from './models/resolve.js';
 import { loadServerModelConfig } from './models/server-config.js';
-import { computeCost, formatCost } from './cost/pricing.js';
+import { computeCost } from './cost/pricing.js';
+import { formatSessionSpendLine } from './repl/session-spend-line.js';
+import { globalCredits } from './cost/credits.js';
+import { initCredits } from './cost/credits-wire.js';
 import { createProviderForMode } from './agent/providers/factory.js';
 import { assertModeLicensed, CspeachLicenseError } from './agent/providers/license-gate.js';
 import { runTurn } from './agent/loop.js';
@@ -240,7 +245,7 @@ function printGoodbye(session) {
     console.log(chalk.dim(`  turns:     ${userTurns}`));
     console.log(chalk.dim(`  last skill: ${session.skill ?? '(none)'}`));
     console.log(chalk.dim(`  tokens:    ${totalTokens.toLocaleString()}  (input+output+cache)`));
-    console.log(chalk.dim(`  spend:     ${formatCost(sessionCost)}`));
+    console.log(chalk.dim(formatSessionSpendLine(sessionCost, globalCredits.snapshot())));
     console.log('');
     console.log(chalk.cyan(`Resume with: cspeach --resume ${session.id}`));
     console.log(chalk.dim(`Full log: ~/.cspeach/streams/${session.id}.md`));
@@ -373,7 +378,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();
@@ -383,6 +407,13 @@ export async function runRepl(opts) {
     // fetch lands simply uses the built-ins (fail-safe). Precedence when it does
     // land: env > local config > server > built-in.
     void loadServerModelConfig(cfg);
+    // Credits (2026-09-16) — resolve ONCE, before any cost figure can render.
+    // A managed customer is billed in credits at a multiplier we do not
+    // disclose, so the dollar figures (our Anthropic COGS) must never reach
+    // their screen. Awaited, but hard-capped at 2.5s inside fetchBalance and
+    // fail-safe: any failure leaves the process in USD mode, i.e. exactly the
+    // pre-credits behaviour. BYOK/ai-hub/local skip the round-trip entirely.
+    await initCredits(cfg, async () => apiKey ?? '');
     // Task C.10 — surface the current write_mode prominently. advisory-only gets
     // a bold yellow banner (no-writes is a surprising-enough state that the user
     // should not miss it). Other modes get a quiet one-liner so the state is
@@ -418,7 +449,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 +497,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 +514,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;
+}