@animalabs/agent-framework 0.13.0 → 0.15.0

package/dist/src/modules/history/index.js

@@ -0,0 +1,519 @@
+/**
+ * HistoryModule — read-only access to an agent's full uncompressed message
+ * history, backed by context-manager's native chronicle secondary index
+ * (`queryMessagesByTime` / `queryMessagesByChannel` /
+ * `queryMessagesByTimeAndChannel` / `getChannelMessageCounts` /
+ * `getChannelTokenStats`, @animalabs/context-manager >= 0.6.0). Those calls
+ * are O(log n + k) against chronicle's `/timestamp` and
+ * `/metadata/external/channelId` field indexes, not a full-store scan, so
+ * this module can answer "what happened in #foo last Tuesday" against a
+ * multi-million-message store without walking the whole log.
+ *
+ * Three tools:
+ *  - `stats`   — per-channel message counts (all-time) + token totals
+ *                (range-scoped), for orienting before pulling raw content.
+ *  - `extract` — paginated raw messages for a time range and/or channel.
+ *  - `search`  — substring/regex match over a narrowed candidate window,
+ *                with an explicit truncation signal when the caller's
+ *                filter was too broad for `maxScan`.
+ *
+ * Kept deliberately read-only, same posture as HealthModule: no side
+ * effects, no message mutation. `onProcess` is a no-op.
+ *
+ * Every query dispatch collapses onto `queryMessagesByTimeAndChannel` — its
+ * own implementation already handles "only a time range", "only a channel",
+ * or "neither" by delegating to the single-filter native queries (see
+ * context-manager's `test/message-store-history-index.test.ts`), so this
+ * module doesn't need to re-decide which of the three query methods to call.
+ */
+import { Worker } from 'node:worker_threads';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+// ============================================================================
+// Limits
+// ============================================================================
+const EXTRACT_DEFAULT_LIMIT = 50;
+const EXTRACT_MAX_LIMIT = 200;
+/**
+ * Real ceiling of the native chronicle pagination `offset` argument (a u32
+ * at the N-API boundary). `Number.MAX_SAFE_INTEGER` is NOT a safe ceiling
+ * for this field: a value between 0xFFFFFFFF and MAX_SAFE_INTEGER passes a
+ * naive upper-bound check unchanged, then wraps/truncates when it crosses
+ * into an unsigned 32-bit int on the native side — silently wrong
+ * pagination (repro: offset:4294967296 against a real store "succeeded"
+ * and returned page 0) instead of a clean failure. Clamping to this ceiling
+ * (same clamp-not-reject behavior `limit` already has) means anything
+ * beyond it lands on an offset no real store's message count will ever
+ * reach, i.e. a correctly-empty page, rather than wrapping onto a wrong one.
+ */
+const NATIVE_OFFSET_MAX = 0xffffffff; // 4294967295
+const SEARCH_DEFAULT_LIMIT = 20;
+const SEARCH_MAX_LIMIT = 100;
+const SEARCH_DEFAULT_MAX_SCAN = 5000;
+const SEARCH_MAX_MAX_SCAN = 50000;
+/** Characters of surrounding context kept on each side of a search snippet. */
+const SNIPPET_CONTEXT_CHARS = 80;
+/** Fallback snippet length when a match position isn't meaningful to center on. */
+const SNIPPET_FALLBACK_CHARS = 160;
+/**
+ * Wall-clock deadline for a single regex-mode search call, enforced by
+ * forcibly terminating the worker thread doing the matching (see
+ * search-regex-worker.ts's header for why a worker — not a
+ * Promise.race/setTimeout — is required to actually interrupt a stuck
+ * synchronous RegExp.exec()). Generous enough for any legitimate pattern
+ * against a few thousand short strings; short enough that a catastrophic
+ * pattern doesn't tie up a worker (or an agent's turn) for long.
+ */
+const SEARCH_REGEX_TIMEOUT_MS = 2000;
+/** Compiled sibling of search-regex-worker.ts — resolved at runtime the same
+ *  way gate-script.ts locates gate-script-worker.js, so it tracks whatever
+ *  directory this module's own compiled output lives in. */
+const SEARCH_WORKER_PATH = join(dirname(fileURLToPath(import.meta.url)), 'search-regex-worker.js');
+export class HistoryModule {
+    name = 'history';
+    ctx = null;
+    cm = null;
+    /**
+     * Wire the context-manager instance. Host calls this after
+     * ContextManager.open() so the module can issue the native index-backed
+     * queries — ModuleContext itself exposes no store/context-manager
+     * reference, only the narrower message CRUD surface (addMessage/getMessage/
+     * queryMessages), which can't do range or channel queries.
+     */
+    bind(contextManager) {
+        this.cm = contextManager;
+    }
+    async start(ctx) {
+        this.ctx = ctx;
+    }
+    async stop() {
+        this.ctx = null;
+    }
+    getTools() {
+        return [
+            {
+                name: 'stats',
+                description: 'Orient before pulling raw history: per-channel message counts and token totals. ' +
+                    'messageCountsAllTime is always all-time and all-channel-scope (the underlying index has no ' +
+                    'range dimension) — it is NOT limited by from/to, only optionally filtered to one channelId. ' +
+                    'tokenStatsForRange IS scoped to from/to when given. The two are reported separately, never ' +
+                    'merged, because their range semantics differ.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        from: { type: 'string', description: 'ISO 8601 inclusive lower bound for tokenStatsForRange. Omit for open-ended.' },
+                        to: { type: 'string', description: 'ISO 8601 inclusive upper bound for tokenStatsForRange. Omit for open-ended.' },
+                        channelId: { type: 'string', description: 'Restrict both parts of the response to one channel.' },
+                    },
+                },
+            },
+            {
+                name: 'extract',
+                description: 'Fetch raw, uncompressed messages for a time range and/or channel, paginated oldest-first. ' +
+                    'Use after `stats` to pull the actual content. format:"text" flattens each message to a short ' +
+                    'readable string (tool_use/tool_result/thinking/images rendered as bracketed labels); ' +
+                    'format:"raw" returns the content blocks unmodified.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        from: { type: 'string', description: 'ISO 8601 inclusive lower bound. Omit for open-ended.' },
+                        to: { type: 'string', description: 'ISO 8601 inclusive upper bound. Omit for open-ended.' },
+                        channelId: { type: 'string', description: 'Restrict to one channel.' },
+                        limit: { type: 'number', description: `Max messages to return (default ${EXTRACT_DEFAULT_LIMIT}, hard cap ${EXTRACT_MAX_LIMIT}). Must be a non-negative integer.` },
+                        offset: { type: 'number', description: `Number of matching messages to skip (default 0, capped to ${NATIVE_OFFSET_MAX}). Must be a non-negative integer.` },
+                        format: { type: 'string', enum: ['text', 'raw'], description: 'Content rendering (default "text").' },
+                    },
+                },
+            },
+            {
+                name: 'search',
+                description: 'Search message history for a substring (default) or regex match, within an optional time ' +
+                    'range/channel window. Narrows candidates via the same query as `extract` before matching, up ' +
+                    'to maxScan candidates — if the narrowed window is larger than maxScan, the response reports ' +
+                    'truncated:true up front rather than silently missing later matches; narrow the filter or raise ' +
+                    'maxScan and retry. regex:true matching runs under a wall-clock deadline and is cleanly failed ' +
+                    `(not silently empty) if a pattern is too slow — avoid nested-quantifier patterns like (a+)+.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Substring (or regex source, when regex:true) to search for.' },
+                        regex: { type: 'boolean', description: 'Treat query as a regular expression (default false).' },
+                        caseSensitive: { type: 'boolean', description: 'Case-sensitive match (default false).' },
+                        from: { type: 'string', description: 'ISO 8601 inclusive lower bound. Omit for open-ended.' },
+                        to: { type: 'string', description: 'ISO 8601 inclusive upper bound. Omit for open-ended.' },
+                        channelId: { type: 'string', description: 'Restrict to one channel.' },
+                        limit: { type: 'number', description: `Max matches to return (default ${SEARCH_DEFAULT_LIMIT}, hard cap ${SEARCH_MAX_LIMIT}). Must be a non-negative integer.` },
+                        maxScan: { type: 'number', description: `Max candidate messages to scan (default ${SEARCH_DEFAULT_MAX_SCAN}, hard cap ${SEARCH_MAX_MAX_SCAN}). Must be a non-negative integer.` },
+                    },
+                    required: ['query'],
+                },
+            },
+        ];
+    }
+    async handleToolCall(call) {
+        try {
+            if (!this.cm) {
+                throw new Error('HistoryModule not bound — host must call bind(contextManager) before tool dispatch.');
+            }
+            switch (call.name) {
+                case 'stats':
+                    return this.handleStats((call.input ?? {}));
+                case 'extract':
+                    return this.handleExtract((call.input ?? {}));
+                case 'search':
+                    return await this.handleSearch((call.input ?? {}));
+                default:
+                    return { success: false, isError: true, error: `Unknown tool: ${call.name}` };
+            }
+        }
+        catch (error) {
+            // Catches our own validation errors (bad ISO date, invalid regex,
+            // out-of-range limit/offset/maxScan, unbound module), a regex-search
+            // worker timeout or worker-side error (see handleSearch/
+            // searchWithRegexWorker — a ReDoS-shaped pattern surfaces here as a
+            // clean timeout error, never a hang), and context-manager's
+            // capability-absent error ("Chronicle history index unsupported...",
+            // thrown by queryMessagesByTime/queryMessagesByChannel/
+            // queryMessagesByTimeAndChannel/getChannelMessageCounts/
+            // getChannelTokenStats on a chronicle build that predates the native
+            // index-query capability) — all surfaced as a normal tool error
+            // rather than crashing the module.
+            return {
+                success: false,
+                isError: true,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async onProcess(_event, _state) {
+        return {};
+    }
+    // ==========================================================================
+    // stats
+    // ==========================================================================
+    handleStats(input) {
+        const fromMs = parseIsoDate(input.from, 'from');
+        const toMs = parseIsoDate(input.to, 'to');
+        const cm = this.cm;
+        let messageCountsAllTime = cm.getChannelMessageCounts();
+        let tokenStatsForRange = cm.getChannelTokenStats({ fromMs, toMs });
+        if (input.channelId) {
+            messageCountsAllTime = messageCountsAllTime.filter((c) => c.channelId === input.channelId);
+            tokenStatsForRange = {
+                // Totals stay whole-range (they're documented as store-wide-for-the-range,
+                // not per-channel); only the byChannel breakdown is narrowed. Labeling the
+                // field `byChannel` (rather than folding a channel-filtered total into
+                // totalMessages/totalTokensEstimate) keeps this from reading as a
+                // misleadingly-merged single-channel total.
+                totalMessages: tokenStatsForRange.totalMessages,
+                totalTokensEstimate: tokenStatsForRange.totalTokensEstimate,
+                byChannel: tokenStatsForRange.byChannel.filter((c) => c.channelId === input.channelId),
+            };
+        }
+        return {
+            success: true,
+            data: {
+                query: { from: input.from ?? null, to: input.to ?? null, channelId: input.channelId ?? null },
+                messageCountsAllTime,
+                tokenStatsForRange,
+            },
+        };
+    }
+    // ==========================================================================
+    // extract
+    // ==========================================================================
+    handleExtract(input) {
+        const fromMs = parseIsoDate(input.from, 'from');
+        const toMs = parseIsoDate(input.to, 'to');
+        const limit = clampCount(input.limit, EXTRACT_DEFAULT_LIMIT, EXTRACT_MAX_LIMIT, 'limit');
+        const offset = clampCount(input.offset, 0, NATIVE_OFFSET_MAX, 'offset');
+        const format = input.format ?? 'text';
+        const cm = this.cm;
+        const result = cm.queryMessagesByTimeAndChannel({
+            fromMs,
+            toMs,
+            channelId: input.channelId,
+            limit,
+            offset,
+        });
+        return {
+            success: true,
+            data: {
+                matchedCount: result.matchedCount,
+                returned: result.messages.length,
+                messages: result.messages.map((msg) => projectMessage(msg, format)),
+            },
+        };
+    }
+    // ==========================================================================
+    // search
+    // ==========================================================================
+    async handleSearch(input) {
+        if (!input.query) {
+            throw new Error('search requires a non-empty "query".');
+        }
+        const fromMs = parseIsoDate(input.from, 'from');
+        const toMs = parseIsoDate(input.to, 'to');
+        const limit = clampCount(input.limit, SEARCH_DEFAULT_LIMIT, SEARCH_MAX_LIMIT, 'limit');
+        const maxScan = clampCount(input.maxScan, SEARCH_DEFAULT_MAX_SCAN, SEARCH_MAX_MAX_SCAN, 'maxScan');
+        const caseSensitive = input.caseSensitive ?? false;
+        const flags = caseSensitive ? '' : 'i';
+        // Validate regex SYNTAX up front — an invalid pattern is a clean tool
+        // error, not a crash mid-scan. This does NOT bound match TIME (a
+        // syntactically valid pattern can still backtrack catastrophically),
+        // which is why regex-mode matching itself runs on a worker below rather
+        // than here.
+        if (input.regex) {
+            try {
+                new RegExp(input.query, flags);
+            }
+            catch (error) {
+                throw new Error(`Invalid regex "${input.query}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const needle = caseSensitive ? input.query : input.query.toLowerCase();
+        const cm = this.cm;
+        // Fetch one more than maxScan so an oversized candidate window is
+        // detected up front (before any matching is attempted), rather than
+        // silently scanning maxScan candidates and returning as if that were the
+        // whole window. See the tool description's `truncated` contract.
+        const probe = cm.queryMessagesByTimeAndChannel({
+            fromMs,
+            toMs,
+            channelId: input.channelId,
+            limit: maxScan + 1,
+            offset: 0,
+        });
+        const truncated = probe.messages.length > maxScan;
+        const candidates = truncated ? probe.messages.slice(0, maxScan) : probe.messages;
+        if (input.regex) {
+            // Regex matching against caller-supplied patterns is ReDoS-shaped: a
+            // pathological pattern (e.g. `(a+)+$`) can take catastrophically long
+            // against one candidate string, and a synchronous RegExp.exec() on
+            // this thread would block the WHOLE framework's event loop — every
+            // agent's turns, health checks, timers — for as long as it runs, with
+            // no way to interrupt it from this same thread. Route matching
+            // through a worker thread instead, which can be forcibly terminated
+            // on a deadline. See search-regex-worker.ts's header for the full
+            // rationale.
+            const { matches, scanned } = await this.searchWithRegexWorker(candidates, input.query, flags, limit);
+            return { success: true, data: { scanned, candidatePoolSize: candidates.length, truncated, matches } };
+        }
+        // Plain substring search (String.prototype.indexOf) is inherently
+        // linear in input length — no ReDoS-equivalent risk — so it stays
+        // in-process. This is also the common case, so it pays no worker-spawn
+        // overhead.
+        const matches = [];
+        let scanned = 0;
+        for (const msg of candidates) {
+            // Check the limit BEFORE doing any work for this candidate — not
+            // after pushing a match — so limit:0 (a valid clampCount value: it's
+            // >= 0) correctly yields zero matches instead of one. Checking
+            // post-push would always let through the match that first reaches
+            // the limit. Same fix mirrored in search-regex-worker.ts's loop.
+            if (matches.length >= limit)
+                break;
+            scanned++;
+            const text = flattenContent(msg.content);
+            const hit = matchSubstring(text, needle, caseSensitive);
+            if (!hit)
+                continue;
+            matches.push({
+                id: String(msg.id),
+                timestamp: msg.timestamp.toISOString(),
+                participant: msg.participant,
+                channelId: getChannelId(msg) ?? null,
+                snippet: snippetAround(text, hit.index, hit.length),
+            });
+        }
+        return {
+            success: true,
+            data: { scanned, candidatePoolSize: candidates.length, truncated, matches },
+        };
+    }
+    /**
+     * Run regex matching for `search` on a worker thread with a hard
+     * wall-clock deadline, so a catastrophically-backtracking pattern can be
+     * forcibly killed instead of hanging the framework. One worker per call
+     * (not per candidate — spawn overhead would dominate at scale; not a
+     * persistent pool — a fresh worker per call means one bad pattern can
+     * never contaminate a later search). Always terminated on the way out,
+     * success or failure, so nothing lingers.
+     *
+     * On timeout or a worker-side error this THROWS (caught by
+     * handleToolCall's try/catch, same as every other error path in this
+     * module) rather than returning an empty match list — a timed-out search
+     * must never be indistinguishable from a clean "no matches" result.
+     */
+    async searchWithRegexWorker(candidates, pattern, flags, limit) {
+        const texts = candidates.map((msg) => flattenContent(msg.content));
+        let worker;
+        try {
+            const { matches: rawMatches, scanned } = await new Promise((resolve, reject) => {
+                worker = new Worker(SEARCH_WORKER_PATH, { workerData: { texts, pattern, flags, limit } });
+                const timer = setTimeout(() => {
+                    reject(new Error(`search timed out after ${SEARCH_REGEX_TIMEOUT_MS}ms while matching regex "${pattern}" against ` +
+                        `up to ${texts.length} candidate(s) — the pattern may be catastrophically slow (exponential ` +
+                        'backtracking) against this data; try a simpler pattern, a literal substring search ' +
+                        '(regex:false), or a smaller maxScan.'));
+                }, SEARCH_REGEX_TIMEOUT_MS);
+                timer.unref?.();
+                worker.once('message', (msg) => {
+                    clearTimeout(timer);
+                    if (msg.type === 'error')
+                        reject(new Error(msg.error));
+                    else
+                        resolve({ matches: msg.matches, scanned: msg.scanned });
+                });
+                worker.once('error', (err) => {
+                    clearTimeout(timer);
+                    reject(err);
+                });
+            });
+            const matches = rawMatches.map(({ candidateIndex, matchIndex, matchLength }) => {
+                const msg = candidates[candidateIndex];
+                const text = texts[candidateIndex];
+                return {
+                    id: String(msg.id),
+                    timestamp: msg.timestamp.toISOString(),
+                    participant: msg.participant,
+                    channelId: getChannelId(msg) ?? null,
+                    snippet: snippetAround(text, matchIndex, matchLength),
+                };
+            });
+            return { matches, scanned };
+        }
+        finally {
+            // Always kill the worker — whether it finished, errored, or is still
+            // stuck mid-backtrack when the deadline hit. terminate() on an
+            // already-exited worker is a harmless no-op.
+            if (worker)
+                void worker.terminate().catch(() => { });
+        }
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/** Parse an ISO 8601 date string to Unix ms. Throws a clear error (not a
+ *  crash) on an unparseable string; returns undefined for an omitted field
+ *  (open-ended bound). */
+function parseIsoDate(value, field) {
+    if (value === undefined)
+        return undefined;
+    const ms = Date.parse(value);
+    if (Number.isNaN(ms)) {
+        throw new Error(`Invalid ISO 8601 date for "${field}": ${JSON.stringify(value)}`);
+    }
+    return ms;
+}
+/**
+ * Validate a pagination-ish numeric input (limit/offset/maxScan) and clamp
+ * it to an upper bound. `Math.min(value, max)` alone is NOT sufficient here:
+ * it only enforces an upper bound, so `Math.min(-1, 200)` is `-1`, not a
+ * sane value — a negative limit/offset/maxScan would sail straight past the
+ * "hard cap" and reach a native chronicle call expecting an unsigned
+ * pagination argument (observed: `extract({limit:-1})` returning every
+ * message in the store instead of being capped). Rejects (rather than
+ * silently clamping) anything that isn't a finite non-negative integer, so
+ * a caller mistake is surfaced as a clean tool error instead of silently
+ * doing something other than what was asked.
+ */
+function clampCount(value, def, max, field) {
+    if (value === undefined)
+        return def;
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error(`"${field}" must be a finite number, got ${JSON.stringify(value)}.`);
+    }
+    if (!Number.isInteger(value)) {
+        throw new Error(`"${field}" must be an integer, got ${value}.`);
+    }
+    if (value < 0) {
+        throw new Error(`"${field}" must be >= 0, got ${value}.`);
+    }
+    return Math.min(value, max);
+}
+/** channelId lives at metadata.external.channelId — same path context-manager's
+ *  own native index reads from (message-store.ts's CHANNEL_FIELD). Metadata's
+ *  index-signature type means this needs an explicit narrow, same as
+ *  MessageStore.getChannelTokenStats does internally. */
+/**
+ * Two channel-id metadata shapes exist in the wild: `metadata.channelId`
+ * (what agent-framework's real MCPL ingestion — `handleMcplChannelIncoming`
+ * — actually writes) and `metadata.external.channelId` (an older
+ * convention). context-manager 0.9.1+ indexes and queries BOTH (see
+ * MessageStore.extractChannelId there), so a channel-filtered result can
+ * come from either shape — check the same order here so a displayed
+ * `channelId` never reads `null` on a message that was, in fact, matched by
+ * channel.
+ */
+function getChannelId(msg) {
+    const metadata = msg.metadata;
+    if (typeof metadata?.channelId === 'string')
+        return metadata.channelId;
+    return typeof metadata?.external?.channelId === 'string' ? metadata.external.channelId : undefined;
+}
+function projectMessage(msg, format) {
+    return {
+        id: String(msg.id),
+        timestamp: msg.timestamp.toISOString(),
+        participant: msg.participant,
+        channelId: getChannelId(msg) ?? null,
+        content: format === 'raw' ? msg.content : flattenContent(msg.content),
+    };
+}
+/** Flatten a message's content blocks to one short, readable string. Text
+ *  blocks verbatim; everything else (tool_use/tool_result/thinking/media) as
+ *  a short bracketed label — this is for agent readability and search
+ *  matching, not byte-faithful reconstruction. */
+function flattenContent(content) {
+    return content.map(blockLabel).join(' ').trim();
+}
+function blockLabel(block) {
+    switch (block.type) {
+        case 'text':
+            return block.text;
+        case 'tool_use':
+            return `[tool_use: ${block.name}]`;
+        case 'tool_result':
+            return block.toolName ? `[tool_result: ${block.toolName}]` : '[tool_result]';
+        case 'thinking':
+        case 'redacted_thinking':
+            return '[thinking]';
+        case 'image':
+            return '[image]';
+        case 'generated_image':
+            return '[image]';
+        case 'document':
+            return '[document]';
+        case 'audio':
+            return '[audio]';
+        case 'video':
+            return '[video]';
+        default:
+            // Exhaustiveness guard: a future ContentBlock variant falls back to a
+            // generic label instead of a compile error at a call site far from here.
+            return `[${block.type}]`;
+    }
+}
+function matchSubstring(text, needle, caseSensitive) {
+    const haystack = caseSensitive ? text : text.toLowerCase();
+    const index = haystack.indexOf(needle);
+    if (index === -1)
+        return null;
+    return { index, length: needle.length };
+}
+/** ~SNIPPET_CONTEXT_CHARS of surrounding context on each side of a match, or
+ *  the first ~SNIPPET_FALLBACK_CHARS of content when no meaningful match
+ *  position is given (kept simple on purpose — this is a readability aid,
+ *  not a highlighting engine). */
+function snippetAround(text, index, length) {
+    if (index < 0)
+        return text.slice(0, SNIPPET_FALLBACK_CHARS);
+    const start = Math.max(0, index - SNIPPET_CONTEXT_CHARS);
+    const end = Math.min(text.length, index + length + SNIPPET_CONTEXT_CHARS);
+    const prefix = start > 0 ? '…' : '';
+    const suffix = end < text.length ? '…' : '';
+    return prefix + text.slice(start, end) + suffix;
+}
+//# sourceMappingURL=index.js.map

package/dist/src/modules/history/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/history/index.ts"],"names":[],"mappings":"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"}

package/dist/src/modules/history/search-regex-worker.d.ts

@@ -0,0 +1,23 @@
+export interface SearchWorkerJob {
+    /** Flattened candidate text, aligned by index with the parent's candidate array. */
+    texts: string[];
+    pattern: string;
+    flags: string;
+    /** Stop scanning once this many matches are found. */
+    limit: number;
+}
+export interface SearchWorkerMatch {
+    /** Index into `texts` / the parent's candidate array. */
+    candidateIndex: number;
+    matchIndex: number;
+    matchLength: number;
+}
+export type SearchWorkerMessage = {
+    type: 'done';
+    matches: SearchWorkerMatch[];
+    scanned: number;
+} | {
+    type: 'error';
+    error: string;
+};
+//# sourceMappingURL=search-regex-worker.d.ts.map

package/dist/src/modules/history/search-regex-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-regex-worker.d.ts","sourceRoot":"","sources":["../../../../src/modules/history/search-regex-worker.ts"],"names":[],"mappings":"AA4BA,MAAM,WAAW,eAAe;IAC9B,oFAAoF;IACpF,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,yDAAyD;IACzD,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/src/modules/history/search-regex-worker.js

@@ -0,0 +1,57 @@
+/**
+ * search-regex-worker — runs a caller-supplied regex against a batch of
+ * message text on a separate thread, so HistoryModule's `search` tool can
+ * forcibly terminate a catastrophically-backtracking pattern (ReDoS)
+ * instead of blocking the framework's single-threaded event loop.
+ *
+ * Why a worker and not a Promise.race/setTimeout "timeout": JS is
+ * single-threaded, so nothing on the SAME thread can interrupt a
+ * synchronous RegExp.exec() call already in flight — a timeout callback
+ * racing it can't even fire until the blocking call returns, by which point
+ * it's too late. A worker thread is real OS-level concurrency: the parent's
+ * event loop keeps running, and `worker.terminate()` actually kills the
+ * stuck thread rather than just giving up on waiting for it.
+ *
+ * Only regex-mode search routes through this worker. Plain substring search
+ * (String.prototype.indexOf) is inherently linear in input length and has
+ * no equivalent risk, so it stays in-process — the common case pays no
+ * worker-spawn overhead.
+ *
+ * One-shot: the whole job (already-flattened text, already syntax-validated
+ * pattern/flags, match limit) arrives via `workerData` at construction; this
+ * script runs it to completion and posts exactly one message, then the
+ * parent always terminates the worker (whether it finished normally or had
+ * to be killed for running long) — no persistent pool, so a wedged worker
+ * from one bad pattern can never contaminate a later call.
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+const { texts, pattern, flags, limit } = workerData;
+try {
+    // Re-construct (not re-validate for safety — RegExp syntax is what it is;
+    // the parent already rejected an uncompilable pattern before ever getting
+    // here) the matcher on this thread. Compilation succeeding doesn't bound
+    // MATCHING time — that's exactly the risk this worker exists to contain.
+    const matcher = new RegExp(pattern, flags);
+    const matches = [];
+    let scanned = 0;
+    for (let i = 0; i < texts.length; i++) {
+        // Check the limit BEFORE doing any work for this candidate — not after
+        // pushing a match — so limit:0 (a valid clampCount value: it's >= 0)
+        // correctly yields zero matches instead of one. Checking post-push would
+        // always let through the match that first reaches the limit.
+        if (matches.length >= limit)
+            break;
+        scanned++;
+        const m = matcher.exec(texts[i] ?? '');
+        if (m) {
+            matches.push({ candidateIndex: i, matchIndex: m.index, matchLength: m[0].length });
+        }
+    }
+    const done = { type: 'done', matches, scanned };
+    parentPort?.postMessage(done);
+}
+catch (e) {
+    const errMsg = { type: 'error', error: e instanceof Error ? e.message : String(e) };
+    parentPort?.postMessage(errMsg);
+}
+//# sourceMappingURL=search-regex-worker.js.map

package/dist/src/modules/history/search-regex-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-regex-worker.js","sourceRoot":"","sources":["../../../../src/modules/history/search-regex-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAsB7D,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,UAA6B,CAAC;AAEvE,IAAI,CAAC;IACH,0EAA0E;IAC1E,0EAA0E;IAC1E,yEAAyE;IACzE,yEAAyE;IACzE,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC3C,MAAM,OAAO,GAAwB,EAAE,CAAC;IACxC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,uEAAuE;QACvE,qEAAqE;QACrE,yEAAyE;QACzE,6DAA6D;QAC7D,IAAI,OAAO,CAAC,MAAM,IAAI,KAAK;YAAE,MAAM;QACnC,OAAO,EAAE,CAAC;QACV,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QACvC,IAAI,CAAC,EAAE,CAAC;YACN,OAAO,CAAC,IAAI,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;IACD,MAAM,IAAI,GAAwB,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;IACrE,UAAU,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;AAAC,OAAO,CAAC,EAAE,CAAC;IACX,MAAM,MAAM,GAAwB,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IACzG,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;AAClC,CAAC"}

package/dist/src/modules/index.d.ts

@@ -5,6 +5,7 @@ export { ApiModule } from './api/index.js';
 export type { ApiEvent } from './api/index.js';
 export { HealthModule } from './health/index.js';
 export type { HealthModuleConfig } from './health/index.js';
+export { HistoryModule } from './history/index.js';
 export { WorkspaceModule, WorkspaceReadError } from './workspace/index.js';
 export type { WorkspaceReadErrorCode, WorkspaceReadStage, WorkspaceDiskReadResult, ReadFileFromDiskOptions } from './workspace/index.js';
 export type { WorkspaceConfig, MountConfig, MountState, WorkspaceModuleState, ReadInput, WriteInput, EditInput, DeleteInput, LsInput, GlobInput, GrepInput, StatusInput, MaterializeInput, SyncInput, } from './workspace/index.js';

package/dist/src/modules/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC3E,YAAY,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACzI,YAAY,EACV,eAAe,EACf,WAAW,EACX,UAAU,EACV,oBAAoB,EACpB,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,OAAO,EACP,SAAS,EACT,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,SAAS,GACV,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACpE,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,YAAY,EACV,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,SAAS,IAAI,gBAAgB,EAC7B,WAAW,EACX,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC3E,YAAY,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACzI,YAAY,EACV,eAAe,EACf,WAAW,EACX,UAAU,EACV,oBAAoB,EACpB,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,OAAO,EACP,SAAS,EACT,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,SAAS,GACV,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACpE,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,YAAY,EACV,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,SAAS,IAAI,gBAAgB,EAC7B,WAAW,EACX,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC"}