@cspeach/cli 1.1.44 → 1.1.46

package/dist/approvals/jwt.js

@@ -15,6 +15,8 @@ const usedNonces = new Set();
  *   - approving `modify` covers modify → activate (write then activate).
  *   - `delete` / `release` stay single-op (and single-use) — one-shot ops the
  *     user must approve explicitly each time.
+ *   - `run` (Part 3 D2) is single-op and single-use too: one approval runs a
+ *     class or program once.
  *
  * This removes the op_mismatch APPROVAL_INVALID storm (create approval used,
  * then set_source rejected because it's a different op) without weakening the
@@ -26,11 +28,12 @@ const OP_COVERAGE = {
     delete: new Set(['delete']),
     activate: new Set(['activate']),
     release: new Set(['release']),
+    run: new Set(['run']),
 };
 /** create/modify approvals are reusable across their object's lifecycle ops
- *  until TTL; delete/release are genuinely one-shot. */
+ *  until TTL; delete/release/run are genuinely one-shot. */
 function isOneShotOp(op) {
-    return op === 'delete' || op === 'release';
+    return op === 'delete' || op === 'release' || op === 'run';
 }
 export async function mintApprovalId(payload) {
     const nonce = crypto.randomBytes(16).toString('hex');

package/dist/approvals/op-labels.js

@@ -14,6 +14,7 @@ const VERBS = {
     delete: 'Delete',
     activate: 'Activate',
     release: 'Release',
+    run: 'Run',
 };
 /**
  * SAP ADT type codes → plain words. The `type` field is free text supplied by
@@ -45,6 +46,8 @@ const TYPE_WORDS = {
     FUNC: 'function module',
     FINC: 'function group include',
     INCL: 'include',
+    // Part 3 (T1 ruling): the release and the create card both read "transport request".
+    CTS: 'transport request',
 };
 export function humanVerb(op) {
     return VERBS[op] ?? op.charAt(0).toUpperCase() + op.slice(1);
@@ -86,6 +89,38 @@ export function affectsLine(change) {
     const t = sanitizeControlChars(String(change.affects ?? '')).trim();
     return t ? `Affects: ${t}` : null;
 }
+/** Part 3 D12 — the longest request description a release card shows. */
+const RELEASE_DESCRIPTION_MAX = 60;
+const RELEASE_LAST_LINE = 'Cannot be undone. Once released, the request can move to the other systems on the transport route.';
+/** Part 3 D13 — the card a person decides on says what CSPeach checks and where to check it after the release (owner wording 2026-10-17). */
+export const RELEASE_CHECK_LINE = 'CSPeach reads SAP\'s verdict after each step and checks the request afterwards. Check the transport in SE09 after the release.';
+/**
+ * Part 3 D12 — the fixed lines under a release change; [] for any other change
+ * or when no facts are attached. The facts are SAP's (request_approval reads
+ * them from the request before the card is drawn); text from SAP still passes
+ * through sanitizeControlChars. A task owned by someone other than the request
+ * owner is named (preflight F-15: SAP releases it under the caller's
+ * authorization).
+ */
+export function releaseLines(change) {
+    const f = change.releaseFacts;
+    if (change.op !== 'release' || !f)
+        return [];
+    const clean = (v) => sanitizeControlChars(String(v ?? '')).trim();
+    let description = clean(f.description);
+    if (description.length > RELEASE_DESCRIPTION_MAX)
+        description = `${description.slice(0, RELEASE_DESCRIPTION_MAX)}…`;
+    const owner = clean(f.owner);
+    const tasks = Array.isArray(f.tasks) ? f.tasks : [];
+    const others = [...new Set(tasks.map((t) => clean(t.owner)).filter((o) => o && o !== owner))];
+    return [
+        `Request ${clean(f.request)} "${description}" · owner ${owner} · target ${clean(f.target) || 'none'}`,
+        `${tasks.length} ${tasks.length === 1 ? 'task' : 'tasks'}: ${tasks.map((t) => clean(t.number)).join(', ')} · ${f.objects === null || f.objects === undefined ? 'objects: could not count' : `${f.objects} ${f.objects === 1 ? 'object' : 'objects'}`}`
+            + (others.length ? ` · other owners: ${others.join(', ')}` : ''),
+        RELEASE_LAST_LINE,
+        RELEASE_CHECK_LINE,
+    ];
+}
 /**
  * The transport to DISPLAY on the approval surface for one change — mirrors
  * how the write tools actually resolve it (traced in sap-write.ts, 2026-07-05
@@ -97,8 +132,8 @@ export function affectsLine(change) {
  *     resolveWriteTransport(args only, + owning-TR override) — NO session
  *     fallback in the actual write, so we only show a transport the request
  *     explicitly carries.
- *   - activate/release: the tools take no transport arg at all — never show
- *     a Transport segment.
+ *   - activate/release/run: the tools take no transport arg at all — never
+ *     show a Transport segment.
  * When nothing is resolvable, return undefined and the caller OMITS the
  * segment — no "new (session)" promise (a $TMP write never creates one).
  */
@@ -109,7 +144,7 @@ export function displayTransport(op, explicit, session) {
         case 'modify':
         case 'delete':
             return explicit;
-        default: // activate / release
+        default: // activate / release / run
             return undefined;
     }
 }
@@ -132,7 +167,7 @@ export function toSourceLines(content) {
  *   - modify  → [d] Show diff (there IS a before/after to diff)
  *   - create  → [v] View source, only when the new source is carried
  *   - delete  → [v] View current source, only when the source is carried
- *   - activate/release → nothing to review (no source in the payload)
+ *   - activate/release/run → nothing to review (no source in the payload)
  */
 export function viewAffordance(change) {
     switch (change.op) {

package/dist/approvals/render.js

@@ -1,7 +1,7 @@
 import { select, input } from '@inquirer/prompts';
 import chalk from 'chalk';
 import { riskReasonText, shownRiskReasons } from './risk-floor.js';
-import { verbLine, viewAffordance, toSourceLines, affectsLine } from './op-labels.js';
+import { verbLine, viewAffordance, toSourceLines, affectsLine, releaseLines } from './op-labels.js';
 import { shouldUseInk } from '../renderer/tty.js';
 import { approvalEmitter } from '../ui/approval-emitter.js';
 import { withInquirer } from '../repl/inquirer-guard.js';
@@ -118,22 +118,44 @@ export async function renderPlanGate(summary, changes, transport, effectiveRisk,
         // implementation) carries its "Affects:" row right under it. The card's
         // step budget counts rows, and a step is never shown without its row.
         // No affects anywhere: one row per step, exactly as before.
+        // Part 3 D12 / F-13 — a release step carries its fact lines the same way:
+        // "Apply all" mints it without its per-change card.
         const steps = visibleChanges.map((c, i) => {
             const affects = affectsLine(c);
-            return [`${i + 1}. ${verbLine(c)}`, ...(affects ? [`   ${affects}`] : [])];
+            return [`${i + 1}. ${verbLine(c)}`, ...(affects ? [`   ${affects}`] : []), ...releaseLines(c).map((l) => `   ${l}`)];
         });
-        const totalRows = steps.reduce((n, s) => n + s.length, 0);
+        // Fix round 1 (owner ruling) — a release step is ALWAYS on the card, with
+        // its fact lines, wherever it sits: its rows have their own budget and
+        // never count toward MAX_STEPS. The other steps keep today's budget, so a
+        // plan without a release renders exactly as before.
+        const isRelease = visibleChanges.map((c) => releaseLines(c).length > 0);
+        const totalRows = steps.reduce((n, s, i) => n + (isRelease[i] ? 0 : s.length), 0);
         if (totalRows > MAX_STEPS) {
             // Object names are model-supplied: neutralise control characters
             // before they reach scrollback (the card sanitises its own rows).
             emitTrace(sanitizeControlChars(['Plan', ...steps.flat().map((s) => `  ${s}`)].join('\n')));
+            const shownRows = [];
             let shown = 0;
+            let others = 0;
             let rows = 0;
-            while (shown < steps.length && (shown === 0 || rows + steps[shown].length <= MAX_STEPS)) {
-                rows += steps[shown].length;
-                shown += 1;
-            }
-            facts.push(...steps.slice(0, shown).flat(), `${getGlyphs().more} ${steps.length - shown} more steps, listed above`);
+            let full = false;
+            steps.forEach((s, i) => {
+                if (isRelease[i]) {
+                    shownRows.push(...s);
+                    shown += 1;
+                    return;
+                }
+                if (!full && (others === 0 || rows + s.length <= MAX_STEPS)) {
+                    shownRows.push(...s);
+                    rows += s.length;
+                    others += 1;
+                    shown += 1;
+                }
+                else {
+                    full = true;
+                }
+            });
+            facts.push(...shownRows, `${getGlyphs().more} ${steps.length - shown} more steps, listed above`);
         }
         else {
             facts.push(...steps.flat());
@@ -180,6 +202,9 @@ async function classicPlanGate(summary, visibleChanges, transport, effectiveRisk
         const affects = affectsLine(c);
         if (affects)
             console.log(`           ${chalk.dim(affects)}`);
+        // Part 3 D12 / F-13 — a release row's facts, under its line.
+        for (const l of releaseLines(c))
+            console.log(`           ${chalk.dim(l)}`);
     });
     console.log('');
     const choice = await withInquirer(() => select({
@@ -213,8 +238,10 @@ export async function renderPerChangeApproval(change, effectiveRisk, transport)
     choices.push({ value: 'skip', name: 'Skip (tell model why)' }, { value: 'cancel', name: 'Cancel turn' });
     // Part 2b D7 — the process a BAdI implementation runs in, under the verb line.
     const affects = affectsLine(change);
+    // Part 3 D12 — a release card's facts, under the verb line.
+    const release = releaseLines(change).map((l) => `\n  ${chalk.dim(l)}`).join('');
     const choice = await withInquirer(() => select({
-        message: `${objLabel} — apply?${affects ? `\n  ${chalk.dim(affects)}` : ''}`,
+        message: `${objLabel} — apply?${affects ? `\n  ${chalk.dim(affects)}` : ''}${release}`,
         default: 'apply',
         theme: inquirerTheme,
         choices,

package/dist/approvals/risk-floor.js

@@ -48,8 +48,18 @@ export function effectiveRisk(declared, changes, ctx) {
     // Round 4 item 8a — these were both labelled 'shared_transport', so a plan
     // on a transport created seconds earlier read "raised … by shared_transport".
     // Each reason now says what actually raised it.
-    if (changes.some((c) => c.op === 'release'))
-        raise('medium', 'transport_release');
+    // Part 3 D2 — a release cannot be undone, and a run executes code on the
+    // system: both are high (never auto-approved), and the reason is always shown.
+    if (changes.some((c) => c.op === 'release')) {
+        raise('high', 'transport_release');
+        if (!raisedBy.includes('transport_release'))
+            raisedBy.push('transport_release');
+    }
+    if (changes.some((c) => c.op === 'run')) {
+        raise('high', 'code_run');
+        if (!raisedBy.includes('code_run'))
+            raisedBy.push('code_run');
+    }
     if (changes.some((c) => c.op === 'activate'))
         raise('medium', 'activation');
     if (ctx.recentAtcFailure && changes.some((c) => ctx.recentAtcFailure.includes(c.object)))
@@ -66,7 +76,7 @@ export function effectiveRisk(declared, changes, ctx) {
 const RISK_REASON_TEXT = {
     non_prod_override: 'auto-approve is set to never on this system (a setting, not a risk)',
     delete_op: 'the plan deletes an object',
-    transport_release: 'the plan releases a transport',
+    transport_release: 'the plan releases a transport; this cannot be undone',
     activation: 'activation makes the change live on the system',
     atc_failed_24h: 'ATC failed on this object in the last 24 hours',
     shared_transport: 'the transport is shared by 3 or more developers',
@@ -74,6 +84,7 @@ const RISK_REASON_TEXT = {
     prod_namespace: 'the object is in a production namespace',
     syntax_errors: 'the last syntax check of this object found errors',
     standard_process: 'this code runs inside a standard SAP process (a BAdI implementation)',
+    code_run: 'this runs code on the SAP system',
 };
 /** Round 8 item 4 — every code the floor can raise (each has plain words above). */
 export const RISK_REASON_CODES = Object.keys(RISK_REASON_TEXT);

package/dist/cli.js

@@ -275,6 +275,13 @@ export async function main(argv) {
         const { runOneShot } = await import('./one-shot.js');
         return runOneShot(args.slice(1).join(' '), { sapAlias, noSap });
     }
+    // Word export (2026-10-19): `cspeach export <file>.md --docx` writes a Word
+    // copy next to the file. Must sit above the one-shot fallback, or the words
+    // would be sent to the model as a paid prompt.
+    if (args[0] === 'export') {
+        const { parseExportDocxArgs, runExportDocxCommand } = await import('./commands/export-docx.js');
+        return runExportDocxCommand({ ...parseExportDocxArgs(args.slice(1)), cwd: process.cwd(), system: noSap ? null : sapAlias ?? null, emit: (l) => console.log(l) });
+    }
     // Default: if first arg exists and is not a flag, treat as one-shot prompt.
     if (args.length > 0 && !args[0].startsWith('-')) {
         const { runOneShot } = await import('./one-shot.js');
@@ -301,6 +308,7 @@ Usage:
   cspeach                           Start interactive REPL
   cspeach "<prompt>"                One-shot — runs one turn and exits
   cspeach --one-shot "<prompt>"     Same as above, explicit flag
+  cspeach export <file>.md --docx   Write a Word copy next to a saved review or handover
   cspeach --sap-alias <name>        Use a specific SAP alias (overrides default)
   cspeach --no-sap                  Start without a SAP system (paste-mode skills only)
   cspeach --continue, -c            Continue the latest session in this folder

package/dist/commands/config-set.js

@@ -1,6 +1,8 @@
 import chalk from 'chalk';
 import { formatAttention } from '../renderer/notice-shape.js';
 import { loadConfig, saveConfig, isValidWriteMode } from '../config/loader.js';
+import { ASSISTANT_STYLES, parseStyle } from '../agent/style.js';
+import { ASSISTANT_LEVELS, parseLevel } from '../agent/level.js';
 import { STANDALONE_PLATFORMS, STANDALONE_DATABASES, STANDALONE_DEPLOYMENTS, STANDALONE_IDES, isStandalonePlatform, deriveDatabase, deriveDeployment, defaultAbapCloudOnly, defaultRelease, } from '../sap/standalone-profile.js';
 /**
  * Mutable keys exposed via `cspeach config set`.
@@ -14,9 +16,13 @@ const MUTABLE_KEYS = new Set([
     'effort',
     'telemetry',
     'classifier.safe_mode',
+    'assistant.lane',
+    'assistant.style',
+    'assistant.level',
     'local_build',
     'local_files', // deprecated alias for local_build (2026-06-13) — still accepted
     'show_cogs',
+    'word_copy',
     'write_mode',
     'plan_mode',
     'plan_audit',
@@ -76,6 +82,7 @@ const LLM_MODE_VALUES = ['managed', 'byok', 'ai-hub', 'local', 'azure'];
 const PLAN_MODE_VALUES = ['step', 'guarded'];
 const PLAN_AUDIT_VALUES = ['on', 'off'];
 const USAGE_REPORTING_VALUES = ['on', 'off'];
+const ASSISTANT_LANE_VALUES = ['chat', 'skills'];
 const APPROVALS_VALUES = ['plan', 'per-write'];
 /**
  * Thrown on validation failure. The outer CLI dispatcher converts to
@@ -102,7 +109,7 @@ function errUnset(msg) {
  * Internal, loader-derived flags that are never serialised (stripped by
  * saveConfig). They must never be targets of `config set`/`config unset`.
  */
-const INTERNAL_KEYS = new Set(['default_model_set', 'effort_set', 'file_keys']);
+const INTERNAL_KEYS = new Set(['default_model_set', 'effort_set', 'file_keys', 'assistant_file_keys']);
 /**
  * Virtual keys whose values live in the OS keychain, not config.toml. `config
  * unset` cannot remove them — that is a keychain operation — so they are
@@ -135,6 +142,18 @@ export function markExplicit(cfg, key) {
         cfg.file_keys = [];
     if (!cfg.file_keys.includes(top))
         cfg.file_keys.push(top);
+    // [assistant] is sparse per field too (staged rollout, 2026-10-17): an
+    // explicit `config set assistant.lane skills` must stick after a later
+    // release flips the lane default.
+    if (top === 'assistant') {
+        const leaf = key.split('.').slice(1).join('.');
+        if (leaf) {
+            if (!Array.isArray(cfg.assistant_file_keys))
+                cfg.assistant_file_keys = [];
+            if (!cfg.assistant_file_keys.includes(leaf))
+                cfg.assistant_file_keys.push(leaf);
+        }
+    }
 }
 /** Human-readable "allowed values" error for a standalone.<field> set. */
 function standaloneValueError(field, value) {
@@ -519,6 +538,30 @@ export async function runConfigSet(args) {
             }
             cfg.classifier.safe_mode = value === 'true';
             break;
+        // Chat lane (spec 2026-10-17 D2/D9). markExplicit below keeps the table.
+        case 'assistant.lane': {
+            const lane = value.trim().toLowerCase();
+            if (lane !== 'chat' && lane !== 'skills') {
+                err(`assistant.lane must be one of: ${ASSISTANT_LANE_VALUES.join(', ')}`);
+            }
+            cfg.assistant.lane = lane;
+            break;
+        }
+        case 'assistant.style': {
+            const style = parseStyle(value);
+            if (!style)
+                err(`assistant.style must be one of: ${ASSISTANT_STYLES.join(', ')}`);
+            cfg.assistant.style = style;
+            break;
+        }
+        // Spec §10 D13 — who CSPeach is talking to.
+        case 'assistant.level': {
+            const level = parseLevel(value);
+            if (!level)
+                err(`assistant.level must be one of: ${ASSISTANT_LEVELS.join(', ')}`);
+            cfg.assistant.level = level;
+            break;
+        }
         case 'local_files':
             // Deprecated alias (2026-06-13). Still applied — but it WRITES to the new
             // `local_build` key so the user's config converges on the new name. The
@@ -568,6 +611,14 @@ export async function runConfigSet(args) {
                 : '  → cost figures will show credits on a managed, metered account.'));
             break;
         }
+        case 'word_copy': {
+            const b = coerceBool(value);
+            if (b === null)
+                err(`${key} must be on/off (also accepts true/false, 1/0).`);
+            cfg.word_copy = b;
+            console.log(chalk.dim(b ? '  → a Word copy is written with every saved review or handover.' : '  → CSPeach will not ask about Word copies.'));
+            break;
+        }
         case 'write_mode':
             if (!isValidWriteMode(value)) {
                 err(`Invalid value for write_mode. Must be one of: auto, approval-gated, advisory-only`);
@@ -747,9 +798,16 @@ export function validateValue(key, value) {
             return TELEMETRY_VALUES.includes(value);
         case 'classifier.safe_mode':
             return value === 'true' || value === 'false';
+        case 'assistant.lane':
+            return ASSISTANT_LANE_VALUES.includes(value.trim().toLowerCase());
+        case 'assistant.style':
+            return parseStyle(value) !== null;
+        case 'assistant.level':
+            return parseLevel(value) !== null;
         case 'local_build':
         case 'local_files': // deprecated alias — same on/off coercion
         case 'show_cogs':
+        case 'word_copy':
             return coerceBool(value) !== null;
         case 'write_mode':
             return isValidWriteMode(value);

package/dist/commands/config-show.js

@@ -26,6 +26,7 @@ const REDACTED_KEYS = new Set([
 const INTERNAL_KEYS = new Set([
     'default_model_set',
     'file_keys',
+    'assistant_file_keys',
     // Task 4 — effort_set is loader-derived; effort_explicit is the stored
     // marker behind it (plumbing, not a user-facing setting).
     'effort_set',

package/dist/commands/export-docx.js

@@ -0,0 +1,66 @@
+// cspeach-cli/src/commands/export-docx.ts
+//
+// `cspeach export <file>.md --docx` and `/export docx <file>`: one body for both.
+// Reads the Markdown, writes <base>.docx next to it (never overwriting), prints
+// the path. Same emit seam as export-audit.ts (chunkEmitter in Ink, console.log
+// in classic, console.log in cli.ts).
+import fs from 'node:fs';
+import path from 'node:path';
+import { metaFromMarkdown } from '../docx/doc-meta.js';
+import { writeDocxNextTo } from '../docx/write-docx.js';
+export const EXPORT_DOCX_USAGE = 'Usage: cspeach export <file>.md --docx   (in the REPL: /export docx <file>.md)';
+export function parseExportDocxArgs(args) {
+    let docx = false;
+    let file;
+    for (const a of args) {
+        if (a === '--docx')
+            docx = true;
+        else if (!a.startsWith('-') && !file)
+            file = a;
+    }
+    return { ...(file ? { file } : {}), docx };
+}
+/**
+ * The file after `/export docx` in the REPL: the whole rest of the line, so a
+ * path with spaces survives (OneDrive folders), with one pair of quotes removed.
+ */
+export function docxFileFromReplArgs(rest) {
+    const m = /^\s*docx\b\s*(.*)$/is.exec(rest);
+    if (!m)
+        return undefined;
+    const f = m[1].trim().replace(/^(["'])(.*)\1$/s, '$2').trim();
+    return f.length > 0 ? f : undefined;
+}
+function localDate() {
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+export async function runExportDocxCommand(opts) {
+    const { emit } = opts;
+    if (!opts.docx || !opts.file) {
+        emit(EXPORT_DOCX_USAGE);
+        return 1;
+    }
+    const mdPath = path.resolve(opts.cwd ?? process.cwd(), opts.file);
+    if (path.extname(mdPath).toLowerCase() !== '.md') {
+        emit(`Only .md files can be exported to Word. ${EXPORT_DOCX_USAGE}`);
+        return 1;
+    }
+    if (!fs.existsSync(mdPath)) {
+        emit(`File not found: ${mdPath}`);
+        return 1;
+    }
+    try {
+        // Inside the try: a directory named x.md (EISDIR) or an unreadable file
+        // (EACCES) gives the one failure line below, not a stack.
+        const markdown = await fs.promises.readFile(mdPath, 'utf8');
+        const meta = metaFromMarkdown(markdown, { date: opts.today ?? localDate(), ...(opts.system ? { system: opts.system } : {}) });
+        const out = await writeDocxNextTo(mdPath, markdown, meta);
+        emit(`Word copy: ${out}`);
+        return 0;
+    }
+    catch (e) {
+        emit(`Word copy not written. ${e.message}`);
+        return 1;
+    }
+}

package/dist/commands/help.js

@@ -50,6 +50,7 @@ export const HELP_GROUPS = [
         ] },
     { title: 'Session', rows: [
             { name: '/new', description: fixed('Next prompt picks a skill afresh (also /reset)') },
+            { name: '/chat on', description: fixed('Switch to chat — just talk; /abap-… for a guided workflow') },
             { name: '/recap', description: fixed('Show the recap (last session, open tasks, plan)') },
             { name: '/cost', description: costCommandDescription },
             { name: '/usage', description: usageCommandDescription },
@@ -61,8 +62,30 @@ export const HELP_GROUPS = [
     { title: 'Look and settings', rows: [
             { name: '/ui [auto|ink]', description: fixed('Change the UI mode (applies after a relaunch)') },
             { name: '/ui look [panels|legacy]', description: fixed('Switch between the panels and legacy looks') },
+            { name: '/style [professional|conversational|humor|blunt]', description: fixed('Change the talking style — words only; findings and warnings never change') },
+            { name: '/level [developer|learning|functional]', description: fixed('Who CSPeach is talking to — how much it explains, never what it found; for a non-developer also run cspeach config set write_mode advisory-only') },
         ] },
 ];
+/** Chat lane (spec 2026-10-17 D8): the Session group's /new reads "Fresh start"
+ *  and /chat + /chat off replace the skills lane's /chat on row. */
+const CHAT_HELP_GROUPS = HELP_GROUPS.map((g) => g.title !== 'Session' ? g : {
+    title: g.title,
+    rows: g.rows.flatMap((r) => {
+        if (r.name === '/new')
+            return [
+                { name: '/new', description: fixed('Fresh start (also /reset)') },
+                { name: '/chat', description: fixed('Back to chat — leave the current workflow') },
+                { name: '/chat off', description: fixed('Skill routing — every message picks a skill again') },
+            ];
+        if (r.name === '/chat on')
+            return [];
+        return [r];
+    }),
+});
+/** The help groups for a lane; the skills lane gets HELP_GROUPS itself. */
+export function helpGroupsFor(lane) {
+    return lane === 'chat' ? CHAT_HELP_GROUPS : HELP_GROUPS;
+}
 /** /help lists the `?` key itself first, then I2's sheet rows in their order. */
 const SHORTCUTS = [['?', 'shortcuts'], ...SHORTCUT_ROWS];
 /**
@@ -103,14 +126,17 @@ const groupTitle = (t) => paint('sap', chalk.bold(t));
  * can route output through chunkEmitter instead of console.log (which
  * corrupts the React frame). Default keeps the classic-mode behaviour.
  */
-export function printHelp(emit = (s) => console.log(s)) {
+export function printHelp(emit = (s) => console.log(s), opts = {}) {
+    const lane = opts.lane ?? 'skills';
     const width = uiWidth();
     const descWidth = Math.max(MIN_DESC_WIDTH, width - NAME_COL_WIDTH);
     const continuationIndent = ' '.repeat(NAME_COL_WIDTH);
     const row = (name, desc) => `  ${chalk.bold(truncateToWidth(name, NAME_COL_PAD).padEnd(NAME_COL_PAD))} ${paint('dim', truncateToWidth(desc, descWidth))}`;
     emit('');
     emit(panelHeading('Commands', 'type / to search'));
-    for (const group of HELP_GROUPS) {
+    if (lane === 'chat')
+        emit(paint('dim', 'Just talk to me. Use /abap-… when you want a specific guided workflow.'));
+    for (const group of helpGroupsFor(lane)) {
         emit('');
         emit(groupTitle(group.title));
         for (const r of group.rows) {

package/dist/config/loader.js

@@ -4,6 +4,8 @@ import toml from '@iarna/toml';
 import { configFile, cspeachRoot } from './paths.js';
 import { DEFAULT_SESSION_MODEL } from './model-defaults.js';
 import { sanitiseStandaloneProfile } from '../sap/standalone-profile.js';
+import { DEFAULT_STYLE, parseStyle } from '../agent/style.js';
+import { DEFAULT_LEVEL, parseLevel } from '../agent/level.js';
 /**
  * Whitelist guard for WriteMode — rejects typos / stale values from disk so
  * downstream code that trusts the WriteMode type doesn't see garbage.
@@ -36,6 +38,12 @@ export const DEFAULT_CONFIG = {
     // the default; 'legacy' reproduces the pre-overhaul output exactly.
     // `background` is left unset: getBackground() then reads COLORFGBG, else dark.
     ui: { rendering: 'auto', look: 'panels' },
+    // 2026-10-17 — chat lane (spec docs/superpowers/specs/2026-10-17-chat-lane-and-style-design.md
+    // D2/D9). 'skills' is today's router — the default for the first release
+    // (staged rollout, owner 2026-10-17; users opt in with /chat on, a later
+    // release flips this); 'professional' sends no style; 'developer' sends no
+    // level (§10 D13).
+    assistant: { lane: 'skills', style: DEFAULT_STYLE, level: DEFAULT_LEVEL },
     // Default `approval-gated` — preserves current UX (user approves each write).
     write_mode: 'approval-gated',
     // Default `managed` — lowest-friction entry point; uses the cspeach.dev proxy.
@@ -186,6 +194,14 @@ export async function loadConfig() {
             // when it's strictly true — a string/typo collapses to "absent" so it
             // can't win the `local_build ?? local_files` fallback.
             local_files: parsed.local_files === true ? true : undefined,
+            // word_copy: same absent-preserving coercion as local_build. Absent →
+            // undefined ("ask"); a typo collapses to false ("never ask"), so a typo
+            // can never write files nobody asked for.
+            word_copy: parsed.word_copy === true
+                ? true
+                : parsed.word_copy === undefined
+                    ? undefined
+                    : false,
             // render_smoke: plain boolean, DEFAULT true (no legacy alias). Preserve
             // only a genuine boolean; a typo/wrong-type collapses to undefined which
             // resolveRenderSmoke reads as the default ON (fail-safe: a config typo can
@@ -268,6 +284,9 @@ export async function loadConfig() {
             llm: { ...DEFAULT_CONFIG.llm, ...(parsed.llm ?? {}) },
             classifier: { ...DEFAULT_CONFIG.classifier, ...(parsed.classifier ?? {}) },
             ui: { ...DEFAULT_CONFIG.ui, ...(parsed.ui ?? {}) },
+            assistant: { ...DEFAULT_CONFIG.assistant, ...(parsed.assistant ?? {}) },
+            // INTERNAL — the sub-keys the file's [assistant] table carried (see the type).
+            assistant_file_keys: parsed.assistant && typeof parsed.assistant === 'object' ? Object.keys(parsed.assistant) : [],
             // Deep-merge `compact` so a user config that only overrides one
             // field (e.g. just `keep_recent_turns = 10`) still gets the four
             // unspecified defaults — and a typo'd field falls through harmlessly.
@@ -284,6 +303,11 @@ export async function loadConfig() {
         // 2026-09-26 — unknown values fall back instead of reaching the renderer.
         if (merged.ui.look !== 'panels' && merged.ui.look !== 'legacy')
             merged.ui.look = DEFAULT_CONFIG.ui.look;
+        // Chat lane (2026-10-17) — unknown values fall back, like ui.look.
+        if (merged.assistant.lane !== 'chat' && merged.assistant.lane !== 'skills')
+            merged.assistant.lane = DEFAULT_CONFIG.assistant.lane;
+        merged.assistant.style = parseStyle(merged.assistant.style) ?? DEFAULT_CONFIG.assistant.style;
+        merged.assistant.level = parseLevel(merged.assistant.level) ?? DEFAULT_CONFIG.assistant.level;
         if (merged.ui.background !== undefined && merged.ui.background !== 'dark' && merged.ui.background !== 'light') {
             delete merged.ui.background;
         }
@@ -311,6 +335,9 @@ export async function loadConfig() {
         // callers see a genuine "absent" shape (treated as OFF → credits).
         if (merged.show_cogs === undefined)
             delete merged.show_cogs;
+        // Same for `word_copy` (absent = ask each time).
+        if (merged.word_copy === undefined)
+            delete merged.word_copy;
         // Same for `plan_mode`: absent-or-invalid must not serialise as
         // `plan_mode = undefined` — drop the key so `config show` stays clean and
         // callers see a genuine "absent" shape (treated as 'step').
@@ -378,6 +405,14 @@ export async function loadConfig() {
         throw err;
     }
 }
+/** The effective Word-copy behaviour of the save hook (see `word_copy`). */
+export function resolveWordCopy(cfg) {
+    if (cfg.word_copy === true)
+        return 'always';
+    if (cfg.word_copy === false)
+        return 'never';
+    return 'ask';
+}
 /**
  * Resolve the effective "local build tools" toggle from a loaded config.
  *
@@ -432,7 +467,7 @@ export async function saveConfig(config) {
     // file-key snapshot) and must never be written back into config.toml.
     // effort_set is internal too (Task 4); the stored marker effort_explicit is kept.
     // compact_threshold_set is internal too (Task 19).
-    const { default_model_set: _dropSet, effort_set: _dropEffortSet, compact_threshold_set: _dropThresholdSet, file_keys: _dropKeys, ...toWrite } = config;
+    const { default_model_set: _dropSet, effort_set: _dropEffortSet, compact_threshold_set: _dropThresholdSet, file_keys: _dropKeys, assistant_file_keys: assistantFileKeys, ...toWrite } = config;
     // Sparse serialisation: drop any key that the file did NOT carry AND whose
     // value is deep-equal to the built-in default. Keys absent from DEFAULT_CONFIG
     // (optional keys like audit_model) never deep-equal a defined value, so any
@@ -446,6 +481,21 @@ export async function saveConfig(config) {
             delete writable[k];
         }
     }
+    // The same rule one level down for [assistant] (staged rollout, 2026-10-17):
+    // write a field only when the file carried it or it differs from the default.
+    if (writable.assistant && typeof writable.assistant === 'object') {
+        const keep = assistantFileKeys ?? [];
+        const defaults = DEFAULT_CONFIG.assistant;
+        const a = { ...writable.assistant };
+        for (const k of Object.keys(a)) {
+            if (!keep.includes(k) && a[k] === defaults[k])
+                delete a[k];
+        }
+        if (Object.keys(a).length === 0)
+            delete writable.assistant;
+        else
+            writable.assistant = a;
+    }
     await fs.writeFile(configFile(), toml.stringify(writable), 'utf-8');
 }
 /** The effective plan-run approval mode — absent/invalid ⇒ 'plan'. */