@pugi/cli 0.1.0-beta.3 → 0.1.0-beta.31

package/dist/core/repl/session.js

@@ -27,6 +27,7 @@
  * verbatim - the brand gate on those happens at the controller.
  */
 import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
 import { getPersona } from '@pugi/personas';
 import { listRoles, getPersonaForRole } from '../agents/registry.js';
 import { evaluateCap, describeVerdict } from './cap-warning.js';
@@ -34,11 +35,16 @@ import { parseSlashCommand } from './slash-commands.js';
 import { webFetchTool } from '../../tools/web-fetch.js';
 import { loadSettings } from '../settings.js';
 import { getJobRegistry } from '../jobs/registry.js';
+import { applyCompactMask } from '../compact/buffer-rewriter.js';
+import { applyRewindMask } from '../checkpoint/rewinder.js';
+import { evaluateAutoCompact } from '../compact/auto-trigger.js';
+import { estimateTokensInMany } from '../compact/token-counter.js';
 import { extractAskTags, extractPlanReviewTags, signatureForAsk, } from './ask.js';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { CancellationToken } from './cancellation.js';
 import { DispatchFSM } from './dispatch-fsm.js';
+import { computeCostUsd, formatCostUsd, formatTokens } from './model-pricing.js';
 const MAX_TRANSCRIPT_ROWS = 500;
 const MAX_TOOL_CALLS = 200;
 const MAX_RECONNECT_ATTEMPTS = 10;
@@ -315,6 +321,19 @@ export class ReplSession {
             toolCalls: [],
             transcript: [],
             tokensDownstreamTotal: 0,
+            // α7 cost-meter sprint — cost accumulators land at zero on boot.
+            // `sessionStartedAtEpochMs` is set at construction time (vs the
+            // server-side `agent.session.opened` event) so the elapsed slot
+            // on the status row starts ticking the moment the REPL mounts.
+            sessionTokensIn: 0,
+            sessionTokensOut: 0,
+            sessionCostUsd: 0,
+            sessionStartedAtEpochMs: this.now(),
+            recentTurns: [],
+            turnTokensIn: 0,
+            turnTokensOut: 0,
+            turnCostUsd: 0,
+            lastTurnDelta: null,
             briefStartedAtEpochMs: undefined,
             pendingAsk: null,
             pendingAskSource: null,
@@ -322,6 +341,7 @@ export class ReplSession {
             pendingPlanReviewSource: null,
             dispatchState: 'idle',
             dispatchToolLabel: null,
+            lastCompletedOutcome: null,
         };
         // α6.9: mirror every FSM transition into the public state so the
         // status-bar surface can rerender on the next frame. Local listener
@@ -359,6 +379,7 @@ export class ReplSession {
                 apiUrl: this.options.apiUrl,
                 apiKey: this.options.apiKey,
                 workspace: this.options.workspace,
+                cyberZoo: this.options.cyberZoo,
             });
             this.patch({ sessionId, connection: 'connecting' });
             this.openStream();
@@ -371,6 +392,11 @@ export class ReplSession {
             // admin-api down) is silent - the operator can still type
             // `/privacy` to see the contract.
             void this.fetchAndAnnouncePrivacyMode().catch(() => undefined);
+            // Leak L21 (2026-05-27): silently drain any feedback envelopes
+            // that landed offline during a previous session. Best-effort —
+            // a failed flush leaves the queue intact for the next start.
+            // Never blocks bootstrap.
+            void this.flushFeedbackQueueOnBootstrap().catch(() => undefined);
         }
         catch (error) {
             this.appendSystemLine(`Could not open Pugi session: ${this.errorMessage(error)}`);
@@ -414,6 +440,21 @@ export class ReplSession {
             // Silent fail - offline / DNS / unauth all collapse to no banner.
         }
     }
+    /**
+     * Leak L21 (2026-05-27): on bootstrap, drain the local feedback
+     * queue silently. Operators who ran `pugi feedback` while offline
+     * see their envelopes flushed on the next online session without
+     * any extra command. The drain is best-effort and never blocks
+     * the REPL — a failed flush leaves the queue intact for the next
+     * bootstrap attempt.
+     */
+    async flushFeedbackQueueOnBootstrap() {
+        const { flushFeedbackQueueSilently } = await import('../../runtime/commands/feedback.js');
+        await flushFeedbackQueueSilently(process.cwd(), {
+            apiUrl: this.options.apiUrl,
+            apiKey: this.options.apiKey,
+        });
+    }
     /**
      * Tear down the SSE stream and stop the reconnect timer. The session
      * id stays valid server-side; `pugi resume <id>` reopens later.
@@ -539,6 +580,73 @@ export class ReplSession {
     getDispatchState() {
         return this.fsm.current;
     }
+    /**
+     * Wave 6 BT 8 (Claude Code parity): Esc-Esc walkback. Trim the last
+     * operator/persona turn pair from the in-memory transcript so the
+     * model's next call sees the conversation as if the most recent
+     * turn never happened. The local SessionStore still has the events
+     * on disk (append-only); the in-memory mask is advisory and the next
+     * `/compact` boundary will fold them naturally.
+     *
+     * Refusal modes:
+     *   - `'no-turn'`     - transcript has no operator/persona row to pop.
+     *   - `'in-flight'`   - dispatch is mid-flight; popping would race with
+     *                       the streaming persona row. The operator must
+     *                       cancel (Ctrl+C) before walking back.
+     *
+     * Success mode:
+     *   - `'walked-back'` - the trailing persona row + the operator row
+     *                       that triggered it are gone from the transcript.
+     *                       A `↩ walked back 1 turn` status row is appended
+     *                       so the operator sees the state change without
+     *                       guessing.
+     *
+     * The mask is in-memory only on purpose. Disk-side rewind already has
+     * a separate first-class command (`/rewind`) with checkpoint
+     * semantics — the Esc-Esc shortcut is a one-tap "oops, undo that" for
+     * the live transcript, NOT a transactional rollback.
+     */
+    walkbackLastTurn() {
+        // Refuse while a dispatch is running. Popping the operator row that
+        // is currently driving the model's response would leave the persona
+        // line orphaned on the next streamed chunk; the FSM also lacks a
+        // clean teardown path here. The operator gets a one-line refusal
+        // and can Ctrl+C first if they really want to walk back.
+        const current = this.fsm.current;
+        if (current !== 'idle' && current !== 'completed'
+            && current !== 'aborted' && current !== 'failed') {
+            this.appendSystemLine('Walkback refused: dispatch in flight. Cancel with Ctrl+C, then Esc-Esc again.');
+            return 'in-flight';
+        }
+        // Find the trailing operator row. Walking backwards because the
+        // transcript is append-only and the most recent operator turn is
+        // by definition the last `source === 'operator'` row.
+        const transcript = this.state.transcript;
+        let operatorIdx = -1;
+        for (let i = transcript.length - 1; i >= 0; i -= 1) {
+            const row = transcript[i];
+            if (row.source === 'operator') {
+                operatorIdx = i;
+                break;
+            }
+        }
+        if (operatorIdx === -1) {
+            // No operator turn to pop. Quiet refusal — surfacing a "nothing
+            // to undo" line on every accidental double-Esc would be noisy.
+            return 'no-turn';
+        }
+        // Trim everything from the operator row onward (its echo + any
+        // persona/system rows that landed in response). The slice keeps
+        // every row BEFORE the operator turn, which is the conversation
+        // exactly as it stood right before the operator pressed Enter.
+        const trimmed = transcript.slice(0, operatorIdx);
+        this.patch({ transcript: trimmed });
+        // Status row so the operator sees the state change without
+        // guessing. Brand voice: single ASCII line, return-arrow glyph
+        // (U+21A9) which renders across every modern terminal.
+        this.appendSystemLine('↩ walked back 1 turn');
+        return 'walked-back';
+    }
     /**
      * Current cancellation token. Returned for the tool execution path
      * (file-tools.ts) so it can pass the token down into a ToolContext
@@ -577,6 +685,18 @@ export class ReplSession {
                 await this.dispatchStop(verdict.persona);
                 return verdict;
             }
+            case 'delegate': {
+                // α7.5 Phase 1: surface the dispatch intent inline. The actual
+                // wire shape (POST /api/pugi/sessions/:id/delegate) requires the
+                // SDK transport extension that ships alongside this PR; the
+                // REPL session module wires the call when the matching transport
+                // method lands (paired CLI follow-up). Today we surface the
+                // delegation intent in the transcript so the operator sees the
+                // verdict echo for muscle-memory before the round-trip lights up.
+                this.appendSystemLine(`delegate ${verdict.persona}: ${verdict.brief.length > 80 ? `${verdict.brief.slice(0, 77)}...` : verdict.brief}`);
+                this.appendSystemLine('Run `pugi delegate <slug> "<brief>"` from a fresh shell while the REPL transport wiring lands.');
+                return verdict;
+            }
             case 'dispatch': {
                 await this.dispatchBrief(verdict.brief);
                 return verdict;
@@ -602,11 +722,15 @@ export class ReplSession {
                 return verdict;
             }
             case 'cost': {
-                this.dispatchCost();
+                await this.dispatchCost();
+                return verdict;
+            }
+            case 'quota': {
+                await this.dispatchQuota();
                 return verdict;
             }
             case 'status': {
-                this.dispatchStatus();
+                await this.dispatchStatus();
                 return verdict;
             }
             case 'consensus': {
@@ -651,12 +775,859 @@ export class ReplSession {
                 await this.dispatchPrivacy();
                 return verdict;
             }
+            case 'init': {
+                // β1 Sl11 → β1a r1 (real inline scaffold, 2026-05-26): invoke
+                // `scaffoldPugiWorkspace` directly so the operator gets the
+                // same .pugi/ setup they would from `pugi init` on a fresh
+                // shell. Already-initialised workspaces (every artifact already
+                // present) get the "Already initialised" copy; partial / fresh
+                // workspaces get the full Created+Skipped breakdown. Default
+                // skills install is best-effort — any error from the bundled
+                // pack is surfaced as a system line and does not break the
+                // REPL session. The dynamic import keeps the slash dispatcher
+                // free of a runtime/cli.ts cycle on every keystroke.
+                try {
+                    const { scaffoldPugiWorkspace } = await import('../../runtime/cli.js');
+                    const lines = [];
+                    const result = await scaffoldPugiWorkspace({
+                        cwd: process.cwd(),
+                        // Slash callers default to the full default-skills pack so
+                        // the in-REPL experience matches `pugi init`. Operators who
+                        // want a minimal scaffold still have the shell command.
+                        noDefaults: false,
+                        log: (line) => {
+                            const trimmed = line.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    if (result.alreadyInitialized) {
+                        this.appendSystemLine(`.pugi/ already initialised at ${result.root}. ${result.skipped.length} artefact(s) verified.`);
+                    }
+                    else {
+                        this.appendSystemLine(`Pugi initialised at ${result.root}. Created ${result.created.length} artefact(s), skipped ${result.skipped.length}.`);
+                    }
+                    if (result.defaultSkills.length > 0) {
+                        const installed = result.defaultSkills.filter((s) => s.status === 'installed').length;
+                        const skippedSkills = result.defaultSkills.filter((s) => s.status === 'skipped-existing').length;
+                        this.appendSystemLine(`Default skills: ${installed} installed, ${skippedSkills} already present.`);
+                    }
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/init failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'mcp': {
+                // β4 Sl7 (2026-05-26): /mcp [sub] [args...] forwards to the
+                // runtime command. We deliberately route through the same
+                // entry-point used by `pugi mcp` from a fresh shell so the
+                // surface stays single-sourced. `serve` is refused inline —
+                // booting an MCP server inside an active REPL would compete
+                // with the REPL itself for stdio, which is exactly the wrong
+                // thing to do.
+                if (verdict.args[0] === 'serve') {
+                    this.appendSystemLine('/mcp serve is not safe inside the REPL (it competes for stdio). ' +
+                        'Run `pugi mcp serve` from a fresh shell instead.');
+                    return verdict;
+                }
+                try {
+                    const { runMcpCommand } = await import('../../runtime/commands/mcp.js');
+                    const lines = [];
+                    await runMcpCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/mcp: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/mcp failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'theme': {
+                // Leak L30 (2026-05-27): /theme [name] [--persist|--reset|--list]
+                // forwards to the shared `runThemeCommand` runner. Same async
+                // buffer-then-flush pattern as `/style` so a future async
+                // write path inside the runner cannot drop a tail emission
+                // and so multi-line payloads (banner + preview table) land
+                // one row per visual line in the conversation pane.
+                try {
+                    const { runThemeCommand } = await import('../../runtime/commands/theme.js');
+                    const lines = [];
+                    await runThemeCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        writeOutput: (_payload, text) => {
+                            for (const raw of text.split('\n')) {
+                                const trimmed = raw.replace(/\s+$/u, '');
+                                lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/theme: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/theme failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'style': {
+                // Leak L18 (2026-05-27): /style [name] [--persist|--reset|--list]
+                // forwards to the shared `runStyleCommand` runner so the slash
+                // + top-level surfaces share one code path. Dynamic import
+                // keeps the dispatcher free of the output-style module graph
+                // until the operator first invokes the slash. The runner's
+                // exit code is captured but NOT propagated to process.exitCode
+                // — REPL session should not die because a bad preset slug was
+                // typed in the input box.
+                try {
+                    const { runStyleCommand } = await import('../../runtime/commands/style.js');
+                    // L18 P1 fix (2026-05-27): writeOutput is invoked SYNCHRONOUSLY
+                    // by `runStyleCommand` for each emitted block. We buffer every
+                    // emission into `lines` and flush after the await resolves so
+                    // that:
+                    //   (1) any future async write path inside the runner cannot
+                    //       drop a tail emission (callback never references the
+                    //       Ink frame directly), and
+                    //   (2) multi-line payloads (e.g. the active-style banner +
+                    //       catalogue table) render one row per visual line in the
+                    //       conversation pane, matching the `/stickers` surface.
+                    const lines = [];
+                    await runStyleCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        writeOutput: (_payload, text) => {
+                            for (const raw of text.split('\n')) {
+                                const trimmed = raw.replace(/\s+$/u, '');
+                                lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/style: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/style failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'onboarding': {
+                // Leak L25 (2026-05-27): /onboarding forwards to the shared
+                // `runOnboardingCommand` runner. From inside the REPL we ALWAYS
+                // route through the non-interactive snapshot path — the REPL
+                // already owns the Ink tree and mounting a second Ink wizard
+                // on top would conflict over stdin raw mode. Operators who
+                // want the interactive walk exit the REPL and run
+                // `pugi onboarding` from a fresh shell; the slash surface
+                // surfaces the recap card + hints inline so the operator
+                // sees current values without leaving the session.
+                try {
+                    const { runOnboardingCommand } = await import('../../runtime/commands/onboarding.js');
+                    const { resolveActiveCredential } = await import('../credentials.js');
+                    const credential = resolveActiveCredential();
+                    const lines = [];
+                    await runOnboardingCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        env: process.env,
+                        authPresent: credential !== null,
+                        interactive: false,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/onboarding: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/onboarding failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'vim': {
+                // Leak L26 (2026-05-27): /vim forwards to the shared
+                // `runVimCommand` runner so the slash + top-level surfaces
+                // stay single-sourced. Dynamic import mirrors /style so the
+                // dispatcher does not drag the vim module graph into every
+                // keystroke.
+                //
+                // The runner mutates `~/.pugi/config.json::vimMode`; the
+                // active REPL session does NOT live-pick-up the flip (the
+                // VimInput wrapper is mounted once at REPL boot). Operators
+                // get a hint that the next session will reflect the change.
+                // A follow-up sprint can plumb a state-store subscriber so
+                // the flip takes effect mid-session.
+                try {
+                    const { runVimCommand } = await import('../../runtime/commands/vim.js');
+                    const lines = [];
+                    await runVimCommand(verdict.args, {
+                        env: process.env,
+                        writeOutput: (_payload, text) => {
+                            for (const raw of text.split('\n')) {
+                                const trimmed = raw.replace(/\s+$/u, '');
+                                lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/vim: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/vim failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'doctor': {
+                // L17 (2026-05-27): run the doctor probe sweep inline. We
+                // dynamic-import the runtime/commands/doctor module so the
+                // slash dispatcher does not pull the diagnostics graph
+                // (execFileSync + fs probes) into every keystroke. The
+                // module's output is captured into local lines so we can
+                // render it as system entries in the conversation pane;
+                // an Ink-rendered table inside the REPL frame is a follow-up.
+                try {
+                    const { runDoctorCommand, defaultHome } = await import('../../runtime/commands/doctor.js');
+                    const lines = [];
+                    await runDoctorCommand({
+                        cwd: process.cwd(),
+                        home: defaultHome(),
+                        env: process.env,
+                        json: false,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/doctor: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/doctor failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'prd-check': {
+                // Wave 6 (2026-05-27): forward to the same handler the shell
+                // surface uses so the verdict is identical between
+                // `/prd-check` and `pugi prd-check`. Dynamic-import the
+                // module to keep the parser + verifier graph out of the
+                // REPL hot path.
+                //
+                // Wave 6 final (2026-05-27): the runner now also honours
+                // `--session` mode (orthogonal to the verifier graph — walks
+                // up for PRD.md, reads NDJSON turns, dispatches a cross-
+                // review subagent). We stream the runner's status lines
+                // directly to the system pane so the operator sees
+                // "Locating PRD..." / "Reviewing against PRD..." while the
+                // dispatch is in flight, then the structured Satisfied /
+                // Outstanding lists when it lands.
+                try {
+                    const { parsePrdCheckArgs, runPrdCheckCommand } = await import('../../runtime/commands/prd-check.js');
+                    const parsed = parsePrdCheckArgs(verdict.args, { jsonDefault: false });
+                    if (!parsed.ok) {
+                        this.appendSystemLine(`/prd-check: ${parsed.error}`);
+                        return verdict;
+                    }
+                    let sawOutput = false;
+                    await runPrdCheckCommand({
+                        cwd: process.cwd(),
+                        ...(parsed.prdPath !== undefined ? { prdPath: parsed.prdPath } : {}),
+                        flags: parsed.flags,
+                        // The REPL slash does not have a snapshot of the CLI
+                        // command registry, so we pass an empty set; the
+                        // command:<name> verifier will report FAIL for now.
+                        // This is a deliberate trade-off — the slash surface
+                        // primarily exists for quick eyeball checks during a
+                        // session; the shell surface (which DOES inject the
+                        // full registry) is the canonical gate.
+                        knownCommands: new Set(),
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0) {
+                                this.appendSystemLine(trimmed);
+                                sawOutput = true;
+                            }
+                        },
+                    });
+                    if (!sawOutput) {
+                        this.appendSystemLine('/prd-check: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/prd-check failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'chain': {
+                // Wave 6 (2026-05-27): forward to the shell-surface runner so
+                // the slash + top-level CLI share one parser + dispatcher.
+                // Dynamic import keeps the chain module out of the REPL hot
+                // path. The slash variant does NOT inject the live delegate
+                // wire-up — operators wanting full dispatch run `pugi chain
+                // next` from a fresh shell. The slash form is best-effort for
+                // status / show / list which are read-only.
+                try {
+                    const { runChainCommand } = await import('../../runtime/commands/chain.js');
+                    const lines = [];
+                    await runChainCommand(verdict.args, {
+                        cwd: process.cwd(),
+                        json: false,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/chain: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/chain failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'permissions': {
+                // Leak L6: handle the `/permissions [mode] [--persist]` flow.
+                // The session module forwards to the runtime helper so the
+                // workspace + global-config writes share one code path with
+                // the CLI's top-level `--mode` resolution. The dynamic import
+                // keeps the dispatcher free of a session.ts -> runtime/cli.ts
+                // cycle.
+                try {
+                    const { runPermissionsCommand } = await import('../../runtime/commands/permissions.js');
+                    const lines = [];
+                    await runPermissionsCommand(verdict, {
+                        workspaceRoot: process.cwd(),
+                        writeOutput: (line) => {
+                            const trimmed = line.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/permissions failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'compact': {
+                // Leak L8 (2026-05-27): /compact summarises older turns and
+                // appends a boundary marker. We forward to the same runner the
+                // top-level `pugi compact` command uses so the surface stays
+                // single-sourced. The session module owns the in-memory
+                // transcript echo (system line + banner row) so the operator
+                // sees the marker land without a fresh REPL bootstrap.
+                //
+                // Wave 6 BT 8 (Claude Code parity): `--force` bypasses the
+                // noop-empty guard so the operator can compact even short
+                // sessions (useful before a manual checkpoint).
+                await this.dispatchCompact('manual', { force: verdict.force });
+                return verdict;
+            }
+            case 'model': {
+                // Wave 6 BT 8 (Claude Code parity): /model lists OR selects the
+                // active model. Slash + top-level CLI share `runModelCommand`.
+                // The session module forwards writeOutput → appendSystemLine so
+                // the menu + the confirmation line land inline in the
+                // transcript. Tier override is undefined at the slash surface;
+                // the runner defaults to 'team' so unauthenticated operators
+                // see every model. Server-side calls enforce the real tier cap.
+                try {
+                    const { runModelCommand } = await import('../../runtime/commands/model.js');
+                    await runModelCommand({ slug: verdict.slug }, {
+                        workspaceRoot: process.cwd(),
+                        writeOutput: (line) => {
+                            const trimmed = line.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                this.appendSystemLine(trimmed);
+                            else
+                                this.appendSystemLine('');
+                        },
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/model failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'rewind': {
+                // Leak L9 (2026-05-27): /rewind appends an append-only
+                // tombstone marker that rolls the conversation back to a
+                // checkpoint. The actual replay-mask is advisory — the on-disk
+                // events stay durable so `pugi sessions undo-rewind` can
+                // reverse the operation. We forward to the same runner the
+                // top-level `pugi rewind` command uses to keep the surface
+                // single-sourced. Dynamic import avoids pulling the checkpoint
+                // graph into the dispatcher at module load.
+                if (!this.store || !this.localSessionId) {
+                    this.appendSystemLine('Local session store is disabled — /rewind is unavailable.');
+                    return verdict;
+                }
+                try {
+                    const { runRewindCommand } = await import('../../runtime/commands/rewind.js');
+                    await runRewindCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        sessionId: this.localSessionId,
+                        store: this.store,
+                        writeOutput: (_payload, text) => {
+                            if (text.length > 0)
+                                this.appendSystemLine(text);
+                        },
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/rewind failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'share': {
+                // Leak L20 (2026-05-27): /share forwards to the same runner the
+                // top-level `pugi share` command uses. The session module
+                // wires writeOutput to appendSystemLine so the upload result +
+                // privacy gate banner land in the REPL transcript inline.
+                // Confirmation prompt + readline still use stdio because the
+                // Ink frame is held by the input box; operators wanting fully
+                // scripted shares pass `--yes` so no prompt fires.
+                try {
+                    const { runShareCommand } = await import('../../runtime/commands/share.js');
+                    const lines = [];
+                    await runShareCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        cliVersion: this.options.cliVersion,
+                        sessionId: this.localSessionId ?? undefined,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/share: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/share failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'plan': {
+                // Leak L7: handle `/plan [--back | --persist] [<prompt>]`.
+                // The session module forwards the mode-switch portion to the
+                // shared runtime helper so the workspace + global-config writes
+                // share one code path with `pugi plan`. When the operator
+                // typed a prompt alongside (`/plan write me X`), the prompt is
+                // forwarded through the dispatch FSM exactly as if they had
+                // typed it directly — the only difference is the gate now
+                // refuses write/dispatch tools because the workspace mode flipped
+                // to plan first. Same dynamic-import trick as /permissions to
+                // avoid pulling the engine adapter graph into the dispatcher.
+                try {
+                    const { runPlanCommand } = await import('../../runtime/commands/plan.js');
+                    const lines = [];
+                    await runPlanCommand({ back: verdict.back, persist: verdict.persist }, {
+                        workspaceRoot: process.cwd(),
+                        writeOutput: (line) => {
+                            const trimmed = line.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    // Optional one-shot engine dispatch: when the operator typed
+                    // a prompt alongside the slash, route it through the existing
+                    // dispatch path. We rewrite the verdict into a synthetic
+                    // `dispatch` result so the engine sees the user's prompt with
+                    // the plan-mode gate already in place. `--auto-back` is NOT
+                    // honoured in the slash surface today — operators stay in
+                    // plan mode and revert manually with `/plan --back`. The CLI
+                    // top-level `pugi plan --auto-back` exists for scripted use.
+                    if (verdict.prompt.length > 0 && !verdict.back) {
+                        return { kind: 'dispatch', brief: verdict.prompt };
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/plan failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'release-notes': {
+                // Leak L24 (2026-05-27): changelog diff between the operator's
+                // last-seen + installed CLI versions. Delegate к the shared
+                // `runReleaseNotesCommand` runner so the slash + top-level
+                // paths stay single-sourced. The renderer collects each line
+                // into the system pane via `appendSystemLine` — no fresh Ink
+                // mount, no boxed render. `--reset` is honoured via the
+                // `verdict.reset` field parsed in slash-commands.ts.
+                try {
+                    const { runReleaseNotesCommand, defaultReleaseNotesHome } = await import('../../runtime/commands/release-notes.js');
+                    const lines = [];
+                    runReleaseNotesCommand({
+                        home: defaultReleaseNotesHome(),
+                        json: false,
+                        reset: verdict.reset,
+                        writeOutput: (_payload, text) => {
+                            for (const line of text.split('\n')) {
+                                lines.push(line.replace(/\s+$/u, ''));
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/release-notes: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/release-notes failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'stickers': {
+                // Leak L33 (2026-05-27): brand-personality gimmick. Delegate to
+                // the shared `runStickersCommand` so the slash + top-level
+                // paths stay single-sourced. The renderer routes the text
+                // through the system pane line-buffer (ascii-only — no fresh
+                // Ink mount) so the gimmick lands as a single contiguous
+                // block в the conversation transcript.
+                try {
+                    const { runStickersCommand } = await import('../../runtime/commands/stickers.js');
+                    // L33 P1 fix (2026-05-27): await the runner even though the
+                    // current implementation is synchronous. Two reasons:
+                    //   (1) future-proofs the call site against the runner growing
+                    //       an async path (e.g. remote stickerpack fetch) — without
+                    //       this await, a returned promise would resolve AFTER we
+                    //       flushed `lines` and the gimmick would render blank, and
+                    //   (2) keeps the slash dispatcher uniform with the other
+                    //       command runners (style, doctor, permissions, plan), all
+                    //       of which are awaited.
+                    const lines = [];
+                    await runStickersCommand({
+                        json: false,
+                        asciiOnly: true,
+                        writeOutput: (_payload, text) => {
+                            for (const line of text.split('\n')) {
+                                const trimmed = line.replace(/\s+$/u, '');
+                                lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/stickers: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/stickers failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'update': {
+                // Leak L27 (2026-05-27): /update probes the npm registry for a
+                // newer @pugi/cli version on the configured channel and prints
+                // the install command. The slash form NEVER spawns `npm install
+                // -g` — that would corrupt the binary we are currently running.
+                // Operators see the install command + run it manually (or run
+                // `pugi update --apply` from a fresh shell after the REPL
+                // exits). The slash + top-level paths share the dispatcher so
+                // channel resolution + last-check persistence stay single-
+                // sourced.
+                try {
+                    const { parseUpdateArgs, runUpdateCommand } = await import('../../runtime/commands/update.js');
+                    const parsed = parseUpdateArgs(verdict.args);
+                    if ('error' in parsed) {
+                        this.appendSystemLine(parsed.error);
+                        return verdict;
+                    }
+                    // Force `apply=false` on the slash path — see comment above.
+                    const slashFlags = { ...parsed, apply: false };
+                    const lines = [];
+                    await runUpdateCommand({
+                        cwd: process.cwd(),
+                        home: homedir(),
+                        env: process.env,
+                        flags: slashFlags,
+                        promptConfirm: async () => false,
+                        writeOutput: (_payload, text) => {
+                            for (const line of text.split('\n')) {
+                                const trimmed = line.replace(/\s+$/u, '');
+                                if (trimmed.length > 0)
+                                    lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/update: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/update failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'feedback': {
+                // Leak L21 (2026-05-27): in-CLI feedback collector. The wizard
+                // mounts a fresh Ink tree (renderFeedbackPrompt) outside the
+                // live REPL input box so the operator can step through
+                // category / rating / comment / context / confirm without
+                // interleaving with persona output. The session module owns
+                // the submit + queue wiring so the slash + top-level CLI
+                // surfaces stay single-sourced through `runFeedbackCommand`.
+                try {
+                    await this.runFeedbackSlash();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/feedback failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'repo-map': {
+                // Leak L28 (2026-05-27): AST-light workspace summary. Delegate
+                // к the shared `runRepoMapCommand` so the slash + top-level
+                // paths stay single-sourced. The rendered text lands on the
+                // system pane via `appendSystemLine` (no fresh Ink mount) so
+                // the listing flows into the conversation transcript like
+                // any other command output.
+                try {
+                    const { runRepoMapCommand } = await import('../../runtime/commands/repo-map.js');
+                    const lines = [];
+                    await runRepoMapCommand({
+                        cwd: process.cwd(),
+                        refresh: verdict.refresh,
+                        json: false,
+                        writeOutput: (_payload, text) => {
+                            for (const line of text.split('\n')) {
+                                const trimmed = line.replace(/\s+$/u, '');
+                                lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/repo-map: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/repo-map failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'undo': {
+                // Wave 6 final (2026-05-27): graduated from stub. The runtime
+                // command `runUndoCommand` already exists with full Aider walk-
+                // back semantics — single-step revert of the most recent
+                // successful `write` / `edit` / `multi_edit` tool result, with
+                // an mtime+hash gate that refuses to overwrite uncommitted
+                // operator work. We open a fresh PugiSession against the cwd
+                // so the inverse-mutation audit lands on the same NDJSON
+                // events stream the REPL writes to; dynamic-import keeps the
+                // runner + git plumbing out of the REPL hot path.
+                try {
+                    const [{ runUndoCommand }, { openSession }] = await Promise.all([
+                        import('../../runtime/commands/undo.js'),
+                        import('../session.js'),
+                    ]);
+                    const workspaceRoot = process.cwd();
+                    const session = openSession(workspaceRoot);
+                    this.appendSystemLine('Reverting last write...');
+                    await runUndoCommand([], {
+                        workspaceRoot,
+                        session,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                this.appendSystemLine(trimmed);
+                        },
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/undo failed: ${message}`);
+                }
+                return verdict;
+            }
             case 'stub': {
                 this.appendSystemLine(verdict.message);
                 return verdict;
             }
         }
     }
+    /**
+     * Leak L21 (2026-05-27): drive the `/feedback` wizard from inside
+     * the REPL. Mounts the Ink prompt, collects the draft, hands it to
+     * `runFeedbackCommand` (which routes to submit-now or
+     * queue-locally), then writes the operator-facing toast to the
+     * conversation system pane.
+     *
+     * The session module owns the wiring (cwd, cliVersion, apiUrl,
+     * apiKey, transcript provider) so the slash + top-level CLI paths
+     * stay single-sourced through `runFeedbackCommand`.
+     */
+    async runFeedbackSlash() {
+        const { renderFeedbackPrompt } = await import('../../tui/feedback-prompt.js');
+        const { runFeedbackCommand, renderFeedbackToast } = await import('../../runtime/commands/feedback.js');
+        const { submitFeedback, redactSessionContext } = await import('../feedback/submitter.js');
+        const verdict = await renderFeedbackPrompt();
+        if (verdict.cancelled || !verdict.draft) {
+            this.appendSystemLine('Feedback cancelled. Nothing was sent.');
+            return;
+        }
+        // Build a session-context provider that reads the LAST 5 turns
+        // from the live transcript + applies the redactor. Only invoked
+        // when the operator opted in on step 4.
+        const sessionContextProvider = () => {
+            const last5 = this.state.transcript
+                .filter((row) => row.source !== 'system')
+                .slice(-5)
+                .map((row) => ({
+                role: row.source === 'operator' ? 'user' : 'assistant',
+                text: row.text,
+            }));
+            // The workspace context exposed to the session does not carry
+            // a git branch field today, so we omit `gitBranch` here. When
+            // `ReplWorkspaceContext` gains the field we can forward it via
+            // an extra options entry without changing the redactor contract.
+            return redactSessionContext(last5);
+        };
+        const result = await runFeedbackCommand({
+            cwd: process.cwd(),
+            cliVersion: this.options.cliVersion,
+            submit: async (env) => submitFeedback(env, {
+                apiUrl: this.options.apiUrl,
+                apiKey: this.options.apiKey,
+            }),
+            draft: verdict.draft,
+            sessionContext: sessionContextProvider,
+        });
+        this.appendSystemLine(renderFeedbackToast(result));
+    }
+    /**
+     * Leak L8 (2026-05-27): drive the `/compact` flow from inside the
+     * REPL. Reuses the standalone runner so the wire shape + reason
+     * codes stay single-sourced. The result is echoed into the
+     * transcript as a system line; on success the operator sees the
+     * banner sentinel on next render.
+     *
+     * `trigger='manual'` for explicit `/compact` invocations;
+     * `trigger='auto'` for the threshold gate. The runner records the
+     * trigger in the marker payload so the banner can distinguish them.
+     */
+    async dispatchCompact(trigger, options = {}) {
+        if (!this.store || !this.localSessionId) {
+            this.appendSystemLine('Local session store is disabled — /compact is unavailable.');
+            return;
+        }
+        try {
+            const { runCompactCommand } = await import('../../runtime/commands/compact.js');
+            const result = await runCompactCommand([], {
+                workspaceRoot: process.cwd(),
+                sessionId: this.localSessionId,
+                store: this.store,
+                trigger,
+                force: options.force === true,
+                writeOutput: (_payload, text) => {
+                    if (text.length > 0)
+                        this.appendSystemLine(text);
+                },
+            });
+            if (result.status === 'compacted') {
+                // L29 (2026-05-27): emit a structured `compact-boundary` row so
+                // the conversation pane routes the marker through the dedicated
+                // `<CompactBanner />` Ink component (gray, terminal-width
+                // separator) instead of leaking the raw text into a `system`
+                // row. The plain-text body is kept as a deterministic fallback
+                // for non-Ink consumers (snapshot tests, JSON-mode exports).
+                const turnsBefore = result.turnsBefore ?? 0;
+                this.appendRow({
+                    source: 'compact-boundary',
+                    text: `─── context compacted (${turnsBefore} turns → 1 summary, ${trigger}) ───`,
+                    compaction: {
+                        turnsBefore,
+                        trigger,
+                        summaryTokenCount: result.tokensSummarised,
+                        // Fresh in-REPL compaction lands at the head of the
+                        // transcript — no turns have followed it yet.
+                        turnsAgo: 0,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.appendSystemLine(`/compact failed: ${message}`);
+        }
+    }
     /**
      * In-REPL `/privacy` - alpha 6.13. Prints the full 3-mode contract
      * doc + the current mode banner inline. The current mode is fetched
@@ -938,22 +1909,195 @@ export class ReplSession {
             this.appendSystemLine(`/diff failed: ${this.errorMessage(error)}`);
         }
     }
-    dispatchCost() {
-        const { tokensDownstreamTotal, agents } = this.state;
+    async dispatchCost() {
+        // α7 cost-meter sprint — full breakdown matching the TUI status row
+        // footer. The session totals line mirrors the footer format
+        // (`↑ <in> ↓ <out> · $X.XX · <elapsed>`) so the operator scans the
+        // same numbers in two places. Per-turn list shows the last 5 turns
+        // oldest → newest; an empty list renders one system line so the
+        // operator knows the surface is wired (`No completed turns yet.`).
+        //
+        // L19 (2026-05-27) — after the in-memory recap, also render the
+        // persisted per-model table from `.pugi/cost.json`. That surface
+        // survives a REPL restart and answers the "what did I spend on
+        // claude-opus vs qwen this week?" question the in-memory recap can
+        // not. Errors loading the file collapse to a single warning line so
+        // the in-memory recap (the older, well-tested surface) is never
+        // gated behind a fresh dependency.
+        const { sessionTokensIn, sessionTokensOut, sessionCostUsd, sessionStartedAtEpochMs, recentTurns, agents, } = this.state;
         const active = agents.filter((a) => a.status === 'queued' || a.status === 'thinking').length;
-        const lineTokens = `Tokens this session: ${tokensDownstreamTotal.toLocaleString()} (in+out).`;
-        const lineAgents = `Active dispatches: ${active} of cap.`;
-        this.appendSystemLine(lineTokens);
-        this.appendSystemLine(lineAgents);
-        this.appendSystemLine('Full per-persona budget breakdown lands in α6.5.');
-    }
-    dispatchStatus() {
-        const sessionId = this.state.sessionId ?? '(unbound)';
-        const reach = this.state.connection;
-        this.appendSystemLine(`Backend: ${this.options.apiUrl} (${reach}).`);
-        this.appendSystemLine(`Session: ${sessionId}.`);
-        this.appendSystemLine(`Workspace: ${this.state.workspaceLabel}.`);
-        this.appendSystemLine(`CLI: pugi ${this.state.cliVersion}.`);
+        const elapsedMs = Math.max(0, this.now() - sessionStartedAtEpochMs);
+        const elapsedLabel = formatElapsedShort(elapsedMs);
+        this.appendSystemLine(`Session: ↑ ${formatTokens(sessionTokensIn)} ↓ ${formatTokens(sessionTokensOut)} · ${formatCostUsd(sessionCostUsd)} · ${elapsedLabel}`);
+        this.appendSystemLine(`Active dispatches: ${active} of cap.`);
+        if (recentTurns.length === 0) {
+            this.appendSystemLine('No completed turns yet — brief the workforce to charge the meter.');
+        }
+        else {
+            this.appendSystemLine(`Recent turns (last ${recentTurns.length}):`);
+            for (let i = 0; i < recentTurns.length; i += 1) {
+                const turn = recentTurns[i];
+                const idx = (i + 1).toString().padStart(2, ' ');
+                this.appendSystemLine(`  ${idx}. ↑ ${formatTokens(turn.tokensIn)} ↓ ${formatTokens(turn.tokensOut)} · ${formatCostUsd(turn.costUsd)}`);
+            }
+        }
+        // L19: append the persisted per-model table from .pugi/cost.json.
+        try {
+            const [{ createCostTracker }, { renderCostForSlash }] = await Promise.all([
+                import('../cost/tracker.js'),
+                import('../../runtime/commands/cost.js'),
+            ]);
+            const workspaceRoot = this.options.workspace?.workspaceCwd ?? process.cwd();
+            const sessionId = this.state.sessionId ?? 'no-session';
+            const tracker = createCostTracker({
+                workspaceRoot,
+                sessionIdProvider: () => sessionId,
+                now: () => this.now(),
+            });
+            const current = tracker.current();
+            if (current && Object.keys(current.models).length > 0) {
+                this.appendSystemLine('');
+                const { lines } = renderCostForSlash({
+                    tracker,
+                    allSessions: false,
+                    windowDays: 30,
+                    now: () => this.now(),
+                });
+                for (const line of lines)
+                    this.appendSystemLine(line);
+            }
+        }
+        catch {
+            // best-effort — the persisted view is additive; failure never
+            // breaks the in-memory recap above
+        }
+    }
+    /**
+     * α7 cost-meter sprint — `/quota` slash handler. Fetches the live
+     * `/api/pugi/usage` snapshot and renders three lines: plan tier,
+     * monthly window, and per-counter `used/cap (pct%)`. Failure modes
+     * (offline, unauth, older admin-api) collapse to a single one-line
+     * `Could not fetch quota…` system message so the surface never throws
+     * from a keystroke handler.
+     *
+     * The fetch is best-effort with a 4s timeout — mirrors the `whoami`
+     * pattern in `runtime/cli.ts` so the operator gets the same UX on the
+     * REPL slash and the CLI command.
+     */
+    async dispatchQuota() {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 4000);
+        try {
+            const url = `${this.options.apiUrl.replace(/\/+$/, '')}/api/pugi/usage`;
+            const res = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    authorization: `Bearer ${this.options.apiKey}`,
+                    accept: 'application/json',
+                },
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                this.appendSystemLine(`Could not fetch quota: HTTP ${res.status}.`);
+                return;
+            }
+            const body = (await res.json());
+            const tier = typeof body.tier === 'string' ? body.tier : '(unknown)';
+            const tierLabel = QUOTA_TIER_LABELS[tier] ?? tier;
+            const month = typeof body.billingMonth === 'string' ? body.billingMonth : '(unknown month)';
+            const resetAt = typeof body.resetAt === 'string' ? body.resetAt : null;
+            const resetLine = resetAt ? ` · resets ${formatResetWindow(resetAt, this.now())}` : '';
+            this.appendSystemLine(`Plan: ${tierLabel} · ${month}${resetLine}`);
+            const used = body.used ?? {};
+            const caps = body.quotas ?? {};
+            const counters = [
+                ['sync', used.sync, caps.sync],
+                ['review', used.review, caps.review],
+                ['engine', used.engine, caps.engine],
+            ];
+            for (const [name, value, cap] of counters) {
+                const v = typeof value === 'number' ? value : 0;
+                if (cap === null || cap === undefined) {
+                    this.appendSystemLine(`  ${name.padEnd(7, ' ')} ${v.toLocaleString()} / unlimited`);
+                }
+                else {
+                    const pct = cap > 0 ? Math.round((v / cap) * 100) : 0;
+                    this.appendSystemLine(`  ${name.padEnd(7, ' ')} ${v.toLocaleString()} / ${cap.toLocaleString()} (${pct}%)`);
+                }
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.appendSystemLine(`Could not fetch quota: ${msg}.`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * In-REPL `/status` — Leak L34 (2026-05-27). Surfaces the full
+     * session snapshot (id + age, cwd, permission mode, CLI version,
+     * tokens, dispatches, last cmd, compact boundaries, auth identity,
+     * connection) by delegating к the same `runStatusCommand` the
+     * top-level `pugi status` shell uses. Live REPL state (session
+     * id, token totals, last operator command) flows in through the
+     * context so the slash variant shows MORE than the shell path.
+     *
+     * The renderer routes к the system pane via `appendSystemLine`
+     * so the snapshot lands as a single contiguous block в the
+     * conversation transcript. Migrating к the Ink `<StatusTable>`
+     * mounted directly в the REPL frame is a follow-up sprint —
+     * keeping the line-buffered path here avoids cycling the
+     * conversation pane's render model mid-α7.
+     */
+    async dispatchStatus() {
+        try {
+            const { runStatusCommand, defaultStatusHome } = await import('../../runtime/commands/status.js');
+            // Find the most-recent operator transcript row + its timestamp
+            // so the snapshot's `Last cmd` field has real content в REPL
+            // mode. Walking от newest end is O(transcript) worst case but
+            // bounded by MAX_TRANSCRIPT_ROWS so this stays cheap.
+            let lastCommand = null;
+            let lastCommandAtEpochMs = null;
+            for (let i = this.state.transcript.length - 1; i >= 0; i -= 1) {
+                const row = this.state.transcript[i];
+                if (row.source === 'operator') {
+                    lastCommand = row.text;
+                    lastCommandAtEpochMs = row.timestampEpochMs;
+                    break;
+                }
+            }
+            const liveTokens = this.state.sessionTokensIn + this.state.sessionTokensOut;
+            const lines = [];
+            await runStatusCommand({
+                cwd: process.cwd(),
+                home: defaultStatusHome(),
+                env: process.env,
+                json: false,
+                liveSessionId: this.state.sessionId ?? null,
+                sessionStartedAtEpochMs: this.state.sessionStartedAtEpochMs,
+                liveTokensUsed: liveTokens >= 0 ? liveTokens : 0,
+                lastCommand,
+                lastCommandAtEpochMs,
+                writeOutput: (_payload, text) => {
+                    for (const line of text.split('\n')) {
+                        const trimmed = line.replace(/\s+$/u, '');
+                        if (trimmed.length > 0)
+                            lines.push(trimmed);
+                    }
+                },
+            });
+            if (lines.length === 0) {
+                this.appendSystemLine('/status: no output.');
+                return;
+            }
+            for (const line of lines)
+                this.appendSystemLine(line);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.appendSystemLine(`/status failed: ${message}`);
+        }
     }
     /**
      * α6.5 `/context` slash handler. Surfaces the three-tier context
@@ -1136,7 +2280,10 @@ export class ReplSession {
             this.appendSystemLine(capLine);
         }
         this.appendOperatorLine(brief);
-        this.patch({ briefStartedAtEpochMs: this.now() });
+        // Reset `lastCompletedOutcome` so a fresh dispatch does not
+        // inherit the prior turn's status-bar label (e.g. a stale
+        // "replied" sticking around while the next dispatch is in flight).
+        this.patch({ briefStartedAtEpochMs: this.now(), lastCompletedOutcome: null });
         // α6.9 + R3 P1 (Codex triple-review 2026-05-25): supersede the
         // prior dispatch when one is in flight. Steps in order:
         //
@@ -1463,6 +2610,7 @@ export class ReplSession {
                 apiUrl: this.options.apiUrl,
                 apiKey: this.options.apiKey,
                 workspace: this.options.workspace,
+                cyberZoo: this.options.cyberZoo,
             });
             this.patch({ sessionId, connection: 'connecting' });
             this.openStream();
@@ -1619,8 +2767,22 @@ export class ReplSession {
             }
             case 'agent.tokens': {
                 const delta = event.tokensIn + event.tokensOut;
+                // α7 cost-meter sprint — bind a client-side USD figure to this
+                // frame. The model slug rides on the event (optional for back-
+                // compat); the price ladder in `model-pricing.ts` falls back to
+                // a Sonnet-tier rate when the slug is missing, so the meter is
+                // always populated. Negative / NaN values are clamped to zero
+                // inside `computeCostUsd` so a buggy upstream never credits the
+                // meter.
+                const deltaCostUsd = computeCostUsd(event.tokensIn, event.tokensOut, event.model);
                 this.patch({
                     tokensDownstreamTotal: this.state.tokensDownstreamTotal + delta,
+                    sessionTokensIn: this.state.sessionTokensIn + event.tokensIn,
+                    sessionTokensOut: this.state.sessionTokensOut + event.tokensOut,
+                    sessionCostUsd: this.state.sessionCostUsd + deltaCostUsd,
+                    turnTokensIn: this.state.turnTokensIn + event.tokensIn,
+                    turnTokensOut: this.state.turnTokensOut + event.tokensOut,
+                    turnCostUsd: this.state.turnCostUsd + deltaCostUsd,
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
                         ? {
                             ...a,
@@ -1640,10 +2802,36 @@ export class ReplSession {
                 }
                 this.askBuffer.delete(event.taskId);
                 this.askBufferPending.delete(event.taskId);
+                // Honour the work-done signal from admin-api.
+                // `outcome === 'replied'` means the turn was a pure text reply
+                // with no delegate XML and no tool call — render it as
+                // "replied" so the operator can tell the difference between
+                // "the orchestrator just talked" and "real work shipped".
+                // Older servers omit the field; default to 'shipped' so the
+                // existing wire stays back-compat.
+                const completedStatus = event.outcome === 'replied' ? 'replied' : 'shipped';
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
-                        ? { ...a, status: 'shipped', detail: 'shipped' }
+                        ? { ...a, status: completedStatus, detail: completedStatus }
                         : a),
+                    // Mirror the outcome to top-level state so the status-bar
+                    // can render `replied` instead of the legacy `shipped`
+                    // label when the FSM lands in `completed`. Without this
+                    // the bottom-bar would still say "shipped" while the
+                    // agent-tree said "replied", restoring the same
+                    // contradiction this PR is fixing (Codex triple-review P2).
+                    //
+                    // r2: gate on the same stale-dispatch check that
+                    // advanceFsmOnDispatchEnd applies. If this completion
+                    // belongs to a SUPERSEDED dispatch (a newer dispatchBrief
+                    // already bumped dispatchSeq before this late terminal
+                    // arrived), don't let the status-bar label flip to the
+                    // stale outcome — the current turn is the live one.
+                    // The agent-tree row patch above is still safe because
+                    // it only updates the row keyed by taskId.
+                    ...(this.isStaleTaskEvent(event.taskId)
+                        ? {}
+                        : { lastCompletedOutcome: completedStatus }),
                 });
                 // α6.9: transition the FSM to `completed` when no other
                 // dispatch is still in flight. The check uses the agents list
@@ -1651,6 +2839,12 @@ export class ReplSession {
                 // the dispatch alive; the FSM only goes terminal when the last
                 // agent ships.
                 this.advanceFsmOnDispatchEnd('completed', 'agent_completed', event.taskId);
+                // α7 cost-meter sprint — flush the per-turn delta when the
+                // LAST agent settles. Decoupled from the FSM gate so a test
+                // fixture (or a single-agent dispatch that never reached
+                // `awaiting_response` — happens on instant SSE replay) still
+                // gets the row written into recentTurns + lastTurnDelta.
+                this.maybeFlushTurnOnAgentSettle(event.taskId);
                 if (target) {
                     // If the persona actually produced a reply via incremental
                     // agent.step events, render that reply in the transcript so
@@ -1716,6 +2910,10 @@ export class ReplSession {
                 // operator sees the bottom-bar settle back to `idle` after the
                 // last block clears.
                 this.advanceFsmOnDispatchEnd('completed', 'agent_blocked', event.taskId);
+                // α7 cost-meter sprint — flush the per-turn delta (blocked
+                // still counts as a billable turn — the operator paid for the
+                // tokens that landed before the refusal).
+                this.maybeFlushTurnOnAgentSettle(event.taskId);
                 return;
             }
             case 'agent.failed': {
@@ -1739,6 +2937,10 @@ export class ReplSession {
                 // `completed` so the bottom-bar surface tracks the dispatch
                 // collectively.
                 this.advanceFsmOnDispatchEnd('failed', 'agent_failed', event.taskId);
+                // α7 cost-meter sprint — flush the per-turn delta when the
+                // dispatch fails (the operator still paid for whatever tokens
+                // landed before the failure).
+                this.maybeFlushTurnOnAgentSettle(event.taskId);
                 return;
             }
         }
@@ -1777,13 +2979,25 @@ export class ReplSession {
      * after a manual `cancel()` finds the FSM already in `aborted` and
      * is silently dropped.
      */
+    /**
+     * 2026-05-26 — shared stale-task check used by both the FSM advance
+     * gate AND the status-bar `lastCompletedOutcome` mirror. Lifts the
+     * R2 dispatchSeq compare out of `advanceFsmOnDispatchEnd` so other
+     * agent.completed-handler side-effects (status-bar label, future
+     * metric counters) can apply the same guard without duplicating it.
+     * Returns true iff the task's stamped dispatchSeq is older than the
+     * current dispatchSeq — i.e. a newer dispatchBrief() superseded it
+     * and the late terminal event must not corrupt live-turn state.
+     */
+    isStaleTaskEvent(taskId) {
+        const taskSeq = this.taskDispatchSeq.get(taskId);
+        return taskSeq !== undefined && taskSeq < this.dispatchSeq;
+    }
     advanceFsmOnDispatchEnd(outcome, reason, taskId) {
         // R2 P1 fix (Codex triple-review 2026-05-25): a terminal event
         // for a SUPERSEDED dispatch must NOT advance the live FSM or null
-        // the live token. If the event carries a taskId and the stamped
-        // dispatchSeq for that task is older than the current dispatchSeq,
-        // the event belongs to a prior dispatch that was replaced by a
-        // newer `dispatchBrief()`. Silently drop the FSM advance.
+        // the live token. Delegates to isStaleTaskEvent so the agent.completed
+        // status-bar mirror in the handler above uses the same gate.
         if (taskId !== undefined) {
             const taskSeq = this.taskDispatchSeq.get(taskId);
             if (taskSeq !== undefined && taskSeq < this.dispatchSeq) {
@@ -1815,6 +3029,63 @@ export class ReplSession {
         this.currentDispatchToken = null;
         this.patch({ briefStartedAtEpochMs: undefined });
     }
+    /**
+     * α7 cost-meter sprint — gate the per-turn flush on "this was the
+     * LAST in-flight agent". Mirrors the `stillActive` guard inside
+     * `advanceFsmOnDispatchEnd` so a multi-agent dispatch only emits a
+     * single recentTurns row + a single lastTurnDelta flash.
+     *
+     * Idempotent: if no tokens have been billed this turn, the inner
+     * `flushTurnAccumulator` short-circuits without pushing an empty row.
+     */
+    maybeFlushTurnOnAgentSettle(taskId) {
+        const stillActive = this.state.agents.some((a) => a.status === 'queued' || a.status === 'thinking');
+        if (stillActive)
+            return;
+        this.flushTurnAccumulator(taskId);
+    }
+    /**
+     * α7 cost-meter sprint — flush the per-turn accumulator into
+     * `recentTurns` + `lastTurnDelta`. Idempotent + safe to call from any
+     * terminal-state branch (`agent.completed` / `agent.blocked` /
+     * `agent.failed`). When no tokens have been billed this turn
+     * (instant abort, cap-warning gate), the helper short-circuits
+     * without pushing an empty row.
+     */
+    flushTurnAccumulator(taskId) {
+        const turnTokensIn = this.state.turnTokensIn;
+        const turnTokensOut = this.state.turnTokensOut;
+        const turnCostUsd = this.state.turnCostUsd;
+        if (turnTokensIn === 0 && turnTokensOut === 0) {
+            // Idempotent zero-flush — never push an empty row into recentTurns.
+            return;
+        }
+        const turnId = taskId !== undefined ? taskId : `turn-${this.dispatchSeq}-${this.now()}`;
+        const newTurn = {
+            id: turnId,
+            tokensIn: turnTokensIn,
+            tokensOut: turnTokensOut,
+            costUsd: turnCostUsd,
+            completedAt: new Date(this.now()).toISOString(),
+        };
+        // Keep the buffer capped at 5 entries (oldest first). The push
+        // order matches the surface contract: `/cost` paginates oldest →
+        // newest so the operator scans top-down chronologically.
+        const recent = [...this.state.recentTurns, newTurn];
+        const trimmed = recent.length > 5 ? recent.slice(-5) : recent;
+        this.patch({
+            recentTurns: trimmed,
+            lastTurnDelta: {
+                tokensIn: turnTokensIn,
+                tokensOut: turnTokensOut,
+                costUsd: turnCostUsd,
+                completedAtEpochMs: this.now(),
+            },
+            turnTokensIn: 0,
+            turnTokensOut: 0,
+            turnCostUsd: 0,
+        });
+    }
     /* ------------- transcript helpers -------------- */
     /**
      * Look up the persona slug for a running task. Used by the tool call
@@ -1871,13 +3142,14 @@ export class ReplSession {
         this.appendRow({ source: 'persona', text: stripped, personaSlug });
     }
     appendRow(input) {
-        if (input.text.length === 0)
+        if (input.text.length === 0 && input.source !== 'compact-boundary')
             return;
         const row = {
             id: randomUUID(),
             source: input.source,
             text: input.text,
             personaSlug: input.personaSlug,
+            compaction: input.compaction,
             timestampEpochMs: this.now(),
         };
         const next = this.state.transcript.concat(row).slice(-MAX_TRANSCRIPT_ROWS);
@@ -1890,6 +3162,62 @@ export class ReplSession {
         //   persona  -> 'persona'
         //   system   -> 'system'
         this.persistRow(row);
+        // Leak L8 (2026-05-27): evaluate the auto-compact gate after
+        // every appendRow that produces a transcript turn. Wrapped in a
+        // setImmediate so the gate never blocks the input-handling fast
+        // path; if the threshold is tripped, the auto-trigger dispatches
+        // `/compact` in the background while the operator keeps typing.
+        if (row.source === 'operator' || row.source === 'persona') {
+            this.maybeAutoCompact();
+        }
+    }
+    /**
+     * Auto-compact gate. Cheap: builds an in-memory token estimate from
+     * the current transcript and consults `evaluateAutoCompact`. When the
+     * gate fires AND a compaction is not already in flight, we dispatch
+     * `/compact` with `trigger='auto'`. The fire-and-forget shape means
+     * the input box stays responsive while the background round-trip
+     * runs.
+     *
+     * Hysteresis: `compactionInFlight` blocks re-entry. The gate is
+     * cleared when the dispatch promise resolves regardless of outcome
+     * so a transient transport failure does not permanently disable the
+     * auto-trigger.
+     */
+    compactionInFlight = false;
+    maybeAutoCompact() {
+        if (this.compactionInFlight)
+            return;
+        if (!this.store || !this.localSessionId)
+            return;
+        if (process.env['PUGI_AUTOCOMPACT_DISABLED'] === '1')
+            return;
+        // Token estimate from the in-memory transcript. The estimate is a
+        // lower bound on actual context pressure (server-side system
+        // prompts add overhead) but the 4-char/token heuristic plus the
+        // 0.75 default threshold gives generous headroom.
+        const texts = this.state.transcript.map((r) => r.text);
+        const tokenCount = estimateTokensInMany(texts);
+        // Conservative default: assume the smallest commonly-used window
+        // (32k tokens for deepseek-v3.1). Resolving the live model slug
+        // through DispatchFSM + admin-api adds latency on a hot path; the
+        // 0.75 threshold + smallest-window assumption errs toward
+        // EARLY trigger which is the safe direction.
+        const verdict = evaluateAutoCompact({
+            tokenCount,
+            windowSize: 32_000,
+        });
+        if (verdict.kind !== 'fire')
+            return;
+        this.compactionInFlight = true;
+        void (async () => {
+            try {
+                await this.dispatchCompact('auto');
+            }
+            finally {
+                this.compactionInFlight = false;
+            }
+        })();
     }
     /**
      * Best-effort write of one transcript row into the local
@@ -1900,6 +3228,15 @@ export class ReplSession {
     persistRow(row) {
         if (!this.store)
             return;
+        // L29 (2026-05-27): `compact-boundary` transcript rows are echoes of
+        // the JSONL `compaction` event the compact runner already appended
+        // via `appendCompactBoundary`. Persisting them here would double-
+        // write the marker (and worse, with a stripped payload that lacks
+        // `summary` / `coversUntilOffset`) — `isCompactBoundary` would
+        // reject the duplicate but `applyCompactMask` would still index off
+        // the wrong offset. Skip the write.
+        if (row.source === 'compact-boundary')
+            return;
         const kind = row.source === 'operator' ? 'user'
             : row.source === 'persona' ? 'persona'
                 : 'system';
@@ -1940,12 +3277,30 @@ export class ReplSession {
      * write the restored events.
      */
     restoreTranscript(events) {
+        // Leak L8 (2026-05-27): apply compact-boundary masking BEFORE the
+        // row conversion. Events strictly before the latest marker are
+        // condensed into the boundary's `keptTailTurns + marker` slice so
+        // the post-resume transcript starts at the most-recent context
+        // floor rather than re-playing the full pre-compaction history.
+        //
+        // Leak L9 (2026-05-27): then apply rewind-marker masking. Any
+        // event inside an active rewind range is stripped from the
+        // visible transcript; the on-disk events stay durable so a
+        // follow-up `pugi sessions undo-rewind` can restore them.
+        const masked = applyRewindMask(applyCompactMask(events));
         const rows = [];
-        for (const event of events) {
+        for (const event of masked) {
             const row = eventToTranscriptRow(event);
             if (row)
                 rows.push(row);
         }
+        // L29 (2026-05-27): tag each compact-boundary row with the count of
+        // operator + persona turns that landed AFTER it in the replay
+        // window. The banner reads `turnsAgo` to render the "N turns ago"
+        // suffix so a long session that resumes across multiple compactions
+        // stays self-orienting. System rows + sibling boundaries are NOT
+        // counted — they are chrome, not operator-visible turns.
+        annotateBoundaryTurnsAgo(rows);
         // Cap at MAX_TRANSCRIPT_ROWS - the same cap appendRow uses so the
         // window math stays consistent post-restore.
         const capped = rows.slice(-MAX_TRANSCRIPT_ROWS);
@@ -2129,8 +3484,71 @@ function eventToTranscriptRow(event) {
             timestampEpochMs: event.t,
         };
     }
+    if (event.kind === 'compaction') {
+        // L8 + L29 (2026-05-27): render the marker as a structured
+        // `compact-boundary` row so the renderer can route it to the
+        // dedicated <CompactBanner /> Ink component. The full summary text
+        // is intentionally NOT inlined here (a 2k-token summary in the
+        // transcript would defeat the purpose of compacting); the operator
+        // sees the "context compacted" banner and can run `/context` to
+        // inspect the marker payload when they want the details. The plain
+        // text fallback stays in place for non-Ink consumers (snapshot
+        // tests, future JSON exports).
+        const compactionPayload = (event.payload ?? null);
+        const trigger = compactionPayload?.trigger === 'auto' ? 'auto' : 'manual';
+        const turns = typeof compactionPayload?.summaryTurnsBefore === 'number'
+            ? compactionPayload.summaryTurnsBefore
+            : 0;
+        const tokens = typeof compactionPayload?.summaryTokenCount === 'number'
+            ? compactionPayload.summaryTokenCount
+            : undefined;
+        return {
+            id: randomUUID(),
+            source: 'compact-boundary',
+            text: `─── context compacted (${turns} turns → 1 summary, ${trigger}) ───`,
+            compaction: {
+                turnsBefore: turns,
+                trigger,
+                summaryTokenCount: tokens,
+            },
+            timestampEpochMs: event.t,
+        };
+    }
     return null;
 }
+/**
+ * L29 (2026-05-27): walk a chronological transcript window and stamp
+ * every `compact-boundary` row's `compaction.turnsAgo` with the count of
+ * operator + persona rows that land AFTER it. The annotation runs in
+ * place on the array — boundaries earlier in time get larger `turnsAgo`
+ * values, the boundary at the head of the window gets zero. System rows
+ * and sibling boundaries are excluded from the count (they are chrome,
+ * not operator-visible turns).
+ *
+ * Exported so a future spec can lock the contract and so the in-REPL
+ * `/compact` path can reuse the same counter on live appends if it ever
+ * needs to. Pure function (mutates only the input slice).
+ */
+export function annotateBoundaryTurnsAgo(rows) {
+    let trailingTurns = 0;
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        if (row.source === 'operator' || row.source === 'persona') {
+            trailingTurns += 1;
+            continue;
+        }
+        if (row.source === 'compact-boundary') {
+            // Re-assign with the live `turnsAgo`. Carry forward the existing
+            // structured payload so we never lose the trigger / token-count
+            // data the renderer needs.
+            const compaction = row.compaction ?? { turnsBefore: 0, trigger: 'manual' };
+            rows[i] = {
+                ...row,
+                compaction: { ...compaction, turnsAgo: trailingTurns },
+            };
+        }
+    }
+}
 /**
  * Heuristic: does this text contain Markdown structures that benefit
  * from atomic grouping? Code fences, bullet lists, numbered lists,
@@ -2197,6 +3615,62 @@ function formatAgeSeconds(deltaMs) {
 export function knownRoles() {
     return listRoles();
 }
+/**
+ * α7 cost-meter sprint — render a session-elapsed ms delta as the
+ * status-row's compact `XmYs` / `XhYm` shape. Distinct from
+ * `formatAgeSeconds` above because `/cost` needs minute-granularity
+ * uniformly (operator wants `2m44s`, not `2m`). Pure / branch-cheap;
+ * the TUI status row + `/cost` both call this on every render.
+ */
+function formatElapsedShort(elapsedMs) {
+    if (!Number.isFinite(elapsedMs) || elapsedMs <= 0)
+        return '0s';
+    const totalSec = Math.floor(elapsedMs / 1000);
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    const min = Math.floor(totalSec / 60);
+    const sec = totalSec % 60;
+    if (min < 60)
+        return `${min}m${sec.toString().padStart(2, '0')}s`;
+    const hr = Math.floor(min / 60);
+    const restMin = min % 60;
+    return `${hr}h${restMin.toString().padStart(2, '0')}m`;
+}
+/**
+ * α7 cost-meter sprint — public-facing tier labels for the `/quota`
+ * slash. Mirrors `TIER_PRICE_LABEL` in `runtime/cli.ts` (kept in sync
+ * via `pricing.spec.ts` gate). Falls through to the raw slug when an
+ * unknown tier ships from a forward-compat admin-api build.
+ */
+const QUOTA_TIER_LABELS = Object.freeze({
+    free: 'Free',
+    founder: 'Founder ($20/mo)',
+    builder: 'Builder ($99/mo)',
+    team: 'Team ($199/mo)',
+});
+/**
+ * α7 cost-meter sprint — render the time-until-reset window for the
+ * `/quota` plan line. `resetAt` is the ISO string admin-api returns;
+ * `now` is the current epoch ms (injected for test determinism). Falls
+ * back to the raw ISO string when parsing fails so the operator never
+ * sees an empty hint.
+ */
+function formatResetWindow(resetAtIso, nowEpochMs) {
+    const resetMs = Date.parse(resetAtIso);
+    if (!Number.isFinite(resetMs))
+        return resetAtIso;
+    const deltaMs = resetMs - nowEpochMs;
+    if (deltaMs <= 0)
+        return 'now';
+    const days = Math.floor(deltaMs / (24 * 60 * 60 * 1000));
+    if (days >= 2)
+        return `in ${days}d`;
+    const hours = Math.floor(deltaMs / (60 * 60 * 1000));
+    if (hours >= 1)
+        return `in ${hours}h`;
+    const minutes = Math.max(1, Math.floor(deltaMs / (60 * 1000)));
+    return `in ${minutes}m`;
+}
 /* ------------------------------------------------------------------ */
 /* Tool call synthesiser - α6.12                                      */
 /* ------------------------------------------------------------------ */
@@ -2230,7 +3704,7 @@ export function synthesiseToolCall(input) {
     // Pattern: ToolName(args) optionally suffixed with a result hint.
     // We allow the canonical Claude Code casing AND the snake_case
     // alias `web_fetch` so the synthesiser matches what personas write.
-    const match = /^(Read|Edit|Bash|Grep|Glob|WebFetch|web_fetch)\s*\(\s*([^)]*)\s*\)\s*(.*)$/i
+    const match = /^(Read|Write|Edit|Bash|Grep|Glob|WebFetch|web_fetch)\s*\(\s*([^)]*)\s*\)\s*(.*)$/i
         .exec(detail);
     if (!match)
         return null;
@@ -2254,6 +3728,8 @@ function normaliseToolName(raw) {
         return 'web_fetch';
     if (lower === 'read')
         return 'read';
+    if (lower === 'write')
+        return 'write';
     if (lower === 'edit')
         return 'edit';
     if (lower === 'bash')
@@ -2479,7 +3955,22 @@ export function stripPersonaPrefixEcho(personaSlug, text) {
     // Escape regex specials in the display name even though THE_TEN
     // names are alpha-only today (forward-defense).
     const escaped = display.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Match `<DisplayName>` (case-insensitive) followed by EITHER:
+    //   - an end-of-string, OR
+    //   - a separator (whitespace / comma / colon / dash / period+space).
+    // The `i` flag is needed so a model writing "PUGI:" or "pugi," still
+    // strips. After this match the post-fix `noSepUppercaseRe` handles
+    // the "PugiПринял" / "PugiHello" no-separator emission pattern
+    // (CEO red-alert 2026-05-27) using a SEPARATE regex without the `i`
+    // flag so the lookahead is case-strict (Pugineous must NOT strip).
     const re = new RegExp(`^${escaped}(?:[\\s,:;\\-—–]+|$)`, 'i');
+    // No-separator case-strict matcher. Display name in either of its
+    // canonical casings ("Pugi" / "PUGI") immediately followed by an
+    // uppercase Cyrillic or Latin letter. The strip is intentionally
+    // narrower than the case-insensitive `re` above because a lowercase
+    // continuation ("Pugineous") is a single word, not a display-name
+    // echo - we must not eat real content.
+    const noSepUppercaseRe = new RegExp(`^(?:${escaped}|${escaped.toUpperCase()})(?=[А-ЯЁA-Z])`);
     // Loop the strip so cascading echoes ("Pugi Pugi Pugi, координатор ...")
     // collapse to a single name. The model occasionally emits the display
     // name two or three times back-to-back when the pane prefix also
@@ -2491,10 +3982,18 @@ export function stripPersonaPrefixEcho(personaSlug, text) {
     // matches an empty string (defence-in-depth even though the current
     // pattern guarantees at least one consumed char).
     for (let i = 0; i < 3; i += 1) {
-        const m = re.exec(working);
-        if (!m || m[0].length === 0)
-            break;
-        working = working.slice(m[0].length).trimStart();
+        let m = re.exec(working);
+        if (m && m[0].length > 0) {
+            working = working.slice(m[0].length).trimStart();
+            continue;
+        }
+        // Fallback: no-separator match for "PugiПринял" / "PugiHello" shape.
+        m = noSepUppercaseRe.exec(working);
+        if (m && m[0].length > 0) {
+            working = working.slice(m[0].length);
+            continue;
+        }
+        break;
     }
     return working;
 }