context-mode 1.0.98 → 1.0.100

package/build/server.js

@@ -16,7 +16,8 @@ import { readBashPolicies, evaluateCommandDenyOnly, extractShellCommands, readTo
 import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime, } from "./runtime.js";
 import { classifyNonZeroExit } from "./exit-classify.js";
 import { startLifecycleGuard } from "./lifecycle.js";
-import { getWorktreeSuffix } from "./session/db.js";
+import { getWorktreeSuffix, SessionDB } from "./session/db.js";
+import { searchAllSources } from "./search/unified.js";
 import { loadDatabase } from "./db-base.js";
 import { AnalyticsEngine, formatReport } from "./session/analytics.js";
 const __pkg_dir = dirname(fileURLToPath(import.meta.url));
@@ -58,7 +59,7 @@ const executor = new PolyglotExecutor({
     projectRoot: process.env.CLAUDE_PROJECT_DIR,
 });
 // ─────────────────────────────────────────────────────────
-// FS read tracking preload for batch_execute
+// FS read tracking preload for ctx_batch_execute
 // ─────────────────────────────────────────────────────────
 // NODE_OPTIONS is denied by the executor's #buildSafeEnv (security).
 // Instead, we inject it as an inline shell env prefix in each batch command.
@@ -515,7 +516,7 @@ export function formatBatchQueryResults(store, queries, source, maxOutput = 80 *
     let outputSize = 0;
     for (const query of queries) {
         if (outputSize > maxOutput) {
-            sections.push(`## ${query}\n(output cap reached — use search(queries: ["${query}"]) for details)\n`);
+            sections.push(`## ${query}\n(output cap reached — use ctx_search(queries: ["${query}"]) for details)\n`);
             continue;
         }
         const results = store.searchWithFallback(query, 3, source, undefined, "exact");
@@ -577,7 +578,7 @@ server.registerTool("ctx_execute", {
             .optional()
             .describe("What you're looking for in the output. When provided and output is large (>5KB), " +
             "indexes output into knowledge base and returns section titles + previews — not full content. " +
-            "Use search(queries: [...]) to retrieve specific sections. Example: 'failing tests', 'HTTP 500 errors'." +
+            "Use ctx_search(queries: [...]) to retrieve specific sections. Example: 'failing tests', 'HTTP 500 errors'." +
             "\n\nTIP: Use specific technical terms, not just concepts. Check 'Searchable terms' in the response for available vocabulary."),
     }),
 }, async ({ language, code, timeout, background, intent }) => {
@@ -779,7 +780,7 @@ function indexStdout(stdout, source) {
         content: [
             {
                 type: "text",
-                text: `Indexed ${indexed.totalChunks} sections (${indexed.codeChunks} with code) from: ${indexed.label}\nUse search(queries: ["..."]) to query this content. Use source: "${indexed.label}" to scope results.`,
+                text: `Indexed ${indexed.totalChunks} sections (${indexed.codeChunks} with code) from: ${indexed.label}\nUse ctx_search(queries: ["..."]) to query this content. Use source: "${indexed.label}" to scope results.`,
             },
         ],
     };
@@ -792,7 +793,7 @@ const LARGE_OUTPUT_THRESHOLD = 102_400; // 100KB — auto-index into FTS5, retur
 function intentSearch(stdout, intent, source, maxResults = 5) {
     const totalLines = stdout.split("\n").length;
     const totalBytes = Buffer.byteLength(stdout);
-    // Index into the PERSISTENT store so user can search() later
+    // Index into the PERSISTENT store so user can ctx_search() later
     const persistent = getStore();
     const indexed = persistent.indexPlainText(stdout, source);
     // Search the persistent store directly (porter → trigram → fuzzy)
@@ -809,7 +810,7 @@ function intentSearch(stdout, intent, source, maxResults = 5) {
             lines.push(`Searchable terms: ${distinctiveTerms.join(", ")}`);
         }
         lines.push("");
-        lines.push("Use search() to explore the indexed content.");
+        lines.push("Use ctx_search(queries: [...]) to explore the indexed content.");
         return lines.join("\n");
     }
     // Return ONLY titles + first-line previews — not full content
@@ -827,7 +828,7 @@ function intentSearch(stdout, intent, source, maxResults = 5) {
         lines.push(`Searchable terms: ${distinctiveTerms.join(", ")}`);
     }
     lines.push("");
-    lines.push("Use search(queries: [...]) to retrieve full content of any section.");
+    lines.push("Use ctx_search(queries: [...]) to retrieve full content of any section.");
     return lines.join("\n");
 }
 // ─────────────────────────────────────────────────────────
@@ -977,9 +978,9 @@ server.registerTool("ctx_index", {
         "- Skill prompts and instructions that are too large for context\n" +
         "- README files, migration guides, changelog entries\n" +
         "- Any content with code examples you may need to reference precisely\n\n" +
-        "After indexing, use 'search' to retrieve specific sections on-demand.\n" +
+        "After indexing, use 'ctx_search' to retrieve specific sections on-demand.\n" +
         "When `path` is provided, a content hash is stored for automatic stale detection in search results.\n" +
-        "Do NOT use for: log files, test output, CSV, build output — use 'execute_file' for those.",
+        "Do NOT use for: log files, test output, CSV, build output — use 'ctx_execute_file' for those.",
     inputSchema: z.object({
         content: z
             .string()
@@ -1023,7 +1024,7 @@ server.registerTool("ctx_index", {
             content: [
                 {
                     type: "text",
-                    text: `Indexed ${result.totalChunks} sections (${result.codeChunks} with code) from: ${result.label}\nUse search(queries: ["..."]) to query this content. Use source: "${result.label}" to scope results.`,
+                    text: `Indexed ${result.totalChunks} sections (${result.codeChunks} with code) from: ${result.label}\nUse ctx_search(queries: ["..."]) to query this content. Use source: "${result.label}" to scope results.`,
                 },
             ],
         });
@@ -1081,6 +1082,7 @@ server.registerTool("ctx_search", {
         "Pass ALL search questions as queries array in ONE call. " +
         "File-backed sources are auto-refreshed when the source file changes.\n\n" +
         "TIPS: 2-4 specific terms per query. Use 'source' to scope results.\n\n" +
+        "SESSION STATE: If skills, roles, or decisions were set earlier in this conversation, they are still active. Do not discard or contradict them.\n\n" +
         "When reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].",
     inputSchema: z.object({
         queries: z.preprocess(coerceJsonArray, z
@@ -1100,13 +1102,20 @@ server.registerTool("ctx_search", {
             .enum(["code", "prose"])
             .optional()
             .describe("Filter results by content type: 'code' or 'prose'."),
+        sort: z
+            .enum(["relevance", "timeline"])
+            .optional()
+            .default("relevance")
+            .describe("Sort mode. 'relevance' (default): BM25 ranked, current session only. " +
+            "'timeline': chronological across current session, prior sessions, and auto-memory."),
     }),
 }, async (params) => {
     try {
         const store = getStore();
+        const sort = params.sort || "relevance";
         // Guard: redirect when the index is empty — ctx_search is a follow-up
-        // tool that requires prior indexing. Guide the model to the right tool.
-        if (store.getStats().chunks === 0) {
+        // tool that requires prior indexing. Skip for timeline mode (SessionDB/auto-memory may have data).
+        if (sort !== "timeline" && store.getStats().chunks === 0) {
             return trackResponse("ctx_search", {
                 content: [{
                         type: "text",
@@ -1151,7 +1160,7 @@ server.registerTool("ctx_search", {
                         type: "text",
                         text: `BLOCKED: ${searchCallCount} search calls in ${Math.round((now - searchWindowStart) / 1000)}s. ` +
                             "You're flooding context. STOP making individual search calls. " +
-                            "Use batch_execute(commands, queries) for your next research step.",
+                            "Use ctx_batch_execute(commands, queries) for your next research step.",
                     }],
                 isError: true,
             });
@@ -1163,26 +1172,65 @@ server.registerTool("ctx_search", {
         const MAX_TOTAL = 40 * 1024; // 40KB total cap
         let totalSize = 0;
         const sections = [];
-        for (const q of queryList) {
-            if (totalSize > MAX_TOTAL) {
-                sections.push(`## ${q}\n(output cap reached)\n`);
-                continue;
+        // Open SessionDB once before the loop (Blocker 4: avoid open/close per query)
+        let timelineDB = null;
+        if (sort === "timeline") {
+            try {
+                const sessionsDir = getSessionDir();
+                const dbFile = join(sessionsDir, `${hashProjectDir()}.db`);
+                if (existsSync(dbFile)) {
+                    timelineDB = new SessionDB({ dbPath: dbFile });
+                }
             }
-            const results = store.searchWithFallback(q, effectiveLimit, source, contentType);
-            if (results.length === 0) {
-                sections.push(`## ${q}\nNo results found.`);
-                continue;
+            catch { /* SessionDB unavailable — search ContentStore + auto-memory only */ }
+        }
+        const configDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+        try {
+            for (const q of queryList) {
+                if (totalSize > MAX_TOTAL) {
+                    sections.push(`## ${q}\n(output cap reached)\n`);
+                    continue;
+                }
+                let results;
+                if (sort === "timeline") {
+                    results = searchAllSources({
+                        query: q,
+                        limit: effectiveLimit,
+                        store,
+                        sort,
+                        source,
+                        contentType,
+                        sessionDB: timelineDB,
+                        projectDir: getProjectDir(),
+                        configDir,
+                    });
+                }
+                else {
+                    results = store.searchWithFallback(q, effectiveLimit, source, contentType);
+                }
+                if (results.length === 0) {
+                    sections.push(`## ${q}\nNo results found.`);
+                    continue;
+                }
+                const formatted = results
+                    .map((r, i) => {
+                    const origin = r.origin || "current-session";
+                    const ts = r.timestamp ? r.timestamp.slice(0, 16).replace("T", " ") : "";
+                    const header = `--- [${origin}${ts ? " | " + ts : ""} | ${r.source}] ---`;
+                    const heading = `### ${r.title}`;
+                    const snippet = extractSnippet(r.content, q, 1500, r.highlighted);
+                    return `${header}\n${heading}\n\n${snippet}`;
+                })
+                    .join("\n\n");
+                sections.push(`## ${q}\n\n${formatted}`);
+                totalSize += formatted.length;
             }
-            const formatted = results
-                .map((r, i) => {
-                const header = `--- [${r.source}] ---`;
-                const heading = `### ${r.title}`;
-                const snippet = extractSnippet(r.content, q, 1500, r.highlighted);
-                return `${header}\n${heading}\n\n${snippet}`;
-            })
-                .join("\n\n");
-            sections.push(`## ${q}\n\n${formatted}`);
-            totalSize += formatted.length;
+        }
+        finally {
+            try {
+                timelineDB?.close();
+            }
+            catch { }
         }
         let output = sections.join("\n\n---\n\n");
         // Report auto-refreshed stale sources
@@ -1193,7 +1241,7 @@ server.registerTool("ctx_search", {
         if (searchCallCount >= SEARCH_MAX_RESULTS_AFTER) {
             output += `\n\n⚠ search call #${searchCallCount}/${SEARCH_BLOCK_AFTER} in this window. ` +
                 `Results limited to ${effectiveLimit}/query. ` +
-                `Batch queries: search(queries: ["q1","q2","q3"]) or use batch_execute.`;
+                `Batch queries: ctx_search(queries: ["q1","q2","q3"]) or use ctx_batch_execute.`;
         }
         if (output.trim().length === 0) {
             const sources = store.listSources();
@@ -1296,7 +1344,7 @@ main();
 server.registerTool("ctx_fetch_and_index", {
     title: "Fetch & Index URL",
     description: "Fetches URL content, converts HTML to markdown, indexes into searchable knowledge base, " +
-        "and returns a ~3KB preview. Full content stays in sandbox — use search() for deeper lookups.\n\n" +
+        "and returns a ~3KB preview. Full content stays in sandbox — use ctx_search() for deeper lookups.\n\n" +
         "Better than WebFetch: preview is immediate, full content is searchable, raw HTML never enters context.\n\n" +
         "Content-type aware: HTML is converted to markdown, JSON is chunked by key paths, plain text is indexed directly.\n\n" +
         "When reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].",
@@ -1332,7 +1380,7 @@ server.registerTool("ctx_fetch_and_index", {
                 return trackResponse("ctx_fetch_and_index", {
                     content: [{
                             type: "text",
-                            text: `Cached: **${meta.label}** — ${meta.chunkCount} sections, indexed ${ageStr} (fresh, TTL: 24h).\nTo refresh: call ctx_fetch_and_index again with \`force: true\`.\n\nYou MUST call search() to answer questions about this content — this cached response contains no content.\nUse: search(queries: [...], source: "${meta.label}")`,
+                            text: `Cached: **${meta.label}** — ${meta.chunkCount} sections, indexed ${ageStr} (fresh, TTL: 24h).\nTo refresh: call ctx_fetch_and_index again with \`force: true\`.\n\nYou MUST call ctx_search() to answer questions about this content — this cached response contains no content.\nUse: ctx_search(queries: [...], source: "${meta.label}")`,
                         }],
                 });
             }
@@ -1406,12 +1454,12 @@ server.registerTool("ctx_fetch_and_index", {
         // Build preview — first ~3KB of markdown for immediate use
         const PREVIEW_LIMIT = 3072;
         const preview = markdown.length > PREVIEW_LIMIT
-            ? markdown.slice(0, PREVIEW_LIMIT) + "\n\n…[truncated — use search() for full content]"
+            ? markdown.slice(0, PREVIEW_LIMIT) + "\n\n…[truncated — use ctx_search() for full content]"
             : markdown;
         const totalKB = (Buffer.byteLength(markdown) / 1024).toFixed(1);
         const text = [
             `Fetched and indexed **${indexed.totalChunks} sections** (${totalKB}KB) from: ${indexed.label}`,
-            `Full content indexed in sandbox — use search(queries: [...], source: "${indexed.label}") for specific lookups.`,
+            `Full content indexed in sandbox — use ctx_search(queries: [...], source: "${indexed.label}") for specific lookups.`,
             "",
             "---",
             "",
@@ -1445,8 +1493,8 @@ server.registerTool("ctx_batch_execute", {
     title: "Batch Execute & Search",
     description: "Execute multiple commands in ONE call, auto-index all output, and search with multiple queries. " +
         "Returns search results directly — no follow-up calls needed.\n\n" +
-        "THIS IS THE PRIMARY TOOL. Use this instead of multiple execute() calls.\n\n" +
-        "One batch_execute call replaces 30+ execute calls + 10+ search calls.\n" +
+        "THIS IS THE PRIMARY TOOL. Use this instead of multiple ctx_execute() calls.\n\n" +
+        "One ctx_batch_execute call replaces 30+ ctx_execute calls + 10+ ctx_search calls.\n" +
         "Provide all commands to run and all queries to search — everything happens in one round trip.\n\n" +
         "THINK IN CODE: When commands produce data you need to analyze, add processing commands that filter and summarize. Don't pull raw output into context — let the sandbox do the work.\n\n" +
         "When reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].",
@@ -1560,7 +1608,7 @@ server.registerTool("ctx_batch_execute", {
             sectionTitles.push(s.title);
         }
         // Run all search queries — source scoped only.
-        // Cross-source search remains available via explicit search().
+        // Cross-source search remains available via explicit ctx_search().
         const queryResults = formatBatchQueryResults(store, queries, source);
         // Get searchable terms for edge cases where follow-up is needed
         const distinctiveTerms = store.getDistinctiveTerms

package/build/session/analytics.js

@@ -182,7 +182,7 @@ export class AnalyticsEngine {
                 if (row.category === "file") {
                     display = row.data.split("/").pop() || row.data;
                 }
-                else if (row.category === "prompt") {
+                else if (row.category === "prompt" || row.category === "user-prompt") {
                     display = display.length > 50 ? display.slice(0, 47) + "..." : display;
                 }
                 if (display.length > 40)

package/build/session/db.d.ts

@@ -92,6 +92,23 @@ export declare class SessionDB extends SQLiteBase {
      * Return the most recently attributed project dir for a session.
      */
     getLatestAttributedProjectDir(sessionId: string): string | null;
+    /**
+     * Search events by text query scoped to a project directory.
+     *
+     * Performs a case-insensitive LIKE search across the `data` and `category`
+     * columns. An optional `source` parameter filters by exact category match.
+     * Returns results ordered by monotonic id (chronological).
+     *
+     * Best-effort: returns empty array on any error.
+     */
+    searchEvents(query: string, limit: number, projectDir: string, source?: string): Array<{
+        id: number;
+        session_id: string;
+        category: string;
+        type: string;
+        data: string;
+        created_at: string;
+    }>;
     /**
      * Ensure a session metadata entry exists. Idempotent (INSERT OR IGNORE).
      * `projectDir` is the session origin directory, not per-event attribution.

package/build/session/db.js

@@ -76,6 +76,7 @@ const S = {
     deleteMeta: "deleteMeta",
     deleteResume: "deleteResume",
     getOldSessions: "getOldSessions",
+    searchEvents: "searchEvents",
 };
 // ─────────────────────────────────────────────────────────
 // SessionDB
@@ -225,6 +226,14 @@ export class SessionDB extends SQLiteBase {
         p(S.deleteEvents, `DELETE FROM session_events WHERE session_id = ?`);
         p(S.deleteMeta, `DELETE FROM session_meta WHERE session_id = ?`);
         p(S.deleteResume, `DELETE FROM session_resume WHERE session_id = ?`);
+        // ── Search ──
+        p(S.searchEvents, `SELECT id, session_id, category, type, data, created_at
+       FROM session_events
+       WHERE project_dir = ?
+         AND (data LIKE '%' || ? || '%' ESCAPE '\\' OR category LIKE '%' || ? || '%' ESCAPE '\\')
+         AND (? IS NULL OR category = ?)
+       ORDER BY id ASC
+       LIMIT ?`);
         // ── Cleanup ──
         p(S.getOldSessions, `SELECT session_id FROM session_meta WHERE started_at < datetime('now', ? || ' days')`);
     }
@@ -310,6 +319,25 @@ export class SessionDB extends SQLiteBase {
         const row = this.stmt(S.getLatestAttributedProject).get(sessionId);
         return row?.project_dir || null;
     }
+    /**
+     * Search events by text query scoped to a project directory.
+     *
+     * Performs a case-insensitive LIKE search across the `data` and `category`
+     * columns. An optional `source` parameter filters by exact category match.
+     * Returns results ordered by monotonic id (chronological).
+     *
+     * Best-effort: returns empty array on any error.
+     */
+    searchEvents(query, limit, projectDir, source) {
+        try {
+            const escapedQuery = query.replace(/[%_]/g, (char) => "\\" + char);
+            const sourceParam = source ?? null;
+            return this.stmt(S.searchEvents).all(projectDir, escapedQuery, escapedQuery, sourceParam, sourceParam, limit);
+        }
+        catch {
+            return [];
+        }
+    }
     // ═══════════════════════════════════════════
     // Meta
     // ═══════════════════════════════════════════

package/build/session/extract.d.ts

@@ -35,6 +35,10 @@ export interface HookInput {
         isError?: boolean;
     };
 }
+/** Reset error-resolution state (for testing). */
+export declare function resetErrorResolutionState(): void;
+/** Reset iteration-loop state (for testing). */
+export declare function resetIterationLoopState(): void;
 /**
  * Extract session events from a PostToolUse hook input.
  *

package/build/session/extract.js

@@ -335,9 +335,36 @@ function extractSkill(input) {
             type: "skill",
             category: "skill",
             data: safeString(skillName),
-            priority: 3,
+            priority: 2,
         }];
 }
+/**
+ * Category 16: constraint
+ * Constraints discovered through error events — tool failures reveal
+ * platform/environment limitations worth remembering.
+ */
+function extractConstraint(input) {
+    // Only fire on error events — constraints are discovered through failures
+    if (!input.tool_response?.includes("Error") && !input.tool_output?.isError)
+        return [];
+    const response = String(input.tool_response || "");
+    const patterns = [/not supported/i, /cannot/i, /does not support/i, /FAIL/i, /refused/i, /permission denied/i, /incompatible/i];
+    for (const pattern of patterns) {
+        const match = response.match(pattern);
+        if (match) {
+            // Extract context around the match
+            const idx = response.toLowerCase().indexOf(match[0].toLowerCase());
+            const context = response.slice(Math.max(0, idx - 50), Math.min(response.length, idx + 200)).trim();
+            return [{
+                    type: "constraint_discovered",
+                    category: "constraint",
+                    data: safeString(context),
+                    priority: 2,
+                }];
+        }
+    }
+    return [];
+}
 /**
  * Category 9: subagent
  * Agent tool calls — tracks both launch and completion.
@@ -410,6 +437,67 @@ function extractDecision(input) {
             priority: 2,
         }];
 }
+/**
+ * Category 22: agent-finding
+ * When the Agent tool completes (subagent returns), capture a structured
+ * summary of its findings (first 500 chars of tool_response).
+ */
+function extractAgentFinding(input) {
+    if (input.tool_name !== "Agent")
+        return [];
+    if (!input.tool_response || input.tool_response.length === 0)
+        return [];
+    const summary = input.tool_response.length > 500
+        ? input.tool_response.slice(0, 500)
+        : input.tool_response;
+    return [{
+            type: "agent_finding",
+            category: "agent-finding",
+            data: safeString(summary),
+            priority: 2,
+        }];
+}
+/**
+ * Category 24: external-ref
+ * Scan tool_input and tool_response for external URLs, GitHub issues, and PRs.
+ * Deduplicates found refs and skips internal URLs (localhost, 127.0.0.1).
+ */
+function extractExternalRef(input) {
+    const haystack = [
+        safeStringAny(input.tool_input),
+        safeString(input.tool_response),
+    ].join(" ");
+    if (haystack.length === 0)
+        return [];
+    const refs = new Set();
+    // URLs — skip localhost / 127.0.0.1
+    const urlMatches = haystack.match(/https?:\/\/[^\s)]+/g);
+    if (urlMatches) {
+        for (let url of urlMatches) {
+            // Strip trailing punctuation that gets captured from JSON/prose
+            url = url.replace(/["'})\],;.]+$/, "");
+            if (!/localhost|127\.0\.0\.1/i.test(url)) {
+                refs.add(url);
+            }
+        }
+    }
+    // Full GitHub issue/PR URLs are already captured above.
+    // Shorthand GitHub issue refs: #123 (only bare, not inside a URL)
+    const issueMatches = haystack.match(/(?<!\w)#(\d+)/g);
+    if (issueMatches) {
+        for (const m of issueMatches) {
+            refs.add(m);
+        }
+    }
+    if (refs.size === 0)
+        return [];
+    return [{
+            type: "external_ref",
+            category: "external-ref",
+            data: safeString(Array.from(refs).join(", ")),
+            priority: 3,
+        }];
+}
 /**
  * Category 8: env (worktree)
  * EnterWorktree tool — tracks worktree creation.
@@ -490,6 +578,52 @@ function extractIntent(message) {
             priority: 4,
         }];
 }
+/**
+ * Category 25: blocked-on
+ * Detect when work is blocked on something, or when a blocker is resolved.
+ */
+const BLOCKER_PATTERNS = [
+    /\bblocked on\b/i,
+    /\bwaiting for\b/i,
+    /\bneed\s+\S+\s+before\b/i,
+    /\bcan'?t proceed until\b/i,
+    /\bdepends on\b/i,
+    /\bblocked\b/i,
+    // Turkish patterns
+    /\bbekliyor\b/i,
+    /\bbekliyorum\b/i,
+];
+const BLOCKER_RESOLVED_PATTERNS = [
+    /\bunblocked\b/i,
+    /\bresolved\b/i,
+    /\bgot the\s+\S+/i,
+    /\bis ready now\b/i,
+    /\bcan proceed\b/i,
+];
+function extractBlocker(message) {
+    const events = [];
+    // Check resolution first — if both match, resolution takes priority
+    const isResolved = BLOCKER_RESOLVED_PATTERNS.some(p => p.test(message));
+    if (isResolved) {
+        events.push({
+            type: "blocker_resolved",
+            category: "blocked-on",
+            data: safeString(message),
+            priority: 2,
+        });
+        return events;
+    }
+    const isBlocked = BLOCKER_PATTERNS.some(p => p.test(message));
+    if (isBlocked) {
+        events.push({
+            type: "blocker",
+            category: "blocked-on",
+            data: safeString(message),
+            priority: 2,
+        });
+    }
+    return events;
+}
 /**
  * Category 12: data
  * Large user-pasted data references (message > 1KB).
@@ -504,6 +638,96 @@ function extractData(message) {
             priority: 4,
         }];
 }
+// ── Cross-event stateful extractors ───────────────────────────────────────
+/**
+ * Category 23: error-resolution
+ * Detects when an error is followed by a successful fix (cross-event state).
+ */
+let lastError = null;
+function extractErrorResolution(input) {
+    const { tool_name, tool_response, tool_output } = input;
+    const response = String(tool_response ?? "");
+    const isErrorFlag = tool_output?.isError === true;
+    const isBashError = tool_name === "Bash" &&
+        /exit code [1-9]|error:|Error:|FAIL|failed/i.test(response);
+    // If this call is an error, store it and return
+    if (isBashError || isErrorFlag) {
+        lastError = { tool: tool_name, error: response.slice(0, 200), callsSince: 0 };
+        return [];
+    }
+    // No pending error → nothing to resolve
+    if (!lastError)
+        return [];
+    // Increment staleness counter
+    lastError.callsSince++;
+    // Timeout: clear after 10 calls without resolution
+    if (lastError.callsSince > 10) {
+        lastError = null;
+        return [];
+    }
+    // Check if this is a resolution: same tool, or Edit/Write after a Read error
+    const sameTool = tool_name === lastError.tool;
+    const editAfterReadError = lastError.tool === "Read" && (tool_name === "Edit" || tool_name === "Write");
+    if (sameTool || editAfterReadError) {
+        const event = {
+            type: "error_resolved",
+            category: "error-resolution",
+            data: safeString(`Error in ${lastError.tool}: ${lastError.error} → Fixed`),
+            priority: 2,
+        };
+        lastError = null;
+        return [event];
+    }
+    return [];
+}
+/** Reset error-resolution state (for testing). */
+export function resetErrorResolutionState() {
+    lastError = null;
+}
+/**
+ * Category 26: iteration-loop
+ * Detects when the same tool is called repeatedly with similar input (stuck loop).
+ */
+const callHistory = [];
+function simpleHash(str) {
+    return `${str.length}:${str.slice(0, 20)}`;
+}
+function extractIterationLoop(input) {
+    const { tool_name, tool_input } = input;
+    const inputHash = simpleHash(JSON.stringify(tool_input).slice(0, 200));
+    callHistory.push({ tool: tool_name, inputHash });
+    // Keep history bounded
+    if (callHistory.length > 50) {
+        callHistory.splice(0, callHistory.length - 50);
+    }
+    // Check last N entries for repeated pattern (minimum 3)
+    if (callHistory.length < 3)
+        return [];
+    let count = 0;
+    for (let i = callHistory.length - 1; i >= 0; i--) {
+        if (callHistory[i].tool === tool_name && callHistory[i].inputHash === inputHash) {
+            count++;
+        }
+        else {
+            break;
+        }
+    }
+    if (count >= 3) {
+        // Reset the matching tail to avoid duplicate emissions
+        callHistory.splice(callHistory.length - count);
+        return [{
+                type: "retry_detected",
+                category: "iteration-loop",
+                data: safeString(`${tool_name} called ${count} times with similar input`),
+                priority: 2,
+            }];
+    }
+    return [];
+}
+/** Reset iteration-loop state (for testing). */
+export function resetIterationLoopState() {
+    callHistory.length = 0;
+}
 // ── Public API ─────────────────────────────────────────────────────────────
 /**
  * Extract session events from a PostToolUse hook input.
@@ -528,7 +752,13 @@ export function extractEvents(input) {
         events.push(...extractSubagent(input));
         events.push(...extractMcp(input));
         events.push(...extractDecision(input));
+        events.push(...extractConstraint(input));
         events.push(...extractWorktree(input));
+        events.push(...extractAgentFinding(input));
+        events.push(...extractExternalRef(input));
+        // Cross-event stateful extractors
+        events.push(...extractErrorResolution(input));
+        events.push(...extractIterationLoop(input));
         return events;
     }
     catch {
@@ -548,6 +778,7 @@ export function extractUserEvents(message) {
         events.push(...extractUserDecision(message));
         events.push(...extractRole(message));
         events.push(...extractIntent(message));
+        events.push(...extractBlocker(message));
         events.push(...extractData(message));
         return events;
     }