@pugi/cli 0.1.0-beta.98 → 1.0.0-alpha.1

package/dist/runtime/commands/cost.js

@@ -1,199 +0,0 @@
-/**
- * `pugi cost` / `pugi usage` command handler — L19 sprint .
- *
- * Shared backend for three operator surfaces:
- *
- *  - `pugi cost`                 current session (default)
- *  - `pugi cost --all-sessions`  30-day rolling aggregate
- *  - `pugi cost --reset --yes`   wipe current session counter (operator-only)
- *  - `pugi usage`                alias of `pugi cost`
- *  - `/cost` REPL slash          same handler, in-REPL output
- *  - `/usage` REPL slash         same handler, alias of /cost
- *
- * Why a separate command from the existing `pugi budget`:
- *
- *  - `pugi budget` walks `.pugi/events.jsonl` and bills against the
- *    event-log heuristic (per-command / per-persona attribution). It
- *    is the right surface for "what did this brief / this persona
- *    spend?". It does not break down by model and it does not persist
- *    a cross-session aggregate.
- *
- *  - `pugi cost` (this command) reads the persisted `.pugi/cost.json`
- *    written by the `CostTracker`. It is the right surface for "what
- *    did this model spend?" and "what did I spend across the last 30
- *    days?". Token + USD figures are sourced from the rate card, which
- *    distinguishes hosted Claude (per-token billed) from open-weight
- *    Qwen / Kimi / DeepSeek (infra cost only).
- *
- * Both commands intentionally coexist — they answer adjacent but distinct
- * operator questions. The L19 spec calls out `/cost` and `/usage` by
- * name; the budget surface is unaffected.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { createCostTracker, totalTokens, totalUsd, } from '../../core/cost/tracker.js';
-import { buildCostView, renderCostTableText } from '../../tui/cost-table.js';
-/**
- * Parsed flag bundle. Exported for the test surface; production callers
- * never touch it directly — `runCostCommand` owns parsing.
- */
-export function parseCostFlags(args) {
-    const flags = {
-        allSessions: false,
-        reset: false,
-        yes: false,
-        json: false,
-        windowDays: 30,
-    };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i] ?? '';
-        if (arg === '--all-sessions')
-            flags.allSessions = true;
-        else if (arg === '--reset')
-            flags.reset = true;
-        else if (arg === '--yes' || arg === '-y')
-            flags.yes = true;
-        else if (arg === '--json')
-            flags.json = true;
-        else if (arg.startsWith('--window=')) {
-            const raw = Number.parseInt(arg.slice('--window='.length), 10);
-            if (Number.isFinite(raw) && raw > 0 && raw <= 365)
-                flags.windowDays = raw;
-        }
-    }
-    return flags;
-}
-export async function runCostCommand(args, ctx) {
-    const flags = parseCostFlags(args);
-    const sessionId = ctx.sessionId ?? deriveSessionIdFromEvents(ctx.workspaceRoot) ?? 'no-session';
-    const tracker = createCostTracker({
-        workspaceRoot: ctx.workspaceRoot,
-        sessionIdProvider: () => sessionId,
-        now: ctx.now,
-    });
-    // --reset: clear the current session counter. Operator-only — refuses
-    // without `--yes` so a typo / shell completion never wipes the meter.
-    if (flags.reset) {
-        if (!flags.yes) {
-            ctx.writeOutput({ command: 'cost', status: 'reset_pending_confirmation' }, 'pugi cost --reset clears the current session counter. Re-run with --yes to confirm.');
-            return;
-        }
-        const wiped = tracker.resetCurrent();
-        const payload = {
-            command: 'cost',
-            status: 'reset_ok',
-            wiped: wiped ?? null,
-        };
-        ctx.writeOutput(payload, wiped
-            ? `Cleared session ${wiped.sessionId} (${Object.keys(wiped.models).length} model(s) wiped).`
-            : 'No current session counter to clear.');
-        return;
-    }
-    const aggregate = flags.allSessions ? tracker.aggregateWithin(flags.windowDays) : (tracker.current() ?? emptyAggregate(sessionId, ctx.now ?? Date.now));
-    const tier = ctx.resolveTier ? await safeResolveTier(ctx.resolveTier) : null;
-    const heading = flags.allSessions
-        ? `Pugi cost / usage — aggregate (last ${flags.windowDays} days)`
-        : buildSessionHeading(aggregate, ctx.now ?? Date.now);
-    const view = buildCostView({ aggregate, heading, tier: tier ?? undefined });
-    const text = renderCostTableText(view);
-    ctx.writeOutput({
-        command: flags.allSessions ? 'cost.aggregate' : 'cost.session',
-        status: 'ok',
-        window: flags.allSessions ? `${flags.windowDays}d` : 'current',
-        tokens: {
-            input: view.totalInputTokens,
-            output: view.totalOutputTokens,
-        },
-        dollars: view.totalUsd,
-        perModel: view.rows.map((row) => ({
-            model: row.model,
-            input: row.inputTokens,
-            output: row.outputTokens,
-            usd: row.usd,
-            note: row.note ?? null,
-        })),
-        tier: tier ?? null,
-    }, text);
-}
-/**
- * Render-only helper for the REPL slash. The slash dispatcher inside
- * `session.ts` owns the side-effect of pushing system lines; this
- * function builds the view and the text rendition so the slash handler
- * can fan the lines into the existing `appendSystemLine` queue.
- *
- * Exposed here (not in the Ink module) so the slash path never imports
- * Ink/React — keeps the REPL bundle slim and the slash handler async-free.
- */
-export function renderCostForSlash(input) {
-    const aggregate = input.allSessions
-        ? input.tracker.aggregateWithin(input.windowDays)
-        : (input.tracker.current() ?? emptyAggregate('no-session', input.now));
-    const heading = input.allSessions
-        ? `Pugi cost / usage — aggregate (last ${input.windowDays} days)`
-        : buildSessionHeading(aggregate, input.now);
-    const view = buildCostView({ aggregate, heading, tier: input.tier ?? undefined });
-    return { view, lines: renderCostTableText(view).split('\n') };
-}
-/**
- * Derive a session id from `.pugi/events.jsonl` when the caller does not
- * pass one. Walks the file once and picks the most recent `session.start`
- * event's id. Falls back to `null` when the file is missing / corrupted
- * — the caller substitutes a `'no-session'` placeholder so the table
- * still renders an empty state instead of crashing.
- */
-function deriveSessionIdFromEvents(workspaceRoot) {
-    const path = resolve(workspaceRoot, '.pugi/events.jsonl');
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = readFileSync(path, 'utf8');
-        const lines = raw.split('\n').filter((line) => line.trim().length > 0);
-        // Walk from newest to oldest — `session.start` is rare, no reason to
-        // scan the whole file when the answer is at the tail.
-        for (let i = lines.length - 1; i >= 0; i -= 1) {
-            try {
-                const parsed = JSON.parse(lines[i]);
-                if (parsed.type === 'session' && parsed.name === 'start' && typeof parsed.sessionId === 'string') {
-                    return parsed.sessionId;
-                }
-            }
-            catch {
-                // partial-write lines are ignored
-            }
-        }
-    }
-    catch {
-        // best-effort; absent events.jsonl is a normal first-boot state
-    }
-    return null;
-}
-function buildSessionHeading(aggregate, now) {
-    if (!aggregate || aggregate.sessionId === 'no-session' || aggregate.sessionId === 'aggregate') {
-        return 'Pugi cost / usage — no active session';
-    }
-    const start = Date.parse(aggregate.startedAt);
-    if (!Number.isFinite(start)) {
-        return `Pugi cost / usage — session ${aggregate.sessionId}`;
-    }
-    const elapsedMin = Math.max(0, Math.floor((now() - start) / 60_000));
-    return `Pugi cost / usage — session ${aggregate.sessionId} (${elapsedMin} min)`;
-}
-function emptyAggregate(sessionId, now) {
-    return {
-        sessionId,
-        startedAt: new Date(now()).toISOString(),
-        models: {},
-    };
-}
-async function safeResolveTier(resolver) {
-    try {
-        return await resolver();
-    }
-    catch {
-        return null;
-    }
-}
-// Re-export aggregate helpers so the cli.ts wire-up can read totals
-// without reaching into the tracker module directly.
-export { totalUsd, totalTokens };
-//# sourceMappingURL=cost.js.map

package/dist/runtime/commands/delegate.js

@@ -1,312 +0,0 @@
-/**
- * Run the delegate command. Parses args, validates the brief, opens a
- * fresh session, and POSTs the delegate brief.
- *
- * Sets `process.exitCode` instead of throwing so the caller (cli.ts
- * handlers table) does not need a try/catch wrapper.
- */
-export async function runDelegateCommand(args, ctx) {
-    // Extract the optional `--wait` flag from positional args. Accept it
-    // in any position so `pugi delegate --wait dev "..."` and
-    // `pugi delegate dev "..." --wait` both work; positional ordering of
-    // slug + brief is preserved by filtering the flag out before the
-    // slug/brief split (Claude P2 fix).
-    const wait = args.some((a) => a === '--wait');
-    const positional = args.filter((a) => a !== '--wait');
-    const slug = positional[0];
-    const brief = positional.slice(1).join(' ').trim();
-    if (!slug || !brief) {
-        ctx.writeOutput({
-            ok: false,
-            error: 'Usage: pugi delegate [--wait] <persona-slug> "<one-sentence brief>"',
-        }, 'Usage: pugi delegate [--wait] <persona-slug> "<one-sentence brief>"');
-        process.exitCode = 2;
-        return;
-    }
-    // Brief size cap mirrors the server-side DTO (8000 chars). The local
-    // gate lets the operator know about the truncation before we waste a
-    // round-trip on a too-large brief.
-    if (brief.length > 8000) {
-        ctx.writeOutput({
-            ok: false,
-            error: `brief is ${brief.length} chars; max 8000`,
-        }, `pugi delegate: brief is ${brief.length} chars; max 8000.`);
-        process.exitCode = 2;
-        return;
-    }
-    const config = ctx.resolveConfig();
-    if (!config) {
-        ctx.writeOutput({
-            ok: false,
-            error: 'no Pugi credential configured; run `pugi login` first',
-        }, 'pugi delegate: no credential configured. Run `pugi login` first.');
-        process.exitCode = 1;
-        return;
-    }
-    const opened = await ctx.openSession(config, ctx.workspaceCwd);
-    if ('error' in opened) {
-        ctx.writeOutput({ ok: false, error: opened.error }, `pugi delegate: session open failed: ${opened.error}`);
-        process.exitCode = 1;
-        return;
-    }
-    const result = await ctx.submitDelegate(config, opened.sessionId, {
-        persona: slug,
-        brief,
-    });
-    switch (result.status) {
-        case 'ok': {
-            const ok = result.response;
-            if (!wait) {
-                ctx.writeOutput({
-                    ok: true,
-                    sessionId: opened.sessionId,
-                    dispatchId: ok.dispatchId,
-                    personaSlug: ok.personaSlug,
-                }, `dispatched ${ok.personaSlug} (dispatchId=${ok.dispatchId}); stream via GET /sessions/${opened.sessionId}/stream.`);
-                return;
-            }
-            // --wait: subscribe to SSE until the persona reaches a terminal
-            // event. The waiter contract is provider-shaped so tests can pass
-            // a fake without standing up fetch.
-            const waiter = ctx.waitForTerminal ?? waitForDelegateTerminal;
-            const outcome = await waiter(config, opened.sessionId, ok.personaSlug);
-            switch (outcome.kind) {
-                case 'completed':
-                    ctx.writeOutput({
-                        ok: true,
-                        sessionId: opened.sessionId,
-                        dispatchId: ok.dispatchId,
-                        personaSlug: outcome.personaSlug,
-                        status: 'completed',
-                    }, `completed ${outcome.personaSlug} (dispatchId=${ok.dispatchId}).`);
-                    return;
-                case 'blocked':
-                    ctx.writeOutput({
-                        ok: false,
-                        sessionId: opened.sessionId,
-                        dispatchId: ok.dispatchId,
-                        personaSlug: outcome.personaSlug,
-                        status: 'blocked',
-                        detail: outcome.detail,
-                    }, `blocked ${outcome.personaSlug}: ${outcome.detail}`);
-                    process.exitCode = 5;
-                    return;
-                case 'failed':
-                    ctx.writeOutput({
-                        ok: false,
-                        sessionId: opened.sessionId,
-                        dispatchId: ok.dispatchId,
-                        personaSlug: outcome.personaSlug,
-                        status: 'failed',
-                        error: outcome.error,
-                    }, `failed ${outcome.personaSlug}: ${outcome.error}`);
-                    process.exitCode = 5;
-                    return;
-                case 'stream_error':
-                    ctx.writeOutput({
-                        ok: false,
-                        sessionId: opened.sessionId,
-                        dispatchId: ok.dispatchId,
-                        error: outcome.error,
-                    }, `pugi delegate --wait: ${outcome.error}`);
-                    process.exitCode = 1;
-                    return;
-            }
-            return;
-        }
-        case 'unknown_persona':
-            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
-            process.exitCode = 3;
-            return;
-        case 'quota_exceeded':
-            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
-            process.exitCode = 4;
-            return;
-        case 'endpoint_missing':
-            ctx.writeOutput({
-                ok: false,
-                error: 'runtime does not expose POST /api/pugi/sessions/:id/delegate (upgrade admin-api to +)',
-                code: result.code,
-            }, 'pugi delegate: runtime does not expose the delegate endpoint. Upgrade admin-api to +.');
-            process.exitCode = 1;
-            return;
-        case 'unauthenticated':
-        case 'failed':
-            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
-            process.exitCode = 1;
-            return;
-    }
-}
-/* ------------------------------------------------------------------ */
-/* --wait waiter                                                     */
-/* ------------------------------------------------------------------ */
-/**
- * Subscribe to the session SSE stream and resolve when the named
- * persona reaches a terminal event (agent.completed / agent.blocked /
- * agent.failed). Falls back to a `stream_error` outcome when the
- * stream closes before any terminal event arrives or when the
- * underlying fetch fails.
- *
- * The waiter is intentionally a single-call helper (not a long-lived
- * subscriber) - the scripted `pugi delegate --wait` caller wants to
- * exit on the first terminal event for THIS persona, not maintain a
- * persistent connection.
- *
- * Why we parse the lifecycle in this file (not via the repl-render
- * subscribe helper): repl-render carries Ink/React deps the
- * non-interactive delegate path does not want to load. Duplicating the
- * minimal SSE-line parser here keeps the command lean (this is the same
- * shape `apps/admin-api/src/pugi/sessions.controller.ts` writes to the
- * wire).
- */
-export async function waitForDelegateTerminal(config, sessionId, targetPersonaSlug) {
-    const url = `${config.apiUrl.replace(/\/+$/, '')}/api/pugi/sessions/${encodeURIComponent(sessionId)}/stream`;
-    const controller = new AbortController();
-    // Hard-cap the waiter at 5 minutes so a stalled server cannot keep
-    // a scripted caller hanging forever; the dispatcher's per-turn budget
-    // is well under this.
-    const timeout = setTimeout(() => controller.abort(), 5 * 60 * 1000);
-    try {
-        const response = await fetch(url, {
-            method: 'GET',
-            headers: {
-                Accept: 'text/event-stream',
-                Authorization: `Bearer ${config.apiKey}`,
-            },
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            return { kind: 'stream_error', error: `HTTP ${response.status}` };
-        }
-        if (!response.body) {
-            return { kind: 'stream_error', error: 'no response body' };
-        }
-        // Track the most-recent persona slug seen on agent.spawned so the
-        // terminal event (which carries only taskId) can be matched to the
-        // delegate target without parsing the random nonce suffix.
-        const taskToPersona = new Map();
-        // Buffer `agent.message` frames per taskId so the terminal event can
-        // surface the persona's full reply (Gemini P1 fix, PR). Keyed by
-        // taskId so a session producing multiple parallel persona dispatches
-        // does not cross-contaminate transcripts.
-        const transcriptByTask = new Map();
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder('utf-8');
-        let buffer = '';
-        let currentData = '';
-        while (true) {
-            const { value, done } = await reader.read();
-            if (done) {
-                return { kind: 'stream_error', error: 'stream ended without terminal event' };
-            }
-            buffer += decoder.decode(value, { stream: true });
-            let newlineIndex;
-            while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
-                const rawLine = buffer.slice(0, newlineIndex).replace(/\r$/, '');
-                buffer = buffer.slice(newlineIndex + 1);
-                if (rawLine.length === 0) {
-                    if (currentData.length > 0) {
-                        const parsed = parseDelegateFrame(currentData);
-                        if (parsed) {
-                            if (parsed.type === 'agent.spawned') {
-                                taskToPersona.set(parsed.taskId, parsed.personaSlug);
-                            }
-                            else if (parsed.type === 'agent.message') {
-                                // Buffer the unfiltered reply by taskId. The terminal
-                                // event below joins these into the `transcript` field
-                                // when the matched persona reaches `agent.completed`.
-                                const existing = transcriptByTask.get(parsed.taskId);
-                                if (existing) {
-                                    existing.push(parsed.content);
-                                }
-                                else {
-                                    transcriptByTask.set(parsed.taskId, [parsed.content]);
-                                }
-                            }
-                            else if (parsed.type === 'agent.completed' ||
-                                parsed.type === 'agent.blocked' ||
-                                parsed.type === 'agent.failed') {
-                                const slug = taskToPersona.get(parsed.taskId) ?? targetPersonaSlug;
-                                if (slug === targetPersonaSlug) {
-                                    controller.abort();
-                                    if (parsed.type === 'agent.completed') {
-                                        const frames = transcriptByTask.get(parsed.taskId) ?? [];
-                                        const transcript = frames.join('\n\n');
-                                        return {
-                                            kind: 'completed',
-                                            personaSlug: slug,
-                                            taskId: parsed.taskId,
-                                            transcript,
-                                        };
-                                    }
-                                    if (parsed.type === 'agent.blocked') {
-                                        return {
-                                            kind: 'blocked',
-                                            personaSlug: slug,
-                                            taskId: parsed.taskId,
-                                            detail: parsed.detail,
-                                        };
-                                    }
-                                    return {
-                                        kind: 'failed',
-                                        personaSlug: slug,
-                                        taskId: parsed.taskId,
-                                        error: parsed.error,
-                                    };
-                                }
-                            }
-                        }
-                    }
-                    currentData = '';
-                    continue;
-                }
-                if (rawLine.startsWith(':'))
-                    continue;
-                const colonIndex = rawLine.indexOf(':');
-                const field = colonIndex === -1 ? rawLine : rawLine.slice(0, colonIndex);
-                const value = colonIndex === -1 ? '' : rawLine.slice(colonIndex + 1).replace(/^ /, '');
-                if (field === 'data') {
-                    currentData = currentData.length === 0 ? value : `${currentData}\n${value}`;
-                }
-            }
-        }
-    }
-    catch (err) {
-        if (controller.signal.aborted) {
-            return { kind: 'stream_error', error: 'wait timed out' };
-        }
-        return { kind: 'stream_error', error: err.message };
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-function parseDelegateFrame(data) {
-    try {
-        const raw = JSON.parse(data);
-        const type = raw.type;
-        const taskId = typeof raw.taskId === 'string' ? raw.taskId : null;
-        if (!taskId)
-            return null;
-        if (type === 'agent.spawned' && typeof raw.personaSlug === 'string') {
-            return { type, taskId, personaSlug: raw.personaSlug };
-        }
-        if (type === 'agent.message' && typeof raw.content === 'string') {
-            return { type, taskId, content: raw.content };
-        }
-        if (type === 'agent.completed') {
-            return { type, taskId };
-        }
-        if (type === 'agent.blocked') {
-            return { type, taskId, detail: typeof raw.detail === 'string' ? raw.detail : '' };
-        }
-        if (type === 'agent.failed') {
-            return { type, taskId, error: typeof raw.error === 'string' ? raw.error : '' };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=delegate.js.map

package/dist/runtime/commands/dispatch.js

@@ -1,126 +0,0 @@
-/**
- * `pugi dispatch <sub>` — fork-subagent cache-handoff surface (—).
- *
- * Sub-commands:
- *
- *  - `pugi dispatch list-cache-refs` — show active cache-inherit refs
- *    persisted under `.pugi/cache-refs/`. Renders an aligned table or
- *    JSON depending on `--json`.
- *
- *  - `pugi dispatch clear-cache-refs [--older-than 1h] [-v]` — GC stale
- *    refs. Without `--older-than`, defaults to 24h (the same cutoff
- *    the REPL boot-time auto-sweep uses). The flag accepts duration
- *    strings the `parseDuration` helper recognises (`1h`, `30m`,
- *    `7d`, `500ms`, ...).
- *
- * The command lives in its own module (not inline in cli.ts) so the
- * dispatch table stays narrow and tests can drive it without spinning
- * up the full CLI.
- */
-import { cleanupStaleCacheRefs, parseDuration, } from '../../core/dispatch/cache-cleanup.js';
-import { listCacheRefs } from '../../core/dispatch/cache-handoff.js';
-const USAGE = [
-    'Usage:',
-    ' pugi dispatch list-cache-refs',
-    '                                      Show every active subagent cache-inherit',
-    '                                      reference persisted under .pugi/cache-refs/.',
-    '',
-    ' pugi dispatch clear-cache-refs [--older-than <duration>] [-v]',
-    '                                      Evict stale refs. Accepts 500ms / 30s / 5m /',
-    '                                      1h / 7d. Default --older-than 24h.',
-].join('\n');
-export async function runDispatchCommand(args, ctx) {
-    const sub = args[0];
-    if (!sub || sub === '--help' || sub === '-h') {
-        ctx.writeOutput({ command: 'dispatch', usage: USAGE.split('\n') }, USAGE);
-        return;
-    }
-    switch (sub) {
-        case 'list-cache-refs':
-            return runListCacheRefs(ctx);
-        case 'clear-cache-refs':
-            return runClearCacheRefs(args.slice(1), ctx);
-        default:
-            ctx.writeOutput({
-                ok: false,
-                error: `unknown subcommand: ${sub}`,
-                usage: USAGE.split('\n'),
-            }, `pugi dispatch: unknown subcommand '${sub}'\n\n${USAGE}`);
-            process.exitCode = 2;
-            return;
-    }
-}
-function runListCacheRefs(ctx) {
-    const refs = listCacheRefs(ctx.workspaceRoot);
-    if (ctx.json) {
-        ctx.writeOutput({ ok: true, count: refs.length, refs }, '');
-        return;
-    }
-    if (refs.length === 0) {
-        ctx.writeOutput({ ok: true, count: 0, refs: [] }, 'No active cache-inherit refs under .pugi/cache-refs/.');
-        return;
-    }
-    // Aligned column table. Widths derived from the data — no hardcoded
-    // sizes so a long childAgentId does not overflow the layout.
-    const header = ['CHILD AGENT', 'CACHE ID', 'PARENT SESSION', 'CREATED'];
-    const rows = refs.map((r) => [
-        r.childAgentId,
-        r.cacheId,
-        r.parentSessionId,
-        r.createdAt,
-    ]);
-    const widths = header.map((h, i) => Math.max(h.length, ...rows.map((row) => (row[i] ?? '').length)));
-    const lines = [];
-    lines.push(header.map((h, i) => h.padEnd(widths[i] ?? 0)).join(' '));
-    lines.push(widths.map((w) => '-'.repeat(w)).join(' '));
-    for (const row of rows) {
-        lines.push(row.map((cell, i) => (cell ?? '').padEnd(widths[i] ?? 0)).join(' '));
-    }
-    ctx.writeOutput({ ok: true, count: refs.length, refs }, lines.join('\n'));
-}
-function runClearCacheRefs(args, ctx) {
-    let olderThanArg;
-    let verbose = false;
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--older-than') {
-            olderThanArg = args[i + 1];
-            i++;
-            continue;
-        }
-        if (arg && arg.startsWith('--older-than=')) {
-            olderThanArg = arg.slice('--older-than='.length);
-            continue;
-        }
-        if (arg === '-v' || arg === '--verbose') {
-            verbose = true;
-            continue;
-        }
-    }
-    // Default 24h matches the REPL boot-time auto-sweep cutoff.
-    const olderThanMs = olderThanArg ? parseDuration(olderThanArg) : 24 * 60 * 60 * 1000;
-    if (olderThanMs === null) {
-        ctx.writeOutput({
-            ok: false,
-            error: `invalid --older-than value: ${olderThanArg ?? '(missing)'}`,
-            usage: USAGE.split('\n'),
-        }, `pugi dispatch clear-cache-refs: invalid --older-than '${olderThanArg ?? '(missing)'}'\n\n${USAGE}`);
-        process.exitCode = 2;
-        return;
-    }
-    const result = cleanupStaleCacheRefs(ctx.workspaceRoot, {
-        olderThanMs,
-        verbose,
-    });
-    const summary = `Removed ${result.removedCount} ref(s) (${result.corruptCount} corrupt), kept ${result.keptCount}.`;
-    ctx.writeOutput({
-        ok: true,
-        olderThanMs,
-        removedCount: result.removedCount,
-        keptCount: result.keptCount,
-        corruptCount: result.corruptCount,
-        removed: result.removed,
-        corrupt: result.corrupt,
-    }, summary);
-}
-//# sourceMappingURL=dispatch.js.map