qlogicagent 2.13.3 → 2.13.5

package/dist/orchestration/error-handling/failover-classification.js

@@ -0,0 +1,381 @@
+const PERIODIC_USAGE_LIMIT_RE = /\b(?:daily|weekly|monthly)(?:\/(?:daily|weekly|monthly))* (?:usage )?limit(?:s)?(?: (?:exhausted|reached|exceeded))?\b/i;
+const ERROR_PATTERNS = {
+    rateLimit: [
+        /rate[_ ]limit|too many requests|429/,
+        "model_cooldown",
+        "exceeded your current quota",
+        "resource has been exhausted",
+        "quota exceeded",
+        "resource_exhausted",
+        "usage limit",
+        /\btpm\b/i,
+        "tokens per minute",
+        "tokens per day",
+    ],
+    overloaded: [
+        /overloaded_error|"type"\s*:\s*"overloaded_error"/i,
+        "overloaded",
+        /service[_ ]unavailable.*(?:overload|capacity|high[_ ]demand)|(?:overload|capacity|high[_ ]demand).*service[_ ]unavailable/i,
+        "high demand",
+    ],
+    timeout: [
+        "timeout",
+        "timed out",
+        "service unavailable",
+        "deadline exceeded",
+        "context deadline exceeded",
+        "connection error",
+        "network error",
+        "network request failed",
+        "fetch failed",
+        "socket hang up",
+        /\beconn(?:refused|reset|aborted)\b/i,
+        /\benotfound\b/i,
+        /\beai_again\b/i,
+        /without sending (?:any )?chunks?/i,
+        /\bstop reason:\s*(?:abort|error|network_error)\b/i,
+        /\breason:\s*(?:abort|error|network_error)\b/i,
+        /\bunhandled stop reason:\s*(?:abort|error|network_error)\b/i,
+    ],
+    billing: [
+        /["']?(?:status|code)["']?\s*[:=]\s*402\b|\bhttp\s*402\b|\berror(?:\s+code)?\s*[:=]?\s*402\b|\b(?:got|returned|received)\s+(?:a\s+)?402\b|^\s*402\s+payment/i,
+        "payment required",
+        "insufficient credits",
+        /insufficient[_ ]quota/i,
+        "credit balance",
+        "plans & billing",
+        "insufficient balance",
+    ],
+    authPermanent: [
+        /api[_ ]?key[_ ]?(?:revoked|invalid|deactivated|deleted)/i,
+        "invalid_api_key",
+        "key has been disabled",
+        "key has been revoked",
+        "account has been deactivated",
+        /could not (?:authenticate|validate).*(?:api[_ ]?key|credentials)/i,
+        "permission_error",
+        "not allowed for this organization",
+    ],
+    auth: [
+        /invalid[_ ]?api[_ ]?key/,
+        "incorrect api key",
+        "invalid token",
+        "authentication",
+        "re-authenticate",
+        "oauth token refresh failed",
+        "unauthorized",
+        "forbidden",
+        "access denied",
+        "insufficient permissions",
+        "insufficient permission",
+        /missing scopes?:/i,
+        "expired",
+        "token has expired",
+        /\b401\b/,
+        /\b403\b/,
+        "no credentials found",
+        "no api key found",
+    ],
+    format: [
+        "string should match pattern",
+        "tool_use.id",
+        "tool_use_id",
+        "messages.1.content.1.tool_use.id",
+        "invalid request format",
+        /tool call id was.*must be/i,
+    ],
+};
+const BILLING_ERROR_HEAD_RE = /^(?:error[:\s-]+)?billing(?:\s+error)?(?:[:\s-]+|$)|^(?:error[:\s-]+)?(?:credit balance|insufficient credits?|payment required|http\s*402\b)/i;
+const BILLING_ERROR_HARD_402_RE = /["']?(?:status|code)["']?\s*[:=]\s*402\b|\bhttp\s*402\b|\berror(?:\s+code)?\s*[:=]?\s*402\b|^\s*402\s+payment/i;
+const BILLING_ERROR_MAX_LENGTH = 512;
+const HTTP_STATUS_CODE_PREFIX_RE = /^(?:http\s*)?(\d{3})(?:\s+([\s\S]+))?$/i;
+const HTML_ERROR_PREFIX_RE = /^\s*(?:<!doctype\s+html\b|<html\b)/i;
+const CLOUDFLARE_HTML_ERROR_CODES = new Set([521, 522, 523, 524, 525, 526, 530]);
+const TRANSIENT_HTTP_ERROR_CODES = new Set([500, 502, 503, 504, 521, 522, 523, 524, 529]);
+const BILLING_402_HINTS = [
+    "insufficient credits",
+    "insufficient quota",
+    "credit balance",
+    "insufficient balance",
+    "plans & billing",
+    "add more credits",
+    "top up",
+];
+const BILLING_402_PLAN_HINTS = [
+    "upgrade your plan",
+    "upgrade plan",
+    "current plan",
+    "subscription",
+];
+const PERIODIC_402_HINTS = ["daily", "weekly", "monthly"];
+const RETRYABLE_402_RETRY_HINTS = ["try again", "retry", "temporary", "cooldown"];
+const RETRYABLE_402_LIMIT_HINTS = ["usage limit", "rate limit", "organization usage"];
+const RETRYABLE_402_SCOPED_HINTS = ["organization", "workspace"];
+const RETRYABLE_402_SCOPED_RESULT_HINTS = ["billing period", "exceeded", "reached", "exhausted"];
+const RAW_402_MARKER_RE = /["']?(?:status|code)["']?\s*[:=]\s*402\b|\bhttp\s*402\b|\berror(?:\s+code)?\s*[:=]?\s*402\b|\b(?:got|returned|received)\s+(?:a\s+)?402\b|^\s*402\s+payment required\b/i;
+const LEADING_402_WRAPPER_RE = /^(?:error[:\s-]+)?(?:(?:http\s*)?402(?:\s+payment required)?|payment required)(?:[:\s-]+|$)/i;
+function matchesErrorPatterns(raw, patterns) {
+    if (!raw) {
+        return false;
+    }
+    const value = raw.toLowerCase();
+    return patterns.some((pattern) => pattern instanceof RegExp ? pattern.test(value) : value.includes(pattern));
+}
+function matchesFormatErrorPattern(raw) {
+    return matchesErrorPatterns(raw, ERROR_PATTERNS.format);
+}
+function isRateLimitErrorMessage(raw) {
+    return matchesErrorPatterns(raw, ERROR_PATTERNS.rateLimit);
+}
+export function isTimeoutErrorMessage(raw) {
+    return matchesErrorPatterns(raw, ERROR_PATTERNS.timeout);
+}
+function isPeriodicUsageLimitErrorMessage(raw) {
+    return PERIODIC_USAGE_LIMIT_RE.test(raw);
+}
+function isBillingErrorMessage(raw) {
+    const value = raw.toLowerCase();
+    if (!value) {
+        return false;
+    }
+    if (raw.length > BILLING_ERROR_MAX_LENGTH) {
+        return BILLING_ERROR_HARD_402_RE.test(value);
+    }
+    if (matchesErrorPatterns(value, ERROR_PATTERNS.billing)) {
+        return true;
+    }
+    if (!BILLING_ERROR_HEAD_RE.test(raw)) {
+        return false;
+    }
+    return (value.includes("upgrade") ||
+        value.includes("credits") ||
+        value.includes("payment") ||
+        value.includes("plan"));
+}
+function isAuthPermanentErrorMessage(raw) {
+    return matchesErrorPatterns(raw, ERROR_PATTERNS.authPermanent);
+}
+function isAuthErrorMessage(raw) {
+    return matchesErrorPatterns(raw, ERROR_PATTERNS.auth);
+}
+function isOverloadedErrorMessage(raw) {
+    return matchesErrorPatterns(raw, ERROR_PATTERNS.overloaded);
+}
+function includesAnyHint(text, hints) {
+    return hints.some((hint) => text.includes(hint));
+}
+function hasExplicit402BillingSignal(text) {
+    return (includesAnyHint(text, BILLING_402_HINTS) ||
+        (includesAnyHint(text, BILLING_402_PLAN_HINTS) && text.includes("limit")) ||
+        text.includes("billing hard limit") ||
+        text.includes("hard limit reached") ||
+        (text.includes("maximum allowed") && text.includes("limit")));
+}
+function hasRetryable402TransientSignal(text) {
+    const hasPeriodicHint = includesAnyHint(text, PERIODIC_402_HINTS);
+    const hasSpendLimit = text.includes("spend limit") || text.includes("spending limit");
+    const hasScopedHint = includesAnyHint(text, RETRYABLE_402_SCOPED_HINTS);
+    return ((includesAnyHint(text, RETRYABLE_402_RETRY_HINTS) &&
+        includesAnyHint(text, RETRYABLE_402_LIMIT_HINTS)) ||
+        (hasPeriodicHint && (text.includes("usage limit") || hasSpendLimit)) ||
+        (hasPeriodicHint && text.includes("limit") && text.includes("reset")) ||
+        (hasScopedHint &&
+            text.includes("limit") &&
+            (hasSpendLimit || includesAnyHint(text, RETRYABLE_402_SCOPED_RESULT_HINTS))));
+}
+function normalize402Message(raw) {
+    return raw.trim().toLowerCase().replace(LEADING_402_WRAPPER_RE, "").trim();
+}
+function classify402Message(message) {
+    const normalized = normalize402Message(message);
+    if (!normalized) {
+        return "billing";
+    }
+    if (hasExplicit402BillingSignal(normalized)) {
+        return "billing";
+    }
+    if (isRateLimitErrorMessage(normalized)) {
+        return "rate_limit";
+    }
+    if (hasRetryable402TransientSignal(normalized)) {
+        return "rate_limit";
+    }
+    return "billing";
+}
+function classifyFailoverReasonFrom402Text(raw) {
+    if (!RAW_402_MARKER_RE.test(raw)) {
+        return null;
+    }
+    return classify402Message(raw);
+}
+function extractLeadingHttpStatus(raw) {
+    const match = raw.match(HTTP_STATUS_CODE_PREFIX_RE);
+    if (!match) {
+        return null;
+    }
+    const code = Number(match[1]);
+    if (!Number.isFinite(code)) {
+        return null;
+    }
+    return { code, rest: (match[2] ?? "").trim() };
+}
+function isJsonApiInternalServerError(raw) {
+    if (!raw) {
+        return false;
+    }
+    const value = raw.toLowerCase();
+    return value.includes('"type":"api_error"') && value.includes("internal server error");
+}
+export function isCloudflareOrHtmlErrorPage(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const status = extractLeadingHttpStatus(trimmed);
+    if (!status || status.code < 500) {
+        return false;
+    }
+    if (CLOUDFLARE_HTML_ERROR_CODES.has(status.code)) {
+        return true;
+    }
+    return status.code < 600 && HTML_ERROR_PREFIX_RE.test(status.rest) && /<\/html>/i.test(status.rest);
+}
+export function isTransientHttpError(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const status = extractLeadingHttpStatus(trimmed);
+    if (!status) {
+        return false;
+    }
+    return TRANSIENT_HTTP_ERROR_CODES.has(status.code);
+}
+export function classifyFailoverReasonFromHttpStatus(status, message) {
+    if (typeof status !== "number" || !Number.isFinite(status)) {
+        return null;
+    }
+    if (status === 402) {
+        return message ? classify402Message(message) : "billing";
+    }
+    if (status === 429) {
+        return "rate_limit";
+    }
+    if (status === 401 || status === 403) {
+        if (message && isAuthPermanentErrorMessage(message)) {
+            return "auth_permanent";
+        }
+        return "auth";
+    }
+    if (status === 408) {
+        return "timeout";
+    }
+    if (status === 503) {
+        if (message && isOverloadedErrorMessage(message)) {
+            return "overloaded";
+        }
+        return "timeout";
+    }
+    if (status === 502 || status === 504) {
+        return "timeout";
+    }
+    if (status === 529) {
+        return "overloaded";
+    }
+    if (status === 400) {
+        if (message && isBillingErrorMessage(message)) {
+            return "billing";
+        }
+        return "format";
+    }
+    return null;
+}
+export function isModelNotFoundErrorMessage(raw) {
+    if (!raw) {
+        return false;
+    }
+    const lower = raw.toLowerCase();
+    if (lower.includes("unknown model") ||
+        lower.includes("model not found") ||
+        lower.includes("model_not_found") ||
+        lower.includes("not_found_error") ||
+        (lower.includes("does not exist") && lower.includes("model")) ||
+        (lower.includes("invalid model") && !lower.includes("invalid model reference"))) {
+        return true;
+    }
+    if (/models\/[^\s]+ is not found/i.test(raw)) {
+        return true;
+    }
+    if (/\b404\b/.test(raw) && /not[-_ ]?found/i.test(raw)) {
+        return true;
+    }
+    return false;
+}
+function isCliSessionExpiredErrorMessage(raw) {
+    if (!raw) {
+        return false;
+    }
+    const lower = raw.toLowerCase();
+    return (lower.includes("session not found") ||
+        lower.includes("session does not exist") ||
+        lower.includes("session expired") ||
+        lower.includes("session invalid") ||
+        lower.includes("conversation not found") ||
+        lower.includes("conversation does not exist") ||
+        lower.includes("conversation expired") ||
+        lower.includes("conversation invalid") ||
+        lower.includes("no such session") ||
+        lower.includes("invalid session") ||
+        lower.includes("session id not found") ||
+        lower.includes("conversation id not found"));
+}
+export function classifyFailoverReason(raw) {
+    if (isCliSessionExpiredErrorMessage(raw)) {
+        return "session_expired";
+    }
+    if (isModelNotFoundErrorMessage(raw)) {
+        return "model_not_found";
+    }
+    const reasonFrom402Text = classifyFailoverReasonFrom402Text(raw);
+    if (reasonFrom402Text) {
+        return reasonFrom402Text;
+    }
+    if (isPeriodicUsageLimitErrorMessage(raw)) {
+        return isBillingErrorMessage(raw) ? "billing" : "rate_limit";
+    }
+    if (isRateLimitErrorMessage(raw)) {
+        return "rate_limit";
+    }
+    if (isOverloadedErrorMessage(raw)) {
+        return "overloaded";
+    }
+    if (isTransientHttpError(raw)) {
+        const status = extractLeadingHttpStatus(raw.trim());
+        if (status?.code === 529) {
+            return "overloaded";
+        }
+        return "timeout";
+    }
+    if (isJsonApiInternalServerError(raw)) {
+        return "timeout";
+    }
+    if (matchesFormatErrorPattern(raw)) {
+        return "format";
+    }
+    if (isBillingErrorMessage(raw)) {
+        return "billing";
+    }
+    if (isTimeoutErrorMessage(raw)) {
+        return "timeout";
+    }
+    if (isAuthPermanentErrorMessage(raw)) {
+        return "auth_permanent";
+    }
+    if (isAuthErrorMessage(raw)) {
+        return "auth";
+    }
+    return null;
+}
+export function isFailoverErrorMessage(raw) {
+    return classifyFailoverReason(raw) !== null;
+}

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

@@ -0,0 +1,69 @@
+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;
+export declare function isForegroundSource(source: string | undefined): boolean;
+/** Is this a transient capacity error (429 or 529/overloaded)? */
+export declare function isTransientCapacityError(status: number | undefined): boolean;
+/**
+ * Compute exponential backoff delay with jitter.
+ * CC parity: withRetry.ts — BASE_DELAY_MS=500, 2^n backoff, capped.
+ */
+export declare function computeRetryBackoff(attempt: number, baseDelayMs?: number, maxDelayMs?: number): number;
+/**
+ * Persistent retry mode — for unattended sessions.
+ * Retries 429/529 indefinitely with higher backoff.
+ * Yields heartbeat events periodically so the host doesn't mark us idle.
+ *
+ * CC parity: withRetry.ts CLAUDE_CODE_UNATTENDED_RETRY
+ */
+export interface PersistentRetryConfig {
+    /** Max backoff interval (CC: 5 min). */
+    maxBackoffMs: number;
+    /** Total cap before giving up (CC: 6 hours). */
+    resetCapMs: number;
+    /** Heartbeat interval during waits (CC: 30 seconds). */
+    heartbeatIntervalMs: number;
+}
+export declare const DEFAULT_PERSISTENT_RETRY_CONFIG: PersistentRetryConfig;
+/**
+ * Check if persistent retry is enabled via environment variable.
+ * 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
+ */
+export declare class CannotRetryError extends Error {
+    readonly originalError: unknown;
+    readonly model: string;
+    constructor(originalError: unknown, model: string);
+}

package/dist/orchestration/error-handling/retry-loop.js

@@ -0,0 +1,96 @@
+export async function executeBoundedRetryLoop(params) {
+    let iterations = 0;
+    while (true) {
+        if (iterations >= params.maxIterations) {
+            return await params.onRetryLimit({
+                iterations,
+                maxIterations: params.maxIterations,
+            });
+        }
+        iterations += 1;
+        const outcome = await params.executeIteration({ iteration: iterations });
+        if (outcome.kind === "return") {
+            return outcome.result;
+        }
+    }
+}
+export function resolveScaledRetryIterations(params) {
+    const baseIterations = Math.max(0, Math.floor(params.baseIterations ?? 24));
+    const perCandidateIterations = Math.max(0, Math.floor(params.perCandidateIterations ?? 8));
+    const minIterations = Math.max(1, Math.floor(params.minIterations ?? 32));
+    const maxIterations = Math.max(minIterations, Math.floor(params.maxIterations ?? 160));
+    const scaled = baseIterations + Math.max(1, Math.floor(params.candidateCount)) * perCandidateIterations;
+    return Math.min(maxIterations, Math.max(minIterations, scaled));
+}
+// ════════════════════════════════════════════════════════════
+// CC Parity — withRetry: persistent retry + heartbeat + fallback
+// ════════════════════════════════════════════════════════════
+/**
+ * Foreground query sources that should retry on 529 (overloaded).
+ * Non-foreground sources (summaries, classifiers) bail immediately
+ * to avoid retry amplification during capacity cascades.
+ *
+ * CC parity: withRetry.ts FOREGROUND_529_RETRY_SOURCES
+ */
+const FOREGROUND_SOURCES = new Set([
+    "main", "sdk", "agent", "compact", "hook", "verification", "side_question",
+]);
+export function isForegroundSource(source) {
+    if (!source)
+        return true; // undefined → retry (conservative)
+    return FOREGROUND_SOURCES.has(source);
+}
+/** Is this a transient capacity error (429 or 529/overloaded)? */
+export function isTransientCapacityError(status) {
+    return status === 429 || status === 529;
+}
+/**
+ * Compute exponential backoff delay with jitter.
+ * CC parity: withRetry.ts — BASE_DELAY_MS=500, 2^n backoff, capped.
+ */
+export function computeRetryBackoff(attempt, baseDelayMs = 500, maxDelayMs = 32_000) {
+    const delay = Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
+    // Add 0-25% jitter to prevent thundering herd
+    return delay + Math.floor(Math.random() * delay * 0.25);
+}
+export const DEFAULT_PERSISTENT_RETRY_CONFIG = {
+    maxBackoffMs: 5 * 60 * 1000,
+    resetCapMs: 6 * 60 * 60 * 1000,
+    heartbeatIntervalMs: 30_000,
+};
+/**
+ * Check if persistent retry is enabled via environment variable.
+ * CC parity: CLAUDE_CODE_UNATTENDED_RETRY
+ */
+export function isPersistentRetryEnabled() {
+    const val = process.env.QLOGICAGENT_PERSISTENT_RETRY;
+    return val === "1" || val === "true";
+}
+/**
+ * Error class for triggering model fallback after repeated 529s.
+ * CC parity: FallbackTriggeredError
+ */
+export class FallbackTriggeredError extends Error {
+    originalModel;
+    fallbackModel;
+    constructor(originalModel, fallbackModel) {
+        super(`Model fallback triggered: ${originalModel} -> ${fallbackModel}`);
+        this.originalModel = originalModel;
+        this.fallbackModel = fallbackModel;
+        this.name = "FallbackTriggeredError";
+    }
+}
+/**
+ * Error class for when retries are exhausted and cannot continue.
+ * CC parity: CannotRetryError
+ */
+export class CannotRetryError extends Error {
+    originalError;
+    model;
+    constructor(originalError, model) {
+        super(originalError instanceof Error ? originalError.message : String(originalError));
+        this.originalError = originalError;
+        this.model = model;
+        this.name = "CannotRetryError";
+    }
+}

package/dist/orchestration/index.d.ts

@@ -0,0 +1,15 @@
+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, 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 "../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 { buildSkillInstruction, recordPatternAndCheckThreshold, getPatternStats, buildToolSignature, type SkillCreateInstruction, type SkillImproveInstruction, type SkillInstruction, type SkillTurnResult, } from "./skill-improvement.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 { 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, filterToolsByRole, type IsolationMode, type PermissionRole, type TaskType, type TaskLifecycle, type TaskState, type TaskStateBase, type LocalBashTaskState, type LocalAgentTaskState, type RemoteAgentTaskState, type TeamMemberTaskState, type DreamTaskState, type DreamTurn, type DreamPhase, } from "./subagent/task-types.js";
+export { calculateTokenWarningState, createTurnLoopGuardState, resolveApiErrorRecovery, resolveOutputTokenEscalation, shouldAbortTurn, type ApiErrorRecovery, type TokenWarningState, type TurnLoopGuardConfig, type TurnLoopGuardState, } from "./context/turn-loop-guard.js";
+export { buildPostCompactRestorationMessage, createReactiveCompactState, shouldAttemptReactiveCompact, type ReactiveCompactConfig, type ReactiveCompactState, } from "./context/reactive-compact.js";

package/dist/orchestration/index.js

@@ -0,0 +1,18 @@
+export { buildAssistantToolCallMessage, buildToolResultMessage, } from "./tool-loop/tool-schema.js";
+export { classifyError, isRetryableCategory, } from "./error-handling/error-classification.js";
+export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, MicroCompactStrategy, postCompactFileRecovery, buildStructuredSummaryPrompt, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, } from "../runtime/context/context-compression-strategies.js";
+export { snipCompactIfNeeded, } from "../runtime/context/context-compression-strategies.js";
+export { applyCollapsesIfNeeded as applyContextCollapsesIfNeeded, recoverFromOverflow as recoverContextCollapseFromOverflow, createCollapseStore, } from "./context/context-collapse.js";
+export { buildSkillInstruction, recordPatternAndCheckThreshold, getPatternStats, buildToolSignature, } from "./skill-improvement.js";
+// - Tool Access -
+// CC-aligned deny-list filtering at agent spawn time.
+// See skills/tool-access.ts for AGENT_DISALLOWED_TOOLS and filterToolsForAgent().
+export { applyToolChoicePolicy, } from "./tool-loop/tool-choice-policy.js";
+export { repairOpenAiChatConversation, } from "./tool-loop/conversation-repair.js";
+export { advanceToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, } from "./tool-loop/tool-loop-state.js";
+export { isForegroundSource, isTransientCapacityError, computeRetryBackoff, isPersistentRetryEnabled, FallbackTriggeredError, } from "./error-handling/retry-loop.js";
+export { canForkAtDepth, buildForkedMessages, buildForkPlaceholderResults, FORK_PLACEHOLDER_RESULT, FORK_SENTINEL_TAG, generateForkChildAgentId, isInForkChild, MAX_FORK_DEPTH, resolveForkChildTools, } from "./subagent/fork-subagent.js";
+export { getBuiltInAgent, getBuiltInAgents, isBuiltInAgent, resolveAgentToolSet, } from "./subagent/agent-registry.js";
+export { createTaskState, filterToolsByRole, } from "./subagent/task-types.js";
+export { calculateTokenWarningState, createTurnLoopGuardState, resolveApiErrorRecovery, resolveOutputTokenEscalation, shouldAbortTurn, } from "./context/turn-loop-guard.js";
+export { buildPostCompactRestorationMessage, createReactiveCompactState, shouldAttemptReactiveCompact, } from "./context/reactive-compact.js";

package/dist/orchestration/product-budget.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Product Budget — token/time budget enforcement for Product Mode.
+ *
+ * Tracks cumulative token usage and elapsed time across all agent instances.
+ * Emits 80% warning and enforces 100% hard limit.
+ */
+import type { ProductBudget } from "../protocol/wire/acp-agent-management.js";
+import type { AcpUsageTracker } from "../runtime/infra/acp-usage-tracker.js";
+/** Budget state and enforcement result. */
+export type BudgetAction = "ok" | "warning" | "exceeded";
+export interface BudgetCheck {
+    action: BudgetAction;
+    percentage: number;
+    usedTokens: number;
+    maxTotalTokens?: number;
+    elapsed: number;
+    maxDuration?: number;
+}
+export declare class ProductBudgetTracker {
+    private maxTotalTokens?;
+    private maxDuration?;
+    private usedTokens;
+    private startedAt;
+    private warningEmitted;
+    constructor(budget?: {
+        maxTotalTokens?: number;
+        maxDuration?: number;
+    });
+    /** Add tokens from a usage tracker snapshot. */
+    addUsage(inputTokens: number, outputTokens: number): void;
+    /** Add tokens from an ACP usage tracker. */
+    addFromTracker(tracker: AcpUsageTracker): void;
+    /** Get current elapsed time in ms. */
+    getElapsed(): number;
+    /** Get the budget snapshot. */
+    getBudget(): ProductBudget;
+    /**
+     * Check budget status. Returns:
+     * - "ok": within budget
+     * - "warning": 80%+ but not exceeded
+     * - "exceeded": over 100%, should pause
+     */
+    check(): BudgetCheck;
+    /** Restore from persisted budget data. */
+    restore(data: {
+        usedTokens: number;
+        startedAt: number;
+        warningEmitted: boolean;
+    }): void;
+    /** Serialize for persistence. */
+    serialize(): {
+        usedTokens: number;
+        startedAt: number;
+        warningEmitted: boolean;
+    };
+}