@pugi/cli 0.1.0-beta.8 → 0.1.0-beta.88

package/dist/core/coordinator/mode-fsm.js

@@ -0,0 +1,70 @@
+const isQuiescent = (state) => state.readTasks === 0 && !state.writeTaskActive;
+export const MODE_TRANSITIONS = [
+    { from: 'idle', to: 'research', trigger: 'plan', guard: isQuiescent },
+    { from: 'research', to: 'synth', trigger: 'synthesize', guard: isQuiescent },
+    { from: 'synth', to: 'impl', trigger: 'execute', guard: isQuiescent },
+    { from: 'impl', to: 'review', trigger: 'verify', guard: isQuiescent },
+    { from: 'review', to: 'done', trigger: 'accept', guard: isQuiescent },
+    { from: 'review', to: 'impl', trigger: 'fix', guard: isQuiescent },
+    { from: 'idle', to: 'idle', trigger: 'reset' },
+    { from: 'research', to: 'idle', trigger: 'reset' },
+    { from: 'synth', to: 'idle', trigger: 'reset' },
+    { from: 'impl', to: 'idle', trigger: 'reset' },
+    { from: 'review', to: 'idle', trigger: 'reset' },
+    { from: 'done', to: 'idle', trigger: 'reset' },
+];
+class CoordinatorModeFSM {
+    state;
+    constructor(initial = 'idle') {
+        this.state = {
+            mode: initial,
+            enteredAt: Date.now(),
+            readTasks: 0,
+            writeTaskActive: false,
+        };
+    }
+    current() {
+        return { ...this.state };
+    }
+    trigger(event) {
+        const transition = MODE_TRANSITIONS.find((candidate) => candidate.from === this.state.mode && candidate.trigger === event);
+        if (!transition) {
+            return {
+                ok: false,
+                reason: `No transition for event '${event}' from mode '${this.state.mode}'.`,
+            };
+        }
+        if (transition.guard && !transition.guard(this.current())) {
+            return {
+                ok: false,
+                reason: `Guard blocked event '${event}' from mode '${this.state.mode}'.`,
+            };
+        }
+        this.state = {
+            ...this.state,
+            mode: transition.to,
+            enteredAt: Date.now(),
+        };
+        return { ok: true };
+    }
+    beginRead() {
+        this.state.readTasks += 1;
+    }
+    endRead() {
+        this.state.readTasks = Math.max(0, this.state.readTasks - 1);
+    }
+    beginWrite() {
+        if (this.state.writeTaskActive) {
+            return { ok: false, reason: 'A write task is already active.' };
+        }
+        this.state.writeTaskActive = true;
+        return { ok: true };
+    }
+    endWrite() {
+        this.state.writeTaskActive = false;
+    }
+}
+export function createFSM(initial) {
+    return new CoordinatorModeFSM(initial);
+}
+//# sourceMappingURL=mode-fsm.js.map

package/dist/core/cost/rate-card.js

@@ -0,0 +1,129 @@
+/**
+ * Rate card for the `pugi cost` / `/cost` / `/usage` surface — L19 sprint.
+ *
+ * Distinct from `core/repl/model-pricing.ts` on purpose:
+ *
+ *  - `model-pricing.ts` powers the TUI cost meter (per-turn flash, status
+ *    row USD). Its ladder is keyed against the live Anvil model slugs and
+ *    intentionally inflates an honest worst-case figure via the Sonnet
+ *    fallback so an operator on a quiet model never gets billed by a
+ *    surprise. It rounds to USD per 1M tokens at runtime.
+ *
+ *  - `rate-card.ts` (this file) powers the persisted `/cost` table the
+ *    operator reads to plan budget. It distinguishes open-weight models
+ *    ($0 / $0 — infra cost only) from hosted closed models so the table
+ *    does not double-charge an operator running a self-hosted Qwen or
+ *    Kimi behind Pugi. The L19 spec calls these out by name.
+ *
+ * Both ladders intentionally agree on Anthropic Claude family pricing so
+ * the TUI flash and the persisted table cannot disagree on a Claude turn.
+ * If they diverge, the per-model-pricing ladder wins for live UI; the
+ * rate card here wins for the persisted `.pugi/cost.json` aggregate.
+ *
+ * Prices are USD per 1,000,000 tokens, sourced from the L19 spec
+ * which mirrors provider list-price pages as of that date.
+ */
+/**
+ * Exact-match price ladder keyed by model slug. Slugs match the L19 task
+ * spec verbatim so a copy-paste from the sprint doc resolves without
+ * normalisation.
+ */
+export const RATES_PER_MTOKEN = Object.freeze({
+    // Anthropic Claude family (hosted, billed).
+    'claude-opus-4-7': { input: 15, output: 75 },
+    'claude-opus-4-6': { input: 15, output: 75 },
+    'claude-sonnet-4-6': { input: 3, output: 15 },
+    'claude-sonnet-4-5': { input: 3, output: 15 },
+    'claude-haiku-4-5-20251001': { input: 1, output: 5 },
+    'claude-haiku-4-5': { input: 1, output: 5 },
+    // Open-weight models — infra cost only, never per-token billed. The
+    // note column surfaces the reason so a CFO reading the JSON envelope
+    // does not assume the row is broken.
+    'qwen3-coder-480b-instruct-fp8': { input: 0, output: 0, note: 'open-weight' },
+    'kimi-k2.6': { input: 0, output: 0, note: 'open-weight' },
+    'deepseek-v4-pro': { input: 0, output: 0, note: 'open-weight' },
+});
+/**
+ * Family-prefix fallback — used only when an exact slug miss. Mirrors the
+ * approach in `model-pricing.ts` so a future model rebind (e.g.
+ * `claude-opus-4-8`) prices reasonably without a code edit.
+ */
+const FAMILY_FALLBACKS = [
+    ['claude-opus-', { input: 15, output: 75 }],
+    ['claude-sonnet-', { input: 3, output: 15 }],
+    ['claude-haiku-', { input: 1, output: 5 }],
+    ['qwen', { input: 0, output: 0, note: 'open-weight' }],
+    ['kimi', { input: 0, output: 0, note: 'open-weight' }],
+    ['deepseek', { input: 0, output: 0, note: 'open-weight' }],
+];
+/**
+ * Final fallback for unknown slugs. Pinned to Sonnet-tier — same posture
+ * as `model-pricing.ts`'s default, so an unrecognised hosted model bills
+ * "honestly conservative" rather than $0 (which would silently hide cost
+ * from the operator).
+ */
+const DEFAULT_RATE = { input: 3, output: 15, note: 'unknown model — Sonnet-tier estimate' };
+/**
+ * Look up the rate for a model slug.
+ *
+ * Resolution order:
+ *  1. Exact match in `RATES_PER_MTOKEN`.
+ *  2. Family-prefix match (first hit wins).
+ *  3. Default Sonnet-tier estimate.
+ *
+ * Pure, never throws. Called on every cost-tracker write so the hot path
+ * stays branch-cheap.
+ */
+export function rateFor(model) {
+    if (!model || typeof model !== 'string')
+        return DEFAULT_RATE;
+    const exact = RATES_PER_MTOKEN[model];
+    if (exact)
+        return exact;
+    for (const [prefix, rate] of FAMILY_FALLBACKS) {
+        if (model.startsWith(prefix))
+            return rate;
+    }
+    return DEFAULT_RATE;
+}
+/**
+ * Compute the USD cost for a single (model, inputTokens, outputTokens)
+ * triple. Defensive against negative / NaN inputs — out-of-range values
+ * floor to zero so a buggy upstream cannot credit a negative cost.
+ */
+export function estimateUsd(model, inputTokens, outputTokens) {
+    const rate = rateFor(model);
+    const safeIn = Number.isFinite(inputTokens) && inputTokens > 0 ? inputTokens : 0;
+    const safeOut = Number.isFinite(outputTokens) && outputTokens > 0 ? outputTokens : 0;
+    const usd = (safeIn * rate.input + safeOut * rate.output) / 1_000_000;
+    return Number.isFinite(usd) && usd > 0 ? usd : 0;
+}
+/**
+ * Format a USD figure for the `/cost` table.
+ *
+ *  - `≥ $0.01` → two decimals (`$0.46`).
+ *  - `< $0.01` but `> 0` → three decimals (`$0.003`) so fractions of a
+ *    cent are honest instead of rounding to `$0.00`.
+ *  - Exactly `0` or NaN → `$0.00`.
+ *
+ * Mirrors `formatCostUsd` from `model-pricing.ts` intentionally — both
+ * surfaces should print the same number in the same shape.
+ */
+export function formatUsd(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return '$0.00';
+    if (value >= 0.01)
+        return `$${value.toFixed(2)}`;
+    return `$${value.toFixed(3)}`;
+}
+/**
+ * Format a token count for the `/cost` table. Uses comma-thousands so the
+ * table reads `14,300` instead of `14.3k` — distinct from the TUI status
+ * row which uses `k`/`m` shortening to save column width.
+ */
+export function formatTokensWithCommas(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return '0';
+    return Math.floor(value).toLocaleString('en-US');
+}
+//# sourceMappingURL=rate-card.js.map

package/dist/core/cost/tracker.js

@@ -0,0 +1,221 @@
+/**
+ * Persisted per-session cost tracker — L19 sprint .
+ *
+ * Mission: every Anvil-mediated LLM call goes through `recordCall`, which
+ * aggregates per-model token + USD totals and atomically persists them
+ * to `.pugi/cost.json` so the operator can read `/cost` across REPL
+ * restarts and reconcile a 14-min session that crossed a process boundary.
+ *
+ * Why a fresh module instead of bolting onto `core/repl/session.ts`?
+ *
+ *  - `session.ts` accumulates in-memory state for the live TUI status
+ *    row, which is by-design ephemeral and cleared on REPL boot. The
+ *    operator's "what did I spend across the project?" question needs
+ *    a durable surface that survives a process restart.
+ *  - L19 also has to read `--all-sessions` (last 30 days). The natural
+ *    store for that is a per-workspace history of session aggregates,
+ *    which is easy with the JSON file pattern below and would be
+ *    awkward stitched into the REPL reducer.
+ *
+ * On-disk shape (single JSON file, atomic tmp+rename writes):
+ *
+ *  {
+ *    "version": 1,
+ *    "current": { sessionId, startedAt, models: { <slug>: ModelEntry } },
+ *    "history": [
+ *      { sessionId, startedAt, endedAt, models: { ... } }
+ *    ]
+ *  }
+ *
+ * History rotation: when `recordCall` is invoked with a sessionId
+ * different from `current.sessionId`, the existing `current` row is
+ * stamped with `endedAt = now()` and pushed onto `history`, then a new
+ * `current` row is initialised. History is capped at 90 entries (the L19
+ * `--all-sessions` window is 30 days; 90 gives a generous buffer for
+ * operators on >1 session/day cadence without unbounded growth).
+ *
+ * The tracker is workspace-scoped — every workspace has its own
+ * `.pugi/cost.json`. This matches the existing `.pugi/events.jsonl` /
+ * `.pugi/index.json` pattern and means a multi-repo operator's costs
+ * are billed against the repo they were incurred in.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { estimateUsd } from './rate-card.js';
+/** On-disk schema version. Bump if the file shape changes. */
+export const COST_FILE_SCHEMA_VERSION = 1;
+/** Maximum number of historical sessions persisted in `.pugi/cost.json`. */
+export const COST_HISTORY_CAP = 90;
+export function createCostTracker(opts) {
+    const filePath = resolve(opts.workspaceRoot, '.pugi/cost.json');
+    const now = opts.now ?? Date.now;
+    let state = readOrInit(filePath);
+    function ensureCurrent(sessionId) {
+        if (state.current && state.current.sessionId === sessionId) {
+            return state.current;
+        }
+        // Session rotation: stamp the previous current with endedAt and push
+        // onto history. Idempotent — calling rotate twice with the same
+        // session id is a no-op.
+        if (state.current) {
+            const ended = {
+                ...state.current,
+                endedAt: new Date(now()).toISOString(),
+            };
+            state.history = [ended, ...state.history].slice(0, COST_HISTORY_CAP);
+        }
+        state.current = {
+            sessionId,
+            startedAt: new Date(now()).toISOString(),
+            models: {},
+        };
+        return state.current;
+    }
+    function persist() {
+        try {
+            mkdirSync(dirname(filePath), { recursive: true });
+        }
+        catch {
+            // best-effort directory create; the write below surfaces the real
+            // error if the parent is genuinely unwritable
+        }
+        const tmp = `${filePath}.tmp`;
+        writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf8');
+        renameSync(tmp, filePath);
+    }
+    return {
+        recordCall(input) {
+            const sessionId = opts.sessionIdProvider();
+            if (!sessionId)
+                return;
+            const current = ensureCurrent(sessionId);
+            const slug = typeof input.model === 'string' && input.model.length > 0 ? input.model : 'unknown';
+            const safeIn = Number.isFinite(input.inputTokens) && input.inputTokens > 0 ? input.inputTokens : 0;
+            const safeOut = Number.isFinite(input.outputTokens) && input.outputTokens > 0 ? input.outputTokens : 0;
+            const existing = current.models[slug] ?? { input: 0, output: 0, callCount: 0 };
+            current.models[slug] = {
+                input: existing.input + safeIn,
+                output: existing.output + safeOut,
+                callCount: existing.callCount + 1,
+            };
+            persist();
+        },
+        current() {
+            return state.current;
+        },
+        history() {
+            return state.history;
+        },
+        aggregateWithin(withinDays) {
+            const cutoffMs = now() - withinDays * 24 * 60 * 60 * 1000;
+            const aggregate = {
+                sessionId: 'aggregate',
+                startedAt: new Date(cutoffMs).toISOString(),
+                endedAt: new Date(now()).toISOString(),
+                models: {},
+            };
+            const rows = [];
+            if (state.current)
+                rows.push(state.current);
+            for (const row of state.history) {
+                const stamp = Date.parse(row.startedAt);
+                if (Number.isFinite(stamp) && stamp >= cutoffMs)
+                    rows.push(row);
+            }
+            for (const row of rows) {
+                for (const [slug, entry] of Object.entries(row.models)) {
+                    const existing = aggregate.models[slug] ?? { input: 0, output: 0, callCount: 0 };
+                    aggregate.models[slug] = {
+                        input: existing.input + entry.input,
+                        output: existing.output + entry.output,
+                        callCount: existing.callCount + entry.callCount,
+                    };
+                }
+            }
+            return aggregate;
+        },
+        resetCurrent() {
+            const wiped = state.current;
+            state.current = null;
+            persist();
+            return wiped;
+        },
+        flush() {
+            persist();
+        },
+    };
+}
+/**
+ * Compute the per-session USD total from a `SessionAggregate`. Pure —
+ * uses the rate card to bind a price to every model entry. Open-weight
+ * models contribute $0 (their entries always have $0/$0 rate).
+ */
+export function totalUsd(aggregate) {
+    let total = 0;
+    for (const [slug, entry] of Object.entries(aggregate.models)) {
+        total += estimateUsd(slug, entry.input, entry.output);
+    }
+    return total;
+}
+/**
+ * Compute total input + output token sums across all models in an
+ * aggregate. Used by the CLI table footer.
+ */
+export function totalTokens(aggregate) {
+    let input = 0;
+    let output = 0;
+    for (const entry of Object.values(aggregate.models)) {
+        input += entry.input;
+        output += entry.output;
+    }
+    return { input, output };
+}
+/**
+ * Read the persisted file (or initialise an empty one). Tolerates a
+ * corrupted file by returning a fresh empty state — losing one
+ * session's history is preferable to throwing from the boot path of
+ * every `pugi cost` invocation.
+ */
+function readOrInit(filePath) {
+    if (!existsSync(filePath)) {
+        return { version: COST_FILE_SCHEMA_VERSION, current: null, history: [] };
+    }
+    try {
+        const raw = readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return { version: COST_FILE_SCHEMA_VERSION, current: null, history: [] };
+        }
+        const obj = parsed;
+        return {
+            version: typeof obj.version === 'number' ? obj.version : COST_FILE_SCHEMA_VERSION,
+            current: isAggregate(obj.current) ? obj.current : null,
+            history: Array.isArray(obj.history) ? obj.history.filter(isAggregate) : [],
+        };
+    }
+    catch {
+        return { version: COST_FILE_SCHEMA_VERSION, current: null, history: [] };
+    }
+}
+function isAggregate(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return false;
+    const obj = v;
+    if (typeof obj.sessionId !== 'string' || typeof obj.startedAt !== 'string')
+        return false;
+    if (!obj.models || typeof obj.models !== 'object')
+        return false;
+    return true;
+}
+/**
+ * Test helper — wipe the `.pugi/cost.json` file. Not exported through the
+ * public CostTracker surface because production code must never call
+ * this; an operator-facing reset goes through `resetCurrent()` which
+ * preserves history.
+ */
+export function _danger_wipeCostFile_forTests(workspaceRoot) {
+    const filePath = resolve(workspaceRoot, '.pugi/cost.json');
+    if (existsSync(filePath))
+        unlinkSync(filePath);
+}
+//# sourceMappingURL=tracker.js.map

package/dist/core/credentials.js

@@ -207,11 +207,11 @@ export function loadApiKey(apiUrl, home = homedir()) {
 }
 export function resolveActiveCredential(env = process.env, home = homedir()) {
     // Resolve the active apiUrl with this precedence:
-    //   1. PUGI_API_URL env (lets CI / self-hosted users force a specific endpoint)
-    //   2. credentials.json `activeApiUrl` (set by `pugi login` to the host the
-    //      user most recently authenticated against — covers self-hosted Anvil
-    //      without re-exporting env between commands)
-    //   3. DEFAULT_API_URL (`https://api.pugi.io`)
+    //  1. PUGI_API_URL env (lets CI / self-hosted users force a specific endpoint)
+    //  2. credentials.json `activeApiUrl` (set by `pugi login` to the host the
+    //     user most recently authenticated against — covers self-hosted Anvil
+    //     without re-exporting env between commands)
+    //  3. DEFAULT_API_URL (`https://api.pugi.io`)
     const file = readCredentialsFile(home);
     const apiUrl = normalizeApiUrl(env.PUGI_API_URL ?? file.activeApiUrl ?? DEFAULT_API_URL);
     if (env.PUGI_API_KEY) {
@@ -238,10 +238,10 @@ export function resolveActiveCredential(env = process.env, home = homedir()) {
  * re-export PUGI_API_URL between commands.
  *
  * Match precedence:
- *   1. exact `label` match (case-insensitive, label is user-chosen so
- *      we forgive casing — same convention as `gh auth switch`)
- *   2. exact `apiUrl` match (canonicalised) — lets `pugi accounts
- *      switch https://api.acme.com` work without a label.
+ *  1. exact `label` match (case-insensitive, label is user-chosen so
+ *     we forgive casing — same convention as `gh auth switch`)
+ *  2. exact `apiUrl` match (canonicalised) — lets `pugi accounts
+ *     switch https://api.acme.com` work without a label.
  *
  * Returns the now-active record, or null when nothing matched.
  */
@@ -311,9 +311,9 @@ export function listStoredCredentials(home = homedir()) {
 /**
  * Canonicalize an apiUrl so two equivalent inputs always resolve to the
  * same record:
- *   - lowercase scheme + host (URL spec: scheme/host are case-insensitive)
- *   - strip trailing slashes
- *   - preserve path/query/fragment case (those ARE case-sensitive)
+ *  - lowercase scheme + host (URL spec: scheme/host are case-insensitive)
+ *  - strip trailing slashes
+ *  - preserve path/query/fragment case (those ARE case-sensitive)
  *
  * Falls back to the trimmed input when the URL is not parseable, so a
  * caller that manages to pass a non-URL string still sees a stable key

package/dist/core/cron/scheduler.js

@@ -0,0 +1,138 @@
+/**
+ * Cron scheduler primitive .
+ *
+ * Wraps `node-cron` (4.2.1, MIT, ~4M weekly downloads) — the de-facto
+ * Node cron scheduler. We do NOT parse cron expressions ourselves;
+ * node-cron handles validation, timezone math, и DST edge cases.
+ *
+ * What this module adds:
+ *  - Named job registry (schedule/cancel/list by name)
+ *  - Concurrency guard — a still-running job is skipped, not stacked,
+ *    when the next tick fires (prevents overlap when an action runs
+ *    longer than the cron period)
+ *  - Stats per job: scheduled, lastRunAt, lastDurationMs, failures
+ *
+ * Pure-ish: state lives в the CronScheduler instance, no globals.
+ * Tool surface (ScheduleCronTool / CronList / CronDelete) wires this
+ * primitive into the engine в a separate PR.
+ */
+import cron from 'node-cron';
+export class CronScheduler {
+    jobs = new Map();
+    /**
+     * Register a cron job. Replaces any prior job at the same name —
+     * the previous one is stopped и destroyed first.
+     *
+     * Throws `RangeError` when `expression` is invalid per node-cron's
+     * parser. The error originates from node-cron and bubbles unchanged.
+     */
+    schedule(name, expression, action, options = {}) {
+        if (!name)
+            throw new TypeError('cron job name must be non-empty');
+        if (!cron.validate(expression)) {
+            throw new RangeError(`invalid cron expression: ${expression}`);
+        }
+        const existing = this.jobs.get(name);
+        if (existing) {
+            existing.task.stop();
+        }
+        const internal = {
+            task: undefined,
+            expression,
+            scheduledAt: Date.now(),
+            lastRunAt: null,
+            lastDurationMs: null,
+            runs: 0,
+            failures: 0,
+            running: false,
+        };
+        const wrapped = async () => {
+            // Concurrency guard: if previous invocation still running, skip.
+            // Stacking would tie up the event loop с long-running actions.
+            if (internal.running)
+                return;
+            internal.running = true;
+            const start = Date.now();
+            try {
+                await action();
+                internal.runs += 1;
+            }
+            catch {
+                internal.failures += 1;
+            }
+            finally {
+                internal.lastRunAt = start;
+                internal.lastDurationMs = Date.now() - start;
+                internal.running = false;
+            }
+        };
+        const scheduleOptions = {};
+        if (options.timezone !== undefined) {
+            scheduleOptions.timezone = options.timezone;
+        }
+        internal.task = cron.schedule(expression, wrapped, scheduleOptions);
+        this.jobs.set(name, internal);
+        if (options.runOnRegister) {
+            // Don't await — register is sync from the caller's perspective
+            void wrapped();
+        }
+    }
+    /** Cancel + drop a job by name. Returns true когда removed, false absent. */
+    cancel(name) {
+        const job = this.jobs.get(name);
+        if (!job)
+            return false;
+        job.task.stop();
+        this.jobs.delete(name);
+        return true;
+    }
+    /** Stop + drop ALL jobs. Safe to call on an empty scheduler. */
+    cancelAll() {
+        for (const job of this.jobs.values()) {
+            job.task.stop();
+        }
+        this.jobs.clear();
+    }
+    /** Snapshot of all registered jobs. Sorted by name for stable output. */
+    list() {
+        const out = [];
+        for (const [name, job] of this.jobs) {
+            out.push({
+                name,
+                expression: job.expression,
+                scheduledAt: job.scheduledAt,
+                lastRunAt: job.lastRunAt,
+                lastDurationMs: job.lastDurationMs,
+                runs: job.runs,
+                failures: job.failures,
+                running: job.running,
+            });
+        }
+        return out.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /** Lookup a single job's stats. Returns null when absent. */
+    stats(name) {
+        const job = this.jobs.get(name);
+        if (!job)
+            return null;
+        return {
+            name,
+            expression: job.expression,
+            scheduledAt: job.scheduledAt,
+            lastRunAt: job.lastRunAt,
+            lastDurationMs: job.lastDurationMs,
+            runs: job.runs,
+            failures: job.failures,
+            running: job.running,
+        };
+    }
+}
+/**
+ * Standalone helper для callers that only want one-off validation
+ * without creating a scheduler. Mirrors node-cron's `validate()` so
+ * callers don't need to import node-cron directly.
+ */
+export function isValidCronExpression(expression) {
+    return cron.validate(expression);
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/core/denial-tracking/index.js

@@ -0,0 +1,8 @@
+/**
+ * Public re-exports for the denial-tracking surface. Engine adapter
+ * code imports from here so we can move internals around (e.g. split
+ * the diagnostics probe into a sibling file) without churning every
+ * call site.
+ */
+export { DenialTrackingState, buildDenialContext, canonicalArgHash, DENIAL_TRACKING_MAX_ENTRIES, DENIAL_REMINDER_THRESHOLD, DENIAL_ARGS_SUMMARY_BYTES, } from './state.js';
+//# sourceMappingURL=index.js.map