qlogicagent 0.5.0 → 0.5.3

package/dist/types/runtime/execution/tool-result-storage.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Tool result storage — CC toolResultStorage.ts aligned.
+ *
+ * Two-layer mechanism to manage tool result sizes:
+ *   Level 1 (per-tool): At execution time, results > DEFAULT_MAX_RESULT_SIZE_CHARS
+ *           are persisted to disk and replaced with preview references.
+ *   Level 2 (per-message budget): Before API call, aggregate tool results in
+ *           each group (consecutive tool messages between assistant messages)
+ *           are checked against MAX_TOOL_RESULTS_PER_MESSAGE_CHARS. The largest
+ *           fresh results are persisted until under budget.
+ *
+ * ContentReplacementState tracks decisions across turns for prompt cache
+ * stability — once a tool result's fate is decided (replaced or not), the
+ * decision is frozen for the remainder of the conversation.
+ *
+ * CC reference: src/utils/toolResultStorage.ts
+ * Zero imports from express/pg/ioredis/ws.
+ */
+export declare const TOOL_RESULTS_SUBDIR = "tool-results";
+/** XML tag wrapping persisted output previews (CC PERSISTED_OUTPUT_TAG) */
+export declare const PERSISTED_OUTPUT_TAG = "<persisted-output>";
+export declare const PERSISTED_OUTPUT_CLOSING_TAG = "</persisted-output>";
+/** Marker injected by microcompact when clearing old tool results (CC parity) */
+export declare const TOOL_RESULT_CLEARED_MESSAGE = "[Old tool result content cleared]";
+/**
+ * Per-conversation-thread state for the aggregate tool result budget.
+ * State must be stable to preserve prompt cache:
+ *   - seenIds: tool_call_ids that have passed through the budget check (replaced
+ *     or not). Once seen, a result's fate is frozen for the conversation.
+ *   - replacements: subset of seenIds that were persisted to disk and
+ *     replaced with previews, mapped to the exact preview string.
+ *     Re-application is a Map lookup — no file I/O, byte-identical.
+ *
+ * CC reference: ContentReplacementState
+ */
+export type ContentReplacementState = {
+    seenIds: Set<string>;
+    replacements: Map<string, string>;
+};
+export type PersistedToolResult = {
+    filepath: string;
+    originalSize: number;
+    preview: string;
+    hasMore: boolean;
+};
+export declare function createContentReplacementState(): ContentReplacementState;
+export declare function generatePreview(content: string, maxBytes: number): {
+    preview: string;
+    hasMore: boolean;
+};
+export declare function persistToolResult(content: string, toolCallId: string, sessionId: string): Promise<PersistedToolResult | null>;
+/**
+ * Build a reference message for large tool results (CC buildLargeToolResultMessage parity).
+ */
+export declare function buildLargeToolResultMessage(result: PersistedToolResult): string;
+/**
+ * If content exceeds threshold, persist to disk and return a preview reference.
+ * Falls back to hard truncation if persistence fails.
+ * Called at tool execution time in streaming-tool-executor.ts.
+ */
+export declare function maybePersistLargeToolResult(content: string, toolCallId: string, sessionId: string, threshold?: number): Promise<string>;
+interface MessageLike {
+    role: string;
+    content?: string | unknown;
+    tool_call_id?: string;
+}
+/**
+ * Enforce per-message aggregate budget on tool results.
+ * CC enforceToolResultBudget parity.
+ *
+ * For each group of tool messages whose content together exceeds
+ * the per-message limit, the largest FRESH (never-before-seen) results
+ * are persisted to disk and replaced with previews.
+ *
+ * State is tracked by tool_call_id: once a result is seen, its fate is
+ * frozen. Previously-replaced results get the same replacement re-applied
+ * (no I/O, byte-identical). Previously-unreplaced results are never
+ * replaced later (would break prompt cache).
+ *
+ * @param state — MUTATED in place (seenIds and replacements updated)
+ * @returns messages with replacements applied + count of new replacements
+ */
+export declare function enforceToolResultBudget(messages: MessageLike[], state: ContentReplacementState, sessionId: string, limit?: number): Promise<{
+    messages: MessageLike[];
+    newlyReplacedCount: number;
+}>;
+export {};

package/dist/types/runtime/hooks/context-compression.d.ts

@@ -0,0 +1,61 @@
+import { ContextEngineRegistry, type CompressibleMessage, type CompressionResult, type CompressionStrategy, type AsyncCompressionStrategy, type SummarizeFn } from "../../orchestration/index.js";
+import type { HookRegistry } from "./hook-registry.js";
+import type { RuntimeLogger } from "./hook-registry.js";
+import type { LLMTransport } from "../../llm/transport.js";
+/** Rough token estimate: ~4 chars per token for mixed CJK/English. */
+export declare function estimateTokens(msg: CompressibleMessage): number;
+/** Estimate total tokens for a message array. */
+export declare function estimateTotalTokens(messages: CompressibleMessage[]): number;
+export declare function getCompressionMetrics(): import("../../orchestration/context-compression.js").CompressionMetricsSnapshot;
+export declare function getContextEngineRegistry(): ContextEngineRegistry;
+/**
+ * Create a summarization callback using an injected LLM transport.
+ * For CLI mode: uses the same transport that powers the agent loop.
+ * Falls back to non-LLM summary when transport/apiKey not available.
+ */
+export declare function createSummarizeFn(log: RuntimeLogger, opts?: {
+    transport?: LLMTransport;
+    apiKey?: string;
+    model?: string;
+}): SummarizeFn;
+/** Phase 1: sync-only pipeline (ToolResultTrim + MicroCompact + SlidingWindow) */
+export declare function createSyncPipeline(): CompressionStrategy;
+/** Phase 2+3: async pipeline with LLM summarization + cache awareness */
+export declare function createAsyncPipeline(summarize: SummarizeFn, opts?: {
+    onCacheInvalidated?: (info: {
+        droppedCount: number;
+        strategy: string;
+    }) => void;
+}): AsyncCompressionStrategy;
+/** Phase 2.3: incremental compaction pipeline (for partial compact) */
+export declare function createIncrementalPipeline(summarize: SummarizeFn, opts?: {
+    preserveRecentCount?: number;
+    onCacheInvalidated?: (info: {
+        droppedCount: number;
+        strategy: string;
+    }) => void;
+}): AsyncCompressionStrategy;
+export interface CompressOptions {
+    budget?: number;
+    model?: string;
+    pipeline?: CompressionStrategy;
+    allowLlm?: boolean;
+    summarize?: SummarizeFn;
+    sessionId?: string;
+}
+/** Synchronous compression (Phase 1 only). */
+export declare function compressMessages(messages: CompressibleMessage[], opts?: CompressOptions): CompressionResult;
+/** Async compression (Phase 2+) — supports LLM summarization. */
+export declare function compressMessagesAsync(messages: CompressibleMessage[], opts: CompressOptions & {
+    summarize: SummarizeFn;
+}): Promise<CompressionResult>;
+export declare function registerDefaultContextEngine(log: RuntimeLogger, opts?: {
+    transport?: LLMTransport;
+    apiKey?: string;
+    model?: string;
+}): void;
+export declare function registerContextCompressionHook(hooks: HookRegistry, log: RuntimeLogger, opts?: {
+    transport?: LLMTransport;
+    apiKey?: string;
+    model?: string;
+}): void;

package/dist/types/runtime/hooks/hook-registry.d.ts

@@ -0,0 +1,12 @@
+import type { HookPoint, HookContextMap, HookResult, HookHandler, HookRegistration, HookRegistry } from "../../contracts/hooks.js";
+export type { HookPoint, HookContextMap, HookResult, HookHandler, HookRegistration, HookRegistry };
+/** Minimal logger interface — compatible with both pino and AgentLogger. */
+export interface RuntimeLogger {
+    info(msg: string): void;
+    info(obj: Record<string, unknown>, msg: string): void;
+    warn(msg: string): void;
+    warn(obj: Record<string, unknown>, msg: string): void;
+    debug(msg: string): void;
+    debug(obj: Record<string, unknown>, msg: string): void;
+}
+export declare function createHookRegistry(log: RuntimeLogger): HookRegistry;

package/dist/types/runtime/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { createHookRegistry, type RuntimeLogger } from "./hook-registry.js";
+export { registerMemoryHooks, createMemoryPrefetchState, type MemoryHooksDeps, type MemoryPrefetchState, MEMORY_PREFETCH_CONFIG, } from "./memory-hooks.js";
+export { registerContextCompressionHook, compressMessages } from "./context-compression.js";

package/dist/types/runtime/hooks/memory-hooks.d.ts

@@ -0,0 +1,49 @@
+import type { HookRegistry } from "../../contracts/hooks.js";
+import type { MemoryProvider } from "qlogicagent-runtime-contracts";
+export declare const MEMORY_PREFETCH_CONFIG: {
+    /** Max bytes of memory content to inject per session (CC: 60KB) */
+    readonly MAX_SESSION_BYTES: number;
+    /** Max results per recall query */
+    readonly LIMIT_PER_RECALL: 10;
+    /** Max entries in surfaced-path LRU set */
+    readonly MAX_SURFACED_ENTRIES: 100;
+};
+export interface MemoryHooksDeps {
+    /** QMemory adapter (MemoryProvider with search/health). */
+    memoryProvider?: MemoryProvider;
+    /** User ID for memory lookups. */
+    userId: string;
+    /** Logger. */
+    log: {
+        debug(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+/** Session-scoped state for dedup and byte budget (CC parity). */
+export interface MemoryPrefetchState {
+    /** Paths already surfaced this session (CC readFileState LRU parity). */
+    surfacedPaths: Set<string>;
+    /** Total bytes injected this session. */
+    sessionBytes: number;
+}
+/**
+ * Create a fresh memory prefetch state (once per session).
+ */
+export declare function createMemoryPrefetchState(): MemoryPrefetchState;
+/**
+ * Register memory lifecycle hooks on the HookRegistry.
+ *
+ * Hook points wired:
+ *   - memory.before_recall: prefetch context from qmemory (query-based)
+ *   - memory.after_recall: log recall results
+ *
+ * CC parity additions:
+ *   - LRU dedup via surfacedPaths (filterDuplicateMemoryAttachments)
+ *   - Session byte limit (MAX_SESSION_BYTES = 60KB)
+ *   - Async prefetch (non-blocking promise, abort-aware)
+ *
+ * Returns a cleanup function to unregister.
+ */
+export declare function registerMemoryHooks(hooks: HookRegistry, deps: MemoryHooksDeps, 
+/** Shared state — pass the same object across hook re-registrations in a session. */
+prefetchState?: MemoryPrefetchState): () => void;

package/dist/types/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./session/index.js";
+export * from "./hooks/index.js";
+export * from "./execution/index.js";
+export * from "./prompt/index.js";
+export * from "./infra/index.js";

package/dist/types/runtime/infra/cleanup-registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cleanup Registry — CC cleanupRegistry.ts parity.
+ *
+ * Global registry for cleanup functions that should run during graceful shutdown.
+ * Separate from stop handling to avoid circular dependencies.
+ *
+ * Reference: claude-code src/utils/cleanupRegistry.ts
+ */
+/**
+ * Register a cleanup function to run during graceful shutdown.
+ * @param cleanupFn - Function to run during cleanup (can be sync or async)
+ * @returns Unregister function that removes the cleanup handler
+ */
+export declare function registerCleanup(cleanupFn: () => Promise<void>): () => void;
+/**
+ * Run all registered cleanup functions.
+ * Used internally by graceful shutdown path.
+ */
+export declare function runCleanupFunctions(): Promise<void>;
+/**
+ * Get count of registered cleanup handlers (for diagnostics).
+ */
+export declare function getCleanupCount(): number;

package/dist/types/runtime/infra/file-watcher.d.ts

@@ -0,0 +1,72 @@
+/**
+ * File Watcher — CC filesystem change tracking parity.
+ *
+ * Fires hook events when files in the project change:
+ *   - file.changed (created/modified/deleted)
+ *   - cwd.changed (working directory switch)
+ *
+ * Uses Node.js fs.watch for project-level file monitoring.
+ * Does NOT use chokidar or other heavyweight watchers —
+ * this is a lightweight change-awareness system.
+ *
+ * Watched paths:
+ *   - .openclaw/settings.json → permission hot-reload
+ *   - INSTRUCTIONS.md / .openclaw/INSTRUCTIONS.md → instruction re-load
+ *   - configurable additional patterns
+ *
+ * Reference: claude-code file-watcher usage throughout lifecycle
+ */
+import type { HookRegistry } from "../../contracts/hooks.js";
+export interface FileWatcherDeps {
+    /** Project root directory (base for relative paths) */
+    projectRoot: string;
+    /** Session ID for hook context */
+    sessionId: string;
+    /** Hook registry for file.changed / cwd.changed events */
+    hooks: HookRegistry;
+    /** Logger */
+    log?: (msg: string) => void;
+    /** Callback to reset instruction cache when instructions change (injected, decoupled from prompt/) */
+    onInstructionCacheReset?: () => void;
+}
+export type ChangeType = "created" | "modified" | "deleted";
+export interface FileChangeEvent {
+    filePath: string;
+    changeType: ChangeType;
+    relativePath: string;
+}
+export declare class FileWatcher {
+    private watchers;
+    private deps;
+    private debounceTimers;
+    private _cwd;
+    constructor(deps: FileWatcherDeps);
+    get cwd(): string;
+    /**
+     * Start watching files.
+     * Watches each path in WATCHED_PATHS that exists on disk.
+     */
+    start(): Promise<void>;
+    /**
+     * Watch a single path. If it's a directory, watches recursively.
+     */
+    private watchPath;
+    /**
+     * Handle a file change event (debounced).
+     */
+    private handleChange;
+    /**
+     * Update the current working directory.
+     * Fires cwd.changed hook if the directory actually changed.
+     */
+    setCwd(newCwd: string): void;
+    /**
+     * Stop all watchers.
+     */
+    stop(): void;
+}
+/**
+ * Create and start a file watcher.
+ * Returns the watcher instance (call .stop() to clean up).
+ */
+export declare function createFileWatcher(deps: FileWatcherDeps): Promise<FileWatcher>;

package/dist/types/runtime/infra/index.d.ts

@@ -0,0 +1,6 @@
+export { getBudgetContinuationMessage } from "./token-budget.js";
+export { type SecureStorage, saveApiKey, loadApiKey } from "./secure-storage.js";
+export { createFileWatcher, FileWatcher } from "./file-watcher.js";
+export { TaskStore } from "./task-runtime.js";
+export { createWorktreeBackend } from "./worktree-backend.js";
+export { registerCleanup, runCleanupFunctions } from "./cleanup-registry.js";

package/dist/types/runtime/infra/secure-storage.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Secure Storage — CC secureStorage parity.
+ *
+ * Platform-aware credential persistence abstraction:
+ *   - Interface: get/set/delete with typed data
+ *   - Implementation: file-based JSON with 0o600 permissions (CC plainTextStorage parity)
+ *   - macOS Keychain / Windows Credential Manager can be added as plugins
+ *
+ * Storage layout:
+ *   ~/.openclaw/.credentials.json  — API keys, OAuth tokens
+ *
+ * Reference: claude-code-haha/src/utils/secureStorage/
+ */
+export interface SecureStorageData {
+    /** Primary API key (user-set) */
+    apiKey?: string;
+    /** OAuth tokens (if using OAuth flow) */
+    oauth?: {
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: number;
+    };
+    /** Arbitrary key-value pairs for extensibility */
+    [key: string]: unknown;
+}
+/**
+ * CC SecureStorage interface parity.
+ *
+ * Implementations may use OS keychain, encrypted file, or plain-text file.
+ * Callers should not assume any specific storage backend.
+ */
+export interface SecureStorage {
+    readonly name: string;
+    get(): Promise<SecureStorageData | null>;
+    set(data: SecureStorageData): Promise<{
+        success: boolean;
+        warning?: string;
+    }>;
+    delete(): Promise<boolean>;
+}
+/**
+ * File-based secure storage with restrictive permissions.
+ *
+ * On Unix: file created with 0o600 (owner-only read/write).
+ * On Windows: ACLs are not set (relies on user profile permissions).
+ *
+ * This matches CC's plainTextStorage.ts behavior — it's the default
+ * on Linux/Windows, and the fallback on macOS.
+ */
+export declare class FileSecureStorage implements SecureStorage {
+    readonly name = "file";
+    get(): Promise<SecureStorageData | null>;
+    set(data: SecureStorageData): Promise<{
+        success: boolean;
+        warning?: string;
+    }>;
+    delete(): Promise<boolean>;
+}
+/**
+ * Get the platform-appropriate secure storage instance.
+ *
+ * Currently returns FileSecureStorage on all platforms.
+ * macOS Keychain integration can be added by checking platform
+ * and returning a KeychainSecureStorage wrapper.
+ */
+export declare function getSecureStorage(): SecureStorage;
+/**
+ * Save an API key to secure storage.
+ */
+export declare function saveApiKey(apiKey: string): Promise<{
+    success: boolean;
+    warning?: string;
+}>;
+/**
+ * Load the stored API key (returns null if none saved).
+ */
+export declare function loadApiKey(): Promise<string | null>;
+/**
+ * Delete the stored API key.
+ */
+export declare function deleteApiKey(): Promise<boolean>;

package/dist/types/runtime/infra/task-runtime.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Task Runtime — CC framework.ts parity.
+ *
+ * Manages task lifecycle: creation, state updates, completion, cleanup.
+ * All task types (local_bash, local_agent, dream, etc.) use this framework.
+ *
+ * CC equivalent: src/utils/task/framework.ts + src/Task.ts
+ *
+ * Architecture note: CC uses React-style setAppState(prev => next). We use
+ * a simple Map-based store since we're in a subprocess (no React).
+ */
+import type { TaskState, TaskType, TaskLifecycle, PermissionRole, IsolationMode, LocalAgentTaskState, LocalBashTaskState } from "../../orchestration/task-types.js";
+import type { HookRegistry } from "../../contracts/hooks.js";
+/** Polling interval for running tasks (ms) */
+export declare const POLL_INTERVAL_MS = 1000;
+/** Display duration for killed tasks before eviction (ms) */
+export declare const STOPPED_DISPLAY_MS = 3000;
+/** Grace period for terminal tasks before eviction (ms) */
+export declare const PANEL_GRACE_MS = 30000;
+export declare function generateTaskId(type: TaskType): string;
+/**
+ * In-memory task store — replaces CC's AppState.tasks.
+ *
+ * Thread-safe for single-process use. All mutations go through
+ * updateTaskState / registerTask for consistency.
+ */
+export declare class TaskStore {
+    private tasks;
+    private listeners;
+    private hooks;
+    private sessionId;
+    /** Attach a hook registry to fire task.created / task.completed hooks. */
+    setHooks(hooks: HookRegistry, sessionId: string): void;
+    /**
+     * Register a listener for task state changes.
+     * @returns Unregister function
+     */
+    onTaskChange(listener: (taskId: string, task: TaskState | null) => void): () => void;
+    private notify;
+    /**
+     * Register a new task.
+     */
+    registerTask(task: TaskState): void;
+    /**
+     * Update a task's state via an updater function.
+     * CC equivalent: updateTaskState()
+     */
+    updateTask<T extends TaskState>(taskId: string, updater: (task: T) => T): void;
+    /**
+     * Get a task by ID.
+     */
+    getTask(taskId: string): TaskState | undefined;
+    /**
+     * Get all running tasks.
+     */
+    getRunningTasks(): TaskState[];
+    /**
+     * Get all tasks.
+     */
+    getAllTasks(): TaskState[];
+    /**
+     * Evict a terminal task from the store.
+     */
+    evictTask(taskId: string): void;
+    /**
+     * Evict all terminal tasks that have passed their grace period.
+     */
+    evictStaleTasks(graceMs?: number): void;
+}
+export declare function isTerminalLifecycle(lifecycle: TaskLifecycle): boolean;
+/**
+ * Transition a task to a terminal state.
+ */
+export declare function completeTask(store: TaskStore, taskId: string): void;
+export declare function failTask(store: TaskStore, taskId: string, error?: string): void;
+export declare function cancelTask(store: TaskStore, taskId: string): void;
+/**
+ * Create and register a local agent task.
+ */
+export declare function createLocalAgentTask(store: TaskStore, opts: {
+    agentName: string;
+    systemPrompt: string;
+    allowedTools?: string[];
+    parentTaskId?: string;
+    tokenBudget?: number;
+    maxTurns?: number;
+    permissionRole?: PermissionRole;
+    isolation?: IsolationMode;
+    worktreeBranch?: string;
+}): LocalAgentTaskState;
+/**
+ * Create and register a local bash task.
+ */
+export declare function createLocalBashTask(store: TaskStore, opts: {
+    command: string;
+    cwd: string;
+    parentTaskId?: string;
+    label?: string;
+}): LocalBashTaskState;
+/**
+ * Build a task notification message in CC's XML format.
+ * This is injected into the conversation as context for the model.
+ */
+export declare function buildTaskNotification(task: TaskState, summary: string): string;
+/**
+ * Get the global task store singleton.
+ */
+export declare function getTaskStore(): TaskStore;

package/dist/types/runtime/infra/token-budget.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Sub-agent Token Budget Enforcer — CC-aligned budget limits.
+ *
+ * Prevents sub-agents from consuming infinite tokens by:
+ *   1. Per-task token budget (from TaskStateBase.tokenBudget)
+ *   2. Session-level aggregate budget (all tasks combined)
+ *   3. Budget continuation messages (CC tokenBudget.ts pattern)
+ *   4. Graceful degradation (warn → force-stop, never hard-crash)
+ *
+ * CC reference: utils/tokenBudget.ts, main.tsx --max-budget-usd / --task-budget
+ *
+ * Key difference from CC: We track prompt + completion tokens (not USD).
+ * CC has no explicit per-sub-agent budget; they rely on session-level maxBudgetUsd.
+ * We add per-task enforcement to prevent a single sub-agent from exhausting the budget.
+ */
+import type { TokenUsage } from "../../agent/types.js";
+export interface BudgetConfig {
+    /** Per-task token budget (prompt + completion). 0 = unlimited. */
+    taskBudgetTokens: number;
+    /** Session-level token budget across all tasks. 0 = unlimited. */
+    sessionBudgetTokens: number;
+    /** Warning threshold as percentage (0-100). Default: 80. */
+    warningThresholdPct: number;
+}
+export interface TaskBudgetState {
+    taskId: string;
+    /** Token budget for this task. 0 = unlimited. */
+    budgetTokens: number;
+    /** Accumulated token usage for this task. */
+    usage: TokenUsage;
+    /** Whether a warning has been issued for this task. */
+    warned: boolean;
+    /** Whether this task has been force-stopped due to budget. */
+    stopped: boolean;
+}
+export interface SessionBudgetState {
+    /** Session-level budget. 0 = unlimited. */
+    budgetTokens: number;
+    /** Aggregate usage across ALL tasks in this session. */
+    totalUsage: TokenUsage;
+    /** Per-task states keyed by taskId. */
+    tasks: Map<string, TaskBudgetState>;
+}
+export type BudgetCheckResult = {
+    status: "ok";
+} | {
+    status: "warning";
+    message: string;
+    usagePct: number;
+} | {
+    status: "exceeded";
+    message: string;
+    usagePct: number;
+};
+/**
+ * Parse a token budget from user text input.
+ * CC reference: parseTokenBudget()
+ *
+ * Supports:
+ *   - Shorthand start: "+500k", "+1.5m"
+ *   - Shorthand end:   "keep working +1m."
+ *   - Verbose:         "use 500k tokens", "spend 1.5M tokens"
+ */
+export declare function parseTokenBudget(text: string): number | null;
+/**
+ * Generate a budget continuation message (CC getBudgetContinuationMessage pattern).
+ * Appended to the assistant context when approaching budget limits.
+ */
+export declare function getBudgetContinuationMessage(usagePct: number, currentTokens: number, budgetTokens: number): string;
+export declare function createSessionBudgetState(config?: Partial<BudgetConfig>): SessionBudgetState;
+export declare function registerTaskBudget(session: SessionBudgetState, taskId: string, budgetTokens: number): TaskBudgetState;
+/**
+ * Record token usage for a task and aggregate into session.
+ */
+export declare function recordTaskUsage(session: SessionBudgetState, taskId: string, usage: TokenUsage): void;
+/**
+ * Check whether a task is within its token budget.
+ */
+export declare function checkTaskBudget(session: SessionBudgetState, taskId: string, config?: Partial<BudgetConfig>): BudgetCheckResult;
+/**
+ * Get a summary of all task budgets in a session.
+ */
+export declare function getSessionBudgetSummary(session: SessionBudgetState): {
+    sessionUsed: number;
+    sessionBudget: number;
+    tasks: Array<{
+        taskId: string;
+        used: number;
+        budget: number;
+        stopped: boolean;
+    }>;
+};