@cspeach/cli 1.1.15 → 1.1.17

package/dist/agent/loop.js

@@ -30,12 +30,14 @@ import { parseFromFlag, coerceDocFromFlagToAttachment } from '../skills/promotio
 import { input } from '@inquirer/prompts';
 import { withInquirer } from '../repl/inquirer-guard.js';
 import { expandTextFileAttachments } from '../projects/workspace.js';
+import { expandImageAttachments, buildUserContent, trimHistoryImages } from '../projects/image-attachments.js';
+import { expandImageChips } from '../ui/clipboard-image.js';
 import { getSapSystemInfo, renderSapSystemBlock } from '../sap/system-info.js';
 import { renderStandaloneContextBlock } from '../sap/standalone-profile.js';
 import { renderStandardsBlock } from '../standards/standards-file.js';
 import { composeSessionContextBlock } from './session-context.js';
 import { objectKeyFromInput } from './retry-key.js';
-import { repairPartialBlocks, healSessionMessagesInPlace, isPartialJsonApiError } from './repair-partial.js';
+import { repairPartialBlocks, healSessionMessagesInPlace, healOrphanToolUses, isPartialJsonApiError } from './repair-partial.js';
 import { drainSteering } from './steering-queue.js';
 import { TurnStreamWriter } from './turn-stream.js';
 import { applyToolResultCheckpoint } from './skill-checkpoint.js';
@@ -45,6 +47,7 @@ import { buildSapConnectionContext } from './sap-connection-adapter.js';
 import { getCurrentTransport } from '../repl/current-transport.js';
 import { collectTurnAssistantText } from './turn-assistant-text.js';
 import { checkAndMark, newGuardState } from './parallel-write-guard.js';
+import { userPromptText } from '../session/user-prompt.js';
 /**
  * Author identity for project-file metadata. Reads CSPEACH_AUTHOR_NAME first,
  * then platform USER/USERNAME, then a generic fallback. Role is fixed to
@@ -103,17 +106,15 @@ const SAVE_HOOK_SKILLS = new Set([
  *    per-process counter would re-inject; the content scan correctly
  *    short-circuits.
  *
- *  - tool_result entries push `role: 'user'` with array-shaped content.
- *    The `typeof === 'string'` check skips those without iterating
- *    multimodal blocks.
+ *  - tool_result entries push `role: 'user'` with array-shaped content;
+ *    userPromptText skips those. An image-attachment prompt is also an
+ *    array ([image…, text]) and IS checked (2026-09-23).
  *
  * Exported for unit testing only — the call site is one floor up in runTurn.
  */
 export function hasProjectContextBlock(messages) {
     for (const m of messages) {
-        if (m.role !== 'user')
-            continue;
-        if (typeof m.content === 'string' && m.content.includes('<project_context')) {
+        if (userPromptText(m)?.includes('<project_context')) {
             return true;
         }
     }
@@ -332,6 +333,20 @@ export async function runTurn(params) {
             userMessageForSave = rest;
         }
     }
+    // Tier 1 screenshots (2026-09-23) — image paths in the prompt (typed,
+    // @-referenced or dragged in) become image content blocks and the path
+    // becomes `[attached <name>]`. Runs BEFORE the text-file expansion so a
+    // path written inside an attached document is never pulled in. Too large
+    // or too many images → the turn is not sent (same early exit as --from).
+    // Pasted clipboard images arrive as [Image #N] chips — swap each for its
+    // saved file path first, so the step below attaches it like a typed path.
+    const imageExpansion = await expandImageAttachments(expandImageChips(userMessageForLLM), params.ctx.cwd, (line) => emit(chalk.dim(line)));
+    if (imageExpansion.error) {
+        emit(chalk.yellow(`
+${imageExpansion.error}`));
+        return;
+    }
+    userMessageForLLM = imageExpansion.text;
     // Phase D — `@<text-file>` attachment expansion.
     // After --from has consumed its own @<token>, scan what's left for
     // `@<filename>` references that resolve to .txt / .md files in the
@@ -416,7 +431,17 @@ export async function runTurn(params) {
     const finalUserContent = projectContextBlock
         ? `${projectContextBlock}\n\n${enriched}`
         : enriched;
-    session.messages.push({ role: 'user', content: finalUserContent });
+    // Images (if any) ride as blocks ahead of the text; with none this is the
+    // same plain string as before.
+    session.messages.push({ role: 'user', content: buildUserContent(finalUserContent, imageExpansion.images) });
+    if (imageExpansion.images.length > 0 && params.provider.name === 'local-openai-compat') {
+        // The local (OpenAI-compatible) provider keeps text blocks only.
+        emit(chalk.dim('(local model: the image is not sent — the model gets the text only)'));
+    }
+    const droppedImages = trimHistoryImages(session.messages);
+    if (droppedImages > 0) {
+        emit(chalk.dim(`(${droppedImages} older image(s) removed from the conversation to keep it under the size limit)`));
+    }
     session.skill = params.skill;
     /**
      * key: `${tool_name}:${object}` — consecutive failures per (tool, target).
@@ -540,6 +565,14 @@ export async function runTurn(params) {
                 // the single chokepoint every request passes through, retries included —
                 // makes the 400 categorically impossible. Idempotent and O(messages).
                 healSessionMessagesInPlace(session.messages);
+                // 2026-09-24 — same chokepoint: a tool call cut off before its
+                // result was recorded 400s every later request (a customer's
+                // `continue` could never succeed). Give each orphan an error result
+                // so the model sees the call did not complete and redoes it.
+                const healedOrphans = healOrphanToolUses(session.messages);
+                if (healedOrphans > 0) {
+                    emit(chalk.dim(`(repaired ${healedOrphans} tool call(s) cut off by an interruption — the model will redo them)`));
+                }
                 const streamParams = {
                     // A4 — per-turn override (plan model tiering) wins over the
                     // configured default; absent on every non-plan turn. model-governance

package/dist/agent/repair-partial.js

@@ -116,3 +116,54 @@ export function isPartialJsonApiError(err) {
         && s.includes('partial_json')
         && /not permitted|Extra inputs/i.test(s));
 }
+/** Result text for a tool call whose real result was lost to an interruption. */
+export const INTERRUPTED_TOOL_RESULT = 'This tool call did not complete — the turn was interrupted before its result was recorded. ' +
+    'Its effect is unknown: check before relying on it, and re-run it if needed.';
+/**
+ * 2026-09-24 — heal tool_use blocks that have no tool_result after them.
+ *
+ * A turn cut after the model streamed a tool_use but before the result was
+ * recorded leaves a history the API rejects on EVERY later request
+ * ("messages.N: `tool_use` ids were found without `tool_result` blocks
+ * immediately after") — a customer's `continue` could never succeed. Each
+ * orphan gets a synthetic error result, placed where the API requires it: at
+ * the front of the next user message (created if the next message is not a
+ * user message). Mutates `messages`; returns the number of results added.
+ * Idempotent; a no-op on a healthy conversation.
+ */
+export function healOrphanToolUses(messages) {
+    if (!messages)
+        return 0;
+    let added = 0;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg?.role !== 'assistant' || !Array.isArray(msg.content))
+            continue;
+        const ids = msg.content
+            .filter((b) => b?.type === 'tool_use' && typeof b.id === 'string')
+            .map((b) => b.id);
+        if (ids.length === 0)
+            continue;
+        let next = messages[i + 1];
+        if (next?.role !== 'user') {
+            next = { role: 'user', content: [] };
+            messages.splice(i + 1, 0, next);
+        }
+        else if (!Array.isArray(next.content)) {
+            next.content = [{ type: 'text', text: String(next.content ?? '') }];
+        }
+        const have = new Set(next.content.filter((b) => b?.type === 'tool_result').map((b) => b.tool_use_id));
+        const missing = ids
+            .filter((id) => !have.has(id))
+            .map((id) => ({ type: 'tool_result', tool_use_id: id, is_error: true, content: INTERRUPTED_TOOL_RESULT }));
+        if (missing.length === 0)
+            continue;
+        // tool_result blocks must lead the message: existing results, then the
+        // synthetic ones, then everything else (e.g. the user's "continue").
+        const results = next.content.filter((b) => b?.type === 'tool_result');
+        const rest = next.content.filter((b) => b?.type !== 'tool_result');
+        next.content = [...results, ...missing, ...rest];
+        added += missing.length;
+    }
+    return added;
+}

package/dist/agent/tool-dispatch.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { getTool, isStandalone } from '../tools/index.js';
 import { NOT_CONNECTED_MESSAGE } from '../sap/offline-adt-client.js';
 import { presentSafetyConfirmation } from '../repl/safety-confirm.js';
@@ -30,7 +31,7 @@ export async function dispatchTool(name, args, ctx) {
     // GUIDE.md) — local scratch, not SAP objects. Rule 8 protects SAP batches;
     // applying it here made the 2nd+ file (GUIDE.md) hit the batch card and,
     // headless, get refused. Exempt from the gate AND from the batch count.
-    const scratchWrite = isScratchOutputWrite(tool, args);
+    const scratchWrite = isScratchOutputWrite(tool, args, ctx.cwd);
     if (tool.isMutating && !scratchWrite && shouldGateRule8()) {
         const r = await presentSafetyConfirmation({
             rule: 'RULE_8_BATCH_PLAN',
@@ -83,21 +84,24 @@ export async function dispatchTool(name, args, ctx) {
     }
 }
 /**
- * True for a mutating filesystem tool whose target sits under ./cspeach-out/
- * (relative to cwd). Accepts `cspeach-out/…`, `./cspeach-out/…` and the
- * Windows backslash form; rejects anything that climbs out (`..`) or is
- * absolute. Deliberately narrow: only this one folder is exempt.
+ * True for a mutating filesystem tool whose target sits under the project's
+ * own ./cspeach-out/ (cwd). Accepts `cspeach-out/…`, `./cspeach-out/…`, the
+ * Windows backslash form, and an ABSOLUTE path that resolves inside
+ * <cwd>/cspeach-out (2026-09-23: models write full paths, and a project deep
+ * in a synced folder hit the batch card on every file after the first).
+ * Rejects anything with a `..` segment and any cspeach-out outside cwd.
+ * Deliberately narrow: only this one folder is exempt.
  */
-export function isScratchOutputWrite(tool, args) {
+export function isScratchOutputWrite(tool, args, cwd = process.cwd()) {
     if (!tool.isMutating || tool.category !== 'filesystem')
         return false;
     const raw = args?.path;
     if (typeof raw !== 'string' || raw.length === 0)
         return false;
     const p = raw.replace(/\\/g, '/').replace(/^\.\//, '');
-    if (p.startsWith('/') || /^[A-Za-z]:\//.test(p))
-        return false;
     if (p.split('/').some((seg) => seg === '..'))
         return false;
-    return p === 'cspeach-out' || p.startsWith('cspeach-out/');
+    const scratchRoot = path.resolve(cwd, 'cspeach-out');
+    const rel = path.relative(scratchRoot, path.resolve(cwd, p));
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
 }

package/dist/agent/turn-error-ux.js

@@ -39,6 +39,11 @@ export function describeError(err) {
     }
     if (msg.includes('ECONNRESET'))
         return 'network connection reset';
+    // 2026-09-24 — the other shapes a dropped connection takes (our service
+    // restarting, a network blip): say it plainly instead of the raw text.
+    if (/fetch failed|socket hang up|other side closed|UND_ERR_SOCKET|ECONNREFUSED/i.test(msg)) {
+        return 'connection to CSPeach dropped';
+    }
     if (msg.includes('ETIMEDOUT'))
         return 'network timeout';
     if (msg.toLowerCase().includes('aborterror'))
@@ -111,6 +116,9 @@ export async function renderTurnError(input) {
     const reason = describeError(input.err);
     const logPath = await writeErrorLog(input.session.id, input.err);
     print(chalk.red(`⚠  Turn interrupted: ${reason}`));
+    if (input.inSession) {
+        print(chalk.yellow(`   Your work so far is saved. Type continue to pick up where it stopped.`));
+    }
     print(chalk.gray(`   Session: ${input.session.id}`));
     if (input.streamFilePath) {
         print(chalk.gray(`   Stream:  ${input.streamFilePath}`));

package/dist/commands/compact.js

@@ -29,6 +29,7 @@ import path from 'node:path';
 import chalk from 'chalk';
 import { sessionsDir } from '../config/paths.js';
 import { saveSession } from '../session/store.js';
+import { isUserPrompt } from '../session/user-prompt.js';
 /** Keep this many recent user-prompt anchored turns verbatim. */
 export const KEEP_RECENT_TURNS = 5;
 /** Don't bother compacting if there's only a handful of older turns. */
@@ -58,8 +59,9 @@ keepRecentTurns = KEEP_RECENT_TURNS) {
     let cutAt = 0;
     for (let i = messages.length - 1; i >= 0; i--) {
         const msg = messages[i];
-        // A user PROMPT (not a tool_result block) — content is a string.
-        if (msg.role === 'user' && typeof msg.content === 'string') {
+        // A user PROMPT (not a tool_result round) — string content, or an
+        // image-attachment prompt ([image…, text]).
+        if (isUserPrompt(msg)) {
             userPromptsSeen++;
             if (userPromptsSeen === keepRecentTurns) {
                 cutAt = i;
@@ -134,6 +136,8 @@ export function serialiseForSummariser(messages) {
                     return '';
                 if (b.type === 'text')
                     return b.text ?? '';
+                if (b.type === 'image')
+                    return '[image]';
                 if (b.type === 'thinking')
                     return `[thinking: ${(b.thinking ?? '').slice(0, 200)}]`;
                 if (b.type === 'tool_use')

package/dist/commands/project-context-impact.js

@@ -24,6 +24,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
 import { sessionsDir } from '../config/paths.js';
+import { userPromptText } from '../session/user-prompt.js';
 /**
  * Read all session JSONs in `dir` (defaults to sessionsDir()), classify
  * each by whether the flag was on, and produce a comparison report.
@@ -134,8 +135,7 @@ async function readAllSessions(dir) {
 function toMetrics(s) {
     const firstUser = s.messages.find((m) => m.role === 'user');
     const flagOn = firstUser !== undefined &&
-        typeof firstUser.content === 'string' &&
-        firstUser.content.includes('<project_context');
+        (userPromptText(firstUser)?.includes('<project_context') ?? false);
     // Count "turns" as user messages — each user message kicks off a model turn.
     const turnCount = s.messages.filter((m) => m.role === 'user').length;
     const usage = s.usage ?? { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 };

package/dist/one-shot.js

@@ -170,6 +170,8 @@ export async function runOneShot(prompt, opts) {
             console.error(chalk.dim(`[offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]`));
         }
         const pct = Math.round(c.confidence * 100);
+        if (c.screenshot)
+            console.log(chalk.dim(`┄ Screenshot: ${c.screenshot}`));
         if (c.confidence < 0.6) {
             const alternates = [c.skill, ...c.alternates].slice(0, 3).map((s) => `/${s}`).join(', ');
             console.error(chalk.yellow(`[classifier] Low confidence (${pct}%). Using /${c.skill}. ` +

package/dist/projects/image-attachments.js

@@ -0,0 +1,155 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+/**
+ * Tier 1 screenshots (2026-09-23, spec 2026-09-16-image-attachments-1.1.5.md).
+ *
+ * An image path in the prompt — typed, `@`-referenced, or dragged in (a
+ * terminal pastes the path as text, double-quoted when it has spaces) — is
+ * read and sent as an image content block. The path in the text becomes
+ * `[attached <name>]`. In standalone mode a screenshot of an ST22 dump or an
+ * ATC list is how users show us what they see.
+ */
+const MEDIA_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+/** Raw-file cap. The API limit is 5 MB per image as base64 (4/3 inflation). */
+export const MAX_IMAGE_BYTES = Math.floor((5 * 1024 * 1024 * 3) / 4);
+export const MAX_IMAGES_PER_TURN = 5;
+/** Appended to the text block whenever an image is attached. */
+export const IMAGE_PROMPT_NOTE = '(Anything taken from an attached image must be stated as "from the screenshot", ' +
+    'and object names read from it confirmed with the user before use.)';
+function mediaTypeOf(p) {
+    return MEDIA_TYPES[path.extname(p).toLowerCase()] ?? null;
+}
+function formatBytes(n) {
+    if (n < 1024 * 1024)
+        return `${Math.max(1, Math.round(n / 1024))} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+export async function expandImageAttachments(message, cwd, log) {
+    // One token per match: optional @, then a "double" or 'single' quoted run,
+    // or a bare word.
+    const tokenRe = /@?(?:"([^"\r\n]+)"|'([^'\r\n]+)'|(\S+))/g;
+    const found = [];
+    let m;
+    while ((m = tokenRe.exec(message)) !== null) {
+        const quoted = m[1] ?? m[2];
+        if (quoted !== undefined) {
+            if (mediaTypeOf(quoted)) {
+                found.push({ index: m.index, length: m[0].length, token: quoted });
+            }
+            else {
+                // A quoted run that is not an image path ("some text with x.png", or
+                // an apostrophe pair) — rescan its words instead of skipping them.
+                const openQuote = m.index + (m[0].startsWith('@') ? 1 : 0);
+                tokenRe.lastIndex = openQuote + 1;
+            }
+            continue;
+        }
+        let token = m[3];
+        let length = m[0].length;
+        const trail = /[,;:.!?)\]]+$/.exec(token);
+        if (trail && trail[0].length < token.length) {
+            token = token.slice(0, -trail[0].length);
+            length -= trail[0].length;
+        }
+        if (token.includes('://') || !mediaTypeOf(token))
+            continue;
+        found.push({ index: m.index, length, token });
+    }
+    if (found.length === 0)
+        return { text: message, images: [] };
+    // Resolve against cwd; keep only files that exist. One block per file even
+    // if it is named twice.
+    const byPath = new Map();
+    const substitutions = [];
+    for (const f of found) {
+        const abs = path.resolve(cwd, f.token);
+        let size;
+        try {
+            const st = await fs.stat(abs);
+            if (!st.isFile())
+                throw new Error('not a file');
+            size = st.size;
+        }
+        catch {
+            if (log)
+                log(`(image ${f.token} not found — looked in ${cwd})`);
+            continue;
+        }
+        const name = path.basename(abs);
+        if (!byPath.has(abs))
+            byPath.set(abs, { name, size });
+        substitutions.push({ index: f.index, length: f.length, replacement: `[attached ${name}]` });
+    }
+    if (byPath.size === 0)
+        return { text: message, images: [] };
+    if (byPath.size > MAX_IMAGES_PER_TURN) {
+        return {
+            text: message,
+            images: [],
+            error: `${byPath.size} images in one message — the limit is ${MAX_IMAGES_PER_TURN}. Nothing was sent.`,
+        };
+    }
+    for (const { name, size } of byPath.values()) {
+        if (size > MAX_IMAGE_BYTES) {
+            return {
+                text: message,
+                images: [],
+                error: `${name} is ${formatBytes(size)} — the limit is ${formatBytes(MAX_IMAGE_BYTES)} per image. ` +
+                    'Crop it or save it as JPEG and try again. Nothing was sent.',
+            };
+        }
+    }
+    const images = [];
+    for (const [abs, { name, size }] of byPath) {
+        const data = (await fs.readFile(abs)).toString('base64');
+        images.push({ type: 'image', source: { type: 'base64', media_type: mediaTypeOf(abs), data } });
+        if (log)
+            log(`(attached ${name} — ${formatBytes(size)})`);
+    }
+    substitutions.sort((a, b) => b.index - a.index);
+    let text = message;
+    for (const s of substitutions) {
+        text = text.slice(0, s.index) + s.replacement + text.slice(s.index + s.length);
+    }
+    return { text: `${text}\n\n${IMAGE_PROMPT_NOTE}`, images };
+}
+/**
+ * The user message content sent to the model: the plain string when no image
+ * is attached (unchanged from before this feature), else images first, then
+ * the text — enrichment blocks stay in the text part.
+ */
+export function buildUserContent(text, images) {
+    if (images.length === 0)
+        return text;
+    return [...images, { type: 'text', text }];
+}
+/**
+ * Images stay in the conversation and are re-sent every turn. Past this
+ * many, the oldest are swapped for a short text note so a long session never
+ * hits the 32 MB request cap (and stops paying for stale screenshots).
+ */
+export const MAX_HISTORY_IMAGES = 10;
+/** Mutates `messages`; returns how many image blocks were removed. */
+export function trimHistoryImages(messages, max = MAX_HISTORY_IMAGES) {
+    const slots = [];
+    for (const m of messages) {
+        if (m.role !== 'user' || !Array.isArray(m.content))
+            continue;
+        m.content.forEach((b, i) => {
+            if (b?.type === 'image')
+                slots.push({ blocks: m.content, i });
+        });
+    }
+    const excess = slots.length - max;
+    for (let k = 0; k < excess; k++) {
+        const { blocks, i } = slots[k];
+        blocks[i] = { type: 'text', text: '[image removed from history]' };
+    }
+    return Math.max(0, excess);
+}

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

@@ -23,6 +23,7 @@ import { globalStore } from '../ui/sap-state-store.js';
 import { globalCredits } from '../cost/credits.js';
 import { printStatusFooter, formatStatusFooter } from '../renderer/status-footer.js';
 import { shouldUseInk } from '../renderer/tty.js';
+import { isUserPrompt } from '../session/user-prompt.js';
 export function snapshotTurnStart(session) {
     return {
         input: session.usage.input_tokens,
@@ -34,7 +35,7 @@ export function snapshotTurnStart(session) {
 }
 export function pushPostTurnStatus(params) {
     const { session, selectedAlias, snapshot, chunkEmitter, turnModel } = params;
-    const userTurns = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length;
+    const userTurns = session.messages.filter(isUserPrompt).length;
     const lifetimeTokensAfter = session.usage.input_tokens + session.usage.output_tokens;
     const lifetimeTokensBefore = snapshot.input + snapshot.output;
     const turnTokens = Math.max(0, lifetimeTokensAfter - lifetimeTokensBefore);

package/dist/repl.js

@@ -1014,6 +1014,10 @@ export async function runRepl(opts) {
                             // from regex, not the LLM, and surface the real cause.
                             chunkEmitter.emit('chunk', chalk.dim(`↪ [offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]\n`));
                         }
+                        if (c.screenshot) {
+                            chunkEmitter.emit('chunk', chalk.dim(`┄ Screenshot: ${c.screenshot}
+`));
+                        }
                         const decision = decideRouting(c);
                         // 2026-05-17 — pass the just-used skill so the picker can
                         // default cursor to it (one-Enter "continue" UX for follow-up
@@ -1376,11 +1380,18 @@ export async function runRepl(opts) {
                 });
             }
             catch (err) {
-                const { emitError } = await import('./ui/error-emitter.js');
-                emitError({
-                    code: 'RUN_TURN_ERROR',
-                    title: 'Turn failed',
-                    body: err.message,
+                // 2026-09-24 — print the turn-error block INTO the conversation (it
+                // stays on screen) instead of the overlay box that vanished after 5 s
+                // — a customer's dropped turn left no trace of what happened or what
+                // to do. Same block classic mode prints; in-session it leads with
+                // "type continue" (the partial turn is already saved).
+                const { renderTurnError } = await import('./agent/turn-error-ux.js');
+                await renderTurnError({
+                    err,
+                    session,
+                    userInterrupted: currentTurnAbort?.signal.aborted ?? false,
+                    inSession: true,
+                    print: (line) => chunkEmitter.emit('chunk', line + '\n'),
                 });
             }
             finally {
@@ -2577,6 +2588,8 @@ export async function runRepl(opts) {
                     if (c.offline) {
                         console.log(chalk.dim(`↪ [offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]`));
                     }
+                    if (c.screenshot)
+                        console.log(chalk.dim(`┄ Screenshot: ${c.screenshot}`));
                     const decision = decideRouting(c);
                     // 2026-05-17 — pass the just-used skill so the picker can
                     // default cursor to it. session.skill = immediately-previous
@@ -2936,6 +2949,7 @@ export async function runRepl(opts) {
                 err,
                 session,
                 userInterrupted: interruptedByUser,
+                inSession: true,
                 print: (line) => console.error(line),
             });
         }

package/dist/router/classifier.js

@@ -3,6 +3,8 @@ import { getStore } from '../auth/api-key.js';
 import { classify as classifyLocal } from '../classifier/client.js';
 import { SKILL_CATALOG, SKILL_ALIASES, resolveSkillAlias } from '../skill-catalog.js';
 import { isBuiltinCommandHead } from '../repl/builtin-commands.js';
+import { expandImageAttachments } from '../projects/image-attachments.js';
+import { expandImageChips } from '../ui/clipboard-image.js';
 // 8s — sized to cover the observed Fly cold-start (~3.2s on the 2026-05-20
 // probe) plus headroom for a slow network. Tighter values risk timing out
 // legitimate cold-start hits and burning the retry budget on the same.
@@ -25,7 +27,7 @@ function extractCause(err) {
     }
     return e.message;
 }
-async function tryFetchOnce(proxyUrl, key, prompt, context) {
+async function tryFetchOnce(proxyUrl, key, prompt, context, images = []) {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
     try {
@@ -35,7 +37,7 @@ async function tryFetchOnce(proxyUrl, key, prompt, context) {
                 'Authorization': `Bearer ${key}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ prompt, context }),
+            body: JSON.stringify(images.length > 0 ? { prompt, context, images } : { prompt, context }),
             signal: ctrl.signal,
         });
     }
@@ -43,7 +45,24 @@ async function tryFetchOnce(proxyUrl, key, prompt, context) {
         clearTimeout(timer);
     }
 }
-export async function classifyPrompt(prompt, context) {
+/**
+ * Screenshot-aware routing (2026-09-23): images in the prompt (pasted
+ * [Image #N] chips or image paths) go to the router so it reads the picture
+ * with the text. Any problem (too large, too many, unreadable) → classify on
+ * text; the turn itself reports the error when it runs.
+ */
+async function promptImages(prompt, cwd) {
+    try {
+        const r = await expandImageAttachments(expandImageChips(prompt), cwd);
+        if (r.error)
+            return [];
+        return r.images.map((im) => ({ media_type: im.source.media_type, data: im.source.data }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function classifyPrompt(prompt, context, opts = {}) {
     // D22/D35 structural invariant (2026-06-11) — an explicit slash command
     // must NEVER reach the classifier. The S3 battery proved the failure mode:
     // `/abap-plan <multiline>` failed the old parseShortcut regex, the whole
@@ -61,6 +80,7 @@ export async function classifyPrompt(prompt, context) {
     const key = await store.get();
     if (!key)
         throw new Error('no_api_key');
+    const images = await promptImages(prompt, opts.cwd ?? process.cwd());
     let r;
     let lastErr;
     // Two attempts total: the second masks the common case of a stale
@@ -71,7 +91,7 @@ export async function classifyPrompt(prompt, context) {
     // they bubble through as before.
     for (let attempt = 0; attempt < 2; attempt++) {
         try {
-            r = await tryFetchOnce(cfg.proxy_url, key, prompt, context);
+            r = await tryFetchOnce(cfg.proxy_url, key, prompt, context, images);
             break;
         }
         catch (err) {

package/dist/session/recap.js

@@ -26,6 +26,7 @@ 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';
 /** Wave-1 truncation rule (see /reroute): ≤60 chars total, '...' suffix. */
 function truncatePrompt(s) {
     return s.length > 60 ? s.slice(0, 57) + '...' : s;
@@ -37,10 +38,12 @@ function truncatePrompt(s) {
 export function buildRecap(session, cwd, opts) {
     const lines = [];
     // ── line 1: session orientation ─────────────────────────────────────────
-    // "User turns" = plain-string user messages (tool_result rounds are arrays)
-    // — same counting rule as the resume picker (session/store.ts).
-    const userMessages = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string');
-    const turns = userMessages.length;
+    // "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
+        .map(userPromptText)
+        .filter((t) => t !== null);
+    const turns = userTexts.length;
     if (turns === 0)
         return [];
     const skillLabel = session.skill ? `/${session.skill}` : 'no skill';
@@ -50,7 +53,7 @@ export function buildRecap(session, cwd, opts) {
     // rule as the picker's promptSnippet).
     let prompt = session.lastUserPrompt;
     if (!prompt) {
-        const last = userMessages[userMessages.length - 1].content;
+        const last = userTexts[userTexts.length - 1];
         prompt = last.replace(/<session_context>[\s\S]*?<\/session_context>\s*/g, '').trim() || null;
     }
     const quoted = prompt ? `"${truncatePrompt(prompt)}"` : '(no prompt)';

package/dist/session/resume.js

@@ -19,23 +19,15 @@ export async function runResume(id) {
             return b.lastTurnAt.localeCompare(a.lastTurnAt);
         });
         targetId = await select({
-            message: 'Pick a session to resume:',
-            choices: sorted.map((s) => {
-                const flag = s.interrupted ? chalk.yellow('⚠ ') : '  ';
-                const idCol = chalk.cyan(s.id.padEnd(8));
-                const timeCol = chalk.gray(formatTimeAgo(s.lastTurnAt).padEnd(10));
-                const sapCol = chalk.gray((s.sapSystem ?? '-').padEnd(8));
-                const skillCol = chalk.gray(`/${s.skill ?? '-'}`.padEnd(22));
-                const turns = chalk.gray(`${s.userTurnCount}t`.padStart(3));
-                const snippet = s.promptSnippet ?? chalk.dim('(no prompt)');
-                return {
-                    value: s.id,
-                    name: `${flag}${idCol} ${timeCol} ${sapCol} ${skillCol} ${turns}  ${snippet}`,
-                    description: s.interrupted
-                        ? `Interrupted (${s.interruptedReason ?? 'unknown'}) — type "continue" after resume`
-                        : `${s.userTurnCount} prior turn(s) — pick up from where you left off`,
-                };
-            }),
+            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`,
+            })),
         });
     }
     let session;
@@ -75,3 +67,31 @@ export async function runResume(id) {
     // to the persistence work in agent/loop.ts.
     return runRepl({ resumedSession: session });
 }
+// 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('⚠ ') : '  ';
+    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}`;
+}
+/**
+ * One dim line naming the row columns (2026-09-23 — rows had no labels). The
+ * picker draws a 2-char cursor gutter before each choice but not before the
+ * message, so the header adds it: gutter + flag = 4 leading spaces.
+ */
+export function formatSessionHeader() {
+    return chalk.dim('    ' +
+        [
+            'ID'.padEnd(W.id),
+            'LAST USED'.padEnd(W.time),
+            'SYSTEM'.padEnd(W.sap),
+            'SKILL'.padEnd(W.skill),
+            'TURNS'.padStart(W.turns),
+        ].join(' ') +
+        '  LAST PROMPT');
+}

package/dist/session/store.js

@@ -3,6 +3,7 @@ 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';
 export function makeSessionId() {
     return crypto.randomBytes(4).toString('hex');
 }
@@ -107,16 +108,17 @@ export async function listSessions(limit = 10) {
             let promptSnippet = null;
             for (let i = messages.length - 1; i >= 0; i--) {
                 const m = messages[i];
-                if (m && m.role === 'user' && typeof m.content === 'string') {
+                const text = m ? userPromptText(m) : null;
+                if (text !== null) {
                     // Strip <session_context>...</session_context> wrapper that the
                     // first turn injects, leaving only the user-typed prompt visible
                     // in the picker.
-                    const stripped = m.content.replace(/<session_context>[\s\S]*?<\/session_context>\s*/g, '').trim();
+                    const stripped = text.replace(/<session_context>[\s\S]*?<\/session_context>\s*/g, '').trim();
                     promptSnippet = (stripped || '<empty>').slice(0, 80);
                     break;
                 }
             }
-            const userTurnCount = messages.filter((m) => m?.role === 'user' && typeof m.content === 'string').length;
+            const userTurnCount = messages.filter((m) => m && isUserPrompt(m)).length;
             results.push({
                 id: parsed.id,
                 startedAt: parsed.started_at,

package/dist/session/user-prompt.js

@@ -0,0 +1,23 @@
+/**
+ * The prompt text of a user message: string content as-is, or the joined
+ * text blocks of array content that carries no tool_result. null for
+ * tool_result rounds, text-less arrays and non-user messages.
+ */
+export function userPromptText(m) {
+    if (m.role !== 'user')
+        return null;
+    if (typeof m.content === 'string')
+        return m.content;
+    if (!Array.isArray(m.content))
+        return null;
+    const blocks = m.content;
+    if (blocks.some((b) => b?.type === 'tool_result'))
+        return null;
+    const texts = blocks
+        .filter((b) => b?.type === 'text' && typeof b.text === 'string')
+        .map((b) => b.text);
+    return texts.length > 0 ? texts.join('\n') : null;
+}
+export function isUserPrompt(m) {
+    return userPromptText(m) !== null;
+}

package/dist/skills/bundled-skills.js

@@ -1,6 +1,6 @@
 // GENERATED FILE — bundled skills for local mode.
 // Source: https://manifest.cspeach.dev/v1.json
-// Generated: 2026-09-23T17:28:19.737Z
+// Generated: 2026-09-24T16:31:52.103Z
 // Manifest signature verified at build time.
 export const BUNDLED_SKILLS = {
     "abap-atc-fix": {

package/dist/ui/clipboard-image.js

@@ -0,0 +1,125 @@
+import { spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+let pasteDir = null;
+let nextNumber = 1;
+const pasted = new Map();
+function dir() {
+    if (!pasteDir)
+        pasteDir = path.join(cspeachRoot(), 'pasted', `${Date.now()}-${process.pid}`);
+    return pasteDir;
+}
+/** Test seam: point the paste folder at a temp dir and reset numbering. */
+export function __resetPastedImagesForTests(testDir) {
+    pasteDir = testDir;
+    nextNumber = 1;
+    pasted.clear();
+}
+/**
+ * Save the clipboard image and return its chip, or null when the clipboard
+ * holds no image (or the platform tool is missing / fails). Never throws —
+ * a paste key must never break the prompt.
+ */
+export async function pasteClipboardImage(reader = readClipboardImage) {
+    const n = nextNumber;
+    const out = path.join(dir(), `image-${n}.png`);
+    try {
+        await fs.mkdir(dir(), { recursive: true });
+        if (!(await reader(out)))
+            return null;
+        const st = await fs.stat(out);
+        if (st.size === 0)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    nextNumber = n + 1;
+    pasted.set(n, out);
+    return `[Image #${n}]`;
+}
+/** Swap each known `[Image #N]` chip for its quoted file path. */
+export function expandImageChips(text) {
+    if (pasted.size === 0)
+        return text;
+    return text.replace(/\[Image #(\d+)\]/g, (chip, num) => {
+        const file = pasted.get(Number(num));
+        return file ? `"${file}"` : chip;
+    });
+}
+/**
+ * The platform command that writes the clipboard image to `outPath`.
+ * Windows and macOS write the file themselves and print "ok"; Linux tools
+ * print the PNG bytes to stdout (`stdoutToFile`). null = unsupported.
+ */
+export function clipboardImageCommand(platform, outPath, env) {
+    if (platform === 'win32') {
+        const p = outPath.replace(/'/g, "''");
+        const script = 'Add-Type -AssemblyName System.Windows.Forms; Add-Type -AssemblyName System.Drawing; ' +
+            '$i = [System.Windows.Forms.Clipboard]::GetImage(); ' +
+            `if ($i -ne $null) { $i.Save('${p}', [System.Drawing.Imaging.ImageFormat]::Png); 'ok' }`;
+        return { cmd: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-STA', '-Command', script] };
+    }
+    if (platform === 'darwin') {
+        const p = outPath.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        return {
+            cmd: 'osascript',
+            args: [
+                '-e', 'try',
+                '-e', 'set d to the clipboard as «class PNGf»',
+                '-e', `set f to open for access POSIX file "${p}" with write permission`,
+                '-e', 'write d to f',
+                '-e', 'close access f',
+                '-e', 'return "ok"',
+                '-e', 'on error',
+                '-e', 'return "none"',
+                '-e', 'end try',
+            ],
+        };
+    }
+    if (platform === 'linux') {
+        return env.WAYLAND_DISPLAY
+            ? { cmd: 'wl-paste', args: ['--no-newline', '--type', 'image/png'], stdoutToFile: true }
+            : { cmd: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'], stdoutToFile: true };
+    }
+    return null;
+}
+/**
+ * Default reader: runs the platform command. stdin is CLOSED — Windows
+ * PowerShell 5.1 waits on an open stdin pipe and never exits (seen live
+ * 2026-09-23). 10 s ceiling covers a cold PowerShell start (~3 s; warm
+ * ~0.35 s).
+ */
+export async function readClipboardImage(outPath) {
+    const c = clipboardImageCommand(process.platform, outPath, process.env);
+    if (!c)
+        return false;
+    const stdout = await new Promise((resolve, reject) => {
+        const child = spawn(c.cmd, c.args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+        const chunks = [];
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error('clipboard read timed out'));
+        }, 10_000);
+        child.stdout.on('data', (d) => chunks.push(d));
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve(Buffer.concat(chunks));
+            else
+                reject(new Error(`${c.cmd} exited ${code}`));
+        });
+    });
+    if (c.stdoutToFile) {
+        if (stdout.length === 0)
+            return false;
+        await fs.writeFile(outPath, stdout);
+        return true;
+    }
+    return stdout.toString('utf8').trim() === 'ok';
+}

package/dist/ui/footer.js

@@ -5,6 +5,7 @@ import { Box, Text, useInput, useStdout } from 'ink';
 // ink-text-input — multi-chunk pastes were losing every chunk but the
 // last (stale-prop closure in the upstream component). See text-input.tsx.
 import TextInput from './text-input.js';
+import { pasteClipboardImage } from './clipboard-image.js';
 import Fuse from 'fuse.js';
 // Task 8 (ux-wave1) — persistence lives in the shared writer (one file,
 // one dedup guard for the Footer, Ink handleSubmit, and classic readline).
@@ -194,6 +195,15 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
         }
         onSubmit(line.trim());
     }, [onSubmit, onSlashTrigger, onHistoryTrigger, history, updateBuffer]);
+    // Claude Code-style image paste (2026-09-23): Ctrl+V / Alt+V saves the
+    // clipboard image and returns an [Image #N] chip; the turn loop swaps the
+    // chip for the file path before the image attachment step.
+    const handlePasteImage = useCallback(async () => {
+        const chip = await pasteClipboardImage();
+        if (!chip)
+            onNotice?.('no image on the clipboard');
+        return chip;
+    }, [onNotice]);
     if (fuzzyMode) {
         return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "History search (Ctrl+R)" }), _jsx(TextInput, { value: fuzzyQuery, onChange: setFuzzyQuery, placeholder: "type to search...", maxDisplayWidth: Math.max(8, columns - 5) }), fuzzyResults.map((r, i) => (_jsx(Text, { dimColor: i > 0, wrap: "truncate-end", children: flattenHistoryEntry(r) }, i))), _jsx(Text, { dimColor: true, children: "Esc: cancel  Enter: select" })] }));
     }
@@ -205,5 +215,5 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
     if (disabled) {
         return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: PROMPT }), _jsx(Text, { dimColor: true, children: "(answer above to continue)" })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [buffer.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [buffer.length > HELD_LINES_SHOWN && (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2026 ", buffer.length - HELD_LINES_SHOWN, " earlier line", buffer.length - HELD_LINES_SHOWN === 1 ? '' : 's'] })), buffer.slice(-HELD_LINES_SHOWN).map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['│ ', line] }, `held-${buffer.length}-${i}`))), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [buffer.length, " line", buffer.length === 1 ? '' : 's', " pending \u2014 Enter sends all, Esc discards, \\ continues"] })] })), _jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: PROMPT }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSubmit, onPasteLines: handlePasteLines, maxDisplayWidth: inputBudget })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [buffer.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [buffer.length > HELD_LINES_SHOWN && (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2026 ", buffer.length - HELD_LINES_SHOWN, " earlier line", buffer.length - HELD_LINES_SHOWN === 1 ? '' : 's'] })), buffer.slice(-HELD_LINES_SHOWN).map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['│ ', line] }, `held-${buffer.length}-${i}`))), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [buffer.length, " line", buffer.length === 1 ? '' : 's', " pending \u2014 Enter sends all, Esc discards, \\ continues"] })] })), _jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: PROMPT }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSubmit, onPasteLines: handlePasteLines, onPasteImage: handlePasteImage, maxDisplayWidth: inputBudget })] })] }));
 }

package/dist/ui/text-input.js

@@ -27,6 +27,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useState, useEffect, useRef } from 'react';
 import { Text, useInput } from 'ink';
 import chalk from 'chalk';
+/** An image chip ending exactly at the cursor — Backspace removes it whole. */
+const CHIP_BEFORE_CURSOR = /\[Image #\d+\]$/;
 /**
  * Pure windowing core (exported for tests). Given the value length, the
  * cursor position, the display budget (character cells) and whether the
@@ -48,7 +50,7 @@ export function computeDisplayWindow(valueLength, cursorOffset, budget, cursorVi
     const end = Math.min(valueLength, start + budget);
     return { start, end };
 }
-export function PasteSafeTextInput({ value: originalValue, placeholder = '', focus = true, mask, showCursor = true, onChange, onSubmit, onPasteLines, maxDisplayWidth, }) {
+export function PasteSafeTextInput({ value: originalValue, placeholder = '', focus = true, mask, showCursor = true, onChange, onSubmit, onPasteLines, maxDisplayWidth, onPasteImage, }) {
     const [cursorOffset, setCursorOffset] = useState((originalValue || '').length);
     // The paste-safety core: synchronous mirrors of value + cursor. The
     // input handler reads/writes THESE, never the (possibly stale) props.
@@ -129,6 +131,23 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
             (key.shift && key.tab)) {
             return;
         }
+        if (onPasteImage && input === 'v' && (key.ctrl || key.meta)) {
+            void onPasteImage().then((chip) => {
+                if (!chip)
+                    return;
+                // Resolves after the clipboard read — insert at the cursor as it
+                // is NOW, through the same synchronous mirrors as a keystroke.
+                const cur = valueRef.current;
+                const at = cursorRef.current;
+                const next = cur.slice(0, at) + chip + cur.slice(at);
+                valueRef.current = next;
+                cursorRef.current = at + chip.length;
+                setCursorOffset(at + chip.length);
+                pendingEchoes.current.push(next);
+                onChange(next);
+            });
+            return;
+        }
         if (key.return) {
             // valueRef (not the prop) — so an Enter in the same stdin drain as
             // the paste tail submits the complete line.
@@ -151,7 +170,16 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
                 nextCursorOffset++;
         }
         else if (key.backspace || key.delete) {
-            if (cursorRef.current > 0) {
+            const chip = onPasteImage
+                ? CHIP_BEFORE_CURSOR.exec(currentValue.slice(0, cursorRef.current))
+                : null;
+            if (chip) {
+                nextValue =
+                    currentValue.slice(0, cursorRef.current - chip[0].length) +
+                        currentValue.slice(cursorRef.current);
+                nextCursorOffset -= chip[0].length;
+            }
+            else if (cursorRef.current > 0) {
                 nextValue =
                     currentValue.slice(0, cursorRef.current - 1) +
                         currentValue.slice(cursorRef.current, currentValue.length);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.15",
-  "description": "CSPeach \u2014 AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
+  "version": "1.1.17",
+  "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",
     "sap",
@@ -32,7 +32,7 @@
     "prebuild": "tsx scripts/prebuild.ts",
     "build": "tsc && node scripts/make-bin-executable.js",
     "install:global": "tsx scripts/install-global.ts",
-    "pretest": "tsx scripts/sync-signing-key.ts || node -e \"console.warn('WARN: sync-signing-key skipped \u2014 using stub')\"",
+    "pretest": "tsx scripts/sync-signing-key.ts || node -e \"console.warn('WARN: sync-signing-key skipped — using stub')\"",
     "start": "node dist/index.js",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
@@ -44,7 +44,7 @@
     "bench:audit": "tsx scripts/bench-audit-task.ts",
     "fiori": "tsx src/tools/fiori/bin.ts",
     "prepare": "husky",
-    "prepublishOnly": "node -e \"const deps=require('./package.json').dependencies||{}; for (const n of ['@cspeach/sap-client','@cspeach/register-core']) { const d=deps[n]||''; if(d.startsWith('file:')||d.startsWith('link:')){console.error('publish blocked: '+n+' is a local link ('+d+') \u2014 point it at the published version before npm publish'); process.exit(1)} }\""
+    "prepublishOnly": "node -e \"const deps=require('./package.json').dependencies||{}; for (const n of ['@cspeach/sap-client','@cspeach/register-core']) { const d=deps[n]||''; if(d.startsWith('file:')||d.startsWith('link:')){console.error('publish blocked: '+n+' is a local link ('+d+') — point it at the published version before npm publish'); process.exit(1)} }\""
   },
   "engines": {
     "node": ">=20.0.0"