@cspeach/cli 1.1.18 → 1.1.20

package/dist/session/recap.js

@@ -4,9 +4,12 @@
 // who just resumed (or typed /recap) without scrolling back through the
 // transcript.
 //
-//   ↩ last session: /abap-generate · 4 turns · 3h ago · "add a validation…"
-//   ▶ tasks: 2 done / 3 open — next: write the BDEF validation
-//   ▷ plan Maintenance Requests: phase 3/7 validated — next: /abap-plan --resume @…
+//   last session: /abap-generate · 4 turns · 3h ago · "add a validation…"
+//   tasks: 2 of 5 done — next: write the BDEF validation
+//   plan Maintenance Requests: phase 3 of 7 validated — next: /abap-plan --resume @…
+//
+// Piece 2: buildRecapParts() exposes the three facts without labels so the
+// panels start screen can place them (resume line / "!" plan notice).
 //
 // Line 1 always prints (unless the session has zero user turns → recap is
 // empty and callers print nothing). Line 2 only when the session's todo list
@@ -26,18 +29,14 @@ import { readProjectFile } from '../projects/status.js';
 import { parsePlanContent } from '../projects/plan-schema.js';
 import { statusesFromItems, isPhaseSatisfied } from '../projects/plan-run.js';
 import { defaultWorkspaceFor } from '../projects/workspace.js';
-import { userPromptText } from './user-prompt.js';
+import { userPromptText, promptPreviewText } from './user-prompt.js';
 /** Wave-1 truncation rule (see /reroute): ≤60 chars total, '...' suffix. */
 function truncatePrompt(s) {
     return s.length > 60 ? s.slice(0, 57) + '...' : s;
 }
-/**
- * Build the recap lines for a session. Returns [] for an empty session
- * (zero user turns) — callers print nothing in that case.
- */
-export function buildRecap(session, cwd, opts) {
-    const lines = [];
-    // ── line 1: session orientation ─────────────────────────────────────────
+export function buildRecapParts(session, cwd, opts) {
+    const parts = { last: null, tasks: null, plan: null };
+    // ── fact 1: session orientation ─────────────────────────────────────────
     // "User turns" = typed prompts, not tool_result rounds — same counting
     // rule as the resume picker (session/store.ts); see session/user-prompt.ts.
     const userTexts = session.messages
@@ -45,7 +44,7 @@ export function buildRecap(session, cwd, opts) {
         .filter((t) => t !== null);
     const turns = userTexts.length;
     if (turns === 0)
-        return [];
+        return parts;
     const skillLabel = session.skill ? `/${session.skill}` : 'no skill';
     // Last user prompt: prefer the persisted lastUserPrompt (user-typed prose;
     // null after slash-only commands), fall back to the last string user
@@ -54,32 +53,45 @@ export function buildRecap(session, cwd, opts) {
     let prompt = session.lastUserPrompt;
     if (!prompt) {
         const last = userTexts[userTexts.length - 1];
-        prompt = last.replace(/<session_context>[\s\S]*?<\/session_context>\s*/g, '').trim() || null;
+        prompt = promptPreviewText(last) || null;
     }
     const quoted = prompt ? `"${truncatePrompt(prompt)}"` : '(no prompt)';
     const ago = formatTimeAgo(session.last_turn_at, opts?.now);
-    lines.push(`↩ last session: ${skillLabel} · ${turns} turn${turns === 1 ? '' : 's'} · ${ago} · ${quoted}`);
-    // ── line 2: todo list (Task 4's todo_set) — only when open work exists ──
+    parts.last = `${skillLabel} · ${turns} turn${turns === 1 ? '' : 's'} · ${ago} · ${quoted}`;
+    // ── fact 2: todo list (Task 4's todo_set) — only when open work exists ──
     const todos = session.todos ?? [];
     const open = todos.filter((t) => t.status !== 'completed');
     if (open.length > 0) {
         const done = todos.length - open.length;
         const next = todos.find((t) => t.status === 'in_progress') ?? todos.find((t) => t.status === 'pending');
-        lines.push(`▶ tasks: ${done} done / ${open.length} open — next: ${next.text}`);
+        parts.tasks = `${done} of ${todos.length} done — next: ${next.text}`;
     }
-    // ── line 3: newest plan family with unsatisfied phases ──────────────────
-    // Never throws: any fs/parse problem silently drops the line.
+    // ── fact 3: newest plan family with unsatisfied phases ──────────────────
+    // Never throws: any fs/parse problem silently drops the fact.
     try {
-        const planLine = buildPlanLine(opts?.workspaceDir ?? defaultWorkspaceFor(cwd));
-        if (planLine)
-            lines.push(planLine);
+        parts.plan = buildPlanPart(opts?.workspaceDir ?? defaultWorkspaceFor(cwd));
     }
     catch { /* recap must never throw */ }
+    return parts;
+}
+/**
+ * Build the recap lines for a session. Returns [] for an empty session
+ * (zero user turns) — callers print nothing in that case.
+ */
+export function buildRecap(session, cwd, opts) {
+    const p = buildRecapParts(session, cwd, opts);
+    if (p.last === null)
+        return [];
+    const lines = [`last session: ${p.last}`];
+    if (p.tasks)
+        lines.push(`tasks: ${p.tasks}`);
+    if (p.plan)
+        lines.push(`plan ${p.plan.text} — next: ${p.plan.next}`);
     return lines;
 }
 /**
  * Scan `workspaceDir` for the newest plan family and, when it still has
- * unsatisfied phases, produce the plan recap line. Returns null when there
+ * unsatisfied phases, produce the plan recap fact. Returns null when there
  * is no plan, the newest plan family is fully satisfied, or its envelope is
  * invalid (silent skip by design).
  *
@@ -90,7 +102,7 @@ export function buildRecap(session, cwd, opts) {
  * file's mtime. Non-plan envelopes (design, spec-gap, …) are skipped so the
  * newest PLAN family is found even when a newer non-plan artefact exists.
  */
-function buildPlanLine(workspaceDir) {
+function buildPlanPart(workspaceDir) {
     let names;
     try {
         names = readdirSync(workspaceDir);
@@ -157,7 +169,7 @@ function buildPlanLine(workspaceDir) {
         const validated = pc.content.phases.filter((p) => isPhaseSatisfied(statuses[p.id], p.audit)).length;
         if (total === 0 || validated >= total)
             return null; // fully satisfied — no line
-        return `▷ plan ${env.title}: phase ${validated}/${total} validated — next: /abap-plan --resume @${basename(cand.path)}`;
+        return { text: `${env.title}: phase ${validated} of ${total} validated`, next: `/abap-plan --resume @${basename(cand.path)}` };
     }
     return null;
 }

package/dist/session/repin-model.js

@@ -0,0 +1,18 @@
+/**
+ * Task 3 fix round 1 (I1, 2026-09-27) — re-pin a resumed session's model.
+ *
+ * The agent loop sends the session's PINNED `session.model` on every call.
+ * A resumed session carries the id saved at creation (possibly retired, or
+ * an id the served config has since moved away from), so on resume the
+ * model is re-resolved ONCE through the same path new sessions use —
+ * resolveModelRole('session_default', cfg), after the awaited served config —
+ * marked 'predicted', and saved. It then stays pinned for the rest of the
+ * session (managed-mode adoption in the loop may still update it).
+ */
+import { resolveModelRole } from '../models/resolve.js';
+import { saveSession } from './store.js';
+export async function repinResumedSessionModel(session, cfg) {
+    session.model = resolveModelRole('session_default', cfg);
+    session.served_model_source = 'predicted';
+    await saveSession(session);
+}

package/dist/session/resume.js

@@ -1,57 +1,113 @@
-import { select } from '@inquirer/prompts';
+import { select } from '../repl/themed-prompts.js';
 import chalk from 'chalk';
-import { listSessions, loadSession } from './store.js';
+import { listSessions, loadSession, RESUME_PICKER_LIMIT } from './store.js';
 import { formatTimeAgo } from './time-ago.js';
 import { runRepl } from '../repl.js';
-export async function runResume(id) {
+import { formatFailure, formatAttention } from '../renderer/notice-shape.js';
+import { getGlyphs } from '../renderer/glyphs.js';
+import { paint } from '../renderer/theme.js';
+import { truncateToWidth } from '../renderer/ui-width.js';
+import { interruptedPickerLine } from './interrupt-reason.js';
+import stringWidth from 'string-width';
+import { STANDALONE_ALIAS } from '../tools/index.js';
+import { loadConfig, resolveStandalone } from '../config/loader.js';
+/** inquirer's Ctrl+C / force-close rejection. */
+function isPromptCancel(err) {
+    return err?.name === 'ExitPromptError';
+}
+/**
+ * The sessions the resume picker offers: round 6 item 4b — no 0-turn
+ * sessions (a start-then-quit left a "0t (no prompt)" row every time) unless
+ * interrupted; interrupted ones first (most likely wanted after a crash),
+ * then most recent.
+ */
+export function pickerSessions(sessions) {
+    return sessions
+        .filter((s) => s.userTurnCount > 0 || s.interrupted)
+        .sort((a, b) => {
+        if (a.interrupted !== b.interrupted)
+            return a.interrupted ? -1 : 1;
+        return b.lastTurnAt.localeCompare(a.lastTurnAt);
+    });
+}
+export async function runResume(id, opts = {}) {
     let targetId = id;
     if (!targetId) {
-        const sessions = await listSessions(20);
+        const sessions = pickerSessions(await listSessions(RESUME_PICKER_LIMIT, { skipEmpty: true }));
         if (sessions.length === 0) {
             console.log('No recent sessions.');
             return 0;
         }
-        // Promote interrupted sessions to the top of the list — they're the
-        // ones the user is most likely looking for after a crash.
-        const sorted = [...sessions].sort((a, b) => {
-            if (a.interrupted !== b.interrupted)
-                return a.interrupted ? -1 : 1;
-            return b.lastTurnAt.localeCompare(a.lastTurnAt);
-        });
-        targetId = await select({
-            message: `Pick a session to resume:
+        const sorted = sessions;
+        try {
+            targetId = await select({
+                message: `Pick a session to resume:
 ${formatSessionHeader()}`,
-            choices: sorted.map((s) => ({
-                value: s.id,
-                name: formatSessionRow(s),
-                description: s.interrupted
-                    ? `Interrupted (${s.interruptedReason ?? 'unknown'}) — type "continue" after resume`
-                    : `${s.userTurnCount} prior turn(s) — pick up from where you left off`,
-            })),
-        });
+                choices: sorted.map((s) => ({
+                    value: s.id,
+                    name: formatSessionRow(s),
+                    // Round 6 item 4a — the answered line shows the id, not the whole row.
+                    short: s.id,
+                    description: s.interrupted
+                        ? interruptedPickerLine(s.interruptedReason)
+                        : `${s.userTurnCount} prior turn(s) — pick up from where you left off`,
+                })),
+            });
+        }
+        catch (err) {
+            // Ctrl+C in the picker: exit quietly, like Claude Code (fix round 3).
+            if (isPromptCancel(err))
+                return 0;
+            throw err;
+        }
     }
     let session;
     try {
         session = await loadSession(targetId);
     }
     catch (err) {
-        console.error(chalk.red(`\n[error] ${err.message}\n`));
+        console.error('\n' + formatFailure({ what: 'Could not load the session', detail: [err.message], next: 'cspeach --resume  (pick from the list)' }));
         return 1;
     }
     const unfinished = session.toolCalls.filter((c) => !c.completed);
+    // Round 6 review I3 — moving a session with unfinished SAP changes to
+    // another system would leave those changes unreconcilable: refuse.
+    const from = session.sap_system;
+    if (opts.sapAlias && unfinished.length > 0 && from && from !== STANDALONE_ALIAS && from !== opts.sapAlias) {
+        console.error(formatFailure({ what: `This session has unfinished changes on ${from} · resume without --sap-alias` }).trimEnd());
+        return 1;
+    }
+    // Final batch 4 + re-review — the same rule for standalone on a SAP
+    // session, whether --no-sap asked for it or the persisted no_sap setting.
+    if (unfinished.length > 0 && from && from !== STANDALONE_ALIAS) {
+        const cfg = await loadConfig();
+        if (resolveStandalone(cfg, opts.noSap === true)) {
+            const how = opts.noSap ? 'resume without --no-sap' : 'resume with SAP enabled';
+            console.error(formatFailure({ what: `This session has unfinished changes on ${from} · ${how}` }).trimEnd());
+            return 1;
+        }
+    }
     if (unfinished.length > 0) {
-        console.log(chalk.yellow(`\n⚠  ${unfinished.length} pending mutation(s) from the previous session:\n`));
+        console.log('\n' + formatAttention({ text: `${unfinished.length} unfinished SAP change${unfinished.length === 1 ? '' : 's'} from the previous session`, fact: 'choose how to reconcile below' }));
         for (const u of unfinished) {
             console.log(`  ${u.tool} ${JSON.stringify(u.args)}`);
         }
-        const action = await select({
-            message: 'Reconcile how?',
-            choices: [
-                { value: 'reconcile', name: 'Query SAP to find out what actually happened (requires SAP reachable)' },
-                { value: 'continue', name: 'Leave as unresolved, continue (risky)' },
-                { value: 'abandon', name: 'Abandon this session (file is kept on disk)' },
-            ],
-        });
+        let action;
+        try {
+            action = await select({
+                message: 'Reconcile how?',
+                choices: [
+                    { value: 'reconcile', name: 'Query SAP to find out what actually happened (requires SAP reachable)' },
+                    { value: 'continue', name: 'Leave as unresolved, continue (risky)' },
+                    { value: 'abandon', name: 'Abandon this session (file is kept on disk)' },
+                ],
+            });
+        }
+        catch (err) {
+            if (isPromptCancel(err))
+                return 0;
+            throw err;
+        }
         if (action === 'abandon')
             return 0;
         if (action === 'reconcile') {
@@ -65,19 +121,31 @@ ${formatSessionHeader()}`,
     // kept (a stub from v0.1). Now resume genuinely picks up where the prior
     // turn left off — including mid-turn-interrupted ones recoverable thanks
     // to the persistence work in agent/loop.ts.
-    return runRepl({ resumedSession: session });
+    // Round 6 review C1 — the start flags reach the REPL (they used to be
+    // dropped, so --sap-alias never switched a resumed session).
+    return runRepl({ resumedSession: session, sapAlias: opts.sapAlias, noSap: opts.noSap });
 }
 // Column widths shared by the rows and the header so the labels line up.
 const W = { id: 8, time: 10, sap: 8, skill: 22, turns: 5 };
-export function formatSessionRow(s) {
-    const flag = s.interrupted ? chalk.yellow('⚠ ') : '  ';
+/**
+ * One picker row. Round 4 item 10 — the preview is cut to the terminal
+ * width (a long one wrapped onto a second line at 100 columns and broke the
+ * table): room = columns − the picker's 2-cell cursor gutter − the fixed
+ * columns − 1 spare cell.
+ */
+export function formatSessionRow(s, columns = process.stdout.columns ?? 80) {
+    const flag = s.interrupted ? paint('warn', getGlyphs().attention) + ' ' : '  ';
     const idCol = chalk.cyan(s.id.padEnd(W.id));
     const timeCol = chalk.gray(formatTimeAgo(s.lastTurnAt).padEnd(W.time));
     const sapCol = chalk.gray((s.sapSystem ?? '-').padEnd(W.sap));
     const skillCol = chalk.gray(`/${s.skill ?? '-'}`.padEnd(W.skill));
     const turns = chalk.gray(`${s.userTurnCount}t`.padStart(W.turns));
-    const snippet = s.promptSnippet ?? chalk.dim('(no prompt)');
-    return `${flag}${idCol} ${timeCol} ${sapCol} ${skillCol} ${turns}  ${snippet}`;
+    const prefix = `${flag}${idCol} ${timeCol} ${sapCol} ${skillCol} ${turns}  `;
+    // Measured (string-width ignores colour codes), not summed: a value wider
+    // than its column pads nothing.
+    const room = Math.max(8, columns - 2 - stringWidth(prefix) - 1);
+    const snippet = s.promptSnippet != null ? truncateToWidth(s.promptSnippet, room) : chalk.dim('(no prompt)');
+    return `${prefix}${snippet}`;
 }
 /**
  * One dim line naming the row columns (2026-09-23 — rows had no labels). The

package/dist/session/store.js

@@ -1,9 +1,12 @@
+import { isUserStopReason } from './interrupt-reason.js';
 import fs from 'node:fs/promises';
+import { existsSync, readdirSync } from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { sessionsDir, pinnedSessionsDir } from '../config/paths.js';
 import { SCHEMA_VERSION } from './schema.js';
-import { userPromptText, isUserPrompt } from './user-prompt.js';
+import { userPromptText, isUserPrompt, promptPreviewText } from './user-prompt.js';
+import { stripUnsignedThinking, dropTrailingThinkingOnly } from '../agent/repair-partial.js';
 export function makeSessionId() {
     return crypto.randomBytes(4).toString('hex');
 }
@@ -12,6 +15,19 @@ function sessionPath(id, startedAt) {
     const stamp = startedAt.replace(/[:.]/g, '-');
     return path.join(dir, `${stamp}-${id}.json`);
 }
+/** Round 6 review I1 — has this session ever been written to disk? */
+export function sessionSaved(session) {
+    try {
+        if (existsSync(sessionPath(session.id, session.started_at)))
+            return true;
+        // Final batch 2 — a pinned session lives in the pinned folder (any stamp).
+        const suffix = `-${session.id}.json`;
+        return existsSync(pinnedSessionsDir()) && readdirSync(pinnedSessionsDir()).some((f) => f.endsWith(suffix));
+    }
+    catch {
+        return false;
+    }
+}
 export async function saveSession(session) {
     const dir = sessionsDir();
     await fs.mkdir(dir, { recursive: true });
@@ -71,7 +87,8 @@ function validateSchema(parsed) {
         if (!Array.isArray(msg.content))
             continue;
         for (const block of msg.content) {
-            if (block?.type === 'tool_use' && typeof block.partial_json === 'string') {
+            // Task 16 (F6): server_tool_use (tool search) streams input the same way.
+            if ((block?.type === 'tool_use' || block?.type === 'server_tool_use') && typeof block.partial_json === 'string') {
                 if (block.input === undefined) {
                     try {
                         block.input = JSON.parse(block.partial_json);
@@ -84,22 +101,65 @@ function validateSchema(parsed) {
             }
         }
     }
+    // 2026-09-27: heal sessions poisoned by a turn cancelled mid-thinking — an
+    // unsigned thinking block makes every later request 400 ("Invalid
+    // `signature` in `thinking` block"), so --resume and `continue` failed.
+    stripUnsignedThinking(parsed.messages);
+    // Review M2 — and a thinking-only last assistant turn (cut right after it).
+    dropTrailingThinkingOnly(parsed.messages);
     return parsed;
 }
-export async function listSessions(limit = 10) {
+/**
+ * Task 18 — a reader subagent (tools/subagent/read_agent.ts) saves its own
+ * `reader-*` session file; it is an internal child of a turn, not something
+ * the user resumes.
+ */
+export function isReaderSessionId(id) {
+    return typeof id === 'string' && id.startsWith('reader-');
+}
+/** How many sessions `cspeach --resume` lists — the unfinished count uses the same window. */
+export const RESUME_PICKER_LIMIT = 20;
+/**
+ * The session files most likely to be the `limit` most recent, newest first
+ * by modification time (fix round 3, items 11d/11e). Every save rewrites the
+ * file, so mtime tracks last_turn_at; a margin of extra candidates absorbs
+ * clock / copy skew, and the caller still sorts by last_turn_at. With
+ * thousands of files this parses a few dozen instead of all of them (each
+ * full pass cost ~1.3 s at startup with 4,410 files).
+ */
+async function recentSessionFiles(dir, limit) {
+    // Merge note — Task 18 reader-* child sessions are skipped by NAME here, so a
+    // burst of reader files can never crowd real sessions out of the window.
+    const files = (await fs.readdir(dir).catch(() => []))
+        .filter((f) => f.endsWith('.json') && !f.includes('-reader-'));
+    const cap = Math.max(limit * 3, 50);
+    if (files.length <= cap)
+        return files;
+    const stamped = await Promise.all(files.map(async (f) => {
+        try {
+            return { f, t: (await fs.stat(path.join(dir, f))).mtimeMs };
+        }
+        catch {
+            return { f, t: 0 };
+        }
+    }));
+    stamped.sort((a, b) => b.t - a.t);
+    return stamped.slice(0, cap).map((x) => x.f);
+}
+export async function listSessions(limit = 10, opts = {}) {
     // NOTE: bypasses validateSchema() for performance — reads JSON directly via
     // JSON.parse + cast. Any new SessionState field accessed here must be
     // defaulted at the read site (e.g. `?? 'skill'`) because pre-chunk-4A
     // serialised sessions on disk lack the field.
     const dir = sessionsDir();
-    const files = await fs.readdir(dir).catch(() => []);
+    const files = await recentSessionFiles(dir, limit);
     const results = [];
     for (const f of files) {
-        if (!f.endsWith('.json'))
-            continue;
         try {
             const raw = await fs.readFile(path.join(dir, f), 'utf-8');
             const parsed = JSON.parse(raw);
+            if (isReaderSessionId(parsed.id))
+                continue; // Task 18 — internal child, never resumed
             const messages = parsed.messages ?? [];
             // First user message that's a plain string (not a tool_result array) — the
             // most recent prompt text that initiated a turn. We pick the LAST such
@@ -113,7 +173,9 @@ export async function listSessions(limit = 10) {
                     // Strip <session_context>...</session_context> wrapper that the
                     // first turn injects, leaving only the user-typed prompt visible
                     // in the picker.
-                    const stripped = text.replace(/<session_context>[\s\S]*?<\/session_context>\s*/g, '').trim();
+                    // (fix round 3: every injected block, e.g. <project_context>, and
+                    // newlines — they broke the picker's table row.)
+                    const stripped = promptPreviewText(text);
                     promptSnippet = (stripped || '<empty>').slice(0, 80);
                     break;
                 }
@@ -135,32 +197,26 @@ export async function listSessions(limit = 10) {
         catch { /* skip corrupt */ }
     }
     results.sort((a, b) => b.lastTurnAt.localeCompare(a.lastTurnAt));
-    return results.slice(0, limit);
+    // Round 6 review M1 — the picker drops 0-turn sessions (unless interrupted)
+    // BEFORE the limit, so a pile of start-then-quit files cannot crowd out
+    // the sessions worth resuming.
+    const kept = opts.skipEmpty ? results.filter((r) => r.userTurnCount > 0 || r.interrupted) : results;
+    return kept.slice(0, limit);
 }
 /**
- * Count interrupted sessions for the startup banner. Reads only enough of each
- * file to find the turnInterrupted flag, so it scales to many sessions without
- * a full parse + sort pass. Returns 0 on any IO failure (best-effort discovery).
+ * Count interrupted sessions for the startup banner — among the sessions the
+ * `--resume` picker can show (RESUME_PICKER_LIMIT most recent), so the
+ * "! N unfinished sessions" notice never points at sessions the picker does
+ * not list (fix round 3, item 11d). Returns 0 on any IO failure.
  */
 export async function countInterruptedSessions() {
-    // NOTE: bypasses validateSchema() (same as listSessions). Any new
-    // SessionState field accessed here must be defaulted at the read site.
     try {
-        const dir = sessionsDir();
-        const files = await fs.readdir(dir).catch(() => []);
-        let count = 0;
-        for (const f of files) {
-            if (!f.endsWith('.json'))
-                continue;
-            try {
-                const raw = await fs.readFile(path.join(dir, f), 'utf-8');
-                const parsed = JSON.parse(raw);
-                if (parsed.turnInterrupted === true)
-                    count++;
-            }
-            catch { /* skip corrupt */ }
-        }
-        return count;
+        // Round 8 item 7 — a turn the USER stopped (Ctrl+C, /exit mid-turn) is
+        // not unfinished work: counting it kept "! 1 unfinished session" on every
+        // start until that session happened to finish a turn. The picker still
+        // lists it as "Stopped by you".
+        return (await listSessions(RESUME_PICKER_LIMIT))
+            .filter((s) => s.interrupted && !isUserStopReason(s.interruptedReason)).length;
     }
     catch {
         return 0;

package/dist/session/user-prompt.js

@@ -21,3 +21,24 @@ export function userPromptText(m) {
 export function isUserPrompt(m) {
     return userPromptText(m) !== null;
 }
+/**
+ * Tags of the context blocks the agent loop injects into a user message
+ * (`<session_context>` from the intent extractor / SAP system info,
+ * `<project_context>` from CSPEACH_PROJECT_CONTEXT). The user never typed
+ * them, so a prompt preview must never show them (fix round 3, item 2).
+ */
+const INJECTED_CONTEXT_TAGS = ['session_context', 'project_context'];
+/**
+ * One-line preview of what the user typed: injected context blocks removed,
+ * `<attached file="x">…</attached>` expansions shown as the original `@x`
+ * token, and all whitespace runs (newlines included) collapsed to one space.
+ * Used by the resume picker and the resumed-session recap line.
+ */
+export function promptPreviewText(text) {
+    let out = text;
+    for (const tag of INJECTED_CONTEXT_TAGS) {
+        out = out.replace(new RegExp(`<${tag}(?:\\s[^>]*)?>[\\s\\S]*?</${tag}>`, 'g'), ' ');
+    }
+    out = out.replace(/<attached file="([^"]*)">[\s\S]*?<\/attached>/g, (_m, f) => `@${f}`);
+    return out.replace(/\s+/g, ' ').trim();
+}

package/dist/skill-catalog.js

@@ -135,6 +135,13 @@ export const SKILL_CATALOG = [
         whenToUse: `pick this for a freestyle UI5 frontend on a published OData service (not /abap-rap — that's the backend; produces local files, not ADT objects)`,
         asks: 'which service and what UI? e.g. "list + object page on ZUI_LAS_INSPECTIONLOG_O4"',
     },
+    {
+        name: 'abap-cap',
+        category: 'Create / Generate',
+        description: 'Build a CAP (Node.js) app on the laptop from a spec — CDS domain model, service, handlers, Fiori Elements annotations, run it locally with cds watch and prove it with the Fiori checks. Side-by-side extensions, not on-stack ABAP.',
+        whenToUse: `pick this for a CAP / BTP side-by-side app (cds, Node.js), not ABAP — on-stack RAP is /abap-rap; a UI on an existing OData service is /abap-fiori-build`,
+        asks: 'what should the app manage? e.g. "suppliers and their certificates, with draft editing"',
+    },
     {
         name: 'abap-data-model',
         category: 'Create / Generate',