@pugi/cli 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/runtime/commands/config.js

@@ -11,21 +11,21 @@ import { resolveActiveCredential } from '../../core/credentials.js';
  * `pugi config` — operator-level configuration surface.
  *
  * Subcommands:
- *   - `pugi config get <key>`              read a value from `~/.pugi/config.json`
- *   - `pugi config set <key> <value>`      write a value
- *   - `pugi config list`                   dump all values
- *   - `pugi config trust .`                trust the current workspace (delegates to core/trust.ts)
- *   - `pugi config mcp trust <name>`       flip MCP server to trusted
- *   - `pugi config mcp deny <name>`        flip MCP server to denied
- *   - `pugi config mcp list`               show declared servers + their trust state
+ *  - `pugi config get <key>`             read a value from `~/.pugi/config.json`
+ *  - `pugi config set <key> <value>`     write a value
+ *  - `pugi config list`                  dump all values
+ *  - `pugi config trust .`               trust the current workspace (delegates to core/trust.ts)
+ *  - `pugi config mcp trust <name>`      flip MCP server to trusted
+ *  - `pugi config mcp deny <name>`       flip MCP server to denied
+ *  - `pugi config mcp list`              show declared servers + their trust state
  *
  * Schema (pugi-config-v1):
- *   {
- *     "permissionMode": "ask" | "acceptEdits" | "auto" | "plan" | "dontAsk" | "bypassPermissions",
- *     "privacy":        "local-only" | "metadata" | "full",
- *     "model":          "<id>" | null,
- *     "preferredEndpoint": "https://api.pugi.io"
- *   }
+ *  {
+ *    "permissionMode": "ask" | "acceptEdits" | "auto" | "plan" | "dontAsk" | "bypassPermissions",
+ *    "privacy":       "local-only" | "metadata" | "full",
+ *    "model":         "<id>" | null,
+ *    "preferredEndpoint": "https://api.pugi.io"
+ *  }
  *
  * The config file lives at `~/.pugi/config.json` (PUGI_HOME-aware) and uses
  * mode 0o600. Unknown keys are rejected by `set` so a typo never silently
@@ -39,9 +39,41 @@ const configSchema = z
     privacy: z.enum(['local-only', 'metadata', 'full']).optional(),
     model: z.string().nullable().optional(),
     preferredEndpoint: z.string().url().optional(),
+    // PUGI-260 — persistent default for the 1M context tier opt-in.
+    // `pugi config set contextTier 1m` (or the dotted form
+    // `context.tier 1m`) writes this; per-invocation `--context-tier=...`
+    // flags override it at request time. Closed enum mirrors the CLI
+    // flag и the admin-api DTO so a typo here surfaces as a Zod parse
+    // error при load, not a silent fallback. Stored on the flat user-
+    // level config (~/.pugi/config.json) so all workspaces inherit the
+    // same default — operators с consistent long-context workloads
+    // (large monorepos, audits) set it once instead of remembering к
+    // pass --context-tier=1m on every dispatch.
+    contextTier: z.enum(['1m', 'standard']).optional(),
 })
     .strict();
-const CONFIG_KEYS = ['permissionMode', 'privacy', 'model', 'preferredEndpoint'];
+const CONFIG_KEYS = [
+    'permissionMode',
+    'privacy',
+    'model',
+    'preferredEndpoint',
+    // PUGI-260 — exposed на `pugi config list` so operators see the
+    // current default. Hidden synonym `context.tier` accepted by
+    // runConfigSet / runConfigGet for a dotted-key familiar UX.
+    'contextTier',
+];
+/**
+ * PUGI-260: legacy / nested key aliasing. `pugi config set context.tier 1m`
+ * is the documented form в the feat doc; we normalise it onto the flat
+ * `contextTier` key before the strict-schema validation так future
+ * settings.json migrations keep one canonical key. Mirrors the
+ * legacy privacy-mode aliasing that already lives in the file.
+ */
+function normaliseConfigKey(raw) {
+    if (raw === 'context.tier')
+        return 'contextTier';
+    return raw;
+}
 export async function runConfigCommand(args, ctx) {
     const sub = args[0];
     if (!sub || sub === '--help' || sub === '-h') {
@@ -63,18 +95,18 @@ export async function runConfigCommand(args, ctx) {
             ],
         }, [
             'Usage:',
-            '  pugi config get <key>                            Read a config value.',
-            '  pugi config set <key> <value>                    Write a config value.',
-            '  pugi config list                                 Show all config values.',
-            '  pugi config trust .                              Trust the current workspace for hooks + MCP.',
-            '  pugi config mcp trust <name>                     Mark an MCP server as trusted.',
-            '  pugi config mcp deny <name>                      Block an MCP server.',
-            '  pugi config mcp list                             Show declared MCP servers + trust state.',
-            '  pugi config get routing                          Show effective routing table (defaults + tenant overrides).',
-            '  pugi config set routing.<tag>.<budget>=<model>   Override the model for one (tag, budget) lane.',
-            '  pugi config unset routing.<tag>.<budget>         Remove a routing override (revert to default).',
-            '  pugi config get privacy                          Show current tenant privacy mode + last-flip metadata.',
-            '  pugi config set privacy=<mode>                   Flip privacy mode (strict | balanced | permissive).',
+            ' pugi config get <key>                           Read a config value.',
+            ' pugi config set <key> <value>                   Write a config value.',
+            ' pugi config list                                Show all config values.',
+            ' pugi config trust .                             Trust the current workspace for hooks + MCP.',
+            ' pugi config mcp trust <name>                    Mark an MCP server as trusted.',
+            ' pugi config mcp deny <name>                     Block an MCP server.',
+            ' pugi config mcp list                            Show declared MCP servers + trust state.',
+            ' pugi config get routing                         Show effective routing table (defaults + tenant overrides).',
+            ' pugi config set routing.<tag>.<budget>=<model>  Override the model for one (tag, budget) lane.',
+            ' pugi config unset routing.<tag>.<budget>        Remove a routing override (revert to default).',
+            ' pugi config get privacy                         Show current tenant privacy mode + last-flip metadata.',
+            ' pugi config set privacy=<mode>                  Flip privacy mode (strict | balanced | permissive).',
         ].join('\n'));
         return;
     }
@@ -108,7 +140,7 @@ export async function runConfigCommand(args, ctx) {
             // names. The unit spec for config.ts has a regression test for
             // both code paths.
             //
-            // Triple-review P2 fix (2026-05-25): the prior disambiguation
+            // Triple-review P2 fix : the prior disambiguation
             // only excluded the bare form (`privacy local-only`) - the `=`
             // form (`privacy=local-only`) still routed to runPrivacySet and
             // 4xx'd. We now check the value AFTER `=` and route legacy local
@@ -178,25 +210,27 @@ function isConfigKey(value) {
     return CONFIG_KEYS.includes(value);
 }
 function runConfigGet(args, ctx) {
-    const key = args[0];
-    if (!key)
+    const rawKey = args[0];
+    if (!rawKey)
         throw new Error('pugi config get requires a key.');
+    const key = normaliseConfigKey(rawKey);
     if (!isConfigKey(key)) {
-        throw new Error(`Unknown config key "${key}". Allowed: ${CONFIG_KEYS.join(', ')}.`);
+        throw new Error(`Unknown config key "${rawKey}". Allowed: ${CONFIG_KEYS.join(', ')}.`);
     }
     const config = readConfig();
     const value = config[key] ?? null;
     ctx.writeOutput({ command: 'config.get', key, value }, value === null || value === undefined ? `${key} = (unset)` : `${key} = ${String(value)}`);
 }
 function runConfigSet(args, ctx) {
-    const key = args[0];
+    const rawKey = args[0];
     const value = args.slice(1).join(' ');
-    if (!key)
+    if (!rawKey)
         throw new Error('pugi config set requires a key.');
     if (value.length === 0)
         throw new Error('pugi config set requires a value.');
+    const key = normaliseConfigKey(rawKey);
     if (!isConfigKey(key)) {
-        throw new Error(`Unknown config key "${key}". Allowed: ${CONFIG_KEYS.join(', ')}.`);
+        throw new Error(`Unknown config key "${rawKey}". Allowed: ${CONFIG_KEYS.join(', ')}.`);
     }
     const current = readConfig();
     // Build the candidate and validate via the schema so an invalid value
@@ -279,7 +313,7 @@ async function runConfigMcpList(ctx) {
     }
     ctx.writeOutput({ command: 'config.mcp.list', servers: declared, ledger }, [
         'MCP servers:',
-        ...declared.map((server) => `  ${server.name.padEnd(20)} ${server.trust.padEnd(8)} ${server.command} ${server.args.join(' ')}`),
+        ...declared.map((server) => ` ${server.name.padEnd(20)} ${server.trust.padEnd(8)} ${server.command} ${server.args.join(' ')}`),
     ].join('\n'));
 }
 async function runConfigMcpFlip(args, ctx, state) {
@@ -297,7 +331,7 @@ async function runConfigMcpFlip(args, ctx, state) {
         : `MCP server "${name}" is now denied.`);
 }
 /* ------------------------------------------------------------------ */
-/* α6.10 multi-model routing — config.routing.* subcommands            */
+/* multi-model routing — config.routing.* subcommands           */
 /* ------------------------------------------------------------------ */
 /**
  * Closed sets — match
@@ -360,7 +394,7 @@ async function runRoutingGet(ctx) {
     });
     const text = [
         'Routing table (effective = override | default):',
-        ...cells.map((cell) => `  routing.${cell.tag.padEnd(10)}.${cell.budgetHint.padEnd(3)} = ${cell.model.padEnd(28)} (${cell.source})`),
+        ...cells.map((cell) => ` routing.${cell.tag.padEnd(10)}.${cell.budgetHint.padEnd(3)} = ${cell.model.padEnd(28)} (${cell.source})`),
     ].join('\n');
     ctx.writeOutput({
         command: 'config.routing.get',
@@ -439,7 +473,7 @@ async function runRoutingUnset(args, ctx) {
         : `routing.${tag}.${budget} had no override (nothing to remove).`);
 }
 /* ------------------------------------------------------------------ */
-/* alpha 6.13 privacy 3-mode - config.privacy.* subcommands             */
+/* alpha 6.13 privacy 3-mode - config.privacy.* subcommands            */
 /* ------------------------------------------------------------------ */
 /**
  * Closed mirror of the server-side PRIVACY_MODES enum
@@ -459,7 +493,7 @@ function isPrivacyMode(value) {
  * Legacy local-config privacy values from before alpha 6.13. Kept so
  * `pugi config set privacy=local-only` continues to write to the local
  * config file (matching the bare-form behaviour). Triple-review P2 fix
- * (2026-05-25): the prior disambiguation only excluded the bare form;
+ * : the prior disambiguation only excluded the bare form;
  * the `=` form routed to runPrivacySet and 4xx'd on the unknown mode.
  */
 const LEGACY_LOCAL_PRIVACY_VALUES = [
@@ -536,7 +570,7 @@ async function runPrivacySet(args, ctx) {
  * — undici's `request` honours the global dispatcher reliably across the
  * pinned undici version. Kept local (not shared with `pugi whoami`) so
  * the routing surface is self-contained — extracting a common helper is
- * α6.10b cleanup once we see two callers.
+ * cleanup once we see two callers.
  */
 async function fetchJson(url, apiKey, options = {}) {
     const method = options.method ?? 'GET';

package/dist/runtime/commands/cost.js

@@ -0,0 +1,199 @@
+/**
+ * `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

@@ -10,7 +10,7 @@ export async function runDelegateCommand(args, ctx) {
     // 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 2026-05-25).
+    // slug/brief split (Claude P2 fix).
     const wait = args.some((a) => a === '--wait');
     const positional = args.filter((a) => a !== '--wait');
     const slug = positional[0];
@@ -125,9 +125,9 @@ export async function runDelegateCommand(args, ctx) {
         case 'endpoint_missing':
             ctx.writeOutput({
                 ok: false,
-                error: 'runtime does not expose POST /api/pugi/sessions/:id/delegate (upgrade admin-api to α7.5+)',
+                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 α7.5+.');
+            }, 'pugi delegate: runtime does not expose the delegate endpoint. Upgrade admin-api to +.');
             process.exitCode = 1;
             return;
         case 'unauthenticated':
@@ -138,7 +138,7 @@ export async function runDelegateCommand(args, ctx) {
     }
 }
 /* ------------------------------------------------------------------ */
-/* --wait waiter                                                      */
+/* --wait waiter                                                     */
 /* ------------------------------------------------------------------ */
 /**
  * Subscribe to the session SSE stream and resolve when the named
@@ -185,6 +185,11 @@ export async function waitForDelegateTerminal(config, sessionId, targetPersonaSl
         // 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 = '';
@@ -206,6 +211,18 @@ export async function waitForDelegateTerminal(config, sessionId, targetPersonaSl
                             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') {
@@ -213,10 +230,13 @@ export async function waitForDelegateTerminal(config, sessionId, targetPersonaSl
                                 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') {
@@ -271,6 +291,9 @@ function parseDelegateFrame(data) {
         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 };
         }

package/dist/runtime/commands/dispatch.js

@@ -0,0 +1,126 @@
+/**
+ * `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