context-mode 1.0.88 → 1.0.90

package/hooks/vscode-copilot/posttooluse.mjs

@@ -10,32 +10,34 @@ import "../ensure-deps.mjs";
  * Must be fast (<20ms). No network, no LLM, just SQLite writes.
  */
 
-import { createSessionLoaders } from "../session-loaders.mjs";
-import { readStdin, getSessionId, getSessionDBPath, getProjectDir, VSCODE_OPTS } from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, VSCODE_OPTS } from "../session-helpers.mjs";
 import { appendFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 
 const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-const { loadSessionDB, loadExtract } = createSessionLoaders(HOOK_DIR);
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
 const OPTS = VSCODE_OPTS;
 const DEBUG_LOG = join(homedir(), ".vscode", "context-mode", "posttooluse-debug.log");
 
 try {
   const raw = await readStdin();
-  const input = JSON.parse(raw);
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
 
   appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] CALL: ${input.tool_name}\n`);
 
   const { extractEvents } = await loadExtract();
+  const { resolveProjectAttributions } = await loadProjectAttribution();
   const { SessionDB } = await loadSessionDB();
 
   const dbPath = getSessionDBPath(OPTS);
   const db = new SessionDB({ dbPath });
   const sessionId = getSessionId(input, OPTS);
 
-  db.ensureSession(sessionId, getProjectDir(OPTS));
+  db.ensureSession(sessionId, projectDir);
 
   const events = extractEvents({
     tool_name: input.tool_name,
@@ -46,9 +48,7 @@ try {
     tool_output: input.tool_output,
   });
 
-  for (const event of events) {
-    db.insertEvent(sessionId, event, "PostToolUse");
-  }
+  attributeAndInsertEvents(db, sessionId, events, input, projectDir, "PostToolUse", resolveProjectAttributions);
 
   appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] OK: ${input.tool_name} → ${events.length} events\n`);
   db.close();

package/hooks/vscode-copilot/precompact.mjs

@@ -10,7 +10,7 @@ import "../ensure-deps.mjs";
  */
 
 import { createSessionLoaders } from "../session-loaders.mjs";
-import { readStdin, getSessionId, getSessionDBPath, VSCODE_OPTS } from "../session-helpers.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, VSCODE_OPTS } from "../session-helpers.mjs";
 import { appendFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -23,7 +23,7 @@ const DEBUG_LOG = join(homedir(), ".vscode", "context-mode", "precompact-debug.l
 
 try {
   const raw = await readStdin();
-  const input = JSON.parse(raw);
+  const input = parseStdin(raw);
 
   const { buildResumeSnapshot } = await loadSnapshot();
   const { SessionDB } = await loadSessionDB();

package/hooks/vscode-copilot/pretooluse.mjs

@@ -10,16 +10,17 @@ import { fileURLToPath } from "node:url";
 import { readStdin } from "../core/stdin.mjs";
 import { routePreToolUse, initSecurity } from "../core/routing.mjs";
 import { formatDecision } from "../core/formatters.mjs";
+import { parseStdin, getSessionId, VSCODE_OPTS } from "../session-helpers.mjs";
 
 const __hookDir = dirname(fileURLToPath(import.meta.url));
 await initSecurity(resolve(__hookDir, "..", "..", "build"));
 
 const raw = await readStdin();
-const input = JSON.parse(raw);
+const input = parseStdin(raw);
 const tool = input.tool_name ?? "";
 const toolInput = input.tool_input ?? {};
 
-const decision = routePreToolUse(tool, toolInput, process.env.VSCODE_CWD || process.env.CLAUDE_PROJECT_DIR, "vscode-copilot");
+const decision = routePreToolUse(tool, toolInput, process.env.VSCODE_CWD || process.env.CLAUDE_PROJECT_DIR, "vscode-copilot", getSessionId(input, VSCODE_OPTS));
 const response = formatDecision("vscode-copilot", decision);
 if (response !== null) {
   process.stdout.write(JSON.stringify(response) + "\n");

package/hooks/vscode-copilot/sessionstart.mjs

@@ -19,7 +19,7 @@ const toolNamer = createToolNamer("vscode-copilot");
 const ROUTING_BLOCK = createRoutingBlock(toolNamer);
 import { writeSessionEventsFile, buildSessionDirective, getSessionEvents, getLatestSessionEvents } from "../session-directive.mjs";
 import {
-  readStdin, getSessionId, getSessionDBPath, getSessionEventsPath, getCleanupFlagPath,
+  readStdin, parseStdin, getSessionId, getSessionDBPath, getSessionEventsPath, getCleanupFlagPath,
   getProjectDir, VSCODE_OPTS,
 } from "../session-helpers.mjs";
 import { join } from "node:path";
@@ -35,7 +35,7 @@ let additionalContext = ROUTING_BLOCK;
 
 try {
   const raw = await readStdin();
-  const input = JSON.parse(raw);
+  const input = parseStdin(raw);
   const source = input.source ?? "startup";
 
   if (source === "compact") {

package/insight/server.mjs

@@ -9,7 +9,7 @@
  */
 
 import { readFileSync, readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
-import { join, dirname, extname } from "node:path";
+import { join, dirname, extname, normalize } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createServer as createHttpServer } from "node:http";
@@ -28,18 +28,28 @@ if (isBun) {
 } else {
   try {
     Database = (await import("better-sqlite3")).default;
-  } catch {
-    console.error("\n  Error: better-sqlite3 not found.");
-    console.error("  Install it: npm install better-sqlite3");
-    console.error("  Or use Bun: bun insight/server.mjs\n");
+    // Verify native addon loads correctly (catches arch mismatch: x86_64 vs arm64)
+    const testDb = new Database(":memory:");
+    testDb.close();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error("\n  Error: better-sqlite3 failed to load.");
+    console.error(`  ${msg}`);
+    if (msg.includes("incompatible architecture") || msg.includes("dlopen")) {
+      const cacheHint = process.env.INSIGHT_SESSION_DIR
+        ? join(dirname(process.env.INSIGHT_SESSION_DIR), "insight-cache", "node_modules")
+        : join("~", ".claude", "context-mode", "insight-cache", "node_modules");
+      console.error(`\n  Fix: rm -rf ${cacheHint} && context-mode insight`);
+    } else {
+      console.error("  Install it: npm install better-sqlite3");
+    }
     process.exit(1);
   }
 }
 
 // ── Paths ────────────────────────────────────────────────
-const BASE = join(homedir(), ".claude", "context-mode");
-const CONTENT_DIR = join(BASE, "content");
-const SESSION_DIR = join(BASE, "sessions");
+const SESSION_DIR = process.env.INSIGHT_SESSION_DIR || join(homedir(), ".claude", "context-mode", "sessions");
+const CONTENT_DIR = process.env.INSIGHT_CONTENT_DIR || join(homedir(), ".claude", "context-mode", "content");
 const DIST_DIR = join(__dirname, "dist");
 
 // ── SQLite helpers ───────────────────────────────────────
@@ -60,6 +70,107 @@ function safeGet(db, sql, params = []) {
   try { return db.prepare(sql).get(...params); } catch { return null; }
 }
 
+function hasColumn(db, table, column) {
+  try {
+    const rows = db.prepare(`PRAGMA table_xinfo(${table})`).all();
+    return rows.some(r => r.name === column);
+  } catch {
+    return false;
+  }
+}
+
+const UNKNOWN_PROJECT_KEY = "__unknown__";
+
+function normalizeFsPath(path) {
+  const norm = normalize(String(path || "")).replace(/\\/g, "/");
+  if (norm.length <= 1) return norm;
+  return norm.replace(/\/+$/, "");
+}
+
+function parseFileSearchPath(data) {
+  const marker = " in ";
+  const idx = String(data || "").lastIndexOf(marker);
+  if (idx < 0) return null;
+  const p = String(data || "").slice(idx + marker.length).trim();
+  return p || null;
+}
+
+function isLikelyPath(value) {
+  const v = String(value || "");
+  return v.includes("/") || v.includes("\\") || v.startsWith(".") || /^[A-Za-z]:[\\/]/.test(v);
+}
+
+function legacyProjectAttribution(db) {
+  const origins = new Map(
+    safeAll(db, "SELECT session_id, project_dir FROM session_meta")
+      .map((r) => [r.session_id, r.project_dir || UNKNOWN_PROJECT_KEY]),
+  );
+
+  const events = safeAll(db, `SELECT id, session_id, type, data FROM session_events ORDER BY id ASC`);
+  const lastProjectBySession = new Map();
+  const projectAgg = new Map();
+  let unknownEvents = 0;
+
+  function addProject(projectDir, sessionId) {
+    const key = projectDir || UNKNOWN_PROJECT_KEY;
+    const existing = projectAgg.get(key) || { project_dir: key, sessionsSet: new Set(), events: 0, compacts: 0, avg_confidence: 0, high_conf_events: 0 };
+    existing.events += 1;
+    existing.sessionsSet.add(sessionId);
+    projectAgg.set(key, existing);
+  }
+
+  for (const ev of events) {
+    const sessionId = ev.session_id;
+    const origin = origins.get(sessionId) || UNKNOWN_PROJECT_KEY;
+    const last = lastProjectBySession.get(sessionId) || "";
+    let projectDir = "";
+
+    if (ev.type === "cwd" && isLikelyPath(ev.data)) {
+      projectDir = normalizeFsPath(ev.data);
+    } else if (ev.type === "file_read" || ev.type === "file_write" || ev.type === "file_edit" || ev.type === "rule") {
+      if (isLikelyPath(ev.data)) {
+        const p = normalizeFsPath(ev.data);
+        if (origin !== UNKNOWN_PROJECT_KEY && (p === origin || p.startsWith(`${origin}/`))) projectDir = origin;
+        else projectDir = p.includes("/") ? p.slice(0, p.lastIndexOf("/")) : p;
+      }
+    } else if (ev.type === "file_search") {
+      const p = parseFileSearchPath(ev.data);
+      if (p && isLikelyPath(p)) {
+        const pp = normalizeFsPath(p);
+        if (origin !== UNKNOWN_PROJECT_KEY && (pp === origin || pp.startsWith(`${origin}/`))) projectDir = origin;
+        else projectDir = pp;
+      }
+    }
+
+    if (!projectDir) {
+      projectDir = last || origin || UNKNOWN_PROJECT_KEY;
+    }
+    if (!projectDir || projectDir === UNKNOWN_PROJECT_KEY) unknownEvents += 1;
+
+    addProject(projectDir, sessionId);
+    if (projectDir && projectDir !== UNKNOWN_PROJECT_KEY) {
+      lastProjectBySession.set(sessionId, projectDir);
+    }
+  }
+
+  const rows = [...projectAgg.values()].map((r) => ({
+    project_dir: r.project_dir,
+    sessions: r.sessionsSet.size,
+    events: r.events,
+    compacts: 0,
+    avg_confidence: 0,
+    high_conf_events: 0,
+  })).sort((a, b) => b.events - a.events);
+
+  return {
+    projectRows: rows,
+    total_events: events.length,
+    unknown_events: unknownEvents,
+    avg_confidence: 0,
+    high_conf_events: 0,
+  };
+}
+
 function listDBFiles(dir) {
   if (!existsSync(dir)) return [];
   return readdirSync(dir)
@@ -103,6 +214,11 @@ function mergeByKey(arr, key, mergeFn) {
   return [...map.values()];
 }
 
+// ── Input validation ────────────────────────────────────
+function isValidHash(hash) {
+  return /^[a-f0-9_]+$/.test(hash);
+}
+
 // ── API Handlers ─────────────────────────────────────────
 
 function apiOverview() {
@@ -347,13 +463,21 @@ function apiAnalytics() {
       GROUP BY se.session_id, se.data HAVING edit_count > 1
       ORDER BY edit_count DESC LIMIT 20`)
   );
-  const gitActivity = queryAllSessionDBs(db =>
-    safeAll(db, `SELECT se.data as action, se.created_at, se.session_id,
-      sm.project_dir, sm.started_at as session_start
+  const gitActivity = queryAllSessionDBs(db => {
+    if (hasColumn(db, "session_events", "project_dir")) {
+      return safeAll(db, `SELECT se.data as action, se.created_at, se.session_id,
+        COALESCE(NULLIF(se.project_dir, ''), sm.project_dir, '${UNKNOWN_PROJECT_KEY}') as project_dir,
+        sm.started_at as session_start
+        FROM session_events se
+        LEFT JOIN session_meta sm ON se.session_id = sm.session_id
+        WHERE se.type = 'git' ORDER BY se.created_at DESC LIMIT 20`);
+    }
+    return safeAll(db, `SELECT se.data as action, se.created_at, se.session_id,
+      COALESCE(sm.project_dir, '${UNKNOWN_PROJECT_KEY}') as project_dir, sm.started_at as session_start
       FROM session_events se
-      JOIN session_meta sm ON se.session_id = sm.session_id
-      WHERE se.type = 'git' ORDER BY se.created_at DESC LIMIT 20`)
-  );
+      LEFT JOIN session_meta sm ON se.session_id = sm.session_id
+      WHERE se.type = 'git' ORDER BY se.created_at DESC LIMIT 20`);
+  });
   const rawSubagents = queryAllSessionDBs(db =>
     safeAll(db, `SELECT data as task, created_at, session_id FROM session_events
       WHERE type = 'subagent' ORDER BY created_at ASC`)
@@ -378,12 +502,34 @@ function apiAnalytics() {
     timeSavedMin: parallelBursts.reduce((a, b) => a + (b.length - 1) * 2, 0),
     burstDetails: parallelBursts.map(b => ({ size: b.length, time: b[0].created_at })),
   };
-  const projectActivity = queryAllSessionDBs(db =>
-    safeAll(db, `SELECT project_dir, COUNT(*) as sessions, SUM(event_count) as events,
-      SUM(compact_count) as compacts
-      FROM session_meta WHERE project_dir IS NOT NULL
-      GROUP BY project_dir ORDER BY events DESC LIMIT 10`)
-  );
+  const projectActivity = queryAllSessionDBs(db => {
+    if (hasColumn(db, "session_events", "project_dir")) {
+      return safeAll(db, `SELECT
+        COALESCE(NULLIF(se.project_dir, ''), '${UNKNOWN_PROJECT_KEY}') as project_dir,
+        COUNT(DISTINCT se.session_id) as sessions,
+        COUNT(*) as events,
+        0 as compacts,
+        AVG(COALESCE(se.attribution_confidence, 0)) as avg_confidence,
+        SUM(CASE WHEN COALESCE(se.attribution_confidence, 0) >= 0.8 THEN 1 ELSE 0 END) as high_conf_events
+        FROM session_events se
+        GROUP BY project_dir
+        ORDER BY events DESC
+        LIMIT 20`);
+    }
+    return legacyProjectAttribution(db).projectRows;
+  });
+
+  const attributionSummary = queryAllSessionDBs(db => {
+    if (hasColumn(db, "session_events", "project_dir")) {
+      return safeAll(db, `SELECT
+        COUNT(*) as total_events,
+        SUM(CASE WHEN COALESCE(project_dir, '') = '' THEN 1 ELSE 0 END) as unknown_events,
+        AVG(COALESCE(attribution_confidence, 0)) as avg_confidence,
+        SUM(CASE WHEN COALESCE(attribution_confidence, 0) >= 0.8 THEN 1 ELSE 0 END) as high_conf_events
+        FROM session_events`);
+    }
+    return [legacyProjectAttribution(db)];
+  });
   const hourlyPattern = queryAllSessionDBs(db =>
     safeAll(db, `SELECT CAST(strftime('%H', created_at) AS INTEGER) as hour, COUNT(*) as count
       FROM session_events WHERE created_at IS NOT NULL
@@ -426,13 +572,22 @@ function apiAnalytics() {
   );
 
   // 2. Personal Commit Rate — commits per session
-  const commitRate = queryAllSessionDBs(db =>
-    safeAll(db, `SELECT sm.session_id, sm.project_dir,
+  const commitRate = queryAllSessionDBs(db => {
+    if (hasColumn(db, "session_events", "project_dir")) {
+      return safeAll(db, `SELECT
+        sm.session_id,
+        COALESCE(NULLIF(MAX(CASE WHEN se.type = 'git' THEN se.project_dir END), ''), sm.project_dir, '${UNKNOWN_PROJECT_KEY}') as project_dir,
+        SUM(CASE WHEN se.type = 'git' AND se.data = 'commit' THEN 1 ELSE 0 END) as commits
+        FROM session_meta sm
+        LEFT JOIN session_events se ON se.session_id = sm.session_id
+        GROUP BY sm.session_id`);
+    }
+    return safeAll(db, `SELECT sm.session_id, COALESCE(sm.project_dir, '${UNKNOWN_PROJECT_KEY}') as project_dir,
       SUM(CASE WHEN se.type = 'git' AND se.data = 'commit' THEN 1 ELSE 0 END) as commits
       FROM session_meta sm
       LEFT JOIN session_events se ON se.session_id = sm.session_id
-      GROUP BY sm.session_id`)
-  );
+      GROUP BY sm.session_id`);
+  });
 
   // 3. Sandbox Adoption — context-mode MCP tool usage vs total
   const sandboxAdoption = queryAllSessionDBs(db =>
@@ -467,6 +622,59 @@ function apiAnalytics() {
     sandbox_calls: (a.sandbox_calls || 0) + (b.sandbox_calls || 0),
     total_calls: (a.total_calls || 0) + (b.total_calls || 0),
   }), { sandbox_calls: 0, total_calls: 0 });
+  const attributionSchemaCoverage = queryAllSessionDBs(db => [{
+    has_attribution_columns: hasColumn(db, "session_events", "project_dir") ? 1 : 0,
+  }]);
+  const fallbackOnly = attributionSchemaCoverage.length > 0
+    && attributionSchemaCoverage.every((r) => !r.has_attribution_columns);
+
+  const mergedProjectActivity = mergeByKey(projectActivity, "project_dir", (a, b) => {
+    const aEvents = Number(a.events || 0);
+    const bEvents = Number(b.events || 0);
+    const aWeighted = Number(
+      (a.weighted_confidence_sum ?? (Number(a.avg_confidence || 0) * aEvents)) || 0,
+    );
+    const bWeighted = Number(
+      (b.weighted_confidence_sum ?? (Number(b.avg_confidence || 0) * bEvents)) || 0,
+    );
+    return {
+      project_dir: a.project_dir,
+      sessions: (a.sessions || 0) + (b.sessions || 0),
+      events: aEvents + bEvents,
+      compacts: (a.compacts || 0) + (b.compacts || 0),
+      weighted_confidence_sum: aWeighted + bWeighted,
+      high_conf_events: (a.high_conf_events || 0) + (b.high_conf_events || 0),
+    };
+  })
+    .map((p) => ({
+      project_dir: p.project_dir,
+      sessions: p.sessions || 0,
+      events: p.events || 0,
+      compacts: p.compacts || 0,
+      avg_confidence: (p.events || 0) > 0 ? (p.weighted_confidence_sum || 0) / p.events : 0,
+      high_conf_events: p.high_conf_events || 0,
+    }))
+    .sort((a, b) => (b.events || 0) - (a.events || 0));
+  const nonUnknownProjects = mergedProjectActivity.filter((p) => p.project_dir !== UNKNOWN_PROJECT_KEY);
+
+  const attributionAgg = attributionSummary.reduce((a, b) => ({
+    total_events: (a.total_events || 0) + (b.total_events || 0),
+    unknown_events: (a.unknown_events || 0) + (b.unknown_events || 0),
+    high_conf_events: (a.high_conf_events || 0) + (b.high_conf_events || 0),
+    // weighted sum for avg_confidence
+    weighted_confidence_sum: (a.weighted_confidence_sum || 0) + ((b.avg_confidence || 0) * (b.total_events || 0)),
+  }), { total_events: 0, unknown_events: 0, high_conf_events: 0, weighted_confidence_sum: 0 });
+
+  const attributedEvents = Math.max(0, attributionAgg.total_events - attributionAgg.unknown_events);
+  const unknownPct = attributionAgg.total_events > 0
+    ? Math.round(1000 * attributionAgg.unknown_events / attributionAgg.total_events) / 10
+    : 100;
+  const avgConfidencePct = attributionAgg.total_events > 0
+    ? Math.round(1000 * attributionAgg.weighted_confidence_sum / attributionAgg.total_events) / 10
+    : 0;
+  const highConfidencePct = attributionAgg.total_events > 0
+    ? Math.round(1000 * attributionAgg.high_conf_events / attributionAgg.total_events) / 10
+    : 0;
 
   return {
     totals: {
@@ -483,7 +691,7 @@ function apiAnalytics() {
       totalTasks: tasks.length, totalPrompts: prompts.length,
       promptsPerSession: sessionDurations.length > 0
         ? Math.round(10 * prompts.length / sessionDurations.length) / 10 : 0,
-      uniqueProjects: projectActivity.length,
+      uniqueProjects: nonUnknownProjects.length,
       totalCommits: commitRate.reduce((a, b) => a + (b.commits || 0), 0),
       commitsPerSession: sessionDurations.length > 0
         ? Math.round(10 * commitRate.reduce((a, b) => a + (b.commits || 0), 0) / sessionDurations.length) / 10 : 0,
@@ -492,6 +700,15 @@ function apiAnalytics() {
       totalRules: rulesFreshness.length,
       totalEditTestCycles: editTestCycles.reduce((a, b) => a + (b.cycles || 0), 0),
     },
+    attribution: {
+      totalEvents: attributionAgg.total_events,
+      attributedEvents,
+      unknownEvents: attributionAgg.unknown_events,
+      unknownPct,
+      avgConfidencePct,
+      highConfidencePct,
+      isFallbackOnly: fallbackOnly,
+    },
     sessionsByDate: mergeByKey(sessionsByDate, "date", (a, b) => ({
       date: a.date, count: a.count + b.count, events: a.events + b.events, compacts: a.compacts + b.compacts
     })),
@@ -503,9 +720,7 @@ function apiAnalytics() {
     timeToFirstCommit,
     exploreExecRatio: exploreExecRatio.reduce((a, b) => ({ explore: (a.explore||0)+(b.explore||0), execute: (a.execute||0)+(b.execute||0), total: (a.total||0)+(b.total||0) }), { explore: 0, execute: 0, total: 0 }),
     reworkData, gitActivity, subagents,
-    projectActivity: mergeByKey(projectActivity, "project_dir", (a, b) => ({
-      project_dir: a.project_dir, sessions: a.sessions + b.sessions, events: a.events + b.events, compacts: (a.compacts||0)+(b.compacts||0)
-    })).sort((a, b) => b.events - a.events),
+    projectActivity: mergedProjectActivity,
     hourlyPattern: mergeByKey(hourlyPattern, "hour", (a, b) => ({ hour: a.hour, count: a.count + b.count })),
     weeklyTrend: mergeByKey(weeklyTrend, "week", (a, b) => ({ week: a.week, sessions: a.sessions + b.sessions, events: a.events + b.events })),
     tasks, prompts,
@@ -530,6 +745,7 @@ function route(method, pathname, params) {
 
   if (pathname.startsWith("/api/content/") && pathname.includes("/chunks/")) {
     const parts = pathname.split("/");
+    if (!isValidHash(parts[3])) return { error: "invalid hash" };
     return apiSourceChunks(parts[3], Number(parts[5]));
   }
   if (pathname === "/api/search") {
@@ -539,10 +755,12 @@ function route(method, pathname, params) {
   }
   if (pathname.startsWith("/api/sessions/") && pathname.includes("/events/")) {
     const parts = pathname.split("/");
+    if (!isValidHash(parts[3])) return { error: "invalid hash" };
     return apiSessionEvents(parts[3], decodeURIComponent(parts[5]));
   }
   if (method === "DELETE" && pathname.startsWith("/api/content/")) {
     const parts = pathname.split("/");
+    if (!isValidHash(parts[3])) return { error: "invalid hash" };
     return apiDeleteSource(parts[3], Number(parts[5]));
   }
   return null;
@@ -568,6 +786,7 @@ function serveStaticFile(pathname) {
 // ── Server (dual runtime) ────────────────────────────────
 
 const indexHTML = readFileSync(join(DIST_DIR, "index.html"), "utf8");
+const API_JSON_HEADERS = { "Content-Type": "application/json" };
 
 if (isBun) {
   // Bun: use Bun.serve
@@ -579,7 +798,7 @@ if (isBun) {
       const data = route(req.method, url.pathname, url.searchParams);
       if (data !== null) {
         return new Response(JSON.stringify(data), {
-          headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+          headers: API_JSON_HEADERS,
         });
       }
       if (url.pathname.startsWith("/assets/") || url.pathname.match(/\.\w{2,4}$/)) {
@@ -595,9 +814,7 @@ if (isBun) {
   // Node: use http.createServer
   const server = createHttpServer((req, res) => {
     const url = new URL(req.url, `http://localhost:${PORT}`);
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, DELETE, OPTIONS");
-    if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }
+    if (req.method === "OPTIONS") { res.writeHead(405); res.end(); return; }
 
     const data = route(req.method, url.pathname, url.searchParams);
     if (data !== null) {
@@ -619,6 +836,19 @@ if (isBun) {
   server.listen(PORT, "127.0.0.1");
 }
 
+// Parent watchdog: exit when the MCP process that spawned us disappears.
+// Fallback for SIGKILL / crash paths where shutdown() cannot run.
+const PARENT_PID = Number(process.env.INSIGHT_PARENT_PID);
+if (Number.isFinite(PARENT_PID) && PARENT_PID > 0) {
+  setInterval(() => {
+    try {
+      process.kill(PARENT_PID, 0);
+    } catch {
+      process.exit(0);
+    }
+  }, 5000).unref();
+}
+
 console.log(`\n  context-mode Insight`);
 console.log(`  http://localhost:${PORT}`);
 console.log(`  Runtime: ${isBun ? "Bun" : "Node.js"}\n`);

package/insight/src/lib/api.ts

@@ -40,7 +40,8 @@ export interface AnalyticsData {
   exploreExecRatio: { explore: number; execute: number; total: number };
   reworkData: { session_id: string; file: string; edit_count: number }[];
   gitActivity: { action: string; created_at: string; session_id: string; project_dir: string; session_start: string }[];
-  projectActivity: { project_dir: string; sessions: number; events: number }[];
+  projectActivity: { project_dir: string; sessions: number; events: number; avg_confidence?: number; high_conf_events?: number }[];
+  attribution?: { totalEvents: number; attributedEvents: number; unknownEvents: number; unknownPct: number; avgConfidencePct: number; highConfidencePct: number; isFallbackOnly: boolean };
   hourlyPattern: { hour: number; count: number }[];
   weeklyTrend: { week: string; sessions: number; events: number }[];
   tasks: { task: string; created_at: string }[];

package/insight/src/routes/index.tsx

@@ -505,18 +505,31 @@ function Dashboard() {
             <div className="grid grid-cols-3 gap-4 mb-4">
               <Mini label="Projects" value={t.uniqueProjects} />
               <Mini label="Top Project" value={topProject?.project_dir?.split("/").pop() || "-"} color="text-emerald-500" />
-              <Mini label="Top Events" value={topProject?.events || 0} />
+              <Mini label="Match Quality" value={data.attribution?.avgConfidencePct != null ? (data.attribution.avgConfidencePct >= 80 ? "Strong" : data.attribution.avgConfidencePct >= 55 ? "Fair" : "Weak") : "-"} color={data.attribution && data.attribution.avgConfidencePct >= 80 ? "text-emerald-500" : data.attribution && data.attribution.avgConfidencePct >= 55 ? "text-amber-500" : "text-red-400"} />
             </div>
+            {data.attribution?.isFallbackOnly && (
+              <div className="mb-3 px-3 py-2 rounded-md bg-muted/50 border border-border text-xs text-muted-foreground flex items-center gap-1.5">
+                <Lightbulb className="h-3 w-3 shrink-0" />
+                Limited tracking detail — project time is estimated from session data
+              </div>
+            )}
             <div className="space-y-2.5 pt-2 border-t border-border">
               {data.projectActivity.slice(0, 6).map((p, i) => {
                 const maxEv = data.projectActivity[0]?.events || 1;
                 const pct = Math.round((p.events / maxEv) * 100);
                 const name = p.project_dir?.split("/").filter(Boolean).slice(-2).join("/") || "Unknown";
+                const conf = p.avg_confidence != null ? Math.round(p.avg_confidence * 100) : null;
+                const qualityLabel = conf != null ? (conf >= 80 ? "Strong" : conf >= 55 ? "Fair" : "Weak") : null;
+                const qualityIcon = conf != null ? (conf >= 80 ? "✓" : conf >= 55 ? "~" : "!") : null;
+                const qualityColor = conf != null ? (conf >= 80 ? "text-emerald-500" : conf >= 55 ? "text-amber-500" : "text-red-400") : "";
                 return (
                   <div key={i}>
                     <div className="flex justify-between text-xs mb-1">
-                      <span className="font-mono truncate max-w-[220px]">{name}</span>
-                      <span className="text-muted-foreground tabular-nums">{p.sessions}s · {p.events}e</span>
+                      <span className="font-mono truncate max-w-[200px]">{name}</span>
+                      <span className="text-muted-foreground tabular-nums">
+                        {p.sessions} sessions · {p.events} events
+                        {qualityLabel != null && <span className={`ml-1.5 text-[11px] font-medium ${qualityColor}`} title={`Match quality: ${conf}%`}>{qualityIcon} {qualityLabel}</span>}
+                      </span>
                     </div>
                     <div className="h-1.5 bg-secondary rounded-full overflow-hidden">
                       <div className="h-full rounded-full transition-all" style={{ width: `${pct}%`, background: COLORS[i % COLORS.length] }} />

package/insight/src/routes/search.tsx

@@ -79,7 +79,7 @@ function SearchPage() {
                       <pre
                         className="text-xs text-muted-foreground whitespace-pre-wrap break-words font-mono leading-relaxed"
                         dangerouslySetInnerHTML={{
-                          __html: (r.highlighted || esc(r.content))
+                          __html: (r.highlighted ? esc(r.highlighted) : esc(r.content))
                             .replace(/«/g, '<mark class="bg-amber-500/20 text-foreground rounded px-0.5">')
                             .replace(/»/g, "</mark>"),
                         }}

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.88",
+  "version": "1.0.90",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.88",
+  "version": "1.0.90",
   "type": "module",
   "description": "MCP plugin that saves 98% of your context window. Works with Claude Code, Gemini CLI, VS Code Copilot, OpenCode, and Codex CLI. Sandboxed code execution, FTS5 knowledge base, and intent-driven search.",
   "author": "Mert Koseoğlu",
@@ -19,13 +19,22 @@
     "sandbox",
     "code-execution",
     "fts5",
-    "bm25"
+    "bm25",
+    "pi-package"
   ],
   "repository": {
     "type": "git",
     "url": "https://github.com/mksglu/context-mode"
   },
   "homepage": "https://github.com/mksglu/context-mode#readme",
+  "pi": {
+    "extensions": [
+      "./build/pi-extension.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
   "openclaw": {
     "extensions": [
       "./build/openclaw-plugin.js"