@cspeach/cli 0.9.0 → 1.1.0

package/dist/renderer/notices.js

@@ -0,0 +1,64 @@
+/**
+ * Notice rendering — the 'warn' / 'info' side-channel (battery B2 fix).
+ *
+ * Tool handlers emit user-facing notices on the SAME EventEmitter that
+ * carries 'chunk' stream data:
+ *
+ *   ctx.chunkEmitter?.emit('warn', msg)   — user-actionable notices
+ *                                           (e.g. "ignoring transport=X,
+ *                                           object locked in Y")
+ *   ctx.chunkEmitter?.emit('info', msg)   — dim, non-fatal diagnostics
+ *                                           (e.g. "snapshot ✓", lookup
+ *                                           fallback traces)
+ *
+ * Before this module existed those events were NO-OPS in the live REPL:
+ * the Ink Body only consumed 'chunk', and the classic/one-shot paths never
+ * put a chunkEmitter on the ToolContext at all. resolveWriteTransport's
+ * carefully-worded Rule 9 notices (D15/D20) were invisible.
+ *
+ * Two consumers, one formatter:
+ *   - Ink:      ui/body.tsx subscribes 'warn'/'info' and pushes
+ *                formatNoticeLine(...) through the SAME chunk batcher, so
+ *                ordering relative to surrounding chunks is preserved.
+ *   - classic / one-shot: createClassicOutputEmitter() returns an emitter
+ *                whose listeners write straight to stdout. repl.tsx
+ *                (classic branch) and one-shot.ts put it on ctx.chunkEmitter.
+ *
+ * Deliberately NOT wired for subagents (tools/subagent/agent_run.ts):
+ * their ctx.chunkEmitter stays undefined so child-turn notices remain
+ * muted — exactly the pre-existing contract pinned in agent_run.test.ts.
+ */
+import chalk from 'chalk';
+import { EventEmitter } from 'node:events';
+/**
+ * Format one notice as a single terminal line (trailing newline included).
+ * Multi-line messages are collapsed to one line — notices are glanceable
+ * margin notes, not documents; anything long belongs in the tool result.
+ *
+ *   warn → yellow  "  ⚠ message"
+ *   info → dim     "  · message"
+ */
+export function formatNoticeLine(level, message) {
+    const oneLine = message.replace(/\s*\r?\n\s*/g, ' ').trim();
+    if (level === 'warn')
+        return chalk.yellow(`  ⚠ ${oneLine}`) + '\n';
+    return chalk.dim(`  · ${oneLine}`) + '\n';
+}
+/**
+ * Build the output emitter for the NON-Ink paths (classic REPL, one-shot).
+ *
+ * Listeners:
+ *   'chunk' → written verbatim (already-formatted stream text — e.g. the
+ *             verify-chain line emitted by write tools)
+ *   'warn'  → formatNoticeLine('warn', …)
+ *   'info'  → formatNoticeLine('info', …)
+ *
+ * The `write` sink defaults to process.stdout — injectable for tests.
+ */
+export function createClassicOutputEmitter(write = (s) => process.stdout.write(s)) {
+    const emitter = new EventEmitter();
+    emitter.on('chunk', (s) => write(s));
+    emitter.on('warn', (msg) => write(formatNoticeLine('warn', msg)));
+    emitter.on('info', (msg) => write(formatNoticeLine('info', msg)));
+    return emitter;
+}

package/dist/renderer/progress-chatter.js

@@ -92,6 +92,10 @@ const MESSAGES = {
         'Reserving a transport request…',
         'Asking SAP for a fresh TR…',
     ],
+    sap_transport_for_object: [
+        'Checking who owns {object_name}…',
+        'Looking for an owning transport…',
+    ],
     sap_transport_list: [
         'Listing open transports…',
         'Finding modifiable TRs…',
@@ -156,6 +160,10 @@ const MESSAGES = {
         'Publishing service binding…',
         'Asking SAP to expose the OData endpoint…',
     ],
+    sap_service_binding_unpublish: [
+        'Unpublishing service binding…',
+        'Asking SAP to remove the OData endpoint…',
+    ],
 };
 const FALLBACK_MESSAGES = [
     'Working on it…',

package/dist/renderer/status-footer.js

@@ -40,7 +40,7 @@ export const LARGE_SESSION_THRESHOLD = 100_000;
  * direct stdout (which would corrupt the live Ink frame).
  */
 export function formatStatusFooter(params) {
-    const { sessionId, sapAlias, skill, turnCount, tokens, cachedTokens, elapsedMs, costThisTurn, costSession, sessionInputTokens } = params;
+    const { sessionId, sapAlias, skill, turnCount, tokens, cachedTokens, elapsedMs, costThisTurn, costSession, sessionInputTokens, variant } = params;
     const shortSession = sessionId.slice(0, 8);
     const skillDisplay = skill.startsWith('/') ? skill : `/${skill}`;
     const turns = `${turnCount} turn${turnCount === 1 ? '' : 's'}`;
@@ -49,17 +49,27 @@ export function formatStatusFooter(params) {
     const elapsed = elapsedMs > 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : '';
     const costTurnStr = costThisTurn != null ? formatCost(costThisTurn) : '';
     const costSessStr = costSession != null ? `session: ${formatCost(costSession)}` : '';
-    const parts = [
-        chalk.dim(`session ${shortSession}`),
-        chalk.dim(sapAlias),
-        chalk.dim(skillDisplay),
-        chalk.dim(turns),
-        chalk.dim(tokStr),
-        ...(costTurnStr ? [chalk.dim(costTurnStr)] : []),
-        ...(cachedStr ? [chalk.dim(cachedStr)] : []),
-        ...(costSessStr ? [chalk.dim(costSessStr)] : []),
-        ...(elapsed ? [chalk.dim(elapsed)] : []),
-    ];
+    // Ink turn-receipt (see the variant doc on StatusFooterParams):
+    // turn-only facts — everything session-scoped lives in <StatusLine />.
+    const parts = variant === 'turn'
+        ? [
+            chalk.dim(skillDisplay),
+            chalk.dim(turns),
+            chalk.dim(tokStr),
+            ...(costTurnStr ? [chalk.dim(costTurnStr)] : []),
+            ...(elapsed ? [chalk.dim(elapsed)] : []),
+        ]
+        : [
+            chalk.dim(`session ${shortSession}`),
+            chalk.dim(sapAlias),
+            chalk.dim(skillDisplay),
+            chalk.dim(turns),
+            chalk.dim(tokStr),
+            ...(costTurnStr ? [chalk.dim(costTurnStr)] : []),
+            ...(cachedStr ? [chalk.dim(cachedStr)] : []),
+            ...(costSessStr ? [chalk.dim(costSessStr)] : []),
+            ...(elapsed ? [chalk.dim(elapsed)] : []),
+        ];
     const lines = ['', RULE, ' ' + parts.join(chalk.dim(' │ '))];
     if (sessionInputTokens != null && sessionInputTokens >= LARGE_SESSION_THRESHOLD) {
         lines.push(' ' + chalk.yellow(`⚠  session getting large (${sessionInputTokens.toLocaleString()} input tokens)`

package/dist/renderer/thinking-heartbeat.js

@@ -48,24 +48,67 @@ const GENERIC_SUFFIXES = [
     { at: 120_000, suffix: ' (2m — still running; Ctrl+C aborts the turn)' },
     { at: 300_000, suffix: ' (5m — likely stuck; Ctrl+C and check the VPN)' },
 ];
+/**
+ * 2026-07-06 (audit-timeout) — the plan-chain audit's own liveness schedule.
+ *
+ * The audit is a PROXY model call (api.cspeach.dev over the internet), NOT a
+ * SAP tool call, so the generic schedule's "check the VPN" 5m copy is a WRONG
+ * diagnosis (the VPN is only for SAP). It is also now bounded: runPhaseAudit
+ * enforces a 120s hard deadline PER attempt × 3 attempts, so the whole audit
+ * can never exceed ~6m before it returns infra_failed — no infinite hang. This
+ * schedule reflects that reality honestly: past 2m the audit is necessarily in
+ * a retry (a single attempt hard-stops at 120s), and there is nothing to check
+ * — it either recovers on the next attempt or returns infra_failed. The
+ * per-attempt transition ("[audit] attempt N of 3 (previous timed out)") is
+ * printed separately by plan-chain via runPhaseAudit's onRetry hook.
+ */
+export const AUDIT_HEARTBEAT_THRESHOLDS = [
+    { at: 3_000, label: '[audit] …running' },
+    { at: 10_000, label: '[audit] …running (10s)' },
+    { at: 30_000, label: '[audit] …running (30s)' },
+    { at: 60_000, label: '[audit] …running (60s — still running, large evidence can take a while)' },
+    { at: 120_000, label: '[audit] …running (2m — still running; large evidence can take a while · Ctrl+C aborts the turn)' },
+    { at: 240_000, label: '[audit] …running (4m — a prior attempt timed out; retrying · Ctrl+C aborts the turn)' },
+    { at: 300_000, label: '[audit] …running (5m — nearly at the retry ceiling; will stop and re-audit on resume if it can\'t finish)' },
+];
 export function startThinkingHeartbeat(opts) {
     const startedAt = Date.now();
     let nextIdx = 0;
     let stopped = false;
-    const THRESHOLDS_MS = opts?.label
-        ? GENERIC_SUFFIXES.map((t) => ({ at: t.at, label: `${opts.label}${t.suffix}` }))
-        : LLM_THRESHOLDS;
+    // Precedence: an explicit `thresholds` schedule (audit) wins over the
+    // `label` generic-suffix path, which wins over the default LLM schedule.
+    const THRESHOLDS_MS = opts?.thresholds
+        ? opts.thresholds
+        : opts?.label
+            ? GENERIC_SUFFIXES.map((t) => ({ at: t.at, label: `${opts.label}${t.suffix}` }))
+            : LLM_THRESHOLDS;
+    /**
+     * Receives the styled label WITHOUT a newline. Fable review (2026-07-05,
+     * audit-reverify item 1): the newline used to be baked INSIDE the chalk
+     * argument — with color enabled (FORCE_COLOR / real terminals) chalk
+     * appends its closing style codes AFTER the embedded `\n`, so the sink
+     * branch's trailing-`\n` strip was a no-op and every tick rendered an
+     * extra blank line. The label is now styled alone and each branch owns
+     * its own termination: sink = none (the caller terminates), chunkEmitter /
+     * stdout = a plain `\n` appended after the styled text (byte-identical to
+     * before under no-color; under color the closing style code now correctly
+     * precedes the newline).
+     */
     const emitLine = (line) => {
-        if (opts?.chunkEmitter) {
+        if (opts?.emit) {
+            // Custom sink (e.g. plan-chain's args.log) owns line termination.
+            opts.emit(line);
+        }
+        else if (opts?.chunkEmitter) {
             // Phase A #4 — route through Ink's chunk pipeline. The Body
             // component's reducer treats this like any other model chunk and
             // appends it as a node, so the heartbeat lives inside the React
             // render tree and survives subsequent renders.
-            opts.chunkEmitter.emit('chunk', line);
+            opts.chunkEmitter.emit('chunk', line + '\n');
         }
         else {
             // Classic mode — direct stdout, plain newline-terminated line.
-            process.stdout.write(line);
+            process.stdout.write(line + '\n');
         }
     };
     const tick = () => {
@@ -74,8 +117,21 @@ export function startThinkingHeartbeat(opts) {
         const elapsed = Date.now() - startedAt;
         while (nextIdx < THRESHOLDS_MS.length && THRESHOLDS_MS[nextIdx].at <= elapsed) {
             const t = THRESHOLDS_MS[nextIdx];
-            // Indent by 2 spaces to align with tool-call rows.
-            emitLine(chalk.dim(`  ${t.label}\n`));
+            // audit-lean FIX #2 — a dynamic suffix (e.g. the live token count),
+            // evaluated NOW so a stall shows a different number from progress.
+            // Defensive: observability must never break the liveness tick.
+            let suffix = '';
+            if (opts?.suffix) {
+                try {
+                    suffix = opts.suffix();
+                }
+                catch {
+                    suffix = '';
+                }
+            }
+            // Indent by 2 spaces to align with tool-call rows. Style ONLY the
+            // label (+ suffix) — never a newline inside the chalk call (see emitLine).
+            emitLine(chalk.dim(`  ${t.label}${suffix}`));
             nextIdx++;
         }
     };

package/dist/renderer/todo-block.js

@@ -0,0 +1,51 @@
+/**
+ * todo_set transcript block — UX Wave 2 follow-up (CC-style checklist).
+ *
+ * Owner feedback (2026-07): "it's not like we have in Claude Code — only
+ * shows the phase it's working on with an arrow." The turn-status strip
+ * (single ▶ row) and the Ctrl+T panel are both by-design; what was missing
+ * was Claude Code's behaviour of dropping the FULL checklist into the
+ * scrollback transcript on every todo_set, so the user sees the whole plan
+ * advance in place rather than a raw `⏺ todo_set({...})` JSON line.
+ *
+ * This module is the pure formatter for that block. todo.ts emits the
+ * returned string as a `chunk` on ctx.chunkEmitter after a successful set
+ * (routes to Ink Static scrollback AND the classic 'chunk'→stdout path);
+ * the raw ⏺/⎿ todo_set rows are widget-suppressed (tool-widget.ts) so the
+ * block is the sole visible representation — exactly mirroring ask_question.
+ *
+ * House style follows todo-panel.tsx glyphs precisely so the transcript
+ * block and the Ctrl+T panel read as the same list:
+ *   ▣ completed   (dim)
+ *   ▶ in_progress (peach, bold)
+ *   □ pending     (default)
+ * Every row is truncate-end (Wave-1 rule — no soft-wrap), preceded by a
+ * slim `Tasks (done/total done)` header.
+ */
+import chalk from 'chalk';
+import { PEACH } from './banners.js';
+/** Max visible width of a row's TEXT (after the 2-char glyph+space prefix).
+ *  72-col total matches the Ctrl+T panel width; 70 leaves room for `▶ `. */
+export const TODO_BLOCK_TEXT_MAX = 70;
+function truncateEnd(s, max) {
+    return s.length > max ? s.substring(0, max - 1) + '…' : s;
+}
+/**
+ * Render the checklist as a scrollback block (leading + trailing newline for
+ * separation from surrounding transcript content). Returns ANSI-coloured
+ * text ready to emit as a `chunk`.
+ */
+export function formatTodoChecklistBlock(todos) {
+    const done = todos.filter((t) => t.status === 'completed').length;
+    const total = todos.length;
+    const header = chalk.dim(`Tasks (${done}/${total} done)`);
+    const rows = todos.map((t) => {
+        const text = truncateEnd(t.text, TODO_BLOCK_TEXT_MAX);
+        if (t.status === 'completed')
+            return chalk.dim(`▣ ${text}`);
+        if (t.status === 'in_progress')
+            return chalk.hex(PEACH).bold(`▶ ${text}`);
+        return `□ ${text}`;
+    });
+    return '\n' + [header, ...rows].join('\n') + '\n';
+}

package/dist/renderer/tool-widget.js

@@ -21,6 +21,31 @@ import { PEACH } from './banners.js';
  *   - No cyan, no rainbow, no boxes.
  */
 const peach = (s) => chalk.hex(PEACH)(s);
+/**
+ * Widget-representation de-clutter (2026-07): tools whose OWN rendering IS
+ * the visible representation, making the generic ⏺ dispatch line (with its
+ * raw JSON args) and the SUCCESS ⎿ result line pure scrollback noise. For
+ * these the ⏺ top line and the success ⎿ row are suppressed; ERROR ⎿ rows
+ * still render (the ✗ row is the only trace of a failed call). The agent
+ * loop also skips the tool spinner for these (it would orphan without its
+ * ⏺ line).
+ *
+ * Members:
+ *   - ask_question: the Ink form / modal (or the classic console.log
+ *     question text) is the representation. Classic mode is unaffected in
+ *     the ways that matter — the v1 path prints its question via
+ *     console.log and the v2 classic path prints its `form i/n · header`
+ *     blocks, neither of which goes through these renderers.
+ *   - todo_set: the handler emits a CC-style checklist block into the
+ *     transcript (renderer/todo-block.ts) on every successful set — that
+ *     block is the representation, so the raw `⏺ todo_set({"todos":[…])`
+ *     line + ⎿ JSON result are suppressed. Owner feedback drove this: the
+ *     transcript should show the full checklist, not a JSON tool line.
+ */
+const WIDGET_SUPPRESSED_TOOLS = new Set(['ask_question', 'todo_set']);
+export function isWidgetSuppressedTool(name) {
+    return WIDGET_SUPPRESSED_TOOLS.has(name);
+}
 const ARG_SUMMARY_MAX = 64;
 // 2026-05-15 (bug 1): widened from 96 → 240 so a parsed ADT exception
 // message ("CTS_WBO_API/047: Request S4HK903388 is not a local request"
@@ -55,13 +80,17 @@ export function clearActiveSpinner() {
 }
 export function renderToolCallTop(params) {
     const { name, args, chunkEmitter } = params;
+    // Ask-form de-clutter: the form/modal IS the visible representation —
+    // no ⏺ dispatch line (with its raw JSON args) belongs in scrollback.
+    if (isWidgetSuppressedTool(name))
+        return;
     const write = (s) => {
         if (chunkEmitter)
             chunkEmitter.emit('chunk', s);
         else
             process.stdout.write(s);
     };
-    const summary = argSummary(name, args);
+    const summary = summariseToolArgs(name, args);
     const wrapped = summary ? chalk.gray('(') + chalk.gray(summary) + chalk.gray(')') : '';
     const line = `${peach('⏺')} ${chalk.bold(name)}${wrapped}`;
     write('\n' + line + '\n');
@@ -136,7 +165,15 @@ function startSpinnerWithVerbs(params, verbs, defaultVerb) {
     return { stop: stopFn };
 }
 export function renderToolCallBottom(params) {
-    const { durationMs, isError, resultSummary, chunkEmitter } = params;
+    const { durationMs, isError, resultSummary, chunkEmitter, name, args } = params;
+    // Ask-form de-clutter: paired with the top-line suppression — on SUCCESS
+    // the answer already came back through the form; a ⎿ row would be noise.
+    // ERRORS still render (review fix): an ask_form_invalid /
+    // ask_question_invalid round never mounts a form, so without the ✗ row
+    // the turn would stall silently with nothing in scrollback. D29 made the
+    // bottom row self-identifying (name + args), so no orphan risk.
+    if (name && isWidgetSuppressedTool(name) && !isError)
+        return;
     const write = (s) => {
         if (chunkEmitter)
             chunkEmitter.emit('chunk', s);
@@ -144,15 +181,26 @@ export function renderToolCallBottom(params) {
             process.stdout.write(s);
     };
     const icon = isError ? chalk.red('✗') : chalk.green('✓');
+    // Label: plain (not bold — the top line keeps visual primacy) name +
+    // dim arg summary, mirroring the top-line shape so orphaned rows still
+    // read as "which tool, on what object".
+    let label = '';
+    if (name) {
+        const summary = summariseToolArgs(name, args ?? {});
+        const wrapped = summary ? chalk.gray('(') + chalk.gray(summary) + chalk.gray(')') : '';
+        label = ` ${name}${wrapped}`;
+    }
     const detailRaw = resultSummary ? truncate(resultSummary, RESULT_SUMMARY_MAX) : '';
     const detail = detailRaw
         ? (isError ? chalk.red(detailRaw) : chalk.gray(detailRaw))
         : '';
     const timing = chalk.dim(formatDuration(durationMs));
     const sep = chalk.dim('·');
-    let line = `  ${peach('⎿')} ${icon}`;
+    let line = `  ${peach('⎿')} ${icon}${label}`;
     if (detail)
         line += ` ${detail} ${sep} ${timing}`;
+    else if (label)
+        line += ` ${sep} ${timing}`;
     else
         line += ` ${timing}`;
     write(line + '\n');
@@ -162,8 +210,11 @@ export function renderToolCallBottom(params) {
  * arguments. Per-tool aware: pulls LLM-supplied summary first, then the
  * common (name, type, package) triple, then specific keys for known tools.
  * Falls back to a truncated JSON dump.
+ *
+ * Exported (D29) so the bottom result row can self-identify with the same
+ * summary the top line used.
  */
-function argSummary(toolName, args) {
+export function summariseToolArgs(toolName, args) {
     if (!args || Object.keys(args).length === 0)
         return '';
     const a = args;

package/dist/renderer/tty.js

@@ -25,6 +25,36 @@ export function setRenderingOverride(mode) {
 export function getRenderingOverride() {
     return renderingOverride;
 }
+/**
+ * B5 (2026-06-11) — headless answer policy signal.
+ *
+ * "Headless" means NO human can answer a prompt: stdin will never deliver
+ * an answer, so any inquirer/readline wait blocks forever (battery S2 Pass A
+ * stalled on exactly this — defect D1). Consumers (ask_question, the save
+ * hook, request_approval) branch to auto-answer / fail-fast policies instead
+ * of prompting.
+ *
+ * Decision order:
+ *   1. Explicit override — runOneShot() sets `true` at startup because
+ *      one-shot is a single non-interactive turn by design (CI parity:
+ *      the same invocation must behave identically piped or from a
+ *      terminal). Tests set/clear it directly.
+ *   2. Fallback — stdin is not a TTY. Covers piped/redirected invocations
+ *      that never went through runOneShot. stdin (not stdout) is the right
+ *      floor: prompts BLOCK on stdin; piping only stdout still leaves a
+ *      human able to answer.
+ */
+let headlessOverride = null;
+/** Set (or clear with null) the explicit headless override. */
+export function setHeadlessOverride(v) {
+    headlessOverride = v;
+}
+/** True when no human can answer prompts — see setHeadlessOverride. */
+export function isHeadless() {
+    if (headlessOverride !== null)
+        return headlessOverride;
+    return process.stdin.isTTY !== true;
+}
 /**
  * True when the Ink UI frame should be mounted.
  *
@@ -32,8 +62,17 @@ export function getRenderingOverride() {
  *   1. If override === 'classic', never use Ink (explicit opt-out)
  *   2. If override === 'ink', use Ink when a TTY is available; otherwise
  *      fall back — Ink cannot render on a pipe regardless of user preference
- *   3. If override === 'auto' (default), use Ink when interactive TTY +
- *      not one-shot + CI=unset
+ *   3. If override === 'auto' (default), use Ink when interactive TTY on
+ *      BOTH stdout and stdin + not one-shot + CI=unset
+ *
+ * UX-5 review C1 (2026-06-12): the auto branch must also require
+ * `process.stdin.isTTY` — Ink mounts raw-mode key handling on stdin, and a
+ * piped stdin (`"/cost`n/exit" | cspeach`) cannot enter raw mode. Worse,
+ * mounting Ink there bypassed the classic loop's early-line buffer
+ * (UX-5 #5), so every piped line was dropped. Piped-stdin invocations now
+ * take the classic path even when stdout is a terminal. The explicit
+ * `ui.rendering = 'ink'` override (branch 2) deliberately keeps its
+ * stdout-only floor — that's the user's explicit choice.
  *
  * v0.3+: pipeline.ts and approvals/render.ts branch on this.
  */
@@ -42,8 +81,8 @@ export function shouldUseInk() {
         return false;
     if (renderingOverride === 'ink')
         return isTTY();
-    // auto
-    return isTTY() && !isOneShot() && !process.env['CI'];
+    // auto — stdin must be a TTY too (raw-mode capable, no piped lines to drop)
+    return isTTY() && process.stdin.isTTY === true && !isOneShot() && !process.env['CI'];
 }
 /**
  * Stub for v0.3 Windows ConPTY / CI TTY hinting.

package/dist/renderer/verify-chain.js

@@ -0,0 +1,77 @@
+/**
+ * Verify-chain line — one compact row per completed SAP write summarizing
+ * the Forge-Rule pipeline the tool actually ran (tour slide-7 alignment):
+ *
+ *   ① snapshot ✓ ② written ✓ ③ syntax ✓ ④ activate pending
+ *
+ * HONESTY CONTRACT: every segment is derived from the tool's real result —
+ * never synthesized. States render truthfully:
+ *   - snapshot 'new_object'  → "① snapshot – (new object)" (genuine ADT 404 —
+ *     nothing to save; NEVER used for other read failures)
+ *   - snapshot 'source_read_failed' → "① snapshot – (no source read: <msg>)" —
+ *     the pre-write read failed for a non-404 reason; the object may exist
+ *     but there is no recovery copy. Hard-gate tools block instead of
+ *     emitting this; it only appears on soft (best-effort) gates.
+ *   - snapshot 'best_effort_failed' → "① snapshot – (skipped)" (write tools
+ *     where the gate is soft, e.g. class includes)
+ *   - syntax fail → "③ syntax ✗ (L12: MESSAGE …)" AND no ④ at all —
+ *     activation is blocked, so we don't show a fake pending step
+ *   - syntax 'not_checked' → "③ syntax – (checked at activation)" —
+ *     sap_set_class_include has no standalone syntax gate
+ *   - ④ is always 'pending', never '✓': activation is a SEPARATE tool call
+ *     (sap_activate); these write tools never activate.
+ *
+ * Consumed by the write tools in tools/sap-write.ts, emitted on the
+ * 'chunk' channel so it lands between the ⏺ dispatch line and the ⎿
+ * result row in both renderers.
+ */
+import chalk from 'chalk';
+const pass = (s) => `${s} ${chalk.green('✓')}`;
+const fail = (s, detail) => `${s} ${chalk.red('✗')}${detail ? ' ' + chalk.red(`(${detail})`) : ''}`;
+const skip = (s, why) => chalk.dim(`${s} – (${why})`);
+const ERROR_DETAIL_MAX = 60;
+const SNAPSHOT_DETAIL_MAX = 40;
+const truncate = (s, max) => {
+    const flat = s.replace(/\s+/g, ' ').trim();
+    return flat.length > max ? flat.substring(0, max - 1) + '…' : flat;
+};
+/**
+ * Build the chain line (no trailing newline). Returns the full line
+ * including the two-space indent that aligns with the ⎿ result row.
+ */
+export function buildWriteChainLine(input) {
+    const parts = [];
+    // ① snapshot
+    if (input.snapshot === 'taken')
+        parts.push(pass('① snapshot'));
+    else if (input.snapshot === 'new_object')
+        parts.push(skip('① snapshot', 'new object'));
+    else if (input.snapshot === 'source_read_failed') {
+        // Honest: the read failed — we do NOT know the object is new, and there
+        // is no recovery copy. Never render this as "(new object)".
+        const why = input.snapshotDetail
+            ? `no source read: ${truncate(input.snapshotDetail, SNAPSHOT_DETAIL_MAX)}`
+            : 'no source read';
+        parts.push(skip('① snapshot', why));
+    }
+    else
+        parts.push(skip('① snapshot', 'skipped'));
+    // ② written
+    parts.push(input.written ? pass('② written') : fail('② written'));
+    // ③ syntax (+ ④ activate, which only exists when activation is possible)
+    if (input.syntax === 'not_checked') {
+        parts.push(skip('③ syntax', 'checked at activation'));
+        parts.push(chalk.dim('④ activate pending'));
+    }
+    else if (input.syntax.ok) {
+        parts.push(pass('③ syntax'));
+        parts.push(chalk.dim('④ activate pending'));
+    }
+    else {
+        const first = (input.syntax.errors[0] ?? 'syntax errors').replace(/\s+/g, ' ').trim();
+        const detail = first.length > ERROR_DETAIL_MAX ? first.substring(0, ERROR_DETAIL_MAX - 1) + '…' : first;
+        parts.push(fail('③ syntax', detail));
+        // No ④ — activation is blocked; rendering a pending step would lie.
+    }
+    return '  ' + parts.join('  ');
+}

package/dist/repl/at-picker.js

@@ -17,24 +17,75 @@
  * without screen takeover, Enter when they want a full search-as-you-type
  * picker. Same backing data, different UI.
  */
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 import { search } from '@inquirer/prompts';
 import { withInquirer } from './inquirer-guard.js';
 import { inquirerTheme } from './inquirer-theme.js';
-import { ensureWorkspaceSync, listProjectFilesSync } from '../projects/workspace.js';
+import { ensureWorkspaceSync, listProjectFilesSync, isAttachableFilename } from '../projects/workspace.js';
 const CANCEL_VALUE = '__cspeach_cancel__';
 /**
  * 2026-06-06 (Ink picker parity): workspace listing + substring filter,
  * exported so the Ink FilePalette shares the same data + seeding
  * semantics as this classic inquirer picker.
+ *
+ * Bug #4 (2026-06-15): the listing is the UNION of
+ *   - all workspace files (.cspeach.json envelopes + .txt/.md/.docx/.pdf), AND
+ *   - top-level .txt/.md/.docx/.pdf files in the current working directory.
+ * A spec file dropped next to the project (the common case) lives in the
+ * cwd, never in .cspeach/, so without the cwd half the picker was empty.
+ *
+ * Deduped by filename — when a name exists in both, the workspace entry
+ * wins. Non-recursive over the cwd; the .cspeach subfolder and any
+ * dotfiles/dirs are skipped. SYNCHRONOUS by contract (the Ink palette and
+ * pendingAtTokenPrefix call it sync). `cwd` / `workspace` are injectable
+ * for tests; the zero-arg call resolves both from the environment.
  */
-export function listWorkspaceFileChoices() {
+export function listWorkspaceFileChoices(opts) {
+    const out = [];
+    const seen = new Set();
+    // Workspace half (takes precedence on name collisions).
+    try {
+        const ws = opts?.workspace ?? ensureWorkspaceSync();
+        for (const f of listProjectFilesSync(ws)) {
+            if (seen.has(f.filename))
+                continue;
+            seen.add(f.filename);
+            out.push({ filename: f.filename, mtimeMs: f.mtimeMs });
+        }
+    }
+    catch {
+        // fall through — still return whatever the cwd half yields
+    }
+    // cwd half — top-level .txt/.md/.docx/.pdf only. Never throws.
+    const cwd = opts?.cwd ?? process.cwd();
     try {
-        const ws = ensureWorkspaceSync();
-        return listProjectFilesSync(ws).map((f) => ({ filename: f.filename, mtimeMs: f.mtimeMs }));
+        for (const name of readdirSync(cwd)) {
+            if (name.startsWith('.'))
+                continue; // dotfiles/dirs (incl. .cspeach)
+            if (!isAttachableFilename(name))
+                continue;
+            if (seen.has(name))
+                continue; // workspace already has it
+            const full = join(cwd, name);
+            let stat;
+            try {
+                stat = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            seen.add(name);
+            out.push({ filename: name, mtimeMs: stat.mtimeMs });
+        }
     }
     catch {
-        return [];
+        // unreadable cwd — return just the workspace list
     }
+    out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return out;
 }
 /** Substring filter; empty prefix returns everything. */
 export function filterFileChoices(prefix, all) {
@@ -126,8 +177,10 @@ export function pendingAtTokenPrefix(trimmed, knownFilenames) {
         }
         else {
             try {
-                const ws = ensureWorkspaceSync();
-                const files = listProjectFilesSync(ws);
+                // Bug #4: check the MERGED listing (workspace + cwd text files),
+                // not workspace-only, so an exact `@spec.txt` for a cwd file
+                // submits directly instead of re-opening the picker.
+                const files = listWorkspaceFileChoices();
                 const exact = files.some((f) => f.filename === prefix);
                 if (exact)
                     return null;