@cspeach/cli 1.0.0 → 1.1.0

package/dist/agent/loop.js

@@ -5,9 +5,10 @@ import { listTools, getTool, toAnthropicTools } from '../tools/index.js';
 import { saveSession } from '../session/store.js';
 import { recordCompletedToolCall } from '../session/pending.js';
 import { loadConfig } from '../config/loader.js';
+import { resolveModelRole } from '../models/resolve.js';
 import { retryWithBackoff } from './retry.js';
 import { renderChunk, initialBufferState, render } from '../renderer/pipeline.js';
-import { renderToolCallTop, renderToolCallBottom, startToolSpinner, startThinkingSpinner } from '../renderer/tool-widget.js';
+import { renderToolCallTop, renderToolCallBottom, startToolSpinner, startThinkingSpinner, isWidgetSuppressedTool } from '../renderer/tool-widget.js';
 import { formatToolErrorSummary } from '../sap-errors/parse-adt-exception.js';
 import { startThinkingHeartbeat } from '../renderer/thinking-heartbeat.js';
 // 2026-06-07 — status-row narration. Safe to import in every mode: the
@@ -520,8 +521,10 @@ export async function runTurn(params) {
                 healSessionMessagesInPlace(session.messages);
                 const streamParams = {
                     // A4 — per-turn override (plan model tiering) wins over the
-                    // configured default; absent on every non-plan turn.
-                    model: params.modelOverride ?? cfg.default_model,
+                    // configured default; absent on every non-plan turn. model-governance
+                    // step 2d — the session-default model now resolves env > local >
+                    // server > built-in (byte-identical to cfg.default_model when nothing set).
+                    model: params.modelOverride ?? resolveModelRole('session_default', cfg),
                     // v0.3.1 — was 8192. Bumped because code-gen skills (abap-generate
                     // etc.) kept running out of budget mid-turn: adaptive thinking +
                     // multiple tool-result prompts + TL;DR mandate + summary prose
@@ -764,7 +767,8 @@ export async function runTurn(params) {
         // never let a save error crash the turn.
         if (params.onPlanManifest) {
             const turnText = collectTurnAssistantText(session.messages, turnStartMessageCount);
-            const blocks = turnText.match(/<!--\s*csforge:plan-manifest\s*\n[\s\S]*?\n\s*-->/g);
+            // E2 dual-read: accept both the legacy `csforge:` and current `cspeach:` prefixes.
+            const blocks = turnText.match(/<!--\s*(?:csforge|cspeach):plan-manifest\s*\n[\s\S]*?\n\s*-->/g);
             const latest = blocks ? blocks[blocks.length - 1] : null;
             if (latest && latest !== lastFiredManifest) {
                 lastFiredManifest = latest;
@@ -872,7 +876,7 @@ export async function runTurn(params) {
                     // A4 — record the actual turn model if an override ran the stream
                     // (unreachable today: plan-resume turns suppress this hook, and
                     // they are the only modelOverride caller — kept honest anyway).
-                    model: params.modelOverride ?? cfg.default_model ?? session.model ?? 'unknown',
+                    model: params.modelOverride ?? resolveModelRole('session_default', cfg) ?? session.model ?? 'unknown',
                     emit,
                     promotedFrom: promotedFromForSave,
                 });
@@ -885,14 +889,17 @@ export async function runTurn(params) {
             // throttle live in config.compact — see config/loader.ts:CompactConfig.
             try {
                 const { maybeAutoCompact } = await import('../commands/auto-compact.js');
-                const { buildSummarisationPrompt, serialiseForSummariser, COMPACTION_MODEL } = await import('../commands/compact.js');
+                const { buildSummarisationPrompt, serialiseForSummariser } = await import('../commands/compact.js');
                 const { summariseViaProvider } = await import('./summarise-via-provider.js');
                 await maybeAutoCompact({
                     session,
                     config: cfg.compact,
                     turnNumber,
                     emit,
-                    summarise: async (toSummarise) => summariseViaProvider(params.provider, buildSummarisationPrompt(), serialiseForSummariser(toSummarise), { model: COMPACTION_MODEL, maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact' } }),
+                    summarise: async (toSummarise) => summariseViaProvider(params.provider, buildSummarisationPrompt(), serialiseForSummariser(toSummarise), 
+                    // model-governance step 2d — compact model resolves env > local >
+                    // server > built-in (== COMPACTION_MODEL when nothing set).
+                    { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact' } }),
                 });
             }
             catch (err) {
@@ -943,6 +950,8 @@ export async function runTurn(params) {
         for (const block of currentAssistantContent) {
             if (block.type === 'tool_use') {
                 // Phase 1: print the dispatch line (CC-style: ⏺ name(args)).
+                // No-op for widget-suppressed tools (ask_question) — the form/modal
+                // is the visible representation; see tool-widget.ts.
                 renderToolCallTop({
                     name: block.name,
                     args: (block.input ?? {}),
@@ -951,8 +960,12 @@ export async function runTurn(params) {
                 // Phase 2a: start the peach-themed spinner. No-op outside TTY / Ink
                 // / CI — the result line still prints, just without the in-place
                 // animation. Spinner is purely a "still working" cue, not
-                // load-bearing for output.
-                const spinner = startToolSpinner({ chunkEmitter: params.chunkEmitter });
+                // load-bearing for output. Skipped entirely for widget-suppressed
+                // tools (ask_question): with the ⏺ line gone the spinner would
+                // orphan on its own row above the form.
+                const spinner = isWidgetSuppressedTool(block.name)
+                    ? { stop: () => undefined }
+                    : startToolSpinner({ chunkEmitter: params.chunkEmitter });
                 // 2026-06-06 (turn-liveness, B5 smoke feedback) — the in-place tool
                 // spinner self-disables under Ink (phantom cursor #25), which left
                 // slow tool calls (SAP over VPN: 10-60s) as DEAD AIR between the ⏺

package/dist/approvals/op-labels.js

@@ -0,0 +1,124 @@
+/**
+ * Human-readable operation + object labels for the approval surfaces.
+ *
+ * Replaces the cryptic op-code glyph (`A`/`M`/`D`/`>`/`^`) the live review
+ * found dishonest and information-poor. Every approval box, plan gate, and
+ * classic prompt now speaks a verb ("Create table ZMNT_NOTE") instead of a
+ * one-letter code where a word belongs.
+ */
+const VERBS = {
+    create: 'Create',
+    modify: 'Change',
+    delete: 'Delete',
+    activate: 'Activate',
+    release: 'Release',
+};
+/**
+ * SAP ADT type codes → plain words. The `type` field is free text supplied by
+ * the model, so an unknown/decorated value (e.g. "testclasses include") falls
+ * through unchanged rather than being mangled.
+ */
+const TYPE_WORDS = {
+    TABL: 'table',
+    CLAS: 'class',
+    INTF: 'interface',
+    PROG: 'program',
+    FUGR: 'function group',
+    DDLS: 'CDS view',
+    DDLX: 'metadata extension',
+    DCLS: 'access control',
+    BDEF: 'behavior definition',
+    SRVD: 'service definition',
+    SRVB: 'service binding',
+    DTEL: 'data element',
+    DOMA: 'domain',
+    STRU: 'structure',
+    TTYP: 'table type',
+    MSAG: 'message class',
+    DEVC: 'package',
+    ENHO: 'enhancement',
+    XSLT: 'transformation',
+    SHLP: 'search help',
+};
+export function humanVerb(op) {
+    return VERBS[op] ?? op.charAt(0).toUpperCase() + op.slice(1);
+}
+export function humanType(type) {
+    if (!type)
+        return '';
+    const key = type.trim().toUpperCase();
+    if (TYPE_WORDS[key])
+        return TYPE_WORDS[key];
+    // Already a word (has a lowercase letter or a space)? use it verbatim.
+    if (/[a-z ]/.test(type))
+        return type;
+    return type.toLowerCase();
+}
+/** e.g. "Create table ZMNT_NOTE", "Change class ZCL_X", "Delete table ZOLD". */
+export function verbLine(change) {
+    return [humanVerb(change.op), humanType(change.type), change.object]
+        .filter(Boolean)
+        .join(' ');
+}
+/**
+ * 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
+ * review):
+ *   - create-family (sap_create_object / set_class_include / create_domain /
+ *     create_data_element): `args.transport ?? session current` — so the
+ *     session fallback is honest to show.
+ *   - modify/delete (sap_set_source / sap_update_method / sap_delete_object):
+ *     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.
+ * When nothing is resolvable, return undefined and the caller OMITS the
+ * segment — no "new (session)" promise (a $TMP write never creates one).
+ */
+export function displayTransport(op, explicit, session) {
+    switch (op) {
+        case 'create':
+            return explicit ?? session ?? undefined;
+        case 'modify':
+        case 'delete':
+            return explicit;
+        default: // activate / release
+            return undefined;
+    }
+}
+/**
+ * A create/delete "diff" is really a source dump (all-adds, or plain source).
+ * Strip unified-diff scaffolding (hunk + file headers) and the leading +/-
+ * marker so View source shows clean source — no +/- colouring that would
+ * imply a before/after that does not exist for a create. Shared by the Ink
+ * modal's [v] view and the classic prompt's View source branch.
+ */
+export function toSourceLines(content) {
+    return content
+        .split('\n')
+        .filter((l) => !l.startsWith('@@') && !l.startsWith('+++') && !l.startsWith('---'))
+        .map((l) => l.replace(/^[+-] ?/, ''));
+}
+/**
+ * The review key that MATCHES the operation — honesty over a blanket "Show
+ * diff":
+ *   - 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)
+ */
+export function viewAffordance(change) {
+    switch (change.op) {
+        case 'modify':
+            // Existing behaviour: [d] always offered; the renderer warns when the
+            // model supplied a description rather than a real unified diff.
+            return { key: 'd', label: 'Show diff' };
+        case 'create':
+            return change.diff ? { key: 'v', label: 'View source' } : null;
+        case 'delete':
+            return change.diff ? { key: 'v', label: 'View current source' } : null;
+        default:
+            return null;
+    }
+}

package/dist/approvals/render.js

@@ -1,5 +1,6 @@
 import { select, input } from '@inquirer/prompts';
 import chalk from 'chalk';
+import { verbLine, viewAffordance, toSourceLines } from './op-labels.js';
 import { shouldUseInk } from '../renderer/tty.js';
 import { approvalEmitter } from '../ui/approval-emitter.js';
 import { askQuestionEmitter } from '../ui/ask-question-emitter.js';
@@ -7,26 +8,6 @@ import { withInquirer } from '../repl/inquirer-guard.js';
 import { inquirerTheme } from '../repl/inquirer-theme.js';
 import { PEACH } from '../renderer/banners.js';
 const peach = (s) => chalk.hex(PEACH)(s);
-/**
- * Op-row glyph. 2026-05-01: dropped the per-op color spread (yellow M,
- * green A, blue >, magenta ^). Using 5 different hues for routine plan
- * rows trains the user to ignore color as semantic signal — by the time
- * an actual delete shows up, red has already appeared on three other
- * lines and lost its punch. Now: only `D` (delete) gets red, because
- * delete is the only op that's destructive enough to deserve a hot
- * accent. Everything else renders dim — the row layout already tells
- * the user it's a change row.
- */
-function opIcon(op) {
-    switch (op) {
-        case 'create': return chalk.dim('A');
-        case 'modify': return chalk.dim('M');
-        case 'delete': return chalk.red('D');
-        case 'activate': return chalk.dim('>');
-        case 'release': return chalk.dim('^');
-        default: return chalk.dim('?');
-    }
-}
 /**
  * Risk tag. 2026-05-01: yellow used to fire on `medium` too, which
  * meant most plans had a yellow tag — defeating yellow's purpose as
@@ -119,12 +100,14 @@ export async function renderPlanGate(summary, changes, transport, effectiveRisk)
         if (effectiveRisk.raisedBy.length > 0) {
             ctx.push(`(raised from low: ${effectiveRisk.raisedBy.join(', ')})`);
         }
-        for (const c of visibleChanges)
-            ctx.push(`  ${opIcon(c.op)} ${c.object} (${c.type})`);
+        // Numbered, operation-aware verb rows ("1. Create table ZMNT_NOTE") —
+        // no cryptic op-code glyph. The Ink modal renders `context` itself, so
+        // no chalk here.
+        visibleChanges.forEach((c, i) => ctx.push(`  ${i + 1}. ${verbLine(c)}`));
         const result = await askQuestionEmitter.request({
             id: 'plan-gate',
             question: 'Apply this plan?',
-            // Strip chalk ANSI from opIcon/riskTag — the Ink modal renders `context`
+            // Strip chalk ANSI from riskTag — the Ink modal renders `context`
             // itself (dimColor), so embedded escape codes would show as raw text.
             context: ctx.join('\n').replace(/\x1b\[[0-9;]*m/g, ''),
             kind: 'choice',
@@ -149,9 +132,9 @@ export async function renderPlanGate(summary, changes, transport, effectiveRisk)
     if (effectiveRisk.raisedBy.length > 0) {
         console.log(`      ${chalk.dim(`(raised from low: ${effectiveRisk.raisedBy.join(', ')})`)}`);
     }
-    for (const c of visibleChanges) {
-        console.log(`        ${opIcon(c.op)} ${c.object.padEnd(30)} ${chalk.dim(`(${c.type})`)}`);
-    }
+    visibleChanges.forEach((c, i) => {
+        console.log(`        ${chalk.dim(`${i + 1}.`)} ${verbLine(c)}`);
+    });
     console.log('');
     const choice = await withInquirer(() => select({
         message: 'Apply?',
@@ -173,17 +156,20 @@ export async function renderPerChangeApproval(change, effectiveRisk, transport)
     // fires standalone (single-change request_approval) AND risk is non-low.
     void effectiveRisk;
     void transport;
-    const objLabel = `${opIcon(change.op)} ${change.object} (${change.type})`;
+    // Verb-first label ("Create table ZMNT_NOTE — apply?") — no op-code glyph.
+    const objLabel = verbLine(change);
+    // Op-aware review choice: [d] Show diff for modify, [v] View source for
+    // create/delete-with-source, omitted for activate/release.
+    const aff = viewAffordance(change);
+    const choices = [{ value: 'apply', name: 'Apply' }];
+    if (aff)
+        choices.push({ value: 'diff', name: aff.label });
+    choices.push({ value: 'skip', name: 'Skip (tell model why)' }, { value: 'cancel', name: 'Cancel turn' });
     const choice = await withInquirer(() => select({
         message: `${objLabel} — apply?`,
         default: 'apply',
         theme: inquirerTheme,
-        choices: [
-            { value: 'apply', name: 'Apply' },
-            { value: 'diff', name: 'Show diff' },
-            { value: 'skip', name: 'Skip (tell model why)' },
-            { value: 'cancel', name: 'Cancel turn' },
-        ],
+        choices,
     }));
     if (choice === 'apply')
         return { approved: true };
@@ -193,9 +179,29 @@ export async function renderPerChangeApproval(change, effectiveRisk, transport)
         const reason = await withInquirer(() => input({ message: 'Why skip?', theme: inquirerTheme }));
         return { approved: false, reason };
     }
-    // 'diff' — print colorized + lines (green) / - lines (red) / hunk headers
-    // (peach) so the user can scan the change at a glance instead of squinting
-    // at flat-gray text.
+    // Review choice.
+    //
+    // I3 (2026-07-05 review): a 'v' affordance (create/delete View source) is
+    // NOT a diff — the payload is plain/all-adds source. Routing it through the
+    // diff printer fired the "⚠ Model did not provide a unified diff" warning
+    // under a View source label. Print numbered plain source instead — never
+    // the diff path or its warning. (The affordance is only offered when
+    // change.diff is present, so the fallback line is belt-and-braces.)
+    if (aff?.key === 'v') {
+        if (change.diff) {
+            const numbered = toSourceLines(change.diff)
+                .map((line, i) => `${chalk.dim(String(i + 1).padStart(4) + '  ')}${line}`)
+                .join('\n');
+            console.log('\n' + numbered + '\n');
+        }
+        else {
+            console.log(chalk.dim('(No source provided by the model)'));
+        }
+        return renderPerChangeApproval(change, effectiveRisk, transport);
+    }
+    // 'd' (modify) — print colorized + lines (green) / - lines (red) / hunk
+    // headers (peach) so the user can scan the change at a glance instead of
+    // squinting at flat-gray text.
     //
     // 2026-05-01: detect "model sent a description, not a diff" — when the
     // payload has no +/-/@ lines and no `--- /+++ ` headers, colorizeDiff

package/dist/cli.js

@@ -62,6 +62,20 @@ export async function main(argv) {
         }
         return 0;
     }
+    if (args[0] === 'config' && args[1] === 'unset') {
+        const { runConfigUnset, ConfigSetError } = await import('./commands/config-set.js');
+        try {
+            await runConfigUnset(args.slice(2));
+        }
+        catch (e) {
+            if (e instanceof ConfigSetError) {
+                console.error(chalk.red(`✗ ${e.message}`));
+                process.exit(e.exitCode);
+            }
+            throw e;
+        }
+        return 0;
+    }
     if (args[0] === 'config' && args[1] === 'show') {
         const { runConfigShow } = await import('./commands/config-show.js');
         await runConfigShow(args.slice(2));
@@ -134,6 +148,7 @@ Usage:
   cspeach config add-sap            Add a SAP system interactively
   cspeach configure                 Alias for \`cspeach config add-sap\`
   cspeach config set <key> <value>  Update a config key
+  cspeach config unset <key>        Remove a config key (revert to default)
   cspeach config show [key]         Show config (full or single key)
   cspeach doctor                    Diagnose install + connectivity
   cspeach login                     Sign in via device-code flow

package/dist/commands/compact.js

@@ -161,6 +161,24 @@ export async function backupBeforeCompact(session) {
     await fs.writeFile(filePath, JSON.stringify(session, null, 2), 'utf-8');
     return filePath;
 }
+/**
+ * UX Wave 2 / Task 4 — render session.todos as a plain-text,
+ * status-prefixed block for the compacted context. Returns '' when there
+ * is no list (undefined or empty) so callers can append unconditionally.
+ *
+ * Format (explicit status words, not glyphs — the reader is the NEXT
+ * turn's model, and `[in_progress]` is unambiguous where `[>]` isn't):
+ *
+ *   Current task list:
+ *   - [completed] Create table ZORDER
+ *   - [in_progress] Write behavior definition
+ *   - [pending] Publish service binding
+ */
+export function renderTodoSection(todos) {
+    if (!todos || todos.length === 0)
+        return '';
+    return ['', 'Current task list:', ...todos.map((t) => `- [${t.status}] ${t.text}`)].join('\n');
+}
 /**
  * The compacted "synthesised earlier history" message that replaces the
  * summarised slice in session.messages. Role=user because (a) Anthropic
@@ -168,9 +186,16 @@ export async function backupBeforeCompact(session) {
  * makes it visually distinct from the model's prior assistant outputs, and
  * (c) the explicit "context compacted by /compact" framing tells the next
  * turn's model exactly what it's looking at.
+ *
+ * UX Wave 2 / Task 4: when `todos` is provided (runCompact passes
+ * session.todos), a `Current task list:` section is appended after the
+ * summary so the model retains its plan across /compact — the summarised
+ * turns are where the list was built, and Haiku isn't trusted to
+ * reproduce it verbatim.
  */
-export function buildSummaryMessage(summary, droppedTurns) {
+export function buildSummaryMessage(summary, droppedTurns, todos) {
     const ts = new Date().toISOString();
+    const todoSection = renderTodoSection(todos);
     return {
         role: 'user',
         content: [
@@ -180,6 +205,7 @@ export function buildSummaryMessage(summary, droppedTurns) {
             `to ~/.cspeach/sessions/${'<session-id>'}.pre-compact-<timestamp>.json]`,
             '',
             summary,
+            ...(todoSection ? [todoSection] : []),
         ].join('\n'),
     };
 }
@@ -228,7 +254,7 @@ export async function runCompact(opts) {
     // which it will be unless the session is very long. (For very long sessions
     // we accept losing the original first prompt because the summary should
     // mention what the goal was.)
-    const summaryMsg = buildSummaryMessage(summary, plan.toSummarise.length);
+    const summaryMsg = buildSummaryMessage(summary, plan.toSummarise.length, session.todos);
     session.messages = [summaryMsg, ...plan.toKeep];
     await saveSession(session);
     return {