qlogicagent 2.13.4 → 2.13.5

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

@@ -0,0 +1,134 @@
+/**
+ * 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

@@ -0,0 +1,73 @@
+/**
+ * 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

@@ -0,0 +1,78 @@
+/**
+ * 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

@@ -0,0 +1,86 @@
+/**
+ * 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

@@ -0,0 +1,100 @@
+/**
+ * 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

@@ -0,0 +1,167 @@
+/**
+ * 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;
+}