token-pilot 0.19.2 → 0.23.0

package/dist/core/event-log.js

@@ -0,0 +1,190 @@
+/**
+ * Phase 6 subtasks 6.1 + 6.2 — hook-events JSONL log.
+ *
+ * Writes to `<projectRoot>/.token-pilot/hook-events.jsonl` with the
+ * schema specified in TP-c2a acceptance:
+ *
+ *   { ts, session_id, agent_type, agent_id, event, file, lines,
+ *     estTokens, summaryTokens, savedTokens }
+ *
+ * Rotation: when the current file grows past `ROTATION_THRESHOLD_BYTES`
+ * (10 MB), it is renamed to `hook-events.<unix-ms>.jsonl` and a new
+ * empty file begins.
+ *
+ * Retention: `applyRetention` deletes rotated files older than
+ * `RETENTION_MAX_AGE_DAYS` (30 days) and trims the directory down to
+ * `RETENTION_MAX_TOTAL_BYTES` (100 MB) by removing the oldest archives
+ * first. The current file is never deleted.
+ *
+ * Legacy coexistence: the old `.token-pilot/hook-denied.jsonl` is left
+ * in place — this module writes only to the new file.
+ */
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+export const ROTATION_THRESHOLD_BYTES = 10_000_000;
+export const RETENTION_MAX_AGE_DAYS = 30;
+export const RETENTION_MAX_TOTAL_BYTES = 100_000_000;
+const CURRENT_FILE = "hook-events.jsonl";
+const ARCHIVE_RE = /^hook-events\.\d+\.jsonl$/;
+export function eventLogDir(projectRoot) {
+    return join(projectRoot, ".token-pilot");
+}
+export function currentLogPath(projectRoot) {
+    return join(eventLogDir(projectRoot), CURRENT_FILE);
+}
+// ─── pure: rotation predicate ───────────────────────────────────────────────
+/**
+ * Decide whether the current log file has grown past the rotation
+ * threshold and should be archived before the next append.
+ */
+export function shouldRotate(stat, thresholdBytes = ROTATION_THRESHOLD_BYTES) {
+    return stat.size >= thresholdBytes;
+}
+// ─── pure: retention policy ─────────────────────────────────────────────────
+/**
+ * Given the full list of archive files with their mtime + size, return
+ * the subset whose paths should be deleted to satisfy:
+ *   (a) maxAgeDays — delete anything older
+ *   (b) maxTotalBytes — delete oldest first until total fits
+ *
+ * `now` is passed in to keep the function deterministic for tests.
+ */
+export function retentionDeletions(files, now, maxAgeDays = RETENTION_MAX_AGE_DAYS, maxTotalBytes = RETENTION_MAX_TOTAL_BYTES) {
+    const toDelete = new Set();
+    const maxAgeMs = maxAgeDays * 86_400_000;
+    // (a) age-based
+    const survivors = [];
+    for (const f of files) {
+        if (now.getTime() - f.mtime.getTime() > maxAgeMs) {
+            toDelete.add(f.path);
+        }
+        else {
+            survivors.push(f);
+        }
+    }
+    // (b) size-based — delete oldest first from survivors until cap is met
+    const totalSize = survivors.reduce((sum, f) => sum + f.size, 0);
+    if (totalSize > maxTotalBytes) {
+        const byOldest = [...survivors].sort((a, b) => a.mtime.getTime() - b.mtime.getTime());
+        let trimmed = totalSize;
+        for (const f of byOldest) {
+            if (trimmed <= maxTotalBytes)
+                break;
+            toDelete.add(f.path);
+            trimmed -= f.size;
+        }
+    }
+    return [...toDelete];
+}
+// ─── FS wrappers ────────────────────────────────────────────────────────────
+async function ensureLogDir(projectRoot) {
+    await fs.mkdir(eventLogDir(projectRoot), { recursive: true });
+}
+async function rotateIfNeeded(projectRoot, thresholdBytes = ROTATION_THRESHOLD_BYTES) {
+    const current = currentLogPath(projectRoot);
+    let stat;
+    try {
+        const s = await fs.stat(current);
+        stat = { size: s.size };
+    }
+    catch {
+        return; // no current file → nothing to rotate
+    }
+    if (!shouldRotate(stat, thresholdBytes))
+        return;
+    const archivePath = join(eventLogDir(projectRoot), `hook-events.${Date.now()}.jsonl`);
+    try {
+        await fs.rename(current, archivePath);
+    }
+    catch {
+        // Rename raced with another process; caller will just append onto
+        // whichever file now exists.
+    }
+}
+/**
+ * Append one event to the current log file. Rotates first if the
+ * current file has reached the threshold. Never throws — a failure
+ * here must not break hook dispatch.
+ */
+export async function appendEvent(projectRoot, event) {
+    try {
+        await ensureLogDir(projectRoot);
+        await rotateIfNeeded(projectRoot);
+        const line = JSON.stringify(event) + "\n";
+        await fs.appendFile(currentLogPath(projectRoot), line);
+    }
+    catch {
+        /* silent — telemetry is best-effort */
+    }
+}
+/**
+ * Read all events from the current log file. Malformed JSONL lines are
+ * skipped silently (a corrupted line should not poison the whole
+ * dataset). Returns [] if the file is missing.
+ */
+export async function loadEvents(projectRoot) {
+    let raw;
+    try {
+        raw = await fs.readFile(currentLogPath(projectRoot), "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return out;
+}
+/**
+ * Enumerate all archive files (`hook-events.<ts>.jsonl`) with metadata
+ * needed by `retentionDeletions`.
+ */
+async function listArchives(projectRoot) {
+    const dir = eventLogDir(projectRoot);
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of entries) {
+        if (!ARCHIVE_RE.test(name))
+            continue;
+        const full = join(dir, name);
+        try {
+            const s = await fs.stat(full);
+            out.push({ path: full, mtime: s.mtime, size: s.size });
+        }
+        catch {
+            /* skip unreadable */
+        }
+    }
+    return out;
+}
+/**
+ * Apply age + size retention. Safe to call on startup; no-op when the
+ * directory does not exist.
+ */
+export async function applyRetention(projectRoot, now = new Date()) {
+    const archives = await listArchives(projectRoot);
+    const victims = retentionDeletions(archives, now);
+    for (const p of victims) {
+        try {
+            await fs.unlink(p);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+//# sourceMappingURL=event-log.js.map

package/dist/core/session-registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * TP-69m — session-scoped ContextRegistry.
+ *
+ * The single `ContextRegistry` lived for the MCP server process lifetime,
+ * so a restart — or the way Claude Code spawns short-lived server
+ * instances — threw away "already loaded X" knowledge. This manager keeps
+ * one registry per `session_id`, persists each to disk under
+ * `.token-pilot/context-registries/<id>.json`, and LRU-evicts cold
+ * sessions from memory.
+ *
+ * Session IDs that fail slug validation (empty, traversal, path separators)
+ * get an ephemeral registry that is never persisted — a safe fallback for
+ * callers that don't know their session_id yet.
+ */
+import { ContextRegistry } from "./context-registry.js";
+export declare const REGISTRIES_SUBDIR = ".token-pilot/context-registries";
+export interface SessionRegistryManagerOptions {
+    inMemoryCap?: number;
+}
+export declare class SessionRegistryManager {
+    private readonly projectRoot;
+    private readonly inMemoryCap;
+    /** Insertion order = LRU order (re-insert on access). */
+    private readonly live;
+    /** Ephemeral (unsafe-id / empty) registries are kept apart from the LRU. */
+    private readonly ephemeral;
+    constructor(projectRoot: string, opts?: SessionRegistryManagerOptions);
+    /**
+     * Return the registry associated with a session id, creating / loading
+     * as needed. Ephemeral for unsafe ids; otherwise LRU-cached and
+     * disk-backed.
+     */
+    getFor(sessionId: string): ContextRegistry;
+    /** Flush one session's registry to disk. Silent on failure. */
+    flush(sessionId: string): Promise<void>;
+    /** Flush every live registry. Called on server shutdown. */
+    flushAll(): Promise<void>;
+    /** LRU insertion-order snapshot of in-memory session ids (for tests). */
+    inMemoryIds(): string[];
+    private pathFor;
+    private evict;
+}
+//# sourceMappingURL=session-registry.d.ts.map

package/dist/core/session-registry.js

@@ -0,0 +1,113 @@
+/**
+ * TP-69m — session-scoped ContextRegistry.
+ *
+ * The single `ContextRegistry` lived for the MCP server process lifetime,
+ * so a restart — or the way Claude Code spawns short-lived server
+ * instances — threw away "already loaded X" knowledge. This manager keeps
+ * one registry per `session_id`, persists each to disk under
+ * `.token-pilot/context-registries/<id>.json`, and LRU-evicts cold
+ * sessions from memory.
+ *
+ * Session IDs that fail slug validation (empty, traversal, path separators)
+ * get an ephemeral registry that is never persisted — a safe fallback for
+ * callers that don't know their session_id yet.
+ */
+import { promises as fs, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ContextRegistry } from "./context-registry.js";
+export const REGISTRIES_SUBDIR = ".token-pilot/context-registries";
+const SAFE_ID_RE = /^[A-Za-z0-9._-]+$/;
+export class SessionRegistryManager {
+    projectRoot;
+    inMemoryCap;
+    /** Insertion order = LRU order (re-insert on access). */
+    live = new Map();
+    /** Ephemeral (unsafe-id / empty) registries are kept apart from the LRU. */
+    ephemeral = new Map();
+    constructor(projectRoot, opts = {}) {
+        this.projectRoot = projectRoot;
+        this.inMemoryCap = opts.inMemoryCap ?? 8;
+    }
+    /**
+     * Return the registry associated with a session id, creating / loading
+     * as needed. Ephemeral for unsafe ids; otherwise LRU-cached and
+     * disk-backed.
+     */
+    getFor(sessionId) {
+        if (!isSafeId(sessionId)) {
+            let reg = this.ephemeral.get(sessionId);
+            if (!reg) {
+                reg = new ContextRegistry();
+                this.ephemeral.set(sessionId, reg);
+            }
+            return reg;
+        }
+        const existing = this.live.get(sessionId);
+        if (existing) {
+            // Refresh LRU position.
+            this.live.delete(sessionId);
+            this.live.set(sessionId, existing);
+            return existing;
+        }
+        const reg = new ContextRegistry();
+        // Best-effort sync load from disk — hook path cannot await.
+        const path = this.pathFor(sessionId);
+        try {
+            const raw = readFileSync(path, "utf-8");
+            reg.loadSnapshot(JSON.parse(raw));
+        }
+        catch {
+            /* no prior state, or corrupt file — start empty */
+        }
+        this.live.set(sessionId, reg);
+        this.evict();
+        return reg;
+    }
+    /** Flush one session's registry to disk. Silent on failure. */
+    async flush(sessionId) {
+        if (!isSafeId(sessionId))
+            return;
+        const reg = this.live.get(sessionId);
+        if (!reg)
+            return;
+        const path = this.pathFor(sessionId);
+        try {
+            await fs.mkdir(join(this.projectRoot, REGISTRIES_SUBDIR), {
+                recursive: true,
+            });
+            await fs.writeFile(path, JSON.stringify(reg.toSnapshot()));
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    /** Flush every live registry. Called on server shutdown. */
+    async flushAll() {
+        const ids = Array.from(this.live.keys());
+        for (const id of ids)
+            await this.flush(id);
+    }
+    /** LRU insertion-order snapshot of in-memory session ids (for tests). */
+    inMemoryIds() {
+        return Array.from(this.live.keys());
+    }
+    pathFor(sessionId) {
+        return join(this.projectRoot, REGISTRIES_SUBDIR, `${sessionId}.json`);
+    }
+    evict() {
+        while (this.live.size > this.inMemoryCap) {
+            const oldest = this.live.keys().next().value;
+            if (!oldest)
+                break;
+            // Best-effort async flush before dropping from memory.
+            void this.flush(oldest);
+            this.live.delete(oldest);
+        }
+    }
+}
+function isSafeId(id) {
+    if (!id)
+        return false;
+    return SAFE_ID_RE.test(id);
+}
+//# sourceMappingURL=session-registry.js.map

package/dist/core/session-savings.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Sum `savedTokens` for all hook-events matching a given session_id.
+ *
+ * Used by the adaptive-threshold path to estimate how much of the
+ * session's context budget has already been burned. Sync implementation
+ * because the hook process is short-lived and a blocking read is
+ * simpler than pulling in async plumbing.
+ *
+ * Silent on every error — telemetry must never break the hook.
+ */
+export declare function loadSessionSavedTokens(projectRoot: string, sessionId: string): number;
+export interface SessionStats {
+    savedTokens: number;
+    eventCount: number;
+    firstTsMs: number | null;
+    lastTsMs: number | null;
+}
+export declare function loadSessionStats(projectRoot: string, sessionId: string): SessionStats;
+//# sourceMappingURL=session-savings.d.ts.map

package/dist/core/session-savings.js

@@ -0,0 +1,60 @@
+/**
+ * Sum `savedTokens` for all hook-events matching a given session_id.
+ *
+ * Used by the adaptive-threshold path to estimate how much of the
+ * session's context budget has already been burned. Sync implementation
+ * because the hook process is short-lived and a blocking read is
+ * simpler than pulling in async plumbing.
+ *
+ * Silent on every error — telemetry must never break the hook.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+export function loadSessionSavedTokens(projectRoot, sessionId) {
+    return loadSessionStats(projectRoot, sessionId).savedTokens;
+}
+export function loadSessionStats(projectRoot, sessionId) {
+    const empty = {
+        savedTokens: 0,
+        eventCount: 0,
+        firstTsMs: null,
+        lastTsMs: null,
+    };
+    if (!sessionId)
+        return empty;
+    const path = join(projectRoot, ".token-pilot", "hook-events.jsonl");
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        return empty;
+    }
+    let savedTokens = 0;
+    let eventCount = 0;
+    let firstTsMs = null;
+    let lastTsMs = null;
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (e.session_id !== sessionId)
+                continue;
+            if (typeof e.savedTokens === "number")
+                savedTokens += e.savedTokens;
+            eventCount += 1;
+            if (typeof e.ts === "number") {
+                if (firstTsMs == null || e.ts < firstTsMs)
+                    firstTsMs = e.ts;
+                if (lastTsMs == null || e.ts > lastTsMs)
+                    lastTsMs = e.ts;
+            }
+        }
+        catch {
+            /* skip malformed */
+        }
+    }
+    return { savedTokens, eventCount, firstTsMs, lastTsMs };
+}
+//# sourceMappingURL=session-savings.js.map

package/dist/handlers/session-budget.d.ts

@@ -0,0 +1,32 @@
+/**
+ * TP-hsz — `session_budget` MCP tool.
+ *
+ * Reports *hook pressure* for the current session: the total tokens the
+ * Read-hook has suppressed so far (`savedTokens` in hook-events.jsonl)
+ * divided by a configurable reference budget. This is a proxy for "how
+ * chatty is the agent being with big files", not a measurement of the
+ * Claude Code context window itself — Token Pilot has no visibility into
+ * what the model actually has in context.
+ *
+ * The adaptive threshold curve uses this same signal to tighten when
+ * pressure is high, so `burnFraction` here matches what the hook sees.
+ * An agent that Reads many files with bounded `offset/limit` will see a
+ * low `burnFraction` even if its context is nearly full — the budget is
+ * about Token Pilot interventions, not total window occupancy.
+ */
+export interface SessionBudgetArgs {
+    sessionId: string;
+}
+export interface SessionBudgetConfig {
+    baseThreshold: number;
+    adaptiveThreshold: boolean;
+    adaptiveBudgetTokens: number;
+}
+export interface SessionBudgetResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}
+export declare function handleSessionBudget(args: SessionBudgetArgs, projectRoot: string, cfg: SessionBudgetConfig): Promise<SessionBudgetResult>;
+//# sourceMappingURL=session-budget.d.ts.map

package/dist/handlers/session-budget.js

@@ -0,0 +1,61 @@
+/**
+ * TP-hsz — `session_budget` MCP tool.
+ *
+ * Reports *hook pressure* for the current session: the total tokens the
+ * Read-hook has suppressed so far (`savedTokens` in hook-events.jsonl)
+ * divided by a configurable reference budget. This is a proxy for "how
+ * chatty is the agent being with big files", not a measurement of the
+ * Claude Code context window itself — Token Pilot has no visibility into
+ * what the model actually has in context.
+ *
+ * The adaptive threshold curve uses this same signal to tighten when
+ * pressure is high, so `burnFraction` here matches what the hook sees.
+ * An agent that Reads many files with bounded `offset/limit` will see a
+ * low `burnFraction` even if its context is nearly full — the budget is
+ * about Token Pilot interventions, not total window occupancy.
+ */
+import { loadSessionStats } from "../core/session-savings.js";
+import { computeEffectiveThreshold } from "../hooks/adaptive-threshold.js";
+export async function handleSessionBudget(args, projectRoot, cfg) {
+    const sessionId = args.sessionId ?? "";
+    const stats = loadSessionStats(projectRoot, sessionId);
+    const savedTokens = stats.savedTokens;
+    const budget = cfg.adaptiveBudgetTokens > 0 ? cfg.adaptiveBudgetTokens : 0;
+    const burnRaw = budget > 0 ? savedTokens / budget : 0;
+    const burnFraction = Math.min(1, Math.max(0, burnRaw));
+    const effectiveThreshold = computeEffectiveThreshold({
+        baseThreshold: cfg.baseThreshold,
+        sessionSavedTokens: savedTokens,
+        sessionBudgetTokens: budget,
+        enabled: cfg.adaptiveThreshold,
+    });
+    // Time-to-compact projection. Silent (null fields) when we lack data.
+    let avgSavedPerEvent = null;
+    let eventsUntilExhaustion = null;
+    if (stats.eventCount > 0 && savedTokens > 0) {
+        avgSavedPerEvent = savedTokens / stats.eventCount;
+        if (budget > 0 && avgSavedPerEvent > 0) {
+            const remaining = Math.max(0, budget - savedTokens);
+            eventsUntilExhaustion = Math.floor(remaining / avgSavedPerEvent);
+        }
+    }
+    const payload = {
+        semantics: "burnFraction is hook-suppression pressure, NOT context-window occupancy. See session-budget.ts docs.",
+        sessionId,
+        savedTokens,
+        budgetTokens: budget,
+        burnFraction: Number(burnFraction.toFixed(4)),
+        baseThreshold: cfg.baseThreshold,
+        effectiveThreshold,
+        adaptive: cfg.adaptiveThreshold,
+        eventCount: stats.eventCount,
+        avgSavedPerEvent: avgSavedPerEvent != null ? Math.round(avgSavedPerEvent) : null,
+        eventsUntilExhaustion,
+        firstEventMs: stats.firstTsMs,
+        lastEventMs: stats.lastTsMs,
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    };
+}
+//# sourceMappingURL=session-budget.js.map

package/dist/handlers/session-snapshot-persist.d.ts

@@ -0,0 +1,22 @@
+export declare const SNAPSHOT_SUBDIR = ".token-pilot/snapshots";
+export declare const LATEST_FILE = "latest.md";
+export declare const MAX_ARCHIVED_SNAPSHOTS = 10;
+export interface PersistSnapshotInput {
+    projectRoot: string;
+    body: string;
+    /** For deterministic tests; defaults to `new Date()`. */
+    now?: Date;
+}
+export interface PersistSnapshotResult {
+    archivedPath: string | null;
+    latestPath: string;
+}
+export declare function persistSnapshot(input: PersistSnapshotInput): Promise<PersistSnapshotResult>;
+export interface LoadedSnapshot {
+    body: string;
+    mtimeMs: number;
+    ageMs: number;
+    path: string;
+}
+export declare function loadLatestSnapshot(projectRoot: string): Promise<LoadedSnapshot | null>;
+//# sourceMappingURL=session-snapshot-persist.d.ts.map

package/dist/handlers/session-snapshot-persist.js

@@ -0,0 +1,76 @@
+/**
+ * TP-340 — persistence layer for session_snapshot.
+ *
+ * When an agent calls `session_snapshot` we save the rendered block to
+ *   `.token-pilot/snapshots/<iso>.md`          (archived history)
+ *   `.token-pilot/snapshots/latest.md`         (always the newest)
+ *
+ * A SessionStart hook later reads `latest.md` and surfaces a short pointer
+ * so the next Claude Code turn after compaction / `/clear` / a new window
+ * can pick the thread back up without re-hydrating context manually.
+ *
+ * Retention: keep the last `MAX_ARCHIVED_SNAPSHOTS` (oldest trimmed first).
+ */
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+export const SNAPSHOT_SUBDIR = ".token-pilot/snapshots";
+export const LATEST_FILE = "latest.md";
+export const MAX_ARCHIVED_SNAPSHOTS = 10;
+function formatIsoStamp(d) {
+    // Safe-for-filename ISO: 2026-04-18T12-00-00Z
+    return d.toISOString().replace(/:/g, "-").replace(/\..+/, "Z");
+}
+export async function persistSnapshot(input) {
+    const now = input.now ?? new Date();
+    const dir = join(input.projectRoot, SNAPSHOT_SUBDIR);
+    await fs.mkdir(dir, { recursive: true });
+    const stamp = formatIsoStamp(now);
+    const archivedPath = join(dir, `${stamp}.md`);
+    const latestPath = join(dir, LATEST_FILE);
+    await fs.writeFile(archivedPath, input.body);
+    await fs.writeFile(latestPath, input.body);
+    await trimArchive(dir);
+    return { archivedPath, latestPath };
+}
+async function trimArchive(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    const archived = entries
+        .filter((n) => n.endsWith(".md") && n !== LATEST_FILE)
+        .sort(); // ISO-stamped names sort chronologically
+    if (archived.length <= MAX_ARCHIVED_SNAPSHOTS)
+        return;
+    const excess = archived.length - MAX_ARCHIVED_SNAPSHOTS;
+    for (let i = 0; i < excess; i++) {
+        try {
+            await fs.unlink(join(dir, archived[i]));
+        }
+        catch {
+            /* best effort */
+        }
+    }
+}
+export async function loadLatestSnapshot(projectRoot) {
+    const path = join(projectRoot, SNAPSHOT_SUBDIR, LATEST_FILE);
+    try {
+        const [body, s] = await Promise.all([
+            fs.readFile(path, "utf-8"),
+            fs.stat(path),
+        ]);
+        return {
+            body,
+            mtimeMs: s.mtimeMs,
+            ageMs: Math.max(0, Date.now() - s.mtimeMs),
+            path,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=session-snapshot-persist.js.map

package/dist/hooks/adaptive-threshold.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Adaptive threshold: lower the effective denyThreshold as the Read-hook
+ * sees more suppressed-token activity in this session, so large-file reads
+ * become stricter the chattier the agent has been with big files.
+ *
+ * Piecewise curve, opt-in only:
+ *   pressure <  30% of budget → base threshold unchanged
+ *   pressure ≥  30%, < 60%    → base × 0.75
+ *   pressure ≥  60%, < 80%    → base × 0.5
+ *   pressure ≥  80%           → base × 0.3 (minimum 50 lines)
+ *
+ * Burn fraction = sessionSavedTokens / sessionBudgetTokens, where
+ * `sessionSavedTokens` is the sum of `savedTokens` entries in
+ * hook-events.jsonl for the current session_id. This is a PROXY for how
+ * aggressively the agent has been trying to pull large files, not a
+ * measurement of Claude Code's actual context-window occupancy — Token
+ * Pilot has no visibility into that. If the agent reads many files with
+ * bounded `offset/limit`, none of that contributes to the burn signal.
+ */
+export interface AdaptiveThresholdInput {
+    baseThreshold: number;
+    sessionSavedTokens: number;
+    sessionBudgetTokens: number;
+    enabled: boolean;
+}
+export declare function computeEffectiveThreshold(input: AdaptiveThresholdInput): number;
+//# sourceMappingURL=adaptive-threshold.d.ts.map