@minhpnq1807/contextos 0.5.41 → 0.5.44

package/plugins/ctx/lib/analyzer.js

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import path from "node:path";
 import { findGraphRelevantFiles, mergeRelevantFiles } from "./graph-retriever.js";
 import { expandImportGraph } from "./import-graph.js";
@@ -15,10 +14,6 @@ const IMPORTANT_WORDS = [
   "luon", "khong bao gio", "bat buoc", "quan trong"
 ];
 
-const IGNORE_DIRS = new Set([
-  ".git", ".next", ".turbo", "coverage", "dist", "build", "node_modules", "vendor"
-]);
-
 const SEMANTIC_ALIASES = {
   duyet: ["moderation", "moderate", "review", "approve", "approval", "approved", "reject", "rejected"],
   kiem: ["check", "verify", "validation", "validate"],
@@ -49,8 +44,6 @@ const SEMANTIC_ALIASES = {
   recheck: ["check", "verify", "review"]
 };
 
-const MODERATION_TOKENS = new Set(["moderation", "moderate", "content-moderation", "approval", "approved", "reject", "rejected", "needs_review"]);
-
 const SYSTEM_USER_RULE_PATTERNS = [
   /\ball\s+shell\s+commands?\s+must\s+run\s+as\b/i,
   /\bcommands?\s+must\s+run\s+as\b/i,
@@ -287,45 +280,23 @@ export async function findRelevantFiles({
   fileEmbeddingTimeoutMs,
   fileEmbeddingOptions = {}
 } = {}) {
-  const rawTaskTokens = new Set(tokenize(task));
-  if (!rawTaskTokens.size) return [];
-
-  const candidates = [];
-  walkFiles(cwd, (filePath) => {
-    const rel = path.relative(cwd, filePath);
-    const fileTokens = new Set(tokenize(rel));
-    const match = scoreFileTokens({ rawTaskTokens, fileTokens });
-    if (match.score > 0) {
-      candidates.push({
-        path: rel,
-        score: match.score,
-        reasons: match.reasons
-      });
-    }
-  });
+  if (!String(task || "").trim()) return [];
 
-  const heuristicFiles = candidates
-    .sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
-    .slice(0, Math.max(limit * 2, 6));
-  const hasHighConfidenceHeuristics =
-    heuristicFiles.length >= limit &&
-    Number(heuristicFiles[0]?.score || 0) >= 8;
-  const embeddingFiles = hasHighConfidenceHeuristics
-    ? []
-    : await embeddingFileFinder({
-      cwd,
-      task,
-      dataDir,
-      timeoutMs: fileEmbeddingTimeoutMs,
-      embeddingOptions: fileEmbeddingOptions,
-      limit: Math.max(limit * 2, 6)
-    });
+  const embeddingFiles = await embeddingFileFinder({
+    cwd,
+    task,
+    dataDir,
+    timeoutMs: fileEmbeddingTimeoutMs,
+    embeddingOptions: fileEmbeddingOptions,
+    limit: Math.max(limit * 2, 6)
+  });
   const importGraphFiles = expandImportGraph({
     cwd,
-    seedFiles: mergeLocalFileCandidates([...heuristicFiles, ...embeddingFiles]).slice(0, limit),
+    seedFiles: embeddingFiles.slice(0, limit),
+    dataDir,
     limit: Math.max(limit * 2, 6)
   });
-  const seedFiles = mergeLocalFileCandidates([...heuristicFiles, ...embeddingFiles, ...importGraphFiles])
+  const seedFiles = mergeLocalFileCandidates([...embeddingFiles, ...importGraphFiles])
     .slice(0, Math.max(limit * 3, 9));
 
   const graphFiles = findGraphRelevantFiles({
@@ -353,56 +324,3 @@ function mergeLocalFileCandidates(files) {
   }
   return [...byPath.values()].sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
 }
-
-function scoreFileTokens({ rawTaskTokens, fileTokens }) {
-  let score = 0;
-  const reasons = new Set();
-  const hasModerationIntent = rawTaskTokens.has("kiem-duyet") || rawTaskTokens.has("kiemduyet") || rawTaskTokens.has("duyet");
-  const hasUploadIntent = rawTaskTokens.has("upload") || rawTaskTokens.has("tai-len") || rawTaskTokens.has("tailen");
-
-  for (const token of rawTaskTokens) {
-    if (fileTokens.has(token)) {
-      score += 3;
-      reasons.add(token);
-    }
-    for (const alias of SEMANTIC_ALIASES[token] || []) {
-      if (fileTokens.has(alias)) {
-        score += 2;
-        reasons.add(`${token}->${alias}`);
-      }
-    }
-  }
-
-  if (hasModerationIntent && [...fileTokens].some((token) => MODERATION_TOKENS.has(token))) {
-    score += 6;
-    reasons.add("domain:moderation");
-  }
-
-  if (hasUploadIntent && (fileTokens.has("upload") || fileTokens.has("uploaded") || fileTokens.has("resource"))) {
-    score += 2;
-    reasons.add("domain:upload");
-  }
-
-  return { score, reasons: [...reasons] };
-}
-
-function walkFiles(directory, onFile, depth = 0) {
-  if (depth > 6) return;
-  let entries = [];
-  try {
-    entries = fs.readdirSync(directory, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") && entry.name !== ".github") {
-      if (entry.name !== ".codex") continue;
-    }
-    const fullPath = path.join(directory, entry.name);
-    if (entry.isDirectory()) {
-      if (!IGNORE_DIRS.has(entry.name)) walkFiles(fullPath, onFile, depth + 1);
-    } else if (entry.isFile()) {
-      onFile(fullPath);
-    }
-  }
-}

package/plugins/ctx/lib/auto-warm.js

@@ -0,0 +1,74 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000;
+
+export function maybeAutoWarmWorkspace({
+  cwd = process.cwd(),
+  prompt = "",
+  dataDir,
+  reason,
+  now = Date.now(),
+  spawnProcess = spawn,
+  cooldownMs = Number(process.env.CONTEXTOS_AUTO_WARM_COOLDOWN_MS || DEFAULT_COOLDOWN_MS)
+} = {}) {
+  if (process.env.CONTEXTOS_AUTO_WARM === "0") return { status: "disabled" };
+  if (!dataDir) return { status: "skipped", reason: "missing-data-dir" };
+  if (!String(prompt || "").trim()) return { status: "skipped", reason: "missing-prompt" };
+  if (!shouldAutoWarm(reason)) return { status: "skipped", reason: "not-actionable" };
+
+  const markerPath = path.join(dataDir, "auto-warm.json");
+  const existing = readJson(markerPath);
+  if (existing?.startedAt) {
+    const ageMs = now - Date.parse(existing.startedAt);
+    if (Number.isFinite(ageMs) && ageMs >= 0 && ageMs < cooldownMs) {
+      return { status: "cooldown", markerPath, ageMs };
+    }
+  }
+
+  try {
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.writeFileSync(markerPath, `${JSON.stringify({
+      startedAt: new Date(now).toISOString(),
+      cwd,
+      reason,
+      prompt: String(prompt).slice(0, 300)
+    }, null, 2)}\n`, "utf8");
+  } catch {
+    return { status: "skipped", reason: "marker-write-failed" };
+  }
+
+  const child = spawnProcess(process.execPath, [ctxBinPath(), "autowarm", "--", prompt], {
+    cwd,
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      CONTEXTOS_AUTO_WARM_CHILD: "1"
+    }
+  });
+  child.on?.("error", () => {});
+  child.unref?.();
+  return { status: "started", pid: child.pid, markerPath };
+}
+
+function shouldAutoWarm(reason) {
+  if (reason === "no-context-candidates") return true;
+  if (reason === "enabled-sections-empty-after-formatting") return true;
+  return false;
+}
+
+function ctxBinPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "../../../bin/ctx.js");
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}

package/plugins/ctx/lib/ctx-mcp-client.js

@@ -4,50 +4,99 @@ import path from "node:path";
 
 import { defaultDataRoot } from "./workspace-data.js";
 
-const DEFAULT_TIMEOUT_MS = 1000;
+const DEFAULT_TIMEOUT_MS = 2000;
+const DEFAULT_CONNECT_TIMEOUT_MS = 100;
+export const CTX_MCP_BRIDGE_REVISION = 2;
 
 export function ctxMcpSocketPath(dataDir = defaultDataDir()) {
   return path.join(dataDir, "ctx-mcp.sock");
 }
 
+export function invalidateCtxMcpSocket(dataDir = defaultDataDir()) {
+  const socketPath = ctxMcpSocketPath(dataDir);
+  if (!fs.existsSync(socketPath)) return false;
+  try {
+    fs.rmSync(socketPath, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export async function callCtxScoreContext(payload, {
   dataDir = defaultDataDir(),
-  timeoutMs = Number(process.env.CONTEXTOS_MCP_BRIDGE_TIMEOUT_MS || DEFAULT_TIMEOUT_MS)
+  timeoutMs = Number(process.env.CONTEXTOS_MCP_BRIDGE_TIMEOUT_MS || DEFAULT_TIMEOUT_MS),
+  connectTimeoutMs = Number(process.env.CONTEXTOS_MCP_CONNECT_TIMEOUT_MS || DEFAULT_CONNECT_TIMEOUT_MS),
+  createConnection = net.createConnection
 } = {}) {
   const socketPath = ctxMcpSocketPath(dataDir);
   if (!fs.existsSync(socketPath)) {
     throw new Error(`ctx-mcp bridge socket not found: ${socketPath}`);
   }
+  const socketIdentity = statIdentity(socketPath);
 
   return new Promise((resolve, reject) => {
-    const client = net.createConnection(socketPath);
+    const client = createConnection(socketPath);
     let raw = "";
-    const timer = setTimeout(() => {
+    let responseTimer;
+    const connectTimer = setTimeout(() => {
       client.destroy();
-      reject(new Error(`ctx-mcp bridge timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
+      reject(new Error(`ctx-mcp bridge connect timed out after ${connectTimeoutMs}ms`));
+    }, connectTimeoutMs);
 
     client.on("connect", () => {
+      clearTimeout(connectTimer);
+      responseTimer = setTimeout(() => {
+        client.destroy();
+        reject(new Error(`ctx-mcp bridge timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
       client.write(`${JSON.stringify(payload)}\n`);
     });
     client.on("data", (chunk) => {
       raw += chunk.toString("utf8");
     });
     client.on("end", () => {
-      clearTimeout(timer);
+      clearTimeout(connectTimer);
+      clearTimeout(responseTimer);
       try {
-        resolve(JSON.parse(raw || "{}"));
+        const response = JSON.parse(raw || "{}");
+        if (response.bridgeRevision !== CTX_MCP_BRIDGE_REVISION) {
+          invalidateSocketIfUnchanged(socketPath, socketIdentity);
+          reject(new Error(`ctx-mcp bridge revision mismatch: expected ${CTX_MCP_BRIDGE_REVISION}, received ${response.bridgeRevision || "missing"}`));
+          return;
+        }
+        resolve(response);
       } catch (error) {
         reject(error);
       }
     });
     client.on("error", (error) => {
-      clearTimeout(timer);
+      clearTimeout(connectTimer);
+      clearTimeout(responseTimer);
       reject(error);
     });
   });
 }
 
+function invalidateSocketIfUnchanged(socketPath, expectedIdentity) {
+  if (!expectedIdentity || statIdentity(socketPath) !== expectedIdentity) return false;
+  try {
+    fs.rmSync(socketPath, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function statIdentity(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    return `${stat.dev}:${stat.ino}`;
+  } catch {
+    return null;
+  }
+}
+
 function defaultDataDir() {
   return defaultDataRoot();
 }

package/plugins/ctx/lib/embedding-scorer.js

@@ -74,6 +74,54 @@ export async function warmRuleEmbeddings({
   return { count: texts.length, cachePath: cache.path };
 }
 
+export async function searchIndexedEmbeddings({
+  kind,
+  task = "",
+  dataDir = defaultDataRoot(),
+  timeoutMs = Number(process.env.CONTEXTOS_EMBEDDING_TIMEOUT_MS || DEFAULT_TIMEOUT_MS),
+  allowRemote = process.env.CONTEXTOS_EMBEDDING_ALLOW_REMOTE === "1",
+  enabled = process.env.CONTEXTOS_EMBEDDINGS !== "0"
+} = {}) {
+  if (!enabled || !kind || !String(task || "").trim()) return { items: [], status: "disabled" };
+  const cachePath = path.join(dataDir, "embeddings.db");
+  if (!allowRemote && !fs.existsSync(cachePath)) return { items: [], status: "cold-cache", cachePath };
+
+  try {
+    return await withTimeout(searchIndexed({ kind, task, dataDir, allowRemote }), timeoutMs);
+  } catch (error) {
+    return { items: [], status: "fallback", error: error?.message || String(error) };
+  }
+}
+
+export async function warmIndexedEmbeddings({
+  kind,
+  items = [],
+  task = "",
+  dataDir = defaultDataRoot(),
+  sources = [],
+  allowRemote = true
+} = {}) {
+  if (!kind || !items.length) return { count: 0, cachePath: path.join(dataDir, "embeddings.db") };
+  if (!allowRemote && !isModelCacheReady(dataDir)) {
+    return { count: 0, cachePath: path.join(dataDir, "embeddings.db"), status: "missing-model" };
+  }
+
+  const cache = await openEmbeddingCache(dataDir);
+  const embedder = await getExtractor({ allowRemote, dataDir });
+  if (String(task || "").trim()) await getCachedEmbedding({ cache, embedder, text: task, sources });
+
+  const indexed = [];
+  for (const item of items) {
+    const text = String(item.text || "");
+    if (!item.id || !text.trim()) continue;
+    const vector = await getCachedEmbedding({ cache, embedder, text, sources });
+    indexed.push({ id: item.id, text, vector });
+  }
+  cache.replaceIndex(kind, indexed);
+  cache.close();
+  return { count: indexed.length, cachePath: cache.path };
+}
+
 async function enhanceRuleScores(rules, task, { dataDir, sources, allowRemote }) {
   const cache = await openEmbeddingCache(dataDir);
   const embedder = await getExtractor({ allowRemote, dataDir });
@@ -113,6 +161,20 @@ async function enhanceRuleScores(rules, task, { dataDir, sources, allowRemote })
   };
 }
 
+async function searchIndexed({ kind, task, dataDir, allowRemote }) {
+  const cache = await openEmbeddingCache(dataDir);
+  const embedder = await getExtractor({ allowRemote, dataDir });
+  const taskEmbedding = await getCachedEmbedding({ cache, embedder, text: task, sources: [] });
+  const items = cache.listIndexed(kind)
+    .map((item) => ({
+      ...item,
+      embeddingScore: Number(similarityToScore(cosine(taskEmbedding, item.vector)).toFixed(3))
+    }))
+    .sort((a, b) => b.embeddingScore - a.embeddingScore || a.id.localeCompare(b.id));
+  cache.close();
+  return { items, status: "enabled", model: DEFAULT_MODEL, cachePath: cache.path };
+}
+
 async function getExtractor({ allowRemote, dataDir }) {
   const cacheDir = modelCacheDir(dataDir);
   const key = `${allowRemote ? "remote" : "local"}:${cacheDir}`;
@@ -183,6 +245,30 @@ export async function openEmbeddingCache(dataDir) {
       );
       writeDatabaseAtomically(cachePath, db);
     },
+    listIndexed(kind) {
+      const stmt = db.prepare("SELECT id, text, vector FROM embedding_index WHERE kind = ? AND model = ?");
+      const items = [];
+      try {
+        stmt.bind([kind, DEFAULT_MODEL]);
+        while (stmt.step()) {
+          const row = stmt.getAsObject();
+          items.push({ id: row.id, text: row.text, vector: JSON.parse(row.vector) });
+        }
+      } finally {
+        stmt.free();
+      }
+      return items;
+    },
+    replaceIndex(kind, items) {
+      db.run("DELETE FROM embedding_index WHERE kind = ? AND model = ?", [kind, DEFAULT_MODEL]);
+      for (const item of items) {
+        db.run(
+          "INSERT INTO embedding_index (kind, id, text, model, vector, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+          [kind, item.id, item.text, DEFAULT_MODEL, JSON.stringify(item.vector), new Date().toISOString()]
+        );
+      }
+      writeDatabaseAtomically(cachePath, db);
+    },
     close() {
       writeDatabaseAtomically(cachePath, db);
       db.close();
@@ -218,6 +304,17 @@ function ensureEmbeddingSchema(db) {
       updated_at TEXT NOT NULL
     )
   `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS embedding_index (
+      kind TEXT NOT NULL,
+      id TEXT NOT NULL,
+      text TEXT NOT NULL,
+      model TEXT NOT NULL,
+      vector TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (kind, id, model)
+    )
+  `);
 }
 
 function openSqlDatabase(SQL, cachePath) {
@@ -316,11 +413,16 @@ function similarityToScore(similarity) {
   return Math.max(0, Math.min(1, (similarity + 1) / 2));
 }
 
-function withTimeout(promise, timeoutMs) {
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => {
-      setTimeout(() => reject(new Error(`embedding scorer timed out after ${timeoutMs}ms`)), timeoutMs);
-    })
-  ]);
+async function withTimeout(promise, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`embedding scorer timed out after ${timeoutMs}ms`)), timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
 }

package/plugins/ctx/lib/file-embedding-retriever.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { enhanceRuleScoresWithEmbeddings, isModelCacheReady, warmRuleEmbeddings } from "./embedding-scorer.js";
+import { isModelCacheReady, searchIndexedEmbeddings, warmIndexedEmbeddings } from "./embedding-scorer.js";
+import { rebuildImportGraphIndex } from "./import-graph.js";
 
 const SOURCE_EXTENSIONS = new Set([
   ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".sql", ".md", ".json"
@@ -8,7 +9,7 @@ const SOURCE_EXTENSIONS = new Set([
 const IGNORE_DIRS = new Set([
   ".git", ".next", ".turbo", "coverage", "dist", "build", "node_modules", "vendor"
 ]);
-const DEFAULT_TIMEOUT_MS = 80;
+const DEFAULT_TIMEOUT_MS = 1000;
 const DEFAULT_MAX_FILES = 1200;
 
 export async function findEmbeddingRelevantFiles({
@@ -18,27 +19,17 @@ export async function findEmbeddingRelevantFiles({
   limit = 10,
   timeoutMs = Number(process.env.CONTEXTOS_FILE_EMBEDDING_TIMEOUT_MS || DEFAULT_TIMEOUT_MS),
   maxFiles = Number(process.env.CONTEXTOS_FILE_EMBEDDING_MAX_FILES || DEFAULT_MAX_FILES),
-  embeddingOptions = {}
+  embeddingOptions = {},
+  indexedSearcher = searchIndexedEmbeddings
 } = {}) {
   if (process.env.CONTEXTOS_FILE_EMBEDDINGS === "0") return [];
   if (!dataDir) return [];
   if (!String(task || "").trim()) return [];
 
-  const files = listSourceFiles(cwd, { maxFiles });
-  if (!files.length) return [];
-
-  const fileRules = files.map((filePath, index) => ({
-    id: `f${index + 1}`,
-    content: fileSearchText(filePath),
-    path: filePath,
-    score: 0,
-    reasons: [],
-    originalOrder: index
-  }));
-
-  const result = await enhanceRuleScoresWithEmbeddings(fileRules, task, {
+  const result = await indexedSearcher({
+    kind: fileIndexKind(cwd),
+    task,
     dataDir,
-    sources: [path.join(cwd, "AGENTS.md")],
     timeoutMs,
     allowRemote: false,
     ...embeddingOptions
@@ -46,12 +37,12 @@ export async function findEmbeddingRelevantFiles({
 
   if (result.status !== "enabled") return [];
 
-  return result.rules
+  return result.items
     .filter((rule) => Number(rule.embeddingScore || 0) >= 0.45)
-    .sort((a, b) => Number(b.embeddingScore || 0) - Number(a.embeddingScore || 0) || a.path.localeCompare(b.path))
+    .sort((a, b) => Number(b.embeddingScore || 0) - Number(a.embeddingScore || 0) || a.id.localeCompare(b.id))
     .slice(0, limit)
     .map((rule) => ({
-      path: rule.path,
+      path: rule.id,
       score: Math.round(Number(rule.embeddingScore || 0) * 10),
       source: "embedding",
       reasons: [`file-embedding:${Number(rule.embeddingScore || 0).toFixed(2)}`]
@@ -67,9 +58,11 @@ export async function warmFileEmbeddings({
   if (!dataDir) return { count: 0, cachePath: null };
   if (!allowRemote && !isModelCacheReady(dataDir)) return { count: 0, cachePath: null, status: "missing-model" };
   const files = listSourceFiles(cwd, { maxFiles });
-  const rules = files.map((filePath) => ({ content: fileSearchText(filePath) }));
-  return warmRuleEmbeddings({
-    rules,
+  rebuildImportGraphIndex({ cwd, files, dataDir });
+  const items = files.map((filePath) => ({ id: filePath, text: fileSearchText(filePath) }));
+  return warmIndexedEmbeddings({
+    kind: fileIndexKind(cwd),
+    items,
     task: "project file semantic retrieval",
     dataDir,
     sources: [path.join(cwd, "AGENTS.md")],
@@ -77,6 +70,10 @@ export async function warmFileEmbeddings({
   });
 }
 
+function fileIndexKind(cwd) {
+  return `file:${path.resolve(cwd)}`;
+}
+
 function listSourceFiles(cwd, { maxFiles }) {
   const files = [];
   walkFiles(cwd, (filePath) => {

package/plugins/ctx/lib/global-hooks.js

@@ -4,6 +4,8 @@ import path from "node:path";
 const CONTEXTOS_COMMAND_MARKER = "/contextos/plugins/ctx/bin/on-";
 const QUIET_CODE_REVIEW_GRAPH_STATUS_COMMAND =
   "git rev-parse --git-dir >/dev/null 2>&1 && code-review-graph status >/dev/null 2>&1 || true";
+const DRAINED_CODE_REVIEW_GRAPH_UPDATE_COMMAND =
+  "cat >/dev/null; git rev-parse --git-dir >/dev/null 2>&1 && code-review-graph update --skip-flows || true";
 
 function shellQuote(value) {
   const s = String(value);
@@ -52,6 +54,23 @@ function quietCodeReviewGraphSessionStart(entries = []) {
   }));
 }
 
+function drainCodeReviewGraphPostToolUse(entries = []) {
+  return entries.map((entry) => ({
+    ...entry,
+    hooks: (entry.hooks || []).map((hook) => {
+      if (typeof hook.command === "string" && hook.command.includes("code-review-graph update --skip-flows")) {
+        return {
+          ...hook,
+          command: hook.command.includes("cat >/dev/null")
+            ? hook.command
+            : DRAINED_CODE_REVIEW_GRAPH_UPDATE_COMMAND
+        };
+      }
+      return hook;
+    })
+  }));
+}
+
 function commandFor(marketplaceRoot, scriptName, { injectPromptContext = true } = {}) {
   const envPrefix = scriptName === "on-prompt.js" && !injectPromptContext ? "CONTEXTOS_INJECT=0 " : "";
   return `${envPrefix}node ${shellQuote(path.join(marketplaceRoot, "plugins", "ctx", "bin", scriptName))}`;
@@ -105,6 +124,7 @@ export function buildGlobalHooksConfig(existingConfig, { marketplaceRoot, inject
   }
 
   config.hooks.SessionStart = quietCodeReviewGraphSessionStart(config.hooks.SessionStart);
+  config.hooks.PostToolUse = drainCodeReviewGraphPostToolUse(config.hooks.PostToolUse);
 
   return config;
 }