context-mode 1.0.99 → 1.0.100

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;
     }

package/build/session/snapshot.js

@@ -312,6 +312,30 @@ function buildSkillsSection(skillEvents, searchTool) {
     ];
     return lines.join("\n");
 }
+function buildRolesSection(roleEvents, searchTool) {
+    if (roleEvents.length === 0)
+        return "";
+    const seen = new Set();
+    const summaryLines = [];
+    const queryTerms = [];
+    for (const ev of roleEvents) {
+        if (seen.has(ev.data))
+            continue;
+        seen.add(ev.data);
+        summaryLines.push(`    ${escapeXML(ev.data)}`);
+        queryTerms.push(ev.data);
+    }
+    if (summaryLines.length === 0)
+        return "";
+    const queries = buildQueries(queryTerms);
+    const lines = [
+        `  <roles count="${summaryLines.length}">`,
+        ...summaryLines,
+        toolCall(searchTool, queries),
+        `  </roles>`,
+    ];
+    return lines.join("\n");
+}
 function buildIntentSection(intentEvents) {
     if (intentEvents.length === 0)
         return "";
@@ -344,6 +368,7 @@ export function buildResumeSnapshot(events, opts) {
     const subagentEvents = [];
     const intentEvents = [];
     const skillEvents = [];
+    const roleEvents = [];
     for (const ev of events) {
         switch (ev.category) {
             case "file":
@@ -379,6 +404,9 @@ export function buildResumeSnapshot(events, opts) {
             case "skill":
                 skillEvents.push(ev);
                 break;
+            case "role":
+                roleEvents.push(ev);
+                break;
         }
     }
     // ── Build all sections ──
@@ -417,6 +445,9 @@ export function buildResumeSnapshot(events, opts) {
     const skills = buildSkillsSection(skillEvents, searchTool);
     if (skills)
         sections.push(skills);
+    const roles = buildRolesSection(roleEvents, searchTool);
+    if (roles)
+        sections.push(roles);
     const intent = buildIntentSection(intentEvents);
     if (intent)
         sections.push(intent);

package/build/store.js

@@ -402,6 +402,10 @@ export class ContentStore {
         content,
         source_id UNINDEXED,
         content_type UNINDEXED,
+        source_category UNINDEXED,
+        session_id UNINDEXED,
+        event_id UNINDEXED,
+        timestamp UNINDEXED,
         tokenize='porter unicode61'
       );
 
@@ -410,6 +414,10 @@ export class ContentStore {
         content,
         source_id UNINDEXED,
         content_type UNINDEXED,
+        source_category UNINDEXED,
+        session_id UNINDEXED,
+        event_id UNINDEXED,
+        timestamp UNINDEXED,
         tokenize='trigram'
       );
 
@@ -419,6 +427,47 @@ export class ContentStore {
 
       CREATE INDEX IF NOT EXISTS idx_sources_label ON sources(label);
     `);
+        // FTS5 schema migration: old schema (4 cols) → new schema (8 cols).
+        // FTS5 virtual tables do not support ALTER TABLE ADD COLUMN, so we must
+        // DROP + re-CREATE. Detection: check for sentinel column `source_category`
+        // via pragma_table_xinfo. Three states:
+        //   1. No table          → CREATE above handled it (fresh DB)
+        //   2. Old schema (4 cols) → DROP + CREATE new
+        //   3. New schema (8 cols) → do nothing
+        try {
+            const cols = this.#db.prepare("SELECT name FROM pragma_table_xinfo('chunks')").all();
+            const colNames = new Set(cols.map(c => c.name));
+            if (cols.length > 0 && !colNames.has("source_category")) {
+                // Old schema detected — drop both FTS5 tables and re-create with new columns
+                this.#db.exec("DROP TABLE IF EXISTS chunks");
+                this.#db.exec("DROP TABLE IF EXISTS chunks_trigram");
+                this.#db.exec(`
+          CREATE VIRTUAL TABLE chunks USING fts5(
+            title,
+            content,
+            source_id UNINDEXED,
+            content_type UNINDEXED,
+            source_category UNINDEXED,
+            session_id UNINDEXED,
+            event_id UNINDEXED,
+            timestamp UNINDEXED,
+            tokenize='porter unicode61'
+          );
+          CREATE VIRTUAL TABLE chunks_trigram USING fts5(
+            title,
+            content,
+            source_id UNINDEXED,
+            content_type UNINDEXED,
+            source_category UNINDEXED,
+            session_id UNINDEXED,
+            event_id UNINDEXED,
+            timestamp UNINDEXED,
+            tokenize='trigram'
+          );
+        `);
+            }
+        }
+        catch { /* pragma_table_xinfo may fail if table doesn't exist yet — safe to ignore */ }
         // Stale detection columns — safe for existing DBs (ALTER is O(1) in SQLite)
         try {
             this.#db.exec("ALTER TABLE sources ADD COLUMN file_path TEXT");
@@ -433,8 +482,8 @@ export class ContentStore {
         // Write path
         this.#stmtInsertSourceEmpty = this.#db.prepare("INSERT INTO sources (label, chunk_count, code_chunk_count, file_path, content_hash) VALUES (?, 0, 0, ?, ?)");
         this.#stmtInsertSource = this.#db.prepare("INSERT INTO sources (label, chunk_count, code_chunk_count, file_path, content_hash) VALUES (?, ?, ?, ?, ?)");
-        this.#stmtInsertChunk = this.#db.prepare("INSERT INTO chunks (title, content, source_id, content_type) VALUES (?, ?, ?, ?)");
-        this.#stmtInsertChunkTrigram = this.#db.prepare("INSERT INTO chunks_trigram (title, content, source_id, content_type) VALUES (?, ?, ?, ?)");
+        this.#stmtInsertChunk = this.#db.prepare("INSERT INTO chunks (title, content, source_id, content_type, source_category, session_id, event_id, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+        this.#stmtInsertChunkTrigram = this.#db.prepare("INSERT INTO chunks_trigram (title, content, source_id, content_type, source_category, session_id, event_id, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
         this.#stmtInsertVocab = this.#db.prepare("INSERT OR IGNORE INTO vocabulary (word) VALUES (?)");
         // Dedup path: delete previous source with same label before re-indexing
         // Prevents stale outputs from accumulating in iterative workflows (build-fix-build)
@@ -447,6 +496,7 @@ export class ContentStore {
         chunks.title,
         chunks.content,
         chunks.content_type,
+        chunks.timestamp,
         sources.label,
         bm25(chunks, 5.0, 1.0) AS rank,
         highlight(chunks, 1, char(2), char(3)) AS highlighted
@@ -461,6 +511,7 @@ export class ContentStore {
         chunks.title,
         chunks.content,
         chunks.content_type,
+        chunks.timestamp,
         sources.label,
         bm25(chunks, 5.0, 1.0) AS rank,
         highlight(chunks, 1, char(2), char(3)) AS highlighted
@@ -475,6 +526,7 @@ export class ContentStore {
         chunks.title,
         chunks.content,
         chunks.content_type,
+        chunks.timestamp,
         sources.label,
         bm25(chunks, 5.0, 1.0) AS rank,
         highlight(chunks, 1, char(2), char(3)) AS highlighted
@@ -489,6 +541,7 @@ export class ContentStore {
         chunks_trigram.title,
         chunks_trigram.content,
         chunks_trigram.content_type,
+        chunks_trigram.timestamp,
         sources.label,
         bm25(chunks_trigram, 5.0, 1.0) AS rank,
         highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
@@ -503,6 +556,7 @@ export class ContentStore {
         chunks_trigram.title,
         chunks_trigram.content,
         chunks_trigram.content_type,
+        chunks_trigram.timestamp,
         sources.label,
         bm25(chunks_trigram, 5.0, 1.0) AS rank,
         highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
@@ -517,6 +571,7 @@ export class ContentStore {
         chunks_trigram.title,
         chunks_trigram.content,
         chunks_trigram.content_type,
+        chunks_trigram.timestamp,
         sources.label,
         bm25(chunks_trigram, 5.0, 1.0) AS rank,
         highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
@@ -532,6 +587,7 @@ export class ContentStore {
         chunks.title,
         chunks.content,
         chunks.content_type,
+        chunks.timestamp,
         sources.label,
         bm25(chunks, 5.0, 1.0) AS rank,
         highlight(chunks, 1, char(2), char(3)) AS highlighted
@@ -546,6 +602,7 @@ export class ContentStore {
         chunks.title,
         chunks.content,
         chunks.content_type,
+        chunks.timestamp,
         sources.label,
         bm25(chunks, 5.0, 1.0) AS rank,
         highlight(chunks, 1, char(2), char(3)) AS highlighted
@@ -560,6 +617,7 @@ export class ContentStore {
         chunks.title,
         chunks.content,
         chunks.content_type,
+        chunks.timestamp,
         sources.label,
         bm25(chunks, 5.0, 1.0) AS rank,
         highlight(chunks, 1, char(2), char(3)) AS highlighted
@@ -574,6 +632,7 @@ export class ContentStore {
         chunks_trigram.title,
         chunks_trigram.content,
         chunks_trigram.content_type,
+        chunks_trigram.timestamp,
         sources.label,
         bm25(chunks_trigram, 5.0, 1.0) AS rank,
         highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
@@ -588,6 +647,7 @@ export class ContentStore {
         chunks_trigram.title,
         chunks_trigram.content,
         chunks_trigram.content_type,
+        chunks_trigram.timestamp,
         sources.label,
         bm25(chunks_trigram, 5.0, 1.0) AS rank,
         highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
@@ -602,6 +662,7 @@ export class ContentStore {
         chunks_trigram.title,
         chunks_trigram.content,
         chunks_trigram.content_type,
+        chunks_trigram.timestamp,
         sources.label,
         bm25(chunks_trigram, 5.0, 1.0) AS rank,
         highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
@@ -714,10 +775,11 @@ export class ContentStore {
             }
             const info = this.#stmtInsertSource.run(label, chunks.length, codeChunks, filePath ?? null, contentHash ?? null);
             const sourceId = Number(info.lastInsertRowid);
+            const now = new Date().toISOString();
             for (const chunk of chunks) {
                 const ct = chunk.hasCode ? "code" : "prose";
-                this.#stmtInsertChunk.run(chunk.title, chunk.content, sourceId, ct);
-                this.#stmtInsertChunkTrigram.run(chunk.title, chunk.content, sourceId, ct);
+                this.#stmtInsertChunk.run(chunk.title, chunk.content, sourceId, ct, null, null, null, now);
+                this.#stmtInsertChunkTrigram.run(chunk.title, chunk.content, sourceId, ct, null, null, null, now);
             }
             return sourceId;
         });
@@ -748,6 +810,7 @@ export class ContentStore {
             rank: r.rank,
             contentType: r.content_type,
             highlighted: r.highlighted,
+            timestamp: r.timestamp ?? undefined,
         }));
     }
     #sourceFilterParam(source, sourceMatchMode) {

package/build/types.d.ts

@@ -74,6 +74,7 @@ export interface SearchResult {
     contentType: "code" | "prose";
     matchLayer?: "porter" | "trigram" | "fuzzy" | "rrf" | "rrf-fuzzy";
     highlighted?: string;
+    timestamp?: string;
 }
 /**
  * Aggregate statistics for a ContentStore instance.