@cspeach/cli 1.1.47 → 1.1.49

package/dist/tools/project/team_lane_move.js

@@ -0,0 +1,127 @@
+/**
+ * team_lane_move — the lead moves packages between people (Task 4, 2026-10-20;
+ * B2's tool part).
+ *
+ * On a skill turn the person asks to move packages; the model calls this,
+ * never file_write (lanes.json is CSPeach's: the file tools refuse it in a
+ * team folder). Code checks everything first — joined, the lead, package
+ * names in full, each a package of the baseline, a reason — then the person
+ * answers ONE card. Yes runs the same body as `cspeach team lane move`
+ * (moveLanes): lanes.json plus one plan record, always. No writes nothing.
+ * Headless: refused, nobody is there to answer the card.
+ *
+ * Chat refuses this tool at dispatch (CHAT_LANE_MOVE_REASON). Rule 8 does not
+ * count it (project category): its own card is the one card.
+ */
+import { registerTool } from '../index.js';
+import { activeProject, readLanes, readProjectFile, RegisterError } from '../../register/store.js';
+import { isLead, isPlainName, MAX_PERSON_NAME, moveLanes, planLaneMove } from '../../commands/team.js';
+import { key as folderKey } from '../../projects/project-folder.js';
+import { NOT_JOINED_LINE } from './_team-tool-shared.js';
+import { shown, shownUpTo } from '../../register/atc-file.js';
+export { NOT_JOINED_LINE };
+/** The session runs in another folder than the joined project's. */
+export const notInProjectLine = (folder) => `Open CSPeach in the project folder to move work: ${folder}.`;
+export const NAME_LINE = `Give the person's name as plain text, at most ${MAX_PERSON_NAME} characters.`;
+export const NEEDS_REASON_LINE = "A move needs the person's reason.";
+export const HEADLESS_LINE = 'This needs a person at the keyboard.';
+/** Live re-run L1: one sentence so the model never reads to-fix as "no decision yet". */
+export const AFTER_MOVE_NEXT = "Tell the person what moved: the moved packages' own counts. "
+    + 'to-fix objects are decided as fix and not started; decided counts every recorded decision. Do not edit lanes.json.';
+const MAX_REASON = 300;
+const fail = (content) => ({ content, is_error: true });
+const sentence = (s) => (/[.!?]$/.test(s) ? s : `${s}.`);
+async function defaultConfirm(req) {
+    const { cardSlotEmitter } = await import('../../ui/card-slot.js');
+    if (cardSlotEmitter.listenerCount('confirm') > 0) {
+        const { askConfirm } = await import('../../ui/confirm-request.js');
+        return askConfirm(req);
+    }
+    const [{ lineConfirm }, { inkAwarePrompt }] = await Promise.all([import('../../journey/chain.js'), import('../../agent/loop.js')]);
+    return lineConfirm(inkAwarePrompt, (line) => console.log(line))(req);
+}
+async function defaultIdentity() {
+    const { getAuthorIdentity } = await import('../../agent/loop.js');
+    return getAuthorIdentity;
+}
+export async function teamLaneMoveHandler(args, ctx, hooks = {}) {
+    const joined = activeProject();
+    if (!joined)
+        return fail(NOT_JOINED_LINE);
+    // Review round 1 — the move is made from the project's own folder only.
+    if (folderKey(ctx.cwd) !== folderKey(joined.projectDir))
+        return fail(notInProjectLine(shownUpTo(joined.projectDir, 260)));
+    try {
+        const said = [];
+        const deps = {
+            identity: hooks.deps?.identity ?? (await defaultIdentity()),
+            ...hooks.deps,
+            print: (line) => { said.push(line); },
+        };
+        const project = readProjectFile(joined.projectDir);
+        if (!isLead(project, deps))
+            return fail(`Only the lead, ${shown(project.lead.name)}, moves packages.`);
+        const packages = Array.isArray(args.packages) ? args.packages.filter((p) => typeof p === 'string') : [];
+        const to = typeof args.to === 'string' ? args.to : '';
+        if (!packages.some((p) => p.trim()))
+            return fail('Name the packages to move in full, for example ZSD_ORDERS.');
+        if (!to.trim())
+            return fail('Say who the packages go to: a person\'s name or a lane id.');
+        if (!isPlainName(to))
+            return fail(NAME_LINE);
+        const lanes = readLanes(joined.projectDir);
+        const plan = planLaneMove(packages, to, joined, lanes);
+        const reason = typeof args.reason === 'string' ? args.reason.trim() : '';
+        if (!reason)
+            return fail(NEEDS_REASON_LINE);
+        if (reason.length > MAX_REASON)
+            return fail(`Keep the reason under ${MAX_REASON} characters.`);
+        if (plan.kind === 'nothing')
+            return { content: JSON.stringify({ moved: [], reason: plan.line }) };
+        const headless = hooks.headless ?? (await import('../../renderer/tty.js')).isHeadless();
+        if (headless)
+            return fail(HEADLESS_LINE);
+        const from = plan.holders.length ? plan.holders.map((l) => `${shown(l.owner)} (${l.id})`).join(', ') : 'nobody yet';
+        const res = await (hooks.confirm ?? defaultConfirm)({
+            id: 'team-lane-move',
+            tag: 'QUESTION',
+            title: `Move ${plan.names.join(', ')} to ${shown(plan.into.owner)}?`,
+            facts: [`From: ${from}.`, `Why: ${sentence(reason)}`, 'Recorded in the project history.'],
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' }],
+            initial: 0,
+            aliases: { y: 'yes', n: 'no' },
+        });
+        if (res.cancelled || res.value !== 'yes')
+            return { content: JSON.stringify({ moved: [], reason: 'declined' }) };
+        // The card may have waited: the move works on the lanes as they are now.
+        // Task 6 (R5): the result is the view's after the move — each moved package's own
+        // objects and parts, and the lane's total apart from them.
+        const done = moveLanes(plan.names, to, reason, joined, readProjectFile(joined.projectDir), readLanes(joined.projectDir), deps);
+        return { content: JSON.stringify({ ...done, next: AFTER_MOVE_NEXT }) };
+    }
+    catch (e) {
+        if (e instanceof RegisterError)
+            return fail(e.message);
+        throw e;
+    }
+}
+registerTool({
+    name: 'team_lane_move',
+    description: 'Move packages from one person to another in the team project this laptop joined (the lead only). '
+        + 'Give package names in full (no patterns), the person\'s name or lane id, and the person\'s reason in their words. '
+        + 'CSPeach checks it and asks the person on one card; on Yes it changes the lanes and records the move in the project history. '
+        + 'Never edit lanes.json yourself. No SAP call.',
+    isMutating: true,
+    category: 'project',
+    requiresSap: false,
+    input_schema: {
+        type: 'object',
+        properties: {
+            packages: { type: 'array', items: { type: 'string' }, description: 'Package names in full, for example ["ZSD_ORDERS", "ZMM_STOCK"].' },
+            to: { type: 'string', description: 'The person the packages go to (their name), or their lane id.' },
+            reason: { type: 'string', description: 'Why, in the person\'s words. Shown back on the card and kept in the history.' },
+        },
+        required: ['packages', 'to', 'reason'],
+    },
+    handler: (args, ctx) => teamLaneMoveHandler(args, ctx),
+});

package/dist/tools/project/upgrade_merge_progress.js

@@ -1,10 +1,14 @@
 /**
  * upgrade_merge_progress — deterministic reconciliation of N parallel
  * /abap-upgrade-fix progress envelopes (the /abap-upgrade-merge skill's
- * execution seam). See cca_merge.ts for the design rationale: the tool
- * does the arithmetic (battery S4 D6/D7), the model presents; the
- * pre-rendered manifest block is pasted verbatim and persisted by the
- * normal save hook.
+ * execution seam). The tool does the arithmetic (battery S4 D6/D7: models
+ * cannot keep counts consistent with rows by hand), the model presents;
+ * the pre-rendered manifest block is pasted verbatim and persisted by the
+ * normal save hook — persistence stays on the one existing save path
+ * instead of the tool minting envelopes through a second door, and the
+ * extractor's counts-vs-rows validation is a tamper backstop if the model
+ * edits the pasted block. (The twin cca_merge tool was cut 2026-10-20,
+ * drift spec §3.6.)
  *
  * Baseline discipline:
  *   - every input's baselineRef.sha256 must match the merge baseline —

package/dist/tools/subagent/schedule_create.js

@@ -0,0 +1,131 @@
+// cspeach-cli/src/tools/subagent/schedule_create.ts
+/**
+ * schedule_create — Phase 3 / Chunk 3E.
+ *
+ * Persists a schedule envelope to ~/.cspeach/schedules/<uuid>.json.
+ * Filename is ALWAYS crypto.randomUUID — never derived from user
+ * input. Closes the path-injection class of attack on the schedules
+ * directory.
+ *
+ * IMPORTANT: this tool persists schedules. It does NOT execute them.
+ * A future chunk (Phase 4 or later) ships the actual runner. The
+ * tool description and the response body both surface this caveat
+ * so the agent doesn't assume the schedule will fire.
+ *
+ * Flag-gated: invisible to listTools() unless
+ * CSPEACH_TOOL_SCHEDULE_CREATE=on. isMutating: true (writes filesystem).
+ */
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { registerTool } from '../index.js';
+const NOT_EXECUTED_NOTE = 'Persisted only — the schedule runner has not shipped yet. ' +
+    'See Phase 4+ for execution.';
+// Test-overridable. Default to ~/.cspeach/schedules. Set null to reset.
+let schedulesDirOverride = null;
+/** Test-only: redirect the schedules dir so tests don't pollute the real home dir. */
+export function __setSchedulesDirForTests(dir) {
+    schedulesDirOverride = dir;
+}
+function getSchedulesDir() {
+    return schedulesDirOverride ?? path.join(os.homedir(), '.cspeach', 'schedules');
+}
+// Strict ISO-8601 UTC: YYYY-MM-DDTHH:MM:SS(.sss)?Z
+const ISO_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
+export async function scheduleCreateHandler(args, _ctx) {
+    if (args.kind !== 'oneoff' && args.kind !== 'cron') {
+        return { content: `error: kind must be 'oneoff' or 'cron' — got '${args.kind}'`, is_error: true };
+    }
+    if (!args.when || typeof args.when !== 'string' || args.when.trim().length === 0) {
+        return { content: 'error: when is required (non-empty string)', is_error: true };
+    }
+    if (!args.command || typeof args.command !== 'string' || args.command.trim().length === 0) {
+        return { content: 'error: command is required (non-empty string)', is_error: true };
+    }
+    if (args.kind === 'oneoff') {
+        if (!ISO_PATTERN.test(args.when)) {
+            return { content: `error: when must be an ISO-8601 UTC timestamp (e.g. 2099-06-01T10:00:00Z) — got '${args.when}'`, is_error: true };
+        }
+        const t = Date.parse(args.when);
+        if (Number.isNaN(t)) {
+            return { content: `error: when is not a parseable ISO timestamp: '${args.when}'`, is_error: true };
+        }
+        // Belt-and-braces against silent month/day rollover. Date.parse('2099-02-30T00:00:00Z')
+        // returns a valid timestamp that round-trips to March 2 — without this check, the
+        // envelope persists '2099-02-30' but the runner fires on March 2 (phantom job).
+        const roundTrip = new Date(t).toISOString();
+        // Normalise both sides: lowercase 'z', strip optional fractional seconds, compare.
+        const norm = (s) => s.replace(/\.\d+Z$/, 'Z').toUpperCase();
+        if (norm(roundTrip) !== norm(args.when)) {
+            return { content: `error: when is not a valid calendar date: '${args.when}' (rolls to ${roundTrip})`, is_error: true };
+        }
+        if (t <= Date.now()) {
+            return { content: `error: when is in the past — schedule must be in the future`, is_error: true };
+        }
+    }
+    else {
+        // cron: just check it has 5 whitespace-separated fields.
+        const fields = args.when.trim().split(/\s+/);
+        if (fields.length !== 5) {
+            return { content: `error: cron expression must have 5 fields (min hour dom mon dow) — got ${fields.length}`, is_error: true };
+        }
+    }
+    const dir = getSchedulesDir();
+    await fs.mkdir(dir, { recursive: true });
+    // Defence-in-depth: resolve the directory and verify it sits inside
+    // the cspeach home (or the test override). Refuses if a symlink
+    // points the dir at /etc/, /tmp/host-controlled/, etc.
+    const realDir = await fs.realpath(dir);
+    // In test mode the override dir IS the root (self-containment is trivial —
+    // mkdtemp gives us a unique dir that acts as both schedules-dir and its own
+    // root). In prod the schedules dir must sit UNDER ~/.cspeach/, so the root
+    // is the parent. Asymmetric on purpose.
+    const expectedRoot = schedulesDirOverride !== null
+        ? path.resolve(schedulesDirOverride)
+        : path.join(os.homedir(), '.cspeach');
+    const rel = path.relative(expectedRoot, realDir);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+        return { content: `error: schedules directory '${realDir}' resolves outside expected root`, is_error: true };
+    }
+    const id = randomUUID();
+    const envelope = {
+        id,
+        kind: args.kind,
+        when: args.when,
+        command: args.command,
+        createdAt: new Date().toISOString(),
+        note: NOT_EXECUTED_NOTE,
+    };
+    const target = path.join(realDir, `${id}.json`);
+    await fs.writeFile(target, JSON.stringify(envelope, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    return {
+        content: `schedule persisted (NOT YET EXECUTED — runner ships in a later chunk).\n` +
+            `path: ${target}\n` +
+            `id: ${id}\n` +
+            `kind: ${args.kind}\n` +
+            `when: ${args.when}\n` +
+            `command: ${args.command}\n` +
+            `note: ${NOT_EXECUTED_NOTE}`,
+    };
+}
+registerTool({
+    name: 'schedule_create',
+    description: 'Persist a oneoff or cron schedule envelope to ~/.cspeach/schedules/<uuid>.json. ' +
+        'Filename is a fresh UUID — never derived from input. NOTE: this tool only PERSISTS the ' +
+        'schedule. No runner is shipped yet — the agent should not assume the command will fire ' +
+        'automatically. A future chunk will ship the runner.',
+    isMutating: true,
+    category: 'subagent',
+    flagGated: true,
+    input_schema: {
+        type: 'object',
+        properties: {
+            kind: { type: 'string', enum: ['oneoff', 'cron'], description: 'oneoff = single ISO timestamp; cron = 5-field expression' },
+            when: { type: 'string', description: 'ISO-8601 UTC timestamp for oneoff, or 5-field cron expression' },
+            command: { type: 'string', description: 'The command the runner WOULD execute (free-form string for now)' },
+        },
+        required: ['kind', 'when', 'command'],
+    },
+    handler: (args, ctx) => scheduleCreateHandler(args, ctx),
+});

package/dist/tools/text-elements/tools.js

@@ -35,6 +35,7 @@ import { appendPending, finalizeToolCall } from '../../session/pending.js';
 import { snapshots, auditLog } from '@cspeach/sap-client';
 import { ERR } from '../../errors/codes.js';
 import { resolveWriteTransport } from '../transport-resolution.js';
+import { projectTransportForWrite, transportForWrite } from '../../register/project-transport.js';
 import { noteWriteTransport } from '../../repl/current-transport.js';
 import { loadConfig } from '../../config/loader.js';
 import { getEffectiveWriteMode } from '../../repl/mode-cycle.js';
@@ -246,7 +247,12 @@ registerTool({
         if (args.transport && sessionTransport && args.transport !== sessionTransport) {
             ctx.chunkEmitter?.emit('warn', `LLM passed transport=${args.transport} but session current-transport=${sessionTransport}`);
         }
-        const resolved = await resolveWriteTransport(ctx, 'PROG', name, args.transport ?? sessionTransport ?? undefined);
+        // Task 8 (B11) / Task 6: the one choice (transportForWrite) — explicit ?? the project request of
+        // this folder ?? session; the owning lock is looked up inside resolveWriteTransport and wins.
+        const supplied = transportForWrite({
+            op: 'modify', explicit: args.transport, project: projectTransportForWrite(ctx, verify.payload), session: sessionTransport,
+        }).request;
+        const resolved = await resolveWriteTransport(ctx, 'PROG', name, supplied);
         // 2026-10-04 — a plan-grant id never writes into a transport other than the grant's.
         if (grantOwningTransportMismatch(verify.payload, resolved.owning)) {
             return errorEnvelope({ error: ERR.APPROVAL_INVALID, reason: 'transport_mismatch', detail: grantOwningTransportDetail(name, resolved.owning) });

package/dist/tools/tool-loading.js

@@ -58,7 +58,7 @@ export const SKILL_STARTERS = Object.freeze({
     'abap-app': ['app_lane_resolve', 'read_document'],
     'abap-atc-fix': ['sap_atc_run'],
     'abap-cca': ['team_estate', 'sap_atc_run', 'sap_usage_references', 'sap_api_state'],
-    'abap-clean-core': ['sap_api_state', 'sap_atc_run', 'sap_usage_references', 'team_findings'],
+    'abap-clean-core': ['sap_api_state', 'sap_atc_run', 'sap_usage_references', 'team_findings', 'team_lane_move'],
     'abap-data-model': ['sap_create_domain', 'sap_create_data_element'],
     'abap-document': ['sap_usage_references'],
     'abap-handover': ['sap_usage_references'],

package/dist/tools/update-method-intercept.js

@@ -28,7 +28,9 @@ export class CancelledByUserError extends Error {
  */
 export async function interceptUpdateMethod(client, call, hook) {
     const classSource = await client.getSource({ type: 'CLAS', name: call.className });
-    const currentBody = extractMethodBody(classSource, call.methodName);
+    // C9 (Task 9): the proposed source is the body only, so compare body with
+    // body — the METHOD / ENDMETHOD wrapper lines are not part of the change.
+    const currentBody = methodBodyOf(extractMethodBody(classSource, call.methodName));
     const proposedBody = call.methodSource;
     const result = await hook({
         className: call.className,
@@ -87,6 +89,21 @@ export function extractMethodBody(classSource, methodName) {
     // diff still surfaces the partial body to the user.
     return lines.slice(start).join('\n');
 }
+/**
+ * C9 (Task 9): the lines between `METHOD x.` and `ENDMETHOD.` of a block
+ * from extractMethodBody. Drops the first line when it opens the method and
+ * the last when it closes it; anything else is kept. Empty stays empty.
+ */
+export function methodBodyOf(block) {
+    if (!block)
+        return block;
+    const lines = block.split('\n');
+    if (lines.length > 0 && /^\s*METHOD\b/i.test(lines[0]))
+        lines.shift();
+    if (lines.length > 0 && /^\s*ENDMETHOD\s*\./i.test(lines[lines.length - 1]))
+        lines.pop();
+    return lines.join('\n');
+}
 function stripCommentsAndStrings(line) {
     // Walk the line and replace string-literal contents and trailing `"` comments
     // with spaces so keyword matching ignores them. Cheap and good enough for

package/dist/tools/write-pipeline.js

@@ -28,6 +28,7 @@ import { auditLog, SapError } from '@cspeach/sap-client';
 import { verifyAndSpendApprovalId } from '../approvals/jwt.js';
 import { grantClaimMismatch, grantOwningTransportMismatch, grantOwningTransportDetail } from '../approvals/grant-claims.js';
 import { typeCode } from '../approvals/risk-floor.js';
+import { projectTransportForWrite, transportForWrite } from '../register/project-transport.js';
 import { autoSnapshot, autoSnapshotClassInclude, autoSnapshotMessageClass } from './snapshot.js';
 import { includeSnapshotType } from './include-snapshot.js';
 import { buildWriteChainLine } from '../renderer/verify-chain.js';
@@ -367,9 +368,17 @@ export async function runWritePipeline(args, ctx, spec) {
     if (spec.transport.mode === 'resolve' || spec.transport.mode === 'fallback-resolve') {
         // D15/D20 — an object already locked in an open request is written under
         // THAT request; any other transport is a guaranteed CTS lock conflict.
-        const supplied = spec.transport.mode === 'fallback-resolve'
-            ? raw.transport ?? ctx.currentTransport?.get() ?? undefined
-            : raw.transport;
+        // Task 8 (B11): one order for every write — owning lock (resolve below)
+        // ?? explicit ?? the project request of this folder ?? the session (where
+        // the mode has always used it). No joined project → null → as before.
+        // Task 6 (project view): the choice is transportForWrite's, the card's too; the
+        // owning lock is looked up below. A 'resolve' write has never used the session.
+        const supplied = transportForWrite({
+            op: spec.approval.op,
+            explicit: raw.transport,
+            project: projectTransportForWrite(ctx, verify.payload),
+            session: spec.transport.mode === 'fallback-resolve' ? ctx.currentTransport?.get() : undefined,
+        }).request;
         const resolved = await resolveWriteTransport(ctx, spec.transport.type(args), spec.transport.name(args), supplied);
         pre.transport = resolved.transport;
         pre.owning = resolved.owning;
@@ -383,8 +392,13 @@ export async function runWritePipeline(args, ctx, spec) {
         }
     }
     else {
-        // Three-tier fallback: explicit arg → session current-transport → none.
-        pre.transport = raw.transport ?? ctx.currentTransport?.get() ?? undefined;
+        // Three-tier fallback: explicit arg → (Task 8) project request → session current-transport → none.
+        pre.transport = transportForWrite({
+            op: spec.approval.op,
+            explicit: raw.transport,
+            project: projectTransportForWrite(ctx, verify.payload),
+            session: ctx.currentTransport?.get(),
+        }).request;
     }
     // ── Gate 2: Snapshot (Rule 7) ─────────────────────────────────────────────
     const snapRefusal = await snapshotGate(args, ctx, spec, pre);

package/dist/ui/approval-modal.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef, useState } from 'react';
 import { Box, Text, useInput, useStdout } from 'ink';
 import { riskReasonText, shownRiskReasons } from '../approvals/risk-floor.js';
-import { verbLine, viewAffordance, toSourceLines, affectsLine, releaseLines } from '../approvals/op-labels.js';
+import { verbLine, viewAffordance, toSourceLines, affectsLine, releaseLines, behaviourLines } from '../approvals/op-labels.js';
 // BUG-1 (2026-07-05 live smoke): the interactive approval modal mounted
 // DEAD — every keypress ignored — when it appeared after a guarded
 // /abap-plan turn. Root cause is identical to the one AskCard
@@ -41,14 +41,17 @@ export function riskRows(effectiveRisk, width) {
 export const AFFECTS_MAX_ROWS = 2;
 /**
  * The rows under the verb line: "Affects: …" (none when the change names no
- * process), then — Part 3 D12 — a release card's fact lines, each wrapping
- * onto up to AFFECTS_MAX_ROWS rows. Any other change: exactly as before.
+ * process), then "Behaviour: …" (Task 7, up to 3 rows, none when absent),
+ * then — Part 3 D12 — a release card's fact lines, each wrapping onto up to
+ * AFFECTS_MAX_ROWS rows. Any other change: exactly as before.
  */
 export function affectsRows(change, width) {
     const cols = Math.max(1, width - MODAL_CHROME_COLS);
     const line = affectsLine(change);
     return [
         ...(line ? wrapRows(line, cols, AFFECTS_MAX_ROWS) : []),
+        // Task 7 — "Behaviour: …" (at most 3 rows; none when absent or 'none').
+        ...behaviourLines(change, cols),
         ...releaseLines(change).flatMap((l) => wrapRows(l, cols, AFFECTS_MAX_ROWS)),
     ];
 }

package/dist/ui/error-emitter.js

@@ -0,0 +1,21 @@
+import { EventEmitter } from 'node:events';
+import { shouldUseInk } from '../renderer/tty.js';
+import chalk from 'chalk';
+export const errorEmitter = new EventEmitter();
+/**
+ * Emit an error. In Ink mode, the main App subscribes and pushes the error
+ * into its errorStack state for overlay rendering. In non-TTY / one-shot,
+ * we fall back to chalk.red on stderr — never mount a second Ink root.
+ */
+export function emitError(err) {
+    if (shouldUseInk()) {
+        errorEmitter.emit('error', err);
+    }
+    else {
+        console.error(chalk.red(`[${err.code}] ${err.title}`));
+        if (err.body)
+            console.error(chalk.red(`  ${err.body}`));
+        if (err.hint)
+            console.error(chalk.dim(`  ${err.hint}`));
+    }
+}

package/dist/ui/footer-line.js

@@ -3,6 +3,22 @@ import { Text, useStdout } from 'ink';
 import { useSapState } from './sap-state-store.js';
 import { formatFooterLine, footerStateFrom } from '../renderer/footer-line.js';
 import { inputBoxWidth } from './footer.js';
+import { projectTransport } from '../register/project-transport.js';
+/** How long the footer trusts its last read of the project file (the line redraws often). */
+const PROJECT_READ_MS = 2_000;
+let lastRead = null;
+/**
+ * Task 6 (project view, R8): the request of the project joined in this folder,
+ * read at most every two seconds. Null outside a project folder (never throws:
+ * `projectTransport` reads null for anything it cannot use).
+ */
+export function footerProjectTransport(cwd = process.cwd(), now = Date.now()) {
+    if (lastRead && lastRead.cwd === cwd && now - lastRead.at < PROJECT_READ_MS)
+        return lastRead.request;
+    const request = projectTransport(cwd);
+    lastRead = { cwd, at: now, request };
+    return request;
+}
 /**
  * The one footer line under the input box (piece 2, spec §8) — replaces the
  * StatusLine. Same width as the input box so the two align. Single truncating
@@ -12,5 +28,7 @@ export function FooterLine() {
     const s = useSapState();
     const { stdout } = useStdout();
     const width = inputBoxWidth(stdout?.columns || 80);
-    return _jsx(Text, { wrap: "truncate-end", children: formatFooterLine(footerStateFrom(s), width) });
+    // In a project folder with a request, the footer says it (a write that names none lands there).
+    const project = footerProjectTransport();
+    return _jsx(Text, { wrap: "truncate-end", children: formatFooterLine(footerStateFrom(s, project), width) });
 }

package/dist/ui/header.js

@@ -0,0 +1,41 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useSapState } from './sap-state-store.js';
+import { formatSpendSegment } from './status-line.js';
+import { CLI_VERSION } from '../lib/version.js';
+const PEACH = '#FFCBA4';
+/**
+ * ⚠ SUPERSEDED (UX Wave 1, Task 4 — 2026-07) by ui/status-line.tsx, the
+ * bottom-anchored borderless statusline mounted in App between TurnStatus
+ * and Footer. This component is no longer rendered anywhere: Phase D6
+ * removed the persistent top Header (inline mode can't pin the frame top),
+ * and the statusline took over the SapStateStore display role. Kept for
+ * reference, not deleted.
+ *
+ * Single-line rich header (Phase D3, 2026-05-16) — back to one line per
+ * Laeeq's feedback that the two-line variant felt worse. Uses tighter
+ * separators and shorter labels so it fits cleanly on typical terminals
+ * (100+ cols). On a narrower terminal Ink will wrap rather than truncate,
+ * accepted as a degradation case.
+ *
+ * Layout:
+ *   🍑 CSPeach 0.6.5 │ S4H │ S.LAEEQ │ tr none │ 28k tok │ $0.54 │ approval-gated
+ */
+export function Header({ writeMode } = {}) {
+    const s = useSapState();
+    const isAdvisory = writeMode === 'advisory-only';
+    const modeLabel = isAdvisory
+        ? 'ADVISORY'
+        : writeMode === 'approval-gated'
+            ? 'approval-gated'
+            : writeMode === 'auto'
+                ? 'auto'
+                : undefined;
+    const modeColor = isAdvisory ? 'yellow' : 'green';
+    const tokDisplay = s.tokenUsageToday >= 1000
+        ? `${(s.tokenUsageToday / 1000).toFixed(1)}k tok`
+        : `${s.tokenUsageToday} tok`;
+    // Shared with <StatusLine /> so the credits/dollar switch has one home.
+    const spendDisplay = formatSpendSegment(s);
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { bold: true, color: PEACH, children: ["\uD83C\uDF51 CSPeach ", CLI_VERSION] }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "cyan", children: s.system || 'no system' }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "white", children: s.user || '—' }), _jsx(Text, { color: "gray", children: " \u2502 tr " }), _jsx(Text, { color: "yellow", children: s.transport ?? 'none' }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "green", children: tokDisplay }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "green", children: spendDisplay }), modeLabel && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: modeColor, bold: isAdvisory, children: modeLabel })] }))] }));
+}

package/dist/ui/ink-classifier-route.js

@@ -0,0 +1,19 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+/**
+ * Medium-confidence banner rendered inside the Ink frame. Auto-settles to
+ * the classifier's top pick after 800ms, unless the user presses Tab — in
+ * which case we open the CommandPalette with alternates.
+ */
+export function InkClassifierRoute({ skill, confidence, onSettle, onOpenPalette }) {
+    useEffect(() => {
+        const t = setTimeout(onSettle, 800);
+        return () => clearTimeout(t);
+    }, [onSettle]);
+    useInput((_input, key) => {
+        if (key.tab)
+            onOpenPalette();
+    });
+    return (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["\\u2504 Suggest /", skill, " (confidence ", Math.round(confidence * 100), "%) \\u2014 Tab to pick"] }) }));
+}

package/dist/ui/rich-error-box.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+function severityColor(s) {
+    return s === 'error' ? 'red' : s === 'warning' ? 'yellow' : 'blue';
+}
+export function RichErrorBox({ code, message, hint, severity = 'error' }) {
+    const color = severityColor(severity);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: color, paddingX: 2, paddingY: 1, children: [_jsx(Text, { bold: true, color: color, children: code }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: message }) }), hint && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: hint }) }))] }));
+}

package/dist/ui/sidebar.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useSapState } from './sap-state-store.js';
+export function Sidebar() {
+    const s = useSapState();
+    // Phase A** (2026-05-16) — dropped the "/ of $100" pseudo-budget. We
+    // don't know the user's actual API spending limit; showing a fake
+    // cap trained the colour signal to be meaningless. Now just shows the
+    // raw spend. Colour signal removed alongside.
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, width: 30, children: [_jsx(Text, { bold: true, color: "cyan", children: s.system || 'no system' }), _jsxs(Text, { color: "gray", children: ["user: ", _jsx(Text, { color: "white", children: s.user || '—' })] }), _jsxs(Text, { color: "gray", children: ["transport: ", _jsx(Text, { color: "yellow", children: s.transport ?? 'none' })] }), _jsxs(Text, { color: "gray", children: ["locks: ", s.locksHeld.length === 0 ? _jsx(Text, { dimColor: true, children: "(none)" })
+                        : s.locksHeld.map((l, i) => _jsxs(Text, { color: "red", children: [l, " "] }, i))] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "green", children: [s.tokenUsageToday.toLocaleString(), " tok / $", s.dollarSpendToday.toFixed(2)] }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "\u2500 recent turns \u2500" }), s.recentTurns.slice(-5).reverse().map((t, i) => (_jsxs(Text, { dimColor: true, children: [t.time, " ", t.command.slice(0, 20)] }, i))), s.recentTurns.length === 0 && _jsx(Text, { dimColor: true, children: "(no turns yet)" })] })] }));
+}

package/dist/ui/status-emitter.js

@@ -0,0 +1,19 @@
+import { EventEmitter } from 'node:events';
+/**
+ * Singleton channel from `runTurn` (producer) to `<App>` (consumer) for
+ * status-row updates in Ink mode. Phase A #1 (2026-05-16) — the prior
+ * version of the REPL claimed Ink rendered its own `<StatusRow>` but
+ * never imported the component. As a result Ink users saw NO cost,
+ * token, or session info ever. This emitter is the missing wire.
+ *
+ * Producer (repl.tsx, end-of-turn): emits an `update` event with the
+ * latest StatusRowData. Consumer (App.tsx): subscribes in a useEffect,
+ * stores in state, renders `<StatusRow data={...} />` above `<Footer>`.
+ *
+ * Why a separate emitter (not chunkEmitter): chunkEmitter pipes strings
+ * into Body. StatusRow needs structured data (numbers + dollar amounts)
+ * and lives in a fixed region — passing it through chunks would mean
+ * sentinel parsing for what is naturally typed state. Matches the
+ * approvalEmitter / errorEmitter / coachingPickerEmitter pattern.
+ */
+export const statusEmitter = new EventEmitter();