context-mode 1.0.99 → 1.0.101

package/build/search/unified.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Unified multi-source search — merges ContentStore, SessionDB, and
+ * auto-memory results into a single ranked or chronological result set.
+ *
+ * Used by ctx_search when sort="timeline" to search across all sources,
+ * or sort="relevance" (default) for ContentStore-only BM25 search.
+ */
+import type { ContentStore } from "../store.js";
+import type { SessionDB } from "../session/db.js";
+export interface UnifiedSearchResult {
+    title: string;
+    content: string;
+    source: string;
+    origin: "current-session" | "prior-session" | "auto-memory";
+    timestamp?: string;
+    rank?: number;
+    matchLayer?: string;
+    highlighted?: string;
+    contentType?: "code" | "prose";
+}
+export interface SearchAllSourcesOpts {
+    query: string;
+    limit: number;
+    store: ContentStore;
+    sort?: "relevance" | "timeline";
+    source?: string;
+    contentType?: "code" | "prose";
+    sessionDB?: SessionDB | null;
+    projectDir?: string;
+    configDir?: string;
+}
+/**
+ * Search across all available sources.
+ *
+ * - sort="relevance" (default): BM25-ranked results from ContentStore only.
+ * - sort="timeline": chronological merge of ContentStore + SessionDB + auto-memory.
+ *
+ * Errors in any single source are caught and logged — partial results
+ * are always returned.
+ */
+export declare function searchAllSources(opts: SearchAllSourcesOpts): UnifiedSearchResult[];

package/build/search/unified.js

@@ -0,0 +1,89 @@
+/**
+ * Unified multi-source search — merges ContentStore, SessionDB, and
+ * auto-memory results into a single ranked or chronological result set.
+ *
+ * Used by ctx_search when sort="timeline" to search across all sources,
+ * or sort="relevance" (default) for ContentStore-only BM25 search.
+ */
+import { searchAutoMemory } from "./auto-memory.js";
+const DEBUG = process.env.DEBUG?.includes("context-mode");
+// ─────────────────────────────────────────────────────────
+// Implementation
+// ─────────────────────────────────────────────────────────
+/**
+ * Search across all available sources.
+ *
+ * - sort="relevance" (default): BM25-ranked results from ContentStore only.
+ * - sort="timeline": chronological merge of ContentStore + SessionDB + auto-memory.
+ *
+ * Errors in any single source are caught and logged — partial results
+ * are always returned.
+ */
+export function searchAllSources(opts) {
+    const { query, limit, store, sort = "relevance", source, contentType, sessionDB, projectDir, configDir, } = opts;
+    const results = [];
+    // Capture session start time once — used as proxy for ContentStore items
+    // (we don't know exact indexing time, but all content is from current session)
+    const sessionStartTime = new Date().toISOString();
+    // ── Source 1: ContentStore (always, both modes) ──
+    try {
+        const storeResults = store.searchWithFallback(query, limit, source, contentType);
+        results.push(...storeResults.map((r) => ({
+            title: r.title,
+            content: r.content,
+            source: r.source,
+            origin: "current-session",
+            timestamp: r.timestamp || sessionStartTime,
+            rank: r.rank,
+            matchLayer: r.matchLayer,
+            highlighted: r.highlighted,
+            contentType: r.contentType,
+        })));
+    }
+    catch (e) {
+        if (DEBUG)
+            process.stderr.write(`[ctx] ContentStore search failed: ${e}\n`);
+    }
+    // ── Sources 2+3: timeline mode only ──
+    if (sort === "timeline") {
+        // Source 2: SessionDB — prior session events
+        try {
+            if (sessionDB) {
+                const dbResults = sessionDB.searchEvents(query, limit, projectDir || "", source);
+                results.push(...dbResults.map((r) => ({
+                    title: `[${r.category}] ${r.type}`,
+                    content: r.data,
+                    source: "prior-session",
+                    origin: "prior-session",
+                    timestamp: r.created_at,
+                })));
+            }
+        }
+        catch (e) {
+            if (DEBUG)
+                process.stderr.write(`[ctx] SessionDB search failed: ${e}\n`);
+        }
+        // Source 3: Auto-memory
+        try {
+            const memResults = searchAutoMemory([query], limit, projectDir, configDir);
+            results.push(...memResults);
+        }
+        catch (e) {
+            if (DEBUG)
+                process.stderr.write(`[ctx] auto-memory search failed: ${e}\n`);
+        }
+    }
+    // ── Normalize timestamps for consistent sorting ──
+    // SQLite datetime('now') → "YYYY-MM-DD HH:MM:SS" (no T, no Z)
+    // ISO → "YYYY-MM-DDTHH:MM:SS.sssZ"
+    for (const r of results) {
+        if (r.timestamp && !r.timestamp.includes("T")) {
+            r.timestamp = r.timestamp.replace(" ", "T") + "Z";
+        }
+    }
+    // ── Sort ──
+    if (sort === "timeline") {
+        results.sort((a, b) => (a.timestamp || "").localeCompare(b.timestamp || ""));
+    }
+    return results.slice(0, limit);
+}

package/build/server.js

@@ -16,7 +16,9 @@ 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 { buildNodeCommand } from "./adapters/types.js";
 import { loadDatabase } from "./db-base.js";
 import { AnalyticsEngine, formatReport } from "./session/analytics.js";
 const __pkg_dir = dirname(fileURLToPath(import.meta.url));
@@ -1081,6 +1083,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 +1103,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",
@@ -1163,26 +1173,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
@@ -1767,10 +1816,10 @@ server.registerTool("ctx_upgrade", {
     catch { /* best effort — don't block upgrade */ }
     let cmd;
     if (existsSync(bundlePath)) {
-        cmd = `node "${bundlePath}" upgrade`;
+        cmd = `${buildNodeCommand(bundlePath)} upgrade`;
     }
     else if (existsSync(fallbackPath)) {
-        cmd = `node "${fallbackPath}" upgrade`;
+        cmd = `${buildNodeCommand(fallbackPath)} upgrade`;
     }
     else {
         // Inline fallback: neither CLI file exists (e.g. marketplace installs).
@@ -1811,7 +1860,7 @@ server.registerTool("ctx_upgrade", {
         const tmpScript = resolve(pluginRoot, ".ctx-upgrade-inline.mjs");
         const { writeFileSync: writeTmp } = await import("node:fs");
         writeTmp(tmpScript, scriptLines);
-        cmd = `node "${tmpScript}"`;
+        cmd = buildNodeCommand(tmpScript);
     }
     const text = [
         "## ctx-upgrade",

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