qlogicagent 0.2.1 → 0.4.0

package/dist/runtime/context-compression.d.ts

@@ -1,61 +0,0 @@
-import { ContextEngineRegistry, type CompressibleMessage, type CompressionResult, type CompressionStrategy, type AsyncCompressionStrategy, type SummarizeFn } from "../orchestration/index.js";
-import type { HookRegistry } from "./hook-registry.js";
-import type { RuntimeLogger } from "./hook-registry.js";
-import type { LLMTransport } from "../llm/transport.js";
-/** Rough token estimate: ~4 chars per token for mixed CJK/English. */
-export declare function estimateTokens(msg: CompressibleMessage): number;
-/** Estimate total tokens for a message array. */
-export declare function estimateTotalTokens(messages: CompressibleMessage[]): number;
-export declare function getCompressionMetrics(): import("../orchestration/context-compression.js").CompressionMetricsSnapshot;
-export declare function getContextEngineRegistry(): ContextEngineRegistry;
-/**
- * Create a summarization callback using an injected LLM transport.
- * For CLI mode: uses the same transport that powers the agent loop.
- * Falls back to non-LLM summary when transport/apiKey not available.
- */
-export declare function createSummarizeFn(log: RuntimeLogger, opts?: {
-    transport?: LLMTransport;
-    apiKey?: string;
-    model?: string;
-}): SummarizeFn;
-/** Phase 1: sync-only pipeline (ToolResultTrim + SlidingWindow) */
-export declare function createSyncPipeline(): CompressionStrategy;
-/** Phase 2+3: async pipeline with LLM summarization + cache awareness */
-export declare function createAsyncPipeline(summarize: SummarizeFn, opts?: {
-    onCacheInvalidated?: (info: {
-        droppedCount: number;
-        strategy: string;
-    }) => void;
-}): AsyncCompressionStrategy;
-/** Phase 2.3: incremental compaction pipeline (for partial compact) */
-export declare function createIncrementalPipeline(summarize: SummarizeFn, opts?: {
-    preserveRecentCount?: number;
-    onCacheInvalidated?: (info: {
-        droppedCount: number;
-        strategy: string;
-    }) => void;
-}): AsyncCompressionStrategy;
-export interface CompressOptions {
-    budget?: number;
-    model?: string;
-    pipeline?: CompressionStrategy;
-    allowLlm?: boolean;
-    summarize?: SummarizeFn;
-    sessionId?: string;
-}
-/** Synchronous compression (Phase 1 only). */
-export declare function compressMessages(messages: CompressibleMessage[], opts?: CompressOptions): CompressionResult;
-/** Async compression (Phase 2+) — supports LLM summarization. */
-export declare function compressMessagesAsync(messages: CompressibleMessage[], opts: CompressOptions & {
-    summarize: SummarizeFn;
-}): Promise<CompressionResult>;
-export declare function registerDefaultContextEngine(log: RuntimeLogger, opts?: {
-    transport?: LLMTransport;
-    apiKey?: string;
-    model?: string;
-}): void;
-export declare function registerContextCompressionHook(hooks: HookRegistry, log: RuntimeLogger, opts?: {
-    transport?: LLMTransport;
-    apiKey?: string;
-    model?: string;
-}): void;

package/dist/runtime/context-compression.js

@@ -1,274 +0,0 @@
-// ============================================================
-// Context Compression Bridge — wires orchestration compression
-// strategies into the Agent turn execution flow.
-//
-// Ported from src/core/runtime/context-compression-bridge.ts.
-// Key change: createSummarizeFn() accepts injected LLM transport
-// instead of hardcoding admin proxy URL. Falls back to sync summary
-// when no LLM is available (CLI standalone mode).
-//
-// Phase 1 (P0): ToolResultTrim + SlidingWindow (no LLM needed)
-// Phase 2 (P1): LLM Summarization — HeadTail + Incremental
-// Phase 3 (P1): Prompt Cache awareness
-// Phase 4 (P2): Adaptive threshold + metrics + engine plugin
-// ============================================================
-import { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, computeAdaptiveBudget, selectCompressionTier, isAsyncCompressionStrategy, } from "../orchestration/index.js";
-// ── Token estimation ───────────────────────────────────────
-/** Rough token estimate: ~4 chars per token for mixed CJK/English. */
-export function estimateTokens(msg) {
-    const text = typeof msg.content === "string"
-        ? msg.content
-        : msg.content != null
-            ? JSON.stringify(msg.content)
-            : "";
-    return Math.ceil(text.length / 4);
-}
-/** Estimate total tokens for a message array. */
-export function estimateTotalTokens(messages) {
-    let total = 0;
-    for (const msg of messages) {
-        total += estimateTokens(msg);
-    }
-    return total;
-}
-// ── Model context window lookup ────────────────────────────
-const MODEL_CONTEXT_WINDOWS = {
-    "deepseek-chat": 64_000,
-    "deepseek-reasoner": 64_000,
-    "deepseek-v4-flash": 64_000,
-    "gpt-4o": 128_000,
-    "gpt-4o-mini": 128_000,
-    "claude-sonnet-4-20250514": 200_000,
-    "claude-3-5-haiku-20241022": 200_000,
-    "gemini-2.0-flash": 1_000_000,
-    "gemini-2.5-flash-preview-05-20": 1_000_000,
-};
-function getModelContextWindow(model) {
-    if (!model)
-        return 128_000;
-    if (model in MODEL_CONTEXT_WINDOWS)
-        return MODEL_CONTEXT_WINDOWS[model];
-    const lower = model.toLowerCase();
-    for (const [key, value] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
-        if (lower.startsWith(key.toLowerCase()))
-            return value;
-    }
-    return 128_000;
-}
-// ── Constants ──────────────────────────────────────────────
-const DEFAULT_TOOL_RESULT_MAX_CHARS = 8_000;
-const SUMMARIZE_MODEL = "deepseek-chat";
-// ── Singleton metrics collector (Phase 4) ──────────────────
-const metricsCollector = new CompressionMetricsCollector(200);
-export function getCompressionMetrics() {
-    return metricsCollector.snapshot();
-}
-// ── Singleton context engine registry (Phase 4.3) ──────────
-const engineRegistry = new ContextEngineRegistry();
-export function getContextEngineRegistry() {
-    return engineRegistry;
-}
-// ── LLM Summarization Callback Factory ─────────────────────
-/**
- * Create a summarization callback using an injected LLM transport.
- * For CLI mode: uses the same transport that powers the agent loop.
- * Falls back to non-LLM summary when transport/apiKey not available.
- */
-export function createSummarizeFn(log, opts) {
-    return async (messages, instruction) => {
-        const transport = opts?.transport;
-        const apiKey = opts?.apiKey;
-        if (!transport || !apiKey) {
-            log.debug("[context-compression] no LLM transport for summarization — using sync fallback");
-            return fallbackSyncSummary(messages);
-        }
-        try {
-            let content = "";
-            const model = opts?.model ?? SUMMARIZE_MODEL;
-            for await (const chunk of transport.stream({
-                model,
-                messages: [
-                    { role: "system", content: "You are a precise conversation summarizer." },
-                    { role: "user", content: instruction },
-                ],
-                maxTokens: 2000,
-                temperature: 0.3,
-            }, apiKey, AbortSignal.timeout(30_000))) {
-                if (chunk.type === "delta")
-                    content += chunk.text;
-            }
-            if (!content) {
-                log.warn("[context-compression] empty summary response");
-                return fallbackSyncSummary(messages);
-            }
-            return content;
-        }
-        catch (err) {
-            log.warn({ err: err.message }, "[context-compression] summarize call error — using fallback");
-            return fallbackSyncSummary(messages);
-        }
-    };
-}
-/** Non-LLM fallback: extract key user messages as bullet points. */
-function fallbackSyncSummary(messages) {
-    const userMsgs = messages.filter((m) => m.role === "user");
-    const bullets = userMsgs.slice(0, 10).map((m) => {
-        const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content ?? "");
-        return `- ${text.slice(0, 200)}${text.length > 200 ? "..." : ""}`;
-    });
-    return `User requests (${userMsgs.length} messages):\n${bullets.join("\n")}`;
-}
-// ── Pipeline factories ─────────────────────────────────────
-/** Phase 1: sync-only pipeline (ToolResultTrim + SlidingWindow) */
-export function createSyncPipeline() {
-    return composeStrategies(new ToolResultTrimStrategy(DEFAULT_TOOL_RESULT_MAX_CHARS), new SlidingWindowStrategy(estimateTokens));
-}
-/** Phase 2+3: async pipeline with LLM summarization + cache awareness */
-export function createAsyncPipeline(summarize, opts) {
-    const innerPipeline = composeAsyncStrategies(new ToolResultTrimStrategy(DEFAULT_TOOL_RESULT_MAX_CHARS), new HeadTailProtectedStrategy({
-        protectedHeadExchanges: 1,
-        protectedTailMessages: 8,
-        summarize,
-        estimateTokens,
-    }), new SlidingWindowStrategy(estimateTokens));
-    return new CacheAwareCompressionStrategy({
-        inner: innerPipeline,
-        estimateTokens,
-        onCacheInvalidated: opts?.onCacheInvalidated,
-    });
-}
-/** Phase 2.3: incremental compaction pipeline (for partial compact) */
-export function createIncrementalPipeline(summarize, opts) {
-    const innerPipeline = composeAsyncStrategies(new ToolResultTrimStrategy(DEFAULT_TOOL_RESULT_MAX_CHARS), new IncrementalCompactStrategy({
-        preserveRecentCount: opts?.preserveRecentCount ?? 12,
-        summarize,
-        estimateTokens,
-    }), new SlidingWindowStrategy(estimateTokens));
-    return new CacheAwareCompressionStrategy({
-        inner: innerPipeline,
-        estimateTokens,
-        onCacheInvalidated: opts?.onCacheInvalidated,
-    });
-}
-/** Synchronous compression (Phase 1 only). */
-export function compressMessages(messages, opts) {
-    const budget = opts?.budget ?? computeAdaptiveBudget({
-        modelContextWindow: getModelContextWindow(opts?.model),
-    });
-    const pipeline = opts?.pipeline ?? createSyncPipeline();
-    const result = pipeline.compress(messages, budget);
-    if (result.droppedCount > 0) {
-        const tokensBefore = estimateTotalTokens(messages);
-        const tokensAfter = estimateTotalTokens(result.messages);
-        metricsCollector.record({
-            timestamp: Date.now(),
-            strategy: result.strategy,
-            tokensBefore,
-            tokensAfter,
-            droppedCount: result.droppedCount,
-            latencyMs: result.metrics?.latencyMs ?? 0,
-            usedLlm: false,
-            cacheInvalidated: result.metrics?.cacheInvalidated ?? false,
-            tier: selectCompressionTier(tokensBefore, budget),
-        });
-    }
-    return result;
-}
-/** Async compression (Phase 2+) — supports LLM summarization. */
-export async function compressMessagesAsync(messages, opts) {
-    const budget = opts.budget ?? computeAdaptiveBudget({
-        modelContextWindow: getModelContextWindow(opts.model),
-    });
-    const activeEngine = engineRegistry.getActive();
-    if (activeEngine) {
-        const result = await activeEngine.compressAsync(messages, budget, {
-            model: opts.model,
-            sessionId: opts.sessionId,
-        });
-        recordMetrics(messages, result, budget);
-        return result;
-    }
-    return compressWithTierSelection(messages, opts, budget);
-}
-async function compressWithTierSelection(messages, opts, budget) {
-    const effectiveBudget = budget ?? computeAdaptiveBudget({
-        modelContextWindow: getModelContextWindow(opts.model),
-    });
-    const currentTokens = estimateTotalTokens(messages);
-    const tier = selectCompressionTier(currentTokens, effectiveBudget);
-    let result;
-    switch (tier) {
-        case "none":
-            result = { messages, droppedCount: 0, strategy: "none" };
-            break;
-        case "trim-only":
-            result = new ToolResultTrimStrategy(DEFAULT_TOOL_RESULT_MAX_CHARS).compress(messages, effectiveBudget);
-            break;
-        case "sliding-window": {
-            const swPipeline = createAsyncPipeline(opts.summarize);
-            result = await swPipeline.compressAsync(messages, effectiveBudget);
-            break;
-        }
-        case "llm-summarize": {
-            const pipeline = opts.pipeline ?? createAsyncPipeline(opts.summarize);
-            result = isAsyncCompressionStrategy(pipeline)
-                ? await pipeline.compressAsync(messages, effectiveBudget)
-                : pipeline.compress(messages, effectiveBudget);
-            break;
-        }
-    }
-    recordMetrics(messages, result, effectiveBudget);
-    return result;
-}
-function recordMetrics(messagesBefore, result, budget) {
-    if (result.droppedCount > 0 || result.metrics?.usedLlm) {
-        const tokensBefore = result.metrics?.tokensBefore || estimateTotalTokens(messagesBefore);
-        const tokensAfter = result.metrics?.tokensAfter || estimateTotalTokens(result.messages);
-        metricsCollector.record({
-            timestamp: Date.now(),
-            strategy: result.strategy,
-            tokensBefore,
-            tokensAfter,
-            droppedCount: result.droppedCount,
-            latencyMs: result.metrics?.latencyMs ?? 0,
-            usedLlm: result.metrics?.usedLlm ?? false,
-            cacheInvalidated: result.metrics?.cacheInvalidated ?? false,
-            tier: selectCompressionTier(tokensBefore, budget),
-        });
-    }
-}
-// ── Default Context Engine (Phase 4.3) ─────────────────────
-export function registerDefaultContextEngine(log, opts) {
-    const summarize = createSummarizeFn(log, opts);
-    const engine = {
-        id: "builtin-compressor",
-        label: "4-Layer Compression Funnel (built-in)",
-        async compressAsync(messages, budget, context) {
-            return compressWithTierSelection(messages, {
-                budget,
-                model: context?.model,
-                sessionId: context?.sessionId,
-                summarize,
-            }, budget);
-        },
-    };
-    engineRegistry.register(engine);
-    engineRegistry.activate(engine.id);
-    log.info(`[context-compression] registered context engine: ${engine.id}`);
-}
-// ── Hook registration ──────────────────────────────────────
-export function registerContextCompressionHook(hooks, log, opts) {
-    registerDefaultContextEngine(log, opts);
-    hooks.register({
-        point: "context.before_compact",
-        priority: 50,
-        label: "context-compression-bridge",
-        handler: (_point, context) => {
-            const messageCount = context.messageCount;
-            if (messageCount && messageCount > 0) {
-                log.debug(`[context-compression] before_compact: ${messageCount} messages entering compression`);
-            }
-            return { action: "continue" };
-        },
-    });
-}

package/dist/runtime/hook-registry.d.ts

@@ -1,12 +0,0 @@
-import type { HookPoint, HookContextMap, HookResult, HookHandler, HookRegistration, HookRegistry } from "../contracts/hooks.js";
-export type { HookPoint, HookContextMap, HookResult, HookHandler, HookRegistration, HookRegistry };
-/** Minimal logger interface — compatible with both pino and AgentLogger. */
-export interface RuntimeLogger {
-    info(msg: string): void;
-    info(obj: Record<string, unknown>, msg: string): void;
-    warn(msg: string): void;
-    warn(obj: Record<string, unknown>, msg: string): void;
-    debug(msg: string): void;
-    debug(obj: Record<string, unknown>, msg: string): void;
-}
-export declare function createHookRegistry(log: RuntimeLogger): HookRegistry;

package/dist/runtime/hook-registry.js

@@ -1,53 +0,0 @@
-// ============================================================
-// Hook registry — manages lifecycle hooks for the Agent Runtime.
-// Hook failures never block the main flow (catch + log).
-//
-// Ported from src/core/runtime/hook-registry.ts (zero changes to logic).
-// ============================================================
-export function createHookRegistry(log) {
-    const handlers = new Map();
-    return {
-        register(registration) {
-            const list = handlers.get(registration.point) ?? [];
-            const entry = {
-                handler: registration.handler,
-                priority: registration.priority ?? 100,
-                label: registration.label,
-            };
-            list.push(entry);
-            list.sort((a, b) => a.priority - b.priority);
-            handlers.set(registration.point, list);
-            return () => {
-                const idx = list.indexOf(entry);
-                if (idx >= 0)
-                    list.splice(idx, 1);
-            };
-        },
-        async invoke(point, context) {
-            const list = handlers.get(point);
-            if (!list || list.length === 0) {
-                return { action: "continue", context };
-            }
-            let current = context;
-            for (const entry of list) {
-                try {
-                    const result = await entry.handler(point, current);
-                    if (!result || result.action === "continue") {
-                        if (result?.context) {
-                            current = result.context;
-                        }
-                        continue;
-                    }
-                    if (result.action === "abort" || result.action === "skip") {
-                        log.info({ hook: point, label: entry.label, action: result.action, reason: result.reason }, "hook intercepted");
-                        return result;
-                    }
-                }
-                catch (err) {
-                    log.warn({ hook: point, label: entry.label, err: err.message }, "hook handler failed (non-blocking)");
-                }
-            }
-            return { action: "continue", context: current };
-        },
-    };
-}

package/dist/runtime/memory-hooks.d.ts

@@ -1,23 +0,0 @@
-import type { HookRegistry } from "../contracts/hooks.js";
-import type { MemoryProvider } from "qlogicagent-runtime-contracts";
-export interface MemoryHooksDeps {
-    /** QMemory adapter (MemoryProvider with search/health). */
-    memoryProvider?: MemoryProvider;
-    /** User ID for memory lookups. */
-    userId: string;
-    /** Logger. */
-    log: {
-        debug(msg: string): void;
-        warn(msg: string): void;
-    };
-}
-/**
- * Register memory lifecycle hooks on the HookRegistry.
- *
- * Hook points wired:
- *   - memory.before_recall: prefetch context from qmemory (query-based)
- *   - memory.after_recall: log recall results
- *
- * Returns a cleanup function to unregister.
- */
-export declare function registerMemoryHooks(hooks: HookRegistry, deps: MemoryHooksDeps): () => void;

package/dist/runtime/memory-hooks.js

@@ -1,65 +0,0 @@
-// ============================================================
-// Memory lifecycle hooks — CLI runtime
-//
-// Wires memory.before_recall / memory.after_recall hook points
-// into the qmemory REST API. Registered once per session when
-// the HookRegistry is created.
-//
-// Unlike the Hub version (PG-based), this uses the local
-// qmemory HTTP adapter for recall prefetch.
-// ============================================================
-/**
- * Register memory lifecycle hooks on the HookRegistry.
- *
- * Hook points wired:
- *   - memory.before_recall: prefetch context from qmemory (query-based)
- *   - memory.after_recall: log recall results
- *
- * Returns a cleanup function to unregister.
- */
-export function registerMemoryHooks(hooks, deps) {
-    const cleanups = [];
-    // Shared recall cache per turn (avoids redundant queries)
-    let lastRecallTurnId;
-    let lastRecallResults = [];
-    // memory.before_recall — prefetch from qmemory
-    cleanups.push(hooks.register({
-        point: "memory.before_recall",
-        priority: 50,
-        label: "qmemory-prefetch",
-        handler: async (_point, ctx) => {
-            if (!deps.memoryProvider || !ctx.query) {
-                return { action: "continue", context: ctx };
-            }
-            try {
-                const results = await deps.memoryProvider.search(ctx.query, deps.userId, {
-                    limit: 10,
-                });
-                lastRecallTurnId = ctx.turnId;
-                lastRecallResults = results;
-                deps.log.debug(`memory.before_recall: prefetched ${results.length} memories for query="${ctx.query?.slice(0, 60)}"`);
-            }
-            catch (err) {
-                deps.log.warn(`memory.before_recall: qmemory prefetch failed: ${err instanceof Error ? err.message : String(err)}`);
-                lastRecallResults = [];
-            }
-            return { action: "continue", context: ctx };
-        },
-    }));
-    // memory.after_recall — log results
-    cleanups.push(hooks.register({
-        point: "memory.after_recall",
-        priority: 50,
-        label: "qmemory-recall-log",
-        handler: (_point, ctx) => {
-            const count = lastRecallTurnId === ctx.turnId ? lastRecallResults.length : 0;
-            deps.log.debug(`memory.after_recall: ${ctx.blockCount ?? 0} blocks assembled, ${count} qmemory results`);
-            return { action: "continue", context: ctx };
-        },
-    }));
-    return () => {
-        for (const cleanup of cleanups)
-            cleanup();
-        lastRecallResults = [];
-    };
-}

package/dist/runtime/tool-eligibility.d.ts

@@ -1,59 +0,0 @@
-/**
- * Tool eligibility resolver for CLI subprocess mode.
- *
- * Ported from src/core/runtime/tool-eligibility.ts, replacing Hub's
- * StoredGatewayCapabilitySnapshot with CLI's ToolDefinition[] from agent.turn.
- *
- * Core decision logic preserved:
- *   - Policy blocked (explicit block list)
- *   - Approval required (meta.requiresApproval / meta.isDangerous)
- *   - Read-only / safe tools (meta.isReadOnly → skip approval even in strict)
- *   - All tools from Gateway manifest are considered enabled & reachable
- *     (Gateway only sends available tools)
- *
- * Zero imports from express/pg/ioredis/ws.
- */
-import type { ToolDefinition } from "../agent/types.js";
-/**
- * Tool permission levels aligned with Claude Code's permission model:
- *
- *   Level 1 — always-allow:  isReadOnly tools (e.g. read_file, search)
- *   Level 2 — default-allow: normal tools with no risk markers
- *   Level 3 — notify:        isDangerous tools → emit tool_blocked warning but allow
- *   Level 4 — ask:           requiresApproval tools → hook can block, emit approval.requested
- *   Level 5 — never-allow:   explicitly blocked by policy
- */
-export type PermissionLevel = 1 | 2 | 3 | 4 | 5;
-export type ToolEligibilityStatus = "eligible" | "approval-required" | "blocked-by-policy" | "dangerous-notify";
-export type ToolEligibilityReasonCode = "policy_blocked" | "approval_required" | "dangerous_tool" | "always_allowed";
-export interface ToolEligibilityEntry {
-    toolName: string;
-    status: ToolEligibilityStatus;
-    permissionLevel: PermissionLevel;
-    approvalRequired: boolean;
-    reasonCodes: ToolEligibilityReasonCode[];
-}
-export interface ToolEligibilityContext {
-    /** Explicitly blocked tool names (e.g. from config or policy) */
-    blockedToolNames?: string[];
-    /** Dangerous tool name patterns (regex strings) for pattern-based detection */
-    dangerousPatterns?: string[];
-}
-export interface ToolEligibilityResult {
-    /** Tools eligible for execution (includes approval-required ones) */
-    eligibleTools: ToolDefinition[];
-    /** Tools blocked by policy (removed from LLM tool list) */
-    blockedTools: ToolEligibilityEntry[];
-    /** Tools needing approval before execution */
-    approvalRequiredTools: ToolEligibilityEntry[];
-    /** Full eligibility map by tool name */
-    eligibilityByName: Map<string, ToolEligibilityEntry>;
-}
-/**
- * Resolve tool eligibility for a set of tools from agent.turn.
- *
- * Returns filtered tool lists and eligibility metadata.
- * Blocked tools are removed from the eligible list (not sent to LLM).
- * Approval-required tools remain in the list but flagged for hook interception.
- */
-export declare function resolveToolEligibility(tools: ToolDefinition[], context?: ToolEligibilityContext): ToolEligibilityResult;

package/dist/runtime/tool-eligibility.js

@@ -1,111 +0,0 @@
-/**
- * Tool eligibility resolver for CLI subprocess mode.
- *
- * Ported from src/core/runtime/tool-eligibility.ts, replacing Hub's
- * StoredGatewayCapabilitySnapshot with CLI's ToolDefinition[] from agent.turn.
- *
- * Core decision logic preserved:
- *   - Policy blocked (explicit block list)
- *   - Approval required (meta.requiresApproval / meta.isDangerous)
- *   - Read-only / safe tools (meta.isReadOnly → skip approval even in strict)
- *   - All tools from Gateway manifest are considered enabled & reachable
- *     (Gateway only sends available tools)
- *
- * Zero imports from express/pg/ioredis/ws.
- */
-// ── Dangerous pattern detection (CC parity) ──────────────────────────────────
-const BUILTIN_DANGEROUS_PATTERNS = [
-    /^(?:bash|shell|exec|terminal|run_command)$/i,
-    /^(?:write_file|delete_file|move_file|create_directory)$/i,
-    /^(?:git_push|git_reset|git_force)$/i,
-];
-function matchesDangerousPattern(toolName, extraPatterns) {
-    if (BUILTIN_DANGEROUS_PATTERNS.some((re) => re.test(toolName))) {
-        return true;
-    }
-    if (extraPatterns) {
-        for (const pattern of extraPatterns) {
-            try {
-                if (new RegExp(pattern, "i").test(toolName))
-                    return true;
-            }
-            catch {
-                // Invalid regex — skip
-            }
-        }
-    }
-    return false;
-}
-// ── Core resolver ────────────────────────────────────────────────────────────
-function resolvePermissionLevel(tool, context) {
-    const name = tool.function.name;
-    const meta = tool.meta;
-    const reasons = [];
-    // Level 5: explicitly blocked
-    if (context.blockedToolNames?.includes(name)) {
-        reasons.push("policy_blocked");
-        return { level: 5, reasons };
-    }
-    // Level 1: always allowed (read-only / safe)
-    if (meta?.isReadOnly) {
-        reasons.push("always_allowed");
-        return { level: 1, reasons };
-    }
-    // Level 4: explicit approval required
-    if (meta?.requiresApproval) {
-        reasons.push("approval_required");
-        return { level: 4, reasons };
-    }
-    // Level 3: dangerous (by meta flag or pattern detection)
-    if (meta?.isDangerous || matchesDangerousPattern(name, context.dangerousPatterns)) {
-        reasons.push("dangerous_tool");
-        return { level: 3, reasons };
-    }
-    // Level 2: default allowed
-    return { level: 2, reasons };
-}
-function levelToStatus(level) {
-    switch (level) {
-        case 1: return "eligible";
-        case 2: return "eligible";
-        case 3: return "dangerous-notify";
-        case 4: return "approval-required";
-        case 5: return "blocked-by-policy";
-    }
-}
-/**
- * Resolve tool eligibility for a set of tools from agent.turn.
- *
- * Returns filtered tool lists and eligibility metadata.
- * Blocked tools are removed from the eligible list (not sent to LLM).
- * Approval-required tools remain in the list but flagged for hook interception.
- */
-export function resolveToolEligibility(tools, context = {}) {
-    const eligibilityByName = new Map();
-    const eligibleTools = [];
-    const blockedTools = [];
-    const approvalRequiredTools = [];
-    for (const tool of tools) {
-        const name = tool.function.name;
-        const { level, reasons } = resolvePermissionLevel(tool, context);
-        const status = levelToStatus(level);
-        const entry = {
-            toolName: name,
-            status,
-            permissionLevel: level,
-            approvalRequired: level === 4,
-            reasonCodes: reasons,
-        };
-        eligibilityByName.set(name, entry);
-        if (level === 5) {
-            blockedTools.push(entry);
-        }
-        else {
-            eligibleTools.push(tool);
-            if (level === 4) {
-                approvalRequiredTools.push(entry);
-            }
-        }
-    }
-    return { eligibleTools, blockedTools, approvalRequiredTools, eligibilityByName };
-}