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

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': {

package/dist/core/smoke/headless-driver.js

@@ -0,0 +1,174 @@
+/**
+ * Headless subprocess driver for the smoke harness (Phase 1, 2026-05-27).
+ *
+ * Spawns `pugi --headless`, feeds the scenario's user-input lines one
+ * at a time, and collects every JSON envelope written to stdout. The
+ * driver is the bridge between the in-process scenario parser and the
+ * real CLI binary — running scenarios via subprocess is what lets
+ * `pugi smoke` validate the AS-PUBLISHED CLI, not just the in-process
+ * code path.
+ *
+ * Phase 1 invariants:
+ *
+ *   - One scenario = one subprocess. We do NOT reuse processes across
+ *     scenarios; each run starts in a fresh temp workspace so file
+ *     assertions are deterministic.
+ *
+ *   - Stdin is fed line-by-line on a timer (default 200ms gap). We
+ *     could fire all lines at once, but spacing them out gives the
+ *     engine a chance to emit `persona-turn` envelopes between user
+ *     turns. Mirrors real-operator typing cadence — feeds a more
+ *     realistic test signal than a burst write.
+ *
+ *   - Hard timeout per scenario (default 30s). The driver kills the
+ *     subprocess on timeout and surfaces a clean executor-error so the
+ *     report still shows the row instead of hanging CI.
+ *
+ *   - Stderr is captured but NOT parsed. We forward it to the optional
+ *     `onStderr` sink so the operator can see what the headless CLI
+ *     wrote to stderr (banners, MCP load notices) — handy for
+ *     debugging a failing scenario locally.
+ */
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+/**
+ * Run a parsed scenario through the headless CLI. Returns the captured
+ * envelope stream + the workspace root the process ran in so the
+ * runner can resolve `EXPECT_FILE` paths.
+ */
+export async function runHeadlessScenario(scenario, opts = {}) {
+    const pugiBin = opts.pugiBin ?? 'pugi';
+    const extraArgs = opts.extraArgs ?? [];
+    const timeoutMs = opts.timeoutMs ?? 30_000;
+    const lineGapMs = opts.lineGapMs ?? 200;
+    const onStderr = opts.onStderr ?? noopChunk;
+    const spawner = opts.spawner ?? defaultSpawner;
+    const workspaceRoot = mkdtempSync(resolve(tmpdir(), 'pugi-smoke-'));
+    let cleanedUp = false;
+    const args = ['--headless', ...extraArgs];
+    const child = spawner(pugiBin, args, {
+        cwd: workspaceRoot,
+        env: { ...process.env, PUGI_HEADLESS: '1' },
+    });
+    const envelopes = [];
+    let stdoutBuffer = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        stdoutBuffer += chunk;
+        let newlineIndex = stdoutBuffer.indexOf('\n');
+        while (newlineIndex !== -1) {
+            const line = stdoutBuffer.slice(0, newlineIndex);
+            stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+            const parsed = parseEnvelopeLine(line);
+            if (parsed)
+                envelopes.push(parsed);
+            newlineIndex = stdoutBuffer.indexOf('\n');
+        }
+    });
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => onStderr(chunk));
+    const userInputs = scenario.steps
+        .filter((s) => s.kind === 'user-input')
+        .map((s) => s.body);
+    // Feed inputs serially with a small gap. We don't await the engine's
+    // response — Phase 1 evaluates the WHOLE envelope stream after the
+    // process closes, so the gap is purely to give the engine room to
+    // emit between turns. A future phase can swap this for a barrier
+    // ("wait for `persona-turn` before sending the next `user-turn`")
+    // once envelope ordering is sealed.
+    const feedPromise = (async () => {
+        for (const line of userInputs) {
+            child.stdin.write(`${line}\n`);
+            await delay(lineGapMs);
+        }
+        child.stdin.end();
+    })();
+    const timeoutHandle = setTimeout(() => {
+        child.kill('SIGTERM');
+    }, timeoutMs);
+    // Don't keep node alive purely for the timeout — the spawned child
+    // already holds the loop via its IPC pipe.
+    timeoutHandle.unref?.();
+    await new Promise((resolvePromise) => {
+        child.on('close', () => resolvePromise());
+    });
+    clearTimeout(timeoutHandle);
+    // Flush any tail bytes that did not end with a newline.
+    if (stdoutBuffer.length > 0) {
+        const parsed = parseEnvelopeLine(stdoutBuffer);
+        if (parsed)
+            envelopes.push(parsed);
+        stdoutBuffer = '';
+    }
+    await feedPromise.catch(() => {
+        /* feed promise rejects when the child closes early — ignore */
+    });
+    // Cleanup the temp workspace lazily — the orchestrator may want to
+    // inspect it after the run. Callers that need a fresh dir per scenario
+    // should pass a custom workspaceRoot in a future phase; for now the
+    // runner resolves EXPECT_FILE paths against this directory and the
+    // OS reaps the tmp tree on reboot.
+    // (Explicit cleanup helper exposed for tests that want determinism.)
+    void cleanedUp;
+    return { envelopes, workspaceRoot };
+}
+/**
+ * Tear down a workspace created by `runHeadlessScenario`. Exposed
+ * separately because the orchestrator wants the directory to survive
+ * the run for EXPECT_FILE evaluation.
+ */
+export function cleanupWorkspace(workspaceRoot) {
+    try {
+        rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/**
+ * Parse one line of headless stdout into an envelope. Returns null
+ * when the line is empty or unparseable — non-fatal so the runner can
+ * tolerate stray banner output.
+ */
+export function parseEnvelopeLine(raw) {
+    const line = raw.trim();
+    if (line.length === 0)
+        return null;
+    if (!line.startsWith('{'))
+        return null;
+    try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed['kind'] !== 'string')
+            return null;
+        if (typeof parsed['body'] !== 'string')
+            return null;
+        const ts = typeof parsed['ts'] === 'number'
+            ? parsed['ts']
+            : Number(parsed['ts'] ?? Date.now());
+        return {
+            kind: parsed['kind'],
+            body: parsed['body'],
+            ts: Number.isFinite(ts) ? ts : Date.now(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function defaultSpawner(bin, args, options) {
+    return spawn(bin, args, {
+        cwd: options.cwd,
+        env: options.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        const handle = setTimeout(resolve, ms);
+        handle.unref?.();
+    });
+}
+function noopChunk(_chunk) { }
+//# sourceMappingURL=headless-driver.js.map

package/dist/core/smoke/orchestrator.js

@@ -0,0 +1,194 @@
+/**
+ * Smoke orchestrator — glues the scenario parser, the headless
+ * subprocess driver, and the runner into a single "load → run → report"
+ * pipeline. The CLI surface (`pugi smoke`) and the standalone script
+ * (`scripts/run-scenarios.ts`) both call into this module so the two
+ * entry points share one code path.
+ *
+ * Phase 1 boundary — `runSmoke` is responsible for:
+ *
+ *   1. Discovering scenario files under `scenariosDir` (glob match on
+ *      `*.scenario.txt`).
+ *   2. Parsing each file via `parseScenario`. Parse errors are surfaced
+ *      via the report but do not stop the run — every scenario gets a
+ *      chance to fail with a clean diagnostic.
+ *   3. Driving each scenario through the headless executor (the
+ *      executor is injected so tests can swap it for a deterministic
+ *      stub; production wires `runHeadlessScenario` from
+ *      `headless-driver.ts`).
+ *   4. Filtering by `--filter <pattern>` (compiles to fnmatch-lite).
+ *   5. Computing pass/fail/summary numbers.
+ *
+ * The orchestrator is intentionally synchronous (apart from the
+ * per-scenario `await`) — running scenarios in parallel is a Phase 2
+ * concern. The corpus is small and sequential output is easier to read.
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseScenario, } from './scenario-parser.js';
+import { runScenario, } from './runner.js';
+/**
+ * Top-level smoke entry. Returns the report so the CLI can pretty-print
+ * it AND set `process.exitCode` deterministically.
+ */
+export async function runSmoke(opts) {
+    const log = opts.log ?? noopLog;
+    const now = opts.now ?? Date.now;
+    const allScenarios = loadScenariosFromDir(opts.scenariosDir);
+    const visible = opts.filter && opts.filter.length > 0
+        ? filterByPattern(allScenarios, opts.filter)
+        : allScenarios;
+    const results = [];
+    let passed = 0;
+    let failed = 0;
+    for (const item of visible) {
+        log(`pugi smoke: running ${item.scenario.id}`);
+        if (item.parseErrors.length > 0) {
+            results.push({
+                id: item.scenario.id,
+                filePath: item.scenario.filePath,
+                status: 'parse-error',
+                durationMs: 0,
+                assertionCount: 0,
+                failures: [],
+                parseErrors: item.parseErrors,
+            });
+            failed += 1;
+            continue;
+        }
+        let envelopes = [];
+        let workspaceRoot = '.';
+        try {
+            const out = await opts.executor(item.scenario);
+            envelopes = out.envelopes;
+            workspaceRoot = out.workspaceRoot;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({
+                id: item.scenario.id,
+                filePath: item.scenario.filePath,
+                status: 'executor-error',
+                durationMs: 0,
+                assertionCount: 0,
+                failures: [],
+                executorError: message,
+            });
+            failed += 1;
+            continue;
+        }
+        const result = runScenario({
+            scenario: item.scenario,
+            envelopes,
+            workspaceRoot,
+            now,
+        });
+        results.push({
+            id: result.id,
+            filePath: item.scenario.filePath,
+            status: result.passed ? 'passed' : 'failed',
+            durationMs: result.durationMs,
+            assertionCount: result.assertionCount,
+            failures: result.failures,
+        });
+        if (result.passed)
+            passed += 1;
+        else
+            failed += 1;
+    }
+    const total = visible.length;
+    const skipped = allScenarios.length - visible.length;
+    const exitCode = failed === 0 ? 0 : 1;
+    return { total, passed, failed, skipped, results, exitCode };
+}
+/**
+ * Walk `dir` for `*.scenario.txt` files (non-recursive). Returns each
+ * file's parsed scenario + collected parse errors so the orchestrator
+ * can surface malformed files as failed runs rather than skipping them.
+ */
+export function loadScenariosFromDir(dir) {
+    let names = [];
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        if (!name.endsWith('.scenario.txt'))
+            continue;
+        const filePath = resolve(dir, name);
+        let stat;
+        try {
+            stat = statSync(filePath);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isFile())
+            continue;
+        const body = readFileSync(filePath, 'utf8');
+        const parsed = parseScenario(filePath, body);
+        if (parsed.scenario) {
+            out.push({ scenario: parsed.scenario, parseErrors: parsed.errors });
+        }
+    }
+    // Stable sort by id so report output is deterministic across
+    // filesystems with different readdir order.
+    out.sort((a, b) => a.scenario.id.localeCompare(b.scenario.id));
+    return out;
+}
+/**
+ * Render a SmokeReport into a multi-line human-readable string. Kept
+ * separate from `runSmoke` so the CLI can pick its own format (text vs
+ * JSON). The default text format mirrors `node:test`'s tap-lite output:
+ *
+ *   ok 1 - identity (12ms)
+ *   not ok 2 - codegen-create-file (8ms)
+ *     line 5: EXPECT failed — no envelope matched ...
+ *
+ *   pugi smoke: 1 passed, 1 failed
+ */
+export function renderReportText(report) {
+    const lines = [];
+    for (let i = 0; i < report.results.length; i += 1) {
+        const r = report.results[i];
+        if (!r)
+            continue;
+        const ordinal = i + 1;
+        if (r.status === 'passed') {
+            lines.push(`ok ${ordinal} - ${r.id} (${r.durationMs}ms)`);
+        }
+        else if (r.status === 'failed') {
+            lines.push(`not ok ${ordinal} - ${r.id} (${r.durationMs}ms)`);
+            for (const f of r.failures) {
+                lines.push(`  line ${f.line}: ${f.message}`);
+            }
+        }
+        else if (r.status === 'parse-error') {
+            lines.push(`not ok ${ordinal} - ${r.id} (parse error)`);
+            for (const e of r.parseErrors ?? []) {
+                lines.push(`  line ${e.line}: ${e.message}`);
+            }
+        }
+        else if (r.status === 'executor-error') {
+            lines.push(`not ok ${ordinal} - ${r.id} (executor error)`);
+            lines.push(`  ${r.executorError ?? 'unknown executor failure'}`);
+        }
+    }
+    lines.push('');
+    const skippedSuffix = report.skipped > 0 ? `, ${report.skipped} skipped` : '';
+    lines.push(`pugi smoke: ${report.passed} passed, ${report.failed} failed${skippedSuffix}`);
+    return lines.join('\n');
+}
+function filterByPattern(scenarios, pattern) {
+    if (!pattern.includes('*')) {
+        return scenarios.filter((s) => s.scenario.id.includes(pattern));
+    }
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
+    return scenarios.filter((s) => re.test(s.scenario.id));
+}
+function noopLog(_line) { }
+//# sourceMappingURL=orchestrator.js.map