@pugi/cli 0.1.0-beta.16 → 0.1.0-beta.17

package/dist/commands/jobs-watch.js

@@ -0,0 +1,201 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * `pugi jobs --watch` Ink TUI — α7 live progress (2026-05-27).
+ *
+ * Tails `~/.pugi/agent-progress/*.json` via chokidar and re-renders a
+ * grid of <AgentProgressCard> components. Mirrors the Claude Code
+ * `/compact` layout pattern — one card per agent, sorted by status
+ * (running → completed → failed) then by lastUpdate descending so the
+ * freshest activity floats к the top.
+ *
+ * Lifecycle:
+ *   1. Resolve dir via resolveProgressDir() (env-aware).
+ *   2. Initial scan with readdirSync — populate the map.
+ *   3. chokidar.watch(dir, { ignoreInitial: true }) for add/change/unlink.
+ *   4. setInterval(1000) tick re-renders to keep elapsed labels live
+ *      WITHOUT re-reading files.
+ *   5. SIGINT (Ctrl+C) triggers `app.unmount()` + process.exit(0).
+ *
+ * Layout: single column under 100 cols, two columns at 100+ cols
+ * (Ink's flexbox computes the responsive split automatically — we just
+ * set `flexDirection="row" flexWrap="wrap"` and bound each card к 50%
+ * width when stdout is wide enough).
+ *
+ * The TUI is opt-in (operator runs `pugi jobs --watch`); the bare
+ * `pugi jobs` continues to print the legacy job-registry table.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import chokidar from 'chokidar';
+import { useEffect, useMemo, useState } from 'react';
+import { Box, Text, render, useApp, useInput, useStdout } from 'ink';
+import { resolveProgressDir } from '../core/agent-progress/writer.js';
+import { runCleanup } from '../core/agent-progress/cleanup.js';
+import { validateAgentProgress, } from '../core/agent-progress/schema.js';
+import { AgentProgressCard } from '../tui/agent-progress-card.js';
+/** Cleanup pass cadence inside the watcher. Cheap (readdir on a small
+ *  dir); 60s is the operator-tested sweet spot — fast enough to feel
+ *  live, slow enough к never burn CPU. */
+const CLEANUP_INTERVAL_MS = 60_000;
+const STATUS_RANK = {
+    running: 0,
+    completed: 1,
+    failed: 2,
+};
+/**
+ * Read + validate one progress file. Returns undefined on any failure
+ * — the watcher prefers к skip a malformed entry rather than crash.
+ * Exported for the spec.
+ */
+export function readProgressFile(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const body = readFileSync(path, 'utf8');
+        const parsed = JSON.parse(body);
+        const result = validateAgentProgress(parsed);
+        return result.ok ? result.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Sort progress entries for stable, operator-friendly display:
+ *   1. Running first.
+ *   2. Then by lastUpdate (most recent first).
+ *   3. Tiebreak on agentId for snapshot stability.
+ */
+export function sortProgressEntries(entries) {
+    return [...entries].sort((a, b) => {
+        const rank = STATUS_RANK[a.status] - STATUS_RANK[b.status];
+        if (rank !== 0)
+            return rank;
+        const tsDiff = Date.parse(b.lastUpdate) - Date.parse(a.lastUpdate);
+        if (tsDiff !== 0)
+            return tsDiff;
+        return a.agentId.localeCompare(b.agentId);
+    });
+}
+export function JobsWatch(props) {
+    const { dir, nowEpochMs, staticMode = false } = props;
+    const resolvedDir = useMemo(() => resolveProgressDir(dir), [dir]);
+    const [agents, setAgents] = useState(() => initialScan(resolvedDir));
+    const [tick, setTick] = useState(0);
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const cols = stdout?.columns ?? 80;
+    const twoColumns = cols >= 100;
+    useInput((_input, key) => {
+        if (key.escape || key.ctrl) {
+            // Ink's useInput passes ctrl=true for Ctrl+<x>; we exit on Ctrl+C
+            // (key.ctrl alone is too broad — actual key char arrives in `input`).
+            // Practically, raw mode passes Ctrl+C as SIGINT to the process so
+            // this is a belt-and-suspenders catch.
+            if (key.escape)
+                exit();
+        }
+    });
+    useEffect(() => {
+        if (staticMode)
+            return;
+        let watcher;
+        try {
+            watcher = chokidar.watch(resolvedDir, {
+                ignoreInitial: true,
+                depth: 0,
+                // The agent writer uses atomic rename — chokidar reports `add`
+                // when the final filename appears, never the *.tmp-* intermediate.
+                ignored: /\.tmp-/,
+            });
+            const onChange = (path) => {
+                if (!/\.json$/.test(path))
+                    return;
+                const progress = readProgressFile(path);
+                if (!progress)
+                    return;
+                setAgents((prev) => ({ ...prev, [progress.agentId]: progress }));
+            };
+            const onRemove = (path) => {
+                const match = /([^/\\]+)\.json$/.exec(path);
+                if (!match)
+                    return;
+                const id = match[1];
+                if (!id)
+                    return;
+                setAgents((prev) => {
+                    if (!(id in prev))
+                        return prev;
+                    const next = { ...prev };
+                    delete next[id];
+                    return next;
+                });
+            };
+            watcher.on('add', onChange);
+            watcher.on('change', onChange);
+            watcher.on('unlink', onRemove);
+        }
+        catch {
+            // Watcher failures degrade gracefully — initial scan still rendered.
+        }
+        const interval = setInterval(() => setTick((t) => t + 1), 1000);
+        // Auto-cleanup completed/failed entries older than the TTL. The
+        // sweep moves them к `<dir>/archive/` so operators can still
+        // forensic; the watcher's chokidar `unlink` handler drops them
+        // from the live grid as the rename fires.
+        const cleanupInterval = setInterval(() => {
+            try {
+                runCleanup({ dir: resolvedDir });
+            }
+            catch {
+                // best-effort housekeeping; never crash the TUI
+            }
+        }, CLEANUP_INTERVAL_MS);
+        return () => {
+            clearInterval(interval);
+            clearInterval(cleanupInterval);
+            if (watcher) {
+                void watcher.close();
+            }
+        };
+    }, [resolvedDir, staticMode]);
+    const sorted = useMemo(() => sortProgressEntries(Object.values(agents)), [agents]);
+    const effectiveNow = nowEpochMs ?? Date.now() + tick * 0; // tick triggers re-render only
+    if (sorted.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { dimColor: true, children: ["No agents broadcasting progress yet. Watching", ' ', _jsx(Text, { bold: true, children: resolvedDir }), " for `<id>.json` files\u2026"] }), _jsx(Text, { dimColor: true, children: "(Press Esc / Ctrl+C \u043A exit.)" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, children: "pugi jobs --watch" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", sorted.length, " ", sorted.length === 1 ? 'agent' : 'agents', " \u00B7", ' ', resolvedDir] })] }), _jsx(Box, { flexDirection: "row", flexWrap: "wrap", children: sorted.map((progress) => (_jsx(Box, { width: twoColumns ? '50%' : '100%', flexDirection: "column", children: _jsx(AgentProgressCard, { progress: progress, nowEpochMs: effectiveNow }) }, progress.agentId))) }), _jsx(Text, { dimColor: true, children: "(Esc / Ctrl+C \u043A exit.)" })] }));
+}
+function initialScan(dir) {
+    const map = {};
+    if (!existsSync(dir))
+        return map;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return map;
+    }
+    for (const name of entries) {
+        if (!name.endsWith('.json'))
+            continue;
+        if (/\.tmp-/.test(name))
+            continue;
+        const progress = readProgressFile(join(dir, name));
+        if (progress)
+            map[progress.agentId] = progress;
+    }
+    return map;
+}
+/**
+ * Entry-point for `pugi jobs --watch`. Mounts the Ink app and returns
+ * a Promise that resolves when the user exits (Ctrl+C / Esc).
+ */
+export async function runJobsWatch(options = {}) {
+    return new Promise((resolve) => {
+        const app = render(_jsx(JobsWatch, { dir: options.dir }), { exitOnCtrlC: true });
+        void app.waitUntilExit().then(() => resolve(0));
+    });
+}
+//# sourceMappingURL=jobs-watch.js.map

package/dist/commands/jobs.js

@@ -16,6 +16,7 @@
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { formatDuration, getJobRegistry, relativeAge, } from '../core/jobs/registry.js';
+import { runJobsWatch } from './jobs-watch.js';
 const HUMAN_STATUS = {
     running: 'on watch',
     finished: 'shipped',
@@ -24,6 +25,19 @@ const HUMAN_STATUS = {
     abandoned: 'lost',
 };
 export async function runJobsCommand(args, flags, io, sessionId) {
+    // α7 live progress (2026-05-27): `pugi jobs --watch` mounts the live
+    // agent-progress TUI. The flag may sit anywhere in the arg list
+    // (`pugi jobs --watch` or `pugi jobs watch`) — both forms route к
+    // the watcher. JSON mode is incompatible (it would never return); we
+    // bail with a helpful error instead of silently swallowing the flag.
+    const wantsWatch = args.includes('--watch') || args[0] === 'watch';
+    if (wantsWatch) {
+        if (flags.json) {
+            io.writeError('pugi jobs --watch is interactive; --json is not supported.');
+            return 2;
+        }
+        return runJobsWatch();
+    }
     const sub = args[0] ?? 'list';
     switch (sub) {
         case 'list':
@@ -48,6 +62,7 @@ function usage() {
         '  pugi jobs tail <id>                      Stream the captured artifact.',
         '  pugi jobs kill <id> [--json]             SIGTERM, escalate to SIGKILL.',
         '  pugi jobs kill --all [--json]            Stand down every running job.',
+        '  pugi jobs --watch                        Live Ink TUI of agent progress.',
     ].join('\n');
 }
 async function runList(flags, io) {

package/dist/core/agent-progress/cleanup.js

@@ -0,0 +1,134 @@
+/**
+ * Agent-progress auto-cleanup — α7 live progress (2026-05-27).
+ *
+ * Rule: a progress file whose status === 'completed' OR 'failed' AND
+ * whose `lastUpdate` is older than COMPLETION_TTL_MS (default 5 min)
+ * gets MOVED into `<dir>/archive/<id>-<ts>.json` rather than deleted.
+ * Operators sometimes want to inspect a finished agent's last state;
+ * the archive keeps that affordance while preventing the live watcher
+ * from cluttering up with stale rows.
+ *
+ * The function is pure-ish:
+ *   - All clock reads go through the injected `now` (defaults Date.now).
+ *   - Returns a structured report so the caller (the watcher or a CLI
+ *     cron) can log what got swept.
+ *   - File-system errors degrade silently — the cleanup is best-effort
+ *     housekeeping, never a hot path.
+ *
+ * Hook-in point: `pugi jobs --watch` calls `runCleanup()` once per
+ * 60-second tick (cheap — readdir on a small directory). A separate
+ * cron entry can call it standalone via the (future) `pugi jobs
+ * gc` subcommand if the operator never runs --watch.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, } from 'node:fs';
+import { join } from 'node:path';
+import { validateAgentProgress, } from './schema.js';
+import { resolveProgressDir } from './writer.js';
+/** Default time a completed/failed entry sits before getting swept. */
+export const COMPLETION_TTL_MS = 5 * 60 * 1000;
+/** Archive subdirectory under the resolved progress dir. */
+export const ARCHIVE_SUBDIR = 'archive';
+/**
+ * Run a single cleanup pass. Returns the report for telemetry / tests.
+ */
+export function runCleanup(options = {}) {
+    const dir = resolveProgressDir(options.dir);
+    const ttl = options.ttlMs ?? COMPLETION_TTL_MS;
+    const now = options.now ?? Date.now;
+    const report = { dir, archived: [], skipped: [] };
+    if (!existsSync(dir))
+        return report;
+    const archiveDir = join(dir, ARCHIVE_SUBDIR);
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch (err) {
+        report.skipped.push({ path: dir, reason: `readdir failed: ${err.message}` });
+        return report;
+    }
+    for (const name of entries) {
+        if (!name.endsWith('.json'))
+            continue;
+        if (/\.tmp-/.test(name))
+            continue;
+        const path = join(dir, name);
+        let body;
+        try {
+            body = readFileSync(path, 'utf8');
+        }
+        catch {
+            report.skipped.push({ path, reason: 'read failed' });
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            report.skipped.push({ path, reason: 'malformed JSON' });
+            continue;
+        }
+        const validation = validateAgentProgress(parsed);
+        if (!validation.ok) {
+            report.skipped.push({ path, reason: `invalid: ${validation.error}` });
+            continue;
+        }
+        const progress = validation.value;
+        if (!isExpired(progress, now(), ttl)) {
+            continue;
+        }
+        if (!existsSync(archiveDir)) {
+            try {
+                mkdirSync(archiveDir, { recursive: true });
+            }
+            catch (err) {
+                report.skipped.push({
+                    path,
+                    reason: `archive mkdir failed: ${err.message}`,
+                });
+                continue;
+            }
+        }
+        const target = join(archiveDir, `${progress.agentId}-${safeStamp(progress.lastUpdate)}.json`);
+        try {
+            renameSync(path, target);
+            report.archived.push({ agentId: progress.agentId, from: path, to: target });
+        }
+        catch (err) {
+            report.skipped.push({ path, reason: `rename failed: ${err.message}` });
+        }
+    }
+    return report;
+}
+/**
+ * Decide whether a single progress doc has aged out. Exported for the
+ * spec — kept pure so tests can probe edges (running entries never
+ * expire, completed entries before TTL stay, etc).
+ */
+export function isExpired(progress, nowEpochMs, ttlMs = COMPLETION_TTL_MS) {
+    if (progress.status === 'running')
+        return false;
+    const lastTs = Date.parse(progress.lastUpdate);
+    if (Number.isNaN(lastTs))
+        return false;
+    return nowEpochMs - lastTs >= ttlMs;
+}
+// 2026-05-27 Claude review followup: `pruneArchive` was removed.
+// Rationale (P1 in the Claude review batch on PR #512):
+//   - hardcoded `/tmp` path was POSIX-only (Windows would break),
+//   - `renameSync` across volumes throws EXDEV,
+//   - collision risk between concurrent hosts/sessions sharing `/tmp`,
+//   - and crucially, the function had ZERO call-sites in the codebase.
+// Deleting it is strictly safer than leaving a broken-on-Windows
+// dead helper that future refactors might accidentally wire up.
+// If/when an archive GC is needed, the right shape is:
+//   - `os.tmpdir()` (not '/tmp'),
+//   - `rmSync(path, {force: true})` for cross-volume safe delete,
+//   - exposed as `pugi jobs gc` so we have an explicit caller.
+function safeStamp(iso) {
+    // Build a filename-safe slug — strip colons/dots which are friendly
+    // в ISO timestamps but hostile к some filesystems.
+    return iso.replace(/[:.]/g, '-');
+}
+//# sourceMappingURL=cleanup.js.map

package/dist/core/agent-progress/schema.js

@@ -0,0 +1,144 @@
+/**
+ * Agent progress JSON schema — α7 live-progress sprint (2026-05-27).
+ *
+ * Long-running agents (spawned externally OR via `pugi /agent`) emit a
+ * single JSON document per agent to `~/.pugi/agent-progress/<id>.json`.
+ * `pugi jobs --watch` tails the directory via chokidar and re-renders
+ * an Ink TUI that mirrors the Claude Code `/compact` visual pattern
+ * (header with elapsed + token counter, unicode progress bar, milestone
+ * list with done/active/pending status icons).
+ *
+ * Schema is intentionally optimistic — every numeric field is clamped
+ * by the writer/reader so a malformed document degrades to a partial
+ * card instead of crashing the watcher. The `pendingCount` /
+ * `completedCount` fields are pre-computed by the agent for the
+ * "… +N pending, M completed" footer; the renderer never re-counts
+ * (the agent may have collapsed milestone history to save bytes).
+ */
+/**
+ * Validate an unknown payload as an `AgentProgress` document. Returns
+ * the typed value on success and a string error otherwise. We deliberately
+ * keep this hand-rolled (no zod) — every field is checked exactly once,
+ * the error message is human-readable, and zero runtime deps.
+ */
+export function validateAgentProgress(value) {
+    if (typeof value !== 'object' || value === null) {
+        return { ok: false, error: 'progress payload must be a JSON object' };
+    }
+    const raw = value;
+    const requiredString = (field) => {
+        const v = raw[field];
+        return typeof v === 'string' && v.length > 0 ? v : null;
+    };
+    const agentId = requiredString('agentId');
+    if (!agentId)
+        return { ok: false, error: 'agentId required (non-empty string)' };
+    if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+        return { ok: false, error: 'agentId must match [a-zA-Z0-9_-]+ (filename-safe)' };
+    }
+    const agentType = requiredString('agentType');
+    if (!agentType)
+        return { ok: false, error: 'agentType required (non-empty string)' };
+    const task = requiredString('task');
+    if (!task)
+        return { ok: false, error: 'task required (non-empty string)' };
+    const startedAt = requiredString('startedAt');
+    if (!startedAt)
+        return { ok: false, error: 'startedAt required (ISO string)' };
+    if (Number.isNaN(Date.parse(startedAt))) {
+        return { ok: false, error: 'startedAt must be a parseable ISO timestamp' };
+    }
+    const lastUpdate = requiredString('lastUpdate');
+    if (!lastUpdate)
+        return { ok: false, error: 'lastUpdate required (ISO string)' };
+    if (Number.isNaN(Date.parse(lastUpdate))) {
+        return { ok: false, error: 'lastUpdate must be a parseable ISO timestamp' };
+    }
+    const elapsedMs = raw.elapsedMs;
+    if (typeof elapsedMs !== 'number' || !Number.isFinite(elapsedMs) || elapsedMs < 0) {
+        return { ok: false, error: 'elapsedMs required (non-negative number)' };
+    }
+    const percentComplete = raw.percentComplete;
+    if (typeof percentComplete !== 'number' ||
+        !Number.isFinite(percentComplete)) {
+        return { ok: false, error: 'percentComplete required (number 0..100)' };
+    }
+    const clampedPercent = Math.max(0, Math.min(100, percentComplete));
+    const status = raw.status;
+    if (status !== 'running' && status !== 'completed' && status !== 'failed') {
+        return { ok: false, error: 'status must be running | completed | failed' };
+    }
+    const currentStep = raw.currentStep;
+    if (typeof currentStep !== 'number' || currentStep < 0) {
+        return { ok: false, error: 'currentStep required (non-negative number)' };
+    }
+    const totalSteps = raw.totalSteps;
+    if (typeof totalSteps !== 'number' || totalSteps < 0) {
+        return { ok: false, error: 'totalSteps required (non-negative number)' };
+    }
+    const stepDescription = typeof raw.stepDescription === 'string'
+        ? raw.stepDescription
+        : '';
+    const milestonesRaw = raw.milestones;
+    if (!Array.isArray(milestonesRaw)) {
+        return { ok: false, error: 'milestones required (array, may be empty)' };
+    }
+    const milestones = [];
+    for (let i = 0; i < milestonesRaw.length; i += 1) {
+        const m = milestonesRaw[i];
+        if (typeof m !== 'object' || m === null) {
+            return { ok: false, error: `milestones[${i}] must be an object` };
+        }
+        const mr = m;
+        const label = typeof mr.label === 'string' ? mr.label : '';
+        if (!label) {
+            return { ok: false, error: `milestones[${i}].label required` };
+        }
+        const mStatus = mr.status;
+        if (mStatus !== 'done' && mStatus !== 'active' && mStatus !== 'pending') {
+            return {
+                ok: false,
+                error: `milestones[${i}].status must be done | active | pending`,
+            };
+        }
+        const ts = typeof mr.ts === 'string' ? mr.ts : undefined;
+        milestones.push({ label, status: mStatus, ts });
+    }
+    const tokensUsed = typeof raw.tokensUsed === 'number' && Number.isFinite(raw.tokensUsed)
+        ? Math.max(0, raw.tokensUsed)
+        : undefined;
+    const pendingCount = typeof raw.pendingCount === 'number' && Number.isFinite(raw.pendingCount)
+        ? Math.max(0, Math.floor(raw.pendingCount))
+        : undefined;
+    const completedCount = typeof raw.completedCount === 'number' && Number.isFinite(raw.completedCount)
+        ? Math.max(0, Math.floor(raw.completedCount))
+        : undefined;
+    return {
+        ok: true,
+        value: {
+            agentId,
+            agentType,
+            task,
+            startedAt,
+            lastUpdate,
+            elapsedMs,
+            tokensUsed,
+            percentComplete: clampedPercent,
+            status,
+            currentStep,
+            totalSteps,
+            stepDescription,
+            milestones,
+            pendingCount,
+            completedCount,
+        },
+    };
+}
+/**
+ * Default directory the writer and watcher share. Lives under the
+ * project workspace by convention so worktree-isolated agents can emit
+ * progress without crossing tenant boundaries. Operators can override
+ * via `PUGI_AGENT_PROGRESS_DIR` env var.
+ */
+export const DEFAULT_AGENT_PROGRESS_DIRNAME = '.pugi/agent-progress';
+//# sourceMappingURL=schema.js.map

package/dist/core/agent-progress/writer.js

@@ -0,0 +1,101 @@
+/**
+ * Agent progress writer — atomic file ops so the chokidar watcher
+ * never reads a half-written JSON document.
+ *
+ * Pattern (POSIX-portable):
+ *   1. Build the canonical JSON body.
+ *   2. Write to `<dir>/<agentId>.json.tmp-<pid>-<seq>`.
+ *   3. Rename (atomic on the same filesystem) to `<dir>/<agentId>.json`.
+ *   4. Cleanup is a no-op on success; on failure the caller bubbles the
+ *      error and the .tmp file is removed best-effort.
+ *
+ * The auto-cleanup of completed entries lives in `cleanup.ts` (commit 4);
+ * the writer here is the minimal surface the agent prompt boilerplate
+ * needs to copy + paste.
+ */
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { DEFAULT_AGENT_PROGRESS_DIRNAME, validateAgentProgress, } from './schema.js';
+let writeSequence = 0;
+/**
+ * Resolve the effective progress directory. Public so the watcher can
+ * share the same resolution rules without duplicating env-var logic.
+ */
+export function resolveProgressDir(override) {
+    const candidate = override
+        ?? process.env.PUGI_AGENT_PROGRESS_DIR
+        ?? join(process.cwd(), DEFAULT_AGENT_PROGRESS_DIRNAME);
+    if (candidate.startsWith('~/')) {
+        return join(homedir(), candidate.slice(2));
+    }
+    return resolve(candidate);
+}
+/**
+ * Write a progress document atomically.
+ *
+ * Throws on validation failure so the caller is loud about a schema
+ * regression. File-system errors propagate untouched.
+ */
+export function writeProgress(progress, options = {}) {
+    const validation = validateAgentProgress(progress);
+    if (!validation.ok) {
+        throw new Error(`invalid agent-progress payload: ${validation.error}`);
+    }
+    const dir = resolveProgressDir(options.dir);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const finalPath = join(dir, `${progress.agentId}.json`);
+    writeSequence += 1;
+    const tmpPath = `${finalPath}.tmp-${process.pid}-${writeSequence}`;
+    const body = `${JSON.stringify(progress, null, 2)}\n`;
+    try {
+        // mkdirSync above may have created `dir`, but a parallel agent could
+        // delete it between the existsSync and writeFile — ensure the parent
+        // of the tmp file exists right before the write.
+        const parent = dirname(tmpPath);
+        if (!existsSync(parent)) {
+            mkdirSync(parent, { recursive: true });
+        }
+        writeFileSync(tmpPath, body, 'utf8');
+        renameSync(tmpPath, finalPath);
+    }
+    catch (err) {
+        try {
+            rmSync(tmpPath, { force: true });
+        }
+        catch {
+            // best-effort cleanup; surface the original error
+        }
+        throw err;
+    }
+    return { path: finalPath };
+}
+/**
+ * Build a fresh progress document with sensible defaults. Mostly a
+ * convenience for tests + the agent prompt boilerplate — the writer
+ * does NOT call this implicitly because agents have richer context
+ * about their own milestone state.
+ */
+export function makeInitialProgress(input) {
+    const now = input.now ?? Date.now;
+    const iso = new Date(now()).toISOString();
+    return {
+        agentId: input.agentId,
+        agentType: input.agentType,
+        task: input.task,
+        startedAt: iso,
+        lastUpdate: iso,
+        elapsedMs: 0,
+        percentComplete: 0,
+        status: 'running',
+        currentStep: 0,
+        totalSteps: Math.max(0, Math.floor(input.totalSteps)),
+        stepDescription: '',
+        milestones: input.milestones ?? [],
+        pendingCount: input.milestones?.filter((m) => m.status === 'pending').length,
+        completedCount: input.milestones?.filter((m) => m.status === 'done').length,
+    };
+}
+//# sourceMappingURL=writer.js.map

package/dist/core/engine/tool-bridge.js

@@ -433,13 +433,19 @@ function parseArgs(raw) {
         throw new Error(`invalid JSON in tool arguments: ${error.message}`);
     }
 }
-function requireString(obj, key) {
-    const v = obj[key];
-    if (typeof v !== 'string') {
-        throw new Error(`tool argument "${key}" must be a string`);
+function requireString(obj, key, aliases = []) {
+    // 2026-05-27 CEO live smoke: model passed `file: "index.html"` to write tool
+    // but spec required `path:`. Tool rejected → silent no-op → file не созданы.
+    // Accept common aliases so models trained на various tool schemas just work.
+    const tryKeys = [key, ...aliases];
+    for (const k of tryKeys) {
+        const v = obj[k];
+        if (typeof v === 'string')
+            return v;
     }
-    return v;
+    throw new Error(`tool argument "${key}" must be a string`);
 }
+const PATH_ALIASES = ['file', 'filename', 'filepath', 'file_path'];
 export function buildExecutor(input) {
     const { kind, ctx, hooks, sessionId, askUserBridge, interactive, allowFetch, allowSearch, agentDispatch, mcpRegistry } = input;
     const mcpPrompt = input.mcpPrompt ?? defaultNonInteractiveMcpPrompt;
@@ -637,7 +643,7 @@ function extractToolPath(name, argsRaw) {
 function dispatchTool(name, args, ctx) {
     switch (name) {
         case 'read': {
-            const { path } = { path: requireString(args, 'path') };
+            const { path } = { path: requireString(args, 'path', PATH_ALIASES) };
             const content = readTool(ctx, path);
             // Cap the content surfaced back to the model so a 10MB file
             // does not blow the context window. The model sees the head
@@ -650,7 +656,7 @@ function dispatchTool(name, args, ctx) {
         }
         case 'write': {
             const wargs = {
-                path: requireString(args, 'path'),
+                path: requireString(args, 'path', PATH_ALIASES),
                 content: requireString(args, 'content'),
             };
             writeTool(ctx, wargs.path, wargs.content);
@@ -658,7 +664,7 @@ function dispatchTool(name, args, ctx) {
         }
         case 'edit': {
             const eargs = {
-                path: requireString(args, 'path'),
+                path: requireString(args, 'path', PATH_ALIASES),
                 oldString: requireString(args, 'oldString'),
                 newString: requireString(args, 'newString'),
             };

package/dist/core/repl/session.js

@@ -2604,7 +2604,7 @@ export function synthesiseToolCall(input) {
     // Pattern: ToolName(args) optionally suffixed with a result hint.
     // We allow the canonical Claude Code casing AND the snake_case
     // alias `web_fetch` so the synthesiser matches what personas write.
-    const match = /^(Read|Edit|Bash|Grep|Glob|WebFetch|web_fetch)\s*\(\s*([^)]*)\s*\)\s*(.*)$/i
+    const match = /^(Read|Write|Edit|Bash|Grep|Glob|WebFetch|web_fetch)\s*\(\s*([^)]*)\s*\)\s*(.*)$/i
         .exec(detail);
     if (!match)
         return null;
@@ -2628,6 +2628,8 @@ function normaliseToolName(raw) {
         return 'web_fetch';
     if (lower === 'read')
         return 'read';
+    if (lower === 'write')
+        return 'write';
     if (lower === 'edit')
         return 'edit';
     if (lower === 'bash')
@@ -2853,7 +2855,22 @@ export function stripPersonaPrefixEcho(personaSlug, text) {
     // Escape regex specials in the display name even though THE_TEN
     // names are alpha-only today (forward-defense).
     const escaped = display.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Match `<DisplayName>` (case-insensitive) followed by EITHER:
+    //   - an end-of-string, OR
+    //   - a separator (whitespace / comma / colon / dash / period+space).
+    // The `i` flag is needed so a model writing "PUGI:" or "pugi," still
+    // strips. After this match the post-fix `noSepUppercaseRe` handles
+    // the "PugiПринял" / "PugiHello" no-separator emission pattern
+    // (CEO red-alert 2026-05-27) using a SEPARATE regex without the `i`
+    // flag so the lookahead is case-strict (Pugineous must NOT strip).
     const re = new RegExp(`^${escaped}(?:[\\s,:;\\-—–]+|$)`, 'i');
+    // No-separator case-strict matcher. Display name in either of its
+    // canonical casings ("Pugi" / "PUGI") immediately followed by an
+    // uppercase Cyrillic or Latin letter. The strip is intentionally
+    // narrower than the case-insensitive `re` above because a lowercase
+    // continuation ("Pugineous") is a single word, not a display-name
+    // echo - we must not eat real content.
+    const noSepUppercaseRe = new RegExp(`^(?:${escaped}|${escaped.toUpperCase()})(?=[А-ЯЁA-Z])`);
     // Loop the strip so cascading echoes ("Pugi Pugi Pugi, координатор ...")
     // collapse to a single name. The model occasionally emits the display
     // name two or three times back-to-back when the pane prefix also
@@ -2865,10 +2882,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;
 }

package/dist/runtime/cli.js

@@ -29,6 +29,7 @@ import { runDeployCommand } from '../commands/deploy.js';
 import { runJobsCommand } from '../commands/jobs.js';
 import { runConfigCommand } from './commands/config.js';
 import { runPrivacyCommand } from './commands/privacy.js';
+import { runReport } from './commands/report.js';
 import { runUndoCommand } from './commands/undo.js';
 import { runBudgetCommand } from './commands/budget.js';
 import { runSkillsCommand } from './commands/skills.js';
@@ -90,6 +91,10 @@ const handlers = {
     plan: runEngineTask('plan'),
     'plan-review': dispatchPlanReview,
     privacy: dispatchPrivacy,
+    // PAVF-7 (2026-05-27): `pugi report --from-error` captures the
+    // most-recent failed session as a redacted bundle so operators can
+    // file clean bug reports without manual log-grepping.
+    report: dispatchReport,
     review,
     resume,
     roster: dispatchRoster,
@@ -271,6 +276,25 @@ async function dispatchPrivacy(args, flags, _session) {
         writeOutput: (payload, text) => writeOutput(flags, payload, text),
     });
 }
+/**
+ * PAVF-7 (2026-05-27): `pugi report --from-error` — bundle the most-
+ * recent failed session into a redacted local report so operators can
+ * file clean bug tickets without manual log-grepping. v1 is local-only
+ * (no auto-upload — see commands/report.ts header for the rationale).
+ */
+async function dispatchReport(args, flags, _session) {
+    const rc = runReport(args, {
+        cwd: process.cwd(),
+        json: flags.json,
+        emit: (line) => {
+            if (!flags.json)
+                process.stdout.write(line);
+        },
+        writeOutput: (payload, text) => writeOutput(flags, payload, text),
+    });
+    if (rc !== 0)
+        process.exitCode = rc;
+}
 /**
  * `pugi roster` - α7.5 Phase 1.
  *
@@ -973,6 +997,16 @@ const COMMAND_HELP_BODIES = {
         'event log, settings), permission mode, and the capability matrix per',
         'engine adapter. Safe to run anywhere; no network calls.',
     ],
+    report: [
+        'pugi report — capture a bug report from the most-recent session.',
+        '',
+        '  --from-error            Bundle the most-recent failed session as a',
+        '                          redacted local report (default + only mode in v1).',
+        '',
+        'Output: writes .pugi/reports/<timestamp>-<session-id>/{report.json, report.md}.',
+        'Secrets (bearer tokens, JWTs, named env values) are stripped before disk write.',
+        'Auto-upload to api.pugi.io planned for a follow-up; v1 keeps everything local.',
+    ],
     ask: [
         'pugi ask "<question>" — surface a yes/no question modal locally.',
         '',
@@ -2140,12 +2174,45 @@ async function performTripleProviderReview(root, session, flags, prompt) {
             `Refusing to submit an empty diff for review.`);
     }
     const resolvedCommit = safeGit(root, ['rev-parse', '--short', commitRef]).trim() || commitRef;
-    const mergeBase = safeGit(root, ['merge-base', baseRef, commitRef]).trim() || '';
+    // merge-base is intentionally a PROBE: an empty result is a valid
+    // signal (orphan branch, shallow clone, moved tag) that the dispatch
+    // path handles by falling back к range-notation. Use the legacy
+    // `safeGit` (probe semantics) explicitly rather than the strict
+    // variant.
+    const mergeBase = safeGitProbe(root, ['merge-base', baseRef, commitRef]).trim() || '';
+    // 2026-05-27 (Claude review followup #489): when merge-base returns empty
+    // (orphan branch, shallow clone, moved tag), we MUST NOT pass the
+    // `<range> <commitRef>` two-arg form to `git diff` — that combo is
+    // invalid syntax, git exits 129, `safeGit` swallows the error, and the
+    // diff payload ships empty. An empty diff is then classified as
+    // `'code'` server-side, dispatched to reviewers who emit a trivial
+    // `VERDICT: PASS` over zero lines — a SILENT GREEN REVIEW on a commit
+    // nobody actually examined. Branch on `mergeBase` так что:
+    //   - mergeBase present  → `git diff <mergeBase> <commitRef> --`
+    //     (both endpoints explicit, only-uncommitted-against-base ignored
+    //     because commitRef is a SHA, not HEAD).
+    //   - mergeBase empty    → `git diff <baseRef>..<commitRef> --`
+    //     (range form encodes both endpoints; do NOT append commitRef
+    //     again or git rejects the args).
     const diffRange = mergeBase || `${baseRef}..${commitRef}`;
-    const diffArgs = ['diff', diffRange, commitRef, '--', '.', ...PROTECTED_DIFF_EXCLUDES];
-    const diffStatArgs = ['diff', '--shortstat', diffRange, commitRef, '--', '.', ...PROTECTED_DIFF_EXCLUDES];
-    const diffPatch = safeGit(root, diffArgs);
-    const diffStats = parseDiffStats(safeGit(root, diffStatArgs));
+    const diffArgs = mergeBase
+        ? ['diff', mergeBase, commitRef, '--', '.', ...PROTECTED_DIFF_EXCLUDES]
+        : ['diff', diffRange, '--', '.', ...PROTECTED_DIFF_EXCLUDES];
+    const diffStatArgs = mergeBase
+        ? ['diff', '--shortstat', mergeBase, commitRef, '--', '.', ...PROTECTED_DIFF_EXCLUDES]
+        : ['diff', '--shortstat', diffRange, '--', '.', ...PROTECTED_DIFF_EXCLUDES];
+    // Use the strict variant — a non-empty diffPatch is load-bearing for
+    // the review gate. If git fails for ANY reason (bad ref, ENOBUFS, FS
+    // permission), we'd rather surface a hard error than ship a green
+    // review on nothing. The `--shortstat` companion uses the same
+    // helper so the throw is symmetric.
+    const diffPatch = safeGitRequired(root, diffArgs, 'triple-providers diff');
+    const diffStats = parseDiffStats(safeGitRequired(root, diffStatArgs, 'triple-providers diff --shortstat'));
+    if (diffPatch.trim() === '') {
+        throw new Error(`pugi review --triple: empty diff between '${baseRef}' and '${commitRef}'. ` +
+            `Refusing to dispatch a review for zero changes — check the refs ` +
+            `or commit your changes before running.`);
+    }
     const requestBody = pugiTripleReviewRequestSchema.parse({
         schema: 1,
         workspace: {
@@ -5039,7 +5106,31 @@ function fileBytes(path) {
         return 0;
     }
 }
-function safeGit(root, args) {
+/**
+ * Git invocation helpers — probe vs required semantics.
+ *
+ * 2026-05-27 (Claude review followup #489): the historical `safeGit`
+ * collapsed BOTH "tell me the branch name if you can" probes AND
+ * "give me the diff or fail" hard requirements into a single helper
+ * that swallowed every error as an empty string. That's the correct
+ * shape for the probe case (branch / status / dirty flag — empty
+ * result is a valid signal) but catastrophically wrong for the diff
+ * case (empty result === false PASS on a commit nobody reviewed).
+ *
+ * The split:
+ *   - `safeGitProbe`  — best-effort. Returns '' on any error. Use for
+ *     branch name lookups, status probes, opt-in dirty detection.
+ *   - `safeGitRequired` — throws on non-zero exit / ENOBUFS / bad ref.
+ *     Use for diff, merge-base resolution, anything whose empty
+ *     output would silently corrupt downstream behaviour.
+ *
+ * Legacy `safeGit` is kept as a deprecated alias of `safeGitProbe`
+ * so existing call-sites (branch detection, status, etc.) keep their
+ * tolerant semantics until they are individually migrated. Diff /
+ * merge-base / rev-parse-verify call-sites are migrated к
+ * `safeGitRequired` in this same patch.
+ */
+export function safeGitProbe(root, args) {
     try {
         return execFileSync('git', args, {
             cwd: root,
@@ -5057,6 +5148,38 @@ function safeGit(root, args) {
         return '';
     }
 }
+/**
+ * Strict variant — throws on non-zero exit, ENOBUFS, or any git-side
+ * failure. The thrown error carries the operation context so the
+ * caller (triple-review dispatch, etc.) can fail loud rather than
+ * ship an empty diff to a remote reviewer.
+ */
+export function safeGitRequired(root, args, context) {
+    try {
+        return execFileSync('git', args, {
+            cwd: root,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            maxBuffer: 64 * 1024 * 1024,
+        });
+    }
+    catch (err) {
+        const cause = err instanceof Error ? err.message : String(err);
+        throw new Error(`git ${args.slice(0, 2).join(' ')} failed (${context}): ${cause}. ` +
+            `Refusing to proceed — empty git output here would corrupt downstream behaviour.`);
+    }
+}
+/**
+ * Deprecated alias preserved for diff / status / branch probes that
+ * legitimately want a tolerant empty-string-on-error shape. New call
+ * sites should pick `safeGitProbe` or `safeGitRequired` explicitly.
+ *
+ * @deprecated 2026-05-27 — prefer `safeGitProbe` (tolerant) or
+ * `safeGitRequired` (strict, throws).
+ */
+function safeGit(root, args) {
+    return safeGitProbe(root, args);
+}
 /**
  * Glob patterns excluded from triple-review `diffPatch` before egress.
  *

package/dist/runtime/version.js

@@ -44,7 +44,7 @@ export function sanitizeSemver(raw) {
  * during import). When bumping the CLI version BOTH literals must be
  * updated; the release smoke-test (`pack:smoke`) verifies they agree.
  */
-export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.16');
+export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.17');
 /**
  * Outbound: the CLI's installed semver. Read at request time by
  * `version-interceptor.ts` and injected on every `fetch` call.

package/dist/tools/file-tools.js

@@ -1,3 +1,31 @@
+/**
+ * file-tools - Pugi CLI file/bash/glob/grep tool surface.
+ *
+ * Workspace-binding contract (CEO red-alert 2026-05-27 follow-up):
+ *
+ *   Every tool dispatch path threads `ctx.root` from the operator's
+ *   `process.cwd()` through `EngineTask.workspaceRoot` ->
+ *   `native-pugi.run()` -> `toolCtx.root` -> here. Tools call
+ *   `resolveWorkspacePath(ctx.root, path)` for every on-disk operation
+ *   so a dispatched specialist (e.g. Hiroshi writing tic-tac-toe HTML)
+ *   produces files in the OPERATOR'S cwd, never in a server-side temp
+ *   space. The path-security gate refuses traversal (`../etc/passwd`,
+ *   URL-encoded variants, symlink escapes at the target).
+ *
+ *   Wiring chain:
+ *     1. runtime/cli.ts:    workspaceRoot = process.cwd()
+ *     2. EngineTask.workspaceRoot threads through to native-pugi.run().
+ *     3. native-pugi:       const root = task.workspaceRoot
+ *     4. tool-bridge:       passes ctx.root to file-tools / bash.
+ *     5. file-tools:        resolveWorkspacePath(ctx.root, path).
+ *
+ *   The contract is locked by `test/tools-write-to-workspace.spec.ts`
+ *   (6 cases covering relative + nested + absolute paths + traversal
+ *   refusal). If any layer of the chain regressed silently, dispatched
+ *   files would land in `/tmp` instead of the operator's repo, which
+ *   is the same failure surface as the menu-mode anti-pattern the
+ *   sibling commits close.
+ */
 import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, relative } from 'node:path';

package/dist/tui/agent-progress-card.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+/** Width of the progress bar in display cells. Tuned to fit comfortably
+ *  inside an 80-col terminal alongside the percent label. */
+export const PROGRESS_BAR_WIDTH = 24;
+/** Max milestone rows the card renders before collapsing to the footer
+ *  summary. Matches the CC `/compact` cutoff. */
+export const MAX_VISIBLE_MILESTONES = 5;
+const STATUS_GLYPH = {
+    done: '◼',
+    active: '▸',
+    pending: '◻',
+};
+const STATUS_COLOR = {
+    done: 'green',
+    active: 'yellow',
+    pending: 'gray',
+};
+const HEADER_DOT_COLOR = {
+    running: 'cyan',
+    completed: 'green',
+    failed: 'red',
+};
+/**
+ * Build the unicode progress bar. Exported для тесты — guarantees the
+ * filled/empty counts match the percent under all rounding edges.
+ */
+export function renderProgressBarCells(percent, width = PROGRESS_BAR_WIDTH) {
+    const safePercent = Math.max(0, Math.min(100, percent));
+    const cells = Math.round((safePercent / 100) * width);
+    const clamped = Math.max(0, Math.min(width, cells));
+    return {
+        filled: '▰'.repeat(clamped),
+        empty: '▱'.repeat(width - clamped),
+        cells: clamped,
+    };
+}
+/**
+ * Format milliseconds as the CC-style `Hh Mm Ss` / `Mm Ss` / `Ss` label.
+ * Mirrors the rule used by status-bar elapsed slot.
+ */
+export function formatElapsed(ms) {
+    const total = Math.max(0, Math.floor(ms / 1000));
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = total % 60;
+    if (h > 0)
+        return `${h}h ${m}m ${s}s`;
+    if (m > 0)
+        return `${m}m ${s}s`;
+    return `${s}s`;
+}
+/**
+ * Format a raw token count as `21.7k` / `3.4M` / `812`. Mirrors the
+ * formatter in `core/repl/model-pricing.ts` so both surfaces stay
+ * visually consistent without coupling.
+ */
+export function formatTokenCount(n) {
+    if (n === undefined)
+        return undefined;
+    if (n < 1_000)
+        return `${n}`;
+    if (n < 1_000_000) {
+        const k = n / 1_000;
+        return `${k >= 10 ? k.toFixed(1).replace(/\.0$/, '') : k.toFixed(1)}k`;
+    }
+    const m = n / 1_000_000;
+    return `${m >= 10 ? m.toFixed(1).replace(/\.0$/, '') : m.toFixed(1)}M`;
+}
+/**
+ * Compute the "… +N pending, M completed" footer counts. When the
+ * agent supplied rollups they win; otherwise we derive from the
+ * milestone array.
+ */
+export function computeFooterCounts(milestones, visibleCount, rollup) {
+    const pending = rollup.pendingCount
+        ?? milestones.filter((m) => m.status === 'pending').length;
+    const completed = rollup.completedCount
+        ?? milestones.filter((m) => m.status === 'done').length;
+    const hidden = Math.max(0, milestones.length - visibleCount);
+    return { pending, completed, hidden };
+}
+function MilestoneRow({ milestone }) {
+    const glyph = STATUS_GLYPH[milestone.status];
+    const color = STATUS_COLOR[milestone.status];
+    // Truncate to 64 chars so a verbose label can't wrap and break the
+    // grid layout in the watcher.
+    const label = milestone.label.length > 64
+        ? `${milestone.label.slice(0, 63)}…`
+        : milestone.label;
+    return (_jsxs(Box, { children: [_jsx(Text, { children: '   ' }), _jsx(Text, { color: color, children: glyph }), _jsx(Text, { children: " " }), _jsx(Text, { color: color === 'gray' ? 'gray' : undefined, dimColor: milestone.status === 'pending', children: label })] }));
+}
+export function AgentProgressCard({ progress, nowEpochMs, }) {
+    // Re-derive elapsed from the wall clock when the parent supplied it;
+    // this is what makes the card tick once a second without the writer
+    // re-emitting JSON every tick.
+    const elapsed = nowEpochMs !== undefined
+        ? Math.max(progress.elapsedMs, nowEpochMs - Date.parse(progress.startedAt))
+        : progress.elapsedMs;
+    const bar = renderProgressBarCells(progress.percentComplete);
+    const percentLabel = `${Math.round(Math.max(0, Math.min(100, progress.percentComplete)))}%`;
+    const tokensLabel = formatTokenCount(progress.tokensUsed);
+    const dotColor = HEADER_DOT_COLOR[progress.status];
+    const visibleMilestones = progress.milestones.slice(0, MAX_VISIBLE_MILESTONES);
+    const footer = computeFooterCounts(progress.milestones, visibleMilestones.length, { pendingCount: progress.pendingCount, completedCount: progress.completedCount });
+    // CC compact pattern: header has a leading `· ` glyph + the task label.
+    // We append `…` only while running (matches CC's "Compacting…" verb form).
+    const headerVerb = progress.status === 'running' ? '…' : '';
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: dotColor, children: '· ' }), _jsx(Text, { bold: true, children: progress.agentType }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [progress.task, headerVerb] }), _jsxs(Text, { dimColor: true, children: [' (', formatElapsed(elapsed), tokensLabel ? ` · ↑ ${tokensLabel} tokens` : '', ')'] })] }), _jsxs(Box, { children: [_jsx(Text, { children: '  ' }), _jsx(Text, { color: "cyan", children: bar.filled }), _jsx(Text, { dimColor: true, children: bar.empty }), _jsxs(Text, { children: [' ', percentLabel] })] }), progress.stepDescription ? (_jsxs(Box, { children: [_jsx(Text, { children: '  ' }), _jsxs(Text, { dimColor: true, children: ["step ", progress.currentStep, "/", progress.totalSteps, ": ", progress.stepDescription] })] })) : null, visibleMilestones.length > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { children: '  ' }), _jsx(Text, { dimColor: true, children: "\u23BF" })] }), visibleMilestones.map((m, i) => (_jsx(MilestoneRow, { milestone: m }, `${m.label}-${i}`))), footer.hidden > 0 ? (_jsxs(Box, { children: [_jsx(Text, { children: '     ' }), _jsxs(Text, { dimColor: true, children: ["\u2026 +", footer.pending, " pending, ", footer.completed, " completed"] })] })) : null] })) : null] }));
+}
+//# sourceMappingURL=agent-progress-card.js.map

package/dist/tui/tool-stream-pane.js

@@ -64,6 +64,13 @@ function toolDisplayName(tool) {
     switch (tool) {
         case 'read':
             return 'Read';
+        case 'write':
+            // 2026-05-27 — Write is the most operator-visible tool for the
+            // codegen-dispatch surface (Hiroshi writing index.html / style.css
+            // / script.js for a tic-tac-toe brief). Add the display name so
+            // the tool stream pane renders ✓ Write(index.html) instead of an
+            // unlabeled placeholder. Mirrors the Claude Code Write rendering.
+            return 'Write';
         case 'edit':
             return 'Edit';
         case 'bash':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-beta.16",
+  "version": "0.1.0-beta.17",
   "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -54,7 +54,7 @@
     "undici": "^8.3.0",
     "zod": "^3.23.0",
     "@pugi/personas": "0.1.2",
-    "@pugi/sdk": "0.1.0-beta.16"
+    "@pugi/sdk": "0.1.0-beta.17"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",