@poolzin/pool-bot 2026.1.32 → 2026.1.34

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.1.32",
-  "commit": "6872480de072314e610d35042267561672a5b97a",
-  "builtAt": "2026-02-04T15:55:30.791Z"
+  "version": "2026.1.34",
+  "commit": "84710f9a55bc3eca77fd7ffa882d9f11b9f92acc",
+  "builtAt": "2026-02-05T14:57:54.102Z"
 }

package/dist/gateway/hooks/index.js

@@ -24,8 +24,6 @@ defaultOnSessionStart, defaultOnSessionEnd, registerDefaultHooks,
 clearAllHooks, } from "./lifecycle-hooks.js";
 // Integration with agent events
 export { startLifecycleHooksIntegration, getIntegrationStats, isSessionTracked, getTrackedSessionInfo, clearTrackedSessions, removeTrackedSession, } from "./lifecycle-hooks-integration.js";
-// Tool usage capture (Day 2 - ACTIVE, feature-flagged)
-export { toolUsageCaptureHook, loadSessionToolUsage, saveSessionToolUsage, } from "./tool-usage-capture.js";
 // Progressive disclosure (Day 3 - ACTIVE, feature-flagged, OPT-IN)
 // Feature flag: PROGRESSIVE_DISCLOSURE_FLAGS.ENABLED = false (OFF by default)
 // Safe: Returns error "feature disabled" if called without enabling flag

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.1.32",
+  "version": "2026.1.34",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "type": "module",
   "main": "dist/index.js",

package/dist/gateway/hooks/tool-usage-capture.js

@@ -1,253 +0,0 @@
-/**
- * Tool Usage Capture Hook
- *
- * Captures tool usage automatically via lifecycle hooks.
- * Safe: never throws, async operations, feature-flagged.
- *
- * Integration:
- * - Registers as onToolUse hook
- * - Captures all tool calls automatically
- * - Stores compressed data in SessionEntry
- */
-import { TOOL_USAGE_ENABLED, TOOL_USAGE_MAX_RECORDS, createToolUsageRecord, updateToolStats, addToHistory, } from "./tool-usage-storage.js";
-// ============================================================================
-// Configuration
-// ============================================================================
-const TOOL_USAGE_BUFFER_FLUSH_INTERVAL = 30000; // 30 seconds
-const TOOL_USAGE_BUFFER_MAX_SIZE = 50; // Flush after 50 tool calls
-const toolUsageBuffer = new Map();
-let bufferFlushScheduled = false;
-// ============================================================================
-// SessionEntry Extension (Type-safe, backward compatible)
-// ============================================================================
-/**
- * Load tool usage from SessionEntry
- * Safe: handles missing data, validates structure
- */
-export async function loadSessionToolUsage(sessionKey) {
-    try {
-        // TODO: Integrate with actual SessionEntry in Phase 4
-        // For now, return in-memory placeholder
-        const existing = toolUsageBuffer.get(sessionKey);
-        if (existing && existing.length > 0) {
-            // Return computed stats from buffer
-            const tools = {};
-            for (const record of existing) {
-                if (!tools[record.toolName]) {
-                    tools[record.toolName] = {
-                        count: 0,
-                        totalMs: 0,
-                        avgMs: 0,
-                        lastUsed: record.timestamp,
-                    };
-                }
-                tools[record.toolName] = updateToolStats(tools[record.toolName], record.executionTimeMs);
-            }
-            return {
-                version: 2,
-                sessionKey,
-                sessionId: sessionKey, // Placeholder
-                tools,
-                history: existing,
-                lastCaptured: Date.now(),
-            };
-        }
-        // Return empty usage
-        return {
-            version: 2,
-            sessionKey,
-            sessionId: sessionKey,
-            tools: {},
-            history: [],
-            lastCaptured: Date.now(),
-        };
-    }
-    catch (err) {
-        console.error("[tool-usage-capture] Failed to load tool usage:", err);
-        // Return empty usage on error
-        return {
-            version: 2,
-            sessionKey,
-            sessionId: sessionKey,
-            tools: {},
-            history: [],
-            lastCaptured: Date.now(),
-        };
-    }
-}
-/**
- * Save tool usage to SessionEntry
- * Safe: validates data, handles errors gracefully
- */
-export async function saveSessionToolUsage(sessionKey, usage) {
-    try {
-        // TODO: Integrate with actual SessionEntry in Phase 4
-        // For now, just update in-memory buffer
-        const existing = toolUsageBuffer.get(sessionKey) || [];
-        const newRecords = usage.history.slice(existing.length);
-        if (newRecords.length > 0) {
-            toolUsageBuffer.set(sessionKey, [...existing, ...newRecords]);
-        }
-        if (TOOL_USAGE_ENABLED) {
-            console.log(`[tool-usage-capture] Saved ${newRecords.length} records for ${sessionKey}`);
-        }
-    }
-    catch (err) {
-        console.error("[tool-usage-capture] Failed to save tool usage:", err);
-        // Never throw - errors are logged only
-    }
-}
-// ============================================================================
-// Hook Implementation
-// ============================================================================
-/**
- * Main hook: captures tool usage automatically
- * Safe: validates all inputs, never throws, handles all edge cases
- */
-export const toolUsageCaptureHook = async (ctx) => {
-    // Feature flag check (safe exit)
-    if (!TOOL_USAGE_ENABLED) {
-        return;
-    }
-    try {
-        // Validate inputs (safe defaults)
-        const toolName = ctx.toolName || "unknown_tool";
-        const executionTimeMs = ctx.executionTimeMs || 0;
-        const success = ctx.success !== undefined ? ctx.success : true;
-        // Create compressed record
-        const record = createToolUsageRecord(toolName, ctx.toolInput, ctx.toolOutput, executionTimeMs, success, ctx.error);
-        // Load existing usage
-        const usage = await loadSessionToolUsage(ctx.sessionKey);
-        // Update stats
-        if (!usage.tools[toolName]) {
-            usage.tools[toolName] = {
-                count: 0,
-                totalMs: 0,
-                avgMs: 0,
-                lastUsed: record.timestamp,
-            };
-        }
-        usage.tools[toolName] = updateToolStats(usage.tools[toolName], executionTimeMs);
-        // Add to history (respects max limit)
-        usage.history = addToHistory(usage.history, record, TOOL_USAGE_MAX_RECORDS);
-        usage.lastCaptured = Date.now();
-        // Save (async, non-blocking)
-        await saveSessionToolUsage(ctx.sessionKey, usage).catch((err) => {
-            // Save errors are logged in saveSessionToolUsage
-            // This catch is just for extra safety
-            console.error("[tool-usage-capture] Unhandled save error:", err);
-        });
-        // Debug logging (can be disabled)
-        if (success && TOOL_USAGE_ENABLED) {
-            console.log(`[tool-usage-capture] ${toolName} (${executionTimeMs}ms) - ${ctx.sessionKey}`);
-        }
-    }
-    catch (err) {
-        // NEVER throw from hook - would break the tool call
-        console.error("[tool-usage-capture] Hook error:", err);
-    }
-};
-// ============================================================================
-// Buffer Management (performance optimization)
-// ============================================================================
-/**
- * Flush in-memory buffer to storage
- * Safe: handles errors, never throws
- */
-export async function flushToolUsageBuffer() {
-    try {
-        if (toolUsageBuffer.size === 0) {
-            return; // Nothing to flush
-        }
-        let flushed = 0;
-        for (const [sessionKey, records] of toolUsageBuffer.entries()) {
-            try {
-                // TODO: Actually persist to SessionEntry in Phase 4
-                // For now, buffer stays in-memory
-                flushed += records.length;
-            }
-            catch (err) {
-                console.error(`[tool-usage-capture] Failed to flush buffer for ${sessionKey}:`, err);
-            }
-        }
-        if (flushed > 0 && TOOL_USAGE_ENABLED) {
-            console.log(`[tool-usage-capture] Flushed ${flushed} records from buffer`);
-        }
-    }
-    catch (err) {
-        console.error("[tool-usage-capture] Buffer flush error:", err);
-    }
-}
-/**
- * Schedule buffer flush
- * Safe: debounced, only schedules once
- */
-function scheduleBufferFlush() {
-    if (bufferFlushScheduled) {
-        return; // Already scheduled
-    }
-    bufferFlushScheduled = true;
-    // Flush after 30 seconds
-    setTimeout(async () => {
-        await flushToolUsageBuffer();
-        bufferFlushScheduled = false;
-    }, TOOL_USAGE_BUFFER_FLUSH_INTERVAL);
-}
-// ============================================================================
-// Query API (for future use)
-// ============================================================================
-/**
- * Get tool usage statistics for a session
- * Safe: returns empty object if no data
- */
-export async function getSessionToolUsage(sessionKey) {
-    try {
-        const usage = await loadSessionToolUsage(sessionKey);
-        return usage;
-    }
-    catch (err) {
-        console.error(`[tool-usage-capture] Failed to get usage for ${sessionKey}:`, err);
-        return undefined;
-    }
-}
-/**
- * Get recent tool usage (last N records)
- * Safe: returns empty array if no data
- */
-export async function getRecentToolUsage(sessionKey, count = 10) {
-    try {
-        const usage = await loadSessionToolUsage(sessionKey);
-        return usage.history.slice(-count);
-    }
-    catch (err) {
-        console.error(`[tool-usage-capture] Failed to get recent usage for ${sessionKey}:`, err);
-        return [];
-    }
-}
-// ============================================================================
-// Cleanup
-// ============================================================================
-/**
- * Clear tool usage buffer (for testing)
- * Safe: never throws
- */
-export function clearToolUsageBuffer() {
-    try {
-        toolUsageBuffer.clear();
-    }
-    catch (err) {
-        console.error("[tool-usage-capture] Buffer clear error:", err);
-    }
-}
-/**
- * Clear tool usage for a specific session
- * Safe: never throws
- */
-export function clearSessionToolUsage(sessionKey) {
-    try {
-        toolUsageBuffer.delete(sessionKey);
-    }
-    catch (err) {
-        console.error(`[tool-usage-capture] Failed to clear usage for ${sessionKey}:`, err);
-    }
-}

package/dist/gateway/hooks/tool-usage-storage.js

@@ -1,144 +0,0 @@
-/**
- * Tool Usage Capture - Storage Layer
- *
- * Safe, efficient storage for tool usage data.
- * Phase 2a: Type definitions and interfaces (NO breaking changes)
- *
- * Safety measures:
- * - All fields optional (backward compatible)
- * - Version field for future migrations
- * - No modifications to existing SessionEntry fields
- */
-// ============================================================================
-// Constants
-// ============================================================================
-export const TOOL_USAGE_MAX_RECORDS = 100; // Keep only last 100 records
-export const TOOL_USAGE_MAX_SUMMARY_LEN = 100; // Max 100 chars per summary
-export const TOOL_USAGE_ENABLED = true; // Feature flag (master switch)
-// ============================================================================
-// Compression Functions (safe, no side effects)
-// ============================================================================
-/**
- * Compress a tool input/output value to a short summary
- * Safe: never throws, handles all types gracefully
- */
-export function compressToolValue(value, maxLen = TOOL_USAGE_MAX_SUMMARY_LEN) {
-    try {
-        // Handle primitives
-        if (value === null)
-            return "null";
-        if (value === undefined)
-            return "undefined";
-        if (typeof value === "string") {
-            return value.length > maxLen ? value.slice(0, maxLen) + "..." : value;
-        }
-        if (typeof value === "number")
-            return String(value);
-        if (typeof value === "boolean")
-            return String(value);
-        // Handle objects and arrays
-        if (typeof value === "object") {
-            const json = JSON.stringify(value);
-            return json.length > maxLen ? json.slice(0, maxLen) + "..." : json;
-        }
-        // Fallback
-        return String(value);
-    }
-    catch (err) {
-        // If compression fails, return safe fallback
-        return "[compression_error]";
-    }
-}
-/**
- * Create a tool usage record from hook context
- * Safe: validates all inputs, never throws
- */
-export function createToolUsageRecord(toolName, toolInput, toolOutput, executionTimeMs, success, error) {
-    // Validate inputs (safe defaults)
-    const safeToolName = typeof toolName === "string" && toolName.length > 0 ? toolName : "unknown_tool";
-    const safeInput = typeof toolInput === "object" && toolInput !== null ? toolInput : {};
-    const safeTime = typeof executionTimeMs === "number" && executionTimeMs >= 0 ? executionTimeMs : 0;
-    const safeSuccess = Boolean(success);
-    return {
-        toolName: safeToolName,
-        timestamp: Date.now(),
-        executionTimeMs: safeTime,
-        success: safeSuccess,
-        inputSummary: compressToolValue(safeInput),
-        outputSummary: compressToolValue(toolOutput),
-        error: error ? String(error).slice(0, 200) : undefined,
-    };
-}
-// ============================================================================
-// Statistics Update (pure function, no side effects)
-// ============================================================================
-/**
- * Update tool statistics with a new record
- * Safe: never mutates input, returns new object
- */
-export function updateToolStats(existingStats, executionTimeMs) {
-    const count = (existingStats?.count ?? 0) + 1;
-    const totalMs = (existingStats?.totalMs ?? 0) + executionTimeMs;
-    const avgMs = count > 0 ? Math.round((totalMs / count) * 100) / 100 : 0;
-    return {
-        count,
-        totalMs,
-        avgMs,
-        lastUsed: Date.now(),
-    };
-}
-// ============================================================================
-// History Management (pure functions)
-// ============================================================================
-/**
- * Add record to history, respecting max limit
- * Safe: never exceeds max records, returns new array
- */
-export function addToHistory(history, record, maxRecords = TOOL_USAGE_MAX_RECORDS) {
-    const newHistory = [...history, record];
-    // Keep only last N records
-    if (newHistory.length > maxRecords) {
-        return newHistory.slice(-maxRecords);
-    }
-    return newHistory;
-}
-/**
- * Get recent tool usage (last N records)
- * Safe: never mutates input, returns slice
- */
-export function getRecentToolUsage(history, count = 10) {
-    return history.slice(-count);
-}
-// ============================================================================
-// Query Functions (for future use)
-// ============================================================================
-/**
- * Get statistics for a specific tool
- * Safe: returns undefined if tool not found
- */
-export function getToolStats(usage, toolName) {
-    return usage?.tools[toolName];
-}
-/**
- * Get all tool names sorted by usage frequency
- * Safe: returns empty array if no data
- */
-export function getToolsByFrequency(usage) {
-    if (!usage?.tools)
-        return [];
-    return Object.entries(usage.tools)
-        .map(([toolName, stats]) => ({ toolName, count: stats.count }))
-        .sort((a, b) => b.count - a.count);
-}
-/**
- * Get slowest tools (by average execution time)
- * Safe: returns empty array if no data
- */
-export function getSlowestTools(usage, limit = 5) {
-    if (!usage?.tools)
-        return [];
-    return Object.entries(usage.tools)
-        .map(([toolName, stats]) => ({ toolName, avgMs: stats.avgMs }))
-        .sort((a, b) => b.avgMs - a.avgMs)
-        .slice(0, limit);
-}