context-mode 1.0.88 → 1.0.90

package/hooks/gemini-cli/aftertool.mjs

@@ -10,32 +10,34 @@ import "../ensure-deps.mjs";
  * Must be fast (<20ms). No network, no LLM, just SQLite writes.
  */
 
-import { readStdin, getSessionId, getSessionDBPath, getProjectDir, GEMINI_OPTS } from "../session-helpers.mjs";
-import { createSessionLoaders } from "../session-loaders.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, GEMINI_OPTS } from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
 import { appendFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-const { loadSessionDB, loadExtract } = createSessionLoaders(HOOK_DIR);
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
 const OPTS = GEMINI_OPTS;
 const DEBUG_LOG = join(homedir(), ".gemini", "context-mode", "aftertool-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, "AfterTool");
-  }
+  attributeAndInsertEvents(db, sessionId, events, input, projectDir, "AfterTool", resolveProjectAttributions);
 
   appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] OK: ${input.tool_name} → ${events.length} events\n`);
   db.close();

package/hooks/gemini-cli/beforetool.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, GEMINI_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.GEMINI_PROJECT_DIR || process.env.CLAUDE_PROJECT_DIR, "gemini-cli");
+const decision = routePreToolUse(tool, toolInput, process.env.GEMINI_PROJECT_DIR || process.env.CLAUDE_PROJECT_DIR, "gemini-cli", getSessionId(input, GEMINI_OPTS));
 const response = formatDecision("gemini-cli", decision);
 if (response !== null) {
   process.stdout.write(JSON.stringify(response) + "\n");

package/hooks/gemini-cli/precompress.mjs

@@ -9,7 +9,7 @@ import "../ensure-deps.mjs";
  * snapshot (<2KB XML), and stores it for injection after compress.
  */
 
-import { readStdin, getSessionId, getSessionDBPath, GEMINI_OPTS } from "../session-helpers.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, GEMINI_OPTS } from "../session-helpers.mjs";
 import { createSessionLoaders } from "../session-loaders.mjs";
 import { appendFileSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -23,7 +23,7 @@ const DEBUG_LOG = join(homedir(), ".gemini", "context-mode", "precompress-debug.
 
 try {
   const raw = await readStdin();
-  const input = JSON.parse(raw);
+  const input = parseStdin(raw);
 
   const { buildResumeSnapshot } = await loadSnapshot();
   const { SessionDB } = await loadSessionDB();

package/hooks/gemini-cli/sessionstart.mjs

@@ -18,7 +18,7 @@ const toolNamer = createToolNamer("gemini-cli");
 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, GEMINI_OPTS,
 } from "../session-helpers.mjs";
 import { createSessionLoaders } from "../session-loaders.mjs";
@@ -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") {
@@ -118,5 +118,13 @@ try {
   } catch { /* ignore logging failure */ }
 }
 
-const output = `SessionStart:compact hook success: Success\nSessionStart hook additional context: \n${additionalContext}`;
-process.stdout.write(output);
+// Emit structured JSON rather than plain text so Gemini CLI treats the
+// routing block as hook metadata instead of user-visible output (#299).
+// Matches the format already used by Claude Code and VS Code Copilot
+// SessionStart hooks.
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "SessionStart",
+    additionalContext,
+  },
+}));

package/hooks/jetbrains-copilot/posttooluse.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * JetBrains Copilot PostToolUse hook — session event capture.
+ *
+ * Captures session events from tool calls (13 categories) and stores
+ * them in the per-project SessionDB for later resume snapshot building.
+ *
+ * Must be fast (<20ms). No network, no LLM, just SQLite writes.
+ */
+
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, JETBRAINS_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, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = JETBRAINS_OPTS;
+const DEBUG_LOG = join(homedir(), ".config", "JetBrains", "context-mode", "posttooluse-debug.log");
+
+try {
+  const raw = await readStdin();
+  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, projectDir);
+
+  const events = extractEvents({
+    tool_name: input.tool_name,
+    tool_input: input.tool_input ?? {},
+    tool_response: typeof input.tool_response === "string"
+      ? input.tool_response
+      : JSON.stringify(input.tool_response ?? ""),
+    tool_output: input.tool_output,
+  });
+
+  attributeAndInsertEvents(db, sessionId, events, input, projectDir, "PostToolUse", resolveProjectAttributions);
+
+  appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] OK: ${input.tool_name} → ${events.length} events\n`);
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ERR: ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// PostToolUse — no stdout output

package/hooks/jetbrains-copilot/precompact.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * JetBrains Copilot PreCompact hook — snapshot generation.
+ *
+ * Triggered when JetBrains Copilot is about to compact the conversation.
+ * Reads all captured session events, builds a priority-sorted resume
+ * snapshot (<2KB XML), and stores it for injection after compact.
+ */
+
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, JETBRAINS_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, loadSnapshot } = createSessionLoaders(HOOK_DIR);
+const OPTS = JETBRAINS_OPTS;
+const DEBUG_LOG = join(homedir(), ".config", "JetBrains", "context-mode", "precompact-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+
+  const { buildResumeSnapshot } = await loadSnapshot();
+  const { SessionDB } = await loadSessionDB();
+
+  const dbPath = getSessionDBPath(OPTS);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  const events = db.getEvents(sessionId);
+
+  if (events.length > 0) {
+    const stats = db.getSessionStats(sessionId);
+    const snapshot = buildResumeSnapshot(events, {
+      compactCount: (stats?.compact_count ?? 0) + 1,
+    });
+
+    db.upsertResume(sessionId, snapshot, events.length);
+    db.incrementCompactCount(sessionId);
+  }
+
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// PreCompact — no stdout output needed

package/hooks/jetbrains-copilot/pretooluse.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+/**
+ * JetBrains Copilot PreToolUse hook for context-mode
+ * Thin wrapper — uses shared routing core, no self-heal, no Claude Code-specific logic.
+ */
+
+import { dirname, resolve } from "node:path";
+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, JETBRAINS_OPTS } from "../session-helpers.mjs";
+
+const __hookDir = dirname(fileURLToPath(import.meta.url));
+await initSecurity(resolve(__hookDir, "..", "..", "build"));
+
+const raw = await readStdin();
+const input = parseStdin(raw);
+const tool = input.tool_name ?? "";
+const toolInput = input.tool_input ?? {};
+
+const decision = routePreToolUse(tool, toolInput, process.env.IDEA_INITIAL_DIRECTORY || process.env.CLAUDE_PROJECT_DIR, "jetbrains-copilot", getSessionId(input, JETBRAINS_OPTS));
+const response = formatDecision("jetbrains-copilot", decision);
+if (response !== null) {
+  process.stdout.write(JSON.stringify(response) + "\n");
+}

package/hooks/jetbrains-copilot/sessionstart.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * JetBrains Copilot SessionStart hook for context-mode
+ *
+ * Session lifecycle management:
+ * - "startup"  → Cleanup old sessions, capture instruction file rules
+ * - "compact"  → Write events file, inject session knowledge directive
+ * - "resume"   → Load previous session events, inject directive
+ * - "clear"    → No action needed
+ */
+
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { createRoutingBlock } from "../routing-block.mjs";
+import { createToolNamer } from "../core/tool-naming.mjs";
+
+const toolNamer = createToolNamer("jetbrains-copilot");
+const ROUTING_BLOCK = createRoutingBlock(toolNamer);
+import { writeSessionEventsFile, buildSessionDirective, getSessionEvents, getLatestSessionEvents } from "../session-directive.mjs";
+import {
+  readStdin, parseStdin, getSessionId, getSessionDBPath, getSessionEventsPath, getCleanupFlagPath,
+  getProjectDir, JETBRAINS_OPTS,
+} from "../session-helpers.mjs";
+import { join } from "node:path";
+import { readFileSync, unlinkSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { homedir } from "node:os";
+
+const HOOK_DIR = fileURLToPath(new URL(".", import.meta.url));
+const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+const OPTS = JETBRAINS_OPTS;
+
+let additionalContext = ROUTING_BLOCK;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const source = input.source ?? "startup";
+
+  if (source === "compact") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+    const resume = db.getResume(sessionId);
+
+    if (resume && !resume.consumed) {
+      db.markResumeConsumed(sessionId);
+    }
+
+    const events = getSessionEvents(db, sessionId);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS));
+      additionalContext += buildSessionDirective("compact", eventMeta, toolNamer);
+    }
+
+    db.close();
+  } else if (source === "resume") {
+    try { unlinkSync(getCleanupFlagPath(OPTS)); } catch { /* no flag */ }
+
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+
+    const events = getLatestSessionEvents(db);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS));
+      additionalContext += buildSessionDirective("resume", eventMeta, toolNamer);
+    }
+
+    db.close();
+  } else if (source === "startup") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    try { unlinkSync(getSessionEventsPath(OPTS)); } catch { /* no stale file */ }
+
+    db.cleanupOldSessions(7);
+    db.db.exec(`DELETE FROM session_events WHERE session_id NOT IN (SELECT session_id FROM session_meta)`);
+
+    const sessionId = getSessionId(input, OPTS);
+    const projectDir = getProjectDir(OPTS);
+    db.ensureSession(sessionId, projectDir);
+
+    const ruleFilePaths = [
+      join(projectDir, ".github", "copilot-instructions.md"),
+    ];
+    for (const p of ruleFilePaths) {
+      try {
+        const content = readFileSync(p, "utf-8");
+        if (content.trim()) {
+          db.insertEvent(sessionId, { type: "rule", category: "rule", data: p, priority: 1 });
+          db.insertEvent(sessionId, { type: "rule_content", category: "rule", data: content, priority: 1 });
+        }
+      } catch { /* file doesn't exist — skip */ }
+    }
+
+    db.close();
+  }
+  // "clear" — no action needed
+} catch (err) {
+  try {
+    const { appendFileSync } = await import("node:fs");
+    const { join: pjoin } = await import("node:path");
+    const { homedir: hd } = await import("node:os");
+    appendFileSync(
+      pjoin(hd(), ".config", "JetBrains", "context-mode", "sessionstart-debug.log"),
+      `[${new Date().toISOString()}] ${err?.message || err}\n${err?.stack || ""}\n`,
+    );
+  } catch { /* ignore logging failure */ }
+}
+
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "SessionStart",
+    additionalContext,
+  },
+}));

package/hooks/kiro/posttooluse.mjs

@@ -8,20 +8,21 @@ import "../ensure-deps.mjs";
  * Source: https://kiro.dev/docs/cli/hooks/
  */
 
-import { readStdin, getSessionId, getSessionDBPath, getInputProjectDir, KIRO_OPTS } from "../session-helpers.mjs";
-import { createSessionLoaders } from "../session-loaders.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, KIRO_OPTS } from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-const { loadSessionDB, loadExtract } = createSessionLoaders(HOOK_DIR);
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
 const OPTS = KIRO_OPTS;
 
 try {
   const raw = await readStdin();
-  const input = JSON.parse(raw);
+  const input = parseStdin(raw);
 
   const { extractEvents } = await loadExtract();
+  const { resolveProjectAttributions } = await loadProjectAttribution();
   const { SessionDB } = await loadSessionDB();
 
   const dbPath = getSessionDBPath(OPTS);
@@ -40,9 +41,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);
 
   db.close();
 } catch {

package/hooks/kiro/pretooluse.mjs

@@ -13,18 +13,19 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { readStdin } from "../core/stdin.mjs";
 import { routePreToolUse, initSecurity } from "../core/routing.mjs";
+import { parseStdin, getSessionId, KIRO_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);
 // Kiro stdin: { hook_event_name, cwd, tool_name, tool_input }
 const tool = input.tool_name ?? "";
 const toolInput = input.tool_input ?? {};
 const projectDir = input.cwd ?? process.cwd();
 
-const decision = routePreToolUse(tool, toolInput, projectDir, "kiro");
+const decision = routePreToolUse(tool, toolInput, projectDir, "kiro", getSessionId(input, KIRO_OPTS));
 
 if (!decision) process.exit(0);
 

package/hooks/posttooluse.mjs

@@ -10,21 +10,23 @@ import "./ensure-deps.mjs";
  * Must be fast (<20ms). No network, no LLM, just SQLite writes.
  */
 
-import { readStdin, getSessionId, getSessionDBPath } from "./session-helpers.mjs";
-import { createSessionLoaders } from "./session-loaders.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir } from "./session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "./session-loaders.mjs";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // Resolve absolute path for imports — relative dynamic imports can fail
 // when Claude Code invokes hooks from a different working directory.
 const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-const { loadSessionDB, loadExtract } = createSessionLoaders(HOOK_DIR);
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
 
 try {
   const raw = await readStdin();
-  const input = JSON.parse(raw);
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input);
 
   const { extractEvents } = await loadExtract();
+  const { resolveProjectAttributions } = await loadProjectAttribution();
   const { SessionDB } = await loadSessionDB();
 
   const dbPath = getSessionDBPath();
@@ -32,7 +34,7 @@ try {
   const sessionId = getSessionId(input);
 
   // Ensure session meta exists
-  db.ensureSession(sessionId, process.env.CLAUDE_PROJECT_DIR || process.cwd());
+  db.ensureSession(sessionId, projectDir);
 
   // Extract and store events
   const events = extractEvents({
@@ -44,9 +46,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);
 
   db.close();
 } catch {

package/hooks/precompact.mjs

@@ -9,21 +9,20 @@ import "./ensure-deps.mjs";
  * snapshot (<2KB XML), and stores it for injection after compact.
  */
 
-import { readStdin, getSessionId, getSessionDBPath } from "./session-helpers.mjs";
+import { readStdin, parseStdin, getSessionId, getSessionDBPath, resolveConfigDir } from "./session-helpers.mjs";
 import { createSessionLoaders } from "./session-loaders.mjs";
 import { appendFileSync } from "node:fs";
 import { join, dirname } from "node:path";
-import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 // Resolve absolute path for imports
 const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
 const { loadSessionDB, loadSnapshot } = createSessionLoaders(HOOK_DIR);
-const DEBUG_LOG = join(homedir(), ".claude", "context-mode", "precompact-debug.log");
+const DEBUG_LOG = join(resolveConfigDir(), "context-mode", "precompact-debug.log");
 
 try {
   const raw = await readStdin();
-  const input = JSON.parse(raw);
+  const input = parseStdin(raw);
 
   const { buildResumeSnapshot } = await loadSnapshot();
   const { SessionDB } = await loadSessionDB();

package/hooks/pretooluse.mjs

@@ -18,6 +18,7 @@ import { homedir, tmpdir } from "node:os";
 import { readStdin } from "./core/stdin.mjs";
 import { routePreToolUse, initSecurity } from "./core/routing.mjs";
 import { formatDecision } from "./core/formatters.mjs";
+import { parseStdin, getSessionId, resolveConfigDir } from "./session-helpers.mjs";
 
 // ─── Manual recursive copy (avoids cpSync libuv crash on non-ASCII paths, Windows + Node 24) ───
 function copyDirSync(src, dest) {
@@ -73,7 +74,7 @@ try {
 
     // 2. Update installed_plugins.json → point to correct version dir
     //    Skip if not present (e.g. CI / non-Claude-Code environments)
-    const ipPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+    const ipPath = resolve(resolveConfigDir(), "plugins", "installed_plugins.json");
     if (existsSync(ipPath)) {
       const ip = JSON.parse(readFileSync(ipPath, "utf-8"));
       for (const [key, entries] of Object.entries(ip.plugins || {})) {
@@ -90,30 +91,52 @@ try {
     // 3. Update hook paths + matcher in settings.json for ALL hook types (#187)
     //    Previously only fixed PreToolUse — SessionStart, PostToolUse, PreCompact,
     //    UserPromptSubmit paths remained stale after marketplace auto-update.
-    const settingsPath = resolve(homedir(), ".claude", "settings.json");
+    const settingsPath = resolve(resolveConfigDir(), "settings.json");
     try {
       const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
       const allHooks = settings.hooks || {};
       let changed = false;
 
-      for (const hookType of Object.keys(allHooks)) {
-        const entries = allHooks[hookType];
-        if (!Array.isArray(entries)) continue;
-
-        for (const entry of entries) {
-          // Fix deprecated Task-only matcher (PreToolUse only)
-          if (hookType === "PreToolUse" && entry.matcher?.includes("Task") && !entry.matcher.includes("Agent")) {
-            entry.matcher = entry.matcher.replace("Task", "Agent|Task");
+      // If hooks.json is present, the plugin system owns hook registration.
+      // Remove any settings.json context-mode entries to prevent duplicate concurrent
+      // hook processes that cause "non-blocking hook error" on every tool call.
+      const hooksJsonPath = resolve(myRoot, "hooks", "hooks.json");
+      if (existsSync(hooksJsonPath)) {
+        for (const hookType of Object.keys(allHooks)) {
+          const entries = allHooks[hookType];
+          if (!Array.isArray(entries)) continue;
+          const filtered = entries.filter(
+            (entry) =>
+              !entry.hooks?.some(
+                (h) => h.command?.includes(".mjs") && h.command?.includes("context-mode"),
+              ),
+          );
+          if (filtered.length !== entries.length) {
+            allHooks[hookType] = filtered;
             changed = true;
           }
-          // Rewrite stale context-mode hook paths to point to current version
-          for (const h of (entry.hooks || [])) {
-            if (h.command && h.command.includes(".mjs") && h.command.includes("context-mode") && !h.command.includes(targetDir)) {
-              // Extract the script filename (e.g., sessionstart.mjs, pretooluse.mjs)
-              const scriptMatch = h.command.match(/([a-z]+\.mjs)\s*"?\s*$/);
-              if (scriptMatch) {
-                h.command = "node " + resolve(targetDir, "hooks", scriptMatch[1]);
-                changed = true;
+        }
+      } else {
+        // Legacy: hooks.json absent — rewrite stale paths to current version dir.
+        for (const hookType of Object.keys(allHooks)) {
+          const entries = allHooks[hookType];
+          if (!Array.isArray(entries)) continue;
+
+          for (const entry of entries) {
+            // Fix deprecated Task-only matcher (PreToolUse only)
+            if (hookType === "PreToolUse" && entry.matcher?.includes("Task") && !entry.matcher.includes("Agent")) {
+              entry.matcher = entry.matcher.replace("Task", "Agent|Task");
+              changed = true;
+            }
+            // Rewrite stale context-mode hook paths to point to current version
+            for (const h of (entry.hooks || [])) {
+              if (h.command && h.command.includes(".mjs") && h.command.includes("context-mode") && !h.command.includes(targetDir)) {
+                // Extract the script filename (e.g., sessionstart.mjs, pretooluse.mjs)
+                const scriptMatch = h.command.match(/([a-z]+\.mjs)\s*"?\s*$/);
+                if (scriptMatch) {
+                  h.command = "node " + resolve(targetDir, "hooks", scriptMatch[1]);
+                  changed = true;
+                }
               }
             }
           }
@@ -136,12 +159,12 @@ await initSecurity(resolve(__hookDir, "..", "build"));
 
 // ─── Read stdin ───
 const raw = await readStdin();
-const input = JSON.parse(raw);
+const input = parseStdin(raw);
 const tool = input.tool_name ?? "";
 const toolInput = input.tool_input ?? {};
 
 // ─── Route and format response ───
-const decision = routePreToolUse(tool, toolInput, process.env.CLAUDE_PROJECT_DIR, "claude-code");
+const decision = routePreToolUse(tool, toolInput, process.env.CLAUDE_PROJECT_DIR, "claude-code", getSessionId(input));
 const response = formatDecision("claude-code", decision);
 if (response !== null) {
   process.stdout.write(JSON.stringify(response) + "\n");