caveat-cli 0.6.2 → 0.10.0

package/dist/index.js

@@ -9761,49 +9761,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base2, relative3, options2, skipNormalization) {
+    function resolveComponent(base2, relative2, options2, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base2 = parse4(serialize(base2, options2), options2);
-        relative3 = parse4(serialize(relative3, options2), options2);
+        relative2 = parse4(serialize(relative2, options2), options2);
       }
       options2 = options2 || {};
-      if (!options2.tolerant && relative3.scheme) {
-        target.scheme = relative3.scheme;
-        target.userinfo = relative3.userinfo;
-        target.host = relative3.host;
-        target.port = relative3.port;
-        target.path = removeDotSegments(relative3.path || "");
-        target.query = relative3.query;
+      if (!options2.tolerant && relative2.scheme) {
+        target.scheme = relative2.scheme;
+        target.userinfo = relative2.userinfo;
+        target.host = relative2.host;
+        target.port = relative2.port;
+        target.path = removeDotSegments(relative2.path || "");
+        target.query = relative2.query;
       } else {
-        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
-          target.userinfo = relative3.userinfo;
-          target.host = relative3.host;
-          target.port = relative3.port;
-          target.path = removeDotSegments(relative3.path || "");
-          target.query = relative3.query;
+        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
+          target.userinfo = relative2.userinfo;
+          target.host = relative2.host;
+          target.port = relative2.port;
+          target.path = removeDotSegments(relative2.path || "");
+          target.query = relative2.query;
         } else {
-          if (!relative3.path) {
+          if (!relative2.path) {
             target.path = base2.path;
-            if (relative3.query !== void 0) {
-              target.query = relative3.query;
+            if (relative2.query !== void 0) {
+              target.query = relative2.query;
             } else {
               target.query = base2.query;
             }
           } else {
-            if (relative3.path[0] === "/") {
-              target.path = removeDotSegments(relative3.path);
+            if (relative2.path[0] === "/") {
+              target.path = removeDotSegments(relative2.path);
             } else {
               if ((base2.userinfo !== void 0 || base2.host !== void 0 || base2.port !== void 0) && !base2.path) {
-                target.path = "/" + relative3.path;
+                target.path = "/" + relative2.path;
               } else if (!base2.path) {
-                target.path = relative3.path;
+                target.path = relative2.path;
               } else {
-                target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative3.path;
+                target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative2.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative3.query;
+            target.query = relative2.query;
           }
           target.userinfo = base2.userinfo;
           target.host = base2.host;
@@ -9811,7 +9811,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base2.scheme;
       }
-      target.fragment = relative3.fragment;
+      target.fragment = relative2.fragment;
       return target;
     }
     function equal(uriA, uriB, options2) {
@@ -12976,7 +12976,7 @@ import { Command } from "commander";
 
 // src/context.ts
 import { homedir } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join8 } from "node:path";
 
 // ../../packages/core/dist/db.js
 import { DatabaseSync } from "node:sqlite";
@@ -15819,7 +15819,14 @@ function search(db, opts = {}) {
     conditions.push(`e.confidence IN (${placeholders})`);
     params.push(...filters.confidence);
   }
+  if (filters.visibility === "public" || filters.visibility === "private") {
+    conditions.push(`e.visibility = ?`);
+    params.push(filters.visibility);
+  }
   if (conditions.length) sql += " AND " + conditions.join(" AND ");
+  if (!ftsQuery) {
+    sql += ` ORDER BY json_extract(e.frontmatter_json, '$.updated_at') DESC`;
+  }
   sql += " LIMIT ?";
   params.push(limit);
   const rows = db.prepare(sql).all(...params);
@@ -15864,6 +15871,7 @@ function toSearchResult(row) {
     title: row.title,
     symptomExcerpt: symptom.slice(0, SYMPTOM_EXCERPT_LENGTH),
     confidence: row.confidence,
+    visibility: row.visibility ?? "public",
     environment: fm.environment ?? {}
   };
 }
@@ -16105,12 +16113,10 @@ function resolvePaths(caveatHome, knowledgeRepo, userHome) {
 
 // ../../packages/core/dist/config.js
 import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-var SHARED_REPO_URL = "https://github.com/kitepon-rgb/Caveat";
 var DEFAULT_CONFIG = {
   knowledgeRepo: "own",
   semverKeys: ["driver", "cuda", "node"],
-  communitySources: [],
-  sharedRepo: SHARED_REPO_URL
+  communitySources: []
 };
 function loadConfig(userConfigPath) {
   const userCfg = existsSync5(userConfigPath) ? JSON.parse(readFileSync4(userConfigPath, "utf-8")) : {};
@@ -16134,7 +16140,7 @@ function deepMerge(base2, overlay) {
 }
 
 // ../../packages/core/dist/community.js
-import { existsSync as existsSync6, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3, rmSync, statSync as statSync4 } from "node:fs";
 import { join as join6 } from "node:path";
 
 // ../../node_modules/.pnpm/simple-git@3.36.0/node_modules/simple-git/dist/esm/index.js
@@ -21164,304 +21170,367 @@ function communityList(opts) {
   }
   return out;
 }
-
-// ../../packages/core/dist/claudeHooks.js
-var CAVEAT_TRIGGERS = [
-  /\b(gpu|cuda|nvidia|amd|rtx|nvenc|nvdec|blackwell|ada|ampere)\b/i,
-  /\bdriver\b/i,
-  /ドライバ/,
-  /\b(vscode|vs\s?code|jetbrains|intellij|pycharm)\b/i,
-  /\bclaude\s?code\b/i,
-  /\b(flaky|intermittent|reproducib|reproduce|repro)\b/i,
-  /再現(しない|性|できない)/,
-  /挙動が(違|おかしい|変)/,
-  /\b(node|python|cuda|cudnn)\s*\d+(\.\d+)?/i,
-  /バージョン(依存|違い|差)/,
-  /\b(prebuild|native\s+module|msvc|gyp)\b/i
-];
-function detectCaveatTrigger(prompt) {
-  if (typeof prompt !== "string" || prompt.length === 0) return false;
-  return CAVEAT_TRIGGERS.some((re) => re.test(prompt));
-}
-function userPromptSubmitReminderText() {
-  return [
-    "[caveat] \u3053\u306E\u30D7\u30ED\u30F3\u30D7\u30C8\u306F\u5916\u90E8\u4ED5\u69D8\u306E\u7F60\uFF08GPU/\u30C9\u30E9\u30A4\u30D0/\u30C4\u30FC\u30EB\u30D0\u30FC\u30B8\u30E7\u30F3/IDE/\u518D\u73FE\u6027\u306E\u4F4E\u3044\u6319\u52D5\uFF09\u306B\u89E6\u308C\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002",
-    "\u5B9F\u88C5\u3092\u59CB\u3081\u308B\u524D\u306B mcp__caveat__caveat_search \u3092\u547C\u3093\u3067\u65E2\u5B58\u306E\u7F60\u30E1\u30E2\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
-    "3 \u6587\u5B57\u4EE5\u4E0A\u306E\u30AF\u30A8\u30EA\u3067\u691C\u7D22\u3001\u65E5\u672C\u8A9E\u306F trigram \u4E00\u81F4\u3002\u8A72\u5F53\u306A\u3057\u306A\u3089\u7D9A\u884C\u3001\u8A72\u5F53\u3042\u308C\u3070 environment \u4E00\u81F4\u3092\u898B\u3066\u9069\u7528\u5224\u65AD\u3092\u3002"
-  ].join("\n");
-}
-function stopReminderText() {
-  return [
-    "[caveat] \u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u5916\u90E8\u4ED5\u69D8\u306E\u7F60\uFF08GPU/\u30C9\u30E9\u30A4\u30D0/\u30C4\u30FC\u30EB\u30D0\u30FC\u30B8\u30E7\u30F3/IDE/\u518D\u73FE\u6027\uFF09\u3092\u8E0F\u307F\u3001\u6B21\u56DE\u306E\u81EA\u5206\u306E\u8ABF\u67FB\u304C\u77ED\u7E2E\u3067\u304D\u305D\u3046\u306A\u3089 mcp__caveat__caveat_record \u3067\u767B\u9332\u3092\u691C\u8A0E\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
-    "\u89E3\u6C7A\u3057\u305F\u30B1\u30FC\u30B9\u3060\u3051\u3067\u306A\u304F\u3001\u300C\u73FE\u72B6\u306E\u5236\u7D04\u3067\u306F\u4E0D\u53EF\u80FD\u3068\u5224\u5B9A\u3057\u305F\u300D\u7D50\u8AD6\u3082 outcome: impossible \u3068\u3057\u3066\u8A18\u9332\u5BFE\u8C61\u3002\u6B21\u56DE\u540C\u3058 3 \u6642\u9593\u3092\u6EB6\u304B\u3055\u306A\u3044\u305F\u3081\u306B\u3002",
-    "\u65E2\u306B\u540C\u7B49\u306E caveat \u304C\u3042\u308B\u5834\u5408\u306F caveat_update \u3067\u4E0A\u66F8\u304D\u3001\u307E\u305F\u306F last_verified \u3060\u3051\u66F4\u65B0\u3002",
-    "\u8A18\u9332\u3057\u305F\u7F60\u304C\u4ED6\u306E\u30E6\u30FC\u30B6\u306B\u3082\u518D\u5229\u7528\u4FA1\u5024\u304C\u3042\u308B\u306A\u3089 mcp__caveat__caveat_push \u3067\u5171\u6709 DB \u306B PR \u3092\u6295\u3052\u308B\u3053\u3068\u3082\u691C\u8A0E\uFF08\u500B\u4EBA\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u56FA\u6709\u306E\u7269\u306F push \u3057\u306A\u3044\uFF09\u3002"
-  ].join("\n");
-}
-
-// ../../packages/core/dist/push.js
-import { spawnSync } from "node:child_process";
-import {
-  copyFileSync,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync5
-} from "node:fs";
-import { dirname as dirname4, join as join7, relative as relative2 } from "node:path";
-async function pushEntry(opts) {
-  if (!checkGhAvailable()) {
-    return {
-      status: "gh-missing",
-      detail: "gh (GitHub CLI) is required. Install: https://cli.github.com/"
-    };
-  }
-  if (!checkGhAuthed()) {
-    return {
-      status: "gh-unauthed",
-      detail: "gh is not authenticated. Run `gh auth login`."
-    };
-  }
-  const validation = validateCommunityUrl(opts.sharedRepoUrl);
-  if (!validation.valid) {
-    return { status: "failed", detail: `sharedRepo URL invalid: ${validation.reason}` };
-  }
-  const [sharedOwner, sharedName] = parseOwnerRepo(opts.sharedRepoUrl);
-  if (!sharedOwner || !sharedName) {
-    return { status: "failed", detail: `cannot parse owner/repo from ${opts.sharedRepoUrl}` };
-  }
-  const owned = findOwnedEntry(opts.entriesDir, opts.id);
-  if (!owned) {
-    return {
-      status: "not-found",
-      detail: `entry id=${opts.id} not found under ${opts.entriesDir}`
-    };
-  }
-  if (owned.visibility === "private") {
-    return {
-      status: "visibility-private",
-      detail: `entry id=${opts.id} has visibility: private and cannot be pushed to the public community DB. Update the entry to visibility: public first (the user declared this entry local-only).`
-    };
+function communityRemove(opts) {
+  const handle = (opts.handle ?? "").trim();
+  if (!handle) {
+    throw new Error("handle is required");
   }
-  const ghUser = resolveGhUser();
-  if (!ghUser) {
-    return { status: "failed", detail: "gh api user failed" };
+  if (handle === "." || handle === ".." || /[\\/]/.test(handle)) {
+    throw new Error(`invalid handle (no path separators or relative segments): ${opts.handle}`);
   }
+  const target = join6(opts.communityDir, handle);
+  const dirExisted = existsSync6(target) && statSync4(target).isDirectory();
+  const source = `community/${handle}`;
+  const row = opts.db.prepare("SELECT COUNT(*) AS n FROM entries WHERE source = ?").get(source);
+  const rowCount = row?.n ?? 0;
   if (opts.dryRun) {
-    return {
-      status: "dry-run",
-      plannedSteps: [
-        `fork ${sharedOwner}/${sharedName} as ${ghUser}/${sharedName}`,
-        `clone fork \u2192 ${forkStagingDir(opts.caveatHome)}`,
-        `copy entry \u2192 entries/${owned.relPath}`,
-        "commit, push branch, open PR against main"
-      ]
-    };
+    return { handle, path: target, dirExisted, rowCount, removed: false, dryRun: true };
   }
-  try {
-    ensureFork(sharedOwner, sharedName);
-    const stagingDir = forkStagingDir(opts.caveatHome);
-    ensureStagingClone(stagingDir, ghUser, sharedName, sharedOwner);
-    const branch = `caveat-push-${owned.id}-${Date.now().toString(36)}`;
-    runOrThrow("git", ["checkout", "-b", branch], { cwd: stagingDir });
-    const destPath = join7(stagingDir, "entries", owned.relPath);
-    mkdirSync3(dirname4(destPath), { recursive: true });
-    copyFileSync(owned.absPath, destPath);
-    runOrThrow("git", ["add", join7("entries", owned.relPath)], { cwd: stagingDir });
-    const isUpdate = upstreamAlreadyHas(stagingDir, "entries/" + owned.relPath);
-    const verb = isUpdate ? "update" : "add";
-    const commitMsg = `${verb}: ${owned.title}`;
-    runOrThrow("git", ["commit", "-m", commitMsg], { cwd: stagingDir });
-    runOrThrow("git", ["push", "--set-upstream", "origin", branch], { cwd: stagingDir });
-    const prTitle = `${verb}: ${owned.title}`;
-    const prBody = [
-      `Contribution of caveat \`${owned.id}\` via \`caveat push\`.`,
-      "",
-      `- entry path: \`entries/${owned.relPath}\``,
-      `- action: ${verb}`,
-      "",
-      "Merged PRs will appear in subscribers' repos on their next `caveat pull`."
-    ].join("\n");
-    const pr = runCapture(
-      "gh",
-      [
-        "pr",
-        "create",
-        "--repo",
-        `${sharedOwner}/${sharedName}`,
-        "--base",
-        "main",
-        "--head",
-        `${ghUser}:${branch}`,
-        "--title",
-        prTitle,
-        "--body",
-        prBody
-      ],
-      { cwd: stagingDir }
-    );
-    if (pr.status !== 0) {
-      return {
-        status: "failed",
-        detail: (pr.stderr || "gh pr create failed").trim()
-      };
-    }
-    return { status: "ok", prUrl: pr.stdout.trim() };
-  } catch (err) {
-    return {
-      status: "failed",
-      detail: err instanceof Error ? err.message : String(err)
-    };
+  if (dirExisted) {
+    rmSync(target, { recursive: true, force: true });
   }
+  if (rowCount > 0) {
+    opts.db.prepare("DELETE FROM entries WHERE source = ?").run(source);
+  }
+  return {
+    handle,
+    path: target,
+    dirExisted,
+    rowCount,
+    removed: dirExisted || rowCount > 0,
+    dryRun: false
+  };
 }
-function shellQuote(s) {
-  if (!/[\s&|<>^()"`$!*?\[\]{}\\]/.test(s)) return s;
-  return `"${s.replace(/"/g, '""')}"`;
-}
-function runCapture(command, args, opts = {}) {
-  const line = [command, ...args].map(shellQuote).join(" ");
-  const r2 = spawnSync(line, {
-    encoding: "utf-8",
-    cwd: opts.cwd,
-    shell: true
-  });
+
+// ../../packages/core/dist/claudeHooks.js
+var PROMPT_TOKEN_MIN_LENGTH = 3;
+var PROMPT_MAX_CANDIDATE_TOKENS = 50;
+var DEFAULT_REMINDER_HIT_LIMIT = 5;
+var SYMPTOM_EXCERPT_LENGTH2 = 200;
+var SYMPTOM_LINE_MAX = 120;
+var MIN_DISTINCT_TOKEN_MATCHES_CEILING = 2;
+var CJK_CHAR = /[぀-ゟ゠-ヿ一-鿿ｦ-ﾟ]/;
+function isCjkDominated(token) {
+  return CJK_CHAR.test(token);
+}
+function expandToken(token, out) {
+  if (isCjkDominated(token)) {
+    if (token.length < PROMPT_TOKEN_MIN_LENGTH) return;
+    for (let i2 = 0; i2 <= token.length - PROMPT_TOKEN_MIN_LENGTH; i2++) {
+      out.push(token.slice(i2, i2 + PROMPT_TOKEN_MIN_LENGTH));
+    }
+  } else if (token.length >= PROMPT_TOKEN_MIN_LENGTH) {
+    out.push(token);
+  }
+}
+function extractPromptCandidates(prompt) {
+  if (typeof prompt !== "string" || prompt.length === 0) return [];
+  const cleaned = prompt.replace(/[^\p{L}\p{N}\s]/gu, " ");
+  const rawTokens = cleaned.split(/\s+/).filter((t2) => t2.length > 0);
+  const expanded = [];
+  for (const t2 of rawTokens) expandToken(t2, expanded);
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const t2 of expanded) {
+    const key = t2.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(t2);
+  }
+  return unique.slice(0, PROMPT_MAX_CANDIDATE_TOKENS);
+}
+function toSearchResult2(row) {
+  const fm = JSON.parse(row.frontmatter_json);
+  const symptomMatch = /##\s+Symptom\s*\n([\s\S]*?)(?=\n##|\n*$)/.exec(row.body);
+  const symptom = symptomMatch?.[1]?.trim() ?? row.body;
   return {
-    status: r2.status,
-    stdout: typeof r2.stdout === "string" ? r2.stdout : "",
-    stderr: typeof r2.stderr === "string" ? r2.stderr : ""
+    id: row.id,
+    source: row.source,
+    title: row.title,
+    symptomExcerpt: symptom.slice(0, SYMPTOM_EXCERPT_LENGTH2),
+    confidence: row.confidence,
+    visibility: row.visibility ?? "public",
+    environment: fm.environment ?? {}
   };
 }
-function runOrThrow(command, args, opts = {}) {
-  const r2 = runCapture(command, args, opts);
-  if (r2.status !== 0) {
-    throw new Error(
-      `${command} ${args.join(" ")} failed: ${(r2.stderr || r2.stdout || "unknown").trim()}`
-    );
+function findCaveatsForPrompt(db, prompt, opts = {}) {
+  const tokens = extractPromptCandidates(prompt);
+  if (tokens.length === 0) return [];
+  const minMatches = Math.min(MIN_DISTINCT_TOKEN_MATCHES_CEILING, tokens.length);
+  const perEntry = /* @__PURE__ */ new Map();
+  const stmt = db.prepare(
+    "SELECT e.* FROM entries_fts f JOIN entries e ON e.rowid = f.rowid WHERE entries_fts MATCH ?"
+  );
+  for (const tok of tokens) {
+    let rows = [];
+    try {
+      rows = stmt.all(`"${tok}"`);
+    } catch {
+      continue;
+    }
+    for (const row of rows) {
+      const existing = perEntry.get(row.rowid);
+      if (existing) existing.count += 1;
+      else perEntry.set(row.rowid, { count: 1, row });
+    }
   }
+  const limit = opts.limit ?? DEFAULT_REMINDER_HIT_LIMIT;
+  return [...perEntry.values()].filter(({ count }) => count >= minMatches).sort((a, b2) => b2.count - a.count).slice(0, limit).map(({ row }) => toSearchResult2(row));
 }
-function checkGhAvailable() {
-  return runCapture("gh", ["--version"]).status === 0;
-}
-function checkGhAuthed() {
-  return runCapture("gh", ["auth", "status"]).status === 0;
+function toolErrorReminderText(hits) {
+  const lines = [];
+  lines.push(
+    `[caveat] \u76F4\u524D\u306E\u30A8\u30E9\u30FC\u306B\u4E00\u81F4\u3059\u308B\u53EF\u80FD\u6027\u306E\u3042\u308B\u65E2\u77E5\u306E\u7F60\u304C ${hits.length} \u4EF6\u3042\u308A\u307E\u3059:`
+  );
+  lines.push("");
+  hits.forEach((h2, i2) => {
+    lines.push(`${i2 + 1}. ${h2.id} (${h2.source}) \u2014 ${h2.title}`);
+    const excerpt = h2.symptomExcerpt.replace(/\s+/g, " ").trim().slice(0, SYMPTOM_LINE_MAX);
+    if (excerpt) lines.push(`   \u75C7\u72B6: ${excerpt}`);
+  });
+  lines.push("");
+  lines.push(
+    "mcp__caveat__caveat_get \u3067\u8A73\u7D30\u3092\u78BA\u8A8D\u3057\u3001documented \u306A\u5BFE\u51E6\u304C\u3042\u308C\u3070\u9069\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u7121\u95A2\u4FC2\u3068\u5224\u65AD\u3057\u305F\u3089\u7121\u8996\u3057\u3066\u7D9A\u884C\u3067 OK\u3002"
+  );
+  return lines.join("\n");
 }
-function resolveGhUser() {
-  const r2 = runCapture("gh", ["api", "user", "--jq", ".login"]);
-  if (r2.status !== 0) return void 0;
-  return r2.stdout.trim() || void 0;
+function userPromptSubmitReminderText(hits) {
+  const lines = [];
+  lines.push(
+    `[caveat] \u3053\u306E\u30D7\u30ED\u30F3\u30D7\u30C8\u306B\u95A2\u9023\u3059\u308B\u53EF\u80FD\u6027\u306E\u3042\u308B\u65E2\u77E5\u306E\u7F60\u304C ${hits.length} \u4EF6\u3042\u308A\u307E\u3059:`
+  );
+  lines.push("");
+  hits.forEach((h2, i2) => {
+    lines.push(`${i2 + 1}. ${h2.id} (${h2.source}) \u2014 ${h2.title}`);
+    const excerpt = h2.symptomExcerpt.replace(/\s+/g, " ").trim().slice(0, SYMPTOM_LINE_MAX);
+    if (excerpt) lines.push(`   \u75C7\u72B6: ${excerpt}`);
+  });
+  lines.push("");
+  lines.push(
+    "\u8A73\u7D30\u306F mcp__caveat__caveat_get \u306B id + source \u3092\u6E21\u3057\u3066\u53D6\u5F97\u3002environment \u304C\u4E00\u81F4\u3059\u308B\u304B\u78BA\u8A8D\u3057\u3066\u304B\u3089\u9069\u7528\u5224\u65AD\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u7121\u95A2\u4FC2\u3068\u5224\u65AD\u3057\u305F\u3089\u7121\u8996\u3057\u3066\u7D9A\u884C\u3067 OK\u3002"
+  );
+  return lines.join("\n");
 }
-function parseOwnerRepo(url) {
-  const m = /^https:\/\/github\.com\/([^/]+)\/([^/]+?)(\.git)?\/?$/.exec(url);
-  if (!m) return [void 0, void 0];
-  return [m[1], m[2]];
+function shortPath(p2) {
+  const parts = p2.split(/[\\/]/);
+  return parts[parts.length - 1] ?? p2;
 }
-function findOwnedEntry(entriesDir, id) {
-  if (!existsSync7(entriesDir)) return void 0;
-  for (const categoryDirent of readdirSync4(entriesDir, { withFileTypes: true })) {
-    if (!categoryDirent.isDirectory()) continue;
-    const categoryDir = join7(entriesDir, categoryDirent.name);
-    for (const fileDirent of readdirSync4(categoryDir, { withFileTypes: true })) {
-      if (!fileDirent.isFile() || !fileDirent.name.endsWith(".md")) continue;
-      const absPath = join7(categoryDir, fileDirent.name);
-      const raw2 = readFileSync5(absPath, "utf-8");
-      try {
-        const parsed = parseMarkdown(raw2);
-        if (parsed.frontmatter.id === id) {
-          const relPath = relative2(entriesDir, absPath).replace(/\\/g, "/");
-          return {
-            id,
-            title: parsed.frontmatter.title,
-            absPath,
-            relPath,
-            visibility: parsed.frontmatter.visibility
-          };
-        }
-      } catch {
-      }
-    }
+function stopReminderText(signals, related) {
+  const lines = [];
+  lines.push("[caveat] \u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u5916\u90E8\u4ED5\u69D8\u306E\u7F60\u306B\u5F53\u305F\u3063\u305F\u53EF\u80FD\u6027\u3092\u793A\u3059\u30B7\u30B0\u30CA\u30EB:");
+  if (signals.toolFailureCount > 0) {
+    lines.push(`- tool failure: ${signals.toolFailureCount} \u4EF6`);
   }
-  return void 0;
-}
-function forkStagingDir(caveatHome) {
-  return join7(caveatHome, "push-fork");
-}
-function ensureFork(owner, repo) {
-  runCapture("gh", ["repo", "fork", `${owner}/${repo}`, "--clone=false", "--remote=false"]);
-}
-function ensureStagingClone(stagingDir, ghUser, sharedName, upstreamOwner) {
-  if (!existsSync7(stagingDir)) {
-    mkdirSync3(dirname4(stagingDir), { recursive: true });
-    const forkUrl = `https://github.com/${ghUser}/${sharedName}.git`;
-    runOrThrow("git", ["clone", "--depth", "30", forkUrl, stagingDir]);
-    runOrThrow(
-      "git",
-      ["remote", "add", "upstream", `https://github.com/${upstreamOwner}/${sharedName}.git`],
-      { cwd: stagingDir }
+  if (signals.fileEditCounts.length > 0) {
+    const top = signals.fileEditCounts.slice(0, 3).map((e) => `${shortPath(e.path)} \xD7 ${e.count}`).join(", ");
+    lines.push(`- \u540C\u4E00\u30D5\u30A1\u30A4\u30EB\u8907\u6570\u7DE8\u96C6: ${top}`);
+  }
+  if (signals.webSearchCount > 0) {
+    const sample = signals.searchQueries[0];
+    const note = sample ? ` (\u4F8B: "${sample.slice(0, 60)}")` : "";
+    lines.push(`- WebSearch: ${signals.webSearchCount} \u56DE${note}`);
+  }
+  if (signals.webFetchCount > 0) {
+    lines.push(`- WebFetch: ${signals.webFetchCount} \u56DE`);
+  }
+  if (signals.bashRetryCount > 0) {
+    lines.push(`- \u540C\u4E00 Bash \u30B3\u30DE\u30F3\u30C9\u306E\u518D\u5B9F\u884C: ${signals.bashRetryCount} \u7A2E`);
+  }
+  if (signals.durationMinutes > 0) {
+    lines.push(`- \u7D4C\u904E\u6642\u9593: ${signals.durationMinutes} \u5206`);
+  }
+  lines.push("");
+  if (related.length > 0) {
+    lines.push(
+      `\u30BB\u30C3\u30B7\u30E7\u30F3\u5185\u5BB9\u3068\u5171\u8D77\u3059\u308B\u65E2\u5B58\u7F60 ${related.length} \u4EF6\uFF08\u95A2\u9023\u304C\u3042\u308C\u3070 mcp__caveat__caveat_update \u3067 last_verified \u3092\u66F4\u65B0 or \u8FFD\u8A18\uFF09:`
+    );
+    related.forEach((h2, i2) => {
+      lines.push(`${i2 + 1}. ${h2.id} (${h2.source}) \u2014 ${h2.title}`);
+    });
+    lines.push("");
+    lines.push(
+      "\u4E0A\u8A18\u3068\u7570\u306A\u308B\u65B0\u898F\u306E\u7F60\u3092\u8E0F\u3093\u3067\u3044\u305F\u3089 mcp__caveat__caveat_record \u3067\u767B\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002outcome: impossible\uFF08\u73FE\u72B6\u306E\u5236\u7D04\u3067\u306F\u4E0D\u53EF\u80FD\u3068\u5224\u5B9A\u3057\u305F\u7D50\u8AD6\uFF09\u3082\u8A18\u9332\u5BFE\u8C61\u3002"
     );
   } else {
-    runOrThrow("git", ["checkout", "main"], { cwd: stagingDir });
-    runOrThrow("git", ["fetch", "upstream", "main"], { cwd: stagingDir });
-    runOrThrow("git", ["reset", "--hard", "upstream/main"], { cwd: stagingDir });
-    runOrThrow("git", ["push", "origin", "main", "--force-with-lease"], { cwd: stagingDir });
+    lines.push(
+      "\u65E2\u5B58\u7F60\u306B\u8A72\u5F53\u306A\u3057\u3002\u5916\u90E8\u4ED5\u69D8\u306E\u7F60\u306B\u82E6\u6226\u3057\u3066\u3044\u305F\u306A\u3089 mcp__caveat__caveat_record \u3067\u767B\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002outcome: impossible \u3082\u8A18\u9332\u5BFE\u8C61\u3002"
+    );
   }
-}
-function upstreamAlreadyHas(stagingDir, relFromRoot) {
-  return existsSync7(join7(stagingDir, relFromRoot));
+  return lines.join("\n");
 }
 
-// ../../packages/core/dist/pullShared.js
-import { existsSync as existsSync8, readdirSync as readdirSync5 } from "node:fs";
-import { join as join8 } from "node:path";
-async function pullShared(opts) {
-  const result = { pulled: [], indexed: [] };
-  if (!existsSync8(opts.communityDir)) {
-    return result;
+// ../../packages/core/dist/transcriptSignals.js
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+var MAX_ERROR_SNIPPETS = 10;
+var MAX_ERROR_SNIPPET_LENGTH = 300;
+var MAX_SEARCH_QUERIES = 10;
+var MAX_SEARCH_QUERY_LENGTH = 200;
+var MAX_FILE_EDIT_ENTRIES = 20;
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function extractResultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const c3 of content) {
+      if (isRecord(c3) && typeof c3.text === "string") parts.push(c3.text);
+    }
+    return parts.join(" ");
   }
-  const pulls = await communityPull({
-    communityDir: opts.communityDir,
-    logger: opts.logger
-  });
-  for (const p2 of pulls) {
-    result.pulled.push({
-      handle: p2.handle,
-      status: p2.status,
-      message: p2.message
-    });
+  return "";
+}
+function parseTimestamp(raw2) {
+  if (typeof raw2 !== "string") return void 0;
+  const ms = Date.parse(raw2);
+  return Number.isNaN(ms) ? void 0 : ms;
+}
+function readSessionSignals(transcriptPath) {
+  if (!transcriptPath || !existsSync7(transcriptPath)) return null;
+  let raw2;
+  try {
+    raw2 = readFileSync5(transcriptPath, "utf-8");
+  } catch {
+    return null;
   }
-  rebuildAll(opts.db);
-  if (existsSync8(opts.entriesDir)) {
-    const own = scanSource({ db: opts.db, source: "own", entriesRoot: opts.entriesDir });
-    result.indexed.push({ source: "own", ...own });
+  const editCounts = /* @__PURE__ */ new Map();
+  const bashCounts = /* @__PURE__ */ new Map();
+  const errorSnippets = [];
+  const searchQueries = [];
+  let toolFailureCount = 0;
+  let webSearchCount = 0;
+  let webFetchCount = 0;
+  let firstTs;
+  let lastTs;
+  for (const line of raw2.split("\n")) {
+    if (line.length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const ts = parseTimestamp(parsed.timestamp);
+    if (ts !== void 0) {
+      if (firstTs === void 0 || ts < firstTs) firstTs = ts;
+      if (lastTs === void 0 || ts > lastTs) lastTs = ts;
+    }
+    if (parsed.type !== "assistant" && parsed.type !== "user") continue;
+    const content = parsed.message?.content;
+    if (!Array.isArray(content)) continue;
+    for (const item of content) {
+      if (!isRecord(item)) continue;
+      if (item.type === "tool_use") {
+        const name = item.name;
+        const input = isRecord(item.input) ? item.input : {};
+        if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
+          const p2 = typeof input.file_path === "string" ? input.file_path : "";
+          if (p2) editCounts.set(p2, (editCounts.get(p2) ?? 0) + 1);
+        } else if (name === "WebSearch") {
+          webSearchCount += 1;
+          if (typeof input.query === "string" && searchQueries.length < MAX_SEARCH_QUERIES) {
+            searchQueries.push(input.query.slice(0, MAX_SEARCH_QUERY_LENGTH));
+          }
+        } else if (name === "WebFetch") {
+          webFetchCount += 1;
+        } else if (name === "Bash") {
+          const cmd = typeof input.command === "string" ? input.command : "";
+          if (cmd) bashCounts.set(cmd, (bashCounts.get(cmd) ?? 0) + 1);
+        }
+      } else if (item.type === "tool_result") {
+        if (item.is_error === true) {
+          toolFailureCount += 1;
+          const text2 = extractResultText(item.content).replace(/\s+/g, " ").trim();
+          if (text2 && errorSnippets.length < MAX_ERROR_SNIPPETS) {
+            errorSnippets.push(text2.slice(0, MAX_ERROR_SNIPPET_LENGTH));
+          }
+        }
+      }
+    }
+  }
+  const fileEditCounts = [...editCounts.entries()].filter(([, c3]) => c3 > 1).map(([path, count]) => ({ path, count })).sort((a, b2) => b2.count - a.count).slice(0, MAX_FILE_EDIT_ENTRIES);
+  const bashRetryCount = [...bashCounts.values()].filter((c3) => c3 > 1).length;
+  const durationMinutes = firstTs !== void 0 && lastTs !== void 0 ? Math.max(0, Math.round((lastTs - firstTs) / 6e4)) : 0;
+  return {
+    toolFailureCount,
+    fileEditCounts,
+    webSearchCount,
+    webFetchCount,
+    bashRetryCount,
+    durationMinutes,
+    errorSnippets,
+    searchQueries
+  };
+}
+function hasAnyStruggleSignal(s) {
+  return s.toolFailureCount > 0 || s.fileEditCounts.length > 0 || s.webSearchCount > 0 || s.webFetchCount > 0 || s.bashRetryCount > 0;
+}
+function struggleSearchText(s) {
+  return [...s.errorSnippets, ...s.searchQueries].join(" ");
+}
+
+// ../../packages/core/dist/pendingReminders.js
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join7 } from "node:path";
+import { randomBytes as randomBytes2 } from "node:crypto";
+function sanitizeSessionId(raw2) {
+  const clean = raw2.replace(/[^A-Za-z0-9_-]/g, "");
+  return clean.length > 0 ? clean : "_unknown";
+}
+function pendingDirFor(caveatHome, sessionId) {
+  return join7(caveatHome, "pending", sanitizeSessionId(sessionId));
+}
+function appendPendingReminder(caveatHome, sessionId, text2) {
+  const dir = pendingDirFor(caveatHome, sessionId);
+  mkdirSync3(dir, { recursive: true });
+  const name = `${Date.now()}-${randomBytes2(4).toString("hex")}.txt`;
+  const path = join7(dir, name);
+  writeFileSync4(path, text2, "utf-8");
+  return path;
+}
+function drainPendingReminders(caveatHome, sessionId) {
+  const dir = pendingDirFor(caveatHome, sessionId);
+  if (!existsSync8(dir)) return [];
+  let entries;
+  try {
+    entries = readdirSync4(dir).filter((f) => f.endsWith(".txt")).sort();
+  } catch {
+    return [];
   }
-  for (const entry of readdirSync5(opts.communityDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const source = `community/${entry.name}`;
-    const root = join8(opts.communityDir, entry.name, "entries");
-    if (!existsSync8(root)) continue;
-    const scan = scanSource({ db: opts.db, source, entriesRoot: root });
-    result.indexed.push({ source, ...scan });
+  const out = [];
+  for (const entry of entries) {
+    const path = join7(dir, entry);
+    try {
+      out.push(readFileSync6(path, "utf-8"));
+    } catch {
+      continue;
+    }
+    try {
+      unlinkSync(path);
+    } catch {
+    }
   }
-  return result;
+  return out;
 }
 
 // src/context.ts
 function buildContext(logger, overrides = {}) {
   const userHome = overrides.userHome ?? homedir();
   const caveatHome = overrides.caveatHome ?? findCaveatHome(userHome);
-  const userConfigPath = join9(userHome, ".caveatrc.json");
+  const userConfigPath = join8(userHome, ".caveatrc.json");
   const config3 = loadConfig(userConfigPath);
   const paths = resolvePaths(caveatHome, config3.knowledgeRepo, userHome);
   return { caveatHome, userHome, userConfigPath, config: config3, paths, logger };
 }
 
 // src/version.ts
-import { readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join10 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname4, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveVersion() {
   try {
-    const here2 = dirname5(fileURLToPath3(import.meta.url));
-    const pkg = JSON.parse(readFileSync6(join10(here2, "..", "package.json"), "utf-8"));
+    const here2 = dirname4(fileURLToPath3(import.meta.url));
+    const pkg = JSON.parse(readFileSync7(join9(here2, "..", "package.json"), "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -21480,14 +21549,15 @@ var stdoutLogger = {
 };
 
 // src/commands/init.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync6, renameSync, rmdirSync, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync5, renameSync, rmdirSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname6, join as join11 } from "node:path";
 
 // src/claudeInstall.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { copyFileSync as copyFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5, join as join10 } from "node:path";
 var EVENT_USER_PROMPT_SUBMIT = "UserPromptSubmit";
+var EVENT_POST_TOOL_USE = "PostToolUse";
 var EVENT_STOP = "Stop";
 function quote(p2) {
   return p2.includes(" ") ? `"${p2}"` : p2;
@@ -21521,26 +21591,26 @@ function removeHook(settings, event, command) {
 }
 function readSettings(path) {
   if (!existsSync9(path)) return {};
-  return JSON.parse(readFileSync7(path, "utf-8"));
+  return JSON.parse(readFileSync8(path, "utf-8"));
 }
 function writeSettings(path, settings) {
-  const dir = dirname6(path);
+  const dir = dirname5(path);
   if (!existsSync9(dir)) mkdirSync4(dir, { recursive: true });
   let backupPath = "";
   if (existsSync9(path)) {
     backupPath = `${path}.caveat-backup-${Date.now()}`;
-    copyFileSync2(path, backupPath);
+    copyFileSync(path, backupPath);
   }
-  writeFileSync4(path, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  writeFileSync5(path, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   return backupPath;
 }
 var CLAUDE_BIN = "claude";
-function shellQuote2(s) {
+function shellQuote(s) {
   return /[\s&|<>^()]/.test(s) ? `"${s}"` : s;
 }
 function runClaude(args) {
-  const line = [CLAUDE_BIN, ...args].map(shellQuote2).join(" ");
-  return spawnSync2(line, { shell: true, encoding: "utf-8" });
+  const line = [CLAUDE_BIN, ...args].map(shellQuote).join(" ");
+  return spawnSync(line, { shell: true, encoding: "utf-8" });
 }
 function registerMcp(nodePath, cliScriptPath, dryRun, logger) {
   const args = mcpArgs(cliScriptPath);
@@ -21590,33 +21660,38 @@ function unregisterMcp(dryRun, logger) {
   return { action: "skipped", detail: "not registered or removal failed" };
 }
 function installClaudeIntegration(opts) {
-  const settingsPath = join11(opts.claudeDir, "settings.json");
+  const settingsPath = join10(opts.claudeDir, "settings.json");
   const settings = readSettings(settingsPath);
   const usCmd = hookCommand(opts.nodePath, opts.cliScriptPath, "user-prompt-submit");
+  const ptCmd = hookCommand(opts.nodePath, opts.cliScriptPath, "post-tool-use");
   const stopCmd = hookCommand(opts.nodePath, opts.cliScriptPath, "stop");
   const userPromptSubmit = upsertHook(settings, EVENT_USER_PROMPT_SUBMIT, usCmd);
+  const postToolUse = upsertHook(settings, EVENT_POST_TOOL_USE, ptCmd);
   const stop = upsertHook(settings, EVENT_STOP, stopCmd);
   let backupPath;
-  if (!opts.dryRun && (userPromptSubmit === "added" || stop === "added")) {
+  const anyAdded = userPromptSubmit === "added" || postToolUse === "added" || stop === "added";
+  if (!opts.dryRun && anyAdded) {
     const backup = writeSettings(settingsPath, settings);
     if (backup) backupPath = backup;
   } else if (opts.dryRun) {
     opts.logger.info(
-      `[dry-run] would ${userPromptSubmit === "added" ? "add" : "keep"} UserPromptSubmit hook and ${stop === "added" ? "add" : "keep"} Stop hook in ${settingsPath}`
+      `[dry-run] would ${userPromptSubmit === "added" ? "add" : "keep"} UserPromptSubmit, ${postToolUse === "added" ? "add" : "keep"} PostToolUse, ${stop === "added" ? "add" : "keep"} Stop hook in ${settingsPath}`
     );
   }
   const mcp = opts.skipMcpRegistration ? { action: "skipped", detail: "skipped by caller" } : registerMcp(opts.nodePath, opts.cliScriptPath, opts.dryRun, opts.logger);
-  return { mcp, hooks: { userPromptSubmit, stop }, backupPath };
+  return { mcp, hooks: { userPromptSubmit, postToolUse, stop }, backupPath };
 }
 function uninstallClaudeIntegration(opts) {
-  const settingsPath = join11(opts.claudeDir, "settings.json");
+  const settingsPath = join10(opts.claudeDir, "settings.json");
   const settings = readSettings(settingsPath);
   const usCmd = hookCommand(opts.nodePath, opts.cliScriptPath, "user-prompt-submit");
+  const ptCmd = hookCommand(opts.nodePath, opts.cliScriptPath, "post-tool-use");
   const stopCmd = hookCommand(opts.nodePath, opts.cliScriptPath, "stop");
   const removedUs = removeHook(settings, EVENT_USER_PROMPT_SUBMIT, usCmd);
+  const removedPt = removeHook(settings, EVENT_POST_TOOL_USE, ptCmd);
   const removedStop = removeHook(settings, EVENT_STOP, stopCmd);
   let backupPath;
-  if (!opts.dryRun && (removedUs || removedStop)) {
+  if (!opts.dryRun && (removedUs || removedPt || removedStop)) {
     const backup = writeSettings(settingsPath, settings);
     if (backup) backupPath = backup;
   }
@@ -21625,6 +21700,7 @@ function uninstallClaudeIntegration(opts) {
     mcp,
     hooks: {
       userPromptSubmit: removedUs ? "added" : "unchanged",
+      postToolUse: removedPt ? "added" : "unchanged",
       stop: removedStop ? "added" : "unchanged"
     },
     backupPath
@@ -21641,7 +21717,7 @@ var KNOWLEDGE_GITIGNORE = [
   ".obsidian/",
   ""
 ].join("\n");
-async function runInit(ctx, opts = { skipClaude: false, skipShared: false, dryRun: false }) {
+async function runInit(ctx, opts = { skipClaude: false, dryRun: false }) {
   ensureUserConfig(ctx.userConfigPath);
   ctx.logger.info(`user config: ${ctx.userConfigPath}`);
   if (!existsSync10(ctx.paths.knowledgeRepo)) {
@@ -21652,24 +21728,23 @@ async function runInit(ctx, opts = { skipClaude: false, skipShared: false, dryRu
     ctx.logger.info(`knowledge repo: ${ctx.paths.knowledgeRepo}`);
   }
   migrateLegacyCommunityDir(ctx);
-  const gitignorePath = join12(ctx.paths.knowledgeRepo, ".gitignore");
+  const gitignorePath = join11(ctx.paths.knowledgeRepo, ".gitignore");
   if (!existsSync10(gitignorePath)) {
-    writeFileSync5(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
+    writeFileSync6(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
     ctx.logger.info(`.gitignore created: ${gitignorePath}`);
   }
-  const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
-  try {
-    if (!opts.skipShared && !opts.dryRun) {
-      await subscribeSharedRepo(ctx, db);
-    } else if (opts.skipShared) {
-      ctx.logger.info("shared community DB subscription skipped (--skip-shared)");
-    } else if (opts.dryRun) {
-      ctx.logger.info(`[dry-run] would subscribe to shared community DB: ${ctx.config.sharedRepo}`);
-    }
-  } finally {
+  if (!opts.dryRun) {
+    const dbDir = dirname6(ctx.paths.dbPath);
+    if (!existsSync10(dbDir)) mkdirSync5(dbDir, { recursive: true });
+    const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
     db.close();
+    ctx.logger.info(`db initialized: ${ctx.paths.dbPath}`);
+  } else {
+    ctx.logger.info(`[dry-run] db path: ${ctx.paths.dbPath}`);
   }
-  ctx.logger.info(`db initialized: ${ctx.paths.dbPath}`);
+  ctx.logger.info(
+    "tip: subscribe to a group repo with `caveat community add <github-url>`, then `caveat pull`."
+  );
   if (opts.skipClaude) {
     ctx.logger.info("Claude Code integration skipped (--skip-claude)");
     return;
@@ -21680,7 +21755,7 @@ async function runInit(ctx, opts = { skipClaude: false, skipShared: false, dryRu
     return;
   }
   const result = installClaudeIntegration({
-    claudeDir: join12(ctx.userHome, ".claude"),
+    claudeDir: join11(ctx.userHome, ".claude"),
     cliScriptPath,
     nodePath: process.execPath,
     dryRun: opts.dryRun,
@@ -21689,7 +21764,7 @@ async function runInit(ctx, opts = { skipClaude: false, skipShared: false, dryRu
   reportInstallResult(ctx, result, opts.dryRun);
 }
 function migrateLegacyCommunityDir(ctx) {
-  const legacy = join12(ctx.paths.knowledgeRepo, "community");
+  const legacy = join11(ctx.paths.knowledgeRepo, "community");
   const current = ctx.paths.communityDir;
   if (legacy === current) return;
   if (!existsSync10(legacy)) return;
@@ -21700,9 +21775,9 @@ function migrateLegacyCommunityDir(ctx) {
     return;
   }
   mkdirSync5(current, { recursive: true });
-  for (const entry of readdirSync6(legacy, { withFileTypes: true })) {
+  for (const entry of readdirSync5(legacy, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    renameSync(join12(legacy, entry.name), join12(current, entry.name));
+    renameSync(join11(legacy, entry.name), join11(current, entry.name));
   }
   try {
     rmdirSync(legacy);
@@ -21710,52 +21785,6 @@ function migrateLegacyCommunityDir(ctx) {
   }
   ctx.logger.info(`migrated legacy community/ \u2192 ${current}`);
 }
-async function subscribeSharedRepo(ctx, db) {
-  const url = ctx.config.sharedRepo;
-  const validation = validateCommunityUrl(url);
-  if (!validation.valid) {
-    ctx.logger.warn(
-      `sharedRepo is not a valid GitHub URL \u2014 skipping: ${validation.reason}`
-    );
-    return;
-  }
-  const handle = validation.handle;
-  const target = join12(ctx.paths.communityDir, handle);
-  if (!existsSync10(target)) {
-    if (!existsSync10(ctx.paths.communityDir)) {
-      mkdirSync5(ctx.paths.communityDir, { recursive: true });
-    }
-    try {
-      await communityAdd({
-        url,
-        communityDir: ctx.paths.communityDir,
-        logger: ctx.logger
-      });
-      ctx.logger.info(`shared community DB subscribed: ${url} \u2192 community/${handle}/`);
-    } catch (err) {
-      ctx.logger.warn(
-        `shared community DB subscription failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-      return;
-    }
-  } else {
-    ctx.logger.info(`shared community DB already subscribed: community/${handle}/`);
-  }
-  if (existsSync10(ctx.paths.communityDir)) {
-    rebuildAll(db);
-    if (existsSync10(ctx.paths.entriesDir)) {
-      scanSource({ db, source: "own", entriesRoot: ctx.paths.entriesDir });
-    }
-    for (const entry of readdirSync6(ctx.paths.communityDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const source = `community/${entry.name}`;
-      const root = join12(ctx.paths.communityDir, entry.name, "entries");
-      if (!existsSync10(root)) continue;
-      const result = scanSource({ db, source, entriesRoot: root });
-      ctx.logger.info(`indexed ${source}: +${result.added}`);
-    }
-  }
-}
 function runUninstall(ctx, opts) {
   const cliScriptPath = process.argv[1];
   if (!cliScriptPath) {
@@ -21763,7 +21792,7 @@ function runUninstall(ctx, opts) {
     process.exit(1);
   }
   const result = uninstallClaudeIntegration({
-    claudeDir: join12(ctx.userHome, ".claude"),
+    claudeDir: join11(ctx.userHome, ".claude"),
     cliScriptPath,
     nodePath: process.execPath,
     dryRun: opts.dryRun,
@@ -21800,8 +21829,8 @@ function reportInstallResult(ctx, result, dryRun) {
 }
 
 // src/commands/indexCmd.ts
-import { existsSync as existsSync11, readdirSync as readdirSync7, mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname7, join as join13 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync6, mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname as dirname7, join as join12 } from "node:path";
 function runIndex(ctx, opts) {
   const dbDir = dirname7(ctx.paths.dbPath);
   if (!existsSync11(dbDir)) mkdirSync6(dbDir, { recursive: true });
@@ -21818,10 +21847,10 @@ function runIndex(ctx, opts) {
       ctx.logger.warn(`entries dir not found: ${ctx.paths.entriesDir}`);
     }
     if (existsSync11(ctx.paths.communityDir)) {
-      for (const entry of readdirSync7(ctx.paths.communityDir, { withFileTypes: true })) {
+      for (const entry of readdirSync6(ctx.paths.communityDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         const source = `community/${entry.name}`;
-        const root = join13(ctx.paths.communityDir, entry.name, "entries");
+        const root = join12(ctx.paths.communityDir, entry.name, "entries");
         if (!existsSync11(root)) continue;
         const result = scanSource({ db, source, entriesRoot: root });
         ctx.logger.info(`${source}: +${result.added} ~${result.updated} -${result.deleted}`);
@@ -22596,11 +22625,11 @@ var serve = (options2, listeningListener) => {
 
 // ../web/dist/context.js
 import { homedir as homedir2 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join13 } from "node:path";
 function buildWebContext(overrides = {}) {
   const userHome = overrides.userHome ?? homedir2();
   const caveatHome = overrides.caveatHome ?? findCaveatHome(userHome);
-  const userConfigPath = join14(userHome, ".caveatrc.json");
+  const userConfigPath = join13(userHome, ".caveatrc.json");
   const logger = overrides.logger ?? stderrLogger;
   const config3 = loadConfig(userConfigPath);
   const paths = resolvePaths(caveatHome, config3.knowledgeRepo, userHome);
@@ -24705,7 +24734,7 @@ ul.entries li { padding: 0.5rem 0; border-bottom: 1px solid #eee; }
 ul.entries a.title { font-weight: 600; color: #0a5fff; text-decoration: none; }
 ul.entries a.title:hover { text-decoration: underline; }
 ul.entries .meta { font-size: 0.85rem; color: #666; margin-top: 0.2rem; }
-ul.entries .meta .badge {
+.badge {
   display: inline-block;
   padding: 0 0.4rem;
   margin-right: 0.3rem;
@@ -24713,10 +24742,12 @@ ul.entries .meta .badge {
   background: #f0f0f0;
   font-size: 0.8rem;
 }
-ul.entries .meta .badge.confirmed { background: #d7f4dc; color: #16703a; }
-ul.entries .meta .badge.reproduced { background: #e6eeff; color: #234ea3; }
-ul.entries .meta .badge.tentative { background: #fff4d1; color: #8a5a00; }
-ul.entries .meta .badge.impossible { background: #ffd9d9; color: #8a1a1a; }
+.badge.confirmed { background: #d7f4dc; color: #16703a; }
+.badge.reproduced { background: #e6eeff; color: #234ea3; }
+.badge.tentative { background: #fff4d1; color: #8a5a00; }
+.badge.impossible { background: #ffd9d9; color: #8a1a1a; }
+.badge.public { background: #eef2f5; color: #5a6470; }
+.badge.private { background: #fde7e7; color: #a02525; font-weight: 600; }
 ul.entries .excerpt { margin-top: 0.3rem; color: #444; font-size: 0.92rem; }
 article h2 { border-bottom: 1px solid #eee; padding-bottom: 0.2rem; margin-top: 1.6rem; }
 article pre {
@@ -24791,6 +24822,7 @@ function createIndexRoute(ctx) {
     const q2 = c3.req.query("q")?.trim() ?? "";
     const sourceParam = c3.req.query("source");
     const tagParam = c3.req.query("tag");
+    const visibilityParam = c3.req.query("visibility");
     const filters = {};
     if (sourceParam === "own" || sourceParam === "community" || sourceParam === "all") {
       filters.source = sourceParam;
@@ -24798,17 +24830,22 @@ function createIndexRoute(ctx) {
     if (tagParam) {
       filters.tags = [tagParam];
     }
-    const results = q2 ? search(ctx.db, { query: q2, filters, limit: 50 }) : listRecent(ctx.db, 50);
+    if (visibilityParam === "public" || visibilityParam === "private") {
+      filters.visibility = visibilityParam;
+    }
+    const results = search(ctx.db, { query: q2, filters, limit: 50 });
     const rows = results.map((r2) => {
       const envEntries = Object.entries(r2.environment ?? {});
       const envSummary = envEntries.slice(0, 3).map(([k2, v]) => `${escapeHtml(k2)}:${escapeHtml(String(v))}`).join(" ");
       const hrefSource = r2.source === "own" ? "" : `?source=${encodeURIComponent(r2.source)}`;
+      const visibilityBadge = r2.visibility === "private" ? `<span class="badge private" title="local-only \u2014 never pushed to community DB">\u{1F512} private</span>` : `<span class="badge public">public</span>`;
       return `
       <li>
         <a class="title" href="/g/${encodeURIComponent(r2.id)}${hrefSource}">${escapeHtml(r2.title)}</a>
         <div class="meta">
           <span class="badge ${escapeHtml(r2.confidence ?? "")}">${escapeHtml(r2.confidence ?? "")}</span>
           <span class="badge">${escapeHtml(r2.source)}</span>
+          ${visibilityBadge}
           ${envSummary ? `<span>${envSummary}</span>` : ""}
         </div>
         ${r2.symptomExcerpt ? `<div class="excerpt">${escapeHtml(r2.symptomExcerpt)}</div>` : ""}
@@ -24822,9 +24859,18 @@ function createIndexRoute(ctx) {
     <option value="own" ${sourceParam === "own" ? "selected" : ""}>own</option>
     <option value="community" ${sourceParam === "community" ? "selected" : ""}>community</option>
   </select>
+  <select name="visibility" title="visibility filter \u2014 useful when sharing screen">
+    <option value="" ${!visibilityParam ? "selected" : ""}>any visibility</option>
+    <option value="public" ${visibilityParam === "public" ? "selected" : ""}>public only</option>
+    <option value="private" ${visibilityParam === "private" ? "selected" : ""}>private only</option>
+  </select>
   <button type="submit">search</button>
 </form>
-${results.length > 0 ? `<ul class="entries">${rows}</ul>` : `<div class="empty">${q2 ? `no results for "${escapeHtml(q2)}"` : "no entries yet \u2014 run <code>caveat index</code> after adding md files"}</div>`}`;
+${results.length > 0 ? `<ul class="entries">${rows}</ul>` : (() => {
+      if (q2) return `<div class="empty">no results for "${escapeHtml(q2)}"</div>`;
+      const hasFilter = !!(sourceParam || tagParam || visibilityParam);
+      return hasFilter ? `<div class="empty">no entries match the active filters</div>` : `<div class="empty">no entries yet \u2014 run <code>caveat index</code> after adding md files</div>`;
+    })()}`;
     const title = q2 ? `search: ${q2} \xB7 Caveat` : "Caveat";
     return c3.html(layout(title, body));
   });
@@ -30290,10 +30336,11 @@ function createDetailRoute(ctx) {
     }
     const fm = entry.frontmatter;
     const envRows = Object.entries(fm.environment ?? {}).map(([k2, v]) => `<dt>${escapeHtml(k2)}</dt><dd>${escapeHtml(String(v))}</dd>`).join("");
+    const visibilityBadge = fm.visibility === "private" ? `<span class="badge private" title="local-only \u2014 never pushed to community DB">\u{1F512} private</span>` : `<span class="badge public">public</span>`;
     const metaRows = [
       `<dt>id</dt><dd><code>${escapeHtml(fm.id)}</code></dd>`,
       `<dt>source</dt><dd>${escapeHtml(entry.source)}</dd>`,
-      `<dt>visibility</dt><dd>${escapeHtml(fm.visibility)}</dd>`,
+      `<dt>visibility</dt><dd>${visibilityBadge}</dd>`,
       `<dt>confidence</dt><dd><span class="badge ${escapeHtml(fm.confidence)}">${escapeHtml(fm.confidence)}</span></dd>`
     ];
     if (fm.outcome) {
@@ -30327,14 +30374,14 @@ function createDetailRoute(ctx) {
 }
 
 // ../web/dist/routes/community.js
-import { existsSync as existsSync12, readdirSync as readdirSync8, statSync as statSync4 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
+import { join as join14 } from "node:path";
 function listCommunity(communityDir, db) {
   if (!existsSync12(communityDir)) return [];
   const handles = [];
-  for (const entry of readdirSync8(communityDir, { withFileTypes: true })) {
+  for (const entry of readdirSync7(communityDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const handlePath = join15(communityDir, entry.name);
+    const handlePath = join14(communityDir, entry.name);
     const countRow = db.prepare("SELECT COUNT(*) AS n FROM entries WHERE source = ?").get(`community/${entry.name}`);
     handles.push({
       handle: entry.name,
@@ -30351,7 +30398,7 @@ function createCommunityRoute(ctx) {
     const list2 = handles.map((h2) => {
       let mtime = "";
       try {
-        mtime = statSync4(h2.path).mtime.toISOString().slice(0, 10);
+        mtime = statSync5(h2.path).mtime.toISOString().slice(0, 10);
       } catch {
         mtime = "";
       }
@@ -44632,11 +44679,11 @@ var StdioServerTransport = class {
 
 // ../mcp/dist/context.js
 import { homedir as homedir3 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join15 } from "node:path";
 function buildMcpContext(overrides = {}) {
   const userHome = overrides.userHome ?? homedir3();
   const caveatHome = overrides.caveatHome ?? findCaveatHome(userHome);
-  const userConfigPath = join16(userHome, ".caveatrc.json");
+  const userConfigPath = join15(userHome, ".caveatrc.json");
   const logger = overrides.logger ?? stderrLogger;
   const config3 = loadConfig(userConfigPath);
   const paths = resolvePaths(caveatHome, config3.knowledgeRepo, userHome);
@@ -44745,45 +44792,37 @@ function handleListRecent(ctx, args) {
 }
 
 // ../mcp/dist/tools/pull.js
+import { existsSync as existsSync13, readdirSync as readdirSync8 } from "node:fs";
+import { join as join16 } from "node:path";
 var pullInputShape = {};
 async function handlePull(ctx, _args = {}) {
-  const result = await pullShared({
-    communityDir: ctx.paths.communityDir,
-    entriesDir: ctx.paths.entriesDir,
-    db: ctx.db,
-    logger: ctx.logger
-  });
-  return {
-    pulled: result.pulled,
-    indexed: result.indexed.map((i2) => ({
-      source: i2.source,
-      added: i2.added,
-      updated: i2.updated,
-      deleted: i2.deleted
-    }))
-  };
-}
-
-// ../mcp/dist/tools/push.js
-var pushInputShape = {
-  id: external_exports.string().min(1).describe("Entry id (frontmatter.id) to push to the shared community DB"),
-  dry_run: external_exports.boolean().optional().describe("If true, compute the plan but do not modify GitHub or local git state")
-};
-async function handlePush(ctx, args) {
-  const result = await pushEntry({
-    entriesDir: ctx.paths.entriesDir,
-    caveatHome: ctx.caveatHome,
-    sharedRepoUrl: ctx.config.sharedRepo,
-    id: args.id,
-    dryRun: args.dry_run ?? false,
-    logger: ctx.logger
-  });
-  return {
-    status: result.status,
-    detail: result.detail,
-    pr_url: result.prUrl,
-    planned_steps: result.plannedSteps
-  };
+  const pulled = [];
+  const indexed = [];
+  if (existsSync13(ctx.paths.communityDir)) {
+    const results = await communityPull({
+      communityDir: ctx.paths.communityDir,
+      logger: ctx.logger
+    });
+    for (const r2 of results) {
+      pulled.push({ handle: r2.handle, status: r2.status, message: r2.message });
+    }
+  }
+  rebuildAll(ctx.db);
+  if (existsSync13(ctx.paths.entriesDir)) {
+    const own = scanSource({ db: ctx.db, source: "own", entriesRoot: ctx.paths.entriesDir });
+    indexed.push({ source: "own", ...own });
+  }
+  if (existsSync13(ctx.paths.communityDir)) {
+    for (const entry of readdirSync8(ctx.paths.communityDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const source = `community/${entry.name}`;
+      const root = join16(ctx.paths.communityDir, entry.name, "entries");
+      if (!existsSync13(root)) continue;
+      const scan = scanSource({ db: ctx.db, source, entriesRoot: root });
+      indexed.push({ source, ...scan });
+    }
+  }
+  return { pulled, indexed };
 }
 
 // ../mcp/dist/registerTools.js
@@ -44847,20 +44886,11 @@ function registerAllTools(server, ctx) {
     "caveat_pull",
     {
       title: "caveat_pull",
-      description: "git-pull the subscribed community caveat repos (the shared knowledge DB + any user-added remotes) and re-index. Call when: (a) the user explicitly asks about others' knowledge on a topic, or (b) caveat_search returned empty for a query that feels like it should have hits and the DB might be stale. Do NOT call reflexively at session start \u2014 it is cheap but not free, and stale-by-minutes is acceptable. Safe and idempotent.",
+      description: "git-pull every subscribed community caveat repo (added via `caveat community add`) and re-index. Call when: (a) the user explicitly asks about others' knowledge on a topic, or (b) caveat_search returned empty for a query that feels like it should have hits and a subscribed repo might be stale. Do NOT call reflexively at session start \u2014 it is cheap but not free, and stale-by-minutes is acceptable. Safe and idempotent.",
       inputSchema: pullInputShape
     },
     async (args) => jsonResult(await handlePull(ctx, args))
   );
-  server.registerTool(
-    "caveat_push",
-    {
-      title: "caveat_push",
-      description: "Contribute a user-owned caveat to the public shared DB via fork + PR on GitHub. This is a PUBLIC, externally-visible action (the PR appears on GitHub and is hard to fully retract). Confirm with the user before calling without dry_run \u2014 or call with dry_run=true first to show the plan. Only push entries that document a trap genuinely reusable by others (not project-specific ties, not duplicated by existing community entries). Entries with `visibility: private` are rejected (`status=visibility-private`) \u2014 the user has declared them local-only. Requires `gh` CLI authenticated; returns `status=gh-missing` / `gh-unauthed` on failure.",
-      inputSchema: pushInputShape
-    },
-    async (args) => jsonResult(await handlePush(ctx, args))
-  );
 }
 
 // ../mcp/dist/server.js
@@ -44900,6 +44930,19 @@ async function runMcpServer() {
 }
 
 // src/commands/hookCmd.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join17 } from "node:path";
+import { randomBytes as randomBytes3 } from "node:crypto";
+var silentLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: (m) => process.stderr.write(`[caveat:hook] ${m}
+`)
+};
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -44918,7 +44961,153 @@ function parsePayload(raw2) {
     return {};
   }
 }
-async function runHook(name) {
+function getSessionId(payload) {
+  const v = payload.session_id ?? payload.sessionId;
+  return typeof v === "string" && v.length > 0 ? v : "_unknown";
+}
+function buildContextSafely() {
+  try {
+    return buildContext(silentLogger);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[caveat:hook] context error: ${msg}
+`);
+    return null;
+  }
+}
+function searchCaveatsFromTextSafely(text2) {
+  if (!text2) return [];
+  let db;
+  try {
+    const ctx = buildContextSafely();
+    if (!ctx || !existsSync14(ctx.paths.dbPath)) return [];
+    db = openDb({ path: ctx.paths.dbPath });
+    return findCaveatsForPrompt(db, text2);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[caveat:hook] search error: ${msg}
+`);
+    return [];
+  } finally {
+    db?.close();
+  }
+}
+function loadSignalsSafely(path) {
+  try {
+    return readSessionSignals(path);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[caveat:hook] transcript read error: ${msg}
+`);
+    return null;
+  }
+}
+function drainForSession(sessionId) {
+  const ctx = buildContextSafely();
+  if (!ctx) return;
+  const reminders = drainPendingReminders(ctx.caveatHome, sessionId);
+  for (const text2 of reminders) {
+    process.stdout.write(`<system-reminder>${text2}</system-reminder>
+`);
+  }
+}
+function extractToolResponseText(response) {
+  if (typeof response === "string") return response;
+  if (Array.isArray(response)) {
+    const parts = [];
+    for (const item of response) {
+      if (typeof item === "string") parts.push(item);
+      else if (item !== null && typeof item === "object" && typeof item.text === "string") {
+        parts.push(item.text);
+      }
+    }
+    return parts.join(" ");
+  }
+  if (response !== null && typeof response === "object") {
+    const r2 = response;
+    if (typeof r2.content === "string") return r2.content;
+    if (Array.isArray(r2.content)) return extractToolResponseText(r2.content);
+    if (typeof r2.output === "string") return r2.output;
+    if (typeof r2.stdout === "string" || typeof r2.stderr === "string") {
+      return [r2.stdout, r2.stderr].filter((x2) => typeof x2 === "string").join(" ");
+    }
+  }
+  return "";
+}
+function isToolError(payload) {
+  const resp = payload.tool_response ?? payload.toolResponse;
+  if (resp !== null && typeof resp === "object" && !Array.isArray(resp)) {
+    if (resp.is_error === true) return true;
+  }
+  if (payload.is_error === true) return true;
+  return false;
+}
+function spawnWorker(job) {
+  const workFile = join17(
+    tmpdir(),
+    `caveat-worker-${Date.now()}-${randomBytes3(4).toString("hex")}.json`
+  );
+  try {
+    writeFileSync7(workFile, JSON.stringify(job), "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[caveat:hook] worker writefile error: ${msg}
+`);
+    return;
+  }
+  const cliScript = process.argv[1];
+  if (!cliScript) return;
+  try {
+    const child = spawn2(
+      process.execPath,
+      ["--disable-warning=ExperimentalWarning", cliScript, "hook", "worker", workFile],
+      { detached: true, stdio: "ignore", windowsHide: true }
+    );
+    child.unref();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[caveat:hook] worker spawn error: ${msg}
+`);
+    try {
+      unlinkSync2(workFile);
+    } catch {
+    }
+  }
+}
+async function runWorker(workFile) {
+  let raw2;
+  try {
+    raw2 = readFileSync9(workFile, "utf-8");
+  } catch {
+    process.exit(0);
+  }
+  try {
+    unlinkSync2(workFile);
+  } catch {
+  }
+  let job;
+  try {
+    job = JSON.parse(raw2);
+  } catch {
+    process.exit(0);
+  }
+  if (!job.searchText || !job.sessionId) process.exit(0);
+  const hits = searchCaveatsFromTextSafely(job.searchText);
+  if (hits.length === 0) process.exit(0);
+  const ctx = buildContextSafely();
+  if (!ctx) process.exit(0);
+  try {
+    appendPendingReminder(ctx.caveatHome, job.sessionId, toolErrorReminderText(hits));
+  } catch {
+  }
+  process.exit(0);
+}
+async function runHook(name, arg) {
+  if (name === "worker") {
+    if (!arg) process.exit(0);
+    await runWorker(arg);
+    return;
+  }
   let raw2 = "";
   try {
     raw2 = await readStdin();
@@ -44929,22 +45118,37 @@ async function runHook(name) {
     process.exit(0);
   }
   const payload = parsePayload(raw2);
+  const sessionId = getSessionId(payload);
+  drainForSession(sessionId);
   if (name === "user-prompt-submit") {
     const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
-    if (detectCaveatTrigger(prompt)) {
+    const hits = searchCaveatsFromTextSafely(prompt);
+    if (hits.length > 0) {
       process.stdout.write(
-        `<system-reminder>${userPromptSubmitReminderText()}</system-reminder>
+        `<system-reminder>${userPromptSubmitReminderText(hits)}</system-reminder>
 `
       );
     }
     process.exit(0);
   }
-  if (name === "stop") {
-    if (payload.stop_hook_active === true) {
-      process.exit(0);
+  if (name === "post-tool-use") {
+    if (!isToolError(payload)) process.exit(0);
+    const errText = extractToolResponseText(payload.tool_response ?? payload);
+    if (errText) {
+      spawnWorker({ sessionId, searchText: errText });
     }
-    process.stdout.write(`<system-reminder>${stopReminderText()}</system-reminder>
-`);
+    process.exit(0);
+  }
+  if (name === "stop") {
+    if (payload.stop_hook_active === true) process.exit(0);
+    const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : "";
+    const signals = transcriptPath ? loadSignalsSafely(transcriptPath) : null;
+    if (!signals || !hasAnyStruggleSignal(signals)) process.exit(0);
+    const related = searchCaveatsFromTextSafely(struggleSearchText(signals));
+    process.stdout.write(
+      `<system-reminder>${stopReminderText(signals, related)}</system-reminder>
+`
+    );
     process.exit(0);
   }
   process.stderr.write(`[caveat:hook] unknown hook name: ${name}
@@ -44953,77 +45157,46 @@ async function runHook(name) {
 }
 
 // src/commands/pull.ts
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync15, readdirSync as readdirSync9 } from "node:fs";
+import { join as join18 } from "node:path";
 async function runPull(ctx) {
-  if (!existsSync13(ctx.paths.communityDir)) {
+  if (!existsSync15(ctx.paths.communityDir)) {
     ctx.logger.info(
-      "no community repos yet \u2014 did you run `caveat init`? You can also `caveat community add <url>` manually."
+      "no community repos yet \u2014 add one with `caveat community add <github-url>`."
     );
     return;
   }
+  const pulls = await communityPull({
+    communityDir: ctx.paths.communityDir,
+    logger: ctx.logger
+  });
+  for (const p2 of pulls) {
+    if (p2.status === "ok") {
+      ctx.logger.info(`${p2.handle}: pulled`);
+    } else {
+      ctx.logger.warn(`${p2.handle}: FAILED \u2014 ${p2.message ?? "unknown"}`);
+    }
+  }
   const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
   try {
-    const result = await pullShared({
-      communityDir: ctx.paths.communityDir,
-      entriesDir: ctx.paths.entriesDir,
-      db,
-      logger: ctx.logger
-    });
-    for (const p2 of result.pulled) {
-      if (p2.status === "ok") {
-        ctx.logger.info(`${p2.handle}: pulled`);
-      } else {
-        ctx.logger.warn(`${p2.handle}: FAILED \u2014 ${p2.message ?? "unknown"}`);
-      }
+    rebuildAll(db);
+    if (existsSync15(ctx.paths.entriesDir)) {
+      const own = scanSource({ db, source: "own", entriesRoot: ctx.paths.entriesDir });
+      ctx.logger.info(`own: +${own.added}`);
     }
-    for (const i2 of result.indexed) {
-      ctx.logger.info(`${i2.source}: +${i2.added}`);
+    for (const entry of readdirSync9(ctx.paths.communityDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const source = `community/${entry.name}`;
+      const root = join18(ctx.paths.communityDir, entry.name, "entries");
+      if (!existsSync15(root)) continue;
+      const scan = scanSource({ db, source, entriesRoot: root });
+      ctx.logger.info(`${source}: +${scan.added}`);
     }
   } finally {
     db.close();
   }
 }
 
-// src/commands/push.ts
-async function runPush(ctx, opts) {
-  const result = await pushEntry({
-    entriesDir: ctx.paths.entriesDir,
-    caveatHome: ctx.caveatHome,
-    sharedRepoUrl: ctx.config.sharedRepo,
-    id: opts.id,
-    dryRun: opts.dryRun,
-    logger: ctx.logger
-  });
-  switch (result.status) {
-    case "ok":
-      ctx.logger.info(`PR opened: ${result.prUrl ?? ""}`);
-      ctx.logger.info(
-        "Once merged, other subscribers will see your entry after their next `caveat pull`."
-      );
-      break;
-    case "dry-run":
-      for (const [i2, step] of (result.plannedSteps ?? []).entries()) {
-        ctx.logger.info(`[dry-run] ${i2 + 1}. ${step}`);
-      }
-      break;
-    case "not-found":
-      ctx.logger.error(
-        `${result.detail}. List entries with \`caveat list\` or write + index first.`
-      );
-      process.exitCode = 1;
-      break;
-    case "gh-missing":
-    case "gh-unauthed":
-      ctx.logger.error(result.detail ?? "gh CLI issue");
-      process.exitCode = 1;
-      break;
-    case "failed":
-      ctx.logger.error(result.detail ?? "unknown failure");
-      process.exitCode = 1;
-      break;
-  }
-}
-
 // src/commands/community.ts
 async function runCommunityAdd(ctx, url) {
   try {
@@ -45073,17 +45246,46 @@ function runCommunityList(ctx) {
     db.close();
   }
 }
+function runCommunityRemove(ctx, handle, opts) {
+  const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
+  try {
+    const result = communityRemove({
+      communityDir: ctx.paths.communityDir,
+      handle,
+      db,
+      dryRun: opts.dryRun,
+      logger: ctx.logger
+    });
+    if (!result.dirExisted && result.rowCount === 0) {
+      ctx.logger.warn(`no community subscription named "${handle}" \u2014 nothing to remove`);
+      return;
+    }
+    const prefix = result.dryRun ? "[dry-run] would " : "";
+    if (result.dirExisted) {
+      ctx.logger.info(`${prefix}remove dir: ${result.path}`);
+    }
+    if (result.rowCount > 0) {
+      ctx.logger.info(
+        `${prefix}delete ${result.rowCount} db row(s) for source=community/${handle}`
+      );
+    }
+  } catch (err) {
+    ctx.logger.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  } finally {
+    db.close();
+  }
+}
 
 // src/index.ts
 var program = new Command();
 program.name("caveat").description("External spec gotcha knowledge base CLI").version(CAVEAT_VERSION);
 program.command("init").description(
-  "Initialize ~/.caveatrc.json, ~/.caveat/, subscribe to the shared community DB, and register Claude Code integration"
-).option("--skip-claude", "skip Claude Code MCP + hook registration", false).option("--skip-shared", "skip subscribing to the shared community DB", false).option("--dry-run", "show planned changes without writing", false).action(async (opts) => {
+  "Initialize ~/.caveatrc.json, ~/.caveat/, and register Claude Code integration. Add knowledge sources later with `caveat community add <github-url>`."
+).option("--skip-claude", "skip Claude Code MCP + hook registration", false).option("--dry-run", "show planned changes without writing", false).action(async (opts) => {
   const ctx = buildContext(stdoutLogger);
   await runInit(ctx, {
     skipClaude: opts.skipClaude,
-    skipShared: opts.skipShared,
     dryRun: opts.dryRun
   });
 });
@@ -45119,23 +45321,21 @@ program.command("stats").description("Show aggregate stats").action(() => {
   runStats(ctx);
 });
 program.command("pull").description(
-  "Refresh all subscribed community repos (incl. shared DB) and re-index. Use this to receive contributions others have merged."
+  "git-pull every subscribed community repo and re-index. Use this to receive updates from group/teammate repos."
 ).action(async () => {
   const ctx = buildContext(stdoutLogger);
   await runPull(ctx);
 });
-program.command("push").description("Contribute a caveat to the shared community DB via fork + PR (requires gh CLI).").argument("<id>", "entry id (from `caveat list`)").option("--dry-run", "show planned steps without making GitHub changes", false).action(async (id, opts) => {
-  const ctx = buildContext(stdoutLogger);
-  await runPush(ctx, { id, dryRun: opts.dryRun });
-});
 program.command("serve").description("Start the read-only web share portal").option("--port <n>", "port number", (v) => Number(v), 4242).action((opts) => {
   runServe({ port: opts.port });
 });
 program.command("mcp-server").description("Run the MCP stdio server (registered by `caveat init`)").action(async () => {
   await runMcpServer();
 });
-program.command("hook <name>").description("Run a Claude Code hook. name: user-prompt-submit | stop").action(async (name) => {
-  await runHook(name);
+program.command("hook <name> [arg]").description(
+  "Run a Claude Code hook. name: user-prompt-submit | post-tool-use | stop | worker"
+).action(async (name, arg) => {
+  await runHook(name, arg);
 });
 var community = program.command("community").description("Manage community caveat repos (shallow clones under <knowledgeRepo>/community/)");
 community.command("add <url>").description("Shallow-clone a GitHub caveat repo into community/<handle>/").action(async (url) => {
@@ -45150,6 +45350,10 @@ community.command("list").description("List imported community repos with entry
   const ctx = buildContext(stdoutLogger);
   runCommunityList(ctx);
 });
+community.command("remove <handle>").description("Unsubscribe from a community repo: delete community/<handle>/ and purge its DB rows").option("--dry-run", "show what would be removed without touching disk or db", false).action((handle, opts) => {
+  const ctx = buildContext(stdoutLogger);
+  runCommunityRemove(ctx, handle, { dryRun: opts.dryRun });
+});
 program.parseAsync(process.argv).catch((err) => {
   const msg = err instanceof Error ? err.message : String(err);
   process.stderr.write(`[caveat:error] ${msg}