@pugi/cli 0.1.0-beta.8 → 0.1.0-beta.88

package/dist/core/repl/session.js

@@ -1,18 +1,18 @@
 /**
- * REPL session lifecycle - Sprint α5.7 (ADR-0056 PR-PUGI-CLI-REPL-DEFAULT).
+ * REPL session lifecycle - Sprint .
  *
  * Owns the state machine that the REPL UI subscribes to:
  *
- *   1. Open a server-side Pugi session via POST /api/pugi/sessions.
- *      The CLI keeps a sessionId; reconnect uses it.
- *   2. Subscribe to GET /api/pugi/sessions/:id/stream (SSE). Each event
- *      pushes one of: agent.spawned, agent.step, agent.tokens,
- *      agent.completed, agent.blocked, agent.failed.
- *   3. Dispatch a brief via POST /api/pugi/sessions/:id/brief.
- *   4. Track active dispatches so the cap-warning gate has a number.
- *   5. Reconnect with Last-Event-ID on transient failure (10 retries,
- *      exponential backoff capped at 5s) so the operator sees a stable
- *      stream even on flaky connections.
+ *  1. Open a server-side Pugi session via POST /api/pugi/sessions.
+ *     The CLI keeps a sessionId; reconnect uses it.
+ *  2. Subscribe to GET /api/pugi/sessions/:id/stream (SSE). Each event
+ *     pushes one of: agent.spawned, agent.step, agent.tokens,
+ *     agent.completed, agent.blocked, agent.failed.
+ *  3. Dispatch a brief via POST /api/pugi/sessions/:id/brief.
+ *  4. Track active dispatches so the cap-warning gate has a number.
+ *  5. Reconnect with Last-Event-ID on transient failure (10 retries,
+ *     exponential backoff capped at 5s) so the operator sees a stable
+ *     stream even on flaky connections.
  *
  * The module is environment-agnostic: callers inject `fetch` (Node 22
  * native or a stub from a test) and `EventSource` (a polyfill or
@@ -21,12 +21,13 @@
  * surface is exercisable without a network.
  *
  * Brand voice: the conversation transcript is line-based, persona-
- * prefixed (Mira / Marcus / Hiroshi / Vera / Anika / Olivia / Diego /
+ * prefixed (Pugi / Marcus / Hiroshi / Vera / Anika / Olivia / Diego /
  * Sofia per @pugi/personas). Forbidden words gate applies to every
  * line we synthesize client-side; server-side events are passed through
  * 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,18 +35,39 @@ 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;
+/**
+ * small-CC-parity batch : width cap for the inline
+ * `streamingDelta` tail rendered next to the args while the call is
+ * `running`. Keeps the tool-stream row single-line on an 80-col
+ * terminal even when Bash output blasts through stdout. Exported so the
+ * spec can pin the truncation behaviour.
+ */
+export const STREAMING_DELTA_MAX_CHARS = 80;
+/**
+ * small-CC-parity batch : character cap for the
+ * collapsed `resultPreview` on a completed row. The pane shows
+ * `✓ Read(file) OK (2ms) "first 50 chars…"` so the operator sees what
+ * the tool produced without expanding. Per CEO spec (50 chars).
+ * Exported so the spec + the pane share one source of truth.
+ */
+export const RESULT_PREVIEW_MAX_CHARS = 50;
 const MAX_RECONNECT_ATTEMPTS = 10;
 const RECONNECT_BASE_MS = 250;
 const RECONNECT_MAX_MS = 5_000;
 /**
- * α6.5 filewatch throttle: minimum gap between two file-change
+ * filewatch throttle: minimum gap between two file-change
  * system lines surfaced in the conversation pane. Per the sprint
  * spec, a noisy save burst should not flood the transcript - we
  * coalesce all chokidar batches that arrive inside the window into
@@ -60,7 +82,7 @@ const FILEWATCH_SYSTEM_LINE_GAP_MS = 5_000;
  * would accumulate forever, holding refs to thousands of FilewatchBatch
  * objects (each carrying its own events array). On overflow we drop
  * the OLDEST batch and surface a one-shot system warning so the
- * operator knows the buffer is shedding. triple-review P1 (PR #380).
+ * operator knows the buffer is shedding. triple-review P1 (PR).
  */
 const PENDING_FILEWATCH_BATCH_CAP = 100;
 /**
@@ -70,7 +92,7 @@ const PENDING_FILEWATCH_BATCH_CAP = 100;
  * CLI mints a fresh server session, swaps the consumer over, and
  * keeps running - but we cap the recovery to 3 attempts inside 60s
  * so a truly down admin-api fails loud instead of spinning forever.
- * (α6.14.2 wave 5 - CEO dogfood fix.)
+ *
  */
 const MAX_SESSION_RECREATE_ATTEMPTS = 3;
 const SESSION_RECREATE_WINDOW_MS = 60_000;
@@ -90,13 +112,13 @@ export class ReplSession {
      * with "Stream interrupted (HTTP 404)" loops, we mint a fresh
      * session and swap the consumer. Capped at MAX_SESSION_RECREATE_*
      * inside SESSION_RECREATE_WINDOW_MS so a permanently down admin-api
-     * fails loud instead of looping silently. (α6.14.2 wave 5.)
+     * fails loud instead of looping silently.
      */
     recentRecreateAtMs = [];
     /**
      * True while a session-recreate POST is in flight. Guards against
      * the SSE stream firing multiple `onError(404)` callbacks racing
-     * the in-flight createSession promise. (α6.14.2 wave 5.)
+     * the in-flight createSession promise.
      */
     recreatingSession = false;
     /**
@@ -108,11 +130,11 @@ export class ReplSession {
      * `shipped.` - the actual reply text was lost. By caching the last
      * non-trivial detail here, we can flush it into the transcript when
      * the agent completes so the operator sees what the persona actually
-     * said. CEO wave-2 fix 2026-05-25.
+     * said. CEO wave-2 fix.
      */
     lastStepDetail = new Map();
     /**
-     * Optional local SessionStore - α6.4. When non-null, every
+     * Optional local SessionStore - . When non-null, every
      * appendRow() call mirrors the row into the JSONL log so the
      * conversation can be restored via `/resume`. Errors from the store
      * are swallowed to a single system line (degradation, not crash).
@@ -146,20 +168,20 @@ export class ReplSession {
      * `/privacy` slash falls back to the contract doc with an "unknown"
      * banner when null.
      *
-     * Triple-review P1 fix (2026-05-25): the prior build defined
+     * Triple-review P1 fix : the prior build defined
      * `renderPrivacyBanner` but never called it, and `/privacy` always
      * rendered with `null` mode. The contract was advertised but the
      * operator had no mode visibility.
      */
     privacyMode = null;
     /**
-     * α6.5 Tier 0 / Tier 1 / chokidar wiring. The bootstrap builds the
+     * Tier 0 / Tier 1 / chokidar wiring. The bootstrap builds the
      * skeleton + working set + watcher once and hands them to the
      * session. The session uses them to:
      *
-     *   - render `/context` (count + cap + total bytes + skeleton size).
-     *   - emit throttled "file changed" system lines on watcher batches.
-     *   - forget removed files from the working set on `unlink`.
+     *  - render `/context` (count + cap + total bytes + skeleton size).
+     *  - emit throttled "file changed" system lines on watcher batches.
+     *  - forget removed files from the working set on `unlink`.
      *
      * All three are optional - tests and minimal callers pass null /
      * undefined and the session degrades to "no three-tier integration"
@@ -181,7 +203,7 @@ export class ReplSession {
      * a summary that mentions how many additional files were touched.
      * Capped at PENDING_FILEWATCH_BATCH_CAP to bound memory growth
      * under long-running noisy filewatch sources (tsc --watch on a
-     * 200-file project hammering for hours). triple-review P1 (PR #380).
+     * 200-file project hammering for hours). triple-review P1 (PR).
      */
     pendingFilewatchBatches = [];
     /**
@@ -198,7 +220,7 @@ export class ReplSession {
      * session.close() and watcher.close() does not run handlers on a
      * dead session. Without detachment, recordFilewatchBatch would
      * touch this.workingSet / this.transcript on a closed session.
-     * triple-review P1 (PR #380).
+     * triple-review P1 (PR).
      */
     filewatchBatchHandler = (batch) => {
         this.recordFilewatchBatch(batch);
@@ -211,7 +233,7 @@ export class ReplSession {
      * signatures. The persona may emit the same envelope twice on network
      * retry; we suppress the duplicate so the operator does not see two
      * stacked modals. Capped at 32 entries - generous for a real session,
-     * defensive against a hostile flood. (α6.3.)
+     * defensive against a hostile flood.
      */
     seenTagSignatures = [];
     /**
@@ -219,11 +241,11 @@ export class ReplSession {
      * `<pugi-ask>` open and close tags may arrive in separate
      * `agent.step` events when the upstream LLM token-streams output
      * char-by-char. We accumulate the running detail per taskId until a
-     * complete envelope lands OR the turn ends. (α6.3.)
+     * complete envelope lands OR the turn ends.
      */
     askBuffer = new Map();
     /**
-     * α6.9 dispatch FSM. One instance owned by the session; transitions
+     * dispatch FSM. One instance owned by the session; transitions
      * are mirrored into `state.dispatchState` via an onEnter listener so
      * subscribers see every change. Resets to `idle` after a terminal
      * transition (`completed` / `failed` / `aborted`) so the next brief
@@ -236,7 +258,7 @@ export class ReplSession {
     // accessor - callers cannot reach into this private field.
     fsm = new DispatchFSM();
     /**
-     * α6.9 cancellation token for the currently in-flight dispatch.
+     * cancellation token for the currently in-flight dispatch.
      * Minted on `dispatchBrief()` and released on terminal transitions.
      * When non-null, calling `cancel()` aborts the token, closes the SSE
      * stream, and transitions the FSM to `aborting` → `aborted`.
@@ -245,7 +267,7 @@ export class ReplSession {
      */
     currentDispatchToken = null;
     /**
-     * R2 P1 fix (Codex triple-review 2026-05-25): monotonic dispatch
+     * R2 P1 fix (Codex triple-review): monotonic dispatch
      * sequence id. Incremented on every `dispatchBrief()`. The
      * agent.spawned handler stamps the current value into
      * `taskDispatchSeq[event.taskId]`. Terminal handlers
@@ -268,7 +290,7 @@ export class ReplSession {
      */
     taskDispatchSeq = new Map();
     /**
-     * R3 P1 fix (Codex triple-review 2026-05-25): wall-clock guard used to
+     * R3 P1 fix (Codex triple-review): wall-clock guard used to
      * drop SSE events whose `event.timestamp` predates the current
      * dispatch. The R2 seq gate alone fails when a LATE `agent.spawned`
      * from brief #1 arrives AFTER brief #2 mints a new dispatch token:
@@ -289,7 +311,7 @@ export class ReplSession {
      * the turn ends with this flag still set, we emit a system-line
      * warning that the persona produced an incomplete tag - the partial
      * XML is silently dropped (the parser already withheld it from the
-     * cleaned body). Codex triple-review P2 (PR #375).
+     * cleaned body). Codex triple-review P2 (PR).
      */
     askBufferPending = new Set();
     constructor(options) {
@@ -315,6 +337,19 @@ export class ReplSession {
             toolCalls: [],
             transcript: [],
             tokensDownstreamTotal: 0,
+            // 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,8 +357,9 @@ export class ReplSession {
             pendingPlanReviewSource: null,
             dispatchState: 'idle',
             dispatchToolLabel: null,
+            lastCompletedOutcome: null,
         };
-        // α6.9: mirror every FSM transition into the public state so the
+        // : mirror every FSM transition into the public state so the
         // status-bar surface can rerender on the next frame. Local listener
         // is intentionally cheap — just a patch + clear the per-state tool
         // label when leaving `tool_running`.
@@ -359,6 +395,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 +408,18 @@ export class ReplSession {
             // admin-api down) is silent - the operator can still type
             // `/privacy` to see the contract.
             void this.fetchAndAnnouncePrivacyMode().catch(() => undefined);
+            // 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);
+            // BT 9 Phase 2 : codegraph cold-start hook.
+            // Surfaces ONE of two nudges:
+            //  - stale-index reminder ("Codegraph index is N days old…")
+            //  - 30-day post-decline reminder ("Detected medium TS repo…")
+            // Skips silently in every other case. Best-effort — a failed
+            // detection NEVER blocks bootstrap (the helper itself catches).
+            void this.runCodegraphColdStart().catch(() => undefined);
         }
         catch (error) {
             this.appendSystemLine(`Could not open Pugi session: ${this.errorMessage(error)}`);
@@ -385,7 +434,7 @@ export class ReplSession {
      * banner is preferable to a noisy "could not fetch privacy mode"
      * line on every login.
      *
-     * Triple-review P1 fix (2026-05-25): without this call,
+     * Triple-review P1 fix : without this call,
      * `renderPrivacyBanner` was defined but never reached the wire, and
      * `/privacy` always rendered with `null` mode.
      */
@@ -414,13 +463,69 @@ export class ReplSession {
             // Silent fail - offline / DNS / unauth all collapse to no banner.
         }
     }
+    /**
+     * 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,
+        });
+    }
+    /**
+     * BT 9 Phase 2 : codegraph cold-start nudge.
+     *
+     * Surfaces ONE of two nudges on REPL boot when the gate trips:
+     *  - 30-day post-decline reminder ("Detected medium TS repo…")
+     *  - stale-index reminder ("Codegraph index is N days old…")
+     *
+     * The evaluator is pure; we stamp `lastReindexCheckAt` here so the
+     * stale-index nudge throttles к once-per-day. The init-flow first-
+     * run prompt is handled separately by `pugi init` to avoid double-
+     * prompting в the common "init + then code" boot sequence.
+     *
+     * Best-effort: any error inside the codegraph module is swallowed —
+     * a cold-start nudge that breaks the REPL would be worse than no
+     * nudge at all.
+     */
+    async runCodegraphColdStart() {
+        try {
+            const workspaceRoot = this.options.workspace?.workspaceCwd ?? process.cwd();
+            const { evaluateColdStart } = await import('../codegraph/offer-hook.js');
+            const verdict = evaluateColdStart({ workspaceRoot });
+            if (verdict.kind === 'silent')
+                return;
+            if (verdict.kind === 'stale-index') {
+                this.appendSystemLine(verdict.message);
+                const { markReindexChecked } = await import('../codegraph/decision-store.js');
+                markReindexChecked(workspaceRoot);
+                return;
+            }
+            // 'remind' — surface the offer copy as a system line. Operator
+            // accepts via `/codegraph-status --install` OR explicitly via
+            // `pugi mcp install codegraph codegraph serve --mcp`.
+            this.appendSystemLine('');
+            this.appendSystemLine(verdict.message);
+            this.appendSystemLine(' Accept: run `pugi mcp install codegraph codegraph serve --mcp && pugi mcp trust codegraph`');
+            this.appendSystemLine(' Skip:  /codegraph-status to inspect the decision; the prompt re-appears in 30 days');
+        }
+        catch {
+            // Codegraph nudge is decoration — failure must NEVER surface.
+        }
+    }
     /**
      * Tear down the SSE stream and stop the reconnect timer. The session
      * id stays valid server-side; `pugi resume <id>` reopens later.
      */
     close() {
         this.closed = true;
-        // α6.9: fire the cancellation token before tearing down the stream
+        // : fire the cancellation token before tearing down the stream
         // so any in-flight tool sees the abort signal AND any pending
         // PostBrief promise can short-circuit. Idempotent — token.abort()
         // is a no-op when already aborted.
@@ -446,32 +551,32 @@ export class ReplSession {
         // run a handler on a dead session. The handlers themselves also
         // hard-guard on `this.closed`, but detaching is the load-bearing
         // fix - it severs the strong reference the watcher held on the
-        // session callback, which otherwise blocks GC. triple-review P1 (PR #380).
+        // session callback, which otherwise blocks GC. triple-review P1 (PR).
         if (this.watcher) {
             this.watcher.off('batch', this.filewatchBatchHandler);
             this.watcher.off('capExceeded', this.filewatchCapHandler);
         }
     }
-    /* ------------- α6.9 cancellation surface -------------- */
+    /* ------------- cancellation surface -------------- */
     /**
      * Operator-driven abort for the in-flight dispatch. Idempotent — a
      * second call while already in `aborting` / `aborted` is a no-op.
      *
      * Steps (in order):
      *
-     *   1. Snapshot the current state. If terminal or idle, no-op.
-     *   2. Transition the FSM to `aborting` so the bottom-bar shows the
-     *      pending shutdown immediately (the operator gets feedback
-     *      before any IO completes).
-     *   3. Abort the cancellation token. This fans out to every listener
-     *      that was attached during the dispatch — chiefly the SSE
-     *      stream wrapper (which calls `streamHandle.close()`) and any
-     *      mid-flight tool executor that polled `isAborted`.
-     *   4. Append a system line so the conversation reads "Aborted." at
-     *      the operator's last input position.
-     *   5. Transition to `aborted` (terminal). The next operator brief
-     *      mints a fresh token + transitions back to
-     *      `awaiting_response`.
+     *  1. Snapshot the current state. If terminal or idle, no-op.
+     *  2. Transition the FSM to `aborting` so the bottom-bar shows the
+     *     pending shutdown immediately (the operator gets feedback
+     *     before any IO completes).
+     *  3. Abort the cancellation token. This fans out to every listener
+     *     that was attached during the dispatch — chiefly the SSE
+     *     stream wrapper (which calls `streamHandle.close()`) and any
+     *     mid-flight tool executor that polled `isAborted`.
+     *  4. Append a system line so the conversation reads "Aborted." at
+     *     the operator's last input position.
+     *  5. Transition to `aborted` (terminal). The next operator brief
+     *     mints a fresh token + transitions back to
+     *     `awaiting_response`.
      *
      * Returns `true` when an abort was actually issued (state was
      * non-terminal + non-idle), `false` otherwise.
@@ -539,6 +644,73 @@ export class ReplSession {
     getDispatchState() {
         return this.fsm.current;
     }
+    /**
+     * BT 8 (the upstream tool 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
@@ -564,7 +736,7 @@ export class ReplSession {
                 // UI overlays - no transport interaction.
                 return verdict;
             case 'quit':
-                // UI Designer audit 2026-05-25: "Brief it. It ships." is reserved
+                // UI Designer audit: "Brief it. It ships." is reserved
                 // for identity intro + landing per wave-4 prompt rule. Drop the
                 // tagline drift here; tell the operator what happened and how to
                 // resume.
@@ -577,6 +749,18 @@ export class ReplSession {
                 await this.dispatchStop(verdict.persona);
                 return verdict;
             }
+            case 'delegate': {
+                // 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;
@@ -594,7 +778,43 @@ export class ReplSession {
                 return verdict;
             }
             case 'jobs': {
-                await this.dispatchJobs();
+                // cleanup : `/jobs --watch` mounts the
+                // live Ink TUI from inside the REPL. The dispatcher does NOT
+                // mount the watcher itself (that would unmount the REPL's
+                // own Ink tree) — instead it surfaces the shell command so
+                // the operator runs the watcher in a fresh terminal. Bare
+                // `/jobs` continues to render the one-shot snapshot.
+                if (verdict.watch) {
+                    this.appendSystemLine('Run `pugi jobs --watch` from a fresh shell — the live TUI cannot share the REPL Ink tree.');
+                }
+                else {
+                    await this.dispatchJobs();
+                }
+                return verdict;
+            }
+            case 'cancel': {
+                // small-CC-parity batch : forward the parsed
+                // mode + dispatchId to `runCancelCommand`. The dispatcher uses
+                // a dynamic import so the cancel module's filesystem helpers
+                // stay out of the REPL keystroke hot path; same separation as
+                // `/redo`, `/prd-check`, `/chain`. The runner writes its
+                // output lines through `appendSystemLine` so the verdict
+                // lands on the system pane alongside other slash results.
+                try {
+                    const { runCancelCommand } = await import('../../runtime/commands/cancel.js');
+                    const cancelMode = verdict.mode === 'list'
+                        ? { kind: 'list' }
+                        : verdict.mode === 'all'
+                            ? { kind: 'all' }
+                            : { kind: 'one', dispatchId: verdict.dispatchId };
+                    await runCancelCommand(cancelMode, {
+                        write: (line) => this.appendSystemLine(line),
+                    });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    this.appendSystemLine(`/cancel failed: ${message}`);
+                }
                 return verdict;
             }
             case 'diff': {
@@ -602,11 +822,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': {
@@ -628,7 +852,7 @@ export class ReplSession {
                 return verdict;
             }
             case 'ask': {
-                // α6.3: synthesise a local yes/no `<pugi-ask>` modal so the
+                // : synthesise a local yes/no `<pugi-ask>` modal so the
                 // operator can exercise the question UI without a persona-side
                 // round trip. The REPL UI mounts the modal from the resulting
                 // `pendingAsk` state; on resolution the encoded verdict lands
@@ -651,12 +875,1007 @@ export class ReplSession {
                 await this.dispatchPrivacy();
                 return verdict;
             }
+            case 'init': {
+                // β1 Sl11 → β1a r1 (real inline scaffold): 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 : /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': {
+                // /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': {
+                // /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 : 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': {
+                // /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': {
+                // /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 : 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': {
+                // : 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.
+                //
+                // final : 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': {
+                // : 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 'codegraph-status': {
+                // BT 9 Phase 2 : forward to the runner. The
+                // bare form renders the four-row status table; flags handle
+                // install / reindex / offer. Dynamic import keeps the
+                // codegraph module out of the REPL hot path until first use.
+                try {
+                    const { runCodegraphStatusCommand } = await import('../../runtime/commands/codegraph-status.js');
+                    const lines = [];
+                    const workspaceRoot = this.options.workspace?.workspaceCwd ?? process.cwd();
+                    await runCodegraphStatusCommand(verdict.args, {
+                        workspaceRoot,
+                        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('/codegraph-status: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/codegraph-status failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'permissions': {
+                // 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': {
+                // /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.
+                //
+                // BT 8 (the upstream tool 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': {
+                // BT 8 (the upstream tool 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': {
+                // /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': {
+                // /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': {
+                // 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': {
+                // 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': {
+                // 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 : 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': {
+                // /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': {
+                // 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': {
+                // 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': {
+                // final : 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 'redo': {
+                // cleanup : counterpart к /undo. The runtime
+                // command `runRedoCommand` consumes one entry from the LIFO
+                // undo stack (most recent unconsumed `tool=undo` result), reads
+                // the captured AFTER content from `.pugi/undo-blobs/`, and
+                // re-applies the mutations under the same mtime+hash external-
+                // modification gate the undo runner uses. Same dynamic-import
+                // posture as /undo so the redo + blob-store + git plumbing
+                // stays out of the REPL hot path.
+                try {
+                    const [{ runRedoCommand }, { openSession }] = await Promise.all([
+                        import('../../runtime/commands/redo.js'),
+                        import('../session.js'),
+                    ]);
+                    const workspaceRoot = process.cwd();
+                    const session = openSession(workspaceRoot);
+                    this.appendSystemLine('Reapplying last undo...');
+                    await runRedoCommand([], {
+                        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(`/redo failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'plan-artifact': {
+                // Pugi backlog : plan-as-FILE artifact surface.
+                // Dynamic-import the core module so the REPL hot path stays free
+                // of the artifact store + diff renderer until the operator
+                // actually exercises a `/plan show|list|diff|prune` invocation.
+                try {
+                    const { readPlan, listPlans, diffPlans, prunePlans, PlanNotFoundError, InvalidPlanIdError, } = await import('../plans/plan-artifact.js');
+                    const root = process.cwd();
+                    const sub = verdict.sub;
+                    if (sub.op === 'show') {
+                        try {
+                            const record = readPlan(sub.planId, { root });
+                            this.appendSystemLine(`plan ${record.frontmatter.planId} (task=${record.frontmatter.taskId}, created=${record.frontmatter.createdAt})`);
+                            if (record.frontmatter.supersededBy) {
+                                this.appendSystemLine(`superseded by ${record.frontmatter.supersededBy}`);
+                            }
+                            for (const line of record.body.split('\n')) {
+                                this.appendSystemLine(line);
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof PlanNotFoundError) {
+                                this.appendSystemLine(`/plan show: plan not found: ${sub.planId}`);
+                            }
+                            else if (error instanceof InvalidPlanIdError) {
+                                this.appendSystemLine(`/plan show: invalid plan-id: ${sub.planId}`);
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
+                    }
+                    else if (sub.op === 'list') {
+                        const filter = sub.taskId ? { taskId: sub.taskId, root } : { root };
+                        const records = listPlans(filter);
+                        if (records.length === 0) {
+                            this.appendSystemLine('/plan list: no plans yet.');
+                        }
+                        else {
+                            this.appendSystemLine(`plan-id                   taskId         createdAt             supersededBy`);
+                            for (const rec of records) {
+                                const fm = rec.frontmatter;
+                                const supers = fm.supersededBy ?? '-';
+                                this.appendSystemLine(`${fm.planId} ${fm.taskId.padEnd(15)} ${fm.createdAt} ${supers}`);
+                            }
+                        }
+                    }
+                    else if (sub.op === 'diff') {
+                        try {
+                            const diff = diffPlans(sub.planId, sub.otherId, { root });
+                            for (const line of diff.split('\n')) {
+                                this.appendSystemLine(line);
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof PlanNotFoundError) {
+                                this.appendSystemLine(`/plan diff: plan not found`);
+                            }
+                            else if (error instanceof InvalidPlanIdError) {
+                                this.appendSystemLine(`/plan diff: invalid plan-id`);
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
+                    }
+                    else {
+                        // prune
+                        const result = prunePlans(sub.maxAgeDays !== undefined
+                            ? { root, maxAgeDays: sub.maxAgeDays }
+                            : { root });
+                        this.appendSystemLine(`/plan prune: cleaned ${result.cleaned} plan${result.cleaned === 1 ? '' : 's'}.`);
+                        for (const id of result.removedIds) {
+                            this.appendSystemLine(` - ${id}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/plan ${verdict.sub.op} failed: ${message}`);
+                }
+                return verdict;
+            }
             case 'stub': {
                 this.appendSystemLine(verdict.message);
                 return verdict;
             }
         }
     }
+    /**
+     * 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));
+    }
+    /**
+     * 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 : 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
@@ -667,7 +1886,7 @@ export class ReplSession {
      */
     async dispatchPrivacy() {
         const { renderPrivacyContractDoc } = await import('./privacy-banner.js');
-        // Triple-review P1 fix (2026-05-25): use the bootstrap-cached mode
+        // Triple-review P1 fix : use the bootstrap-cached mode
         // so the operator sees the LIVE current mode in the banner header
         // instead of "(unknown)". The fetch happens once on session start;
         // if it failed (offline / unauth) the cache stays null and the
@@ -677,7 +1896,7 @@ export class ReplSession {
         this.appendSystemLine(doc);
     }
     /**
-     * In-REPL `/resume` - α6.4. Lists the 10 most recent sessions from
+     * In-REPL `/resume` - . Lists the 10 most recent sessions from
      * the local SessionStore and prints them as a numbered system menu.
      * The Ink-side picker UI is deferred to the next sprint; today the
      * operator gets a deterministic list + the exact command to relaunch
@@ -708,7 +1927,7 @@ export class ReplSession {
             const title = (row.title ?? '(untitled)').slice(0, 64);
             const idShort = row.id.slice(0, 13);
             const branch = row.branch ?? 'no-branch';
-            this.appendSystemLine(`  ${(i + 1).toString().padStart(2)}. ${idShort}  ${branch.padEnd(16)}  ${title}`);
+            this.appendSystemLine(` ${(i + 1).toString().padStart(2)}. ${idShort} ${branch.padEnd(16)} ${title}`);
         }
         this.appendSystemLine('Pick one with: pugi resume <id> (paste the 13-char id from above).');
     }
@@ -720,7 +1939,7 @@ export class ReplSession {
     clearTranscript() {
         this.patch({ transcript: [] });
     }
-    /* ------------- α6.3 office-hours surface -------------- */
+    /* ------------- office-hours surface -------------- */
     /**
      * Surface an `<pugi-ask>` modal manually. Returned promise resolves
      * with the operator's verdict - used by the `pugi ask "<q>"` shell
@@ -769,7 +1988,7 @@ export class ReplSession {
      * came from a persona stream, cancel ALSO dispatches a literal
      * `[ASK-RESPONSE:cancelled]` to admin-api so the persona observes the
      * cancellation rather than hanging indefinitely on the missing
-     * follow-up. The matching documentation in the Mira system prompt
+     * follow-up. The matching documentation in the Pugi system prompt
      * teaches the persona to acknowledge cancellation and offer a
      * different path. Local-origin modals (synthesised via `/ask`) skip
      * the dispatch entirely - the persona never saw the question.
@@ -892,22 +2111,87 @@ export class ReplSession {
         try {
             const registry = getJobRegistry();
             const entries = await registry.list();
-            if (entries.length === 0) {
+            // cleanup : also scan `.pugi/agent-progress/*.json`
+            // so long-running external agents (the JSON pattern from
+            // `feedback_agent_progress_tracking_pattern.md`) show up next к
+            // background-bash entries. The two surfaces are orthogonal — bash
+            // jobs come from the in-process registry, agent-progress comes from
+            // sidecar JSON written by any agent (Pugi-spawned or external) — so
+            // we render both, sorted with running first.
+            const agentProgressRows = await this.collectAgentProgressRows();
+            if (entries.length === 0 && agentProgressRows.length === 0) {
                 this.appendSystemLine('No background jobs tracked.');
                 return;
             }
-            this.appendSystemLine(`Background jobs (${entries.length}):`);
-            for (const entry of entries) {
-                const id = entry.id.replace(/^pj-/, '').slice(0, 8);
-                const status = entry.status;
-                const cmd = entry.command.length > 48 ? `${entry.command.slice(0, 47)}…` : entry.command;
-                this.appendSystemLine(`  ${id}  ${status.padEnd(10)}  ${cmd}`);
+            if (entries.length > 0) {
+                this.appendSystemLine(`Background jobs (${entries.length}):`);
+                for (const entry of entries) {
+                    const id = entry.id.replace(/^pj-/, '').slice(0, 8);
+                    const status = entry.status;
+                    const cmd = entry.command.length > 48 ? `${entry.command.slice(0, 47)}…` : entry.command;
+                    this.appendSystemLine(` ${id} ${status.padEnd(10)} ${cmd}`);
+                }
+            }
+            if (agentProgressRows.length > 0) {
+                this.appendSystemLine(`Agent progress (${agentProgressRows.length}):`);
+                for (const row of agentProgressRows) {
+                    this.appendSystemLine(` ${row}`);
+                }
+                this.appendSystemLine('Tip: run `pugi jobs --watch` for the live Ink TUI.');
             }
         }
         catch (error) {
             this.appendSystemLine(`/jobs failed: ${this.errorMessage(error)}`);
         }
     }
+    /**
+     * cleanup : scan `.pugi/agent-progress/*.json`
+     * for in-flight long-running agent tasks and emit a one-line per
+     * agent for the `/jobs` snapshot. Sorting matches the live TUI's
+     * `sortProgressEntries` (running first, then by lastUpdate desc).
+     *
+     * Best-effort: a missing dir, malformed JSON, or bad permissions
+     * yields an empty list and a swallowed error — the in-process
+     * registry view is the older well-tested surface and must never be
+     * gated behind a sidecar dir's health.
+     */
+    async collectAgentProgressRows() {
+        try {
+            const [{ resolveProgressDir }, { readProgressFile, sortProgressEntries }, fs, path] = await Promise.all([
+                import('../agent-progress/writer.js'),
+                import('../../commands/jobs-watch.js'),
+                import('node:fs'),
+                import('node:path'),
+            ]);
+            const dir = resolveProgressDir();
+            if (!fs.existsSync(dir))
+                return [];
+            const files = fs
+                .readdirSync(dir)
+                .filter((f) => f.endsWith('.json'))
+                .map((f) => path.join(dir, f));
+            const progress = files
+                .map((p) => readProgressFile(p))
+                .filter((p) => p !== undefined);
+            const sorted = sortProgressEntries(progress);
+            return sorted.map((p) => {
+                const id = p.agentId.length > 24 ? `${p.agentId.slice(0, 23)}…` : p.agentId;
+                const pct = `${String(Math.round(p.percentComplete)).padStart(3, ' ')}%`;
+                const elapsedSec = Math.max(0, Math.floor(p.elapsedMs / 1000));
+                const elapsed = elapsedSec >= 60
+                    ? `${Math.floor(elapsedSec / 60)}m${String(elapsedSec % 60).padStart(2, '0')}s`
+                    : `${elapsedSec}s`;
+                const status = p.status.padEnd(9, ' ');
+                const step = p.stepDescription.length > 36
+                    ? `${p.stepDescription.slice(0, 35)}…`
+                    : p.stepDescription;
+                return `${id.padEnd(24, ' ')} ${status} ${pct} ${elapsed.padStart(6, ' ')} ${step}`;
+            });
+        }
+        catch {
+            return [];
+        }
+    }
     dispatchDiff() {
         try {
             const artifactsRoot = resolvePath(process.cwd(), '.pugi', 'artifacts');
@@ -923,7 +2207,7 @@ export class ReplSession {
                 const candidate = resolvePath(artifactsRoot, name, 'diff.patch');
                 if (existsSync(candidate)) {
                     const size = statSync(candidate).size;
-                    diffs.push(`  ${name}/diff.patch (${size} bytes)`);
+                    diffs.push(` ${name}/diff.patch (${size} bytes)`);
                 }
             }
             if (diffs.length === 0) {
@@ -938,38 +2222,233 @@ export class ReplSession {
             this.appendSystemLine(`/diff failed: ${this.errorMessage(error)}`);
         }
     }
-    dispatchCost() {
-        const { tokensDownstreamTotal, agents } = this.state;
+    async dispatchCost() {
+        // 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 — 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}.`);
-    }
-    /**
-     * α6.5 `/context` slash handler. Surfaces the three-tier context
+        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
+        }
+    }
+    /**
+     * 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],
+            ];
+            // cleanup : color-code each counter row by
+            // utilisation. The thresholds match the upstream tool's tier-meter
+            // convention so operators trained on that surface read the same
+            // signal here. ANSI codes wrap the WHOLE row (not just the
+            // percent) so the line wraps as one visual unit; the cost-quota
+            // spec regex still matches because anchors are inside the
+            // wrapped substring.
+            for (const [name, value, cap] of counters) {
+                const v = typeof value === 'number' ? value : 0;
+                if (cap === null || cap === undefined) {
+                    // Unlimited counters never trip the gauge — leave them
+                    // uncolored so the eye does not register an alarm signal
+                    // where there is no cap к exhaust.
+                    this.appendSystemLine(` ${name.padEnd(7, ' ')} ${v.toLocaleString()} / unlimited`);
+                }
+                else {
+                    const pct = cap > 0 ? Math.round((v / cap) * 100) : 0;
+                    const row = ` ${name.padEnd(7, ' ')} ${v.toLocaleString()} / ${cap.toLocaleString()} (${pct}%)`;
+                    this.appendSystemLine(colorizeQuotaRow(row, 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` — . 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-.
+     */
+    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,
+                // Repl-mode context: the session knows both the live
+                // transport URL and the operator's workspace label, so we
+                // forward them as authoritative inputs к the snapshot.
+                // The status snapshot used к infer these from the
+                // credentials file, which was wrong in two cases:
+                //  (a) the operator was inside a REPL talking к Anvil dev
+                //      (port 4100) but credentials still pointed к
+                //      api.pugi.io — the `Backend` row mis-reported;
+                //  (b) `workspaceLabel` was никогда rendered at all.
+                liveApiUrl: this.options.apiUrl,
+                workspaceLabel: this.options.workspaceLabel,
+                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}`);
+        }
+    }
+    /**
+     * `/context` slash handler. Surfaces the three-tier context
      * summary as a stack of system lines. Sections (in order):
      *
-     *   1. Tier 0 (repo skeleton) - size in bytes, branch, package
-     *      manager, languages. Skipped when no skeleton was injected
-     *      (REPL launched outside a workspace or with --no-context).
+     *  1. Tier 0 (repo skeleton) - size in bytes, branch, package
+     *     manager, languages. Skipped when no skeleton was injected
+     *     (REPL launched outside a workspace or with --no-context).
      *
-     *   2. Tier 1 (working set) - `count / capacity` plus the total
-     *      size in bytes plus the oldest entry's age in seconds.
-     *      Always emits even when empty so the operator can confirm
-     *      the tier is wired.
+     *  2. Tier 1 (working set) - `count / capacity` plus the total
+     *     size in bytes plus the oldest entry's age in seconds.
+     *     Always emits even when empty so the operator can confirm
+     *     the tier is wired.
      *
-     *   3. Tier 2 (RAG) - one-line heads-up that the Anvil-side
-     *      workspace lands in α6.5b.
+     *  3. Tier 2 (RAG) - one-line heads-up that the Anvil-side
+     *     workspace lands in .
      *
      * The renderer never mutates state.
      */
@@ -998,10 +2477,10 @@ export class ReplSession {
         else {
             this.appendSystemLine('Tier 1 working set: not wired.');
         }
-        this.appendSystemLine('Tier 2 RAG: deferred to α6.5b (Anvil-side per-tenant workspace).');
+        this.appendSystemLine('Tier 2 RAG: deferred to (Anvil-side per-tenant workspace).');
     }
     /**
-     * α6.5 chokidar batch handler. Forwards each event to the working
+     * chokidar batch handler. Forwards each event to the working
      * set tracker (so `unlink` evicts and `add`/`change` bump the
      * recency) and emits at most one throttled system line per
      * `FILEWATCH_SYSTEM_LINE_GAP_MS` window.
@@ -1009,7 +2488,7 @@ export class ReplSession {
      * The transcript surface intentionally shows ONE filename + the
      * count of additional changes (`file changed: src/foo.ts (+3 more)`).
      * The full event list is preserved in the buffer for future
-     * `/context --files` deep-dive (not in α6.5 Phase 1).
+     * `/context --files` deep-dive (not in Phase 1).
      */
     recordFilewatchBatch(batch) {
         // Hard-guard against post-close invocation. close() detaches the
@@ -1018,7 +2497,7 @@ export class ReplSession {
         // listener captured at the start of emit(). If the session closes
         // mid-emit, the handler can still fire on a dead session. Returning
         // early keeps the working set + transcript untouched.
-        // triple-review P1 (PR #380).
+        // triple-review P1 (PR).
         if (this.closed)
             return;
         if (this.workingSet) {
@@ -1038,7 +2517,7 @@ export class ReplSession {
             // do not emit a system line. Cap the buffer at
             // PENDING_FILEWATCH_BATCH_CAP and drop the oldest on overflow so
             // a noisy filewatch source cannot drive unbounded memory growth
-            // across a long REPL session. triple-review P1 (PR #380).
+            // across a long REPL session. triple-review P1 (PR).
             if (this.pendingFilewatchBatches.length >= PENDING_FILEWATCH_BATCH_CAP) {
                 this.pendingFilewatchBatches.shift();
                 if (!this.pendingFilewatchOverflowWarned) {
@@ -1066,14 +2545,14 @@ export class ReplSession {
         this.pendingFilewatchBatches = [];
     }
     /**
-     * α6.5 chokidar cap-exceeded handler. The watcher closes itself
+     * chokidar cap-exceeded handler. The watcher closes itself
      * when it crosses the watched-paths cap; the session surfaces a
      * single system line so the operator knows live updates are off.
      * The conversation stays usable - we just lose the file-changed
      * badge for the rest of the session.
      */
     recordFilewatchCapExceeded(info) {
-        // Same post-close guard as recordFilewatchBatch. triple-review P1 (PR #380).
+        // Same post-close guard as recordFilewatchBatch. triple-review P1 (PR).
         if (this.closed)
             return;
         this.appendSystemLine(`Filewatch off: ${info.watchedCount} watched paths exceeded cap (${info.cap}). Falling back to manual stat-on-read.`);
@@ -1081,7 +2560,7 @@ export class ReplSession {
     /**
      * Fetch one URL via the web_fetch tool and inject the resulting
      * Markdown into the transcript as an operator-attributed brief. The
-     * `<untrusted-content>` sentinel travels with the body so the Mira
+     * `<untrusted-content>` sentinel travels with the body so the Pugi
      * system prompt can refuse to follow instructions inside it.
      *
      * Gating: the dispatcher reads PugiSettings from disk on every
@@ -1136,33 +2615,36 @@ export class ReplSession {
             this.appendSystemLine(capLine);
         }
         this.appendOperatorLine(brief);
-        this.patch({ briefStartedAtEpochMs: this.now() });
-        // α6.9 + R3 P1 (Codex triple-review 2026-05-25): supersede the
+        // 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 });
+        // + R3 P1 (Codex triple-review): supersede the
         // prior dispatch when one is in flight. Steps in order:
         //
-        //   1. Abort the old CancellationToken so any in-flight tool
-        //      holding `ctx.cancellation` sees `isAborted = true` and bails
-        //      (the R2 fix; preserves the file-tools cancellation gate).
-        //   2. Drive the OLD FSM through `aborting -> aborted` terminal.
-        //      This is load-bearing for the R3 race: a LATE event arriving
-        //      on the old FSM (`agent.spawned`, `agent.step`, terminal,
-        //      etc.) before the timestamp gate trips would otherwise still
-        //      attempt to transition the new FSM. Driving the old FSM to a
-        //      terminal state means the FSM check in
-        //      `advanceFsmOnDispatchEnd` (`isTerminal`) short-circuits as a
-        //      defense-in-depth layer.
-        //   3. `resetFsmToIdle()` mints a fresh FSM so the new dispatch
-        //      starts clean. The FSM legal-transition matrix forbids
-        //      `aborted -> awaiting_response`, so the reset is required.
-        //   4. Record `currentDispatchStartTime` BEFORE bumping
-        //      `dispatchSeq` + clearing `taskDispatchSeq`. The timestamp
-        //      gate in `handleServerEvent` checks
-        //      `event.timestamp < currentDispatchStartTime` to drop late
-        //      events from any superseded dispatch (including the late
-        //      `agent.spawned` that the R2 seq gate could not catch).
-        //   5. Clear `taskDispatchSeq` so any stamp left over from the old
-        //      dispatch cannot influence seq comparisons for the new turn.
-        //   6. Bump `dispatchSeq` and mint a fresh `CancellationToken`.
+        //  1. Abort the old CancellationToken so any in-flight tool
+        //     holding `ctx.cancellation` sees `isAborted = true` and bails
+        //     (the R2 fix; preserves the file-tools cancellation gate).
+        //  2. Drive the OLD FSM through `aborting -> aborted` terminal.
+        //     This is load-bearing for the R3 race: a LATE event arriving
+        //     on the old FSM (`agent.spawned`, `agent.step`, terminal,
+        //     etc.) before the timestamp gate trips would otherwise still
+        //     attempt to transition the new FSM. Driving the old FSM to a
+        //     terminal state means the FSM check in
+        //     `advanceFsmOnDispatchEnd` (`isTerminal`) short-circuits as a
+        //     defense-in-depth layer.
+        //  3. `resetFsmToIdle()` mints a fresh FSM so the new dispatch
+        //     starts clean. The FSM legal-transition matrix forbids
+        //     `aborted -> awaiting_response`, so the reset is required.
+        //  4. Record `currentDispatchStartTime` BEFORE bumping
+        //     `dispatchSeq` + clearing `taskDispatchSeq`. The timestamp
+        //     gate in `handleServerEvent` checks
+        //     `event.timestamp < currentDispatchStartTime` to drop late
+        //     events from any superseded dispatch (including the late
+        //     `agent.spawned` that the R2 seq gate could not catch).
+        //  5. Clear `taskDispatchSeq` so any stamp left over from the old
+        //     dispatch cannot influence seq comparisons for the new turn.
+        //  6. Bump `dispatchSeq` and mint a fresh `CancellationToken`.
         //
         // If no prior dispatch is in flight (clean idle / terminal entry),
         // the supersede block is skipped; we only reset the FSM if it sits
@@ -1214,7 +2696,7 @@ export class ReplSession {
         if (this.fsm.current === 'idle') {
             this.fsm.transition('awaiting_response', 'brief_dispatched');
         }
-        // α6.9: re-open the SSE stream if a prior `cancel()` tore it
+        // : re-open the SSE stream if a prior `cancel()` tore it
         // down. Without this, the new brief would dispatch on admin-api
         // but the client would never observe `agent.spawned` / `step` /
         // `completed` — the operator would see a stalled status bar
@@ -1233,14 +2715,14 @@ export class ReplSession {
         }
         catch (error) {
             this.appendSystemLine(`Brief dispatch refused: ${this.errorMessage(error)}`);
-            // α6.9: a failed brief POST never produced a turn, so we move
+            // : a failed brief POST never produced a turn, so we move
             // the FSM straight to `failed` so the bottom-bar surfaces the
             // outcome and the next brief can mint a fresh token.
             this.markDispatchFailed('post_brief_failed');
         }
     }
     /**
-     * α6.9: reset the FSM to `idle` after a terminal transition so the
+     * : reset the FSM to `idle` after a terminal transition so the
      * next brief can start. The FSM does not allow direct
      * `completed -> awaiting_response`, so we mint a fresh FSM by
      * overwriting the field. Listeners on the old FSM are dropped (they
@@ -1269,7 +2751,7 @@ export class ReplSession {
         this.patch({ dispatchState: 'idle', dispatchToolLabel: null });
     }
     /**
-     * α6.9: short-circuit the FSM to `failed` on a non-recoverable
+     * : short-circuit the FSM to `failed` on a non-recoverable
      * dispatch error (network refusal, malformed event, etc). Idempotent
      * — a second call from a terminal state is a no-op.
      */
@@ -1285,7 +2767,7 @@ export class ReplSession {
         if (this.fsm.current === 'aborting')
             return;
         this.fsm.transition('failed', reason);
-        // α6.9 P1 fix (Claude triple-review): postBrief threw between
+        // P1 fix (Claude triple-review): postBrief threw between
         // openStream() and dispatch registration server-side. The local
         // SSE handle is open but listening for events under a dispatchId
         // the admin-api never created. If we leave it open, any inbound
@@ -1294,7 +2776,7 @@ export class ReplSession {
         // IllegalDispatchTransitionError. Tear down so the next brief
         // re-opens cleanly via dispatchBrief's openStream() gate.
         //
-        // R2 P2 fix (Claude triple-review 2026-05-25): tear down the
+        // R2 P2 fix (Claude triple-review): tear down the
         // stream BEFORE nulling the token. Same ordering contract as
         // `cancel()`: any onAbort listener fired during teardown should
         // observe the (now-aborted) token via getCurrentDispatchToken()
@@ -1352,7 +2834,7 @@ export class ReplSession {
             onError: (error) => {
                 if (this.closed)
                     return;
-                // α6.14.2 wave 5: when admin-api restarts it drops the in-memory
+                // wave 5: when admin-api restarts it drops the in-memory
                 // session store, so subscribe returns HTTP 404 forever on the
                 // saved sessionId. Detect that case and mint a fresh server
                 // session silently rather than spamming the operator with
@@ -1382,7 +2864,7 @@ export class ReplSession {
                     void this.recreateSessionSilently();
                     return;
                 }
-                // α6.14.4 CEO dogfood 2026-05-25 (parity with Claude Code):
+                // CEO dogfood (parity with the upstream tool):
                 // collapse the repeated "Stream interrupted (fetch failed).
                 // Reconnecting." spam. The status bar already shows
                 // connection='reconnecting' AND the attempt counter; pushing
@@ -1407,7 +2889,7 @@ export class ReplSession {
      * `Error("HTTP 404 on SSE stream")`. We pattern-match on the status
      * 404 so a different transport (e.g. a test fake or a future polling
      * fallback) can surface the same intent with the same shape.
-     * (α6.14.2 wave 5.)
+     *
      */
     isSessionNotFoundError(error) {
         const msg = this.errorMessage(error);
@@ -1420,7 +2902,7 @@ export class ReplSession {
      * a permanently down admin-api fails loud after a few seconds of
      * trying. Logged once per attempt at debug level (we surface a
      * single visible line on first auto-recreate so the operator knows
-     * what happened, then stay quiet). (α6.14.2 wave 5.)
+     * what happened, then stay quiet).
      */
     async recreateSessionSilently() {
         if (this.closed)
@@ -1463,6 +2945,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();
@@ -1494,7 +2977,7 @@ export class ReplSession {
     }
     /* ------------- event reducer -------------- */
     handleServerEvent(event) {
-        // R3 P1 fix (Codex triple-review 2026-05-25): wall-clock gate that
+        // R3 P1 fix (Codex triple-review): wall-clock gate that
         // drops events from a SUPERSEDED dispatch. The R2 seq gate alone
         // could not catch a LATE `agent.spawned` for an old taskId arriving
         // AFTER `dispatchBrief` already bumped `dispatchSeq`. The late
@@ -1522,16 +3005,16 @@ export class ReplSession {
         switch (event.type) {
             case 'agent.spawned': {
                 const persona = safePersonaName(event.role);
-                // Wave 4 fix 2026-05-25: the roster collapses to one row per
-                // persona slug. The α5.7 reducer pushed a fresh row on every
+                // fix: the roster collapses to one row per
+                // persona slug. The reducer pushed a fresh row on every
                 // spawn, so after three turns the bottom panel stacked
                 // "Pugi orchestrator shipped" three times. The new contract:
-                //   - If a row already exists for this personaSlug, REUSE it.
-                //     Replace its taskId, reset status to 'queued', clear the
-                //     detail line, restart the duration clock, zero the token
-                //     counters. The persona name + slug + role stay stable
-                //     (they are the row identity).
-                //   - If no row exists yet, push a new one.
+                //  - If a row already exists for this personaSlug, REUSE it.
+                //    Replace its taskId, reset status to 'queued', clear the
+                //    detail line, restart the duration clock, zero the token
+                //    counters. The persona name + slug + role stay stable
+                //    (they are the row identity).
+                //  - If no row exists yet, push a new one.
                 // Per-task lifecycle (step/tokens/completed/blocked/failed) is
                 // keyed off `taskId` everywhere, so the reused row still folds
                 // the latest task's events correctly.
@@ -1555,7 +3038,7 @@ export class ReplSession {
                 else {
                     this.patch({ agents: [node, ...this.state.agents] });
                 }
-                // R2 P1 fix (Codex triple-review 2026-05-25): stamp the live
+                // R2 P1 fix (Codex triple-review): stamp the live
                 // dispatch sequence onto this taskId so terminal handlers can
                 // tell apart a "current dispatch" event from a "superseded
                 // dispatch" event. See `dispatchSeq` + `taskDispatchSeq`
@@ -1567,7 +3050,7 @@ export class ReplSession {
                 // double-print. `void persona` keeps the resolved name in scope
                 // for the agent tree node above without leaking it into the
                 // transcript body.
-                // α6.14.3 CEO dogfood 2026-05-25: drop the "dispatched (X)"
+                // CEO dogfood: drop the "dispatched (X)"
                 // transcript echo. The agent tree pane already shows the
                 // spawned state; printing it as a persona row is pure noise
                 // between the operator's brief and the persona's real reply.
@@ -1575,7 +3058,7 @@ export class ReplSession {
                 return;
             }
             case 'agent.step': {
-                // α6.3 office-hours: scan the running buffer for `<pugi-ask>` /
+                // office-hours: scan the running buffer for `<pugi-ask>` /
                 // `<pugi-plan-review>` envelopes BEFORE we cache the detail.
                 // The parser returns the cleaned remainder with the raw XML
                 // stripped, so the operator never sees the envelope as prose.
@@ -1588,7 +3071,7 @@ export class ReplSession {
                 if (sanitised && sanitised.trim().length > 0) {
                     this.lastStepDetail.set(event.taskId, sanitised);
                 }
-                // α6.12: synthesise a tool call entry when the step detail
+                // : synthesise a tool call entry when the step detail
                 // matches a tool-invocation grammar. The pattern is generous
                 // (Read(path) / Edit(path:lines) / Bash(cmd) / Grep(pat) /
                 // Glob(pat) / WebFetch(url)) so the pane has rows to render
@@ -1603,7 +3086,7 @@ export class ReplSession {
                 });
                 if (synthesised) {
                     this.appendToolCall(synthesised);
-                    // α6.9: a fresh tool call moves the FSM to `tool_running`
+                    // : a fresh tool call moves the FSM to `tool_running`
                     // when the dispatch is still active. The status-bar surface
                     // also gets a short label (`tool: read`, `tool: bash`, etc).
                     // Aborting / terminal states are not allowed to transition
@@ -1619,8 +3102,22 @@ export class ReplSession {
             }
             case 'agent.tokens': {
                 const delta = event.tokensIn + event.tokensOut;
+                // 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,17 +3137,49 @@ 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
+                // : transition the FSM to `completed` when no other
                 // dispatch is still in flight. The check uses the agents list
                 // POST-patch so any sibling task in `queued` / `thinking` keeps
                 // the dispatch alive; the FSM only goes terminal when the last
                 // agent ships.
                 this.advanceFsmOnDispatchEnd('completed', 'agent_completed', event.taskId);
+                // 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
@@ -1663,16 +3192,16 @@ export class ReplSession {
                     if (finalDetail
                         && finalDetail !== 'queued for dispatch'
                         && finalDetail.trim().length > 4) {
-                        // α6.12: ship the WHOLE body as one transcript row when the
+                        // : ship the WHOLE body as one transcript row when the
                         // reply contains ANY Markdown structure (code fence, bullet
                         // list, numbered list, headings). The conversation pane
                         // routes it through Markdown renderer в one pass, preserving
                         // grouped bullets + heading hierarchy. Plain prose still
                         // splits per line so word-wrap stays correct.
                         //
-                        // Claude triple-review P1 (PR #369): the prior `includes('```')`
+                        // Claude triple-review P1 (PR): the prior `includes('```')`
                         // gate only caught fences - multi-line bullets fragmented
-                        // per row showed as `▸ Mira • read PUGI.md / ▸ Mira • patched
+                        // per row showed as `▸ Pugi • read PUGI.md / ▸ Pugi • patched
                         // bug / ...` instead of a single grouped bullet block.
                         if (looksLikeMarkdown(finalDetail)) {
                             this.appendPersonaLine(target.personaSlug, finalDetail);
@@ -1687,7 +3216,7 @@ export class ReplSession {
                         }
                     }
                     else {
-                        // α6.14.3 CEO dogfood 2026-05-25: drop the literal
+                        // CEO dogfood: drop the literal
                         // "shipped." fallback row. If we have no cached detail to
                         // surface, stay silent. The agent tree pane already shows
                         // the green check + duration.
@@ -1711,11 +3240,15 @@ export class ReplSession {
                 if (target) {
                     this.appendPersonaLine(target.personaSlug, `blocked: ${event.detail}`);
                 }
-                // α6.9: `blocked` is a graceful refusal, not a crash — treat it
+                // : `blocked` is a graceful refusal, not a crash — treat it
                 // as a `completed` outcome from the FSM's perspective so the
                 // operator sees the bottom-bar settle back to `idle` after the
                 // last block clears.
                 this.advanceFsmOnDispatchEnd('completed', 'agent_blocked', event.taskId);
+                // 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': {
@@ -1734,17 +3267,21 @@ export class ReplSession {
                 if (target) {
                     this.appendPersonaLine(target.personaSlug, `failed: ${event.error}`);
                 }
-                // α6.9: terminal `failed` transition when no sibling task
+                // : terminal `failed` transition when no sibling task
                 // remains. Same defer-until-last-agent semantics as
                 // `completed` so the bottom-bar surface tracks the dispatch
                 // collectively.
                 this.advanceFsmOnDispatchEnd('failed', 'agent_failed', event.taskId);
+                // 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;
             }
         }
     }
     /**
-     * α6.9 helper: advance the FSM to `tool_running` when a tool call
+     * helper: advance the FSM to `tool_running` when a tool call
      * lands mid-dispatch. Guarded against terminal / aborting states so
      * a late tool event after `cancel()` does not throw on an illegal
      * transition. The `tool` label drives the bottom-bar's
@@ -1768,7 +3305,7 @@ export class ReplSession {
         this.patch({ dispatchToolLabel: `tool: ${tool}` });
     }
     /**
-     * α6.9 helper: advance the FSM toward a terminal outcome when the
+     * helper: advance the FSM toward a terminal outcome when the
      * LAST in-flight agent's lifecycle ends. The dispatch is "still
      * running" when any other agent in the tree is in `queued` /
      * `thinking`; the FSM only goes terminal when the last one settles.
@@ -1777,13 +3314,25 @@ export class ReplSession {
      * after a manual `cancel()` finds the FSM already in `aborted` and
      * is silently dropped.
      */
+    /**
+     * — 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
+        // R2 P1 fix (Codex triple-review): 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 +3364,63 @@ export class ReplSession {
         this.currentDispatchToken = null;
         this.patch({ briefStartedAtEpochMs: undefined });
     }
+    /**
+     * 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);
+    }
+    /**
+     * 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
@@ -1827,6 +3433,73 @@ export class ReplSession {
         const agent = this.state.agents.find((a) => a.taskId === taskId);
         return agent?.personaSlug ?? 'unknown';
     }
+    /**
+     * small-CC-parity batch : public ingest path for
+     * a backend-driven `tool.call.delta` event. Appends the delta tail
+     * onto the row's `streamingDelta` (capped at
+     * `STREAMING_DELTA_MAX_CHARS` so the row stays single-line) when the
+     * id matches a `running` row. No-op when the id is unknown OR when
+     * the row already transitioned to a terminal status — late deltas
+     * from a completed call must not overwrite the final detail.
+     *
+     * The renderer in `tool-stream-pane.tsx` reads `streamingDelta` to
+     * paint the inline preview after the canonical args. This method is
+     * the seam the future admin-api SSE consumer hooks into; until then
+     * the spec drives it directly so the delta-append branch is locked
+     * down behaviourally.
+     */
+    appendToolCallDelta(id, deltaChunk) {
+        if (!id || !deltaChunk)
+            return;
+        const idx = this.state.toolCalls.findIndex((c) => c.id === id);
+        if (idx < 0)
+            return;
+        const existing = this.state.toolCalls[idx];
+        if (existing.status !== 'running')
+            return;
+        const current = existing.streamingDelta ?? '';
+        let combined = current + deltaChunk;
+        if (combined.length > STREAMING_DELTA_MAX_CHARS) {
+            // Keep the TAIL — the operator wants the freshest bytes (the
+            // line being written right now), not the stale head. The leading
+            // ellipsis signals truncation.
+            combined = `…${combined.slice(combined.length - STREAMING_DELTA_MAX_CHARS + 1)}`;
+        }
+        const next = this.state.toolCalls.slice();
+        next[idx] = { ...existing, streamingDelta: combined };
+        this.patch({ toolCalls: next });
+    }
+    /**
+     * small-CC-parity batch : public ingest path for
+     * the terminal `tool.call.end` event. Flips the row to `ok` / `error`
+     * with the resolved duration + optional result preview. Cleans up the
+     * transient `streamingDelta` so the completed row renders cleanly
+     * without the live tail. No-op when the id is unknown.
+     */
+    endToolCall(input) {
+        if (!input.id)
+            return;
+        const idx = this.state.toolCalls.findIndex((c) => c.id === input.id);
+        if (idx < 0)
+            return;
+        const existing = this.state.toolCalls[idx];
+        const endedAt = input.endedAtEpochMs ?? Date.now();
+        const durationMs = Math.max(0, endedAt - existing.startedAtEpochMs);
+        const preview = input.resultPreview
+            ? truncatePreview(input.resultPreview, RESULT_PREVIEW_MAX_CHARS)
+            : undefined;
+        const next = this.state.toolCalls.slice();
+        next[idx] = {
+            ...existing,
+            status: input.status,
+            detail: input.detail ?? existing.detail,
+            resultLines: input.resultLines ?? existing.resultLines,
+            durationMs,
+            resultPreview: preview,
+            streamingDelta: undefined,
+        };
+        this.patch({ toolCalls: next });
+    }
     /**
      * Fold a tool call entry into the rolling list. If the entry id
      * already exists, replace it in-place (so a synthesised `running` →
@@ -1856,10 +3529,10 @@ export class ReplSession {
         this.appendRow({ source: 'system', text });
     }
     appendPersonaLine(personaSlug, text) {
-        // α6.14.2 wave 5: dedup the persona display-name prefix. The
+        // wave 5: dedup the persona display-name prefix. The
         // conversation pane already renders `▸ <DisplayName> <text>` from
         // the slug → name map; when the model's own reply begins with
-        // the same display name (CEO 2026-05-25 screenshot: "Pugi Pugi,
+        // the same display name (CEO screenshot: "Pugi Pugi,
         // координатор Pugi"), the operator sees the name twice. Strip
         // the leading display-name token (with optional trailing comma /
         // colon / whitespace) so the prefix the pane adds is the only one
@@ -1871,13 +3544,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);
@@ -1886,10 +3560,66 @@ export class ReplSession {
         // Persistence is fail-safe: a single error becomes one system
         // line, subsequent errors are silent so a stuck disk does not
         // flood the operator. The mapping from row.source -> store kind:
-        //   operator -> 'user'   (drives turn_count + title)
-        //   persona  -> 'persona'
-        //   system   -> 'system'
+        //  operator -> 'user'  (drives turn_count + title)
+        //  persona -> 'persona'
+        //  system  -> 'system'
         this.persistRow(row);
+        // 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 +3630,15 @@ export class ReplSession {
     persistRow(row) {
         if (!this.store)
             return;
+        // L29 : `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';
@@ -1927,7 +3666,7 @@ export class ReplSession {
         });
     }
     /**
-     * Restore a transcript from a stored event log - α6.4. Called by
+     * Restore a transcript from a stored event log - . Called by
      * the CLI bootstrap when the operator runs `pugi resume <id>` or
      * picks an entry from the `/resume` picker. Replays each event into
      * the local transcript WITHOUT writing back to the store so the
@@ -1940,12 +3679,30 @@ export class ReplSession {
      * write the restored events.
      */
     restoreTranscript(events) {
+        // 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.
+        //
+        // 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 : 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);
@@ -1959,7 +3716,7 @@ export class ReplSession {
     getLocalSessionId() {
         return this.localSessionId;
     }
-    /* ------------- α6.3 buffered tag detection -------------- */
+    /* ------------- buffered tag detection -------------- */
     /**
      * Scan the running `agent.step.detail` buffer for `<pugi-ask>` /
      * `<pugi-plan-review>` envelopes. If a complete envelope is found,
@@ -2064,7 +3821,7 @@ export class ReplSession {
     }
 }
 /* ------------------------------------------------------------------ */
-/* Helpers                                                            */
+/* Helpers                                                           */
 /* ------------------------------------------------------------------ */
 /**
  * Resolve role → display name without throwing on unknown roles. The
@@ -2080,9 +3837,9 @@ export class ReplSession {
  * tool stream rows, not transcript rows). The shape mirrors the
  * `persistRow` mapping in reverse:
  *
- *   'user'    -> operator (brief)
- *   'persona' -> persona  (text + personaSlug)
- *   'system'  -> system   (text)
+ *  'user'   -> operator (brief)
+ *  'persona' -> persona (text + personaSlug)
+ *  'system' -> system  (text)
  *
  * Exported indirectly via `restoreTranscript`.
  */
@@ -2129,13 +3886,76 @@ function eventToTranscriptRow(event) {
             timestampEpochMs: event.t,
         };
     }
+    if (event.kind === 'compaction') {
+        // L8 + L29 : 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 : 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,
  * headings - anything where per-line splitting would fragment visual
- * grouping (Claude triple-review P1 PR #369).
+ * grouping (Claude triple-review P1 PR).
  */
 function looksLikeMarkdown(text) {
     if (text.includes('```'))
@@ -2168,10 +3988,10 @@ function safePersonaName(role) {
  * Render a millisecond delta as a compact human-readable age. Used by
  * `/context` to surface the oldest working-set entry's age:
  *
- *   < 60s        -> `45s`
- *   < 1h         -> `4m`
- *   < 24h        -> `2h`
- *   >= 24h       -> `3d`
+ *  < 60s       -> `45s`
+ *  < 1h        -> `4m`
+ *  < 24h       -> `2h`
+ *  >= 24h      -> `3d`
  *
  * Negative deltas (clock skew) clamp to `0s`.
  */
@@ -2197,23 +4017,103 @@ function formatAgeSeconds(deltaMs) {
 export function knownRoles() {
     return listRoles();
 }
+/**
+ * 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`;
+}
+/**
+ * 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)',
+});
+/**
+ * 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`;
+}
+/**
+ * cleanup : wrap a `/quota` counter row in ANSI
+ * color codes by utilisation percent. Thresholds match the upstream tool's
+ * tier-meter convention so operators trained on that surface read the
+ * same signal here:
+ *
+ *  - 0..70%  → green (32m) — comfortable headroom
+ *  - 70..90% → yellow (33m) — approaching cap, plan ahead
+ *  - 90..100% → red (31m)   — burn rate alarm, throttle now
+ *
+ * The wrap is whole-row (not just the percent) so the eye registers
+ * the level on the line, not just the trailing parenthesis. Tests
+ * that match the inner row text via regex are unaffected because the
+ * regex anchors live inside the wrapped substring; the ANSI codes
+ * sit at the boundaries.
+ */
+export function colorizeQuotaRow(row, pct) {
+    const RESET = '\x1b[0m';
+    if (pct >= 90)
+        return `\x1b[31m${row}${RESET}`;
+    if (pct >= 70)
+        return `\x1b[33m${row}${RESET}`;
+    return `\x1b[32m${row}${RESET}`;
+}
 /* ------------------------------------------------------------------ */
-/* Tool call synthesiser - α6.12                                      */
+/* Tool call synthesiser -                                      */
 /* ------------------------------------------------------------------ */
 /**
  * Match canonical tool invocation grammar in an `agent.step.detail`
  * string and emit a synthesised `ToolCallEntry`. Returns null when no
  * known tool pattern matches.
  *
- * The grammar mirrors the way Claude Code, Codex CLI, and Gemini CLI
+ * The grammar mirrors the way the upstream tool, Codex CLI, and Gemini CLI
  * display tool calls in their tool stream panes:
  *
- *   Read(path)
- *   Edit(path[:lines])
- *   Bash(command)
- *   Grep("pattern" [in path])
- *   Glob(pattern)
- *   WebFetch(url)
+ *  Read(path)
+ *  Edit(path[:lines])
+ *  Bash(command)
+ *  Grep("pattern" [in path])
+ *  Glob(pattern)
+ *  WebFetch(url)
  *
  * The matcher is case-insensitive on the tool name so a persona that
  * spells the tool as `READ(...)` or `web_fetch(...)` still lands in
@@ -2228,9 +4128,9 @@ export function synthesiseToolCall(input) {
     if (detail.length === 0)
         return null;
     // Pattern: ToolName(args) optionally suffixed with a result hint.
-    // We allow the canonical Claude Code casing AND the snake_case
+    // We allow the canonical the upstream tool 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;
@@ -2248,12 +4148,32 @@ export function synthesiseToolCall(input) {
         startedAtEpochMs: input.now,
     };
 }
+/**
+ * small-CC-parity batch : collapse a multi-line
+ * result preview down to a single-line head capped at `max` chars. The
+ * collapsed-result row on a completed tool call uses this so the
+ * preview never expands the row vertically. Exported для the spec so
+ * the truncation behaviour is locked down.
+ */
+export function truncatePreview(value, max) {
+    if (!value)
+        return '';
+    // Strip CR/LF + tab so the preview stays single-line. Multiple
+    // whitespace runs collapse to single space — operator wants signal,
+    // not formatting noise.
+    const single = value.replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ').trim();
+    if (single.length <= max)
+        return single;
+    return `${single.slice(0, Math.max(0, max - 1))}…`;
+}
 function normaliseToolName(raw) {
     const lower = raw.toLowerCase();
     if (lower === 'webfetch' || lower === 'web_fetch')
         return 'web_fetch';
     if (lower === 'read')
         return 'read';
+    if (lower === 'write')
+        return 'write';
     if (lower === 'edit')
         return 'edit';
     if (lower === 'bash')
@@ -2284,12 +4204,12 @@ function parseStatusFromTail(tail) {
     return { status: 'ok', detail: tail };
 }
 /* ------------------------------------------------------------------ */
-/* α6.3 office-hours encoders                                          */
-/*                                                                    */
-/* Mirrors `tui/ask-modal.tsx#encodeAskVerdict` so the session can     */
-/* synthesise the operator-side echo without dragging an Ink module    */
-/* into the test surface. The two encoders MUST agree byte-for-byte -  */
-/* a divergence would silently mis-prefix the persona's follow-up.    */
+/* office-hours encoders                                         */
+/*                                                                   */
+/* Mirrors `tui/ask-modal.tsx#encodeAskVerdict` so the session can    */
+/* synthesise the operator-side echo without dragging an Ink module   */
+/* into the test surface. The two encoders MUST agree byte-for-byte - */
+/* a divergence would silently mis-prefix the persona's follow-up.   */
 /* ------------------------------------------------------------------ */
 function encodeAskVerdictLocal(verdict) {
     if (verdict.cancelled)
@@ -2315,7 +4235,7 @@ function encodeAskVerdictLocal(verdict) {
  * `[ASK-RESPONSE:other] [ASK-RESPONSE:vercel] my real answer` which
  * a prefix-greedy persona could read as "operator chose vercel".
  *
- * Claude triple-review P1 (PR #375).
+ * Claude triple-review P1 (PR).
  */
 function sanitiseVerdictText(raw) {
     let cleaned = raw;
@@ -2421,7 +4341,7 @@ export function synthesiseLocalAskTag(question) {
     // Use the single-source signature helper so a persona-emitted ask
     // with the same question + same option values does not collide with
     // this synthesised one under a divergent algorithm. Claude
-    // triple-review P1 (PR #375).
+    // triple-review P1 (PR).
     const signature = signatureForAsk(trimmed, options);
     return {
         question: trimmed,
@@ -2438,20 +4358,20 @@ export function synthesiseLocalAskTag(question) {
  * production callers go through `appendPersonaLine`.
  *
  * Examples (display name = "Pugi"):
- *   "Pugi, координатор Pugi. Брифую..."   -> "координатор Pugi. Брифую..."
- *   "Pugi: вот результат"                 -> "вот результат"
- *   "<workspace-context-abc>Pugi, привет" -> "привет"
- *   "обычный ответ без префикса"          -> "обычный ответ без префикса"
+ *  "Pugi, координатор Pugi. Брифую..."  -> "координатор Pugi. Брифую..."
+ *  "Pugi: вот результат"                -> "вот результат"
+ *  "<workspace-context-abc>Pugi, привет" -> "привет"
+ *  "обычный ответ без префикса"         -> "обычный ответ без префикса"
  *
  * The strip is conservative - we only remove the display name when it
  * is followed by a separator (comma, colon, dash, space) so a sentence
  * that legitimately contains the name mid-text ("спроси у Pugi") is
- * not mangled. (α6.14.2 wave 5 - CEO dogfood fix.)
+ * not mangled.
  */
 export function stripPersonaPrefixEcho(personaSlug, text) {
     let working = text.trimStart();
     // Drop any leaked `<workspace-context-...>` / `</workspace-context-...>`
-    // wrapper at the head. The Mira prompt v1.1 sometimes echoes the
+    // wrapper at the head. The Pugi prompt v1.1 sometimes echoes the
     // scaffolding envelope back when the model is warm-starting the
     // first turn; cosmetic noise the operator never needs to see.
     // We strip both opening tag and any text up to (and including) the
@@ -2479,7 +4399,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) 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 +4426,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;
 }