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

package/dist/core/bare-mode/index.js

@@ -0,0 +1,107 @@
+/**
+ * Leak L22 (2026-05-27) — `--bare` mode predicate.
+ *
+ * Mirror of Claude Code's `--bare` flag: when active the CLI behaves
+ * like a plain LLM frontend with NO project auto-discovery. Useful for:
+ *
+ *   - headless scripting where the operator wants deterministic, repo-
+ *     independent behavior (`pugi --bare --print "..."`),
+ *   - dropping into a workspace without auto-creating `.pugi/`,
+ *   - REPL sessions that should NOT inject ambient `PUGI.md` / `CLAUDE.md`
+ *     into the model prompt,
+ *   - support / triage flows where the engineer needs the CLI to act
+ *     like a fresh install regardless of where it's invoked.
+ *
+ * Discovery surfaces gated by `isBareMode()`:
+ *
+ *   1. `PUGI.md` / `AGENTS.md` / `CLAUDE.md` / `GEMINI.md` parent-dir
+ *      walk-up (`loadTraversedMarkdown` in `core/context/markdown-traverse.ts`).
+ *   2. Workspace-root markdown context (`loadMarkdownContext` consumers).
+ *   3. Auto-init `.pugi/` scaffold on REPL boot in untouched dirs.
+ *   4. Persona / skill auto-load from `.pugi/skills/`.
+ *   5. Workspace summary (`readPugiSummary`) read on REPL session start.
+ *
+ * Activation precedence — the bare bit is "sticky" once set so any
+ * subprocess the CLI spawns inherits it without re-passing the flag:
+ *
+ *   1. Top-level `--bare` arg parsed by `parseArgs` in `runtime/cli.ts`.
+ *      The parser sets `process.env.PUGI_BARE='1'` BEFORE the dispatch
+ *      flows so callsites checking the env see the activated state.
+ *   2. `PUGI_BARE=1` env var (any value matching `/^(1|true|yes|on)$/i`).
+ *   3. Default: bare mode OFF — full auto-discovery as before.
+ *
+ * This mirrors the existing `PUGI_SKIP_SPLASH` / `PUGI_NO_AUTO_INIT`
+ * env-flag pattern so the bare module fits the rest of the runtime
+ * configuration grammar without inventing a new wire.
+ *
+ * Test surface: `apps/pugi-cli/test/bare-mode.spec.ts` exercises the
+ * env precedence, value parsing, and the explicit-set / clear helpers.
+ */
+/**
+ * Env var consulted by `isBareMode()`. Kept as an export so the spec
+ * + the runtime CLI can use the same constant — no string-typing of
+ * the wire name across modules.
+ */
+export const PUGI_BARE_ENV = 'PUGI_BARE';
+/**
+ * Truthy values recognised on the `PUGI_BARE` env. Anything else
+ * (empty string, `0`, `false`, `no`, `off`, `disabled`, undefined) is
+ * treated as bare-mode OFF. The list is intentionally short — the
+ * value is set by the CLI parser and is not customer-typed prose, so
+ * we do not need a permissive boolean coercion.
+ */
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+/**
+ * Return true when bare mode is active for the current process. Reads
+ * `process.env[PUGI_BARE_ENV]` and applies the truthy-value match.
+ *
+ * Safe to call from any module (no FS, no side-effects). The runtime
+ * cost is a single env-var lookup + lower-case + set membership, so
+ * gating hot-path callsites with `if (isBareMode()) return ...` adds
+ * effectively zero overhead in the default (non-bare) case.
+ */
+export function isBareMode(env = process.env) {
+    const raw = env[PUGI_BARE_ENV];
+    if (typeof raw !== 'string' || raw.length === 0)
+        return false;
+    return TRUTHY.has(raw.toLowerCase());
+}
+/**
+ * Explicitly activate bare mode for the current process. Called by
+ * `parseArgs` in `runtime/cli.ts` when `--bare` is seen on the command
+ * line so downstream modules (engine, REPL bootstrap, doctor probe)
+ * see a consistent activated state via `isBareMode()` regardless of
+ * whether the operator set the env var manually or used the flag.
+ *
+ * Subprocess inheritance is the reason we mutate `process.env` rather
+ * than threading a `bare: boolean` field through every call signature
+ * — every Node child_process spawn inherits `process.env` by default,
+ * so the bare bit propagates to MCP servers / hook scripts / git
+ * subprocesses without ceremony.
+ */
+export function setBareMode(env = process.env) {
+    env[PUGI_BARE_ENV] = '1';
+}
+/**
+ * Clear bare mode for the current process. Provided primarily for the
+ * spec so adjacent tests do not leak state between cases. Production
+ * code does NOT call this — bare mode is a one-shot per process.
+ */
+export function clearBareMode(env = process.env) {
+    delete env[PUGI_BARE_ENV];
+}
+/**
+ * Human-readable one-line banner printed by the dispatcher when bare
+ * mode is active and the invocation is NOT JSON-only. Kept as a single
+ * constant so the spec can assert the exact wording and downstream
+ * tools (status bars, doctor row, REPL header) stay in lockstep.
+ */
+export const BARE_MODE_BANNER = 'Pugi --bare mode: project auto-discovery disabled.';
+/**
+ * Short label rendered inside the `pugi doctor` table when bare mode
+ * is active. The doctor probe surfaces `BARE MODE` as a separate row
+ * so operators triaging "why is Pugi ignoring my PUGI.md" see the
+ * cause without grep'ing the env.
+ */
+export const BARE_MODE_DOCTOR_LABEL = 'BARE MODE';
+//# sourceMappingURL=index.js.map

package/dist/core/checkpoint/resumer.js

@@ -0,0 +1,149 @@
+/**
+ * Resumer — read SessionStore events for a session, apply the L8
+ * compact mask + the L9 rewind mask, and return the visible transcript
+ * the REPL bootstrap (or a programmatic consumer) should render.
+ *
+ * Separation of concerns:
+ *
+ *   - This module owns the READ path: list sessions, load events,
+ *     reconstruct a clean transcript stream. No writes.
+ *   - The WRITE path (append a rewind-marker, undo-rewind) lives in
+ *     `./rewinder.ts`.
+ *   - The REPL session lifecycle (lockfile, Ink mount, dispatch FSM)
+ *     stays in `core/repl/session.ts`. We do NOT spin up the REPL here.
+ *
+ * Why route resume through this module at all (vs. operators using
+ * `core/repl/store/*` directly):
+ *
+ *   The store returns RAW events. Most consumers want masked events —
+ *   i.e. the chronological list after compact-boundary masking AND
+ *   rewind-marker masking. Doing both passes inline at every call site
+ *   would scatter the mask logic; centralising it here means a future
+ *   third mask (named checkpoints? selective edit?) lands in one place.
+ */
+import { homedir } from 'node:os';
+import { applyCompactMask } from '../compact/buffer-rewriter.js';
+import { SqliteSessionStore, resolveProjectStoreDir, } from '../repl/store/index.js';
+import { applyRewindMask, findLatestActiveRewind } from './rewinder.js';
+/**
+ * Composed mask: compact-mask first (collapses summarised slices into
+ * boundary markers + kept tail), then rewind-mask (drops everything
+ * inside an active rewind range, including any compaction markers that
+ * fell inside it).
+ *
+ * Order matters: compact-mask reads `coversUntilOffset` against the
+ * RAW event indices. Running rewind-mask first would shift indices and
+ * break the compact replay anchor. The result is the chronological
+ * stream the operator should SEE, with infra rows (rewind markers)
+ * stripped.
+ */
+export function applyAllMasks(events) {
+    return applyRewindMask(applyCompactMask(events));
+}
+/**
+ * List sessions a `pugi resume` invocation could open. Uses the
+ * READ-ONLY store view so the call never takes the lockfile — safe to
+ * run alongside a live REPL. Each row carries derived metadata
+ * (`visibleEventCount`, `hasActiveRewind`) so the renderer does not
+ * need to re-walk events.
+ *
+ * Returns an empty array when the project store does not exist (no
+ * sessions ever started for this project slug). Callers surface a
+ * "nothing to resume" message in that branch.
+ */
+export async function listResumableSessions(input) {
+    const dir = input.storeDir ?? resolveProjectStoreDir(input.projectSlug, input.home ?? homedir());
+    const limit = clampLimit(input.limit ?? 10, 1, 50);
+    let view;
+    try {
+        view = await SqliteSessionStore.openReadOnly(dir);
+    }
+    catch {
+        return [];
+    }
+    try {
+        const rows = await view.list({ project: input.projectSlug, limit });
+        const out = [];
+        for (const row of rows) {
+            const events = await view.events(row.id);
+            const visible = applyAllMasks(events);
+            const latest = findLatestActiveRewind(events);
+            out.push({
+                row,
+                visibleEventCount: visible.length,
+                hasActiveRewind: latest !== null,
+                updatedAt: row.updatedAt,
+            });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        await view.close();
+    }
+}
+/**
+ * Load one session for replay. The caller (REPL bootstrap, tests,
+ * future programmatic exporters) gets BOTH the raw event stream and
+ * the masked view so it can choose its rendering strategy. Returns
+ * null when the session does not exist; throws when the store cannot
+ * be opened (the caller surfaces a one-line error).
+ *
+ * The PID lockfile contention is NOT relevant here — we use the
+ * read-only view. Concurrent writers from a live REPL are safe.
+ */
+export async function loadSessionForReplay(input) {
+    const dir = input.storeDir ?? resolveProjectStoreDir(input.projectSlug, input.home ?? homedir());
+    const view = await SqliteSessionStore.openReadOnly(dir);
+    try {
+        const row = await view.get(input.sessionId);
+        if (!row)
+            return null;
+        const rawEvents = await view.events(row.id);
+        const visibleEvents = applyAllMasks(rawEvents);
+        const latest = findLatestActiveRewind(rawEvents);
+        return {
+            row,
+            rawEvents,
+            visibleEvents,
+            hasActiveRewind: latest !== null,
+        };
+    }
+    finally {
+        await view.close();
+    }
+}
+/**
+ * Load raw + masked events through an already-open SessionStore.
+ *
+ * Used by the in-REPL `/rewind` slash handler — the live REPL already
+ * holds the writer lock, so we cannot open the read-only view in the
+ * same process. The store reference IS the active write handle; we
+ * just call `loadEvents` and run the masks.
+ *
+ * Same shape as `loadSessionForReplay` minus the read-only-view setup.
+ */
+export async function loadFromStore(store, sessionId) {
+    const row = await store.getSession(sessionId);
+    if (!row)
+        return null;
+    const rawEvents = await store.loadEvents(sessionId);
+    const visibleEvents = applyAllMasks(rawEvents);
+    const latest = findLatestActiveRewind(rawEvents);
+    return {
+        row,
+        rawEvents,
+        visibleEvents,
+        hasActiveRewind: latest !== null,
+    };
+}
+function clampLimit(raw, min, max) {
+    if (!Number.isFinite(raw) || raw < min)
+        return min;
+    if (raw > max)
+        return max;
+    return Math.floor(raw);
+}
+//# sourceMappingURL=resumer.js.map

package/dist/core/checkpoint/rewinder.js

@@ -0,0 +1,291 @@
+/**
+ * Type guard: discriminate a SessionEvent against the `rewind-marker`
+ * kind. The boundary check is strict — a malformed payload returns
+ * `false` so the replay layer can treat it as a regular (visible) event
+ * instead of trusting partial data.
+ */
+export function isRewindMarker(event) {
+    if (event.kind !== 'rewind-marker')
+        return false;
+    const p = event.payload;
+    if (p === null || typeof p !== 'object')
+        return false;
+    if (p.version !== 1)
+        return false;
+    if (p.mode !== 'rewind' && p.mode !== 'undo-rewind')
+        return false;
+    if (typeof p.toEventIndex !== 'number')
+        return false;
+    if (typeof p.fromEventIndex !== 'number')
+        return false;
+    if (typeof p.turnsRewound !== 'number')
+        return false;
+    if (p.reason !== 'manual'
+        && p.reason !== 'to-event'
+        && p.reason !== 'interactive'
+        && p.reason !== 'undo') {
+        return false;
+    }
+    return true;
+}
+/**
+ * Append one `rewind-marker` event to the SessionStore. Returns the
+ * SessionEvent we wrote so the caller can echo it into the in-memory
+ * transcript without a re-read. Throws on store error so the caller
+ * surfaces the failure inline.
+ */
+export async function appendRewindMarker(input) {
+    const ts = (input.now ?? (() => Date.now()))();
+    const payload = {
+        version: 1,
+        mode: input.mode ?? 'rewind',
+        toEventIndex: input.toEventIndex,
+        fromEventIndex: input.fromEventIndex,
+        turnsRewound: input.turnsRewound,
+        reason: input.reason,
+    };
+    const event = {
+        t: ts,
+        kind: 'rewind-marker',
+        payload,
+    };
+    await input.store.appendEvent(event);
+    return event;
+}
+/**
+ * Apply rewind masking to a chronological event list. Pure function —
+ * returns a new array with the masked events stripped. The marker
+ * events themselves are stripped too (they are infrastructure, not
+ * conversation rows); the renderer surfaces the rewind banner via a
+ * separate informational payload, NOT by leaving the marker in the
+ * transcript.
+ *
+ * Algorithm (matched-pair cancellation):
+ *
+ *   1. Walk events newest-to-oldest. Maintain an integer `undoBalance`
+ *      that counts the unmatched 'undo-rewind' markers we have seen.
+ *   2. When we hit an 'undo-rewind' marker, increment `undoBalance` —
+ *      it will cancel the next older 'rewind' marker.
+ *   3. When we hit a 'rewind' marker:
+ *      - If `undoBalance > 0`: decrement (the undo cancels this
+ *        rewind). The marker AND the events in its masked range stay
+ *        visible — the undo restored them.
+ *      - Otherwise: record the marker's `[toEventIndex+1 ..
+ *        fromEventIndex]` range as masked.
+ *   4. After the walk, return every event whose index is NOT inside an
+ *      active masked range AND that is not itself a rewind-marker.
+ *
+ * Why not just look at the latest marker:
+ *   The operator can rewind, then rewind again, then undo-rewind once.
+ *   The newest rewind should still apply; only the innermost rewind is
+ *   cancelled by the undo. Matched-pair walking handles every
+ *   stack-depth without special-casing.
+ */
+export function applyRewindMask(events) {
+    // Pass 1: walk newest-to-oldest, collect active masked ranges.
+    let undoBalance = 0;
+    // Each range is half-open [start, end] inclusive on both ends so the
+    // membership check below stays a simple two-integer comparison.
+    const maskedRanges = [];
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const ev = events[i];
+        if (!isRewindMarker(ev))
+            continue;
+        if (ev.payload.mode === 'undo-rewind') {
+            undoBalance += 1;
+            continue;
+        }
+        // mode === 'rewind'
+        if (undoBalance > 0) {
+            undoBalance -= 1;
+            continue;
+        }
+        // Active rewind — mask everything strictly AFTER toEventIndex and
+        // strictly BEFORE the marker itself. The marker (index === i) is
+        // dropped via the rewind-marker kind filter below.
+        const start = ev.payload.toEventIndex + 1;
+        const end = i - 1;
+        if (end >= start) {
+            maskedRanges.push({ start, end });
+        }
+    }
+    // Pass 2: emit only events that are NOT inside any masked range and
+    // are NOT themselves rewind-markers. Linear scan with a sorted-ranges
+    // membership check would be faster for very large logs, but the
+    // typical transcript is in the hundreds of events — O(N*M) here with
+    // M = number of rewinds ever appended stays well under a millisecond.
+    const out = [];
+    for (let i = 0; i < events.length; i += 1) {
+        const ev = events[i];
+        if (isRewindMarker(ev))
+            continue;
+        let masked = false;
+        for (const range of maskedRanges) {
+            if (i >= range.start && i <= range.end) {
+                masked = true;
+                break;
+            }
+        }
+        if (!masked)
+            out.push(ev);
+    }
+    return out;
+}
+/**
+ * Walk events oldest-to-newest and return the indices of the last `n`
+ * operator turns (`kind === 'user'`) — used by `/rewind N` to translate
+ * "drop the last 3 turns" into a concrete `toEventIndex`.
+ *
+ * Visibility is computed via `applyRewindMask`-aware indexing: the
+ * caller supplies the FULL event list (incl. existing markers) and we
+ * walk only the visible subset so a follow-up rewind on top of an
+ * existing rewind operates on what the operator currently SEES, not the
+ * full on-disk history.
+ *
+ * Returns the index of the event that should become the new
+ * `toEventIndex` — i.e. the event *immediately before* the Nth turn
+ * boundary, counting from the end. When `n` exceeds the visible turn
+ * count, returns `-1` (rewind everything).
+ */
+export function pickRewindTargetForTurns(events, turnsToDrop) {
+    if (turnsToDrop <= 0) {
+        // No-op — return the last index unchanged so the caller can detect
+        // the noop and emit a sensible message.
+        return { toEventIndex: events.length - 1, turnsRewound: 0 };
+    }
+    const visible = applyRewindMask(events);
+    // Walk visible newest-to-oldest, count user turns.
+    const userTurnVisibleIndices = [];
+    for (let i = visible.length - 1; i >= 0; i -= 1) {
+        if (visible[i].kind === 'user')
+            userTurnVisibleIndices.push(i);
+        if (userTurnVisibleIndices.length >= turnsToDrop + 1)
+            break;
+    }
+    const turnsAvailable = userTurnVisibleIndices.length;
+    if (turnsAvailable < turnsToDrop) {
+        // Fewer turns than asked — rewind everything visible.
+        return { toEventIndex: -1, turnsRewound: turnsAvailable };
+    }
+    if (turnsAvailable === turnsToDrop) {
+        // Drop ALL visible turns — anchor at -1 inside the visible list
+        // (i.e. before the first visible event). Translate back to an
+        // index in the full event list by picking the position right
+        // before the oldest visible event.
+        const oldestVisibleIdx = visible.length > 0 ? indexInFull(events, visible[0]) : -1;
+        return { toEventIndex: oldestVisibleIdx - 1, turnsRewound: turnsToDrop };
+    }
+    // `userTurnVisibleIndices` collected user turns newest-first. The
+    // OLDEST turn the operator wants to drop sits at index
+    // `turnsToDrop - 1` of that array (the Nth most recent). The new
+    // `toEventIndex` is the visible event RIGHT BEFORE that turn — that
+    // becomes the last visible row after the rewind. The N most-recent
+    // turns + everything between them get masked.
+    const cutVisibleIdx = userTurnVisibleIndices[turnsToDrop - 1];
+    // Pick the event one slot before the cut as the new toEventIndex.
+    const anchorVisibleIdx = cutVisibleIdx - 1;
+    if (anchorVisibleIdx < 0) {
+        return { toEventIndex: -1, turnsRewound: turnsToDrop };
+    }
+    const anchorEvent = visible[anchorVisibleIdx];
+    const toEventIndex = indexInFull(events, anchorEvent);
+    return { toEventIndex, turnsRewound: turnsToDrop };
+}
+/**
+ * Resolve a `--to <event-id>` argument into a concrete event index in
+ * the on-disk log. The L8 / L9 wire format does NOT mint an `id` field
+ * on individual events; the operator picks by the (1-based) line number
+ * we surface in `applyRewindMask`-aware listings. So `<event-id>` here
+ * is `"<n>"` where n is the 1-based visible index. We accept both
+ * 1-based (UI-facing) and 0-based (programmatic / tests) by checking
+ * for a leading `#`.
+ *
+ * Returns the matching index in the full event list, or null when the
+ * input is unparseable / out of range.
+ */
+export function resolveEventIdToIndex(events, eventId) {
+    const trimmed = eventId.trim();
+    if (trimmed.length === 0)
+        return null;
+    const zeroBased = trimmed.startsWith('#');
+    const raw = zeroBased ? trimmed.slice(1) : trimmed;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return null;
+    const visible = applyRewindMask(events);
+    const visibleIdx = zeroBased ? parsed : parsed - 1;
+    if (visibleIdx < 0 || visibleIdx >= visible.length)
+        return null;
+    return indexInFull(events, visible[visibleIdx]);
+}
+/**
+ * Locate the index of `target` inside `events` by identity-then-equality.
+ * Identity hits in O(1); the equality fallback walks the array and
+ * compares the (t, kind) discriminator, which is unique-enough for the
+ * append-only log where two events at the same millisecond with the
+ * same kind would also have identical payloads.
+ */
+function indexInFull(events, target) {
+    // Identity check first — `applyRewindMask` returns elements from the
+    // input array directly, so `===` succeeds in the common path.
+    for (let i = 0; i < events.length; i += 1) {
+        if (events[i] === target)
+            return i;
+    }
+    // Fallback: compare by t + kind + payload reference. Unlikely path.
+    for (let i = 0; i < events.length; i += 1) {
+        const ev = events[i];
+        if (ev.t === target.t && ev.kind === target.kind && ev.payload === target.payload) {
+            return i;
+        }
+    }
+    return -1;
+}
+export function buildRewindPickerRows(events, limit = 10) {
+    const visible = applyRewindMask(events);
+    const rows = [];
+    let turnsAgo = 0;
+    for (let i = visible.length - 1; i >= 0 && rows.length < limit; i -= 1) {
+        const ev = visible[i];
+        if (ev.kind !== 'user')
+            continue;
+        turnsAgo += 1;
+        const payload = ev.payload;
+        const preview = typeof payload?.brief === 'string'
+            ? payload.brief.slice(0, 64)
+            : '(empty turn)';
+        rows.push({
+            eventIndex: indexInFull(events, ev),
+            visibleIndex: i + 1,
+            preview,
+            turnsAgo,
+            timestampEpochMs: ev.t,
+        });
+    }
+    return rows;
+}
+/**
+ * Find the latest active 'rewind' marker — i.e. the one that an
+ * `undo-rewind` would cancel. Walks newest-to-oldest, balancing
+ * 'undo-rewind' markers against 'rewind' markers; returns the first
+ * unmatched 'rewind' or null when every rewind has already been undone.
+ */
+export function findLatestActiveRewind(events) {
+    let undoBalance = 0;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const ev = events[i];
+        if (!isRewindMarker(ev))
+            continue;
+        if (ev.payload.mode === 'undo-rewind') {
+            undoBalance += 1;
+            continue;
+        }
+        if (undoBalance > 0) {
+            undoBalance -= 1;
+            continue;
+        }
+        return { event: ev, payload: ev.payload, index: i };
+    }
+    return null;
+}
+//# sourceMappingURL=rewinder.js.map

package/dist/core/compact/auto-trigger.js

@@ -0,0 +1,96 @@
+/**
+ * Auto-compact threshold gate.
+ *
+ * Decides whether the conversation buffer has crossed the threshold
+ * percent of the active model's context window. The check runs after
+ * every operator/persona turn before the NEXT operator input lands so
+ * the compaction completes BEFORE the model would have rejected the
+ * request with a context-overflow error.
+ *
+ * Design choices:
+ *
+ *   - Pure function. The caller passes (tokenCount, windowSize, env).
+ *     The gate returns a verdict; the session module owns the side
+ *     effect of invoking the summariser. Pure-function shape keeps the
+ *     spec exhaustive and the call site readable.
+ *
+ *   - Hysteresis: once a compaction lands, the marker resets the
+ *     baseline token count to "summary + tail" — the gate looks at the
+ *     POST-marker tokens only. This is enforced upstream by the caller
+ *     passing the post-marker count; the gate itself has no memory.
+ *
+ *   - Two env knobs:
+ *       PUGI_AUTOCOMPACT_DISABLED=1  — kill switch
+ *       PUGI_AUTOCOMPACT_THRESHOLD=N — float in (0, 1] (default 0.75)
+ *     Anything outside (0, 1] is rejected and the gate falls back to
+ *     the default. Bad input never crashes the REPL.
+ */
+/** Default trip point as a fraction of the context window. */
+export const DEFAULT_THRESHOLD = 0.75;
+/**
+ * Decide whether to fire `/compact` automatically. Pure; safe to call
+ * after every turn.
+ */
+export function evaluateAutoCompact(input) {
+    const env = input.env ?? process.env;
+    const threshold = resolveThreshold(env);
+    if (input.windowSize <= 0 || !Number.isFinite(input.windowSize)) {
+        return {
+            kind: 'skip',
+            reason: 'invalid-window',
+            tokenCount: input.tokenCount,
+            windowSize: input.windowSize,
+            threshold,
+            pressure: 0,
+        };
+    }
+    if (env['PUGI_AUTOCOMPACT_DISABLED'] === '1') {
+        return {
+            kind: 'skip',
+            reason: 'disabled',
+            tokenCount: input.tokenCount,
+            windowSize: input.windowSize,
+            threshold,
+            pressure: roundPressure(input.tokenCount / input.windowSize),
+        };
+    }
+    const pressure = roundPressure(input.tokenCount / input.windowSize);
+    if (pressure >= threshold) {
+        return {
+            kind: 'fire',
+            tokenCount: input.tokenCount,
+            windowSize: input.windowSize,
+            threshold,
+            pressure,
+        };
+    }
+    return {
+        kind: 'skip',
+        reason: 'below-threshold',
+        tokenCount: input.tokenCount,
+        windowSize: input.windowSize,
+        threshold,
+        pressure,
+    };
+}
+/**
+ * Resolve the threshold from env, clamping to the (0, 1] open-closed
+ * interval. Bad input silently falls back to DEFAULT_THRESHOLD so the
+ * REPL never crashes on a malformed environment variable.
+ */
+function resolveThreshold(env) {
+    const raw = env['PUGI_AUTOCOMPACT_THRESHOLD'];
+    if (!raw)
+        return DEFAULT_THRESHOLD;
+    const parsed = Number.parseFloat(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 1) {
+        return DEFAULT_THRESHOLD;
+    }
+    return parsed;
+}
+function roundPressure(raw) {
+    if (!Number.isFinite(raw) || raw < 0)
+        return 0;
+    return Math.round(raw * 1000) / 1000;
+}
+//# sourceMappingURL=auto-trigger.js.map