qlogicagent 2.13.5 → 2.13.6

package/dist/orchestration/context/context-collapse.js

@@ -1,134 +0,0 @@
-/**
- * Context Collapse — staged lightweight context reduction that runs
- * BEFORE autocompact and can drain on 413 BEFORE reactive compact.
- *
- * CC parity: services/contextCollapse/index.ts
- *
- * Architecture:
- * 1. applyCollapsesIfNeeded() — runs every iteration, projects the
- *    collapsed view and maybe commits more collapses (by summarizing
- *    old tool-result groups into compact summaries).
- * 2. recoverFromOverflow() — drain all staged collapses on a real
- *    API 413. If it can free enough context, the retry may succeed
- *    without reactive compact (which is heavier and destroys more
- *    context).
- *
- * Collapses are ordered "stages" — oldest first. Each stage replaces
- * a contiguous run of old messages with a single summary line.
- */
-export function createCollapseStore() {
-    return { stages: [] };
-}
-/**
- * Evaluate whether new collapses should be staged.
- *
- * Heuristic: if the conversation has > thresholdMessages non-system messages,
- * group old tool-result runs into collapse stages.
- */
-export function applyCollapsesIfNeeded(messages, store, opts) {
-    const threshold = opts?.thresholdMessages ?? 40;
-    const nonSystem = messages.filter((m) => m.role !== "system");
-    if (nonSystem.length <= threshold) {
-        return { messages, stagedCount: 0 };
-    }
-    // Project already-committed stages
-    let projected = projectCommittedStages(messages, store);
-    // Stage new collapses for old tool-result runs
-    const newStages = identifyCollapseTargets(projected, store, threshold);
-    if (newStages.length === 0) {
-        return { messages: projected, stagedCount: 0 };
-    }
-    for (const stage of newStages) {
-        store.stages.push(stage);
-    }
-    // Re-project with new stages
-    projected = projectCommittedStages(messages, store);
-    return { messages: projected, stagedCount: newStages.length };
-}
-/**
- * Drain all staged (uncommitted) collapses — called on 413 recovery.
- * Commits every pending stage and returns the collapsed messages.
- */
-export function recoverFromOverflow(messages, store) {
-    let committedCount = 0;
-    for (const stage of store.stages) {
-        if (!stage.committed) {
-            stage.committed = true;
-            committedCount++;
-        }
-    }
-    if (committedCount === 0) {
-        return { messages, committed: 0 };
-    }
-    return { messages: applyCommittedCollapses(messages, store), committed: committedCount };
-}
-// ── Internal helpers ────────────────────────────────────────
-function projectCommittedStages(messages, store) {
-    const committedStages = store.stages.filter((s) => s.committed);
-    if (committedStages.length === 0)
-        return messages;
-    return applyCommittedCollapses(messages, store);
-}
-function applyCommittedCollapses(messages, store) {
-    const committed = store.stages
-        .filter((s) => s.committed)
-        .sort((a, b) => b.range[0] - a.range[0]); // reverse order to maintain indices
-    const result = [...messages];
-    for (const stage of committed) {
-        const [start, end] = stage.range;
-        if (start >= result.length)
-            continue;
-        const safeEnd = Math.min(end, result.length);
-        const summaryMsg = { role: "system", content: stage.summary };
-        result.splice(start, safeEnd - start, summaryMsg);
-    }
-    return result;
-}
-/**
- * Identify contiguous runs of old tool-result messages that can be collapsed.
- * Only targets messages before the "recent" window (threshold / 2 from end).
- */
-function identifyCollapseTargets(messages, store, threshold) {
-    const recentBoundary = Math.max(0, messages.length - Math.floor(threshold / 2));
-    const stages = [];
-    const existingRanges = new Set(store.stages.map((s) => `${s.range[0]}-${s.range[1]}`));
-    let runStart = -1;
-    let runCount = 0;
-    for (let i = 0; i < recentBoundary; i++) {
-        const msg = messages[i];
-        const isToolResult = msg.role === "tool" || (msg.role === "assistant" && typeof msg.content === "string" && msg.content === "");
-        if (isToolResult) {
-            if (runStart < 0)
-                runStart = i;
-            runCount++;
-        }
-        else {
-            if (runCount >= 3) {
-                const key = `${runStart}-${runStart + runCount}`;
-                if (!existingRanges.has(key)) {
-                    stages.push({
-                        id: `collapse_${runStart}_${runStart + runCount}`,
-                        range: [runStart, runStart + runCount],
-                        summary: `[${runCount} tool results collapsed]`,
-                        committed: false,
-                    });
-                }
-            }
-            runStart = -1;
-            runCount = 0;
-        }
-    }
-    // Flush trailing run
-    if (runCount >= 3) {
-        const key = `${runStart}-${runStart + runCount}`;
-        if (!existingRanges.has(key)) {
-            stages.push({
-                id: `collapse_${runStart}_${runStart + runCount}`,
-                range: [runStart, runStart + runCount],
-                summary: `[${runCount} tool results collapsed]`,
-                committed: false,
-            });
-        }
-    }
-    return stages;
-}

package/dist/orchestration/context/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/orchestration/context/reactive-compact.js

@@ -1,78 +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 const DEFAULT_REACTIVE_COMPACT_CONFIG = {
-    maxConsecutiveFailures: 3,
-    minMessagesAfterCompact: 4,
-    targetUsagePercent: 50,
-};
-/**
- * Build the restoration message to inject after a compact operation.
- * This ensures critical state survives context compression.
- */
-export function buildPostCompactRestorationMessage(payload) {
-    const sections = [];
-    if (payload.todoList && payload.todoList.length > 0) {
-        const todoLines = payload.todoList.map((t) => `  ${t.status === "completed" ? "[x]" : t.status === "in-progress" ? "[~]" : "[ ]"} #${t.id}: ${t.title}`);
-        sections.push(`## Active Todo List\n${todoLines.join("\n")}`);
-    }
-    if (payload.activeSkillContext) {
-        sections.push(`## Active Skill: ${payload.activeSkillContext.name}\nStep ${payload.activeSkillContext.step}:\n${payload.activeSkillContext.instructions}`);
-    }
-    if (payload.toolDelta && (payload.toolDelta.added.length > 0 || payload.toolDelta.removed.length > 0)) {
-        const lines = [];
-        if (payload.toolDelta.added.length > 0) {
-            lines.push(`New tools available: ${payload.toolDelta.added.join(", ")}`);
-        }
-        if (payload.toolDelta.removed.length > 0) {
-            lines.push(`Tools no longer available: ${payload.toolDelta.removed.join(", ")}`);
-        }
-        sections.push(`## Tool Changes\n${lines.join("\n")}`);
-    }
-    if (payload.customBlocks) {
-        for (const block of payload.customBlocks) {
-            sections.push(`## ${block.label}\n${block.content}`);
-        }
-    }
-    if (sections.length === 0)
-        return null;
-    return `[Context was compressed. The following state has been restored:]\n\n${sections.join("\n\n")}`;
-}
-export function createReactiveCompactState() {
-    return {
-        consecutiveFailures: 0,
-        attemptedThisTurn: false,
-        lastCompactAt: null,
-        toolsAtLastCompact: [],
-    };
-}
-/**
- * Determine if reactive compact should be attempted.
- */
-export function shouldAttemptReactiveCompact(state, config = DEFAULT_REACTIVE_COMPACT_CONFIG) {
-    if (state.attemptedThisTurn)
-        return false;
-    if (state.consecutiveFailures >= config.maxConsecutiveFailures)
-        return false;
-    return true;
-}
-/**
- * Calculate the tool delta since last compact.
- */
-export function computeToolDelta(currentTools, toolsAtLastCompact) {
-    const currentSet = new Set(currentTools);
-    const lastSet = new Set(toolsAtLastCompact);
-    const added = currentTools.filter((t) => !lastSet.has(t));
-    const removed = toolsAtLastCompact.filter((t) => !currentSet.has(t));
-    return { added, removed };
-}

package/dist/orchestration/context/turn-loop-guard.d.ts

@@ -1,86 +0,0 @@
-/**
- * Turn Loop Guard — Abort signal + token budget warning for preventive termination.
- *
- * Aligned with Claude Code's multi-condition termination:
- * 1. AbortSignal from user cancellation
- * 2. Token budget pre-check (don't send API call if over budget)
- * 3. max_output_tokens escalation on truncation
- * 4. Prompt-too-long reactive compact trigger
- */
-export interface TurnLoopGuardConfig {
-    /** Context window size in tokens. */
-    contextWindowTokens: number;
-    /** Buffer reserved for response (default: 13000). */
-    responseBufferTokens: number;
-    /** Max output tokens for current model. */
-    maxOutputTokens: number;
-    /** Abort signal for user cancellation. */
-    abortSignal?: AbortSignal;
-    /** Whether reactive compact is available. */
-    reactiveCompactEnabled: boolean;
-    /** Whether max_output_tokens escalation is allowed. */
-    outputEscalationEnabled: boolean;
-}
-export type TokenWarningState = {
-    level: "ok";
-} | {
-    level: "warning";
-    usagePercent: number;
-    remainingTokens: number;
-} | {
-    level: "blocking";
-    usagePercent: number;
-    reason: "prompt_too_long" | "budget_exhausted";
-};
-export interface TurnLoopGuardState {
-    /** Current accumulated prompt tokens. */
-    promptTokens: number;
-    /** Whether reactive compact has already been attempted this turn. */
-    hasAttemptedReactiveCompact: boolean;
-    /** Current max_output_tokens (may escalate). */
-    currentMaxOutputTokens: number;
-    /** Number of consecutive max_tokens truncations. */
-    consecutiveTruncations: number;
-    /** Whether the turn has been aborted. */
-    aborted: boolean;
-}
-/** Initial guard state. */
-export declare function createTurnLoopGuardState(config: TurnLoopGuardConfig): TurnLoopGuardState;
-/**
- * Calculate token warning state before making an API call.
- * If level is "blocking", do NOT send the API call.
- */
-export declare function calculateTokenWarningState(state: TurnLoopGuardState, config: TurnLoopGuardConfig): TokenWarningState;
-/**
- * Handle API error and determine recovery action.
- */
-export type ApiErrorRecovery = {
-    action: "reactive_compact";
-} | {
-    action: "escalate_output_tokens";
-    newMax: number;
-} | {
-    action: "retry";
-    reason: string;
-} | {
-    action: "abort";
-    reason: string;
-};
-export declare function resolveApiErrorRecovery(error: {
-    type?: string;
-    status?: number;
-    message?: string;
-}, state: TurnLoopGuardState, config: TurnLoopGuardConfig): ApiErrorRecovery;
-/**
- * Handle finish_reason === "max_tokens" — escalate max_output_tokens.
- *
- * CC pattern: double the output token budget up to model max.
- */
-export declare function resolveOutputTokenEscalation(state: TurnLoopGuardState, config: TurnLoopGuardConfig, modelMaxOutput: number): {
-    shouldEscalate: boolean;
-    newMax: number;
-};
-/**
- * Check if the turn should be aborted (user cancellation).
- */
-export declare function shouldAbortTurn(state: TurnLoopGuardState, config: TurnLoopGuardConfig): boolean;

package/dist/orchestration/context/turn-loop-guard.js

@@ -1,100 +0,0 @@
-/**
- * Turn Loop Guard — Abort signal + token budget warning for preventive termination.
- *
- * Aligned with Claude Code's multi-condition termination:
- * 1. AbortSignal from user cancellation
- * 2. Token budget pre-check (don't send API call if over budget)
- * 3. max_output_tokens escalation on truncation
- * 4. Prompt-too-long reactive compact trigger
- */
-/** Initial guard state. */
-export function createTurnLoopGuardState(config) {
-    return {
-        promptTokens: 0,
-        hasAttemptedReactiveCompact: false,
-        currentMaxOutputTokens: config.maxOutputTokens,
-        consecutiveTruncations: 0,
-        aborted: config.abortSignal?.aborted ?? false,
-    };
-}
-/**
- * Calculate token warning state before making an API call.
- * If level is "blocking", do NOT send the API call.
- */
-export function calculateTokenWarningState(state, config) {
-    if (state.aborted) {
-        return { level: "blocking", usagePercent: 100, reason: "budget_exhausted" };
-    }
-    const effectiveLimit = config.contextWindowTokens - config.responseBufferTokens - state.currentMaxOutputTokens;
-    const usagePercent = effectiveLimit > 0 ? (state.promptTokens / effectiveLimit) * 100 : 100;
-    if (state.promptTokens >= effectiveLimit) {
-        if (state.hasAttemptedReactiveCompact || !config.reactiveCompactEnabled) {
-            return { level: "blocking", usagePercent, reason: "prompt_too_long" };
-        }
-        return { level: "blocking", usagePercent, reason: "prompt_too_long" };
-    }
-    // Warning at 85%
-    if (usagePercent >= 85) {
-        return { level: "warning", usagePercent, remainingTokens: effectiveLimit - state.promptTokens };
-    }
-    return { level: "ok" };
-}
-export function resolveApiErrorRecovery(error, state, config) {
-    const msg = error.message?.toLowerCase() ?? "";
-    const status = error.status ?? 0;
-    // Prompt too long (413 or specific error message)
-    if (status === 413 || msg.includes("prompt_too_long") || msg.includes("context_length_exceeded")) {
-        if (!state.hasAttemptedReactiveCompact && config.reactiveCompactEnabled) {
-            return { action: "reactive_compact" };
-        }
-        return { action: "abort", reason: "prompt_too_long_unrecoverable" };
-    }
-    // 5xx transient errors
-    if (status >= 500 && status < 600) {
-        return { action: "retry", reason: `server_error_${status}` };
-    }
-    // Rate limit
-    if (status === 429) {
-        return { action: "retry", reason: "rate_limited" };
-    }
-    // Auth errors (401/403) — non-retryable, clear reason
-    if (status === 401 || status === 403) {
-        return { action: "abort", reason: "auth_error" };
-    }
-    // Model/endpoint not found (404) — non-retryable
-    if (status === 404) {
-        return { action: "abort", reason: "model_not_found" };
-    }
-    return { action: "abort", reason: msg || "unknown_error" };
-}
-/**
- * Handle finish_reason === "max_tokens" — escalate max_output_tokens.
- *
- * CC pattern: double the output token budget up to model max.
- */
-export function resolveOutputTokenEscalation(state, config, modelMaxOutput) {
-    if (!config.outputEscalationEnabled) {
-        return { shouldEscalate: false, newMax: state.currentMaxOutputTokens };
-    }
-    // Don't escalate more than 3 times
-    if (state.consecutiveTruncations >= 3) {
-        return { shouldEscalate: false, newMax: state.currentMaxOutputTokens };
-    }
-    const newMax = Math.min(state.currentMaxOutputTokens * 2, modelMaxOutput);
-    if (newMax <= state.currentMaxOutputTokens) {
-        return { shouldEscalate: false, newMax: state.currentMaxOutputTokens };
-    }
-    return { shouldEscalate: true, newMax };
-}
-/**
- * Check if the turn should be aborted (user cancellation).
- */
-export function shouldAbortTurn(state, config) {
-    if (state.aborted)
-        return true;
-    if (config.abortSignal?.aborted) {
-        state.aborted = true;
-        return true;
-    }
-    return false;
-}

package/dist/orchestration/dag-scheduler.d.ts

@@ -1,167 +0,0 @@
-/**
- * DAG Scheduler v2 — unified scheduling for Product + Automation modes.
- *
- * Single-track model: one algorithm, no compat shims, no legacy paths.
- * Product mode = flat DAG (kind:"agent", no conditions, no loops) — strict subset.
- *
- * Spec: docs/dag-scheduler-v2-spec.md
- */
-import type { ProductTaskStatus } from "../protocol/wire/acp-agent-management.js";
-/**
- * Loop safety hard ceiling (plan D15): a loop controller's `maxIterations` is required and may
- * never exceed this. Unattended/triggered runs must not be able to declare an effectively
- * unbounded loop, so a value above the cap is rejected fail-loud at construction — not clamped.
- */
-export declare const LOOP_MAX_ITERATIONS_HARD_CAP = 1000;
-/** Unified node status; "skipped" is a terminal success (intentionally not run). */
-export type NodeStatus = ProductTaskStatus;
-/**
- * Fully-materialized runtime node (constructed from NodeDef, never partial).
- * Internal to the scheduler — do not mutate directly outside DagScheduler.
- */
-export interface Node {
-    id: string;
-    kind: string;
-    params: Record<string, unknown>;
-    status: NodeStatus;
-    outPorts: string[];
-    joinPolicy: "all" | "any";
-    firedPorts?: string[];
-    output?: unknown;
-    error?: string;
-    startedAt?: number;
-    completedAt?: number;
-    runIndex: number;
-    maxIterations?: number;
-    iteration?: number;
-}
-/** Declarative input for the constructor. Edges derived from dependsOn. */
-export interface NodeDef {
-    id: string;
-    kind?: string;
-    params?: Record<string, unknown>;
-    dependsOn?: string[];
-    outPorts?: string[];
-    joinPolicy?: "all" | "any";
-    maxIterations?: number;
-}
-export interface Edge {
-    from: string;
-    to: string;
-    fromPort?: string;
-    loopBack?: boolean;
-}
-export declare class DagScheduler {
-    private nodes;
-    private edges;
-    constructor(defs: NodeDef[]);
-    getNode(id: string): Node | undefined;
-    getAllNodes(): Node[];
-    /**
-     * Ready = pending + all forward incoming edges satisfied (or no incoming edges).
-     * Spec §3.1.
-     */
-    getReadyNodes(): Node[];
-    isFinished(): boolean;
-    /** All nodes completed or skipped (skipped = intentionally not run, counts as success). */
-    isAllCompleted(): boolean;
-    getBlockedNodes(): Node[];
-    getProgress(): {
-        total: number;
-        completed: number;
-        running: number;
-        failed: number;
-        pending: number;
-        paused: number;
-        skipped: number;
-    };
-    markRunning(id: string): void;
-    /**
-     * Mark completed. firedPorts omitted → all outPorts fire (agent/tool nodes).
-     * Triggers skip propagation (§3.2).
-     */
-    markCompleted(id: string, out: {
-        output?: unknown;
-        firedPorts?: string[];
-    }): void;
-    markFailed(id: string, error: string): void;
-    markPaused(id: string): void;
-    resumePaused(id: string): void;
-    markSkipped(id: string): void;
-    pauseAll(): void;
-    resumeAll(): void;
-    /**
-     * Loop controller decision (§3.3).
-     * If again && iterations remain → reset loop body, fire "loop" port.
-     * Otherwise → fire "done" port (exit).
-     */
-    decideLoop(loopId: string, again: boolean): void;
-    addNode(def: NodeDef): void;
-    /** Add multiple nodes atomically. All-or-nothing. */
-    addNodes(defs: NodeDef[]): void;
-    /**
-     * Remove a pending node. Cannot remove running or completed nodes.
-     * Removes all edges incident to this node.
-     */
-    removeNode(id: string): void;
-    /**
-     * Reset a failed node to pending. Optionally patches params (e.g. revised prompt).
-     */
-    retryNode(id: string, paramsPatch?: Record<string, unknown>): void;
-    /** Merge patch into node.params. Node must be pending. */
-    updateNodeParams(id: string, patch: Record<string, unknown>): void;
-    /** Add an explicit edge. Validates no cycle. Validates ports exist on source. */
-    addEdge(edge: Edge): void;
-    removeEdge(from: string, to: string, fromPort?: string): void;
-    serialize(): SerializedNode[];
-    /**
-     * Restore status from persisted snapshot.
-     * Running nodes become pending (need re-execution after crash).
-     * Missing fields use defaults.
-     */
-    restore(data: SerializedNode[]): void;
-    /** §3.1 edge predicate: source completed AND this port fired. */
-    private edgeSatisfied;
-    /** An edge is "dead" if the source is skipped, OR source completed but did NOT fire this port. */
-    private edgeDead;
-    private incomingForwardEdges;
-    private isBlockedByFailed;
-    /** A pending node is "skippable" if all its forward edges are dead. */
-    private isSkippable;
-    /**
-     * §3.2 Skip propagation.
-     * After markCompleted/markFailed/markSkipped, repeatedly mark pending nodes
-     * whose incoming edges are all dead as skipped.
-     * Product mode (no conditional edges) → no-op.
-     */
-    private propagateSkips;
-    /**
-     * §3.3 Reset all loop-body nodes back to pending for next iteration.
-     */
-    private resetLoopScope;
-    /**
-     * Compute the loop body: nodes reachable from the loop controller's "loop" outPort
-     * via non-loopBack forward edges, up to (but not including) the loop controller itself.
-     * The controller's "done" port leads OUT of the loop and is not part of the body.
-     */
-    private loopBodyNodes;
-    private validateDag;
-    private requireNode;
-}
-export interface SerializedNode {
-    id: string;
-    kind: string;
-    params: Record<string, unknown>;
-    dependsOn: string[];
-    outPorts: string[];
-    joinPolicy: "all" | "any";
-    status: NodeStatus;
-    firedPorts?: string[];
-    output?: unknown;
-    error?: string;
-    startedAt?: number;
-    completedAt?: number;
-    runIndex: number;
-    maxIterations?: number;
-    iteration?: number;
-}