qlogicagent 2.24.9 → 2.24.11

package/dist/types/embedded/contracts.d.ts

@@ -0,0 +1,244 @@
+export interface AgentLogger {
+    info(message: string): void;
+    info(context: Record<string, unknown>, message: string): void;
+    warn(message: string): void;
+    warn(context: Record<string, unknown>, message: string): void;
+    error(message: string): void;
+    error(context: Record<string, unknown>, message: string): void;
+    debug(message: string): void;
+    debug(context: Record<string, unknown>, message: string): void;
+}
+export interface ToolCallMessage {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null;
+    tool_calls?: ToolCallMessage[];
+    tool_call_id?: string;
+    name?: string;
+    is_error?: boolean;
+    reasoning_content?: string;
+    thinkingBlocks?: Array<{
+        thinking: string;
+        signature: string;
+    }>;
+}
+export interface ToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+export interface LLMRequest {
+    model: string;
+    messages: ChatMessage[];
+    tools?: ToolDefinition[];
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "function";
+        name: string;
+    };
+    temperature?: number;
+    maxTokens?: number;
+    reasoning?: {
+        effort: "minimal" | "low" | "medium" | "high" | "xhigh";
+        includeEncryptedReasoning?: boolean;
+    };
+    maxToolCalls?: number;
+    streamRequired?: boolean;
+    promptCacheKey?: string;
+    promptCacheRetention?: "in_memory" | "24h";
+    serviceTier?: "auto" | "default" | "flex" | "priority";
+    parallelToolCalls?: boolean;
+    textVerbosity?: "low" | "medium" | "high";
+}
+export type LLMChunk = {
+    type: "delta";
+    text: string;
+} | {
+    type: "tool_call_delta";
+    index: number;
+    id?: string;
+    name?: string;
+    arguments: string;
+} | {
+    type: "reasoning_delta";
+    text: string;
+} | {
+    type: "reasoning_block_complete";
+    thinking: string;
+    signature: string;
+} | {
+    type: "usage";
+    totalPromptTokens?: number;
+    promptTokens: number;
+    completionTokens: number;
+    reasoningTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+} | {
+    type: "response_id";
+    id: string;
+} | {
+    type: "annotations";
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+} | {
+    type: "error";
+    message: string;
+} | {
+    type: "done";
+    finishReason: string;
+};
+export interface LLMTransport {
+    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
+}
+export interface ToolInvoker {
+    invoke(turnId: string, name: string, args: string, signal?: AbortSignal): Promise<{
+        result: string;
+        error?: string;
+        toolReferences?: string[];
+        imageUrls?: string[];
+        details?: Record<string, unknown>;
+    }>;
+}
+export interface TurnConfig {
+    model?: string;
+    maxRounds?: number;
+    temperature?: number;
+    contextWindowTokens?: number;
+    maxOutputTokens?: number;
+    modelMaxOutputTokens?: number;
+    maxTurns?: number;
+    maxToolCalls?: number;
+    maxConcurrentTools?: number;
+    parallelToolCalls?: boolean;
+    streamRequired?: boolean;
+    toolChoice?: "auto" | "none" | "required";
+}
+export interface TurnRequest {
+    turnId: string;
+    sessionId: string;
+    messages: ChatMessage[];
+    availableTools?: ToolDefinition[];
+    tools: ToolDefinition[];
+    systemPrompt?: string;
+    config?: TurnConfig;
+}
+export interface TokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    reasoningTokens?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}
+export type TurnEvent = {
+    type: "start";
+    turnId: string;
+    effectiveMaxRounds?: number;
+    effectiveMaxToolCalls?: number;
+} | {
+    type: "delta";
+    turnId: string;
+    text: string;
+} | {
+    type: "tool_call";
+    turnId: string;
+    callId: string;
+    name: string;
+    displayName?: string;
+    arguments: string;
+    inputSummary?: string;
+} | {
+    type: "tool_result";
+    turnId: string;
+    callId: string;
+    name: string;
+    ok: boolean;
+    error?: string;
+    outputPreview?: string;
+    durationMs?: number;
+    details?: Record<string, unknown>;
+} | {
+    type: "tool_blocked";
+    turnId: string;
+    callId: string;
+    name: string;
+    reason: string;
+} | {
+    type: "recovery";
+    turnId: string;
+    action: string;
+    detail?: string;
+} | {
+    type: "text_rollback";
+    turnId: string;
+    keepLength: number;
+    reason: string;
+} | {
+    type: "reasoning_delta";
+    turnId: string;
+    text: string;
+} | {
+    type: "annotations";
+    turnId: string;
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+} | {
+    type: "tool_use_summary";
+    turnId: string;
+    ledgerSchemaVersion: 5;
+    toolCalls: Array<Record<string, unknown>>;
+    availableToolNames: string[];
+    enabledToolNames: string[];
+    toolCallNames: string[];
+    blockedToolCalls: Array<{
+        name: string;
+        reason: string;
+    }>;
+} | {
+    type: "end";
+    turnId: string;
+    content: string;
+    turnStatus?: "completed" | "stopped";
+    taskOutcome?: "unverified";
+    usage?: TokenUsage;
+    model?: string;
+    provider?: string;
+    recoveryTrace?: Record<string, number>;
+} | {
+    type: "error";
+    turnId: string;
+    error: string;
+    code?: string;
+    usage?: TokenUsage;
+};
+export interface EmbeddedRuntimeOptions {
+    maxToolResultChars?: number;
+}
+export interface EmbeddedAgent {
+    run(request: TurnRequest, signal?: AbortSignal): AsyncGenerator<TurnEvent>;
+}
+export interface CreateEmbeddedAgentOptions {
+    llmTransport: LLMTransport;
+    toolInvoker: ToolInvoker;
+    apiKey?: string;
+    logger?: AgentLogger;
+    maxRounds?: number;
+    runtime?: EmbeddedRuntimeOptions;
+}

package/dist/types/embedded/default-runtime-ports.d.ts

@@ -0,0 +1,3 @@
+import type { AgentRuntimePorts } from "../runtime/ports/agent-runtime-ports.js";
+import type { EmbeddedRuntimeOptions } from "./contracts.js";
+export declare function createEmbeddedRuntimePorts(options?: EmbeddedRuntimeOptions): AgentRuntimePorts;

package/dist/types/embedded/embedded-tool-executor.d.ts

@@ -0,0 +1,9 @@
+import { type OpenAiToolCall } from "../runtime/ports/tool-call-contracts.js";
+import type { StreamingToolExecutorPort, StreamingToolExecutorPortConfig, ToolExecutionResultPort } from "../runtime/ports/agent-runtime-ports.js";
+export declare class EmbeddedToolExecutor implements StreamingToolExecutorPort {
+    private readonly config;
+    private readonly calls;
+    constructor(config: StreamingToolExecutorPortConfig);
+    addTool(call: OpenAiToolCall): void;
+    getRemainingResults(): AsyncIterable<ToolExecutionResultPort>;
+}

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

@@ -0,0 +1,3 @@
+import type { CreateEmbeddedAgentOptions, EmbeddedAgent } from "./contracts.js";
+export declare function createEmbeddedAgent(options: CreateEmbeddedAgentOptions): EmbeddedAgent;
+export type { AgentLogger, ChatMessage, CreateEmbeddedAgentOptions, EmbeddedAgent, EmbeddedRuntimeOptions, LLMChunk, LLMRequest, LLMTransport, ToolDefinition, ToolInvoker, TurnConfig, TurnEvent, TurnRequest, } from "./contracts.js";

package/dist/types/orchestration/error-handling/retry-loop.d.ts

@@ -27,15 +27,6 @@ export declare const DEFAULT_PERSISTENT_RETRY_CONFIG: PersistentRetryConfig;
  * CC parity: CLAUDE_CODE_UNATTENDED_RETRY
  */
 export declare function isPersistentRetryEnabled(): boolean;
-/**
- * Error class for triggering model fallback after repeated 529s.
- * CC parity: FallbackTriggeredError
- */
-export declare class FallbackTriggeredError extends Error {
-    readonly originalModel: string;
-    readonly fallbackModel: string;
-    constructor(originalModel: string, fallbackModel: string);
-}
 /**
  * Error class for when retries are exhausted and cannot continue.
  * CC parity: CannotRetryError

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

@@ -1,12 +1,10 @@
 export { buildAssistantToolCallMessage, buildToolResultMessage, type FunctionToolDefinition, } from "./tool-loop/tool-schema.js";
 export { classifyError, isRetryableCategory, type ErrorCategory, } from "./error-handling/error-classification.js";
-export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, MicroCompactStrategy, postCompactFileRecovery, type PostCompactRecoveryConfig, buildStructuredSummaryPrompt, CONTEXT_CAPSULE_MARKER, parseContextCapsule, redactCompressionSecrets, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, type AdaptiveBudgetConfig, type AsyncCompressionStrategy, type CacheAwareCompressionConfig, type CompressibleMessage, type CompressionEvent, type ContextCapsule, type ContextCompactionReceipt, type CompressionMetrics, type CompressionMetricsSnapshot, type CompressionResult, type CompressionStrategy, type CompressionTier, type ContextEngine, type HeadTailProtectionConfig, type IncrementalCompactConfig, type SummarizeFn, } from "../runtime/context/context-compression-strategies.js";
-export { snipCompactIfNeeded, type SnipResult, } from "../runtime/context/context-compression-strategies.js";
-export { applyCollapsesIfNeeded as applyContextCollapsesIfNeeded, recoverFromOverflow as recoverContextCollapseFromOverflow, createCollapseStore, type CollapseStore, type CollapseStage, } from "./context/context-collapse.js";
+export { SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, buildStructuredSummaryPrompt, CONTEXT_CAPSULE_MARKER, parseContextCapsule, redactCompressionSecrets, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, type AdaptiveBudgetConfig, type AsyncCompressionStrategy, type CacheAwareCompressionConfig, type CompressibleMessage, type CompressionEvent, type ContextCapsule, type ContextCompactionReceipt, type CompressionMetrics, type CompressionMetricsSnapshot, type CompressionResult, type CompressionStrategy, type CompressionTier, type ContextEngine, type HeadTailProtectionConfig, type SummarizeFn, } from "../runtime/context/context-compression-strategies.js";
 export { applyToolChoicePolicy, type ApplyToolChoicePolicyInput, type ApplyToolChoicePolicyResult, } from "./tool-loop/tool-choice-policy.js";
 export { repairOpenAiChatConversation, type ConversationRepairOptions, type OpenAiChatMessageLike, type OpenAiToolCall, } from "./tool-loop/conversation-repair.js";
 export { advanceToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, type RepairToolLoopStateResult, type ToolLoopRepairAction, type ToolLoopState, } from "./tool-loop/tool-loop-state.js";
-export { isForegroundSource, isTransientCapacityError, computeRetryBackoff, isPersistentRetryEnabled, FallbackTriggeredError, type PersistentRetryConfig, } from "./error-handling/retry-loop.js";
+export { isForegroundSource, isTransientCapacityError, computeRetryBackoff, isPersistentRetryEnabled, type PersistentRetryConfig, } from "./error-handling/retry-loop.js";
 export { canForkAtDepth, buildForkedMessages, buildForkPlaceholderResults, FORK_PLACEHOLDER_RESULT, FORK_SENTINEL_TAG, generateForkChildAgentId, isInForkChild, MAX_FORK_DEPTH, resolveForkChildTools, type ForkChildConfig, type ForkChildMessage, type ForkContext, type ForkResult, } from "./subagent/fork-subagent.js";
 export { getBuiltInAgent, getBuiltInAgents, isBuiltInAgent, resolveAgentToolSet, type AgentDefinition, } from "./subagent/agent-registry.js";
 export { createTaskState, type IsolationMode, type PermissionRole, type TaskType, type TaskLifecycle, type TaskState, type TaskStateBase, type LocalBashTaskState, type LocalAgentTaskState, type RemoteAgentTaskState, } from "./subagent/task-types.js";

package/dist/types/protocol/wire/acp-protocol.d.ts

@@ -215,12 +215,15 @@ export interface AcpFsWriteTextFileResult {
     bytesWritten: number;
 }
 export interface AcpUsage {
+    totalTokens: number;
     inputTokens: number;
     outputTokens: number;
-    cacheReadTokens?: number;
-    cacheWriteTokens?: number;
-    totalCost?: number;
+    thoughtTokens?: number;
+    cachedReadTokens?: number;
+    cachedWriteTokens?: number;
+    _meta?: Record<string, unknown>;
 }
+export declare const ACP_AUTHORITATIVE_USAGE_META_KEY = "xiaozhiclaw/authoritativeUsage";
 export type AcpStopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
 export interface AcpJsonRpcRequest {
     jsonrpc: "2.0";

package/dist/types/protocol/wire/index.d.ts

@@ -1,6 +1,6 @@
 export { type ChatMessage, type ChatMessageRole, type ContextAnchor, type ContextAnchorCategory, type ContextEnvelope, type LocalizedToolText, type SemanticToolCapability, type ThinkingBlock, type ToolCapabilityCategory, type ToolCallMessage, type ToolDefinition, type ToolIdentity, } from "./chat-types.js";
-export { type MediaResultType, type NotificationMethod, type NotificationMethodMap, type TurnDeltaNotification, type TurnEndNotification, type TurnMediaResultNotification, type TurnReasoningDeltaNotification, type TurnToolBlockedNotification, type TurnToolCallNotification, type TurnToolResultNotification, type WireTokenUsage, } from "./notification-payloads.js";
-export { ACP_METHODS, ACP_PROTOCOL_VERSION, isAcpJsonRpcNotification, isAcpJsonRpcRequest, isAcpJsonRpcResponse, parseAcpMessage, type AcpAgentCapabilities, type AcpConfigOptionDescriptor, type AcpContentBlock, type AcpFsReadTextFileParams, type AcpFsReadTextFileResult, type AcpFsWriteTextFileParams, type AcpFsWriteTextFileResult, type AcpHostCapabilities, type AcpInitializeParams, type AcpInitializeResult, type AcpJsonRpcError, type AcpJsonRpcMessage, type AcpJsonRpcNotification, type AcpJsonRpcRequest, type AcpJsonRpcResponse, type AcpMode, type AcpPermissionOption, type AcpPermissionRequestParams, ACP_PERMISSION_PRESENTATION_META_KEY, type AcpPermissionPresentationMetaV1, type AcpPermissionRequestResult, type AcpSessionCancelParams, type AcpSessionCloseParams, type AcpSessionMeta, type AcpSessionLoadParams, type AcpSessionModeState, type AcpSessionNewParams, type AcpSessionNewResult, type AcpSessionPromptParams, type AcpSessionPromptResult, type AcpSessionSetConfigParams, type AcpSessionSetConfigResult, type AcpStandardMethod, type AcpStopReason, type AcpUsage, } from "./acp-protocol.js";
+export { type MediaResultType, type NotificationMethod, type NotificationMethodMap, type TurnDeltaNotification, type TurnEndNotification, type TurnMediaResultNotification, type TurnReasoningDeltaNotification, type TurnToolBlockedNotification, type TurnToolCallNotification, type TurnToolResultNotification, type WireAuthoritativeUsage, type WireTokenUsage, } from "./notification-payloads.js";
+export { ACP_METHODS, ACP_PROTOCOL_VERSION, isAcpJsonRpcNotification, isAcpJsonRpcRequest, isAcpJsonRpcResponse, parseAcpMessage, type AcpAgentCapabilities, type AcpConfigOptionDescriptor, type AcpContentBlock, type AcpFsReadTextFileParams, type AcpFsReadTextFileResult, type AcpFsWriteTextFileParams, type AcpFsWriteTextFileResult, type AcpHostCapabilities, type AcpInitializeParams, type AcpInitializeResult, type AcpJsonRpcError, type AcpJsonRpcMessage, type AcpJsonRpcNotification, type AcpJsonRpcRequest, type AcpJsonRpcResponse, type AcpMode, type AcpPermissionOption, type AcpPermissionRequestParams, ACP_PERMISSION_PRESENTATION_META_KEY, type AcpPermissionPresentationMetaV1, type AcpPermissionRequestResult, type AcpSessionCancelParams, type AcpSessionCloseParams, type AcpSessionMeta, type AcpSessionLoadParams, type AcpSessionModeState, type AcpSessionNewParams, type AcpSessionNewResult, type AcpSessionPromptParams, type AcpSessionPromptResult, ACP_AUTHORITATIVE_USAGE_META_KEY, type AcpSessionSetConfigParams, type AcpSessionSetConfigResult, type AcpStandardMethod, type AcpStopReason, type AcpUsage, } from "./acp-protocol.js";
 export { type ApprovalRequiredToolContract, type ModelSelectionReason, type PendingPromptContract, type RuntimeCapabilitySummaryContract, type RuntimeSessionContract, type SessionIdentityContract, } from "./session.js";
 export { CAPABILITY_MANIFEST_DIFF_SECTIONS, cloneCapabilityManifestSnapshot, createCapabilityManifestDiffPayload, deriveCapabilityToolNamespaces, deriveCapabilityWorkspaceIds, mergeCapabilityManifestSnapshot, type CapabilityManifestApprovalMode, type CapabilityManifestApprovalPolicyContract, type CapabilityManifestDiffSection, type CapabilityMcpManifestContract, type CapabilityManifestSnapshotContract, type HostCapabilitySnapshotContract, type CapabilityPluginManifestContract, type RuntimeCapabilityViewContract, type RuntimeToolEligibilityContract, type CapabilitySkillManifestContract, type CapabilityToolManifestContract, type CapabilityWorkspaceSummaryContract, type ToolEligibilityResolvedSource, type ToolEligibilityReasonCode, type ToolEligibilityStatus, } from "./capability-manifest.js";
 export { WEB_ACTION_SCOPE_VALUES, WEB_APPROVAL_DEFAULT_VALUES, WEB_CAPABILITY_FAMILY_VALUES, WEB_CAPABILITY_ID_VALUES, WEB_DEGRADATION_TARGET_VALUES, WEB_ESCALATION_REASON_VALUES, WEB_EXECUTION_MODE_VALUES, WEB_POLICY_RISK_CLASS_VALUES, WEB_RETRY_POLICY_VALUES, WEB_STATEFULNESS_VALUES, WEB_TASK_MODE_VALUES, type WebActionScope, type WebApprovalDefault, type WebCapabilityDescriptorContract, type WebCapabilityFamily, type WebCapabilityId, type WebDegradationTarget, type WebEscalationReason, type WebExecutionMode, type WebPolicyRiskClass, type WebRetryPolicy, type WebStatefulness, type WebTaskMode, type ToolRiskLevel, } from "./web-capability.js";

package/dist/types/protocol/wire/notification-payloads.d.ts

@@ -1,10 +1,17 @@
 /** Token accounting returned by an Agent turn. */
+export interface WireAuthoritativeUsage {
+    source: string;
+    currency: string;
+    cost: string;
+    requestIds: string[];
+}
 export interface WireTokenUsage {
     inputTokens: number;
     outputTokens: number;
     reasoningTokens?: number;
     cacheRead?: number;
     cacheWrite?: number;
+    authoritative?: WireAuthoritativeUsage;
 }
 /** Internal events that have a direct standard ACP projection. */
 export interface TurnDeltaNotification {

package/dist/types/runtime/config/tunable-defaults.d.ts

@@ -37,8 +37,6 @@ export declare const MAX_TOOL_RESULTS_PER_MESSAGE_CHARS = 200000;
 export declare const TOOL_RESULT_PREVIEW_BYTES = 2000;
 /** Heartbeat interval during persistent retry waits (ms). */
 export declare const HEARTBEAT_INTERVAL_MS = 30000;
-/** Max 529 errors before fallback model switch. */
-export declare const MAX_529_RETRIES = 3;
 /** Max consecutive API error retries before aborting. */
 export declare const MAX_API_RETRIES = 2;
 /** Max backoff interval for persistent retry (ms). */
@@ -107,7 +105,6 @@ export interface TunableDefaults {
     maxToolResultsPerMessageChars: number;
     toolResultPreviewBytes: number;
     heartbeatIntervalMs: number;
-    max529Retries: number;
     maxApiRetries: number;
     persistentRetryMaxBackoffMs: number;
     persistentRetryResetCapMs: number;

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

@@ -82,12 +82,6 @@ export declare class ToolResultTrimStrategy implements CompressionStrategy {
     constructor(maxToolResultChars?: number);
     compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
 }
-export declare function composeStrategies(...strategies: CompressionStrategy[]): CompressionStrategy;
-/**
- * Compose strategies with async support — if any strategy is async,
- * the pipeline becomes async.
- */
-export declare function composeAsyncStrategies(...strategies: CompressionStrategy[]): AsyncCompressionStrategy;
 /**
  * Build the structured 9-section summary instruction for the LLM.
  * Based on Claude Code's Full Compact mode, adapted for Hub.
@@ -119,27 +113,6 @@ export declare class HeadTailProtectedStrategy implements AsyncCompressionStrate
     compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
     compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
 }
-export interface IncrementalCompactConfig {
-    /** Messages newer than this count are never summarized (default: 12) */
-    preserveRecentCount: number;
-    /** Summarization callback */
-    summarize: SummarizeFn;
-    /** Token estimator */
-    estimateTokens?: (msg: CompressibleMessage) => number;
-}
-/**
- * Phase 2.3: Incremental (partial) compaction.
- *
- * Only summarizes the oldest messages beyond the preserve window.
- * Avoids repeatedly re-summarizing already-compressed content.
- * If a previous summary marker exists, only new old messages are compressed.
- */
-export declare class IncrementalCompactStrategy implements AsyncCompressionStrategy {
-    private config;
-    constructor(config: IncrementalCompactConfig);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
 export interface CacheAwareCompressionConfig {
     /** The inner strategy to delegate to */
     inner: CompressionStrategy;
@@ -248,84 +221,3 @@ export declare class ContextEngineRegistry {
         active: boolean;
     }>;
 }
-/**
- * MicroCompact — selective clearing of old compactable tool results.
- *
- * CC parity: microCompact.ts
- *
- * For tool result messages from COMPACTABLE_TOOLS, if the message is
- * "old enough" (not in the most recent N messages), replace its content
- * with a compact "[result cleared]" marker. This preserves the tool call
- * structure (so the LLM knows what was called) but reclaims token budget.
- *
- * This is a lighter alternative to full summarization — it runs BEFORE
- * LLM summarization as a first-pass reduction.
- */
-export declare class MicroCompactStrategy implements CompressionStrategy {
-    /** Number of recent messages to preserve (don't clear) */
-    private preserveRecentCount;
-    /** Token estimator */
-    private estimateTokens;
-    constructor(
-    /** Number of recent messages to preserve (don't clear) */
-    preserveRecentCount?: number, 
-    /** Token estimator */
-    estimateTokens?: (msg: CompressibleMessage) => number);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-}
-/**
- * After compaction, the most recently read/edited files may have been
- * dropped from the conversation. CC re-injects up to N file contents
- * to ensure the agent doesn't lose awareness of files it was working with.
- *
- * CC parity: compact.ts postCompactFileStateRecovery
- */
-export interface PostCompactRecoveryConfig {
-    /** Maximum number of files to re-inject (default 5) */
-    maxFiles: number;
-    /** Maximum total tokens for re-injected files (default 50000) */
-    maxTokenBudget: number;
-    /** Function to read a file from disk (injected by caller) */
-    readFile: (path: string) => Promise<string | null>;
-    /** Token estimator */
-    estimateTokens?: (text: string) => number;
-}
-/**
- * Extract file paths that were recently read/edited from the conversation.
- * Looks at tool calls and results for file path arguments.
- */
-export declare function extractRecentFilePaths(messages: CompressibleMessage[]): string[];
-/**
- * Re-inject recently-used file contents after compaction.
- *
- * Call this AFTER compression but BEFORE sending to the LLM.
- * Appends file content as system messages at the end of the
- * system message block.
- */
-export declare function postCompactFileRecovery(compressedMessages: CompressibleMessage[], originalMessages: CompressibleMessage[], config: PostCompactRecoveryConfig): Promise<CompressibleMessage[]>;
-/**
- * Snip Compact — permanently remove specific messages by identifier.
- *
- * CC parity: services/compact/snipCompact.ts
- *
- * Unlike sliding window or summarization, snip removes messages by
- * their unique id (tool_call_id, or index-based). This is used for:
- * - Removing old tool results that are known to be stale
- * - Dropping large image/media messages after they've been processed
- * - Clearing tombstoned messages from the transcript
- *
- * Snip runs BEFORE microcompact and autocompact — both may fire
- * after snip if the result is still over threshold.
- */
-export interface SnipResult {
-    messages: CompressibleMessage[];
-    tokensFreed: number;
-    removedCount: number;
-    /** Optional boundary message to yield (marks snip point in transcript). */
-    boundaryMessage?: CompressibleMessage;
-}
-/**
- * Remove messages whose tool_call_id or name matches the removedIds set.
- * If no removedIds are pending, this is a no-op.
- */
-export declare function snipCompactIfNeeded(messages: CompressibleMessage[], removedIds: Set<string>, estimateTokens?: (msg: CompressibleMessage) => number): SnipResult;

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

@@ -20,8 +20,6 @@ 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:
@@ -68,15 +66,6 @@ export declare function toolResultContextPolicy(details: Record<string, unknown>
 export declare function toolResultContextBudget(policy: ToolResultContextPolicy): ToolResultContextBudget;
 export declare function requiredContextBudgetViolation(state: ContentReplacementState | undefined, details: Record<string, unknown> | undefined, contentSize: number): string | undefined;
 export declare function registerToolResultContext(state: ContentReplacementState | undefined, toolCallId: string, details: Record<string, unknown> | undefined, contentSize?: number, _invocationArgs?: Record<string, unknown>): void;
-/**
- * Re-apply required Host instruction context after generic compression stages.
- * Existing tool messages are restored in place; if a whole tool exchange was removed,
- * a system capsule is inserted so wire-level tool-call pairing stays valid.
- */
-export declare function restoreRequiredContextMessages(messagesBefore: MessageLike[], messagesAfter: MessageLike[], state: ContentReplacementState): {
-    messages: MessageLike[];
-    recoveredCount: number;
-};
 /**
  * Where oversized tool output is spilled to disk.
  *

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

@@ -1,3 +1,8 @@
+/**
+ * Single-pass context compaction for the Agent turn loop.
+ * The active tier chooses exactly one transform; model selection remains in
+ * the Host-projected registry and is never guessed by this module.
+ */
 import { ContextEngineRegistry, type CompressibleMessage, type CompressionResult, type CompressionStrategy, type AsyncCompressionStrategy, type SummarizeFn } from "../context/context-compression-strategies.js";
 import type { HookRegistry } from "./hook-registry.js";
 import type { RuntimeLogger } from "./hook-registry.js";
@@ -23,23 +28,15 @@ export declare function createSummarizeFn(log: RuntimeLogger, opts?: {
     apiKey?: string;
     model?: string;
 }): SummarizeFn;
-/** Phase 1: sync-only pipeline (ToolResultTrim + MicroCompact + SlidingWindow) */
+/** Synchronous fallback: one deterministic sliding-window transform. */
 export declare function createSyncPipeline(): CompressionStrategy;
-/** Phase 2+3: async pipeline with LLM summarization + cache awareness */
+/** One protected summarization transform with cache accounting. */
 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;
@@ -48,9 +45,9 @@ export interface CompressOptions {
     summarize?: SummarizeFn;
     sessionId?: string;
 }
-/** Synchronous compression (Phase 1 only). */
+/** Synchronous one-pass compression. */
 export declare function compressMessages(messages: CompressibleMessage[], opts?: CompressOptions): CompressionResult;
-/** Async compression (Phase 2+) — supports LLM summarization. */
+/** Async one-pass compression; the selected tier may use LLM summarization. */
 export declare function compressMessagesAsync(messages: CompressibleMessage[], opts: CompressOptions & {
     summarize: SummarizeFn;
 }): Promise<CompressionResult>;

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

@@ -11,7 +11,7 @@
  *
  * Watched paths:
  *   - .qlogicagent/settings.json → permission hot-reload
- *   - INSTRUCTIONS.md / .qlogicagent/INSTRUCTIONS.md → instruction re-load
+ *   - INSTRUCTIONS.md / .qlogicagent/INSTRUCTIONS.md → file.changed notification
  *   - configurable additional patterns
  *
  * Reference: claude-code file-watcher usage throughout lifecycle
@@ -26,8 +26,6 @@ export interface FileWatcherDeps {
     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 {

package/dist/types/runtime/ports/agent-runtime-ports.d.ts

@@ -56,18 +56,6 @@ export interface ToolLoopRuntimePorts {
         newlyReplacedCount: number;
         newlyPersistedBytes?: number;
     }>;
-    restoreRequiredContextMessages?(messagesBefore: Array<{
-        role: string;
-        content?: string | unknown;
-        tool_call_id?: string;
-    }>, messagesAfter: Array<{
-        role: string;
-        content?: string | unknown;
-        tool_call_id?: string;
-    }>, state: unknown): {
-        messages: unknown[];
-        recoveredCount: number;
-    };
     getActiveContextCompressionEngine(): ContextCompressionEnginePort | null;
     compressMessages(messages: RuntimeCompressibleMessage[], options: {
         budget: number;
@@ -83,5 +71,4 @@ export interface ToolLoopRuntimePorts {
 }
 export interface AgentRuntimePorts {
     toolLoop: ToolLoopRuntimePorts;
-    resolveModelForPurpose(purpose: "smallModel" | string): string | null;
 }

package/dist/types/runtime/ports/model-transport-contracts.d.ts

@@ -82,6 +82,21 @@ export type LLMChunk = {
     reasoningTokens?: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
+    authoritative?: {
+        schemaVersion: number;
+        source: string;
+        requestId: string;
+        currency: string;
+        cost: string;
+        tokens: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+            reasoningTokens: number;
+            cacheReadTokens: number;
+            cacheCreationTokens: number;
+        };
+    };
 } | {
     type: "response_id";
     id: string;