qlogicagent 0.2.1 → 0.4.0

package/dist/orchestration/memory-flush-policy.js

@@ -1,85 +0,0 @@
-export function hasAlreadyFlushedForCurrentCompaction(entry) {
-    const compactionCount = entry.compactionCount ?? 0;
-    const lastFlushAt = entry.memoryFlushCompactionCount;
-    return typeof lastFlushAt === "number" && lastFlushAt === compactionCount;
-}
-export function shouldRunMemoryFlush(params) {
-    if (!params.entry) {
-        return false;
-    }
-    const override = params.tokenCount;
-    const overrideTokens = typeof override === "number" && Number.isFinite(override) && override > 0
-        ? Math.floor(override)
-        : undefined;
-    const totalTokens = overrideTokens ?? params.resolveFreshSessionTotalTokens(params.entry);
-    if (!totalTokens || totalTokens <= 0) {
-        return false;
-    }
-    const contextWindow = Math.max(1, Math.floor(params.contextWindowTokens));
-    const reserveTokens = Math.max(0, Math.floor(params.reserveTokensFloor));
-    const softThreshold = Math.max(0, Math.floor(params.softThresholdTokens));
-    const threshold = Math.max(0, contextWindow - reserveTokens - softThreshold);
-    if (threshold <= 0 || totalTokens < threshold) {
-        return false;
-    }
-    if (hasAlreadyFlushedForCurrentCompaction(params.entry)) {
-        return false;
-    }
-    return true;
-}
-export function resolveMemoryFlushReadPlan(params) {
-    const canAttemptFlush = params.memoryFlushWritable && !params.isHeartbeat && !params.isCli;
-    const flushThreshold = params.contextWindowTokens - params.reserveTokensFloor - params.softThresholdTokens;
-    const shouldReadTranscriptForOutput = canAttemptFlush &&
-        params.hasSessionEntry &&
-        params.hasFreshPersistedPromptTokens &&
-        typeof params.promptTokenEstimate === "number" &&
-        Number.isFinite(params.promptTokenEstimate) &&
-        flushThreshold > 0 &&
-        (params.persistedPromptTokens ?? 0) + params.promptTokenEstimate >=
-            flushThreshold - params.transcriptOutputReadBufferTokens;
-    const shouldReadTranscript = Boolean(canAttemptFlush &&
-        params.hasSessionEntry &&
-        (!params.hasFreshPersistedPromptTokens || shouldReadTranscriptForOutput));
-    const shouldCheckTranscriptSizeForForcedFlush = Boolean(canAttemptFlush &&
-        params.hasSessionEntry &&
-        Number.isFinite(params.forceFlushTranscriptBytes) &&
-        params.forceFlushTranscriptBytes > 0);
-    return {
-        canAttemptFlush,
-        flushThreshold,
-        shouldReadTranscriptForOutput,
-        shouldReadTranscript,
-        shouldCheckTranscriptSizeForForcedFlush,
-        shouldReadSessionLog: shouldReadTranscript || shouldCheckTranscriptSizeForForcedFlush,
-    };
-}
-export function resolveMemoryFlushProjection(params) {
-    const shouldForceFlushByTranscriptSize = typeof params.transcriptByteSize === "number" &&
-        params.transcriptByteSize >= params.forceFlushTranscriptBytes;
-    const hasReliableTranscriptPromptTokens = typeof params.transcriptPromptTokens === "number" &&
-        Number.isFinite(params.transcriptPromptTokens) &&
-        params.transcriptPromptTokens > 0;
-    const shouldPersistTranscriptPromptTokens = hasReliableTranscriptPromptTokens &&
-        (!params.hasFreshPersistedPromptTokens ||
-            (params.transcriptPromptTokens ?? 0) > (params.persistedPromptTokens ?? 0));
-    const promptTokensSnapshot = Math.max(params.hasFreshPersistedPromptTokens ? (params.persistedPromptTokens ?? 0) : 0, hasReliableTranscriptPromptTokens ? (params.transcriptPromptTokens ?? 0) : 0);
-    const hasFreshPromptTokensSnapshot = promptTokensSnapshot > 0 &&
-        (params.hasFreshPersistedPromptTokens || hasReliableTranscriptPromptTokens);
-    const projectedTokenCount = hasFreshPromptTokensSnapshot
-        ? params.resolveEffectivePromptTokens(promptTokensSnapshot, params.transcriptOutputTokens, params.promptTokenEstimate)
-        : undefined;
-    const tokenCountForFlush = typeof projectedTokenCount === "number" &&
-        Number.isFinite(projectedTokenCount) &&
-        projectedTokenCount > 0
-        ? projectedTokenCount
-        : undefined;
-    return {
-        shouldForceFlushByTranscriptSize,
-        shouldPersistTranscriptPromptTokens,
-        promptTokensSnapshot,
-        hasFreshPromptTokensSnapshot,
-        projectedTokenCount,
-        tokenCountForFlush,
-    };
-}

package/dist/orchestration/memory-provider.d.ts

@@ -1,14 +0,0 @@
-import { MEMORY_OBSERVATION_HOOK_VALUES, type MemoryObservationHook, MEMORY_OBSERVATION_SOURCE_VALUES, type MemoryObservationSource, MEMORY_WRITE_ACCESS_VALUES, type MemoryWriteAccess } from "qlogicagent-runtime-contracts";
-export { MEMORY_OBSERVATION_HOOK_VALUES, type MemoryObservationHook, MEMORY_OBSERVATION_SOURCE_VALUES, type MemoryObservationSource, MEMORY_WRITE_ACCESS_VALUES, type MemoryWriteAccess, };
-export interface MemoryProviderLifecycleInvocation {
-    hook: MemoryObservationHook;
-    source: MemoryObservationSource;
-    sessionId: string;
-    turnId?: string;
-    executionId?: string;
-    rootExecutionId?: string;
-    parentExecutionId?: string;
-    sidechainId?: string;
-    attemptId?: string;
-    writeAccess: MemoryWriteAccess;
-}

package/dist/orchestration/memory-provider.js

@@ -1,2 +0,0 @@
-import { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, } from "qlogicagent-runtime-contracts";
-export { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, };

package/dist/orchestration/parallel-tool-calls.d.ts

@@ -1,41 +0,0 @@
-export type ParallelToolCallsPreference = {
-    kind: "enabled";
-    enabled: boolean;
-} | {
-    kind: "suppressed";
-} | {
-    kind: "invalid";
-    summary: string;
-};
-export interface ToolCallLike {
-    id: string;
-    function: {
-        name: string;
-        arguments?: string;
-    };
-}
-export interface ToolCapabilityLike {
-    name: string;
-    requiresApproval?: boolean;
-    approvalMode?: string;
-    parallelSafe?: boolean;
-    serialOnly?: boolean;
-}
-export interface ToolCallBatch<TCall extends ToolCallLike> {
-    mode: "parallel" | "serial";
-    calls: TCall[];
-}
-export interface ResolveParallelToolCallSchedulingInput<TCall extends ToolCallLike, TCapability extends ToolCapabilityLike> {
-    requestedPreference?: unknown;
-    providerSupportsParallel?: boolean;
-    toolCalls: readonly TCall[];
-    toolCapabilities?: readonly TCapability[];
-}
-export interface ResolveParallelToolCallSchedulingResult<TCall extends ToolCallLike> {
-    enabled: boolean;
-    mode: "parallel" | "serial";
-    batches: Array<ToolCallBatch<TCall>>;
-    warnings: string[];
-}
-export declare function normalizeParallelToolCallsPreference(rawValue: unknown): ParallelToolCallsPreference | undefined;
-export declare function resolveParallelToolCallScheduling<TCall extends ToolCallLike, TCapability extends ToolCapabilityLike>(params: ResolveParallelToolCallSchedulingInput<TCall, TCapability>): ResolveParallelToolCallSchedulingResult<TCall>;

package/dist/orchestration/parallel-tool-calls.js

@@ -1,59 +0,0 @@
-export function normalizeParallelToolCallsPreference(rawValue) {
-    if (rawValue === undefined) {
-        return undefined;
-    }
-    if (typeof rawValue === "boolean") {
-        return { kind: "enabled", enabled: rawValue };
-    }
-    if (rawValue === null) {
-        return { kind: "suppressed" };
-    }
-    return {
-        kind: "invalid",
-        summary: typeof rawValue === "string" ? rawValue : typeof rawValue,
-    };
-}
-export function resolveParallelToolCallScheduling(params) {
-    const warnings = [];
-    const preference = normalizeParallelToolCallsPreference(params.requestedPreference);
-    const capabilityMap = new Map((params.toolCapabilities ?? []).map((capability) => [capability.name, capability]));
-    let enabled = params.providerSupportsParallel !== false;
-    if (preference?.kind === "enabled") {
-        enabled = preference.enabled && params.providerSupportsParallel !== false;
-    }
-    else if (preference?.kind === "suppressed") {
-        enabled = false;
-    }
-    else if (preference?.kind === "invalid") {
-        warnings.push(`ignoring invalid parallel_tool_calls param: ${preference.summary}`);
-    }
-    if (enabled && params.providerSupportsParallel === false) {
-        warnings.push("provider does not support parallel tool calls; downgraded to serial execution.");
-    }
-    const batches = [];
-    let currentParallelBatch = [];
-    const flushParallelBatch = () => {
-        if (currentParallelBatch.length === 0) {
-            return;
-        }
-        batches.push({ mode: "parallel", calls: currentParallelBatch });
-        currentParallelBatch = [];
-    };
-    for (const toolCall of params.toolCalls) {
-        const capability = capabilityMap.get(toolCall.function.name);
-        const mustSerialize = !enabled || capability?.requiresApproval === true || capability?.serialOnly === true || capability?.parallelSafe === false || capability?.approvalMode === "user-confirm";
-        if (mustSerialize) {
-            flushParallelBatch();
-            batches.push({ mode: "serial", calls: [toolCall] });
-            continue;
-        }
-        currentParallelBatch.push(toolCall);
-    }
-    flushParallelBatch();
-    return {
-        enabled,
-        mode: batches.some((batch) => batch.mode === "parallel" && batch.calls.length > 1) ? "parallel" : "serial",
-        batches,
-        warnings,
-    };
-}

package/dist/orchestration/prompt-cache-strategy.d.ts

@@ -1,126 +0,0 @@
-/** Retention hint passed to the provider. */
-export type CacheRetention = "none" | "short" | "long";
-/** A message in the conversation array eligible for cache marking. */
-export interface CacheableMessage {
-    role: string;
-    content?: string | unknown;
-    name?: string;
-    tool_calls?: unknown;
-    tool_call_id?: string;
-}
-/** Segment classification for stability analysis. */
-export type CacheSegmentKind = "system" | "tool-definition" | "conversation" | "recent";
-/** Configuration for the cache marking policy. */
-export interface PromptCachePolicy {
-    /** Max breakpoints the provider supports (Anthropic: 4). */
-    maxBreakpoints: number;
-    /** Cache retention hint. */
-    retention: CacheRetention;
-    /** Minimum estimated tokens in a segment to justify a breakpoint. */
-    minSegmentTokens: number;
-    /** Number of trailing messages considered "recent" (never marked). */
-    recentTailCount: number;
-    /** Whether tool-definition blocks should be treated as stable prefix. */
-    markToolDefinitions: boolean;
-}
-/** A computed breakpoint recommendation. */
-export interface CacheBreakpoint {
-    /** Zero-based index in the original message array. */
-    index: number;
-    /** Classification of the segment ending at this index. */
-    segment: CacheSegmentKind;
-    /** Estimated tokens in this segment (if estimator provided). */
-    estimatedTokens?: number;
-}
-/** Result of the cache marking analysis. */
-export interface CacheMarkingResult {
-    /** Recommended breakpoints, ordered by index ascending. */
-    breakpoints: CacheBreakpoint[];
-    /** Total estimated cacheable tokens (sum of breakpoint segments). */
-    estimatedCacheableTokens: number;
-    /** The retention hint from policy. */
-    retention: CacheRetention;
-}
-export declare const DEFAULT_PROMPT_CACHE_POLICY: PromptCachePolicy;
-/**
- * Analyse a message array and return recommended cache breakpoints.
- *
- * The algorithm:
- * 1. Classify each message into segments (system / tool-def / conversation / recent).
- * 2. Identify segment boundaries where the classification changes.
- * 3. Rank boundaries by estimated token cost (heaviest first).
- * 4. Select the top `maxBreakpoints` that meet `minSegmentTokens`.
- *
- * @param messages        The conversation message array (in order).
- * @param estimateTokens  Optional per-message token estimator. Falls back to
- *                        character-length heuristic (1 token ≈ 4 chars).
- * @param policy          Cache marking policy (uses defaults if omitted).
- */
-export declare function computeCacheBreakpoints(messages: readonly CacheableMessage[], estimateTokens?: (msg: CacheableMessage) => number, policy?: Partial<PromptCachePolicy>): CacheMarkingResult;
-/**
- * Apply cache_control markers to a mutable message array based on breakpoints.
- *
- * For each breakpoint index, the last content block of that message gets a
- * `cache_control: { type: "ephemeral" }` annotation (Anthropic format).
- * String content is promoted to a text content block array.
- *
- * This is a pure transform — it returns a new array with shallow-cloned messages.
- */
-export declare function applyCacheMarkers<T extends CacheableMessage>(messages: readonly T[], breakpoints: readonly CacheBreakpoint[]): T[];
-/**
- * Estimate the cache savings ratio for a turn.
- *
- * @param totalTokens    Total input tokens for the turn.
- * @param cacheableTokens  Tokens covered by cache breakpoints.
- * @param cacheHitRatio  Fraction of cacheable tokens actually served from cache (0–1).
- * @returns Estimated fraction of input tokens saved (0–1).
- */
-export declare function estimateCacheSavingsRatio(totalTokens: number, cacheableTokens: number, cacheHitRatio?: number): number;
-/**
- * Determine the optimal cache marker position for fork scenarios.
- *
- * CC pattern:
- * - Normal request: marker on messages[length - 1] (last message)
- * - Fork (skipCacheWrite): marker on messages[length - 2] (shared prefix point)
- *
- * This ensures all fork children produce byte-identical API request prefix up to
- * the marker, maximising cache reuse.
- */
-export declare function resolveForkCacheMarkerIndex(messagesLength: number, options?: {
-    isForkChild?: boolean;
-    skipCacheWrite?: boolean;
-}): number;
-/**
- * A cache break occurs when any property of the API request that affects
- * the prefix cache changes between requests. Track these to diagnose
- * unexpected cache misses.
- */
-export interface CacheBreakDetectionState {
-    systemHash: string | null;
-    toolsHash: string | null;
-    modelId: string | null;
-    thinkingEnabled: boolean | null;
-}
-export declare function createCacheBreakDetectionState(): CacheBreakDetectionState;
-export interface CacheBreakEvent {
-    field: "system" | "tools" | "model" | "thinking";
-    previousHash: string | null;
-    currentHash: string | null;
-}
-/**
- * Detect if a cache break has occurred by comparing current request properties
- * against the last known state.
- *
- * Returns the list of fields that changed (empty = no break).
- */
-export declare function detectCacheBreaks(state: CacheBreakDetectionState, current: {
-    systemHash: string;
-    toolsHash: string;
-    modelId: string;
-    thinkingEnabled: boolean;
-}): CacheBreakEvent[];
-/**
- * Compute a lightweight hash for cache break detection.
- * Uses DJB2 algorithm (fast, good distribution for strings).
- */
-export declare function quickHash(input: string): string;

package/dist/orchestration/prompt-cache-strategy.js

@@ -1,228 +0,0 @@
-// ============================================================
-// Prompt cache marking strategy — identify optimal breakpoints
-// in a message array for provider-level prefix caching.
-//
-// Providers like Anthropic cache message prefixes: if consecutive
-// requests share identical leading messages, the cached portion
-// skips re-tokenization and re-processing. The strategy here
-// decides WHERE to place cache breakpoints (up to maxBreakpoints)
-// to maximise prefix reuse across turns.
-// ============================================================
-// ── Defaults ────────────────────────────────────────────────
-export const DEFAULT_PROMPT_CACHE_POLICY = {
-    maxBreakpoints: 4,
-    retention: "short",
-    minSegmentTokens: 256,
-    recentTailCount: 2,
-    markToolDefinitions: true,
-};
-// ── Core strategy ───────────────────────────────────────────
-/**
- * Analyse a message array and return recommended cache breakpoints.
- *
- * The algorithm:
- * 1. Classify each message into segments (system / tool-def / conversation / recent).
- * 2. Identify segment boundaries where the classification changes.
- * 3. Rank boundaries by estimated token cost (heaviest first).
- * 4. Select the top `maxBreakpoints` that meet `minSegmentTokens`.
- *
- * @param messages        The conversation message array (in order).
- * @param estimateTokens  Optional per-message token estimator. Falls back to
- *                        character-length heuristic (1 token ≈ 4 chars).
- * @param policy          Cache marking policy (uses defaults if omitted).
- */
-export function computeCacheBreakpoints(messages, estimateTokens, policy = {}) {
-    const p = { ...DEFAULT_PROMPT_CACHE_POLICY, ...policy };
-    const estimate = estimateTokens ?? defaultTokenEstimator;
-    if (p.retention === "none" || messages.length === 0) {
-        return { breakpoints: [], estimatedCacheableTokens: 0, retention: p.retention };
-    }
-    // Classify every message
-    const recentStart = Math.max(0, messages.length - p.recentTailCount);
-    const classified = messages.map((msg, i) => ({
-        index: i,
-        kind: i >= recentStart ? "recent" : classifyMessage(msg, p),
-        tokens: estimate(msg),
-    }));
-    // Build contiguous segments by kind
-    const segments = [];
-    let current;
-    for (const entry of classified) {
-        if (!current || current.kind !== entry.kind) {
-            if (current)
-                segments.push(current);
-            current = { kind: entry.kind, startIndex: entry.index, endIndex: entry.index, tokens: entry.tokens };
-        }
-        else {
-            current.endIndex = entry.index;
-            current.tokens += entry.tokens;
-        }
-    }
-    if (current)
-        segments.push(current);
-    // Candidate breakpoints: end of each non-recent segment meeting the threshold
-    const candidates = [];
-    for (const seg of segments) {
-        if (seg.kind === "recent")
-            continue;
-        if (seg.tokens < p.minSegmentTokens)
-            continue;
-        candidates.push({
-            index: seg.endIndex,
-            segment: seg.kind,
-            estimatedTokens: seg.tokens,
-        });
-    }
-    // Rank by tokens descending, pick top N
-    candidates.sort((a, b) => (b.estimatedTokens ?? 0) - (a.estimatedTokens ?? 0));
-    const selected = candidates.slice(0, p.maxBreakpoints);
-    // Re-sort by index ascending for stable output
-    selected.sort((a, b) => a.index - b.index);
-    const estimatedCacheableTokens = selected.reduce((sum, bp) => sum + (bp.estimatedTokens ?? 0), 0);
-    return { breakpoints: selected, estimatedCacheableTokens, retention: p.retention };
-}
-/**
- * Apply cache_control markers to a mutable message array based on breakpoints.
- *
- * For each breakpoint index, the last content block of that message gets a
- * `cache_control: { type: "ephemeral" }` annotation (Anthropic format).
- * String content is promoted to a text content block array.
- *
- * This is a pure transform — it returns a new array with shallow-cloned messages.
- */
-export function applyCacheMarkers(messages, breakpoints) {
-    const bpSet = new Set(breakpoints.map((bp) => bp.index));
-    return messages.map((msg, i) => {
-        if (!bpSet.has(i))
-            return msg;
-        return injectCacheControl(msg);
-    });
-}
-/**
- * Estimate the cache savings ratio for a turn.
- *
- * @param totalTokens    Total input tokens for the turn.
- * @param cacheableTokens  Tokens covered by cache breakpoints.
- * @param cacheHitRatio  Fraction of cacheable tokens actually served from cache (0–1).
- * @returns Estimated fraction of input tokens saved (0–1).
- */
-export function estimateCacheSavingsRatio(totalTokens, cacheableTokens, cacheHitRatio = 1) {
-    if (totalTokens <= 0 || cacheableTokens <= 0)
-        return 0;
-    return Math.min(1, (cacheableTokens * Math.max(0, Math.min(1, cacheHitRatio))) / totalTokens);
-}
-// ── Helpers ─────────────────────────────────────────────────
-function classifyMessage(msg, policy) {
-    const role = msg.role;
-    if (role === "system" || role === "developer")
-        return "system";
-    if (policy.markToolDefinitions && role === "tool")
-        return "conversation";
-    // Tool-call results are part of conversation flow
-    if (msg.tool_call_id)
-        return "conversation";
-    return "conversation";
-}
-function defaultTokenEstimator(msg) {
-    const content = msg.content;
-    if (typeof content === "string")
-        return Math.ceil(content.length / 4);
-    if (Array.isArray(content)) {
-        let chars = 0;
-        for (const part of content) {
-            if (typeof part === "string")
-                chars += part.length;
-            else if (part && typeof part === "object" && "text" in part) {
-                chars += typeof part.text === "string"
-                    ? (part.text).length
-                    : 0;
-            }
-        }
-        return Math.ceil(chars / 4);
-    }
-    return 0;
-}
-function injectCacheControl(msg) {
-    const clone = { ...msg };
-    const content = clone.content;
-    if (typeof content === "string") {
-        // Promote string to text content block with cache_control
-        clone.content = [
-            { type: "text", text: content, cache_control: { type: "ephemeral" } },
-        ];
-    }
-    else if (Array.isArray(content) && content.length > 0) {
-        const newContent = content.map((part, idx) => {
-            if (idx !== content.length - 1)
-                return part;
-            if (part && typeof part === "object") {
-                return { ...part, cache_control: { type: "ephemeral" } };
-            }
-            return part;
-        });
-        clone.content = newContent;
-    }
-    return clone;
-}
-// ── CC-aligned Fork Prefix Cache ────────────────────────────
-/**
- * Determine the optimal cache marker position for fork scenarios.
- *
- * CC pattern:
- * - Normal request: marker on messages[length - 1] (last message)
- * - Fork (skipCacheWrite): marker on messages[length - 2] (shared prefix point)
- *
- * This ensures all fork children produce byte-identical API request prefix up to
- * the marker, maximising cache reuse.
- */
-export function resolveForkCacheMarkerIndex(messagesLength, options = {}) {
-    if (messagesLength <= 0)
-        return -1;
-    if (options.skipCacheWrite || options.isForkChild) {
-        // Fork children: marker goes on the shared prefix (second-to-last message)
-        return Math.max(0, messagesLength - 2);
-    }
-    // Normal: marker on last message
-    return messagesLength - 1;
-}
-export function createCacheBreakDetectionState() {
-    return { systemHash: null, toolsHash: null, modelId: null, thinkingEnabled: null };
-}
-/**
- * Detect if a cache break has occurred by comparing current request properties
- * against the last known state.
- *
- * Returns the list of fields that changed (empty = no break).
- */
-export function detectCacheBreaks(state, current) {
-    const events = [];
-    if (state.systemHash !== null && state.systemHash !== current.systemHash) {
-        events.push({ field: "system", previousHash: state.systemHash, currentHash: current.systemHash });
-    }
-    if (state.toolsHash !== null && state.toolsHash !== current.toolsHash) {
-        events.push({ field: "tools", previousHash: state.toolsHash, currentHash: current.toolsHash });
-    }
-    if (state.modelId !== null && state.modelId !== current.modelId) {
-        events.push({ field: "model", previousHash: state.modelId, currentHash: current.modelId });
-    }
-    if (state.thinkingEnabled !== null && state.thinkingEnabled !== current.thinkingEnabled) {
-        events.push({ field: "thinking", previousHash: String(state.thinkingEnabled), currentHash: String(current.thinkingEnabled) });
-    }
-    // Update state
-    state.systemHash = current.systemHash;
-    state.toolsHash = current.toolsHash;
-    state.modelId = current.modelId;
-    state.thinkingEnabled = current.thinkingEnabled;
-    return events;
-}
-/**
- * Compute a lightweight hash for cache break detection.
- * Uses DJB2 algorithm (fast, good distribution for strings).
- */
-export function quickHash(input) {
-    let hash = 5381;
-    for (let i = 0; i < input.length; i++) {
-        hash = ((hash << 5) + hash + input.charCodeAt(i)) | 0;
-    }
-    return (hash >>> 0).toString(36);
-}

package/dist/orchestration/reactive-compact.d.ts

@@ -1,73 +0,0 @@
-/**
- * Reactive Compact — Emergency context compression when API returns prompt-too-long.
- *
- * Aligned with Claude Code's reactive compact chain:
- * 1. API 413 → withhold error → attempt reactive compact → retry
- * 2. Only one reactive compact attempt per turn (prevent infinite loops)
- * 3. Falls back to abort if compact fails
- *
- * Also handles post-compact restoration:
- * - Todo list re-injection
- * - Skill context re-injection
- * - Tool delta re-injection (new/removed tools since last compact)
- */
-export interface ReactiveCompactConfig {
-    /** Maximum consecutive auto-compact failures before giving up (CC: 3). */
-    maxConsecutiveFailures: number;
-    /** Minimum messages to keep after reactive compact. */
-    minMessagesAfterCompact: number;
-    /** Target token usage after compact (percentage of context window). */
-    targetUsagePercent: number;
-}
-export declare const DEFAULT_REACTIVE_COMPACT_CONFIG: ReactiveCompactConfig;
-export interface PostCompactRestorationPayload {
-    /** Current active todo list to re-inject after compact. */
-    todoList?: Array<{
-        id: number;
-        title: string;
-        status: string;
-    }>;
-    /** Active skill context (if LLM is executing a skill). */
-    activeSkillContext?: {
-        name: string;
-        step: number;
-        instructions: string;
-    };
-    /** Tool delta since last compact (tools added/removed from available set). */
-    toolDelta?: {
-        added: string[];
-        removed: string[];
-    };
-    /** Custom restoration blocks from memory hooks. */
-    customBlocks?: Array<{
-        label: string;
-        content: string;
-    }>;
-}
-/**
- * Build the restoration message to inject after a compact operation.
- * This ensures critical state survives context compression.
- */
-export declare function buildPostCompactRestorationMessage(payload: PostCompactRestorationPayload): string | null;
-export interface ReactiveCompactState {
-    /** Number of consecutive compact failures. */
-    consecutiveFailures: number;
-    /** Whether reactive compact has been attempted in this turn. */
-    attemptedThisTurn: boolean;
-    /** Last compact timestamp. */
-    lastCompactAt: number | null;
-    /** Tool names at time of last compact (for delta calculation). */
-    toolsAtLastCompact: string[];
-}
-export declare function createReactiveCompactState(): ReactiveCompactState;
-/**
- * Determine if reactive compact should be attempted.
- */
-export declare function shouldAttemptReactiveCompact(state: ReactiveCompactState, config?: ReactiveCompactConfig): boolean;
-/**
- * Calculate the tool delta since last compact.
- */
-export declare function computeToolDelta(currentTools: string[], toolsAtLastCompact: string[]): {
-    added: string[];
-    removed: string[];
-};