@weavetab/mcp 2.5.0-beta.0

package/dist/sensors/network.js

@@ -0,0 +1,193 @@
+export class TelemetryCapture {
+    session;
+    requests = new Map();
+    toastMessages = [];
+    errors = [];
+    navigationOccurred = false;
+    newUrl;
+    active = false;
+    // Store each CDP event listener reference so stop() can remove them.
+    // Multiple TelemetryCapture instances per session must not accumulate listeners.
+    _onRequestWillBeSent = null;
+    _onResponseReceived = null;
+    _onLoadingFinished = null;
+    _onLoadingFailed = null;
+    _onFrameNavigated = null;
+    _onChildNodeInserted = null;
+    _onConsoleAPICalled = null;
+    constructor(session) {
+        this.session = session;
+        this.setupListeners();
+    }
+    setupListeners() {
+        this._onRequestWillBeSent = (params) => {
+            if (!this.active)
+                return;
+            this.requests.set(params.requestId, {
+                url: params.request.url,
+                method: params.request.method,
+                isApi: params.request.url.includes('/api/') || params.request.headers?.['Accept']?.includes('application/json'),
+                timestamp: params.wallTime ? params.wallTime * 1000 : Date.now(),
+                _startTimeMonotonic: params.timestamp
+            });
+        };
+        this.session.Network.requestWillBeSent(this._onRequestWillBeSent);
+        this._onResponseReceived = (params) => {
+            if (!this.active)
+                return;
+            const req = this.requests.get(params.requestId);
+            if (req) {
+                req.status = params.response.status;
+                if (params.response.mimeType?.includes('application/json')) {
+                    req.isApi = true;
+                }
+                // 1. Capture TLS/SSL Certificate Metadata
+                if (params.response.securityDetails) {
+                    const sec = params.response.securityDetails;
+                    req.securityDetails = {
+                        protocol: sec.protocol,
+                        issuer: sec.issuer,
+                        subjectName: sec.subjectName,
+                        validFrom: sec.validFrom,
+                        validTo: sec.validTo,
+                        cipher: sec.cipher,
+                        keyExchange: sec.keyExchange,
+                        sanList: sec.sanList,
+                        certificateId: sec.certificateId
+                    };
+                }
+                // 2. Capture Network Timing Breakdown (DNS, TCP, SSL, Send, Wait)
+                if (params.response.timing) {
+                    const t = params.response.timing;
+                    const dnsMs = (t.dnsEnd > 0 && t.dnsStart >= 0) ? Math.max(0, t.dnsEnd - t.dnsStart) : 0;
+                    const connectMs = (t.connectEnd > 0 && t.connectStart >= 0) ? Math.max(0, t.connectEnd - t.connectStart) : 0;
+                    const sslMs = (t.sslEnd > 0 && t.sslStart >= 0) ? Math.max(0, t.sslEnd - t.sslStart) : 0;
+                    const sendMs = (t.sendEnd > 0 && t.sendStart >= 0) ? Math.max(0, t.sendEnd - t.sendStart) : 0;
+                    const waitMs = (t.receiveHeadersStart > 0 && t.sendEnd >= 0) ? Math.max(0, t.receiveHeadersStart - t.sendEnd) : 0;
+                    req.timing = {
+                        dnsMs: Number(dnsMs.toFixed(3)),
+                        connectMs: Number(connectMs.toFixed(3)),
+                        sslMs: Number(sslMs.toFixed(3)),
+                        sendMs: Number(sendMs.toFixed(3)),
+                        waitMs: Number(waitMs.toFixed(3)),
+                    };
+                    if (t.requestTime && t.receiveHeadersStart > 0) {
+                        req._responseHeadersMonotonic = t.requestTime + (t.receiveHeadersStart / 1000);
+                    }
+                }
+            }
+        };
+        this.session.Network.responseReceived(this._onResponseReceived);
+        this._onLoadingFinished = (params) => {
+            if (!this.active)
+                return;
+            const req = this.requests.get(params.requestId);
+            if (req) {
+                const finishTimeMonotonic = params.timestamp;
+                if (req._startTimeMonotonic && finishTimeMonotonic) {
+                    const totalMs = (finishTimeMonotonic - req._startTimeMonotonic) * 1000;
+                    if (!req.timing)
+                        req.timing = {};
+                    req.timing.totalMs = Number(Math.max(0, totalMs).toFixed(3));
+                    if (req._responseHeadersMonotonic) {
+                        const downloadMs = (finishTimeMonotonic - req._responseHeadersMonotonic) * 1000;
+                        req.timing.downloadMs = Number(Math.max(0, downloadMs).toFixed(3));
+                    }
+                    else {
+                        req.timing.downloadMs = 0;
+                    }
+                }
+            }
+        };
+        this.session.Network.loadingFinished(this._onLoadingFinished);
+        this._onLoadingFailed = (params) => {
+            if (!this.active)
+                return;
+            const req = this.requests.get(params.requestId);
+            if (req) {
+                req.failure = {
+                    errorText: params.errorText || "net::ERR_FAILED",
+                    canceled: params.canceled,
+                    blockedReason: params.blockedReason
+                };
+                this.errors.push(`[Network Error] ${req.url} failed: ${params.errorText || 'net::ERR_FAILED'}`);
+            }
+        };
+        this.session.Network.loadingFailed(this._onLoadingFailed);
+        this._onFrameNavigated = (params) => {
+            if (!this.active)
+                return;
+            if (!params.frame.parentId) { // Main frame
+                this.navigationOccurred = true;
+                this.newUrl = params.frame.url;
+            }
+        };
+        this.session.Page.frameNavigated(this._onFrameNavigated);
+        this._onChildNodeInserted = (params) => {
+            if (!this.active)
+                return;
+            const attrs = params.node.attributes || [];
+            const isToast = attrs.some((a) => typeof a === 'string' && a.toLowerCase().match(/toast|snackbar|notification|alert/));
+            if (isToast) {
+                this.toastMessages.push("Toast or banner detected");
+            }
+        };
+        this.session.DOM.childNodeInserted(this._onChildNodeInserted);
+        this._onConsoleAPICalled = (params) => {
+            if (!this.active)
+                return;
+            if (params.type === 'error' || params.type === 'warning') {
+                const text = params.args.map((a) => a.value || a.description).join(' ');
+                this.errors.push(`[${params.type}] ${text}`);
+            }
+        };
+        this.session.Runtime.consoleAPICalled(this._onConsoleAPICalled);
+    }
+    async start() {
+        this.requests.clear();
+        this.toastMessages = [];
+        this.errors = [];
+        this.navigationOccurred = false;
+        this.newUrl = undefined;
+        await this.session.Network.enable();
+        await this.session.Page.enable();
+        await this.session.DOM.enable();
+        await this.session.Runtime.enable();
+        this.active = true;
+    }
+    async stop() {
+        this.active = false;
+        // Remove all listeners to prevent accumulation
+        try {
+            if (this._onRequestWillBeSent)
+                this.session.Network.removeListener('requestWillBeSent', this._onRequestWillBeSent);
+            if (this._onResponseReceived)
+                this.session.Network.removeListener('responseReceived', this._onResponseReceived);
+            if (this._onLoadingFinished)
+                this.session.Network.removeListener('loadingFinished', this._onLoadingFinished);
+            if (this._onLoadingFailed)
+                this.session.Network.removeListener('loadingFailed', this._onLoadingFailed);
+            if (this._onFrameNavigated)
+                this.session.Page.removeListener('frameNavigated', this._onFrameNavigated);
+            if (this._onChildNodeInserted)
+                this.session.DOM.removeListener('childNodeInserted', this._onChildNodeInserted);
+            if (this._onConsoleAPICalled)
+                this.session.Runtime.removeListener('consoleAPICalled', this._onConsoleAPICalled);
+        }
+        catch { /* ignore */ }
+        this._onRequestWillBeSent = this._onResponseReceived = this._onLoadingFinished = this._onLoadingFailed =
+            this._onFrameNavigated = this._onChildNodeInserted = this._onConsoleAPICalled = null;
+        const requestsClean = Array.from(this.requests.values()).map(r => {
+            const { _startTimeMonotonic, _responseHeadersMonotonic, ...publicReq } = r;
+            return publicReq;
+        });
+        return {
+            networkRequests: requestsClean,
+            domMutations: this.toastMessages.length > 0 ? ["Toasts appeared"] : [], // simplified DOM mutations for now
+            navigationOccurred: this.navigationOccurred,
+            newUrl: this.newUrl,
+            toastMessages: this.toastMessages,
+            errors: this.errors
+        };
+    }
+}

package/dist/sensors/operation_monitor.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Weavetab — sensors/operation_monitor.ts
+ * Intelligent operation monitoring for detecting and resolving tool execution lag.
+ * Detects when operations hang inside tool execution and provides adaptive bail-out.
+ * Weavetab by fy2ne
+ */
+export interface OperationPhase {
+    name: string;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    completed: boolean;
+    warning?: string;
+}
+export interface OperationDiagnostics {
+    toolName: string;
+    totalDuration: number;
+    phases: OperationPhase[];
+    bottlenecks: string[];
+    health: "healthy" | "degraded" | "critical";
+    bailOutReason?: string;
+}
+declare class OperationMonitor {
+    private activeOperations;
+    private readonly PHASE_THRESHOLDS;
+    private readonly BAIL_OUT_THRESHOLDS;
+    private readonly TOTAL_OPERATION_TIMEOUT;
+    /**
+     * Start monitoring a new tool operation
+     */
+    startOperation(operationId: string, toolName: string): void;
+    /**
+     * Record the start of a specific phase within an operation
+     */
+    startPhase(operationId: string, phaseName: string): void;
+    /**
+     * Record the completion of a specific phase
+     */
+    endPhase(operationId: string, phaseName: string, warning?: string): void;
+    /**
+     * End operation monitoring and return diagnostics
+     */
+    endOperation(operationId: string): OperationDiagnostics | null;
+    /**
+     * Check if an operation should bail out with degraded results
+     */
+    shouldBailOut(operationId: string): {
+        shouldBail: boolean;
+        reason?: string;
+    };
+    /**
+     * Get current operation status for diagnostics
+     */
+    getOperationStatus(operationId: string): {
+        toolName: string;
+        duration: number;
+        currentPhase: string;
+        health: "healthy" | "degraded" | "critical";
+    } | null;
+    /**
+     * Periodic health check for active operations
+     */
+    private checkOperationHealth;
+    /**
+     * Identify bottlenecks in operation phases
+     */
+    private identifyBottlenecks;
+    /**
+     * Determine overall operation health
+     */
+    private determineHealth;
+    /**
+     * Clear every active diagnostics timer. Registered on process exit events so
+     * that a tool crashing before endOperation() can't leave an interval firing
+     * every second and pinning the Node.js event loop.
+     */
+    cleanupAll(): void;
+}
+export declare const operationMonitor: OperationMonitor;
+export {};

package/dist/sensors/operation_monitor.js

@@ -0,0 +1,203 @@
+import { logDebug } from "../audit/logger.js";
+class OperationMonitor {
+    activeOperations = new Map();
+    PHASE_THRESHOLDS = {
+        // Expected maximum duration for each phase (in ms)
+        setup: 500, // Security checks, session setup
+        element_resolution: 1000, // Finding elements in DOM
+        actionability_check: 800, // Checking if element is clickable
+        ghost_move: 500, // Ghost cursor movement
+        action_dispatch: 300, // Actual click/type dispatch
+        stuck_check: 1000, // Post-action stuck detection
+        network_wait: 3000, // Network idle waiting
+        dom_stability: 1500, // DOM stability checks
+    };
+    BAIL_OUT_THRESHOLDS = {
+        // When to bail out with degraded results (in ms)
+        element_resolution: 2500,
+        actionability_check: 2000,
+        network_wait: 6000,
+        dom_stability: 4000,
+    };
+    TOTAL_OPERATION_TIMEOUT = 15000; // 15s max for any operation
+    /**
+     * Start monitoring a new tool operation
+     */
+    startOperation(operationId, toolName) {
+        this.activeOperations.set(operationId, {
+            toolName,
+            startTime: Date.now(),
+            phases: [],
+        });
+        // Start periodic health check
+        const diagnosticsTimer = setInterval(() => {
+            this.checkOperationHealth(operationId);
+        }, 1000); // Check every 1 second (reduced from 2s for faster detection)
+        this.activeOperations.get(operationId).diagnosticsTimer = diagnosticsTimer;
+    }
+    /**
+     * Record the start of a specific phase within an operation
+     */
+    startPhase(operationId, phaseName) {
+        const op = this.activeOperations.get(operationId);
+        if (!op)
+            return;
+        op.phases.push({
+            name: phaseName,
+            startTime: Date.now(),
+            completed: false,
+        });
+    }
+    /**
+     * Record the completion of a specific phase
+     */
+    endPhase(operationId, phaseName, warning) {
+        const op = this.activeOperations.get(operationId);
+        if (!op)
+            return;
+        const phase = op.phases.find(p => p.name === phaseName && !p.completed);
+        if (phase) {
+            phase.endTime = Date.now();
+            phase.duration = phase.endTime - phase.startTime;
+            phase.completed = true;
+            phase.warning = warning;
+        }
+    }
+    /**
+     * End operation monitoring and return diagnostics
+     */
+    endOperation(operationId) {
+        const op = this.activeOperations.get(operationId);
+        if (!op)
+            return null;
+        // Clear diagnostics timer
+        if (op.diagnosticsTimer) {
+            clearInterval(op.diagnosticsTimer);
+        }
+        const totalDuration = Date.now() - op.startTime;
+        const bottlenecks = this.identifyBottlenecks(op.phases);
+        const health = this.determineHealth(totalDuration, bottlenecks);
+        const diagnostics = {
+            toolName: op.toolName,
+            totalDuration,
+            phases: op.phases,
+            bottlenecks,
+            health,
+        };
+        this.activeOperations.delete(operationId);
+        return diagnostics;
+    }
+    /**
+     * Check if an operation should bail out with degraded results
+     */
+    shouldBailOut(operationId) {
+        const op = this.activeOperations.get(operationId);
+        if (!op)
+            return { shouldBail: false };
+        const totalDuration = Date.now() - op.startTime;
+        // Check total operation timeout
+        if (totalDuration > this.TOTAL_OPERATION_TIMEOUT) {
+            return { shouldBail: true, reason: `Total operation timeout (${totalDuration}ms > ${this.TOTAL_OPERATION_TIMEOUT}ms)` };
+        }
+        // Check specific phase timeouts
+        const currentPhase = op.phases.find(p => !p.completed);
+        if (currentPhase) {
+            const phaseDuration = Date.now() - currentPhase.startTime;
+            const bailOutThreshold = this.BAIL_OUT_THRESHOLDS[currentPhase.name];
+            if (bailOutThreshold && phaseDuration > bailOutThreshold) {
+                return {
+                    shouldBail: true,
+                    reason: `Phase '${currentPhase.name}' timeout (${phaseDuration}ms > ${bailOutThreshold}ms)`
+                };
+            }
+        }
+        return { shouldBail: false };
+    }
+    /**
+     * Get current operation status for diagnostics
+     */
+    getOperationStatus(operationId) {
+        const op = this.activeOperations.get(operationId);
+        if (!op)
+            return null;
+        const duration = Date.now() - op.startTime;
+        const currentPhase = op.phases.find(p => !p.completed)?.name || "idle";
+        const health = this.determineHealth(duration, []);
+        return {
+            toolName: op.toolName,
+            duration,
+            currentPhase,
+            health,
+        };
+    }
+    /**
+     * Periodic health check for active operations
+     */
+    checkOperationHealth(operationId) {
+        const op = this.activeOperations.get(operationId);
+        if (!op)
+            return;
+        const duration = Date.now() - op.startTime;
+        const currentPhase = op.phases.find(p => !p.completed);
+        if (currentPhase) {
+            const phaseDuration = Date.now() - currentPhase.startTime;
+            const threshold = this.PHASE_THRESHOLDS[currentPhase.name];
+            if (threshold && phaseDuration > threshold) {
+                // Phase is taking longer than expected
+                logDebug(`[Weavetab Monitor] Phase '${currentPhase.name}' taking longer than expected: ${phaseDuration}ms (threshold: ${threshold}ms)`);
+                // Add warning to phase
+                currentPhase.warning = `Exceeded threshold by ${phaseDuration - threshold}ms`;
+            }
+        }
+        if (duration > this.TOTAL_OPERATION_TIMEOUT * 0.7) {
+            // Operation is approaching timeout
+            logDebug(`[Weavetab Monitor] Operation '${op.toolName}' approaching timeout: ${duration}ms / ${this.TOTAL_OPERATION_TIMEOUT}ms`);
+        }
+    }
+    /**
+     * Identify bottlenecks in operation phases
+     */
+    identifyBottlenecks(phases) {
+        const bottlenecks = [];
+        for (const phase of phases) {
+            if (!phase.completed || !phase.duration)
+                continue;
+            const threshold = this.PHASE_THRESHOLDS[phase.name];
+            if (threshold && phase.duration > threshold) {
+                bottlenecks.push(`${phase.name}: ${phase.duration}ms (threshold: ${threshold}ms)`);
+            }
+        }
+        return bottlenecks;
+    }
+    /**
+     * Determine overall operation health
+     */
+    determineHealth(duration, bottlenecks) {
+        if (bottlenecks.length > 2 || duration > this.TOTAL_OPERATION_TIMEOUT * 0.8) {
+            return "critical";
+        }
+        if (bottlenecks.length > 0 || duration > this.TOTAL_OPERATION_TIMEOUT * 0.5) {
+            return "degraded";
+        }
+        return "healthy";
+    }
+    /**
+     * Clear every active diagnostics timer. Registered on process exit events so
+     * that a tool crashing before endOperation() can't leave an interval firing
+     * every second and pinning the Node.js event loop.
+     */
+    cleanupAll() {
+        for (const [id, op] of this.activeOperations.entries()) {
+            if (op.diagnosticsTimer) {
+                clearInterval(op.diagnosticsTimer);
+            }
+            this.activeOperations.delete(id);
+        }
+    }
+}
+export const operationMonitor = new OperationMonitor();
+// Register shutdown hooks so timers are always cleared, even on crashes
+process.on('exit', () => operationMonitor.cleanupAll());
+process.on('SIGINT', () => { operationMonitor.cleanupAll(); });
+process.on('SIGTERM', () => { operationMonitor.cleanupAll(); });
+process.on('uncaughtException', () => { operationMonitor.cleanupAll(); });

package/dist/sensors/pacing.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Weavetab — src/sensors/pacing.ts
+ * Human Pacing System — pass-through wrapper that records timing telemetry.
+ * All human-like delays live in ghost.ts (ghostMove, ghostType).
+ * This file does NOT add its own delays — eliminates the "double pacing" bug.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+export declare const HumanPace: {
+    afterRead: () => Promise<unknown>;
+    betweenClicks: () => Promise<unknown>;
+    afterNavigate: () => Promise<unknown>;
+    thinkingPause: () => Promise<unknown>;
+    fieldToField: () => Promise<unknown>;
+    beforeSubmit: () => Promise<unknown>;
+};
+export interface ToolCallMetrics {
+    tool: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    latencyMs: number;
+    timestamp: number;
+}
+/**
+ * Returns a session-level usage summary.
+ * Exposed to browser_eval via window.__wt_get_usage().
+ */
+export declare function getUsageStats(): {
+    totalCalls: number;
+    totalTokens: number;
+    byTool: {
+        tool: string;
+        calls: number;
+        tokens: number;
+        avgLatencyMs: number;
+    }[];
+    topSlowest: string[];
+};
+/**
+ * Wraps a tool action — records timing + updates HUD state.
+ * No artificial delays added here; ghost.ts handles human-like pacing.
+ */
+export declare function agentAction(session: CDP.Client, type: 'clicking' | 'typing' | 'reading' | 'thinking' | 'navigating', fn: () => Promise<any>, toolName?: string): Promise<any>;

package/dist/sensors/pacing.js

@@ -0,0 +1,111 @@
+import { sendToExtension } from "../cdp/helpers.js";
+import { agentState } from "../state/agent.js";
+import { getRandomThought } from "./thoughts.js";
+export const HumanPace = {
+    afterRead: () => sleep(randomBetween(800, 2500)),
+    betweenClicks: () => sleep(randomBetween(300, 800)),
+    afterNavigate: () => sleep(randomBetween(1500, 3500)),
+    thinkingPause: () => sleep(randomBetween(2000, 5000)),
+    fieldToField: () => sleep(randomBetween(400, 900)),
+    beforeSubmit: () => sleep(randomBetween(500, 1500)),
+};
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+function randomBetween(min, max) {
+    return Math.random() * (max - min) + min;
+}
+/** Rolling log of the last 100 tool calls for devMode HUD and usage() queries. */
+const toolCallLog = [];
+const MAX_LOG_SIZE = 100;
+function estimateTokens(obj) {
+    try {
+        return Math.ceil(JSON.stringify(obj).length / 4);
+    }
+    catch {
+        return 0;
+    }
+}
+function recordMetrics(metrics) {
+    toolCallLog.push(metrics);
+    if (toolCallLog.length > MAX_LOG_SIZE)
+        toolCallLog.shift();
+}
+/**
+ * Returns a session-level usage summary.
+ * Exposed to browser_eval via window.__wt_get_usage().
+ */
+export function getUsageStats() {
+    const byTool = new Map();
+    for (const entry of toolCallLog) {
+        const existing = byTool.get(entry.tool) ?? { calls: 0, tokens: 0, totalLatencyMs: 0 };
+        existing.calls++;
+        existing.tokens += entry.totalTokens;
+        existing.totalLatencyMs += entry.latencyMs;
+        byTool.set(entry.tool, existing);
+    }
+    const totalCalls = toolCallLog.length;
+    const totalTokens = toolCallLog.reduce((s, e) => s + e.totalTokens, 0);
+    const toolEntries = [...byTool.entries()].map(([tool, data]) => ({
+        tool,
+        calls: data.calls,
+        tokens: data.tokens,
+        avgLatencyMs: Math.round(data.totalLatencyMs / data.calls),
+    }));
+    const topSlowest = [...toolCallLog]
+        .sort((a, b) => b.latencyMs - a.latencyMs)
+        .slice(0, 5)
+        .map(e => `${e.tool} (${e.latencyMs}ms)`);
+    return { totalCalls, totalTokens, byTool: toolEntries, topSlowest };
+}
+/**
+ * Wraps a tool action — records timing + updates HUD state.
+ * No artificial delays added here; ghost.ts handles human-like pacing.
+ */
+export async function agentAction(session, type, fn, toolName) {
+    // Report tool activity to agent state manager
+    agentState.reportToolCall();
+    // Update state indicator with a varied thought (no cursor position — ghost.ts handles real cursor)
+    const thought = getRandomThought(type);
+    sendToExtension(session, {
+        type: 'Weavetab_STATE',
+        state: type,
+        ...(thought ? { hud: { action: thought } } : {}),
+    }).catch(() => { });
+    const start = Date.now();
+    const result = await fn();
+    const elapsed = Date.now() - start;
+    // Record execution timing for telemetry
+    if (result && typeof result === 'object') {
+        result.execution_ms = elapsed;
+    }
+    // Token telemetry — approximate via JSON length / 4
+    if (toolName) {
+        const inputTokens = estimateTokens(result); // args not captured here, output used as proxy
+        const outputTokens = estimateTokens(result);
+        const metrics = {
+            tool: toolName,
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+            latencyMs: elapsed,
+            timestamp: start,
+        };
+        recordMetrics(metrics);
+        // DevMode HUD console output
+        const liveConfig = global.__wt_live_config;
+        const devMode = liveConfig?.devMode;
+        const devEnabled = devMode === true;
+        if (devEnabled) {
+            const stats = getUsageStats();
+            process.stderr.write(`\n┌─ Tool Call ──────────────────────────────────────────┐\n` +
+                `│ ${toolName.padEnd(50)} │\n` +
+                `│ Input: ${String(inputTokens).padStart(4)} tokens  │  Latency: ${String(elapsed).padStart(6)}ms       │\n` +
+                `│ Output: ${String(outputTokens).padStart(4)} tokens │  Total:   ${String(metrics.totalTokens).padStart(4)} tokens      │\n` +
+                `│ ──────────────────────────────────────────────────── │\n` +
+                `│ Session total: ${stats.totalTokens} tokens (${stats.totalCalls} calls)`.padEnd(53) + `│\n` +
+                `└──────────────────────────────────────────────────────┘\n`);
+        }
+    }
+    return result;
+}

package/dist/sensors/thoughts.d.ts

@@ -0,0 +1,2 @@
+export declare const THOUGHT_POOLS: Record<string, string[]>;
+export declare function getRandomThought(state: string): string | null;