@cspeach/cli 1.1.45 → 1.1.47

package/dist/docx/markdown-to-docx.js

@@ -0,0 +1,250 @@
+// cspeach-cli/src/docx/markdown-to-docx.ts
+//
+// Markdown string + metadata → .docx Buffer. One pure function, no UI, no
+// filesystem: the save hook, the export command and (later) the transport
+// dossier all call it.
+//
+// Parser: the `marked` lexer the CLI already ships (renderer/markdown.ts uses
+// it for terminal output). A fresh `Marked` instance here so the terminal
+// extensions never leak in. Writer: the `docx` package.
+//
+// Rule: unknown Markdown degrades to plain text; this function never throws
+// for any input string. Every block is converted inside a try/catch that falls
+// back to the token's raw text.
+import { Marked } from 'marked';
+import { AlignmentType, BorderStyle, Document, ExternalHyperlink, HeadingLevel, LevelFormat, Packer, PageBreak, Paragraph, ShadingType, Table, TableCell, TableRow, TextRun, WidthType, } from 'docx';
+const CODE_FONT = 'Consolas';
+const CODE_SIZE = 18; // half-points: 9 pt
+const CODE_FILL = 'F2F2F2';
+const NUMBERED = 'cspeach-numbered';
+// Text width of the docx default page (A4, 1-inch margins) in twips. Tables get
+// explicit column widths that add up to it: with percentage widths only, docx
+// writes 100-twip grid columns and Google Docs shows one letter per line.
+const TEXT_WIDTH = 11906 - 2 * 1440;
+const MIN_COL = 720; // half an inch
+const HEADINGS = [
+    HeadingLevel.HEADING_1, HeadingLevel.HEADING_2, HeadingLevel.HEADING_3,
+    HeadingLevel.HEADING_4, HeadingLevel.HEADING_5, HeadingLevel.HEADING_6,
+];
+/** One numbered-list instance per list so each restarts at 1. */
+class Ctx {
+    numberedInstances = 0;
+}
+export async function markdownToDocx(markdown, meta) {
+    const ctx = new Ctx();
+    const body = blocksFrom(markdown, ctx);
+    const doc = new Document({
+        creator: 'CSPeach',
+        lastModifiedBy: 'CSPeach',
+        title: meta.title,
+        numbering: {
+            config: [{
+                    reference: NUMBERED,
+                    levels: [0, 1, 2].map((level) => ({
+                        level,
+                        format: LevelFormat.DECIMAL,
+                        text: `%${level + 1}.`,
+                        alignment: AlignmentType.START,
+                        style: { paragraph: { indent: { left: 720 * (level + 1), hanging: 360 } } },
+                    })),
+                }],
+        },
+        styles: {
+            default: { document: { run: { font: 'Calibri', size: 22 } } },
+        },
+        sections: [{ children: [...titlePage(meta), ...body] }],
+    });
+    return Packer.toBuffer(doc);
+}
+/** Title, date, system, object, "Prepared with CSPeach", then a page break. (Task 3 pins it.) */
+function titlePage(meta) {
+    const facts = [`Date: ${meta.date}`];
+    if (meta.system)
+        facts.push(`System: ${meta.system}`);
+    if (meta.object)
+        facts.push(`Object: ${meta.object}`);
+    return [
+        new Paragraph({ text: meta.title, heading: HeadingLevel.TITLE, spacing: { before: 2400 } }),
+        ...facts.map((f) => new Paragraph({ text: f })),
+        new Paragraph({ text: 'Prepared with CSPeach', spacing: { before: 480 } }),
+        new Paragraph({ children: [new PageBreak()] }),
+    ];
+}
+/** Lex, then convert every top-level block. Never throws. */
+export function blocksFrom(markdown, ctx = new Ctx()) {
+    let tokens;
+    try {
+        tokens = new Marked({ gfm: true }).lexer(markdown ?? '');
+    }
+    catch {
+        return [new Paragraph({ text: markdown ?? '' })];
+    }
+    const out = [];
+    for (const t of tokens)
+        out.push(...blockToDocx(t, ctx, 0));
+    return out;
+}
+function blockToDocx(t, ctx, depth, extra = {}) {
+    try {
+        switch (t.type) {
+            case 'space': return [];
+            case 'heading': {
+                const h = t;
+                return [new Paragraph({ ...extra, heading: HEADINGS[Math.min(h.depth, 6) - 1], children: inline(h.tokens) })];
+            }
+            case 'paragraph':
+            case 'text': {
+                const p = t;
+                const kids = 'tokens' in p && p.tokens ? inline(p.tokens) : [new TextRun(p.text ?? p.raw ?? '')];
+                return [new Paragraph({ ...extra, children: kids })];
+            }
+            case 'list': return list(t, ctx, depth);
+            case 'code': return code(t);
+            case 'table': return [table(t)];
+            case 'blockquote': return quote(t, ctx, depth);
+            case 'hr': return [new Paragraph({ thematicBreak: true })];
+            case 'html': return [new Paragraph({ ...extra, text: t.raw.trim() })];
+            default: return [new Paragraph({ ...extra, text: ('raw' in t ? String(t.raw) : '').trim() })];
+        }
+    }
+    catch {
+        return [new Paragraph({ text: ('raw' in t ? String(t.raw) : '').trim() })];
+    }
+}
+/** Nested lists: a bullet or numbered paragraph per item; child lists recurse one level deeper. */
+function list(l, ctx, depth) {
+    const level = Math.min(depth, 2);
+    const instance = l.ordered ? ctx.numberedInstances++ : -1;
+    const out = [];
+    for (const item of l.items) {
+        const mark = l.ordered
+            ? { numbering: { reference: NUMBERED, level, instance } }
+            : { bullet: { level } };
+        let first = true;
+        for (const child of item.tokens) {
+            if (child.type === 'list') {
+                out.push(...list(child, ctx, depth + 1));
+                continue;
+            }
+            // The first text block of an item carries the marker; later paragraphs are indented plain text.
+            out.push(...blockToDocx(child, ctx, depth, first ? mark : { indent: { left: 720 * (level + 1) } }));
+            first = false;
+        }
+        if (first)
+            out.push(new Paragraph({ ...mark, text: item.text ?? '' }));
+    }
+    return out;
+}
+function code(c) {
+    const lines = (c.text ?? '').split('\n');
+    return lines.map((line) => new Paragraph({
+        shading: { type: ShadingType.CLEAR, fill: CODE_FILL },
+        spacing: { before: 0, after: 0 },
+        children: [new TextRun({ text: line.length ? line : ' ', font: CODE_FONT, size: CODE_SIZE })],
+    }));
+}
+function table(t) {
+    const width = Math.max(1, t.header.length);
+    const pad = (cells) => {
+        const row = cells.slice(0, width);
+        while (row.length < width)
+            row.push({ text: '', tokens: [] });
+        return row;
+    };
+    const header = pad(t.header);
+    const rows = t.rows.map(pad);
+    const cols = columnWidths([header, ...rows], width);
+    const cell = (c, i, bold) => new TableCell({
+        width: { size: cols[i], type: WidthType.DXA },
+        children: [new Paragraph({ children: inline(c.tokens ?? [], bold ? { bold: true } : {}) })],
+        shading: bold ? { type: ShadingType.CLEAR, fill: 'E7E6E6' } : undefined,
+    });
+    return new Table({
+        width: { size: TEXT_WIDTH, type: WidthType.DXA },
+        columnWidths: cols,
+        rows: [
+            new TableRow({ tableHeader: true, children: header.map((c, i) => cell(c, i, true)) }),
+            ...rows.map((r) => new TableRow({ children: r.map((c, i) => cell(c, i, false)) })),
+        ],
+    });
+}
+/** Split the page width by each column's longest text (capped), never below MIN_COL. */
+function columnWidths(rows, n) {
+    const weight = Array.from({ length: n }, (_, i) => Math.min(60, Math.max(3, ...rows.map((r) => (r[i]?.text ?? '').length))));
+    const total = weight.reduce((a, b) => a + b, 0);
+    const spare = Math.max(0, TEXT_WIDTH - MIN_COL * n);
+    const cols = weight.map((w) => MIN_COL + Math.floor((spare * w) / total));
+    cols[n - 1] += TEXT_WIDTH - cols.reduce((a, b) => a + b, 0);
+    return cols;
+}
+function quote(q, ctx, depth) {
+    const extra = {
+        indent: { left: 720 },
+        border: { left: { style: BorderStyle.SINGLE, size: 12, color: 'BFBFBF', space: 8 } },
+    };
+    const out = [];
+    for (const child of q.tokens)
+        out.push(...blockToDocx(child, ctx, depth, extra));
+    return out;
+}
+/** Inline tokens → runs. Unknown inline → its raw text. */
+function inline(tokens, style = {}) {
+    const out = [];
+    for (const t of tokens ?? []) {
+        try {
+            switch (t.type) {
+                case 'text':
+                case 'escape':
+                    out.push(run(t.text, style));
+                    break;
+                case 'strong':
+                    out.push(...inline(t.tokens, { ...style, bold: true }));
+                    break;
+                case 'em':
+                    out.push(...inline(t.tokens, { ...style, italics: true }));
+                    break;
+                case 'del':
+                    out.push(...inline(t.tokens, { ...style, strike: true }));
+                    break;
+                case 'codespan':
+                    out.push(run(t.text, { ...style, code: true }));
+                    break;
+                case 'br':
+                    out.push(new TextRun({ break: 1 }));
+                    break;
+                case 'link': {
+                    const l = t;
+                    out.push(new ExternalHyperlink({
+                        link: l.href,
+                        children: [new TextRun({ text: unescapeHtml(textOf(l.tokens) || l.href), style: 'Hyperlink' })],
+                    }));
+                    break;
+                }
+                case 'image':
+                    out.push(run(t.text || t.href, style));
+                    break;
+                default: out.push(run('raw' in t ? String(t.raw) : '', style));
+            }
+        }
+        catch {
+            out.push(run('raw' in t ? String(t.raw) : '', style));
+        }
+    }
+    return out;
+}
+// marked's lexer HTML-escapes text and inline code; docx escapes again on write,
+// so without this the reader sees "&gt;" instead of ">".
+const ENTITIES = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&#39;': "'" };
+function unescapeHtml(text) {
+    return text.replace(/&(?:amp|lt|gt|quot|#39);/g, (m) => ENTITIES[m]);
+}
+function run(text, s) {
+    return new TextRun({
+        text: unescapeHtml(text ?? ''),
+        bold: s.bold, italics: s.italics, strike: s.strike,
+        ...(s.code ? { font: CODE_FONT, size: CODE_SIZE } : {}),
+    });
+}
+function textOf(tokens) {
+    return (tokens ?? []).map((t) => ('text' in t ? String(t.text) : ('raw' in t ? String(t.raw) : ''))).join('');
+}

package/dist/docx/write-docx.js

@@ -0,0 +1,54 @@
+// cspeach-cli/src/docx/write-docx.ts
+//
+// The Word copy goes next to its Markdown source with the same base name.
+// Never overwrites (repo convention: projects/save.ts, projects/sort-command.ts):
+// `wx` flag, then -2, -3 … when the name is taken. A file held open by Word
+// or a synced folder (EPERM / EBUSY) is reported once in plain words, never
+// retried in a loop.
+import fs from 'node:fs';
+import path from 'node:path';
+import { markdownToDocx } from './markdown-to-docx.js';
+const MAX_SUFFIX = 999;
+export function docxPathFor(mdPath) {
+    const parsed = path.parse(mdPath);
+    const base = parsed.ext.toLowerCase() === '.md' ? parsed.name : parsed.base;
+    return path.join(parsed.dir, `${base}.docx`);
+}
+/** The first of `p`, `<stem>-2<ext>`, `-3` … that does not exist. */
+export async function uniquePath(p) {
+    const { dir, name, ext } = path.parse(p);
+    let candidate = p;
+    for (let n = 2; n <= MAX_SUFFIX; n++) {
+        if (!fs.existsSync(candidate))
+            return candidate;
+        candidate = path.join(dir, `${name}-${n}${ext}`);
+    }
+    if (!fs.existsSync(candidate))
+        return candidate;
+    throw new Error(`Too many copies of ${path.basename(p)} in ${dir} (${MAX_SUFFIX}). Delete some and try again.`);
+}
+/** Write `data` to `target`, or to the next free -N name if a race took it. */
+export async function writeNoClobber(target, data) {
+    for (let attempt = 0; attempt < 5; attempt++) {
+        const p = await uniquePath(target);
+        try {
+            await fs.promises.writeFile(p, data, { flag: 'wx' });
+            return p;
+        }
+        catch (e) {
+            const code = e.code;
+            if (code === 'EEXIST')
+                continue;
+            if (code === 'EPERM' || code === 'EBUSY' || code === 'EACCES') {
+                throw new Error(`Could not write ${p}: it is open in another program or the folder is read-only. Close it and try again.`);
+            }
+            throw e;
+        }
+    }
+    throw new Error(`Could not find a free name for ${path.basename(target)}.`);
+}
+export async function writeDocxNextTo(mdPath, markdown, meta) {
+    const buf = await markdownToDocx(markdown, meta);
+    await fs.promises.mkdir(path.dirname(mdPath), { recursive: true });
+    return writeNoClobber(docxPathFor(mdPath), buf);
+}

package/dist/one-shot.js

@@ -26,6 +26,8 @@ import { startThinkingHeartbeat, ROUTING_HEARTBEAT_THRESHOLDS } from './renderer
 import { setRenderingOverride, setHeadlessOverride, setOneShotOverride } from './renderer/tty.js';
 import { resolveRenderingMode } from './renderer/rendering-mode.js';
 import { setLook, setBackground } from './renderer/look.js';
+import { setAssistantStyle } from './agent/style-state.js';
+import { setAssistantLevel } from './agent/level-state.js';
 import { alwaysDeclinePreviewHook } from './repl/update-method-preview-hook.js';
 import { createClassicOutputEmitter } from './renderer/notices.js';
 import { AnswerTrim } from './renderer/answer-trim.js';
@@ -49,6 +51,7 @@ import './tools/approval.js';
 import './tools/snapshot.js';
 import './tools/ask-question.js';
 import './tools/dispatch-skill.js';
+import './tools/hand-off.js';
 import './tools/todo.js';
 import './tools/filesystem/file-read.js';
 import './tools/tool-output-read.js';
@@ -100,6 +103,13 @@ export async function runOneShot(prompt, opts) {
     setOneShotOverride(true);
     setRenderingOverride(resolveRenderingMode(cfg.ui.rendering).mode);
     setLook(cfg.ui.look);
+    // Chat lane D-D/D9 — the talking style rides on one-shot workflow turns too
+    // (professional = no header, so the default request is unchanged). The
+    // chat lane itself never runs here: one-shot keeps today's routing.
+    // Read defensively: a config without an `assistant` table (older test
+    // doubles, a hand-built cfg) means the defaults.
+    setAssistantStyle(cfg.assistant?.style ?? 'professional');
+    setAssistantLevel(cfg.assistant?.level ?? 'developer'); // §10 D14 — same rule as the style
     setBackground(cfg.ui.background);
     // model-governance step 2d — fetch the served model-config (managed mode
     // only). Task 3: awaited, but startup waits at most 1.5 s (then a fresh disk

package/dist/projects/document-save.js

@@ -0,0 +1,62 @@
+// cspeach-cli/src/projects/document-save.ts
+//
+// The save for the two document skills (2026-10-19, owner decision 2026-10-17).
+// A review or a handover is prose, not an envelope: it goes to
+// <cwd>/cspeach-out/<date>-<kind>-<OBJECT>.md (the folder the model already
+// writes extra copies to; skipped by the @-picker; exempt from the Rule 8
+// card). Then one question, "Word copy too?", unless `word_copy` decides.
+// Never overwrites. Never throws: a failure is one line through `emit`.
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { askYesNo, isYes } from './yes-no.js';
+import { metaFromMarkdown } from '../docx/doc-meta.js';
+import { writeDocxNextTo, writeNoClobber } from '../docx/write-docx.js';
+import { safeFileStem } from '../register/xlsx.js';
+import { DOCUMENT_SKILLS } from './document-skills.js';
+export { DOCUMENT_SKILLS };
+export const OUT_DIR = 'cspeach-out';
+export function documentFilename(kind, object, date) {
+    const stem = safeFileStem((object ?? 'document').replace(/\//g, ''));
+    return `${date}-${kind}-${stem}.md`;
+}
+export async function offerDocumentSave(p) {
+    const skill = DOCUMENT_SKILLS[p.skill];
+    if (!skill || p.markdown.trim().length === 0)
+        return {};
+    const meta = metaFromMarkdown(p.markdown, { date: p.today, kind: skill.kind, ...(p.sapSystem ? { system: p.sapSystem } : {}) });
+    if (!p.headless) {
+        const a = await askYesNo({ question: `Save this ${skill.noun} to a file?`, confirm: p.confirm });
+        if (!isYes(a))
+            return {};
+    }
+    else {
+        p.emit(chalk.dim(`headless: saving the ${skill.noun} without asking`));
+    }
+    let mdPath;
+    try {
+        const target = path.join(p.cwd, OUT_DIR, documentFilename(skill.kind, meta.object, p.today));
+        await fs.promises.mkdir(path.dirname(target), { recursive: true });
+        mdPath = await writeNoClobber(target, p.markdown);
+    }
+    catch (e) {
+        p.emit(`Not saved. ${e.message}`);
+        return {};
+    }
+    p.emit(`Saved: ${path.resolve(mdPath)}`);
+    let wantWord = p.wordCopy === 'always';
+    if (p.wordCopy === 'ask' && !p.headless) {
+        wantWord = isYes(await askYesNo({ question: 'Word copy too?', confirm: p.confirm }));
+    }
+    if (!wantWord)
+        return { mdPath };
+    try {
+        const docxPath = await writeDocxNextTo(mdPath, p.markdown, meta);
+        p.emit(`Word copy: ${path.resolve(docxPath)}`);
+        return { mdPath, docxPath };
+    }
+    catch (e) {
+        p.emit(`Word copy not written. ${e.message}`);
+        return { mdPath };
+    }
+}

package/dist/projects/document-skills.js

@@ -0,0 +1,9 @@
+// cspeach-cli/src/projects/document-skills.ts
+//
+// The two document skills, on their own so the agent loop can check a skill
+// name without loading document-save.ts (and the docx package behind it) on
+// every turn. Type-only import: nothing heavy loads from here.
+export const DOCUMENT_SKILLS = {
+    'abap-review': { kind: 'review', noun: 'review' },
+    'abap-handover': { kind: 'handover', noun: 'handover' },
+};

package/dist/renderer/footer-line.js

@@ -38,13 +38,14 @@ export function footerStateFrom(s) {
         user: s.user || undefined,
         transport: (s.transport ?? s.lastWriteTransport ?? s.confirmedTransport) || undefined,
         standalone: s.standalone === true,
+        chat: s.chatLane === true,
         mode: s.writeMode ?? '',
         spend: formatSpendSegment(s),
     };
 }
 const MODE_ROLE = { 'advisory-only': 'warn', 'approval-gated': 'ok', auto: 'sap' };
 /**
- * `<SYS> · <USER> · transport <TR> · <mode> · <spend>` on the left and a dim
+ * `<SYS> · <USER> · [chat ·] transport <TR> · <mode> · <spend>` on the left and a dim
  * `? shortcuts` on the right, padded to exactly `width`. When it does not fit,
  * the hint drops first, then the left side truncates.
  */
@@ -52,6 +53,8 @@ export function formatFooterLine(s, width) {
     const parts = [];
     if (s.standalone) {
         parts.push({ text: 'standalone', role: 'sap' }, { text: 'local files', role: 'dim' });
+        if (s.chat)
+            parts.push({ text: 'chat', role: 'sap' });
     }
     else {
         // System, user and transport come from config / SAP responses (the
@@ -60,6 +63,8 @@ export function formatFooterLine(s, width) {
         parts.push(s.system ? { text: sanitizeControlChars(s.system), role: 'sap' } : { text: 'no system', role: 'dim' });
         if (s.user)
             parts.push({ text: sanitizeControlChars(s.user), role: 'dim' });
+        if (s.chat)
+            parts.push({ text: 'chat', role: 'sap' });
         parts.push({ text: s.transport ? `transport ${sanitizeControlChars(s.transport)}` : 'no transport', role: 'dim' });
     }
     if (s.mode)

package/dist/renderer/goodbye.js

@@ -10,6 +10,7 @@ import { panelRow } from './panel-rows.js';
 import { paint } from './theme.js';
 import { formatInfo } from './notice-shape.js';
 import { sanitizeControlChars } from './sanitize.js';
+import { creditsActive } from '../cost/credits.js';
 const LABEL = 10; // 'Last skill'
 /**
  * `logDir` — the display path of this session's turn-stream folder, passed
@@ -25,7 +26,9 @@ export function formatGoodbye(p) {
         chalk.bold(`Session ${id}`),
         panelRow('Turns', String(p.turns), LABEL),
         panelRow('Last skill', skill, LABEL),
-        panelRow('Tokens', `${p.tokens.toLocaleString('en-US')}  (input + output + cache)`, LABEL),
+        // Credits mode: no token count beside credits (owner 2026-10-02 for /cost
+        // and the footer; 2026-10-19 here) — it invites "credits per token" maths.
+        ...(creditsActive() ? [] : [panelRow('Tokens', `${p.tokens.toLocaleString('en-US')}  (input + output + cache)`, LABEL)]),
         panelRow('Spend', p.spend, LABEL),
         '',
         // Round 6 review I1 — a session never written (no turns) has nothing to resume.

package/dist/renderer/startup-lines.js

@@ -109,6 +109,8 @@ export function aliasSourceNote(source, alias) {
 }
 export function panelsStatusLine(p) {
     const segs = [p.standalone ? paint('dim', 'standalone (no SAP system)') : paint('sap', p.system)];
+    if (p.chat)
+        segs.push(paint('sap', 'chat'));
     if (p.tools === 'files+commands')
         segs.push(paint('warn', 'local files + commands on'));
     else if (p.tools === 'files')
@@ -120,10 +122,12 @@ export function panelsStatusLine(p) {
     return '   ' + segs.join(paint('dim', ' · '));
 }
 /** Line 3 of the panels start screen (non-resume). */
-export function panelsHintLine(tools) {
+export function panelsHintLine(tools, lane = 'skills') {
     const text = tools === 'files+commands'
         ? 'turn off commands: cspeach config set local_build off · ? for shortcuts'
-        : '? for shortcuts · /help for commands';
+        : lane === 'chat'
+            ? 'Just talk to me · use /abap-… when you want a specific guided workflow · /help for commands'
+            : '? for shortcuts · /help for commands';
     return '   ' + paint('dim', text);
 }
 /** Line 3 of the panels start screen on --resume: the recap's "last session" fact.

package/dist/renderer/tool-labels.js

@@ -199,6 +199,7 @@ const RULES = {
     ask_question: (a) => ({ verb: 'Question', object: shortRight(str(a['question']) ?? '') }),
     todo_set: () => ({ verb: 'Updated todos', object: '' }),
     dispatch_skill: (a) => ({ verb: 'Ran skill', object: shortRight(str(a['command']) ?? '') }),
+    hand_off: (a) => ({ verb: 'Handed off', object: shortRight(`/${(str(a['skill']) ?? '').replace(/^\//, '')}`) }),
     read_document: (a, r) => ({ verb: 'Read document', object: shortLeft(str(a['path']) ?? ''), ...(r !== undefined ? { detail: `${lineCount(r)} lines` } : {}) }),
     web_fetch: (a) => ({ verb: 'Fetched', object: shortRight(str(a['url']) ?? '') }),
     web_search: (a) => ({ verb: 'Searched web', object: shortRight(`"${str(a['query']) ?? ''}"`) }),
@@ -276,7 +277,7 @@ const PRESENT = {
     'Created data element': 'Creating data element', 'Read BAdI': 'Reading BAdI', 'Read enhancement options': 'Reading enhancement options of', 'Created BAdI implementation': 'Creating BAdI implementation', 'Created table type': 'Creating table type', 'Read table type': 'Reading table type', 'Read transport request': 'Reading transport request', 'Listed function group': 'Listing function group', Locked: 'Locking', Unlocked: 'Unlocking',
     Published: 'Publishing', Unpublished: 'Unpublishing', Messages: 'Maintaining messages in',
     'Number range': 'Maintaining number range', Question: 'Asking', 'Updated todos': 'Updating todos',
-    'Ran skill': 'Running skill', 'Read document': 'Reading document', Fetched: 'Fetching',
+    'Ran skill': 'Running skill', 'Handed off': 'Handing off', 'Read document': 'Reading document', Fetched: 'Fetching',
     'Searched web': 'Searching web', 'Read project context': 'Reading project context',
     'Read playbook': 'Reading playbook', 'Read convention': 'Reading convention', 'Merged CCA': 'Merging CCA',
     'Merged progress': 'Merging progress', 'Checked background': 'Checking background',

package/dist/renderer/tool-widget.js

@@ -48,8 +48,12 @@ const peach = (s) => chalk.hex(PEACH)(s);
  *     block is the representation, so the raw `⏺ todo_set({"todos":[…])`
  *     line + ⎿ JSON result are suppressed. Owner feedback drove this: the
  *     transcript should show the full checklist, not a JSON tool line.
+ *   - hand_off: the chat lane queues the workflow with one dim `→ /abap-x`
+ *     line (queued-step origin, both REPLs) — that line is the
+ *     representation, so a "Handed off /abap-x" row would only double it.
+ *     A refused hand_off still shows its ✗ row.
  */
-const WIDGET_SUPPRESSED_TOOLS = new Set(['ask_question', 'todo_set']);
+const WIDGET_SUPPRESSED_TOOLS = new Set(['ask_question', 'todo_set', 'hand_off']);
 export function isWidgetSuppressedTool(name) {
     return WIDGET_SUPPRESSED_TOOLS.has(name);
 }

package/dist/repl/builtin-commands.js

@@ -33,7 +33,7 @@ export const BUILTIN_ENTRIES = [
     { name: '/cost', get description() { return costCommandDescription(); } },
     { name: '/usage', get description() { return usageCommandDescription(); } },
     { name: '/compact', description: 'Shrink a long session and keep the facts (later turns cost far less)' },
-    { name: '/export', description: 'Export the signable session audit record — /export audit [filename]' },
+    { name: '/export', description: 'Export the session audit record (/export audit [filename]) or a Word copy of a saved file (/export docx <file>.md)' },
     { name: '/context', description: 'Show what fills the model context window — a composition grid of bars' },
     { name: '/exit', description: 'Exit CSPeach' },
     { name: '/quit', description: 'Exit CSPeach (alias)' },
@@ -41,10 +41,13 @@ export const BUILTIN_ENTRIES = [
     { name: '/skills', description: 'Show all skills (alias)' },
     { name: '/mode', description: 'Cycle or set the session write mode (advisory / gated / auto) — config unchanged' },
     { name: '/new', description: 'Reset routing — next prompt is classified afresh' },
+    { name: '/chat', description: 'Chat mode — /chat on · /chat off · /chat to leave a workflow' },
     { name: '/recap', description: 'Show the session recap (last session · open tasks · plan progress)' },
     { name: '/reset', description: 'Reset routing (alias)' },
     { name: '/rewind', description: 'Undo a write from this session — restore an object to a pre-write snapshot (Esc Esc)' },
     { name: '/ui', description: 'View or change rendering mode (auto / ink), or the look: /ui look panels|legacy' },
+    { name: '/style', description: 'View or change the talking style: professional (default), conversational, humor or blunt' },
+    { name: '/level', description: 'Who CSPeach is talking to: developer (default), learning or functional' },
     { name: '/reroute', description: 'Re-dispatch the previous prompt to a different skill' },
     { name: '/transport', description: 'View or set the active transport for this session' },
     { name: '/rules', description: 'View or change the decision rules of the joined team project (the lead changes them)' },

package/dist/repl/chat-command.js

@@ -0,0 +1,64 @@
+import { applyLaneTools } from './chat-lane.js';
+import { clearAppFlow } from '../lane/app-flow.js';
+import { clearJourneyFlow } from '../journey/flow.js';
+import { formatFailure, formatInfo } from '../renderer/notice-shape.js';
+import { markExplicit } from '../commands/config-set.js';
+export const CHAT_BACK_LINE = 'Back in chat · just talk, or /abap-… for a guided workflow · /chat off for skill routing';
+export const CHAT_ON_LINE = 'Chat is on · just talk, or /abap-… for a guided workflow';
+export const CHAT_ON_PIPED_LINE = 'Chat is on · it applies in an interactive terminal';
+export const CHAT_OFF_LINE = 'Skill routing is on · every message picks a skill again · /chat on switches back';
+export const CHAT_SKILLS_LANE_LINE = 'Skill routing is on · /chat on switches to chat';
+export const CHAT_USAGE_LINE = 'Use /chat, /chat on or /chat off';
+/** Leave the active workflow: the next message goes to chat (D6). */
+function leaveWorkflow(session) {
+    session.skill = null;
+    session.awaitingSkillAnswer = false;
+    clearAppFlow(session);
+    clearJourneyFlow(session);
+}
+/** Returns the lane in force after the command. */
+export async function handleChatCommand(arg, d) {
+    const a = arg.trim().toLowerCase();
+    const say = (s) => d.emit(formatInfo(s).trimEnd());
+    if (a === '') {
+        if (d.lane === 'chat') {
+            leaveWorkflow(d.session);
+            say(CHAT_BACK_LINE);
+        }
+        else
+            say(CHAT_SKILLS_LANE_LINE);
+        return d.lane;
+    }
+    if (a !== 'on' && a !== 'off') {
+        say(CHAT_USAGE_LINE);
+        return d.lane;
+    }
+    const next = a === 'on' ? 'chat' : 'skills';
+    // Already on with a workflow running: same as bare /chat — back in chat.
+    const hadWorkflow = !!d.session.skill;
+    if (next === 'chat')
+        leaveWorkflow(d.session);
+    else if (next !== d.lane)
+        d.session.awaitingSkillAnswer = false; // review E — a chat turn's question never carries into routing
+    if (next === 'chat' && d.lane === 'chat' && hadWorkflow) {
+        say(CHAT_BACK_LINE);
+        return next;
+    }
+    if (next !== d.lane) {
+        d.cfg.assistant.lane = next;
+        // Spec D2: an explicit switch is saved explicitly, even when it equals
+        // today's default, so a later release's default flip never overrides it.
+        markExplicit(d.cfg, 'assistant.lane');
+        // In static tool mode the session's tools array grows once here (hand_off);
+        // /chat off never removes it — hand_off is refused outside the chat lane.
+        applyLaneTools(next, d.interactive);
+        try {
+            await d.save(d.cfg);
+        }
+        catch (err) {
+            d.emit(formatFailure({ what: `Failed to save config: ${err.message} (applied for this session only)` }).trimEnd());
+        }
+    }
+    say(next === 'chat' ? (d.interactive ? CHAT_ON_LINE : CHAT_ON_PIPED_LINE) : CHAT_OFF_LINE);
+    return next;
+}