qlogicagent 0.2.1 → 0.4.0

package/dist/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/orchestration/fork-subagent.js

@@ -1,98 +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)
- */
-/** Sentinel tag injected into fork children to prevent recursive forking. */
-export const FORK_SENTINEL_TAG = "<fork-child-context>";
-/** Placeholder text used for all tool_results in shared prefix (ensures byte-identical prefix). */
-export const FORK_PLACEHOLDER_RESULT = "Fork started \u2014 processing in background";
-/** Maximum fork depth for in-memory agents (more permissive than DB sidechain). */
-export const MAX_FORK_DEPTH = 4;
-/** Maximum fork depth for DB-backed sidechains (more conservative). */
-export const MAX_SIDECHAIN_DB_DEPTH = 2;
-/**
- * Check if current context is inside a fork child (prevents recursive forking).
- */
-export function isInForkChild(messages) {
-    return JSON.stringify(messages).includes(FORK_SENTINEL_TAG);
-}
-/**
- * Check if fork depth allows spawning another child.
- */
-export function canForkAtDepth(currentDepth, mode = "in-memory") {
-    const maxDepth = mode === "in-memory" ? MAX_FORK_DEPTH : MAX_SIDECHAIN_DB_DEPTH;
-    return currentDepth < maxDepth;
-}
-/**
- * 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 function buildForkedMessages(context, childConfig) {
-    const messages = [...context.parentMessages];
-    // Inject fork sentinel + child task as the unique tail
-    const childDirective = {
-        role: "user",
-        content: [
-            { type: "text", text: `${FORK_SENTINEL_TAG}\n\nYou are the "${childConfig.agent.name}" agent.\n\n${childConfig.taskPrompt}` },
-        ],
-    };
-    messages.push(childDirective);
-    return messages;
-}
-/**
- * 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 function buildForkPlaceholderResults(pendingToolCallIds) {
-    return pendingToolCallIds.map((id) => ({
-        role: "tool",
-        tool_call_id: id,
-        content: FORK_PLACEHOLDER_RESULT,
-    }));
-}
-/**
- * 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 function resolveForkChildTools(parentTools, agent) {
-    if (agent.allowedTools && agent.allowedTools.length > 0) {
-        const allowed = new Set(agent.allowedTools);
-        return parentTools.filter((t) => allowed.has(t));
-    }
-    if (agent.toolAccessMode === "none")
-        return [];
-    if (agent.toolAccessMode === "read-only") {
-        const writeTools = new Set([
-            "file_edit", "create_file", "write_file", "replace_string_in_file",
-            "multi_replace_string_in_file", "create_directory", "delete_file",
-            "rename_file", "move_file", "exec", "run_in_terminal", "run_command",
-            "git_commit", "git_push", "patch",
-        ]);
-        return parentTools.filter((t) => !writeTools.has(t));
-    }
-    // full access — remove agent_tool if canFork=false
-    if (!agent.canFork) {
-        return parentTools.filter((t) => t !== "agent_tool");
-    }
-    return [...parentTools];
-}
-/**
- * Generate a unique agent ID for a fork child.
- */
-export function generateForkChildAgentId(parentAgentId, agentName, depth) {
-    const ts = Date.now().toString(36);
-    return `${parentAgentId}:fork:${agentName}:d${depth}:${ts}`;
-}

package/dist/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/orchestration/index.js

@@ -1,267 +0,0 @@
-export { buildAssistantToolCallMessage, buildToolResultMessage, cleanToolSchemaForGemini, convertCapabilityToolManifestsToFunctionTools, convertFunctionTools, isXaiProvider, normalizeMessageTextContent, normalizeFunctionToolParameters, parseOpenAiToolCallsFromChatResponse, } from "./tool-schema.js";
-export { classifyError, classifyErrorFromReason, getRetryStrategy, } from "./error-classification.js";
-export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, buildStructuredSummaryPrompt, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, } from "./context-compression.js";
-export { buildSkillInstruction, shouldCreateSkill, shouldImproveSkill, } from "./skill-improvement.js";
-export { buildSkillCandidateEffectivenessSummary, buildSkillCandidateEvidencePayload, buildSkillCandidateImprovementEvidenceBundle, buildSkillCandidateLatestReview, createDefaultSkillImprovementPolicy, normalizeSkillImprovementPolicy, } from "./skill-candidate.js";
-export const SIDECHAIN_TYPE_VALUES = ["research", "planner", "plan-repair", "code-repair", "media-prep"];
-const SIDECHAIN_TYPE_POLICY_MAP = {
-    research: {
-        type: "research",
-        label: "Research",
-        description: "Independent retrieval or evidence gathering branches.",
-        mergePolicy: "summary-only",
-        budgetTier: "medium",
-        budgetWeight: 2,
-        preferFullContext: false,
-        preserveConversationHistory: true,
-        toolAccessMode: "read-only",
-    },
-    planner: {
-        type: "planner",
-        label: "Planner",
-        description: "Planning and tool orchestration branches that may return structured context.",
-        mergePolicy: "append-messages",
-        budgetTier: "high",
-        budgetWeight: 3,
-        preferFullContext: true,
-        preserveConversationHistory: true,
-        toolAccessMode: "none",
-    },
-    "plan-repair": {
-        type: "plan-repair",
-        label: "Plan Repair",
-        description: "Failure repair or fallback branches that re-plan tool choice, ordering, or approval strategy.",
-        mergePolicy: "replace-context",
-        budgetTier: "medium",
-        budgetWeight: 2,
-        preferFullContext: true,
-        preserveConversationHistory: false,
-        toolAccessMode: "none",
-    },
-    "code-repair": {
-        type: "code-repair",
-        label: "Code Repair",
-        description: "Recovery branches focused on file edits, patch validation, or workspace mutation repair.",
-        mergePolicy: "replace-context",
-        budgetTier: "high",
-        budgetWeight: 3,
-        preferFullContext: true,
-        preserveConversationHistory: false,
-        toolAccessMode: "full",
-    },
-    "media-prep": {
-        type: "media-prep",
-        label: "Media Prep",
-        description: "Preparation branches for media generation, normalization, or staging.",
-        mergePolicy: "summary-only",
-        budgetTier: "low",
-        budgetWeight: 1,
-        preferFullContext: false,
-        preserveConversationHistory: false,
-        toolAccessMode: "read-only",
-    },
-};
-export const SIDECHAIN_TOOL_DENY_ALWAYS = [
-    "gateway",
-    "agents_list",
-    "whatsapp_login",
-    "session_status",
-    "cron",
-    "memory_query",
-    "sessions_send",
-];
-export const SIDECHAIN_TOOL_DENY_LEAF = [
-    "sessions_list",
-    "sessions_history",
-    "sessions_spawn",
-];
-/** Tools that perform write/mutation operations — denied in read-only sidechain types. */
-export const SIDECHAIN_TOOL_DENY_WRITE = [
-    "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 function resolveSidechainToolAccessPolicy(params = {}) {
-    const maxDepth = Math.max(1, Math.floor(params.maxDepth ?? 2));
-    const depth = typeof params.depth === "number" && Number.isFinite(params.depth)
-        ? Math.max(0, Math.floor(params.depth))
-        : maxDepth;
-    const isLeaf = params.role ? params.role === "leaf" : depth >= maxDepth;
-    const deniedTools = isLeaf
-        ? [...SIDECHAIN_TOOL_DENY_ALWAYS, ...SIDECHAIN_TOOL_DENY_LEAF]
-        : [...SIDECHAIN_TOOL_DENY_ALWAYS];
-    const deniedSet = new Set(deniedTools);
-    const toolNames = Array.isArray(params.toolNames)
-        ? params.toolNames
-        : params.toolNames
-            ? Array.from(params.toolNames)
-            : [];
-    const tools = Array.from(new Set(toolNames.map((toolName) => toolName.trim()).filter(Boolean))).map((toolName) => {
-        const denied = deniedSet.has(toolName);
-        return {
-            toolName,
-            decision: denied ? "denied" : "allowed",
-            inheritance: denied ? "shrink" : "inherit",
-            reason: denied
-                ? SIDECHAIN_TOOL_DENY_ALWAYS.includes(toolName)
-                    ? "always-deny"
-                    : "leaf-deny"
-                : "default-allow",
-        };
-    });
-    return {
-        deniedTools,
-        canSpawnChildren: !isLeaf,
-        defaultDecision: "allowed",
-        defaultInheritance: "inherit",
-        tools,
-    };
-}
-/**
- * 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 function resolveSidechainToolAccessByType(params) {
-    const policy = resolveSidechainTypePolicy(params.type);
-    const basePolicy = resolveSidechainToolAccessPolicy({
-        depth: params.depth,
-        maxDepth: params.maxDepth,
-        role: params.role,
-        toolNames: params.toolNames,
-    });
-    if (policy.toolAccessMode === "full") {
-        return basePolicy;
-    }
-    if (policy.toolAccessMode === "none") {
-        const allToolNames = Array.isArray(params.toolNames)
-            ? params.toolNames
-            : params.toolNames ? Array.from(params.toolNames) : [];
-        const uniqueNames = [...new Set(allToolNames.map((n) => n.trim()).filter(Boolean))];
-        return {
-            deniedTools: uniqueNames,
-            canSpawnChildren: false,
-            defaultDecision: "allowed",
-            defaultInheritance: "inherit",
-            tools: uniqueNames.map((toolName) => ({
-                toolName,
-                decision: "denied",
-                inheritance: "shrink",
-                reason: "always-deny",
-            })),
-        };
-    }
-    // "read-only": add write tools to deny list
-    const writeSet = new Set(SIDECHAIN_TOOL_DENY_WRITE);
-    const combinedDenied = [...new Set([...basePolicy.deniedTools, ...SIDECHAIN_TOOL_DENY_WRITE])];
-    return {
-        ...basePolicy,
-        deniedTools: combinedDenied,
-        tools: basePolicy.tools.map((rule) => {
-            if (rule.decision === "denied")
-                return rule;
-            if (writeSet.has(rule.toolName)) {
-                return { ...rule, decision: "denied", inheritance: "shrink", reason: "always-deny" };
-            }
-            return rule;
-        }),
-    };
-}
-/**
- * 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 function filterToolCallsByAccessPolicy(toolCalls, policy) {
-    const deniedSet = new Set(policy.deniedTools);
-    const ruleMap = new Map(policy.tools.map((r) => [r.toolName, r]));
-    const allowed = [];
-    const denied = [];
-    for (const tc of toolCalls) {
-        const name = tc.function.name;
-        const rule = ruleMap.get(name);
-        if (rule?.decision === "denied") {
-            denied.push({ toolCall: tc, reason: `tool "${name}" denied by sidechain policy: ${rule.reason}` });
-        }
-        else if (deniedSet.has(name)) {
-            denied.push({ toolCall: tc, reason: `tool "${name}" is in sidechain deny list` });
-        }
-        else {
-            allowed.push(tc);
-        }
-    }
-    return { allowed, denied };
-}
-export function listSidechainTypePolicies() {
-    return SIDECHAIN_TYPE_VALUES.map((type) => SIDECHAIN_TYPE_POLICY_MAP[type]);
-}
-export function resolveSidechainTypePolicy(type) {
-    return SIDECHAIN_TYPE_POLICY_MAP[type];
-}
-export function resolveRepairSidechainType(params = {}) {
-    if (params.preferCodeRepair) {
-        return "code-repair";
-    }
-    const trigger = typeof params.trigger === "string" ? params.trigger.trim().toLowerCase() : "";
-    if (trigger.includes("code") || trigger.includes("patch") || trigger.includes("workspace")) {
-        return "code-repair";
-    }
-    const toolNames = Array.from(params.toolNames ?? []).map((toolName) => toolName.trim().toLowerCase()).filter(Boolean);
-    const codeRepairHints = ["code", "edit", "patch", "diff", "file", "workspace", "git", "terminal"];
-    return toolNames.some((toolName) => codeRepairHints.some((hint) => toolName.includes(hint)))
-        ? "code-repair"
-        : "plan-repair";
-}
-export function resolveSidechainMergePolicyByType(type, overrides = {}) {
-    const policy = resolveSidechainTypePolicy(type);
-    return resolveSidechainMergePolicy({
-        forceManualReview: overrides.forceManualReview,
-        preferFullContext: overrides.preferFullContext ?? policy.preferFullContext,
-        preserveConversationHistory: overrides.preserveConversationHistory ?? policy.preserveConversationHistory,
-    });
-}
-export function resolveSidechainMergePolicy(params = {}) {
-    if (params.forceManualReview) {
-        return "manual";
-    }
-    if (params.preferFullContext) {
-        return params.preserveConversationHistory ? "append-messages" : "replace-context";
-    }
-    return "summary-only";
-}
-export { applyToolChoiceCompatibility, applyToolChoicePolicy, filterEligibleTools, normalizeAnthropicFunctionToolDefinition, normalizeAnthropicToolChoice, } from "./tool-choice-policy.js";
-export { downgradeOpenAiFunctionCallReasoningPairs, downgradeOpenAiReasoningBlocks, ensureAssistantReasoningContent, injectDanglingToolCallPlaceholders, repairOpenAiChatConversation, repairOpenAiResponsesItems, sanitizeOpenAiChatMessages, stripForcedStopAssistantToolMetadata, } from "./conversation-repair.js";
-export { classifyFailoverReason, classifyFailoverReasonFromHttpStatus, isCloudflareOrHtmlErrorPage, isFailoverErrorMessage, isModelNotFoundErrorMessage, isTimeoutErrorMessage, isTransientHttpError, } from "./failover-classification.js";
-export { FailoverError, coerceToFailoverError, describeFailoverError, isFailoverError, isTimeoutError, resolveFailoverReasonFromError, resolveFailoverStatus, } from "./failover-error.js";
-export { repairToolCallInputs, repairToolUseResultPairing, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails, stripTransientErrorMessages, } from "./transcript-repair.js";
-export { normalizeParallelToolCallsPreference, resolveParallelToolCallScheduling, } from "./parallel-tool-calls.js";
-export { advanceToolLoopState, createToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, } from "./tool-loop-state.js";
-export { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, } from "./memory-provider.js";
-export { hasAlreadyFlushedForCurrentCompaction, resolveMemoryFlushProjection, resolveMemoryFlushReadPlan, shouldRunMemoryFlush, } from "./memory-flush-policy.js";
-export { executeBoundedRetryLoop, resolveScaledRetryIterations, } from "./retry-loop.js";
-export { buildAssistantFailoverErrorDetails, pickFallbackThinkingLevel, resolveAssistantFailureActionDecision, resolveAuthProfileFailoverReason, resolveFallbackThinkingDecision, resolvePromptErrorPolicy, resolvePromptFailureActionDecision, resolveRetryableFailureReason, shouldAttemptAssistantFailureRotation, shouldAttemptPromptFailureRotation, } from "./embedded-failover-policy.js";
-export { buildApprovalAwareReason, buildApprovalStepContext, summarizeApprovalAwareToolPlan, } from "./approval-aware-tool-plan.js";
-export { resolveWebBrowserPolicy, } from "./web-browser-policy.js";
-export { applyCacheMarkers, computeCacheBreakpoints, createCacheBreakDetectionState, DEFAULT_PROMPT_CACHE_POLICY, detectCacheBreaks, estimateCacheSavingsRatio, quickHash, resolveForkCacheMarkerIndex, } from "./prompt-cache-strategy.js";
-export { computeLifecycleTransitions, DEFAULT_CURATOR_SCHEDULE_POLICY, INITIAL_CURATOR_STATE, selectReviewCandidates, shouldRunCurator, } from "./curator-scheduler.js";
-export { buildConsolidationPrompt, buildCuratorRunSummary, detectPrefixClusters, parseConsolidationOutput, reconcileConsolidationPlan, } from "./skill-consolidation.js";
-export { bigramSimilarity, computeSimilarity, decideSimilarityAction, DEFAULT_SKILL_SIMILARITY_POLICY, findSimilarSkills, stepCountProximity, toolSetJaccard, } from "./skill-similarity.js";
-export { aggregateTeamResults, allocateTokenBudgets, buildAgentTaskPrompt, inferAggregationPolicy, inferExecutionMode, mapRoleToSidechainType, resolveAgentToolAccess, resolveExecutionOrder, resolveTeamPlan, shouldCancelTeam, TEAM_MAX_AGENTS, TEAM_MAX_DEPTH, validateTeamPlan, } from "./team-orchestration.js";
-export { canDispatchDuringStreaming, createStreamingToolExecutor, } 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, } from "./fork-subagent.js";
-export { getBuiltInAgent, getBuiltInAgents, isBuiltInAgent, resolveAgentToolSet, } from "./agent-registry.js";
-export { calculateTokenWarningState, createTurnLoopGuardState, resolveApiErrorRecovery, resolveOutputTokenEscalation, shouldAbortTurn, } from "./turn-loop-guard.js";
-export { buildPostCompactRestorationMessage, computeToolDelta, createReactiveCompactState, DEFAULT_REACTIVE_COMPACT_CONFIG, shouldAttemptReactiveCompact, } from "./reactive-compact.js";
-export { aggregateTeamToolResults, mapTeamRequestToForkConfigs, resolveTeamExecutionPlan, } from "./team-tool-loop-wiring.js";

package/dist/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;