qlogicagent 0.3.0 → 0.4.0

package/dist/types/orchestration/fork-subagent.d.ts

@@ -1,100 +0,0 @@
-/**
- * Fork Sub-Agent — CC-aligned fork mechanism for spawning child agents.
- *
- * Core design principles (aligned with Claude Code):
- * 1. Child agent shares parent's message prefix (prompt cache hit)
- * 2. Fork uses placeholder results to ensure byte-identical prefix across children
- * 3. Child has independent tool context (doesn't pollute parent state)
- * 4. Results flow back via AsyncGenerator (streaming backflow)
- * 5. Depth control via in-memory counter (not DB-based)
- */
-import type { AgentDefinition } from "./agent-registry.js";
-/** Sentinel tag injected into fork children to prevent recursive forking. */
-export declare const FORK_SENTINEL_TAG = "<fork-child-context>";
-/** Placeholder text used for all tool_results in shared prefix (ensures byte-identical prefix). */
-export declare const FORK_PLACEHOLDER_RESULT = "Fork started \u2014 processing in background";
-/** Maximum fork depth for in-memory agents (more permissive than DB sidechain). */
-export declare const MAX_FORK_DEPTH = 4;
-/** Maximum fork depth for DB-backed sidechains (more conservative). */
-export declare const MAX_SIDECHAIN_DB_DEPTH = 2;
-export interface ForkContext {
-    /** Parent's full message history (becomes shared prefix for cache). */
-    parentMessages: unknown[];
-    /** Parent's rendered system prompt (byte-exact for cache hit). */
-    systemPrompt: string;
-    /** Parent's full tool pool (useExactTools=true pattern). */
-    parentTools: string[];
-    /** Current fork depth (0 = root). */
-    depth: number;
-    /** Abort signal from parent. */
-    abortSignal?: AbortSignal;
-    /** Parent's agent ID for lineage tracking. */
-    parentAgentId: string;
-}
-export interface ForkChildConfig {
-    /** The agent definition to run. */
-    agent: AgentDefinition;
-    /** Task-specific prompt for this child (the unique part after shared prefix). */
-    taskPrompt: string;
-    /** Optional override for max turns. */
-    maxTurns?: number;
-    /** Whether to run in background (async). */
-    isAsync?: boolean;
-}
-export interface ForkChildMessage {
-    role: "assistant" | "user" | "system";
-    content: unknown;
-    toolCalls?: unknown[];
-}
-export interface ForkResult {
-    /** Whether the fork completed successfully. */
-    ok: boolean;
-    /** Child's final output text (summary). */
-    output: string;
-    /** Messages produced by the child (for result backflow). */
-    messages: ForkChildMessage[];
-    /** Total tokens consumed by the child. */
-    tokensUsed: number;
-    /** Whether the child hit its turn limit. */
-    maxTurnsReached: boolean;
-    /** Child's agent ID. */
-    childAgentId: string;
-}
-/**
- * Check if current context is inside a fork child (prevents recursive forking).
- */
-export declare function isInForkChild(messages: unknown[]): boolean;
-/**
- * Check if fork depth allows spawning another child.
- */
-export declare function canForkAtDepth(currentDepth: number, mode?: "in-memory" | "db-sidechain"): boolean;
-/**
- * Build forked messages that ensure byte-identical prefix across all fork children.
- *
- * Strategy (aligned with CC's buildForkedMessages):
- * 1. Keep full parent message history (all tool_use blocks, thinking, text)
- * 2. Replace all pending tool_results with FORK_PLACEHOLDER_RESULT
- * 3. Append a single user message with the child-specific directive
- * → All children share the same prefix up to the directive → maximum cache hits.
- */
-export declare function buildForkedMessages(context: ForkContext, childConfig: ForkChildConfig): unknown[];
-/**
- * Build placeholder tool results for the shared prefix.
- * When parent has pending tool_calls, replace them all with identical placeholder text
- * so all fork children produce byte-identical API request prefix.
- */
-export declare function buildForkPlaceholderResults(pendingToolCallIds: string[]): Array<{
-    role: "tool";
-    tool_call_id: string;
-    content: string;
-}>;
-/**
- * Resolve the effective tool set for a fork child.
- * CC pattern: useExactTools=true → child gets parent's full tool pool,
- * then filtered by agent definition.
- */
-export declare function resolveForkChildTools(parentTools: string[], agent: AgentDefinition): string[];
-/**
- * Generate a unique agent ID for a fork child.
- */
-export declare function generateForkChildAgentId(parentAgentId: string, agentName: string, depth: number): string;

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

@@ -1,120 +0,0 @@
-export { buildAssistantToolCallMessage, buildToolResultMessage, cleanToolSchemaForGemini, convertCapabilityToolManifestsToFunctionTools, convertFunctionTools, isXaiProvider, normalizeMessageTextContent, normalizeFunctionToolParameters, parseOpenAiToolCallsFromChatResponse, type CapabilityToolManifestLike, type FunctionToolDefinition, type FunctionToolSource, type ToolSchemaProvider, } from "./tool-schema.js";
-export { classifyError, classifyErrorFromReason, getRetryStrategy, type ErrorCategory, type RetryStrategy, } from "./error-classification.js";
-export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, buildStructuredSummaryPrompt, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, type AdaptiveBudgetConfig, type AsyncCompressionStrategy, type CacheAwareCompressionConfig, type CompressibleMessage, type CompressionEvent, type CompressionMetrics, type CompressionMetricsSnapshot, type CompressionResult, type CompressionStrategy, type CompressionTier, type ContextEngine, type HeadTailProtectionConfig, type IncrementalCompactConfig, type SummarizeFn, } from "./context-compression.js";
-export { buildSkillInstruction, shouldCreateSkill, shouldImproveSkill, type SkillCreateInstruction, type SkillImproveInstruction, type SkillInstruction, type SkillTurnResult, } from "./skill-improvement.js";
-export { buildSkillCandidateEffectivenessSummary, buildSkillCandidateEvidencePayload, buildSkillCandidateImprovementEvidenceBundle, buildSkillCandidateLatestReview, createDefaultSkillImprovementPolicy, normalizeSkillImprovementPolicy, type SkillCandidateImprovementEvidenceBundleContract, type SkillImprovementPolicyContract, } from "./skill-candidate.js";
-export declare const SIDECHAIN_TYPE_VALUES: readonly ["research", "planner", "plan-repair", "code-repair", "media-prep"];
-export type SidechainType = typeof SIDECHAIN_TYPE_VALUES[number];
-export type SidechainBudgetTier = "low" | "medium" | "high";
-export type SidechainMergePolicy = "summary-only" | "append-messages" | "replace-context" | "manual";
-export type SidechainToolAccessMode = "full" | "read-only" | "none";
-export interface SidechainTypePolicy {
-    type: SidechainType;
-    label: string;
-    description: string;
-    mergePolicy: SidechainMergePolicy;
-    budgetTier: SidechainBudgetTier;
-    budgetWeight: number;
-    preferFullContext: boolean;
-    preserveConversationHistory: boolean;
-    toolAccessMode: SidechainToolAccessMode;
-}
-export type SidechainToolAccessDecision = "allowed" | "denied";
-export type SidechainToolAccessInheritance = "inherit" | "shrink";
-export type SidechainToolAccessReason = "default-allow" | "always-deny" | "leaf-deny";
-export interface SidechainToolAccessRule {
-    toolName: string;
-    decision: SidechainToolAccessDecision;
-    inheritance: SidechainToolAccessInheritance;
-    reason: SidechainToolAccessReason;
-}
-export interface SidechainToolAccessPolicy {
-    deniedTools: string[];
-    canSpawnChildren: boolean;
-    defaultDecision: "allowed";
-    defaultInheritance: "inherit";
-    tools: SidechainToolAccessRule[];
-}
-export declare const SIDECHAIN_TOOL_DENY_ALWAYS: readonly ["gateway", "agents_list", "whatsapp_login", "session_status", "cron", "memory_query", "sessions_send"];
-export declare const SIDECHAIN_TOOL_DENY_LEAF: readonly ["sessions_list", "sessions_history", "sessions_spawn"];
-/** Tools that perform write/mutation operations — denied in read-only sidechain types. */
-export declare const SIDECHAIN_TOOL_DENY_WRITE: readonly ["file_edit", "create_file", "replace_string_in_file", "multi_replace_string_in_file", "create_directory", "run_in_terminal", "run_command", "delete_file", "rename_file", "move_file", "git_commit", "git_push", "manage_todo_list"];
-export declare function resolveSidechainToolAccessPolicy(params?: {
-    depth?: number;
-    maxDepth?: number;
-    role?: "leaf" | "orchestrator";
-    toolNames?: Iterable<string>;
-}): SidechainToolAccessPolicy;
-/**
- * Resolve tool access policy for a specific sidechain type.
- * Combines depth-based deny lists with type-specific access mode:
- * - "full": only depth-based denials apply
- * - "read-only": depth-based + all write/mutation tools denied
- * - "none": all tools denied
- */
-export declare function resolveSidechainToolAccessByType(params: {
-    type: SidechainType;
-    depth?: number;
-    maxDepth?: number;
-    role?: "leaf" | "orchestrator";
-    toolNames?: Iterable<string>;
-}): SidechainToolAccessPolicy;
-export interface ToolCallAccessFilterResult<T> {
-    allowed: T[];
-    denied: Array<{
-        toolCall: T;
-        reason: string;
-    }>;
-}
-/**
- * Filter tool_calls against a resolved access policy.
- * Returns allowed calls and denied calls with reasons.
- * T must have at least { id: string; function: { name: string } }.
- */
-export declare function filterToolCallsByAccessPolicy<T extends {
-    id: string;
-    function: {
-        name: string;
-    };
-}>(toolCalls: T[], policy: SidechainToolAccessPolicy): ToolCallAccessFilterResult<T>;
-export declare function listSidechainTypePolicies(): SidechainTypePolicy[];
-export declare function resolveSidechainTypePolicy(type: SidechainType): SidechainTypePolicy;
-export declare function resolveRepairSidechainType(params?: {
-    toolNames?: Iterable<string>;
-    preferCodeRepair?: boolean;
-    trigger?: string;
-}): Extract<SidechainType, "plan-repair" | "code-repair">;
-export declare function resolveSidechainMergePolicyByType(type: SidechainType, overrides?: {
-    forceManualReview?: boolean;
-    preferFullContext?: boolean;
-    preserveConversationHistory?: boolean;
-}): SidechainMergePolicy;
-export declare function resolveSidechainMergePolicy(params?: {
-    preferFullContext?: boolean;
-    forceManualReview?: boolean;
-    preserveConversationHistory?: boolean;
-}): SidechainMergePolicy;
-export { applyToolChoiceCompatibility, applyToolChoicePolicy, filterEligibleTools, normalizeAnthropicFunctionToolDefinition, normalizeAnthropicToolChoice, type ApplyToolChoicePolicyInput, type ApplyToolChoicePolicyResult, type ToolEligibilityLike, type ToolChoiceCompatibilityPolicy, type ToolChoiceLike, type ToolChoiceToolLike, } from "./tool-choice-policy.js";
-export { downgradeOpenAiFunctionCallReasoningPairs, downgradeOpenAiReasoningBlocks, ensureAssistantReasoningContent, injectDanglingToolCallPlaceholders, repairOpenAiChatConversation, repairOpenAiResponsesItems, sanitizeOpenAiChatMessages, stripForcedStopAssistantToolMetadata, type ConversationRepairOptions, type ContentPart, type OpenAiChatMessageLike, type OpenAiChatToolCallRef, type OpenAiResponsesItemLike, type OpenAiToolCall, } from "./conversation-repair.js";
-export { classifyFailoverReason, classifyFailoverReasonFromHttpStatus, isCloudflareOrHtmlErrorPage, isFailoverErrorMessage, isModelNotFoundErrorMessage, isTimeoutErrorMessage, isTransientHttpError, type FailoverReason, } from "./failover-classification.js";
-export { FailoverError, coerceToFailoverError, describeFailoverError, isFailoverError, isTimeoutError, resolveFailoverReasonFromError, resolveFailoverStatus, } from "./failover-error.js";
-export { repairToolCallInputs, repairToolUseResultPairing, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails, stripTransientErrorMessages, type ToolCallInputRepairOptions, type ToolCallInputRepairReport, type ToolUseRepairOptions, type ToolUseRepairReport, type TranscriptMessageLike, type TranscriptToolCallLike, } from "./transcript-repair.js";
-export { normalizeParallelToolCallsPreference, resolveParallelToolCallScheduling, type ParallelToolCallsPreference, type ResolveParallelToolCallSchedulingInput, type ResolveParallelToolCallSchedulingResult, type ToolCallBatch, type ToolCallLike, type ToolCapabilityLike, } from "./parallel-tool-calls.js";
-export { advanceToolLoopState, createToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, type RepairToolLoopStateResult, type ToolLoopRepairAction, type ToolLoopState, } from "./tool-loop-state.js";
-export { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, type MemoryObservationHook, type MemoryObservationSource, type MemoryWriteAccess, type MemoryProviderLifecycleInvocation, } from "./memory-provider.js";
-export { hasAlreadyFlushedForCurrentCompaction, resolveMemoryFlushProjection, resolveMemoryFlushReadPlan, shouldRunMemoryFlush, type MemoryFlushCompactionStateLike, type MemoryFlushProjection, type MemoryFlushReadPlan, type MemoryFlushTokenStateLike, } from "./memory-flush-policy.js";
-export { executeBoundedRetryLoop, resolveScaledRetryIterations, } from "./retry-loop.js";
-export { buildAssistantFailoverErrorDetails, pickFallbackThinkingLevel, resolveAssistantFailureActionDecision, resolveAuthProfileFailoverReason, resolveFallbackThinkingDecision, resolvePromptErrorPolicy, resolvePromptFailureActionDecision, resolveRetryableFailureReason, shouldAttemptAssistantFailureRotation, shouldAttemptPromptFailureRotation, type EmbeddedAssistantFailureAction, type EmbeddedPromptErrorPolicyResolution, type EmbeddedPromptFailureAction, } from "./embedded-failover-policy.js";
-export { buildApprovalAwareReason, buildApprovalStepContext, summarizeApprovalAwareToolPlan, type ApprovalAwareToolCapability, type ApprovalAwareToolPlanStep, type ToolExecutionStepContext, } from "./approval-aware-tool-plan.js";
-export { resolveWebBrowserPolicy, type ResolveWebBrowserPolicyInput, type ResolveWebBrowserPolicyResult, } from "./web-browser-policy.js";
-export { applyCacheMarkers, computeCacheBreakpoints, createCacheBreakDetectionState, DEFAULT_PROMPT_CACHE_POLICY, detectCacheBreaks, estimateCacheSavingsRatio, quickHash, resolveForkCacheMarkerIndex, type CacheableMessage, type CacheBreakDetectionState, type CacheBreakEvent, type CacheBreakpoint, type CacheMarkingResult, type CacheRetention, type CacheSegmentKind, type PromptCachePolicy, } from "./prompt-cache-strategy.js";
-export { computeLifecycleTransitions, DEFAULT_CURATOR_SCHEDULE_POLICY, INITIAL_CURATOR_STATE, selectReviewCandidates, shouldRunCurator, type CuratorAutoTransitionResult, type CuratorGateInput, type CuratorGateResult, type CuratorLifecycleTransition, type CuratorSchedulePolicy, type CuratorSkillLifecycleState, type CuratorSkillRecord, type CuratorState, } from "./curator-scheduler.js";
-export { buildConsolidationPrompt, buildCuratorRunSummary, detectPrefixClusters, parseConsolidationOutput, reconcileConsolidationPlan, type ConsolidationAction, type ConsolidationPlan, type ConsolidationSkillSummary, type CuratorRunReport, type PruningAction, type ReconciledConsolidationPlan, type SkillPrefixCluster, } from "./skill-consolidation.js";
-export { bigramSimilarity, computeSimilarity, decideSimilarityAction, DEFAULT_SKILL_SIMILARITY_POLICY, findSimilarSkills, stepCountProximity, toolSetJaccard, type SimilarityDecision, type SimilarityScore, type SimilarSkillMatch, type SkillSimilarityPolicy, type SkillSimilarityProfile, } from "./skill-similarity.js";
-export { aggregateTeamResults, allocateTokenBudgets, buildAgentTaskPrompt, inferAggregationPolicy, inferExecutionMode, mapRoleToSidechainType, resolveAgentToolAccess, resolveExecutionOrder, resolveTeamPlan, shouldCancelTeam, TEAM_MAX_AGENTS, TEAM_MAX_DEPTH, validateTeamPlan, type AgentRole, type TeamAgentResult, type TeamAgentSpec, type TeamAggregationPolicy, type TeamExecutionMode, type TeamLifecycleState, type TeamPlan, type TeamResult, } from "./team-orchestration.js";
-export { canDispatchDuringStreaming, createStreamingToolExecutor, type StreamingToolCall, type StreamingToolExecutor, type StreamingToolExecutorConfig, type StreamingToolResult, type ToolExecutorFn, } from "./streaming-tool-executor.js";
-export { canForkAtDepth, buildForkedMessages, buildForkPlaceholderResults, FORK_PLACEHOLDER_RESULT, FORK_SENTINEL_TAG, generateForkChildAgentId, isInForkChild, MAX_FORK_DEPTH, MAX_SIDECHAIN_DB_DEPTH, resolveForkChildTools, type ForkChildConfig, type ForkChildMessage, type ForkContext, type ForkResult, } from "./fork-subagent.js";
-export { getBuiltInAgent, getBuiltInAgents, isBuiltInAgent, resolveAgentToolSet, type AgentDefinition, } from "./agent-registry.js";
-export { calculateTokenWarningState, createTurnLoopGuardState, resolveApiErrorRecovery, resolveOutputTokenEscalation, shouldAbortTurn, type ApiErrorRecovery, type TokenWarningState, type TurnLoopGuardConfig, type TurnLoopGuardState, } from "./turn-loop-guard.js";
-export { buildPostCompactRestorationMessage, computeToolDelta, createReactiveCompactState, DEFAULT_REACTIVE_COMPACT_CONFIG, shouldAttemptReactiveCompact, type PostCompactRestorationPayload, type ReactiveCompactConfig, type ReactiveCompactState, } from "./reactive-compact.js";
-export { aggregateTeamToolResults, mapTeamRequestToForkConfigs, resolveTeamExecutionPlan, type TeamAgentRequest, type TeamAggregatedResult, type TeamExecutionBatch, type TeamExecutionPlan, type TeamToolRequest, } from "./team-tool-loop-wiring.js";

package/dist/types/orchestration/memory-flush-policy.d.ts

@@ -1,57 +0,0 @@
-export interface MemoryFlushCompactionStateLike {
-    compactionCount?: number;
-    memoryFlushCompactionCount?: number;
-}
-export interface MemoryFlushTokenStateLike extends MemoryFlushCompactionStateLike {
-    totalTokens?: number;
-    totalTokensFresh?: boolean;
-}
-export interface MemoryFlushReadPlan {
-    canAttemptFlush: boolean;
-    flushThreshold: number;
-    shouldReadTranscriptForOutput: boolean;
-    shouldReadTranscript: boolean;
-    shouldCheckTranscriptSizeForForcedFlush: boolean;
-    shouldReadSessionLog: boolean;
-}
-export interface MemoryFlushProjection {
-    shouldForceFlushByTranscriptSize: boolean;
-    shouldPersistTranscriptPromptTokens: boolean;
-    promptTokensSnapshot: number;
-    hasFreshPromptTokensSnapshot: boolean;
-    projectedTokenCount: number | undefined;
-    tokenCountForFlush: number | undefined;
-}
-export declare function hasAlreadyFlushedForCurrentCompaction(entry: MemoryFlushCompactionStateLike): boolean;
-export declare function shouldRunMemoryFlush(params: {
-    entry?: MemoryFlushTokenStateLike;
-    tokenCount?: number;
-    resolveFreshSessionTotalTokens: (entry: MemoryFlushTokenStateLike) => number | undefined;
-    contextWindowTokens: number;
-    reserveTokensFloor: number;
-    softThresholdTokens: number;
-}): boolean;
-export declare function resolveMemoryFlushReadPlan(params: {
-    memoryFlushWritable: boolean;
-    isHeartbeat: boolean;
-    isCli: boolean;
-    hasSessionEntry: boolean;
-    hasFreshPersistedPromptTokens: boolean;
-    promptTokenEstimate?: number;
-    persistedPromptTokens?: number;
-    contextWindowTokens: number;
-    reserveTokensFloor: number;
-    softThresholdTokens: number;
-    transcriptOutputReadBufferTokens: number;
-    forceFlushTranscriptBytes: number;
-}): MemoryFlushReadPlan;
-export declare function resolveMemoryFlushProjection(params: {
-    transcriptByteSize?: number;
-    forceFlushTranscriptBytes: number;
-    transcriptPromptTokens?: number;
-    transcriptOutputTokens?: number;
-    persistedPromptTokens?: number;
-    hasFreshPersistedPromptTokens: boolean;
-    promptTokenEstimate?: number;
-    resolveEffectivePromptTokens: (promptTokensSnapshot: number, transcriptOutputTokens: number | undefined, promptTokenEstimate: number | undefined) => number | undefined;
-}): MemoryFlushProjection;

package/dist/types/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/types/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/types/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/types/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[];
-};

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

@@ -1,22 +0,0 @@
-export declare function executeBoundedRetryLoop<TResult>(params: {
-    maxIterations: number;
-    onRetryLimit: (params: {
-        iterations: number;
-        maxIterations: number;
-    }) => Promise<TResult> | TResult;
-    executeIteration: (params: {
-        iteration: number;
-    }) => Promise<{
-        kind: "continue";
-    } | {
-        kind: "return";
-        result: TResult;
-    }>;
-}): Promise<TResult>;
-export declare function resolveScaledRetryIterations(params: {
-    candidateCount: number;
-    baseIterations?: number;
-    perCandidateIterations?: number;
-    minIterations?: number;
-    maxIterations?: number;
-}): number;

package/dist/types/orchestration/skill-candidate.d.ts

@@ -1,52 +0,0 @@
-import { type SkillCandidateAction, type SkillCandidateArtifactContract, type SkillCandidateEffectivenessContract, type SkillCandidateReviewContract, type SkillCandidateSourceExecutionContract } from "../contracts/skill-candidate.js";
-export type SkillImprovementPolicyContract = {
-    reviewRequired: boolean;
-    canaryRequired: boolean;
-    autoPromote: boolean;
-    minCanarySampleCount: number;
-    minSuccessRate: number;
-    maxRegressionRate: number;
-    maxCostIncreaseRate: number;
-    staleAfterHours: number;
-};
-export type SkillCandidateImprovementEvidenceBundleContract = {
-    artifact?: SkillCandidateArtifactContract | null;
-    sourceExecution?: SkillCandidateSourceExecutionContract | null;
-    sourceSessionKey?: string | null;
-    diffSummary?: string | null;
-    baselineCandidateId?: string | null;
-    rolloutNotes?: string | null;
-    validationRefs?: string[];
-    evidence?: Record<string, unknown>;
-};
-export declare function createDefaultSkillImprovementPolicy(overrides?: Partial<SkillImprovementPolicyContract>): SkillImprovementPolicyContract;
-export declare function normalizeSkillImprovementPolicy(value: unknown, fallback?: SkillImprovementPolicyContract): SkillImprovementPolicyContract;
-export declare function buildSkillCandidateEvidencePayload(params: {
-    evidence?: Record<string, unknown> | null;
-    artifact?: SkillCandidateArtifactContract | null;
-    sourceExecution?: SkillCandidateSourceExecutionContract | null;
-    sourceSessionKey?: string | null;
-}): Record<string, unknown>;
-export declare function buildSkillCandidateImprovementEvidenceBundle(params: SkillCandidateImprovementEvidenceBundleContract): Record<string, unknown>;
-export declare function buildSkillCandidateLatestReview(params: {
-    action: SkillCandidateAction;
-    actor?: string | null;
-    notes?: string | null;
-    payload?: Record<string, unknown> | null;
-    createdAt?: string;
-}): SkillCandidateReviewContract;
-export declare function buildSkillCandidateEffectivenessSummary(params: {
-    phase: "canary" | "published";
-    sampleCount?: number;
-    successCount?: number;
-    failureCount?: number;
-    regressionCount?: number;
-    avgLatencyMs?: number;
-    avgCostUsd?: number;
-    score?: number;
-    staleReason?: string | null;
-    notes?: string | null;
-    summary?: Record<string, unknown> | null;
-    lastObservedAt?: string;
-    updatedAt?: string;
-}): SkillCandidateEffectivenessContract;