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

package/dist/core/repl/session.js

@@ -47,6 +47,22 @@ import { DispatchFSM } from './dispatch-fsm.js';
 import { computeCostUsd, formatCostUsd, formatTokens } from './model-pricing.js';
 const MAX_TRANSCRIPT_ROWS = 500;
 const MAX_TOOL_CALLS = 200;
+/**
+ * Wave 6 small-CC-parity batch (2026-05-27): 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;
+/**
+ * Wave 6 small-CC-parity batch (2026-05-27): 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;
@@ -397,6 +413,13 @@ export class ReplSession {
             // a failed flush leaves the queue intact for the next start.
             // Never blocks bootstrap.
             void this.flushFeedbackQueueOnBootstrap().catch(() => undefined);
+            // Wave 6 BT 9 Phase 2 (2026-05-27): 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)}`);
@@ -455,6 +478,47 @@ export class ReplSession {
             apiKey: this.options.apiKey,
         });
     }
+    /**
+     * Wave 6 BT 9 Phase 2 (2026-05-27): 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.
@@ -714,7 +778,43 @@ export class ReplSession {
                 return verdict;
             }
             case 'jobs': {
-                await this.dispatchJobs();
+                // Wave 6 cleanup (2026-05-27): `/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': {
+                // Wave 6 small-CC-parity batch (2026-05-27): 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': {
@@ -1131,6 +1231,38 @@ export class ReplSession {
                 }
                 return verdict;
             }
+            case 'codegraph-status': {
+                // Wave 6 BT 9 Phase 2 (2026-05-27): 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': {
                 // Leak L6: handle the `/permissions [mode] [--persist]` flow.
                 // The session module forwards to the runtime helper so the
@@ -1517,6 +1649,39 @@ export class ReplSession {
                 }
                 return verdict;
             }
+            case 'redo': {
+                // Wave 6 cleanup (2026-05-27): 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 'stub': {
                 this.appendSystemLine(verdict.message);
                 return verdict;
@@ -1863,22 +2028,87 @@ export class ReplSession {
         try {
             const registry = getJobRegistry();
             const entries = await registry.list();
-            if (entries.length === 0) {
+            // Wave 6 cleanup (2026-05-27): 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)}`);
         }
     }
+    /**
+     * Wave 6 cleanup (2026-05-27): 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');
@@ -2015,14 +2245,25 @@ export class ReplSession {
                 ['review', used.review, caps.review],
                 ['engine', used.engine, caps.engine],
             ];
+            // Wave 6 cleanup (2026-05-27): color-code each counter row by
+            // utilisation. The thresholds match Claude Code'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;
-                    this.appendSystemLine(`  ${name.padEnd(7, ' ')} ${v.toLocaleString()} / ${cap.toLocaleString()} (${pct}%)`);
+                    const row = `  ${name.padEnd(7, ' ')} ${v.toLocaleString()} / ${cap.toLocaleString()} (${pct}%)`;
+                    this.appendSystemLine(colorizeQuotaRow(row, pct));
                 }
             }
         }
@@ -2079,6 +2320,17 @@ export class ReplSession {
                 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, '');
@@ -3098,6 +3350,73 @@ export class ReplSession {
         const agent = this.state.agents.find((a) => a.taskId === taskId);
         return agent?.personaSlug ?? 'unknown';
     }
+    /**
+     * Wave 6 small-CC-parity batch (2026-05-27): 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 });
+    }
+    /**
+     * Wave 6 small-CC-parity batch (2026-05-27): 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` →
@@ -3671,6 +3990,30 @@ function formatResetWindow(resetAtIso, nowEpochMs) {
     const minutes = Math.max(1, Math.floor(deltaMs / (60 * 1000)));
     return `in ${minutes}m`;
 }
+/**
+ * Wave 6 cleanup (2026-05-27): wrap a `/quota` counter row in ANSI
+ * color codes by utilisation percent. Thresholds match Claude Code'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                                      */
 /* ------------------------------------------------------------------ */
@@ -3722,6 +4065,24 @@ export function synthesiseToolCall(input) {
         startedAtEpochMs: input.now,
     };
 }
+/**
+ * Wave 6 small-CC-parity batch (2026-05-27): 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')

package/dist/core/repl/slash-commands.js

@@ -63,7 +63,8 @@ export const SLASH_COMMAND_HELP = Object.freeze([
     { name: 'agents', args: '', gloss: 'List the on-watch agent roster', group: 'Workforce dispatch' },
     { name: 'delegate', args: '<slug> <brief>', gloss: 'Dispatch a brief to one Tier 1 specialist (α7.5)', group: 'Workforce dispatch' },
     { name: 'stop', args: '<persona>', gloss: 'Stop one agent by persona slug', group: 'Workforce dispatch' },
-    { name: 'jobs', args: '', gloss: 'List background jobs', group: 'Workforce dispatch' },
+    { name: 'jobs', args: '[--watch]', gloss: 'List background jobs + agent-progress; --watch mounts the live Ink TUI', group: 'Workforce dispatch' },
+    { name: 'cancel', args: '[<id> | all]', gloss: 'Halt active dispatch by id (Wave 6)', group: 'Workforce dispatch' },
     { name: 'ask', args: '<question>', gloss: 'Surface a yes/no modal locally (α6.3 forcing question)', group: 'Workforce dispatch' },
     // Session
     { name: 'clear', args: '', gloss: 'Clear conversation pane', group: 'Session' },
@@ -81,6 +82,7 @@ export const SLASH_COMMAND_HELP = Object.freeze([
     { name: 'status', args: '', gloss: 'Session snapshot — id · cwd · mode · tokens · dispatches · auth', group: 'Pugi tools' },
     { name: 'consensus', args: '[ref]', gloss: '3-model consensus review (codex · claude · deepseek)', group: 'Pugi tools' },
     { name: 'repo-map', args: '[refresh]', gloss: 'AST-light symbol summary of the workspace (leak L28)', group: 'Pugi tools' },
+    { name: 'codegraph-status', args: '[--install|--reindex|--offer]', gloss: 'Codegraph MCP — install state, index age, symbol count, refresh CTA (Wave 6 BT 9 P2)', group: 'Pugi tools' },
     // Settings
     { name: 'config', args: '', gloss: 'Show config', group: 'Settings', stub: true },
     { name: 'privacy', args: '', gloss: 'Show privacy mode + contract', group: 'Settings' },
@@ -94,6 +96,7 @@ export const SLASH_COMMAND_HELP = Object.freeze([
     { name: 'onboarding', args: '[--reset|--non-interactive]', gloss: 'First-run wizard — auth / mode / style / MCP / telemetry (leak L25)', group: 'Settings' },
     { name: 'vim', args: '[on|off|status]', gloss: 'Toggle vim-style modal editing in the input buffer (leak L26)', group: 'Settings' },
     { name: 'undo', args: '', gloss: 'Revert the last successful write / edit / multi_edit (Aider walk-back, Wave 6)', group: 'Settings' },
+    { name: 'redo', args: '', gloss: 'Reapply the most recent /undo (LIFO stack, Wave 6 cleanup)', group: 'Settings' },
     // Meta
     { name: 'help', args: '', gloss: 'Show this help overlay', group: 'Meta' },
     { name: 'version', args: '', gloss: 'Show CLI version', group: 'Meta' },
@@ -231,7 +234,48 @@ export function parseSlashCommand(input) {
             return { kind: 'version' };
         }
         case 'jobs': {
-            return { kind: 'jobs' };
+            // Wave 6 cleanup (2026-05-27): tokenise the tail so the slash
+            // can route `--watch` к the live Ink TUI (same renderer as
+            // `pugi jobs --watch`). Unknown tokens fall through silently —
+            // the slash surface is intentionally minimal vs. the shell
+            // command (which supports list/status/tail/kill subcommands
+            // through `runJobsCommand`).
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            const watch = tokens.includes('--watch') || tokens.includes('-w') || tokens[0] === 'watch';
+            return { kind: 'jobs', watch };
+        }
+        case 'cancel':
+        case 'halt': {
+            // Wave 6 small-CC-parity batch (2026-05-27):
+            //
+            //   /cancel              -> list active dispatches
+            //   /cancel all          -> halt every running dispatch
+            //   /cancel <id>         -> halt one (id may be a prefix; runner
+            //                           does startsWith lookup)
+            //
+            // The `halt` alias matches operator muscle memory from systemd /
+            // brand voice (`stop` is already taken by /stop <persona>; cancel
+            // is dispatch-id-keyed, stop is persona-keyed). Unknown extra
+            // tokens are tolerated — the runner reads only the first.
+            const trimmedTail = tail.trim();
+            if (trimmedTail.length === 0) {
+                return { kind: 'cancel', mode: 'list', dispatchId: '' };
+            }
+            const firstToken = trimmedTail.split(/\s+/)[0].toLowerCase();
+            if (firstToken === 'all' || firstToken === '*') {
+                return { kind: 'cancel', mode: 'all', dispatchId: 'all' };
+            }
+            // Defensive: dispatch ids are filename-safe per the
+            // `validateAgentProgress` agentId regex (`[a-zA-Z0-9_-]+`).
+            // Reject anything outside that range with a usage tip so the
+            // operator sees the typo before the round-trip.
+            if (!/^[A-Za-z0-9_-]+$/.test(firstToken)) {
+                return {
+                    kind: 'error',
+                    message: `/cancel: invalid dispatch id '${firstToken}'. Use letters / digits / '-' / '_' only.`,
+                };
+            }
+            return { kind: 'cancel', mode: 'one', dispatchId: firstToken };
         }
         case 'ask': {
             if (tail.length === 0) {
@@ -477,6 +521,17 @@ export function parseSlashCommand(input) {
             const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
             return { kind: 'chain', args: tokens };
         }
+        case 'codegraph-status':
+        case 'codegraph': {
+            // Wave 6 BT 9 Phase 2 (2026-05-27): forward the tokenized argv
+            // to `runCodegraphStatusCommand`. Flags handled by the runner:
+            //   --install — merge codegraph into .pugi/mcp.json (accept)
+            //   --reindex — stamp lastIndexedAt + hint runtime to refresh
+            //   --offer   — surface the install prompt even after a decline
+            // `/codegraph` is the short alias; same handler.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'codegraph-status', args: tokens };
+        }
         case 'compact': {
             // Leak L8 (2026-05-27): graduated from stub. The session module
             // owns the summariser round-trip. Wave 6 BT 8: `--force` overrides
@@ -561,11 +616,19 @@ export function parseSlashCommand(input) {
             // Wave 6 final (2026-05-27): graduated from stub. Tail args are
             // ignored — `runUndoCommand` is parameterless (single-step revert
             // of the most recent successful mutating tool result). Multiple
-            // undos = stack of single-step undos. Re-do is not yet
-            // implemented; the runner reports that in the operator-facing
-            // message after each successful undo.
+            // undos = stack of single-step undos. `/redo` is the counterpart
+            // (Wave 6 cleanup) — operators ping-pong через undo/redo on the
+            // event-log stack without re-running the underlying tool.
             return { kind: 'undo' };
         }
+        case 'redo': {
+            // Wave 6 cleanup (2026-05-27): counterpart к /undo. Tail args
+            // are ignored — `runRedoCommand` is parameterless. Each /redo
+            // pops one entry from the LIFO undo stack (the runner tracks
+            // which undos have already been consumed by previous redos so
+            // double-/redo is a noop, not a double-write).
+            return { kind: 'redo' };
+        }
         case 'memory':
         case 'config':
         case 'budget': {