kibi-cursor 2.12.0 → 2.13.0

package/dist/bin/hook-runner.mjs

@@ -1,19 +1,68 @@
 #!/usr/bin/env node
 
 // src/hook-runner.ts
-import fs7 from "node:fs";
-import path9 from "node:path";
+import fs9 from "node:fs";
+import path11 from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 
+// ../agent-core/dist/checkout-hooks.js
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var HOOK_MANAGER_FILES = [
+  "lefthook.yml",
+  "lefthook.yaml",
+  ".lefthook.yml",
+  ".lefthook.yaml",
+  "lefthook.json",
+  ".husky",
+  ".pre-commit-config.yaml"
+];
+function git(workspaceRoot, args) {
+  const result = spawnSync("git", args, {
+    cwd: workspaceRoot,
+    encoding: "utf8",
+    timeout: 2000
+  });
+  return result.status === 0 ? result.stdout.trim() : null;
+}
+function hasKibiPreCommitGate(workspaceRoot) {
+  const resolved = git(workspaceRoot, [
+    "rev-parse",
+    "--git-path",
+    "hooks/pre-commit"
+  ]);
+  const hookPath = resolved !== null ? path.resolve(workspaceRoot, resolved) : path.join(workspaceRoot, ".git", "hooks", "pre-commit");
+  try {
+    return /kibi[^\n]*\bcheck\b/i.test(String(fs.readFileSync(hookPath)));
+  } catch {}
+  return false;
+}
+function kibiHooksMissing(workspaceRoot) {
+  if (!fs.existsSync(path.join(workspaceRoot, ".kb", "manifest.json")))
+    return false;
+  if (git(workspaceRoot, ["rev-parse", "--is-inside-work-tree"]) !== "true")
+    return false;
+  if (git(workspaceRoot, ["config", "--get", "core.hooksPath"]) !== null)
+    return false;
+  if (HOOK_MANAGER_FILES.some((file) => fs.existsSync(path.join(workspaceRoot, file))))
+    return false;
+  return !hasKibiPreCommitGate(workspaceRoot);
+}
+var MISSING_HOOKS_NOTE = "Kibi git hooks are not installed in this checkout (a clone never carries .git/hooks), so commits skip `kibi check --staged` and a branch switch does not recompile the KB. Install them with `npx --no-install kibi hooks install` (or the project's package-manager runner), or by installing the project's dependencies when its prepare script runs it.";
+function missingHooksNote(workspaceRoot) {
+  return kibiHooksMissing(workspaceRoot) ? MISSING_HOOKS_NOTE : null;
+}
+
 // ../agent-core/dist/decision-guard.js
 import { createHash as createHash2 } from "node:crypto";
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 
 // ../agent-core/dist/requirement-candidates.js
-import path from "node:path";
-var REQUIREMENTS_DIR = path.join(".kb", "requirements");
-var LAYOUT_WORDS = new Set([
+import path2 from "node:path";
+var REQUIREMENTS_DIR = path2.join(".kb", "requirements");
+var LAYOUT_WORDS = stems([
   "src",
   "app",
   "apps",
@@ -21,44 +70,31 @@ var LAYOUT_WORDS = new Set([
   "libs",
   "source",
   "page",
-  "pages",
   "component",
-  "components",
   "view",
-  "views",
   "screen",
-  "screens",
   "package",
-  "packages",
   "main",
   "index",
   "shared",
   "common",
   "core",
   "util",
-  "utils",
   "helper",
-  "helpers",
   "public",
   "static",
   "asset",
-  "assets",
   "web",
   "client",
   "server",
   "frontend",
   "backend",
   "module",
-  "modules",
   "feature",
-  "features",
   "internal",
   "service",
-  "services",
   "test",
-  "tests",
   "spec",
-  "specs",
   "dist",
   "build",
   "html",
@@ -79,7 +115,7 @@ var LAYOUT_WORDS = new Set([
   "swift",
   "php"
 ]);
-var FILLER_WORDS = new Set([
+var FILLER_WORDS = stems([
   "the",
   "and",
   "for",
@@ -90,7 +126,6 @@ var FILLER_WORDS = new Set([
   "may",
   "can",
   "are",
-  "is",
   "its",
   "their",
   "that",
@@ -106,13 +141,16 @@ var FILLER_WORDS = new Set([
   "auto"
 ]);
 function words(text) {
-  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length >= 3 && !/\d/.test(word)).map((word) => word.length > 4 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word);
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().match(/[a-z0-9]+/g)?.filter((word) => word.length >= 3 && !/\d/.test(word)).map((word) => word.length > 4 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word) ?? [];
+}
+function stems(list) {
+  return new Set(list.flatMap(words));
 }
 function requestTopicWords(text, limit = 40) {
   const found = words(text).filter((word) => !FILLER_WORDS.has(word) && !REQUEST_FILLER_WORDS.has(word));
   return [...new Set(found)].slice(0, limit);
 }
-var REQUEST_FILLER_WORDS = new Set([
+var REQUEST_FILLER_WORDS = stems([
   "please",
   "could",
   "would",
@@ -175,12 +213,12 @@ var REQUEST_FILLER_WORDS = new Set([
 ]);
 
 // ../agent-core/dist/snippets.js
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 
 // ../agent-core/dist/knowledge-index.js
 import { createHash, randomUUID } from "node:crypto";
-import fs from "node:fs";
-import path2 from "node:path";
+import fs2 from "node:fs";
+import path3 from "node:path";
 var SYMBOLS_MANIFEST = ".kb/symbols.yaml";
 var SYMBOL_COORDINATES = ".kb/symbol-coordinates.yaml";
 var INDEX_FORMAT = "kibi-agent-core.knowledge-index.v2";
@@ -197,56 +235,36 @@ function unquote(raw) {
   if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
     return value.slice(1, -1).replaceAll("''", "'");
   }
-  const comment = value.search(/\s#/);
-  return comment >= 0 ? value.slice(0, comment).trimEnd() : value;
+  return value.replace(/\s#[\s\S]*/, "").trimEnd();
 }
+var FLOW_BLANK = /(?:[ \t\n\r]|#[^\n]*)*/y;
+var DOUBLE_QUOTED = /"(?:[^"\\]|\\[\s\S])*"/y;
+var SINGLE_QUOTED = /'(?:[^']|'')*'/y;
 function parseFlow(text, start = 0) {
   let pos = start;
   const skip = () => {
-    while (pos < text.length) {
-      const char = text[pos];
-      if (char === "#") {
-        while (pos < text.length && text[pos] !== `
-`)
-          pos += 1;
-      } else if (char === " " || char === "\t" || char === `
-` || char === "\r") {
-        pos += 1;
-      } else {
-        break;
-      }
-    }
+    FLOW_BLANK.lastIndex = pos;
+    FLOW_BLANK.test(text);
+    pos = FLOW_BLANK.lastIndex;
   };
   const scalar = (stops) => {
-    const quote = text[pos];
+    const quote = text.charAt(pos);
     if (quote === '"' || quote === "'") {
-      let cursor = pos + 1;
-      while (cursor < text.length) {
-        if (quote === '"' && text[cursor] === "\\")
-          cursor += 2;
-        else if (text[cursor] === quote) {
-          if (quote === "'" && text[cursor + 1] === "'")
-            cursor += 2;
-          else
-            break;
-        } else
-          cursor += 1;
-      }
-      if (cursor >= text.length)
-        return;
-      const raw = text.slice(pos, cursor + 1);
-      pos = cursor + 1;
+      const pattern = quote === '"' ? DOUBLE_QUOTED : SINGLE_QUOTED;
+      pattern.lastIndex = pos;
+      const raw = pattern.exec(text)[0];
+      pos = pattern.lastIndex;
       return unquote(raw);
     }
     let cursor = pos;
-    while (cursor < text.length) {
-      const char = text[cursor] ?? "";
+    for (;; ) {
+      const char = text.charAt(cursor);
       if (stops.includes(char) && char !== ":" || char === `
 ` || char === "\r")
         break;
-      if (stops.includes(":") && char === ":" && (cursor + 1 >= text.length || /[\s,\]}]/.test(text[cursor + 1] ?? "")))
+      if (stops.includes(":") && char === ":" && /[\s,\]}]/.test(text.charAt(cursor + 1)))
         break;
-      if (char === "#" && /\s/.test(text[cursor - 1] ?? ""))
+      if (char === "#" && /\s/.test(text.charAt(cursor - 1)))
         break;
       cursor += 1;
     }
@@ -255,27 +273,22 @@ function parseFlow(text, start = 0) {
     return raw;
   };
   const value = () => {
-    skip();
-    const open = text[pos];
+    const open = text.charAt(pos);
     if (open === "[") {
       pos += 1;
       const items = [];
       for (;; ) {
         skip();
-        if (text[pos] === "]") {
+        if (text.charAt(pos) === "]") {
           pos += 1;
           return items;
         }
-        if (pos >= text.length)
-          throw new SyntaxError("unterminated flow sequence");
-        const item = value();
-        if (item !== undefined)
-          items.push(item);
+        items.push(value());
         skip();
-        if (text[pos] === ",")
+        if (text.charAt(pos) === ",")
           pos += 1;
-        else if (text[pos] !== "]")
-          throw new SyntaxError("expected , or ]");
+        else if (text.charAt(pos) !== "]")
+          throw new SyntaxError;
       }
     }
     if (open === "{") {
@@ -283,46 +296,37 @@ function parseFlow(text, start = 0) {
       const record = {};
       for (;; ) {
         skip();
-        if (text[pos] === "}") {
+        if (text.charAt(pos) === "}") {
           pos += 1;
           return record;
         }
-        if (pos >= text.length)
-          throw new SyntaxError("unterminated flow mapping");
         const key = scalar(":,}");
-        if (key === undefined)
-          throw new SyntaxError("unterminated key");
         skip();
         let entry;
-        if (text[pos] === ":") {
+        if (text.charAt(pos) === ":") {
           pos += 1;
           skip();
-          entry = text[pos] === "," || text[pos] === "}" ? undefined : value();
+          entry = text.charAt(pos) === "," || text.charAt(pos) === "}" ? undefined : value();
         }
         if (key.length > 0)
           record[key] = entry;
         skip();
-        if (text[pos] === ",")
+        if (text.charAt(pos) === ",")
           pos += 1;
-        else if (text[pos] !== "}")
-          throw new SyntaxError("expected , or }");
+        else if (text.charAt(pos) !== "}")
+          throw new SyntaxError;
       }
     }
-    const raw = scalar(",]}");
-    if (raw === undefined)
-      throw new SyntaxError("unterminated scalar");
-    return raw;
+    return scalar(",]}");
   };
   try {
     const parsed = value();
     return { value: parsed, end: pos };
-  } catch {
-    return;
-  }
+  } catch {}
+  return;
 }
 function opensFlow(raw) {
-  const value = raw.trim();
-  return value.startsWith("[") || value.startsWith("{");
+  return raw.startsWith("[") || raw.startsWith("{");
 }
 var keyValue = /^([A-Za-z0-9_"'-][^:]*?):(?:\s+(.*))?$/;
 function completeFlowValue(raw) {
@@ -335,7 +339,7 @@ function completeFlowValue(raw) {
   return rest.length === 0 || rest.startsWith("#") ? parsed : undefined;
 }
 function parseScalarOrFlow(raw) {
-  if (raw === undefined || raw.trim().length === 0)
+  if (!raw)
     return;
   return completeFlowValue(raw)?.value ?? unquote(raw);
 }
@@ -349,32 +353,27 @@ function flowRecords(text, start) {
   const parsed = parseFlow(text, start);
   if (!Array.isArray(parsed?.value))
     return;
-  return parsed.value.filter((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+  return parsed.value.filter((item) => typeof item === "object" && !Array.isArray(item));
 }
 function scanFlowSection(text, sectionKey) {
-  const escapedKey = sectionKey.replaceAll(/[.*+?^$(){}|[\]\\]/g, "\\$&");
-  const header = new RegExp(`^${escapedKey}:[ \\t]*(\\[)?`);
+  const header = new RegExp(`^${sectionKey}:[ \\t]*(\\[)?`);
   let offset = 0;
   let first = true;
   let afterHeader = false;
   for (const piece of text.split(/(\r?\n)/)) {
     const content = piece.trim();
-    const indent = piece.length - piece.trimStart().length;
     if (content.length > 0 && !content.startsWith("#")) {
-      if (afterHeader) {
-        return content.startsWith("[") ? flowRecords(text, offset + piece.indexOf("[")) : undefined;
-      }
-      if (first && content.startsWith("[")) {
-        return flowRecords(text, offset + piece.indexOf("["));
-      }
+      const bracket = offset + piece.indexOf("[");
+      if ((first || afterHeader) && content.startsWith("["))
+        return flowRecords(text, bracket);
+      if (afterHeader)
+        return;
       first = false;
-      if (indent === 0) {
-        const match = header.exec(piece);
-        if (match) {
-          if (match[1] !== undefined)
-            return flowRecords(text, offset + piece.indexOf("["));
-          afterHeader = true;
-        }
+      const match = header.exec(piece);
+      if (match) {
+        if (match[1] !== undefined)
+          return flowRecords(text, bracket);
+        afterHeader = true;
       }
     }
     offset += piece.length;
@@ -386,123 +385,96 @@ function scanRecordSequence(text, sectionKey) {
   if (flowSection !== undefined)
     return flowSection;
   const records = [];
-  let itemIndent;
-  let keyIndent = 0;
-  let current;
+  let item;
   let listKey;
   let listItem;
-  let section = "root";
+  let otherSection = false;
   let pendingFlow;
+  const assign = (target, key, raw, recordIndent) => {
+    if (raw !== undefined && unbalancedFlow(raw)) {
+      pendingFlow = { target, key, first: raw, text: raw, recordIndent };
+      return false;
+    }
+    const value = parseScalarOrFlow(raw);
+    if (value === undefined)
+      return true;
+    target[key] = value;
+    return false;
+  };
   for (const rawLine of text.split(/\r?\n/)) {
     const content = rawLine.trim();
     if (content.length === 0 || content.startsWith("#"))
       continue;
     const indent = rawLine.length - rawLine.trimStart().length;
     const dash = /^(\s*)-(\s+)(.*)$/.exec(rawLine);
-    if (pendingFlow !== undefined && current !== undefined) {
-      const target = pendingFlow.onListItem && listItem !== undefined ? listItem : current;
-      if (indent > (itemIndent ?? 0) && !(dash && indent === itemIndent)) {
+    if (pendingFlow !== undefined) {
+      if (indent > pendingFlow.recordIndent) {
         pendingFlow.text += `
 ${content}`;
         const parsed = parseFlow(pendingFlow.text);
         if (parsed === undefined)
           continue;
-        target[pendingFlow.key] = parsed.value;
+        pendingFlow.target[pendingFlow.key] = parsed.value;
         pendingFlow = undefined;
         continue;
       }
-      target[pendingFlow.key] = unquote(pendingFlow.first);
+      pendingFlow.target[pendingFlow.key] = unquote(pendingFlow.first);
       pendingFlow = undefined;
     }
     if (indent === 0 && !dash) {
       const pair = keyValue.exec(content);
-      section = pair?.[1] !== undefined && unquote(pair[1]) === sectionKey ? "records" : "other";
-      current = undefined;
-      itemIndent = undefined;
+      otherSection = pair === null || unquote(pair[1]) !== sectionKey;
+      item = undefined;
       continue;
     }
-    if (section === "other")
+    if (otherSection)
       continue;
-    if (dash && (itemIndent === undefined || indent === itemIndent)) {
-      itemIndent = indent;
-      keyIndent = (dash[1]?.length ?? 0) + 1 + (dash[2]?.length ?? 1);
-      current = {};
-      records.push(current);
+    if (dash && (item === undefined || indent === item.indent)) {
+      const rest = dash[3];
+      item = { record: {}, indent, keyIndent: rawLine.length - rest.length };
+      records.push(item.record);
       listKey = undefined;
       listItem = undefined;
-      const pair = keyValue.exec(dash[3] ?? "");
-      if (pair?.[1] !== undefined) {
+      const pair = keyValue.exec(rest);
+      if (pair !== null) {
         const key = unquote(pair[1]);
-        if (pair[2] !== undefined && unbalancedFlow(pair[2])) {
-          pendingFlow = {
-            key,
-            first: pair[2],
-            text: pair[2],
-            onListItem: false
-          };
-          continue;
-        }
-        const value = parseScalarOrFlow(pair[2]);
-        if (value !== undefined)
-          current[key] = value;
-        else
+        if (assign(item.record, key, pair[2], indent))
           listKey = key;
       }
       continue;
     }
-    if (current === undefined || itemIndent === undefined)
-      continue;
-    if (indent <= itemIndent)
+    if (item === undefined || indent <= item.indent)
       continue;
     if (dash) {
       if (listKey === undefined)
         continue;
-      const list = Array.isArray(current[listKey]) ? current[listKey] : [];
-      current[listKey] = list;
-      const item = dash[3] ?? "";
-      const flowItem = completeFlowValue(item);
-      const pair = flowItem === undefined ? keyValue.exec(item) : null;
+      const list = Array.isArray(item.record[listKey]) ? item.record[listKey] : [];
+      item.record[listKey] = list;
+      const rest = dash[3];
+      const flowItem = completeFlowValue(rest);
+      listItem = undefined;
       if (flowItem !== undefined) {
-        listItem = undefined;
         list.push(flowItem.value);
-      } else if (pair?.[1] !== undefined && pair[2] !== undefined) {
+        continue;
+      }
+      const pair = keyValue.exec(rest);
+      if (pair?.[2] !== undefined) {
         listItem = { [unquote(pair[1])]: parseScalarOrFlow(pair[2]) };
         list.push(listItem);
       } else {
-        listItem = undefined;
-        list.push(unquote(item));
+        list.push(unquote(rest));
       }
       continue;
     }
     const pair = keyValue.exec(content);
-    if (pair?.[1] === undefined)
+    if (pair === null)
       continue;
     const key = unquote(pair[1]);
-    if (indent === keyIndent) {
+    if (indent === item.keyIndent) {
       listItem = undefined;
-      if (pair[2] !== undefined && unbalancedFlow(pair[2])) {
-        pendingFlow = {
-          key,
-          first: pair[2],
-          text: pair[2],
-          onListItem: false
-        };
-        listKey = undefined;
-        continue;
-      }
-      const value = parseScalarOrFlow(pair[2]);
-      if (value === undefined) {
-        listKey = key;
-      } else {
-        current[key] = value;
-        listKey = undefined;
-      }
-    } else if (listItem !== undefined && pair[2] !== undefined) {
-      if (unbalancedFlow(pair[2])) {
-        pendingFlow = { key, first: pair[2], text: pair[2], onListItem: true };
-        continue;
-      }
-      listItem[key] = parseScalarOrFlow(pair[2]);
+      listKey = assign(item.record, key, pair[2], item.indent) ? key : undefined;
+    } else if (listItem !== undefined) {
+      assign(listItem, key, pair[2], item.indent);
     }
   }
   return records;
@@ -510,49 +482,43 @@ ${content}`;
 function scanSymbolCoordinates(text) {
   const coordinates = {};
   let inCoordinates = false;
-  let idIndent;
-  let currentId;
+  let current;
   for (const rawLine of text.split(/\r?\n/)) {
-    const content = rawLine.trim();
-    if (content.length === 0 || content.startsWith("#"))
+    const pair = keyValue.exec(rawLine.trim());
+    if (pair === null)
       continue;
     const indent = rawLine.length - rawLine.trimStart().length;
-    const pair = keyValue.exec(content);
-    if (pair?.[1] === undefined)
-      continue;
     const key = unquote(pair[1]);
     if (indent === 0) {
       inCoordinates = key === "coordinates";
-      idIndent = undefined;
-      currentId = undefined;
+      current = undefined;
       continue;
     }
     if (!inCoordinates)
       continue;
-    if (idIndent === undefined || indent === idIndent) {
-      idIndent = indent;
-      currentId = key;
-      coordinates[currentId] ??= {};
+    if (current !== undefined && indent < current.indent)
+      continue;
+    if (current === undefined || indent === current.indent) {
+      coordinates[key] ??= {};
+      current = { indent, entry: coordinates[key] };
       continue;
     }
-    if (currentId === undefined || indent < idIndent)
+    if (pair[2] === undefined)
       continue;
-    const entry = coordinates[currentId] ?? {};
+    const value = unquote(pair[2]);
     if (key === "sourceFile") {
-      const sourceFile = normalizeSourceFile(unquote(pair[2] ?? ""));
+      const sourceFile = normalizeSourceFile(value);
       if (sourceFile.length > 0)
-        entry.sourceFile = sourceFile;
-      coordinates[currentId] = entry;
+        current.entry.sourceFile = sourceFile;
       continue;
     }
-    const numeric = Number.parseInt(unquote(pair[2] ?? ""), 10);
+    const numeric = Number.parseInt(value, 10);
     if (!Number.isFinite(numeric))
       continue;
     if (key === "sourceLine")
-      entry.line = numeric;
+      current.entry.line = numeric;
     if (key === "sourceEndLine")
-      entry.endLine = numeric;
-    coordinates[currentId] = entry;
+      current.entry.endLine = numeric;
   }
   return coordinates;
 }
@@ -599,7 +565,19 @@ function buildKnowledgeIndex(records, coordinates = {}, options = {}, manifest =
       coveredBy: [],
       executableFor: []
     };
-    const relationships = [];
+    const relate = (type, target) => {
+      if (type === "implements")
+        pushUnique(symbol.implements, target);
+      else if (type === "covered_by")
+        pushUnique(symbol.coveredBy, target);
+      else if (type === "executable_for")
+        pushUnique(symbol.executableFor, target);
+    };
+    const relateTyped = (relation) => {
+      const typed = relation ?? {};
+      if (typeof typed.target === "string")
+        relate(typed.type, typed.target);
+    };
     if (options.legacyLinksAsImplements !== false) {
       let links = [];
       if (typeof record.links === "string")
@@ -607,31 +585,15 @@ function buildKnowledgeIndex(records, coordinates = {}, options = {}, manifest =
       else if (Array.isArray(record.links))
         links = record.links;
       for (const link of links) {
-        if (typeof link === "string") {
-          relationships.push({ type: "implements", target: link });
-        } else if (link !== null && typeof link === "object") {
-          const typed = link;
-          if (typeof typed.type === "string" && typeof typed.target === "string") {
-            relationships.push({ type: typed.type, target: typed.target });
-          }
-        }
+        if (typeof link === "string")
+          relate("implements", link);
+        else
+          relateTyped(link);
       }
     }
-    for (const relation of Array.isArray(record.relationships) ? record.relationships : []) {
-      if (relation === null || typeof relation !== "object")
-        continue;
-      const typed = relation;
-      if (typeof typed.type === "string" && typeof typed.target === "string")
-        relationships.push({ type: typed.type, target: typed.target });
-    }
-    for (const { type, target } of relationships) {
-      if (type === "implements")
-        pushUnique(symbol.implements, target);
-      else if (type === "covered_by")
-        pushUnique(symbol.coveredBy, target);
-      else if (type === "executable_for")
-        pushUnique(symbol.executableFor, target);
-    }
+    if (Array.isArray(record.relationships))
+      for (const relation of record.relationships)
+        relateTyped(relation);
     if (symbol.implements.length + symbol.coveredBy.length + symbol.executableFor.length === 0) {
       continue;
     }
@@ -650,7 +612,7 @@ function buildKnowledgeIndex(records, coordinates = {}, options = {}, manifest =
 }
 function fileSignature(filePath) {
   try {
-    const stats = fs.statSync(filePath);
+    const stats = fs2.statSync(filePath);
     return `${stats.size}:${stats.mtimeMs}`;
   } catch {
     return "missing";
@@ -658,41 +620,45 @@ function fileSignature(filePath) {
 }
 function readText(filePath) {
   try {
-    return fs.readFileSync(filePath, "utf8");
-  } catch {
-    return;
-  }
+    return fs2.readFileSync(filePath, "utf8");
+  } catch {}
+  return;
 }
 function writeCacheAtomically(cachePath, payload) {
   try {
-    fs.mkdirSync(path2.dirname(cachePath), { recursive: true });
+    fs2.mkdirSync(path3.dirname(cachePath), { recursive: true });
     const temporary = `${cachePath}.${process.pid}.${randomUUID()}.tmp`;
-    fs.writeFileSync(temporary, payload);
-    fs.renameSync(temporary, cachePath);
+    fs2.writeFileSync(temporary, payload);
+    fs2.renameSync(temporary, cachePath);
+  } catch {}
+}
+function readCachedIndex(cachePath, signature) {
+  try {
+    const parsed = JSON.parse(String(fs2.readFileSync(cachePath)));
+    if (parsed.signature === signature && parsed.index)
+      return parsed.index;
   } catch {}
+  return;
+}
+function scanKnowledgeIndex(symbolsPath, coordinatesPath, options) {
+  const symbolsText = readText(symbolsPath);
+  const coordinatesText = readText(coordinatesPath);
+  const records = symbolsText === undefined ? [] : scanSymbolsManifest(symbolsText);
+  return buildKnowledgeIndex(records, coordinatesText === undefined ? {} : scanSymbolCoordinates(coordinatesText), options, manifestStateOf(symbolsText, records.length));
 }
 function loadKnowledgeIndex(workspaceRoot, cacheDir, options = {}) {
-  const symbolsPath = path2.join(workspaceRoot, SYMBOLS_MANIFEST);
-  const coordinatesPath = path2.join(workspaceRoot, SYMBOL_COORDINATES);
+  const symbolsPath = path3.join(workspaceRoot, SYMBOLS_MANIFEST);
+  const coordinatesPath = path3.join(workspaceRoot, SYMBOL_COORDINATES);
+  if (!cacheDir)
+    return scanKnowledgeIndex(symbolsPath, coordinatesPath, options);
   const legacyMode = options.legacyLinksAsImplements === false ? "typed" : "legacy";
   const signature = `${INDEX_FORMAT}|${legacyMode}|${fileSignature(symbolsPath)}|${fileSignature(coordinatesPath)}`;
-  const cachePath = cacheDir ? path2.join(cacheDir, options.cacheFileName ?? CACHE_FILE) : undefined;
-  if (cachePath) {
-    const cached = readText(cachePath);
-    if (cached !== undefined) {
-      try {
-        const parsed = JSON.parse(cached);
-        if (parsed.signature === signature && parsed.index)
-          return parsed.index;
-      } catch {}
-    }
-  }
-  const symbolsText = readText(symbolsPath);
-  const records = symbolsText === undefined ? [] : scanSymbolsManifest(symbolsText);
-  const index = buildKnowledgeIndex(records, scanSymbolCoordinates(readText(coordinatesPath) ?? ""), options, manifestStateOf(symbolsText, records.length));
-  if (cachePath) {
-    writeCacheAtomically(cachePath, JSON.stringify({ signature, index }));
-  }
+  const cachePath = path3.join(cacheDir, options.cacheFileName ?? CACHE_FILE);
+  const cached = readCachedIndex(cachePath, signature);
+  if (cached !== undefined)
+    return cached;
+  const index = scanKnowledgeIndex(symbolsPath, coordinatesPath, options);
+  writeCacheAtomically(cachePath, JSON.stringify({ signature, index }));
   return index;
 }
 var ENTITY_LANES = [
@@ -724,8 +690,7 @@ function readScalar(lines, index, raw) {
   const block = /^[>|][+-]?$/.test(raw.trim());
   const parts = block ? [] : [raw.trim()];
   let last = index;
-  while (last + 1 < lines.length) {
-    const next = lines[last + 1] ?? "";
+  for (const next of lines.slice(index + 1)) {
     if (next.trim() === "---" || !/^\s+\S/.test(next))
       break;
     if (!block && /^\s+-\s/.test(next))
@@ -733,7 +698,7 @@ function readScalar(lines, index, raw) {
     parts.push(next.trim());
     last += 1;
   }
-  const joined = parts.join(" ").trim();
+  const joined = parts.join(" ");
   return { value: block ? joined : unquote(joined), last };
 }
 function firstParagraph(lines) {
@@ -752,33 +717,30 @@ function firstParagraph(lines) {
     }
     paragraph.push(text);
   }
-  return paragraph.length > 0 ? paragraph.join(" ") : undefined;
+  return paragraph.join(" ");
 }
 var MAX_SUMMARY_LINKS = 24;
 var RELATIONSHIPS_DIR = ".kb/relationships";
 var shardCache = new Map;
 function shardPathFor(workspaceRoot, entityId) {
   const shard = createHash("sha256").update(entityId).digest("hex");
-  return path2.join(workspaceRoot, RELATIONSHIPS_DIR, `${shard.slice(0, 2)}.yaml`);
+  return path3.join(workspaceRoot, RELATIONSHIPS_DIR, `${shard.slice(0, 2)}.yaml`);
 }
 function shardLinksFrom(workspaceRoot, entityId) {
   const shardPath = shardPathFor(workspaceRoot, entityId);
   const signature = fileSignature(shardPath);
-  if (signature === "missing") {
-    shardCache.delete(shardPath);
-    return [];
-  }
   let cached = shardCache.get(shardPath);
   if (cached?.signature !== signature) {
     const byFrom = new Map;
-    const records = scanRecordSequence(readText(shardPath) ?? "", "relationships");
-    for (const { type, from, to } of records) {
-      if (typeof type !== "string" || typeof from !== "string" || typeof to !== "string") {
-        continue;
+    const text = readText(shardPath);
+    if (text !== undefined) {
+      for (const { type, from, to } of scanRecordSequence(text, "relationships")) {
+        if (typeof type !== "string" || typeof to !== "string")
+          continue;
+        const list = byFrom.get(from) ?? [];
+        list.push({ type, target: to });
+        byFrom.set(from, list);
       }
-      const list = byFrom.get(from) ?? [];
-      list.push({ type, target: to });
-      byFrom.set(from, list);
     }
     cached = { signature, byFrom };
     shardCache.set(shardPath, cached);
@@ -798,19 +760,19 @@ function readEntitySummary(workspaceRoot, entityId) {
     return { id: entityId };
   let head;
   try {
-    const descriptor = fs.openSync(path2.join(workspaceRoot, ".kb", lane[1], `${entityId}.md`), "r");
+    const descriptor = fs2.openSync(path3.join(workspaceRoot, ".kb", lane[1], `${entityId}.md`), "r");
     try {
       const buffer = Buffer.alloc(8192);
-      const bytes = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+      const bytes = fs2.readSync(descriptor, buffer, 0, buffer.length, 0);
       head = buffer.subarray(0, bytes).toString("utf8");
     } finally {
-      fs.closeSync(descriptor);
+      fs2.closeSync(descriptor);
     }
   } catch {
     return { id: entityId };
   }
   const lines = head.split(/\r?\n/);
-  if (lines[0]?.trim() !== "---")
+  if (lines[0].trim() !== "---")
     return { id: entityId };
   const summary = { id: entityId };
   const authored = [];
@@ -824,20 +786,20 @@ function readEntitySummary(workspaceRoot, entityId) {
   let bodyStart = lines.length;
   let pending;
   for (let index = 1;index < lines.length; index += 1) {
-    const line = lines[index] ?? "";
+    const line = lines[index];
     if (line.trim() === "---") {
       closed = true;
       bodyStart = index + 1;
       break;
     }
-    const scalar = /^([a-z_]+):\s*(.*)$/.exec(line);
-    const scalarField = scalar ? SUMMARY_SCALARS[scalar[1] ?? ""] : undefined;
+    const scalar = /^([a-z_]+):\s*(.*)/.exec(line);
+    const scalarField = scalar ? SUMMARY_SCALARS[scalar[1]] : undefined;
     if (scalar && scalarField && scalar[2]) {
       const { value, last } = readScalar(lines, index, scalar[2]);
       if (value !== "") {
         if (scalarField === "statement")
           summary.statement = value;
-        else if (scalarField !== "values")
+        else
           claim[scalarField] = value;
       }
       index = last;
@@ -847,19 +809,19 @@ function readEntitySummary(workspaceRoot, entityId) {
       inValueSet = false;
       continue;
     }
-    if (scalar && SCALAR_VALUE_FIELDS.has(scalar[1] ?? "") && scalar[2]) {
+    if (scalar && SCALAR_VALUE_FIELDS.has(scalar[1]) && scalar[2]) {
       values.push(unquote(scalar[2]));
     }
     const flowSet = /^value_set:\s*\[(.*)\]\s*$/.exec(line);
-    if (flowSet?.[1]?.trim()) {
+    if (flowSet !== null && flowSet[1].trim()) {
       values.push(...flowSet[1].split(",").map((member) => unquote(member)));
     }
     if (/^\S/.test(line))
       inValueSet = /^value_set:\s*$/.test(line);
     else if (inValueSet) {
-      const member = /^\s*-\s*(.+)$/.exec(line);
+      const member = /^\s*-\s*(.+)/.exec(line);
       if (member)
-        values.push(unquote(member[1] ?? ""));
+        values.push(unquote(member[1]));
     }
     const flowOrigin = /^origin:\s*\{.*\bkind:\s*["']?([a-z]+)/.exec(line);
     if (flowOrigin)
@@ -869,7 +831,7 @@ function readEntitySummary(workspaceRoot, entityId) {
       originKind = nestedKind[1];
     if (/^\S/.test(line))
       inOrigin = /^origin:\s*$/.test(line);
-    const match = /^(title|status|firmness):\s*(.*)$/.exec(line);
+    const match = /^(title|status|firmness):\s*(.*)/.exec(line);
     if (match?.[1] === "title" && match[2])
       summary.title = unquote(match[2]);
     if (match?.[1] === "status" && match[2])
@@ -884,19 +846,19 @@ function readEntitySummary(workspaceRoot, entityId) {
     }
     if (!inLinks)
       continue;
-    const entry = /^\s*-\s*(.*)$/.exec(line);
+    const entry = /^\s*-\s*(.*)/.exec(line);
     if (entry) {
       flushLink(authored, pending);
       pending = {};
     }
     if (!pending)
       continue;
-    const body = (entry ? entry[1] ?? "" : line).trim();
-    const field = /^(type|target):\s*(.+)$/.exec(body);
+    const body = (entry ? entry[1] : line).trim();
+    const field = /^(type|target):\s*(.+)/.exec(body);
     if (field?.[1] === "type")
-      pending.type = unquote(field[2] ?? "");
+      pending.type = unquote(field[2]);
     else if (field?.[1] === "target")
-      pending.target = unquote(field[2] ?? "");
+      pending.target = unquote(field[2]);
     else if (entry && SAFE_ENTITY_ID.test(unquote(body)))
       pending.bare = unquote(body);
   }
@@ -944,45 +906,28 @@ function truncate(text, limit) {
   return text.length <= limit ? text : `${text.slice(0, limit - 1)}…`;
 }
 function overlaps(symbol, range) {
-  if (symbol.line === undefined)
-    return false;
-  const end = symbol.endLine ?? symbol.line;
-  return symbol.line <= range.end && end >= range.start;
+  const line = Number(symbol.line);
+  return line <= range.end && Number(symbol.endLine ?? line) >= range.start;
+}
+function span(symbol) {
+  return Number(symbol.endLine ?? symbol.line) - Number(symbol.line);
 }
 function focusedSymbols(symbols, focus) {
-  if (!focus || focus.length === 0)
+  if (!focus)
     return [];
-  return symbols.filter((symbol) => focus.some((range) => overlaps(symbol, range))).sort((left, right) => (left.endLine ?? left.line ?? 0) - (left.line ?? 0) - ((right.endLine ?? right.line ?? 0) - (right.line ?? 0)));
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return symbols.filter((symbol) => focus.some((range) => overlaps(symbol, range))).sort((left, right) => span(left) - span(right));
 }
 function editFocus(absolutePath, toolInput) {
-  if (!isRecord(toolInput))
-    return;
-  const needles = [];
-  const collect = (record) => {
-    for (const key of ["old_string", "oldString"]) {
-      const value = record[key];
-      if (typeof value === "string")
-        needles.push(value);
-    }
-  };
-  collect(toolInput);
-  if (Array.isArray(toolInput.edits)) {
-    for (const edit of toolInput.edits) {
-      if (isRecord(edit))
-        collect(edit);
-    }
-  }
-  const usable = needles.filter((needle) => needle.length > 0);
+  const input = toolInput ?? {};
+  const edits = Array.isArray(input.edits) ? input.edits : [];
+  const usable = [input, ...edits.map((edit) => edit ?? {})].flatMap((record) => [record.old_string, record.oldString]).filter((needle) => typeof needle === "string" && needle.length > 0);
   if (usable.length === 0)
     return;
   let content;
   try {
-    if (fs2.statSync(absolutePath).size > MAX_FOCUS_SCAN_BYTES)
+    if (fs3.statSync(absolutePath).size > MAX_FOCUS_SCAN_BYTES)
       return;
-    content = fs2.readFileSync(absolutePath, "utf8");
+    content = fs3.readFileSync(absolutePath, "utf8");
   } catch {
     return;
   }
@@ -1004,7 +949,7 @@ function formatList(items, limit) {
 }
 var RETIRED_STATUS = /supersed|deprecat|reject|obsolete|retired/i;
 function isRetiredStatus(status) {
-  return status !== undefined && RETIRED_STATUS.test(status);
+  return RETIRED_STATUS.test(String(status));
 }
 function describeEntity(summary) {
   const retired = isRetiredStatus(summary.status) ? ` (${summary.status})` : "";
@@ -1021,7 +966,7 @@ function displayTitle(summary) {
   if (!/^\.\S/.test(rest))
     return title;
   const end = rest.search(/[.!?](?:\s|$)/);
-  return end < 0 ? statement : statement.slice(0, title.length + end);
+  return end === -1 ? statement : statement.slice(0, title.length + end);
 }
 function jsonString(value) {
   return JSON.stringify(value);
@@ -1055,13 +1000,13 @@ var OPERATOR_PHRASES = {
   excludes: "must not include"
 };
 function joinMembers(values, conjunction) {
-  if (values.length <= 1)
-    return values[0] ?? "";
+  if (values.length === 1)
+    return values[0];
   return `${values.slice(0, -1).join(", ")} ${conjunction} ${values.at(-1)}`;
 }
 var MODAL = /^(.{1,100}?)\s+(?:must|may|can|cannot|should|shall|will|never)\b/i;
 function subjectPhrase(claim) {
-  const spoken = MODAL.exec(claim.claimText ?? "")?.[1];
+  const spoken = MODAL.exec(String(claim.claimText))?.[1];
   if (spoken)
     return spoken;
   return claim.subjectKey?.replace(/[._]+/g, " ").trim() || undefined;
@@ -1146,10 +1091,7 @@ function createEntitySummarizer(workspaceRoot) {
 }
 function requirementOwners(symbols, focus) {
   const owners = new Map;
-  const ordered = [
-    ...focus,
-    ...symbols.filter((symbol) => !focus.includes(symbol))
-  ];
+  const ordered = new Set([...focus, ...symbols]);
   for (const symbol of ordered) {
     for (const requirement of symbol.implements) {
       const titles = owners.get(requirement) ?? [];
@@ -1161,7 +1103,7 @@ function requirementOwners(symbols, focus) {
   const focusOwners = new Set(focus.flatMap((symbol) => symbol.implements));
   const requirementIds = [...owners.keys()].sort((left, right) => {
     const focusOrder = Number(focusOwners.has(right)) - Number(focusOwners.has(left));
-    return focusOrder !== 0 ? focusOrder : (owners.get(right)?.length ?? 0) - (owners.get(left)?.length ?? 0);
+    return focusOrder !== 0 ? focusOrder : owners.get(right).length - owners.get(left).length;
   });
   return { owners, requirementIds };
 }
@@ -1182,7 +1124,7 @@ function fileKnowledgeSnippet(input) {
     `Kibi knowledge for ${relativePath} (symbol manifest):`
   ];
   for (const requirementId of requirementIds.slice(0, MAX_REQUIREMENTS)) {
-    const symbolTitles = owners.get(requirementId) ?? [];
+    const symbolTitles = owners.get(requirementId);
     lines.push(`- ${describeEntity(summarize(requirementId))} — ${formatList(symbolTitles, MAX_SYMBOLS_PER_REQUIREMENT)}`);
   }
   if (requirementIds.length > MAX_REQUIREMENTS) {
@@ -1263,32 +1205,39 @@ function firmEditNotice(where, requirements) {
 }
 function sessionPath(session, name) {
   if (!session.stateDir)
-    return;
+    throw new Error;
   const key = createHash2("sha256").update(session.sessionId?.trim() || "unattributed").digest("hex").slice(0, 32);
-  return path3.join(session.stateDir, "decision-guard", key, name);
+  return path4.join(session.stateDir, "decision-guard", key, name);
 }
-function writeMarker(file, content, flag) {
-  fs3.mkdirSync(path3.dirname(file), { recursive: true });
-  fs3.writeFileSync(file, content, { flag });
+function writeMarker(file, content) {
+  fs4.mkdirSync(path4.dirname(file), { recursive: true });
+  fs4.writeFileSync(file, content);
+}
+function touchMarker(file, flag) {
+  fs4.mkdirSync(path4.dirname(file), { recursive: true });
+  fs4.closeSync(fs4.openSync(file, flag));
+}
+function readMarker(session, name) {
+  return JSON.parse(String(fs4.readFileSync(sessionPath(session, name))));
+}
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function markDecisionFlag(session, flag) {
-  const file = sessionPath(session, flag);
-  if (!file)
-    return;
   try {
-    writeMarker(file, "", "w");
+    touchMarker(sessionPath(session, flag), "w");
   } catch {}
 }
 function hasDecisionFlag(session, flag) {
-  const file = sessionPath(session, flag);
-  return file !== undefined && fs3.existsSync(file);
+  try {
+    return fs4.existsSync(sessionPath(session, flag));
+  } catch {
+    return false;
+  }
 }
 function claimDecisionFlag(session, flag) {
-  const file = sessionPath(session, flag);
-  if (!file)
-    return false;
   try {
-    writeMarker(file, "", "wx");
+    touchMarker(sessionPath(session, flag), "wx");
     return true;
   } catch {
     return false;
@@ -1296,12 +1245,9 @@ function claimDecisionFlag(session, flag) {
 }
 function recordRequest(session, prompt) {
   const rule = statedRule(prompt);
-  const file = sessionPath(session, "request-words.json");
-  if (file) {
-    try {
-      writeMarker(file, JSON.stringify(requestTopicWords(prompt)), "w");
-    } catch {}
-  }
+  try {
+    writeMarker(sessionPath(session, "request-words.json"), JSON.stringify(requestTopicWords(prompt)));
+  } catch {}
   if (rule !== undefined)
     markDecisionFlag(session, "rule-prompt");
   return rule;
@@ -1309,9 +1255,9 @@ function recordRequest(session, prompt) {
 function claimCaptureReminder(session) {
   return hasDecisionFlag(session, "source-edited") && !hasDecisionFlag(session, "kb-recorded") && claimDecisionFlag(session, "capture-asked");
 }
-var SIGNOFF_LATEST_JSON = path3.join(".kb", "briefs", "signoff", "latest.json");
+var SIGNOFF_LATEST_JSON = path4.join(".kb", "briefs", "signoff", "latest.json");
 function record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+  return typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
 function isRequirementUpsert(toolInput) {
   const input = record(toolInput);
@@ -1319,20 +1265,18 @@ function isRequirementUpsert(toolInput) {
   return args?.type === "req" && args.dryRun !== true;
 }
 function mtimeMs(file) {
-  if (!file)
-    return;
+  let time = Number.NaN;
   try {
-    return fs3.statSync(file).mtimeMs;
-  } catch {
-    return;
-  }
+    time = fs4.statSync(file()).mtimeMs;
+  } catch {}
+  return time;
 }
 function claimSignoffReminder(session, workspaceRoot) {
-  const recorded = mtimeMs(sessionPath(session, "requirement-recorded"));
-  if (recorded === undefined)
+  const recorded = mtimeMs(() => sessionPath(session, "requirement-recorded"));
+  if (Number.isNaN(recorded))
     return false;
-  const shown = mtimeMs(path3.join(workspaceRoot, SIGNOFF_LATEST_JSON));
-  if (shown !== undefined && shown >= recorded)
+  const shown = mtimeMs(() => path4.join(workspaceRoot, SIGNOFF_LATEST_JSON));
+  if (shown >= recorded)
     return false;
   return claimDecisionFlag(session, "signoff-asked");
 }
@@ -1343,55 +1287,43 @@ function signoffReminder() {
   ].join(`
 `);
 }
-function readSettled(file) {
-  if (!file)
-    return [];
+function readSettled(session) {
   try {
-    const parsed = JSON.parse(fs3.readFileSync(file, "utf8"));
-    return Array.isArray(parsed) ? parsed.filter((id) => typeof id === "string") : [];
+    return stringList(readMarker(session, "firm-settled.json"));
   } catch {
     return [];
   }
 }
 function settledFirmRequirements(session) {
-  return new Set(readSettled(sessionPath(session, "firm-settled.json")));
+  return new Set(readSettled(session));
 }
 function settleFirmRequirements(session, ids) {
-  const file = sessionPath(session, "firm-settled.json");
-  if (!file)
-    return;
   try {
-    writeMarker(file, JSON.stringify([...new Set([...readSettled(file), ...ids])]), "w");
+    writeMarker(sessionPath(session, "firm-settled.json"), JSON.stringify([...new Set([...readSettled(session), ...ids])]));
   } catch {}
 }
 function holdRuleNote(session, phrase) {
-  const file = sessionPath(session, "rule-note");
-  if (!file)
-    return;
   try {
-    writeMarker(file, rulePromptNote(phrase), "w");
+    writeMarker(sessionPath(session, "rule-note"), rulePromptNote(phrase));
   } catch {}
 }
 function takeRuleNote(session) {
-  const file = sessionPath(session, "rule-note");
-  if (!file)
-    return;
+  let note = "";
   try {
-    const note = fs3.readFileSync(file, "utf8");
-    fs3.rmSync(file, { force: true });
-    return note || undefined;
-  } catch {
-    return;
-  }
+    const file = sessionPath(session, "rule-note");
+    note = String(fs4.readFileSync(file));
+    fs4.rmSync(file);
+  } catch {}
+  return note || undefined;
 }
 
 // ../agent-core/dist/hook-usage-log.js
-import { randomUUID as randomUUID3 } from "node:crypto";
-import fs5 from "node:fs";
-import path6 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import fs7 from "node:fs";
+import path8 from "node:path";
 
 // ../agent-core/dist/kb-mcp-tools.js
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readString(record, keys) {
@@ -1425,33 +1357,33 @@ function readStringArray(record, keys) {
 function readRecord(record, keys) {
   for (const key of keys) {
     const value = record[key];
-    if (isRecord2(value)) {
+    if (isRecord(value)) {
       return value;
     }
   }
   return;
 }
 function canonicalKbToolName(toolName) {
-  const trimmed = toolName?.trim() ?? "";
-  const lastSegment = trimmed.includes("__") ? trimmed.split("__").at(-1) ?? "" : trimmed.replace(/^MCP:/i, "");
+  const trimmed = String(toolName).trim();
+  const lastSegment = trimmed.includes("__") ? trimmed.split("__").at(-1) : trimmed.replace(/^MCP:/i, "");
   const operation = lastSegment.replace(/^kibi_/, "");
   return operation.startsWith("kb_") ? operation : undefined;
 }
 var KIBI_WORKSPACE_ARGUMENT = "workspaceRoot";
 function isKibiMcpToolName(toolName) {
-  const name = toolName?.trim() ?? "";
+  const name = String(toolName).trim();
   if (/^MCP:kb_[a-z_]+$/i.test(name))
     return true;
   const segments = name.split("__");
-  if (segments.length < 3 || segments[0] !== "mcp")
+  if (segments[0] !== "mcp")
     return false;
   const server = segments.slice(1, -1).join("__");
-  return /kibi/i.test(server) && /^kb_[a-z_]+$/.test(segments.at(-1) ?? "");
+  return /kibi/i.test(server) && /^kb_[a-z_]+$/.test(segments.at(-1));
 }
 function stampKibiWorkspace(toolName, toolInput, workspaceRoot) {
   if (!workspaceRoot || !isKibiMcpToolName(toolName))
     return;
-  const base = isRecord2(toolInput) ? toolInput : {};
+  const base = isRecord(toolInput) ? toolInput : {};
   return { ...base, [KIBI_WORKSPACE_ARGUMENT]: workspaceRoot };
 }
 function resolveKibiInterface(mcpState, workspaceTrusted) {
@@ -1460,58 +1392,31 @@ function resolveKibiInterface(mcpState, workspaceTrusted) {
   }
   return workspaceTrusted ? "cli" : "setup";
 }
+var TOOL_NAME_KEYS = ["toolName", "tool_name", "name"];
 function extractKbMcpToolCall(toolName, toolInput) {
-  let normalizedToolName = canonicalKbToolName(toolName);
-  if (isRecord2(toolInput)) {
-    normalizedToolName ??= readString(toolInput, [
-      "toolName",
-      "tool_name",
-      "name"
-    ]);
-    const args = readRecord(toolInput, ["arguments", "args"]);
-    const payload = args ?? toolInput;
-    const includeImpactDiagnostics = readBoolean(payload, [
+  const input = isRecord(toolInput) ? toolInput : {};
+  let name = canonicalKbToolName(toolName) ?? readString(input, TOOL_NAME_KEYS);
+  if (!name?.startsWith("kb_")) {
+    const nested = input.arguments ?? input.args;
+    const nestedTool = isRecord(nested) ? readString(nested, TOOL_NAME_KEYS) : undefined;
+    return nestedTool?.startsWith("kb_") ? { toolName: nestedTool, impactCheckRun: false, sourceFiles: [] } : undefined;
+  }
+  const payload = readRecord(input, ["arguments", "args"]) ?? input;
+  if (name === "kb_upsert" && readBoolean(payload, ["dryRun"]) === true) {
+    name = "kb_validate_upsert";
+  }
+  const sourceFiles = readStringArray(payload, ["sourceFiles", "source_files"]);
+  return {
+    toolName: name,
+    impactCheckRun: name === "kb_check" && readBoolean(payload, [
       "includeImpactDiagnostics",
       "include_impact_diagnostics"
-    ]);
-    const includeWorkingTreeDiff = readBoolean(payload, [
+    ]) === true && readBoolean(payload, [
       "includeWorkingTreeDiff",
       "include_working_tree_diff"
-    ]);
-    const sourceFiles = readStringArray(payload, [
-      "sourceFiles",
-      "source_files"
-    ]);
-    if (normalizedToolName === "kb_upsert" && readBoolean(payload, ["dryRun"]) === true) {
-      normalizedToolName = "kb_validate_upsert";
-    }
-    if (normalizedToolName?.startsWith("kb_")) {
-      return {
-        toolName: normalizedToolName,
-        impactCheckRun: normalizedToolName === "kb_check" && includeImpactDiagnostics === true && includeWorkingTreeDiff === true && sourceFiles.length > 0,
-        sourceFiles
-      };
-    }
-    const nestedArgs = toolInput.arguments ?? toolInput.args;
-    if (isRecord2(nestedArgs)) {
-      const nestedTool = readString(nestedArgs, [
-        "toolName",
-        "tool_name",
-        "name"
-      ]);
-      if (nestedTool?.startsWith("kb_")) {
-        return { toolName: nestedTool, impactCheckRun: false, sourceFiles: [] };
-      }
-    }
-  }
-  if (normalizedToolName?.startsWith("kb_")) {
-    return {
-      toolName: normalizedToolName,
-      impactCheckRun: false,
-      sourceFiles: []
-    };
-  }
-  return;
+    ]) === true && sourceFiles.length > 0,
+    sourceFiles
+  };
 }
 var KIBI_CLI_ROUTES = {
   check: "kb_check",
@@ -1535,16 +1440,16 @@ function kibiCliOperation(command) {
 var SHELL_TOOL_NAMES = new Set(["Bash", "bash", "Shell", "shell"]);
 function hostKbOperation(toolName, toolInput) {
   const mcp = canonicalKbToolName(toolName);
-  if (mcp !== undefined && /^kb_[a-z_]+$/.test(mcp))
+  if (/kb_[a-z_]+$/.test(String(mcp)))
     return mcp;
-  if (!toolName || !SHELL_TOOL_NAMES.has(toolName) || !isRecord2(toolInput)) {
+  if (!toolName || !SHELL_TOOL_NAMES.has(toolName) || !isRecord(toolInput)) {
     return;
   }
   return kibiCliOperation(toolInput.command);
 }
 
 // ../agent-core/dist/path-policy.js
-import path4 from "node:path";
+import path5 from "node:path";
 var codeExtensions = new Set([
   ".c",
   ".cc",
@@ -1629,7 +1534,7 @@ var explicitPathKeys = new Set([
   "relative_path",
   "target_path"
 ]);
-function isRecord3(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeWorkspacePath(candidate) {
@@ -1656,7 +1561,7 @@ function visitExplicitPathFields(value, output) {
       visitExplicitPathFields(item, output);
     return;
   }
-  if (!isRecord3(value))
+  if (!isRecord2(value))
     return;
   for (const [key, child] of Object.entries(value)) {
     if (explicitPathKeys.has(key.toLowerCase()))
@@ -1678,11 +1583,13 @@ function classifyPath(relativePath) {
   if (segments.some((segment) => documentationSegments.has(segment))) {
     return "other";
   }
-  const basename = segments.at(-1) ?? "";
-  const extension = path4.extname(basename).toLowerCase();
+  const basename = segments.at(-1);
+  if (basename === undefined)
+    return "other";
+  const extension = path5.extname(basename).toLowerCase();
   if (!codeExtensions.has(extension))
     return "other";
-  if (testBasename.test(basename) || segments.slice(0, -1).some((segment) => testSegments.has(segment))) {
+  if (testBasename.test(basename) || segments.some((segment) => testSegments.has(segment))) {
     return "test";
   }
   return "source";
@@ -1691,11 +1598,8 @@ function isKbPath(candidate) {
   return pathSegments(candidate).includes(".kb");
 }
 function isCanonicalKbKnowledgePath(segments) {
-  const kbIndex = segments.indexOf(".kb");
-  if (kbIndex < 0)
-    return false;
-  const lane = segments[kbIndex + 1];
-  return lane !== undefined && (canonicalKbKnowledgeFiles.has(lane) || canonicalKbKnowledgeLanes.has(lane));
+  const lane = segments[segments.indexOf(".kb") + 1];
+  return canonicalKbKnowledgeFiles.has(lane) || canonicalKbKnowledgeLanes.has(lane);
 }
 function isMeaningfulTrackedPath(candidate) {
   const segments = pathSegments(candidate);
@@ -1703,14 +1607,16 @@ function isMeaningfulTrackedPath(candidate) {
     return false;
   if (segments.includes(".kb"))
     return isCanonicalKbKnowledgePath(segments);
-  const basename = segments.at(-1) ?? "";
-  const extension = path4.extname(basename).toLowerCase();
+  const basename = segments.at(-1);
+  if (basename === undefined)
+    return false;
+  const extension = path5.extname(basename).toLowerCase();
   if (basename === "README.md")
     return true;
   if (segments.some((segment) => documentationSegments.has(segment))) {
     return documentationExtensions.has(extension);
   }
-  if (testBasename.test(basename) || segments.slice(0, -1).some((segment) => testSegments.has(segment))) {
+  if (testBasename.test(basename) || segments.some((segment) => testSegments.has(segment))) {
     return codeExtensions.has(extension) || documentationExtensions.has(extension);
   }
   return codeExtensions.has(extension);
@@ -1720,15 +1626,127 @@ function isSourceImpactRelevantPath(candidate) {
 }
 function isDocumentationTrackedPath(candidate) {
   const segments = pathSegments(candidate);
-  const basename = segments.at(-1) ?? "";
-  return basename === "README.md" || segments.some((segment) => documentationSegments.has(segment)) || documentationExtensions.has(path4.extname(basename).toLowerCase());
+  const basename = segments.at(-1);
+  if (basename === undefined)
+    return false;
+  return segments.some((segment) => documentationSegments.has(segment)) || documentationExtensions.has(path5.extname(basename).toLowerCase());
 }
 
-// ../agent-core/dist/usage-telemetry.js
+// ../agent-core/dist/telemetry-signals.js
 import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
-import fs4 from "node:fs";
+import fs5 from "node:fs";
+import path6 from "node:path";
+var RETRY_WINDOW_MS = 10 * 60 * 1000;
+var SEARCH_REPEAT_WINDOW_MS = 2 * 60 * 1000;
+var SKILL_WINDOW_MS = 30 * 60 * 1000;
+var MAX_RECENT_ENTRIES = 200;
+var RECENT_FILE = "telemetry-recent.json";
+var KIBI_SKILL_NAMES = new Set([
+  "kibi-bootstrap",
+  "kibi-commit-review",
+  "kibi-decisions",
+  "kibi-freshness",
+  "kibi-provable-code",
+  "kibi-traceability",
+  "kibi-usage"
+]);
+var RESULT_COUNT_BUCKETS = [
+  [0, 0, "0"],
+  [1, 1, "1"],
+  [2, 5, "2-5"],
+  [6, 10, "6-10"],
+  [11, Number.POSITIVE_INFINITY, "11+"]
+];
+var RELATIONSHIP_COUNT_BUCKETS = [
+  [0, 0, "0"],
+  [1, 1, "1"],
+  [2, 5, "2-5"],
+  [6, Number.POSITIVE_INFINITY, "6+"]
+];
+var SMALL_COUNT_BUCKETS = [
+  [1, 1, "1"],
+  [2, 2, "2"],
+  [3, 3, "3"],
+  [4, Number.POSITIVE_INFINITY, "4+"]
+];
+var KIBI_SOURCE_PACKAGES = "agent-core|cli|mcp|core|runtime|claude|codex|cursor|opencode|zcode|vscode|plugin-[a-z0-9-]+|lang-[a-z0-9-]+";
+var SOURCE_FRAME = new RegExp(`(?:^|/)packages/(${KIBI_SOURCE_PACKAGES})/((?:src|dist|bin)/.+)$`);
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+var SKILL_FILE = /(?:^|[\\/])(kibi-[a-z0-9-]+)[\\/]SKILL\.md\b/i;
+function skillName(name) {
+  return KIBI_SKILL_NAMES.has(name) ? name : "other";
+}
+function skillInStrings(value, depth) {
+  if (typeof value === "string") {
+    const match = SKILL_FILE.exec(value);
+    return match ? skillName(match[1].toLowerCase()) : undefined;
+  }
+  if (depth <= 0)
+    return;
+  for (const child of Object.values(value ?? {}).slice(0, 50)) {
+    const found = skillInStrings(child, depth - 1);
+    if (found)
+      return found;
+  }
+  return;
+}
+function kibiSkillLoad(toolName, toolInput) {
+  if (/^skill$/i.test(String(toolName).trim()) && isRecord3(toolInput)) {
+    for (const key of ["skill", "name", "command"]) {
+      const value = toolInput[key];
+      if (typeof value !== "string")
+        continue;
+      const bare = value.trim().split(":").at(-1).toLowerCase();
+      if (/^kibi-[a-z0-9-]+$/.test(bare))
+        return skillName(bare);
+    }
+  }
+  return skillInStrings(toolInput, 3);
+}
+function recentPath(directory) {
+  return path6.join(directory, RECENT_FILE);
+}
+function entries(value) {
+  return Array.isArray(value) ? value : [];
+}
+function fresh(entry, now, windowMs) {
+  return isRecord3(entry) && typeof entry.t === "number" && now - entry.t <= windowMs;
+}
+function readRecent(directory, now) {
+  let parsed = {};
+  try {
+    parsed = JSON.parse(String(fs5.readFileSync(recentPath(directory)))) ?? parsed;
+  } catch {}
+  return {
+    calls: entries(parsed.calls).filter((entry) => fresh(entry, now, RETRY_WINDOW_MS) && typeof entry.o === "string"),
+    skills: entries(parsed.skills).filter((entry) => fresh(entry, now, SKILL_WINDOW_MS))
+  };
+}
+function writeRecent(directory, recent) {
+  try {
+    fs5.mkdirSync(directory, { recursive: true });
+    const file = recentPath(directory);
+    const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
+    fs5.writeFileSync(temporary, JSON.stringify({
+      calls: recent.calls.slice(-MAX_RECENT_ENTRIES),
+      skills: recent.skills.slice(-MAX_RECENT_ENTRIES)
+    }));
+    fs5.renameSync(temporary, file);
+  } catch {}
+}
+function rememberSkillLoad(directory, workspaceHash, now = Date.now()) {
+  const recent = readRecent(directory, now);
+  recent.skills.push({ w: workspaceHash, t: now });
+  writeRecent(directory, recent);
+}
+
+// ../agent-core/dist/usage-telemetry.js
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import fs6 from "node:fs";
 import os from "node:os";
-import path5 from "node:path";
+import path7 from "node:path";
 import { fileURLToPath } from "node:url";
 var DEFAULT_TELEMETRY_KEY = "phc_A5z8jRhD528abGJiTtPfgu4d4hpbEbfiJr9iUGn9TMsY";
 var DEFAULT_TELEMETRY_HOST = "https://eu.i.posthog.com";
@@ -1744,10 +1762,37 @@ var STALE_CLAIM_MS = 10 * 60 * 1000;
 var MAX_EVENT_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 var MAX_QUEUE_BYTES = 1024 * 1024;
 var DEFAULT_FLUSH_TIMEOUT_MS = 1500;
+var TELEMETRY_EVENT_VERSION = 2;
+var REJECTED_CATEGORIES = new Set([
+  "bootstrap_plan_rejected",
+  "check_violations",
+  "coarse_symbol_linkage",
+  "conflicting_input",
+  "entity_not_found",
+  "entity_validation_failed",
+  "firm_decision_locked",
+  "generated_artifacts_stale",
+  "incomplete_propositions",
+  "input_read_failed",
+  "integration_failed",
+  "invalid_project_config",
+  "invalid_relationship",
+  "legacy_branch_storage",
+  "migration_plan_refused",
+  "missing_input",
+  "query_limit_exceeded",
+  "relationship_source_mismatch",
+  "relationship_validation_failed",
+  "semantic_contradiction",
+  "symbol_granularity_violation",
+  "tests_failed",
+  "uncompiled_source",
+  "unknown_operation",
+  "upsert_dry_run_invalid",
+  "validation_failed"
+]);
 function flagValue(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (normalized === undefined || normalized === "")
-    return;
+  const normalized = String(value).trim().toLowerCase();
   if (["1", "true", "yes", "on"].includes(normalized))
     return true;
   if (["0", "false", "no", "off"].includes(normalized))
@@ -1811,7 +1856,7 @@ var SESSION_ENV_KEYS = [
   "CODEX_THREAD_ID"
 ];
 function hostKey(name) {
-  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function detectTelemetryHost(env = process.env) {
   const explicit = env.KIBI_HOST?.trim() || env.KIBI_MCP_HOST?.trim();
@@ -1837,9 +1882,9 @@ function remoteEnvironment(env) {
 }
 function realDirectory(directory) {
   try {
-    return fs4.realpathSync(directory);
+    return fs6.realpathSync(directory);
   } catch {
-    return path5.resolve(directory);
+    return path7.resolve(directory);
   }
 }
 function sandboxedHome(env) {
@@ -1848,16 +1893,17 @@ function sandboxedHome(env) {
     return false;
   const temp = realDirectory(os.tmpdir());
   const resolved = realDirectory(home);
-  return resolved !== temp && resolved.startsWith(`${temp}${path5.sep}`);
+  return resolved.startsWith(`${temp}${path7.sep}`);
 }
 var KIBI_REPOSITORY_PACKAGE = "kibi";
 function moduleFileFromUrl(readUrl) {
+  let file;
   try {
     const url = readUrl();
-    return typeof url === "string" && url !== "" ? fileURLToPath(url) : undefined;
-  } catch {
-    return;
-  }
+    if (typeof url === "string")
+      file = fileURLToPath(url);
+  } catch {}
+  return file;
 }
 function thisModuleFile() {
   return moduleFileFromUrl(() => import.meta.url);
@@ -1866,15 +1912,15 @@ function insideKibiCheckout(file) {
   const resolved = realDirectory(file);
   if (resolved.split(/[\\/]/).includes("node_modules"))
     return false;
-  let current = path5.dirname(resolved);
+  let current = path7.dirname(resolved);
   for (;; ) {
     try {
-      const manifest = JSON.parse(fs4.readFileSync(path5.join(current, "package.json"), "utf8"));
-      if (manifest.name === KIBI_REPOSITORY_PACKAGE && fs4.existsSync(path5.join(current, "packages", "agent-core"))) {
+      const manifest = JSON.parse(fs6.readFileSync(path7.join(current, "package.json"), "utf8"));
+      if (manifest.name === KIBI_REPOSITORY_PACKAGE && fs6.existsSync(path7.join(current, "packages", "agent-core"))) {
         return true;
       }
     } catch {}
-    const parent = path5.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current)
       return false;
     current = parent;
@@ -1888,7 +1934,7 @@ function telemetryChannel(env = process.env, moduleFile = thisModuleFile() ?? nu
   const explicit = env.KIBI_TELEMETRY_CHANNEL?.trim();
   if (explicit)
     return {
-      channel: telemetryCategory(explicit) ?? "release",
+      channel: telemetryCategory(explicit),
       source: "KIBI_TELEMETRY_CHANNEL"
     };
   if (!moduleFile)
@@ -1905,14 +1951,14 @@ function telemetryDirectory(env = process.env) {
   if (explicit)
     return explicit;
   if (process.platform === "win32" && env.LOCALAPPDATA) {
-    return path5.join(env.LOCALAPPDATA, "kibi");
+    return path7.join(env.LOCALAPPDATA, "kibi");
   }
   const stateHome = env.XDG_STATE_HOME?.trim();
-  return path5.join(stateHome || path5.join(env.HOME || os.homedir(), ".local", "state"), "kibi");
+  return path7.join(stateHome || path7.join(env.HOME || os.homedir(), ".local", "state"), "kibi");
 }
 function readTelemetryConfig(env = process.env) {
   try {
-    const parsed = JSON.parse(fs4.readFileSync(path5.join(telemetryDirectory(env), CONFIG_FILE), "utf8"));
+    const parsed = JSON.parse(String(fs6.readFileSync(path7.join(telemetryDirectory(env), CONFIG_FILE))));
     return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
     return {};
@@ -1920,9 +1966,9 @@ function readTelemetryConfig(env = process.env) {
 }
 function writeTelemetryConfig(config, env) {
   const directory = telemetryDirectory(env);
-  fs4.mkdirSync(directory, { recursive: true });
-  fs4.writeFileSync(path5.join(directory, CONFIG_FILE), `${JSON.stringify(config, null, 2)}
-`, "utf8");
+  fs6.mkdirSync(directory, { recursive: true });
+  fs6.writeFileSync(path7.join(directory, CONFIG_FILE), `${JSON.stringify(config, null, 2)}
+`);
 }
 function telemetryStatus(env = process.env) {
   const directory = telemetryDirectory(env);
@@ -1978,31 +2024,31 @@ function installId(env) {
   if (typeof config.installId === "string" && config.installId !== "") {
     return config.installId;
   }
-  const created = randomUUID2();
+  const created = randomUUID3();
   try {
     writeTelemetryConfig({ ...config, installId: created }, env);
   } catch {}
   return created;
 }
 function hashTelemetryId(value) {
-  return createHash3("sha256").update("kibi-telemetry\x00").update(value).digest("hex").slice(0, 16);
+  return createHash4("sha256").update("kibi-telemetry\x00").update(value).digest("hex").slice(0, 16);
 }
 function runtimeName() {
   return typeof globalThis.Bun === "undefined" ? "node" : "bun";
 }
 function sessionMarkersPath(env) {
-  return path5.join(telemetryDirectory(env), SESSIONS_FILE);
+  return path7.join(telemetryDirectory(env), SESSIONS_FILE);
 }
 function readSessionMarkers(env) {
   try {
-    const parsed = JSON.parse(fs4.readFileSync(sessionMarkersPath(env), "utf8"));
-    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    const parsed = JSON.parse(String(fs6.readFileSync(sessionMarkersPath(env))));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
     return {};
   }
 }
 function workspaceKey(workspaceRoot) {
-  return hashTelemetryId(`workspace\x00${path5.resolve(workspaceRoot)}`);
+  return hashTelemetryId(`workspace\x00${path7.resolve(workspaceRoot)}`);
 }
 function rememberHookSession(workspaceRoot, sessionId, env = process.env) {
   if (!sessionId.trim() || !telemetryEnabled(env))
@@ -2016,22 +2062,22 @@ function rememberHookSession(workspaceRoot, sessionId, env = process.env) {
   const kept = Object.entries(markers).filter(([, marker]) => typeof marker?.at === "number" && now - marker.at <= SESSION_MARKER_MAX_AGE_MS).sort(([, left], [, right]) => right.at - left.at).slice(0, MAX_SESSION_MARKERS);
   try {
     const file = sessionMarkersPath(env);
-    fs4.mkdirSync(path5.dirname(file), { recursive: true });
-    const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
-    fs4.writeFileSync(temporary, JSON.stringify(Object.fromEntries(kept)));
-    fs4.renameSync(temporary, file);
+    fs6.mkdirSync(path7.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.${randomUUID3()}.tmp`;
+    fs6.writeFileSync(temporary, JSON.stringify(Object.fromEntries(kept)));
+    fs6.renameSync(temporary, file);
   } catch {}
 }
 function workspaceSessionHash(startDirectory, env = process.env) {
   const markers = readSessionMarkers(env);
   const now = Date.now();
-  let current = path5.resolve(startDirectory);
+  let current = path7.resolve(startDirectory);
   for (;; ) {
     const marker = markers[workspaceKey(current)];
     if (marker && typeof marker.session === "string" && typeof marker.at === "number" && now - marker.at <= SESSION_MARKER_MAX_AGE_MS) {
       return marker.session;
     }
-    const parent = path5.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current)
       return;
     current = parent;
@@ -2049,31 +2095,32 @@ function baseProperties(source, env) {
     $process_person_profile: false,
     $geoip_disable: true,
     $lib: "kibi",
+    telemetry_version: TELEMETRY_EVENT_VERSION,
     package: source.packageName,
     package_version: source.packageVersion ?? null,
-    host: source.host?.trim() && hostKey(source.host) || detectTelemetryHost(env) || "unknown",
+    host: source.host && hostKey(source.host) || detectTelemetryHost(env) || "unknown",
     remote: remoteEnvironment(env),
     channel: detectTelemetryChannel(env),
     session: sessionProperty(source, env),
     os: process.platform,
     arch: process.arch,
     runtime: runtimeName(),
-    runtime_version: process.versions.node.split(".")[0] ?? null
+    runtime_version: process.versions.node.split(".")[0]
   };
 }
 function queuePath(env) {
-  return path5.join(telemetryDirectory(env), QUEUE_FILE);
+  return path7.join(telemetryDirectory(env), QUEUE_FILE);
 }
 function appendEvent(event, env) {
   try {
     const file = queuePath(env);
-    fs4.mkdirSync(path5.dirname(file), { recursive: true });
+    fs6.mkdirSync(path7.dirname(file), { recursive: true });
     try {
-      if (fs4.statSync(file).size > MAX_QUEUE_BYTES)
+      if (fs6.statSync(file).size > MAX_QUEUE_BYTES)
         return;
     } catch {}
-    fs4.appendFileSync(file, `${JSON.stringify(event)}
-`, "utf8");
+    fs6.appendFileSync(file, `${JSON.stringify(event)}
+`);
   } catch {}
 }
 function telemetryCategory(value) {
@@ -2082,6 +2129,11 @@ function telemetryCategory(value) {
     return null;
   return /^[A-Za-z0-9_.:+-]{1,160}$/.test(trimmed) ? trimmed.toLowerCase() : "unclassified";
 }
+function rememberTelemetrySkillLoad(workspaceRoot, env = process.env) {
+  if (!telemetryEnabled(env))
+    return;
+  rememberSkillLoad(telemetryDirectory(env), workspaceKey(workspaceRoot));
+}
 function recordHookTelemetry(source, hook, env = process.env) {
   if (!telemetryEnabled(env))
     return;
@@ -2095,7 +2147,8 @@ function recordHookTelemetry(source, hook, env = process.env) {
       path_kind: hook.pathKind ?? null,
       kb_operation: hook.kbOperation ?? null,
       kb_used_before: hook.kbUsedBefore ?? null,
-      requirement_count: hook.requirementCount ?? null
+      requirement_count: hook.requirementCount ?? null,
+      skill: hook.skill ?? null
     }
   }, env);
 }
@@ -2103,8 +2156,6 @@ function parseQueued(text, now) {
   const events = [];
   for (const line of text.split(`
 `)) {
-    if (line.trim() === "")
-      continue;
     try {
       const event = JSON.parse(line);
       const age = now - Date.parse(event.timestamp);
@@ -2117,7 +2168,7 @@ function parseQueued(text, now) {
 function flushDue(file, now) {
   let text;
   try {
-    text = fs4.readFileSync(file, "utf8");
+    text = fs6.readFileSync(file, "utf8");
   } catch {
     return false;
   }
@@ -2128,7 +2179,7 @@ function flushDue(file, now) {
   if (lines.length >= FLUSH_BATCH_EVENTS)
     return true;
   try {
-    const first = JSON.parse(lines[0] ?? "");
+    const first = JSON.parse(lines[0]);
     return now - Date.parse(first.timestamp) >= FLUSH_MAX_AGE_MS;
   } catch {
     return true;
@@ -2138,26 +2189,26 @@ function claimBatches(directory, now) {
   const claimed = [];
   let names;
   try {
-    names = fs4.readdirSync(directory);
+    names = fs6.readdirSync(directory);
   } catch {
     return claimed;
   }
   for (const name of names) {
     if (!name.endsWith(SENDING_SUFFIX))
       continue;
-    const file = path5.join(directory, name);
+    const file = path7.join(directory, name);
     try {
-      if (now - fs4.statSync(file).mtimeMs < STALE_CLAIM_MS)
+      if (now - fs6.statSync(file).mtimeMs < STALE_CLAIM_MS)
         continue;
-      const reclaimed = `${file}.${randomUUID2()}${SENDING_SUFFIX}`;
-      fs4.renameSync(file, reclaimed);
+      const reclaimed = `${file}.${randomUUID3()}${SENDING_SUFFIX}`;
+      fs6.renameSync(file, reclaimed);
       claimed.push(reclaimed);
     } catch {}
   }
-  const queue = path5.join(directory, QUEUE_FILE);
-  const target = path5.join(directory, `${QUEUE_FILE}.${process.pid}.${randomUUID2()}${SENDING_SUFFIX}`);
+  const queue = path7.join(directory, QUEUE_FILE);
+  const target = path7.join(directory, `${QUEUE_FILE}.${process.pid}.${randomUUID3()}${SENDING_SUFFIX}`);
   try {
-    fs4.renameSync(queue, target);
+    fs6.renameSync(queue, target);
     claimed.push(target);
   } catch {}
   return claimed;
@@ -2170,17 +2221,15 @@ async function flushTelemetry(options = {}, env = process.env) {
   if (!options.force && !flushDue(queuePath(env), now))
     return 0;
   const claimed = claimBatches(directory, now);
-  if (claimed.length === 0)
-    return 0;
   const events = [];
   for (const file of claimed) {
     try {
-      events.push(...parseQueued(fs4.readFileSync(file, "utf8"), now));
+      events.push(...parseQueued(fs6.readFileSync(file, "utf8"), now));
     } catch {}
   }
   const release = () => {
     for (const file of claimed)
-      fs4.rmSync(file, { force: true });
+      fs6.rmSync(file, { force: true });
   };
   if (events.length === 0) {
     release();
@@ -2189,7 +2238,7 @@ async function flushTelemetry(options = {}, env = process.env) {
   const fetchImpl = options.fetchImpl ?? globalThis.fetch;
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? DEFAULT_FLUSH_TIMEOUT_MS);
-  timer.unref?.();
+  timer.unref();
   try {
     const response = await fetchImpl(`${telemetryHost(env)}/batch/`, {
       method: "POST",
@@ -2202,7 +2251,7 @@ async function flushTelemetry(options = {}, env = process.env) {
       signal: controller.signal
     });
     if (!response.ok && response.status >= 500)
-      throw new Error("retry");
+      throw new Error;
     release();
     return response.ok ? events.length : 0;
   } catch {
@@ -2218,6 +2267,7 @@ async function flushTelemetry(options = {}, env = process.env) {
 // ../agent-core/dist/hook-usage-log.js
 var HOOK_ACTION_EDITED = "edited";
 var HOOK_ACTION_KB_USAGE = "kb_usage";
+var HOOK_ACTION_SKILL_LOADED = "skill_loaded";
 function hookTelemetryEnabled(env = process.env) {
   const value = env.KIBI_DIAGNOSTIC_MODE?.trim().toLowerCase();
   return value === "1" || value === "true";
@@ -2242,15 +2292,19 @@ function appendHookUsage(row, env = process.env) {
     pathKind: row.trace.pathKind,
     kbOperation: row.trace.kbOperation,
     kbUsedBefore: row.trace.kbUsedBefore,
-    requirementCount: row.trace.requirementIds?.length
+    requirementCount: row.trace.requirementIds?.length,
+    skill: row.trace.skill
   }, env);
+  if (row.trace.action === HOOK_ACTION_SKILL_LOADED) {
+    rememberTelemetrySkillLoad(row.workspaceRoot, env);
+  }
   if (!hookTelemetryEnabled(env))
     return;
   const finishedAt = new Date;
   const { trace } = row;
   const record = {
     timestamp: finishedAt.toISOString(),
-    request_id: `hook-${randomUUID3()}`,
+    request_id: `hook-${randomUUID4()}`,
     tool: `hook_${row.event}`,
     interface: "hook",
     host: row.host,
@@ -2269,15 +2323,21 @@ function appendHookUsage(row, env = process.env) {
     duration_ms: finishedAt.getTime() - row.startedAt.getTime()
   };
   try {
-    const logPath = path6.join(row.workspaceRoot, ".kb", "usage.log");
-    fs5.mkdirSync(path6.dirname(logPath), { recursive: true });
-    fs5.appendFileSync(logPath, `${JSON.stringify(record)}
-`, "utf8");
+    const logPath = path8.join(row.workspaceRoot, ".kb", "usage.log");
+    fs7.mkdirSync(path8.dirname(logPath), { recursive: true });
+    fs7.appendFileSync(logPath, `${JSON.stringify(record)}
+`);
   } catch {}
 }
 function kbUsageTrace(toolName, toolInput) {
   const kbOperation = hostKbOperation(toolName, toolInput);
-  return kbOperation ? { action: HOOK_ACTION_KB_USAGE, kbOperation } : undefined;
+  if (kbOperation)
+    return { action: HOOK_ACTION_KB_USAGE, kbOperation };
+  return skillLoadTrace(toolName, toolInput);
+}
+function skillLoadTrace(toolName, toolInput) {
+  const skill = kibiSkillLoad(toolName, toolInput);
+  return skill ? { action: HOOK_ACTION_SKILL_LOADED, skill } : undefined;
 }
 function editTraces(relativePaths, requirementIdsFor) {
   const traces = [];
@@ -2295,8 +2355,6 @@ function editTraces(relativePaths, requirementIdsFor) {
   return traces;
 }
 function appendHookUsageRows(row, traces, env = process.env) {
-  if (!hookTracesWanted(env))
-    return;
   for (const trace of traces)
     appendHookUsage({ ...row, trace }, env);
 }
@@ -2312,10 +2370,10 @@ async function finishHookTelemetry(input, env = process.env) {
 }
 function readPackageVersion(packageJsonPath) {
   try {
-    const parsed = JSON.parse(fs5.readFileSync(packageJsonPath, "utf8"));
-    if (typeof parsed === "object" && parsed !== null && "version" in parsed && typeof parsed.version === "string") {
-      return parsed.version;
-    }
+    const parsed = JSON.parse(String(fs7.readFileSync(packageJsonPath)));
+    const version = parsed.version;
+    if (typeof version === "string")
+      return version;
   } catch {}
   return null;
 }
@@ -2591,10 +2649,10 @@ function parseStdinJson(rawInput) {
 }
 
 // src/hook-state-storage.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import fs6 from "node:fs";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import fs8 from "node:fs";
 import os2 from "node:os";
-import path7 from "node:path";
+import path9 from "node:path";
 var stateFileName = "hook-state.json";
 var lockFileName = "hook-state.lock";
 var maxDirtyPaths = 50;
@@ -2604,10 +2662,10 @@ var lockRetryCount = 100;
 var lockRetryDelayMs = 5;
 var staleLockAgeMs = 30000;
 function statePath(pluginData) {
-  return path7.join(pluginData, stateFileName);
+  return path9.join(pluginData, stateFileName);
 }
 function lockPath(pluginData) {
-  return path7.join(pluginData, lockFileName);
+  return path9.join(pluginData, lockFileName);
 }
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2621,7 +2679,7 @@ function sleepSync(milliseconds) {
   Atomics.wait(view, 0, 0, milliseconds);
 }
 function uniqueTempPath(pluginData) {
-  return path7.join(pluginData, `${stateFileName}.${process.pid}.${Date.now()}.${randomUUID4()}.tmp`);
+  return path9.join(pluginData, `${stateFileName}.${process.pid}.${Date.now()}.${randomUUID5()}.tmp`);
 }
 function mergeStringPaths(existingPaths, nextPaths) {
   const merged = [...existingPaths, ...nextPaths].map(normalizePath).filter((dirtyPath) => dirtyPath.length > 0);
@@ -2645,7 +2703,7 @@ function acquireLock(pluginData) {
   const targetLockPath = lockPath(pluginData);
   for (let attempt = 0;attempt < lockRetryCount; attempt++) {
     try {
-      return fs6.openSync(targetLockPath, "wx");
+      return fs8.openSync(targetLockPath, "wx");
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "EEXIST") {
         if (removeStaleLock(targetLockPath)) {
@@ -2662,7 +2720,7 @@ function acquireLock(pluginData) {
 function removeStaleLock(targetLockPath) {
   let stats;
   try {
-    stats = fs6.statSync(targetLockPath);
+    stats = fs8.statSync(targetLockPath);
   } catch {
     return false;
   }
@@ -2670,7 +2728,7 @@ function removeStaleLock(targetLockPath) {
     return false;
   }
   try {
-    fs6.unlinkSync(targetLockPath);
+    fs8.unlinkSync(targetLockPath);
     return true;
   } catch {
     return false;
@@ -2678,14 +2736,14 @@ function removeStaleLock(targetLockPath) {
 }
 function releaseLock(pluginData, fileDescriptor) {
   try {
-    fs6.closeSync(fileDescriptor);
+    fs8.closeSync(fileDescriptor);
   } catch (error) {
     if (!(error instanceof Error)) {
       throw error;
     }
   }
   try {
-    fs6.unlinkSync(lockPath(pluginData));
+    fs8.unlinkSync(lockPath(pluginData));
   } catch (error) {
     if (!(error instanceof Error)) {
       throw error;
@@ -2723,14 +2781,14 @@ function resolveStateDir(pluginData, conversationId) {
   if (!conversationId) {
     return;
   }
-  return path7.join(os2.tmpdir(), "kibi-cursor-hook-state", conversationId.replaceAll(/[^a-zA-Z0-9._-]/g, "_"));
+  return path9.join(os2.tmpdir(), "kibi-cursor-hook-state", conversationId.replaceAll(/[^a-zA-Z0-9._-]/g, "_"));
 }
 function loadHookState(stateDir) {
   if (!stateDir) {
     return emptyHookState();
   }
   try {
-    return coerceHookState(JSON.parse(fs6.readFileSync(statePath(stateDir), "utf8")));
+    return coerceHookState(JSON.parse(fs8.readFileSync(statePath(stateDir), "utf8")));
   } catch {
     return emptyHookState();
   }
@@ -2739,19 +2797,19 @@ function saveHookState(stateDir, state) {
   if (!stateDir) {
     return;
   }
-  fs6.mkdirSync(stateDir, { recursive: true });
+  fs8.mkdirSync(stateDir, { recursive: true });
   const boundedState = coerceHookState(state);
   const tempPath = uniqueTempPath(stateDir);
-  fs6.writeFileSync(tempPath, `${JSON.stringify(boundedState)}
+  fs8.writeFileSync(tempPath, `${JSON.stringify(boundedState)}
 `);
-  fs6.renameSync(tempPath, statePath(stateDir));
+  fs8.renameSync(tempPath, statePath(stateDir));
 }
 function updateHookState(stateDir, updater) {
   const initialState = loadHookState(stateDir);
   if (!stateDir) {
     return updater(initialState);
   }
-  fs6.mkdirSync(stateDir, { recursive: true });
+  fs8.mkdirSync(stateDir, { recursive: true });
   const lockFileDescriptor = acquireLock(stateDir);
   if (lockFileDescriptor === undefined) {
     return updater(initialState);
@@ -2846,14 +2904,14 @@ function clearSessionHookState(stateDir) {
 }
 
 // src/source-linked-requirements.ts
-import path8 from "node:path";
+import path10 from "node:path";
 var CURSOR_INDEX_OPTIONS = {
   legacyLinksAsImplements: false,
   cacheFileName: "cursor-knowledge-index.json"
 };
 function toManifestPath(workspaceRoot, filePath) {
-  const absolute = path8.isAbsolute(filePath) ? filePath : path8.resolve(workspaceRoot, filePath);
-  return path8.relative(workspaceRoot, absolute).split(path8.sep).join("/");
+  const absolute = path10.isAbsolute(filePath) ? filePath : path10.resolve(workspaceRoot, filePath);
+  return path10.relative(workspaceRoot, absolute).split(path10.sep).join("/");
 }
 function getSourceLinkedSymbols(workspaceRoot, filePath, cacheDir) {
   const relativePath = toManifestPath(workspaceRoot, filePath);
@@ -2890,7 +2948,7 @@ function firmNotice(workspaceRoot, linked, focus, session, env) {
   return firmEditNotice(symbol ? `${symbol.title} in ${linked.relativePath}` : linked.relativePath, ids.map(summarize));
 }
 function packageVersion() {
-  return readPackageVersion(path9.join(path9.dirname(fileURLToPath2(import.meta.url)), "..", "package.json"));
+  return readPackageVersion(path11.join(path11.dirname(fileURLToPath2(import.meta.url)), "..", "package.json"));
 }
 function recordToolTelemetry(input, workspaceRoot, stateDir, startedAt, env) {
   if (!hookTracesWanted(env))
@@ -2926,19 +2984,19 @@ function hasKibiConfig(cwd) {
   if (!cwd) {
     return false;
   }
-  return fs7.existsSync(path9.join(cwd, ".kb", "manifest.json"));
+  return fs9.existsSync(path11.join(cwd, ".kb", "manifest.json"));
 }
 function kibiWorkspaceFor(directory) {
   if (!directory)
     return;
-  let current = path9.resolve(directory);
+  let current = path11.resolve(directory);
   for (;; ) {
-    if (fs7.existsSync(path9.join(current, ".kb", "manifest.json"))) {
+    if (fs9.existsSync(path11.join(current, ".kb", "manifest.json"))) {
       return current;
     }
-    if (fs7.existsSync(path9.join(current, ".git")))
+    if (fs9.existsSync(path11.join(current, ".git")))
       return;
-    const parent = path9.dirname(current);
+    const parent = path11.dirname(current);
     if (parent === current)
       return;
     current = parent;
@@ -2993,7 +3051,9 @@ ${advisory}` : BOOTSTRAP_REMINDER
         }
         {
           const advisory = interfaceAdvisory(initialState.mcpState, workspaceTrusted);
-          return advisory ? { additional_context: advisory } : emptyResult();
+          const context = [advisory, missingHooksNote(cwd)].filter((line) => Boolean(line)).join(`
+`);
+          return context ? { additional_context: context } : emptyResult();
         }
       case "preToolUse": {
         const stamped = stampKibiWorkspace(input.toolName, input.toolInput, kibiWorkspaceFor(input.cwd ?? input.workspaceRoots?.[0]));
@@ -3019,7 +3079,7 @@ ${advisory}` : BOOTSTRAP_REMINDER
         const linked = getSourceLinkedSymbols(cwd, primaryPath, stateDir);
         trace.pathKind = classifyPath(relativePath);
         trace.requirementIds = implementedRequirementIds(linked.symbols);
-        const focus = editFocus(path9.resolve(cwd, primaryPath), input.toolInput);
+        const focus = editFocus(path11.resolve(cwd, primaryPath), input.toolInput);
         const ruleNote = takeRuleNote(session);
         const notice = firmNotice(cwd, linked, focus, session, environment.env ?? process.env);
         const guidance = hasGuidedPath(state, "pre-edit", relativePath) ? undefined : preEditGuidance(primaryPath, {
@@ -3102,7 +3162,8 @@ ${advisory}` : BOOTSTRAP_REMINDER
             markDecisionFlag(session, "source-edited");
           }
         }
-        if (kbToolCall?.toolName === "kb_upsert" || kbUsageTrace(input.toolName, input.toolInput)?.kbOperation === "kb_upsert") {
+        const kbOperation = kbToolCall ? kbToolCall.toolName : kbUsageTrace(input.toolName, input.toolInput)?.kbOperation;
+        if (kbOperation === "kb_upsert") {
           markDecisionFlag(session, "kb-recorded");
           if (isRequirementUpsert(input.toolInput)) {
             markDecisionFlag(session, "requirement-recorded");
@@ -3204,7 +3265,7 @@ async function main() {
 `);
 }
 function isInvokedAsCli(argv1, moduleUrl) {
-  const invokedPath = argv1 ? pathToFileURL(path9.resolve(argv1)).href : "";
+  const invokedPath = argv1 ? pathToFileURL(path11.resolve(argv1)).href : "";
   return moduleUrl === invokedPath;
 }
 async function runHookCli() {