@cybedefend/vibedefend 1.3.1 → 1.4.0

package/dist/hook-runner.js

@@ -269,16 +269,16 @@ var require_re2 = __commonJS({
       if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
         return UTF8Decoder.decode(heap.subarray(idx, endPtr));
       } else {
-        var str = "";
+        var str2 = "";
         while (idx < endPtr) {
           var u0 = heap[idx++];
           if (!(u0 & 128)) {
-            str += String.fromCharCode(u0);
+            str2 += String.fromCharCode(u0);
             continue;
           }
           var u1 = heap[idx++] & 63;
           if ((u0 & 224) == 192) {
-            str += String.fromCharCode((u0 & 31) << 6 | u1);
+            str2 += String.fromCharCode((u0 & 31) << 6 | u1);
             continue;
           }
           var u2 = heap[idx++] & 63;
@@ -289,27 +289,27 @@ var require_re2 = __commonJS({
             u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++] & 63;
           }
           if (u0 < 65536) {
-            str += String.fromCharCode(u0);
+            str2 += String.fromCharCode(u0);
           } else {
             var ch = u0 - 65536;
-            str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+            str2 += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
           }
         }
       }
-      return str;
+      return str2;
     }
     function UTF8ToString(ptr, maxBytesToRead) {
       return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
     }
-    function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+    function stringToUTF8Array(str2, heap, outIdx, maxBytesToWrite) {
       if (!(maxBytesToWrite > 0))
         return 0;
       var startIdx = outIdx;
       var endIdx = outIdx + maxBytesToWrite - 1;
-      for (var i = 0; i < str.length; ++i) {
-        var u = str.charCodeAt(i);
+      for (var i = 0; i < str2.length; ++i) {
+        var u = str2.charCodeAt(i);
         if (u >= 55296 && u <= 57343) {
-          var u1 = str.charCodeAt(++i);
+          var u1 = str2.charCodeAt(++i);
           u = 65536 + ((u & 1023) << 10) | u1 & 1023;
         }
         if (u <= 127) {
@@ -336,15 +336,15 @@ var require_re2 = __commonJS({
       heap[outIdx] = 0;
       return outIdx - startIdx;
     }
-    function stringToUTF8(str, outPtr, maxBytesToWrite) {
+    function stringToUTF8(str2, outPtr, maxBytesToWrite) {
       assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
-      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+      return stringToUTF8Array(str2, HEAPU8, outPtr, maxBytesToWrite);
     }
-    function lengthBytesUTF8(str) {
+    function lengthBytesUTF8(str2) {
       var len = 0;
-      for (var i = 0; i < str.length; ++i) {
-        var u = str.charCodeAt(i);
-        if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
+      for (var i = 0; i < str2.length; ++i) {
+        var u = str2.charCodeAt(i);
+        if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str2.charCodeAt(++i) & 1023;
         if (u <= 127) ++len;
         else if (u <= 2047) len += 2;
         else if (u <= 65535) len += 3;
@@ -363,16 +363,16 @@ var require_re2 = __commonJS({
       if (endPtr - ptr > 32 && UTF16Decoder) {
         return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
       } else {
-        var str = "";
+        var str2 = "";
         for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
           var codeUnit = HEAP16[ptr + i * 2 >> 1];
           if (codeUnit == 0) break;
-          str += String.fromCharCode(codeUnit);
+          str2 += String.fromCharCode(codeUnit);
         }
-        return str;
+        return str2;
       }
     }
-    function stringToUTF16(str, outPtr, maxBytesToWrite) {
+    function stringToUTF16(str2, outPtr, maxBytesToWrite) {
       assert(outPtr % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!");
       assert(typeof maxBytesToWrite == "number", "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
       if (maxBytesToWrite === void 0) {
@@ -381,36 +381,36 @@ var require_re2 = __commonJS({
       if (maxBytesToWrite < 2) return 0;
       maxBytesToWrite -= 2;
       var startPtr = outPtr;
-      var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+      var numCharsToWrite = maxBytesToWrite < str2.length * 2 ? maxBytesToWrite / 2 : str2.length;
       for (var i = 0; i < numCharsToWrite; ++i) {
-        var codeUnit = str.charCodeAt(i);
+        var codeUnit = str2.charCodeAt(i);
         HEAP16[outPtr >> 1] = codeUnit;
         outPtr += 2;
       }
       HEAP16[outPtr >> 1] = 0;
       return outPtr - startPtr;
     }
-    function lengthBytesUTF16(str) {
-      return str.length * 2;
+    function lengthBytesUTF16(str2) {
+      return str2.length * 2;
     }
     function UTF32ToString(ptr, maxBytesToRead) {
       assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!");
       var i = 0;
-      var str = "";
+      var str2 = "";
       while (!(i >= maxBytesToRead / 4)) {
         var utf32 = HEAP32[ptr + i * 4 >> 2];
         if (utf32 == 0) break;
         ++i;
         if (utf32 >= 65536) {
           var ch = utf32 - 65536;
-          str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+          str2 += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
         } else {
-          str += String.fromCharCode(utf32);
+          str2 += String.fromCharCode(utf32);
         }
       }
-      return str;
+      return str2;
     }
-    function stringToUTF32(str, outPtr, maxBytesToWrite) {
+    function stringToUTF32(str2, outPtr, maxBytesToWrite) {
       assert(outPtr % 4 == 0, "Pointer passed to stringToUTF32 must be aligned to four bytes!");
       assert(typeof maxBytesToWrite == "number", "stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
       if (maxBytesToWrite === void 0) {
@@ -419,10 +419,10 @@ var require_re2 = __commonJS({
       if (maxBytesToWrite < 4) return 0;
       var startPtr = outPtr;
       var endPtr = startPtr + maxBytesToWrite - 4;
-      for (var i = 0; i < str.length; ++i) {
-        var codeUnit = str.charCodeAt(i);
+      for (var i = 0; i < str2.length; ++i) {
+        var codeUnit = str2.charCodeAt(i);
         if (codeUnit >= 55296 && codeUnit <= 57343) {
-          var trailSurrogate = str.charCodeAt(++i);
+          var trailSurrogate = str2.charCodeAt(++i);
           codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
         }
         HEAP32[outPtr >> 2] = codeUnit;
@@ -432,10 +432,10 @@ var require_re2 = __commonJS({
       HEAP32[outPtr >> 2] = 0;
       return outPtr - startPtr;
     }
-    function lengthBytesUTF32(str) {
+    function lengthBytesUTF32(str2) {
       var len = 0;
-      for (var i = 0; i < str.length; ++i) {
-        var codeUnit = str.charCodeAt(i);
+      for (var i = 0; i < str2.length; ++i) {
+        var codeUnit = str2.charCodeAt(i);
         if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
         len += 4;
       }
@@ -445,10 +445,10 @@ var require_re2 = __commonJS({
       assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
       HEAP8.set(array, buffer2);
     }
-    function writeAsciiToMemory(str, buffer2, dontAddNull) {
-      for (var i = 0; i < str.length; ++i) {
-        assert(str.charCodeAt(i) === str.charCodeAt(i) & 255);
-        HEAP8[buffer2++ >> 0] = str.charCodeAt(i);
+    function writeAsciiToMemory(str2, buffer2, dontAddNull) {
+      for (var i = 0; i < str2.length; ++i) {
+        assert(str2.charCodeAt(i) === str2.charCodeAt(i) & 255);
+        HEAP8[buffer2++ >> 0] = str2.charCodeAt(i);
       }
       if (!dontAddNull) HEAP8[buffer2 >> 0] = 0;
     }
@@ -677,8 +677,8 @@ var require_re2 = __commonJS({
     };
     Module["FS_createDataFile"] = FS.createDataFile;
     Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
-    function hasPrefix(str, prefix) {
-      return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0;
+    function hasPrefix(str2, prefix) {
+      return String.prototype.startsWith ? str2.startsWith(prefix) : str2.indexOf(prefix) === 0;
     }
     var dataURIPrefix = "data:application/octet-stream;base64,";
     function isDataURI(filename) {
@@ -770,9 +770,9 @@ var require_re2 = __commonJS({
           module2 = new WebAssembly.Module(binary);
           instance = new WebAssembly.Instance(module2, info);
         } catch (e) {
-          var str = e.toString();
-          err("failed to compile wasm module: " + str);
-          if (str.indexOf("imported Memory") >= 0 || str.indexOf("memory import") >= 0) {
+          var str2 = e.toString();
+          err("failed to compile wasm module: " + str2);
+          if (str2.indexOf("imported Memory") >= 0 || str2.indexOf("memory import") >= 0) {
             err("Memory size incompatibility issues may be due to changing INITIAL_MEMORY at runtime to something too large. Use ALLOW_MEMORY_GROWTH to allow any size memory (and also make sure not to set INITIAL_MEMORY at runtime to something smaller than it was at compile time).");
           }
           throw e;
@@ -2132,7 +2132,7 @@ var require_re2 = __commonJS({
         name,
         "fromWireType": function(value) {
           var length = HEAPU32[value >> 2];
-          var str;
+          var str2;
           if (stdStringIsUTF8) {
             var decodeStartPtr = value + 4;
             for (var i = 0; i <= length; ++i) {
@@ -2140,11 +2140,11 @@ var require_re2 = __commonJS({
               if (i == length || HEAPU8[currentBytePtr] == 0) {
                 var maxRead = currentBytePtr - decodeStartPtr;
                 var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
-                if (str === void 0) {
-                  str = stringSegment;
+                if (str2 === void 0) {
+                  str2 = stringSegment;
                 } else {
-                  str += String.fromCharCode(0);
-                  str += stringSegment;
+                  str2 += String.fromCharCode(0);
+                  str2 += stringSegment;
                 }
                 decodeStartPtr = currentBytePtr + 1;
               }
@@ -2154,10 +2154,10 @@ var require_re2 = __commonJS({
             for (var i = 0; i < length; ++i) {
               a[i] = String.fromCharCode(HEAPU8[value + 4 + i]);
             }
-            str = a.join("");
+            str2 = a.join("");
           }
           _free(value);
-          return str;
+          return str2;
         },
         "toWireType": function(destructors, value) {
           if (value instanceof ArrayBuffer) {
@@ -2235,24 +2235,24 @@ var require_re2 = __commonJS({
         "fromWireType": function(value) {
           var length = HEAPU32[value >> 2];
           var HEAP2 = getHeap();
-          var str;
+          var str2;
           var decodeStartPtr = value + 4;
           for (var i = 0; i <= length; ++i) {
             var currentBytePtr = value + 4 + i * charSize;
             if (i == length || HEAP2[currentBytePtr >> shift] == 0) {
               var maxReadBytes = currentBytePtr - decodeStartPtr;
               var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
-              if (str === void 0) {
-                str = stringSegment;
+              if (str2 === void 0) {
+                str2 = stringSegment;
               } else {
-                str += String.fromCharCode(0);
-                str += stringSegment;
+                str2 += String.fromCharCode(0);
+                str2 += stringSegment;
               }
               decodeStartPtr = currentBytePtr + charSize;
             }
           }
           _free(value);
-          return str;
+          return str2;
         },
         "toWireType": function(destructors, value) {
           if (!(typeof value === "string")) {
@@ -2592,11 +2592,11 @@ var require_re2 = __commonJS({
       var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
       var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
       function leadingSomething(value, digits, character) {
-        var str = typeof value === "number" ? value.toString() : value || "";
-        while (str.length < digits) {
-          str = character[0] + str;
+        var str2 = typeof value === "number" ? value.toString() : value || "";
+        while (str2.length < digits) {
+          str2 = character[0] + str2;
         }
-        return str;
+        return str2;
       }
       function leadingNulls(value, digits) {
         return leadingSomething(value, digits, "0");
@@ -4502,7 +4502,7 @@ function extractToolInputShape(input, client) {
 
 // src/hooks/runtime/resolve.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
 
 // src/auth/auth-store.ts
 import { execFileSync } from "node:child_process";
@@ -4742,6 +4742,325 @@ async function doRefresh(mcpName, stored) {
   }
 }
 
+// src/git.ts
+import { spawnSync } from "node:child_process";
+function parseRemoteUrl(url) {
+  const trimmed = url.trim();
+  if (trimmed.length === 0) return null;
+  let host;
+  let rawPath;
+  if (trimmed.includes("://")) {
+    let parsed;
+    try {
+      parsed = new URL(trimmed);
+    } catch {
+      return null;
+    }
+    if (!parsed.hostname) return null;
+    host = parsed.hostname;
+    rawPath = parsed.pathname;
+  } else {
+    const scpMatch = /^(?:[^@\s]+@)?([^:\s/]+):(.+)$/.exec(trimmed);
+    if (!scpMatch) return null;
+    host = scpMatch[1].toLowerCase();
+    rawPath = scpMatch[2];
+  }
+  const slug = rawPath.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+  if (slug.length === 0) return null;
+  return { provider: detectProvider(host), host, slug };
+}
+function detectProvider(host) {
+  const lower = host.toLowerCase();
+  if (lower.includes("github")) return "github";
+  if (lower.includes("gitlab")) return "gitlab";
+  return null;
+}
+var GIT_REMOTE_TIMEOUT_MS = 3e3;
+function getOriginRemote(cwd, deps = {}) {
+  const execImpl = deps.execImpl ?? defaultExecImpl;
+  const result = execImpl("git", ["remote", "get-url", "origin"], {
+    cwd,
+    timeoutMs: GIT_REMOTE_TIMEOUT_MS
+  });
+  if (result.status !== 0) return null;
+  const url = result.stdout.trim();
+  return url.length > 0 ? url : null;
+}
+function defaultExecImpl(cmd, args, opts) {
+  const result = spawnSync(cmd, args, {
+    cwd: opts.cwd,
+    encoding: "utf8",
+    timeout: opts.timeoutMs,
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true
+  });
+  return { status: result.status, stdout: result.stdout ?? "" };
+}
+
+// src/api/projects.ts
+var RESOLVE_TIMEOUT_MS = 4e3;
+function unwrap(body) {
+  if (!body || typeof body !== "object") return {};
+  const root = body;
+  const data = root.data;
+  return data ?? root;
+}
+function str(v) {
+  return typeof v === "string" ? v : v == null ? "" : String(v);
+}
+async function resolveProjectByRepository(apiBase, token, q, deps = {}) {
+  const f = deps.fetchImpl ?? globalThis.fetch;
+  const params = new URLSearchParams({ provider: q.provider, slug: q.slug });
+  if (q.host) params.set("host", q.host);
+  const url = `${apiBase}/user/projects/resolve?${params.toString()}`;
+  let res;
+  try {
+    res = await f(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(deps.timeoutMs ?? RESOLVE_TIMEOUT_MS)
+    });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return null;
+  }
+  const data = unwrap(body);
+  const rawMatches = Array.isArray(data.matches) ? data.matches : [];
+  return rawMatches.map((raw) => {
+    const m = raw ?? {};
+    return {
+      projectId: str(m.projectId),
+      organizationId: str(m.organizationId),
+      projectName: str(m.projectName),
+      provider: str(m.provider),
+      repository: str(m.repository),
+      // Missing → enabled (default-on). Only an explicit `false` disables.
+      vibedefendEnabled: m.vibedefendEnabled !== false
+    };
+  });
+}
+
+// src/hooks/runtime/repo-link-cache.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+
+// src/utils.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { homedir as homedir2, platform } from "node:os";
+
+// node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/index.mjs
+var FORCE_COLOR;
+var NODE_DISABLE_COLORS;
+var NO_COLOR;
+var TERM;
+var isTTY = true;
+if (typeof process !== "undefined") {
+  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+  isTTY = process.stdout && process.stdout.isTTY;
+}
+var $ = {
+  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY),
+  // modifiers
+  reset: init(0, 0),
+  bold: init(1, 22),
+  dim: init(2, 22),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  // colors
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  grey: init(90, 39),
+  // background colors
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49)
+};
+function run(arr, str2) {
+  let i = 0, tmp, beg = "", end = "";
+  for (; i < arr.length; i++) {
+    tmp = arr[i];
+    beg += tmp.open;
+    end += tmp.close;
+    if (!!~str2.indexOf(tmp.close)) {
+      str2 = str2.replace(tmp.rgx, tmp.close + tmp.open);
+    }
+  }
+  return beg + str2 + end;
+}
+function chain(has, keys) {
+  let ctx = { has, keys };
+  ctx.reset = $.reset.bind(ctx);
+  ctx.bold = $.bold.bind(ctx);
+  ctx.dim = $.dim.bind(ctx);
+  ctx.italic = $.italic.bind(ctx);
+  ctx.underline = $.underline.bind(ctx);
+  ctx.inverse = $.inverse.bind(ctx);
+  ctx.hidden = $.hidden.bind(ctx);
+  ctx.strikethrough = $.strikethrough.bind(ctx);
+  ctx.black = $.black.bind(ctx);
+  ctx.red = $.red.bind(ctx);
+  ctx.green = $.green.bind(ctx);
+  ctx.yellow = $.yellow.bind(ctx);
+  ctx.blue = $.blue.bind(ctx);
+  ctx.magenta = $.magenta.bind(ctx);
+  ctx.cyan = $.cyan.bind(ctx);
+  ctx.white = $.white.bind(ctx);
+  ctx.gray = $.gray.bind(ctx);
+  ctx.grey = $.grey.bind(ctx);
+  ctx.bgBlack = $.bgBlack.bind(ctx);
+  ctx.bgRed = $.bgRed.bind(ctx);
+  ctx.bgGreen = $.bgGreen.bind(ctx);
+  ctx.bgYellow = $.bgYellow.bind(ctx);
+  ctx.bgBlue = $.bgBlue.bind(ctx);
+  ctx.bgMagenta = $.bgMagenta.bind(ctx);
+  ctx.bgCyan = $.bgCyan.bind(ctx);
+  ctx.bgWhite = $.bgWhite.bind(ctx);
+  return ctx;
+}
+function init(open, close) {
+  let blk = {
+    open: `\x1B[${open}m`,
+    close: `\x1B[${close}m`,
+    rgx: new RegExp(`\\x1b\\[${close}m`, "g")
+  };
+  return function(txt) {
+    if (this !== void 0 && this.has !== void 0) {
+      !!~this.has.indexOf(open) || (this.has.push(open), this.keys.push(blk));
+      return txt === void 0 ? this : $.enabled ? run(this.keys, txt + "") : txt + "";
+    }
+    return txt === void 0 ? chain([open], [blk]) : $.enabled ? run([blk], txt + "") : txt + "";
+  };
+}
+
+// src/utils.ts
+function home(...parts) {
+  return join2(homedir2(), ...parts);
+}
+function ensureDirFor(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+}
+
+// src/hooks/runtime/repo-link-cache.ts
+var POSITIVE_TTL_MS = 24 * 60 * 60 * 1e3;
+var NEGATIVE_TTL_MS = 15 * 60 * 1e3;
+function repoLinkCachePath() {
+  return home(".cybedefend", "repo-links.json");
+}
+function pathOf(deps) {
+  return deps.cachePath ?? repoLinkCachePath();
+}
+function readRepoLinkCache(deps = {}) {
+  const p = pathOf(deps);
+  if (!existsSync3(p)) return {};
+  try {
+    const raw = readFileSync3(p, "utf8");
+    if (!raw.trim()) return {};
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function getCachedRepoLink(key, deps = {}) {
+  const now = deps.now ?? Date.now;
+  const entry = readRepoLinkCache(deps)[key];
+  if (!entry || typeof entry !== "object") return { kind: "miss" };
+  const resolvedAt = entry.resolvedAt;
+  if (typeof resolvedAt !== "number") return { kind: "miss" };
+  const age = now() - resolvedAt;
+  if (age < 0) return { kind: "miss" };
+  if (entry.negative === true) {
+    return age < NEGATIVE_TTL_MS ? { kind: "negative" } : { kind: "miss" };
+  }
+  const pos = entry;
+  if (typeof pos.projectId !== "string" || pos.projectId.length === 0) {
+    return { kind: "miss" };
+  }
+  if (age < POSITIVE_TTL_MS) {
+    return {
+      kind: "positive",
+      projectId: pos.projectId,
+      // Missing → treated as enabled; only explicit `false` disables.
+      vibedefendEnabled: pos.vibedefendEnabled !== false
+    };
+  }
+  return { kind: "miss" };
+}
+function writeCachedRepoLink(key, entry, deps = {}) {
+  const now = deps.now ?? Date.now;
+  try {
+    const map = readRepoLinkCache(deps);
+    map[key] = "negative" in entry ? { negative: true, resolvedAt: now() } : {
+      projectId: entry.projectId,
+      vibedefendEnabled: entry.vibedefendEnabled,
+      resolvedAt: now()
+    };
+    const p = pathOf(deps);
+    const dir = dirname2(p);
+    if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
+    writeFileSync3(p, JSON.stringify(map, null, 2) + "\n");
+  } catch {
+  }
+}
+
+// src/hooks/runtime/config.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+function runtimeConfigPath() {
+  return join3(homedir3(), ".cybedefend", "runtime-config.json");
+}
+function loadRuntimeConfig(path) {
+  const p = path ?? runtimeConfigPath();
+  if (!existsSync4(p)) return null;
+  try {
+    const raw = readFileSync4(p, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  if (!raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
 // src/hooks/runtime/resolve.ts
 function resolveProjectId(cwd = process.cwd()) {
   const envProjectId = process.env.CYBEDEFEND_PROJECT_ID;
@@ -4749,9 +5068,9 @@ function resolveProjectId(cwd = process.cwd()) {
     return { projectId: envProjectId, apiBase: null };
   }
   const configPath = `${cwd}/.cybedefend/config.json`;
-  if (existsSync2(configPath)) {
+  if (existsSync5(configPath)) {
     try {
-      const raw = readFileSync2(configPath, "utf8");
+      const raw = readFileSync5(configPath, "utf8");
       const cfg = JSON.parse(raw);
       return {
         projectId: cfg.projectId ?? null,
@@ -4865,6 +5184,54 @@ async function resolveTokenWithRefresh(mcpName, deps = {}) {
   }
   return resolveTokenFn(mcpName);
 }
+var RESOLVE_API_TIMEOUT_MS = 4e3;
+async function resolveProjectIdWithApi(cwd = process.cwd(), deps = {}) {
+  const resolveSync = deps.resolveSync ?? resolveProjectId;
+  const base = resolveSync(cwd);
+  if (base.projectId) return base;
+  try {
+    const getOrigin = deps.getOrigin ?? getOriginRemote;
+    const originUrl = getOrigin(cwd);
+    if (!originUrl) return base;
+    const remote = parseRemoteUrl(originUrl);
+    if (!remote || remote.provider === null) return base;
+    const key = `${remote.provider}:${remote.host}:${remote.slug}`;
+    const cached = getCachedRepoLink(key, deps.cacheDeps);
+    if (cached.kind === "positive") {
+      return { projectId: cached.projectId, apiBase: base.apiBase };
+    }
+    if (cached.kind === "negative") {
+      return base;
+    }
+    const config = (deps.loadConfig ?? loadRuntimeConfig)();
+    if (!config) return base;
+    const apiBase = base.apiBase ?? config.region.apiBase;
+    const resolveTokenFn = deps.resolveTokenFn ?? resolveTokenWithRefresh;
+    const token = await resolveTokenFn(config.region.mcpName);
+    if (!token) return base;
+    const resolveByRepo = deps.resolveByRepo ?? resolveProjectByRepository;
+    const matches = await resolveByRepo(
+      apiBase,
+      token,
+      { provider: remote.provider, slug: remote.slug, host: remote.host },
+      { timeoutMs: deps.timeoutMs ?? RESOLVE_API_TIMEOUT_MS }
+    );
+    if (matches === null) return base;
+    if (matches.length === 1 && matches[0].vibedefendEnabled !== false) {
+      const m = matches[0];
+      writeCachedRepoLink(
+        key,
+        { projectId: m.projectId, vibedefendEnabled: m.vibedefendEnabled },
+        deps.cacheDeps
+      );
+      return { projectId: m.projectId, apiBase: base.apiBase };
+    }
+    writeCachedRepoLink(key, { negative: true }, deps.cacheDeps);
+    return base;
+  } catch {
+    return base;
+  }
+}
 
 // src/hooks/runtime/api.ts
 var DEFAULT_TIMEOUT_MS = 1e4;
@@ -5006,38 +5373,6 @@ function emitStop(body, client, reason) {
   emit(body, client);
 }
 
-// src/hooks/runtime/config.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
-function runtimeConfigPath() {
-  return join2(homedir2(), ".cybedefend", "runtime-config.json");
-}
-function loadRuntimeConfig(path) {
-  const p = path ?? runtimeConfigPath();
-  if (!existsSync3(p)) return null;
-  try {
-    const raw = readFileSync3(p, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function readStdinJson() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-  }
-  const raw = Buffer.concat(chunks).toString("utf8");
-  if (!raw.trim()) return {};
-  try {
-    const parsed = JSON.parse(raw);
-    return typeof parsed === "object" && parsed !== null ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-
 // src/hooks/runtime/fetch-rules.ts
 var INTERESTED_TOOLS = /* @__PURE__ */ new Set([
   "Edit",
@@ -5048,7 +5383,7 @@ var INTERESTED_TOOLS = /* @__PURE__ */ new Set([
 async function fetchRulesHook(deps = {}) {
   const readStdin = deps.readStdin ?? readStdinJson;
   const loadConfig = deps.loadConfig ?? loadRuntimeConfig;
-  const resolveProject = deps.resolveProject ?? resolveProjectId;
+  const resolveProject = deps.resolveProject ?? resolveProjectIdWithApi;
   const resolveTok = deps.resolveTokenFn ?? resolveToken;
   const fetchRules = deps.fetchRulesFn ?? fetchBusinessRules;
   const fetchSecRules = deps.fetchSecurityRulesFn ?? fetchSecurityRules;
@@ -5059,7 +5394,7 @@ async function fetchRulesHook(deps = {}) {
   if (!event.filePath) return;
   const config = loadConfig();
   if (!config) return;
-  const { projectId, apiBase: configApiBase } = resolveProject();
+  const { projectId, apiBase: configApiBase } = await resolveProject();
   if (!projectId) return;
   const apiBase = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config.region.apiBase;
   const token = resolveTok(config.region.mcpName);
@@ -5152,119 +5487,10 @@ function composeSecurityBody(markdown, total, filePath) {
 
 // src/hooks/runtime/self-update-check.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
+import { existsSync as existsSync7, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
 import { join as join4 } from "node:path";
 
-// src/utils.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname, join as join3 } from "node:path";
-
-// node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/index.mjs
-var FORCE_COLOR;
-var NODE_DISABLE_COLORS;
-var NO_COLOR;
-var TERM;
-var isTTY = true;
-if (typeof process !== "undefined") {
-  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
-  isTTY = process.stdout && process.stdout.isTTY;
-}
-var $ = {
-  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY),
-  // modifiers
-  reset: init(0, 0),
-  bold: init(1, 22),
-  dim: init(2, 22),
-  italic: init(3, 23),
-  underline: init(4, 24),
-  inverse: init(7, 27),
-  hidden: init(8, 28),
-  strikethrough: init(9, 29),
-  // colors
-  black: init(30, 39),
-  red: init(31, 39),
-  green: init(32, 39),
-  yellow: init(33, 39),
-  blue: init(34, 39),
-  magenta: init(35, 39),
-  cyan: init(36, 39),
-  white: init(37, 39),
-  gray: init(90, 39),
-  grey: init(90, 39),
-  // background colors
-  bgBlack: init(40, 49),
-  bgRed: init(41, 49),
-  bgGreen: init(42, 49),
-  bgYellow: init(43, 49),
-  bgBlue: init(44, 49),
-  bgMagenta: init(45, 49),
-  bgCyan: init(46, 49),
-  bgWhite: init(47, 49)
-};
-function run(arr, str) {
-  let i = 0, tmp, beg = "", end = "";
-  for (; i < arr.length; i++) {
-    tmp = arr[i];
-    beg += tmp.open;
-    end += tmp.close;
-    if (!!~str.indexOf(tmp.close)) {
-      str = str.replace(tmp.rgx, tmp.close + tmp.open);
-    }
-  }
-  return beg + str + end;
-}
-function chain(has, keys) {
-  let ctx = { has, keys };
-  ctx.reset = $.reset.bind(ctx);
-  ctx.bold = $.bold.bind(ctx);
-  ctx.dim = $.dim.bind(ctx);
-  ctx.italic = $.italic.bind(ctx);
-  ctx.underline = $.underline.bind(ctx);
-  ctx.inverse = $.inverse.bind(ctx);
-  ctx.hidden = $.hidden.bind(ctx);
-  ctx.strikethrough = $.strikethrough.bind(ctx);
-  ctx.black = $.black.bind(ctx);
-  ctx.red = $.red.bind(ctx);
-  ctx.green = $.green.bind(ctx);
-  ctx.yellow = $.yellow.bind(ctx);
-  ctx.blue = $.blue.bind(ctx);
-  ctx.magenta = $.magenta.bind(ctx);
-  ctx.cyan = $.cyan.bind(ctx);
-  ctx.white = $.white.bind(ctx);
-  ctx.gray = $.gray.bind(ctx);
-  ctx.grey = $.grey.bind(ctx);
-  ctx.bgBlack = $.bgBlack.bind(ctx);
-  ctx.bgRed = $.bgRed.bind(ctx);
-  ctx.bgGreen = $.bgGreen.bind(ctx);
-  ctx.bgYellow = $.bgYellow.bind(ctx);
-  ctx.bgBlue = $.bgBlue.bind(ctx);
-  ctx.bgMagenta = $.bgMagenta.bind(ctx);
-  ctx.bgCyan = $.bgCyan.bind(ctx);
-  ctx.bgWhite = $.bgWhite.bind(ctx);
-  return ctx;
-}
-function init(open, close) {
-  let blk = {
-    open: `\x1B[${open}m`,
-    close: `\x1B[${close}m`,
-    rgx: new RegExp(`\\x1b\\[${close}m`, "g")
-  };
-  return function(txt) {
-    if (this !== void 0 && this.has !== void 0) {
-      !!~this.has.indexOf(open) || (this.has.push(open), this.keys.push(blk));
-      return txt === void 0 ? this : $.enabled ? run(this.keys, txt + "") : txt + "";
-    }
-    return txt === void 0 ? chain([open], [blk]) : $.enabled ? run([blk], txt + "") : txt + "";
-  };
-}
-
-// src/utils.ts
-function ensureDirFor(filePath) {
-  const dir = dirname(filePath);
-  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
-}
-
 // src/hooks/runtime/semver.ts
 function parseVersion(input) {
   const cleaned = input.trim().replace(/^v/i, "");
@@ -5291,7 +5517,7 @@ function isNewer(latest, current) {
 
 // src/self-update.ts
 import { fileURLToPath } from "node:url";
-import { existsSync as existsSync5, realpathSync } from "node:fs";
+import { existsSync as existsSync6, realpathSync } from "node:fs";
 var GLOBAL_MODES = /* @__PURE__ */ new Set([
   "npm-global",
   "pnpm-global",
@@ -5318,7 +5544,7 @@ function detectInstallMode(scriptPath) {
 }
 function resolveScriptPath() {
   const fromArgv = process.argv[1];
-  if (fromArgv && existsSync5(fromArgv)) {
+  if (fromArgv && existsSync6(fromArgv)) {
     try {
       return realpathSync(fromArgv);
     } catch {
@@ -5335,7 +5561,7 @@ var THROTTLE_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 async function selfUpdateCheck(deps) {
   const now = deps.now ?? (() => Date.now());
-  const dir = deps.cybeDir ?? join4(process.env.CYBEDEFEND_HOME ?? homedir3(), ".cybedefend");
+  const dir = deps.cybeDir ?? join4(process.env.CYBEDEFEND_HOME ?? homedir4(), ".cybedefend");
   const throttlePath = join4(dir, "update-check.json");
   const logPath = join4(dir, "last-update.log");
   const installMode = deps.installMode ?? (deps.runnerSource ? detectInstallMode(deps.runnerSource) : detectInstallMode(resolveScriptPath()));
@@ -5370,8 +5596,8 @@ function applyOrNotify(deps, installMode, latest, logPath) {
 }
 function readThrottle(path) {
   try {
-    if (!existsSync6(path)) return null;
-    const data = JSON.parse(readFileSync5(path, "utf8"));
+    if (!existsSync7(path)) return null;
+    const data = JSON.parse(readFileSync6(path, "utf8"));
     if (typeof data.lastCheckedAt !== "number") return null;
     return { lastCheckedAt: data.lastCheckedAt };
   } catch {
@@ -5381,16 +5607,16 @@ function readThrottle(path) {
 function writeThrottle(path, throttle) {
   try {
     ensureDirFor(path);
-    writeFileSync3(path, JSON.stringify(throttle) + "\n");
+    writeFileSync4(path, JSON.stringify(throttle) + "\n");
   } catch {
   }
 }
 function takeUpdateLogNotice(logPath) {
   try {
-    if (!existsSync6(logPath)) return null;
+    if (!existsSync7(logPath)) return null;
     let parsed = {};
     try {
-      parsed = JSON.parse(readFileSync5(logPath, "utf8"));
+      parsed = JSON.parse(readFileSync6(logPath, "utf8"));
     } catch {
       parsed = {};
     }
@@ -5464,18 +5690,18 @@ function pmCommand(mode, spec) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname3, join as join5 } from "node:path";
 var PKG_NAME = "@cybedefend/vibedefend";
 function defaultPkgPath() {
-  return join5(dirname2(fileURLToPath2(import.meta.url)), "..", "package.json");
+  return join5(dirname3(fileURLToPath2(import.meta.url)), "..", "package.json");
 }
 function readPackageMeta(opts = {}) {
   if (typeof opts.bakedVersion === "string" && opts.bakedVersion.length > 0) {
     return { name: PKG_NAME, version: opts.bakedVersion };
   }
-  const readFile = opts.readFile ?? ((p) => readFileSync6(p, "utf8"));
+  const readFile = opts.readFile ?? ((p) => readFileSync7(p, "utf8"));
   const pkgPath = opts.pkgPath ?? defaultPkgPath();
   try {
     return JSON.parse(readFile(pkgPath));
@@ -5484,14 +5710,14 @@ function readPackageMeta(opts = {}) {
   }
 }
 var pkg = readPackageMeta({
-  bakedVersion: true ? "1.3.1" : void 0
+  bakedVersion: true ? "1.4.0" : void 0
 });
 
 // src/hooks/runtime/session-start.ts
 async function sessionStartHook(deps = {}) {
   const readStdin = deps.readStdin ?? readStdinJson;
   const loadConfig = deps.loadConfig ?? loadRuntimeConfig;
-  const resolveProject = deps.resolveProject ?? resolveProjectId;
+  const resolveProject = deps.resolveProject ?? resolveProjectIdWithApi;
   const resolveTok = deps.resolveTokenFn ?? resolveToken;
   const fetchProposals = deps.fetchProposalsFn ?? fetchProposalsCount;
   const selfUpdateCheckFn = deps.selfUpdateCheckFn ?? selfUpdateCheck;
@@ -5500,7 +5726,7 @@ async function sessionStartHook(deps = {}) {
   const event = sniff(stdin);
   const config = loadConfig();
   if (!config) return;
-  const { projectId, apiBase: configApiBase } = resolveProject();
+  const { projectId, apiBase: configApiBase } = await resolveProject();
   if (!projectId) return;
   const apiBase = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config.region.apiBase;
   if (process.env.CYBEDEFEND_DRY_RUN === "1") {
@@ -5586,7 +5812,7 @@ async function sessionStartHook(deps = {}) {
 }
 
 // src/hooks/runtime/session-review.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
 var COUNTED_TOOLS = /* @__PURE__ */ new Set([
   "Edit",
   "Write",
@@ -5664,9 +5890,9 @@ function loadTranscript(stdin, readFile) {
   return out;
 }
 function defaultReadTranscript(path) {
-  if (!existsSync7(path)) return null;
+  if (!existsSync8(path)) return null;
   try {
-    return readFileSync7(path, "utf8");
+    return readFileSync8(path, "utf8");
   } catch {
     return null;
   }
@@ -5734,10 +5960,12 @@ function collectChangedFilesDeep(node, depth, out) {
   }
 }
 function relativizePath(p, cwd) {
-  if (cwd && p.startsWith(cwd.endsWith("/") ? cwd : cwd + "/")) {
-    return p.slice(cwd.endsWith("/") ? cwd.length : cwd.length + 1);
+  const np = p.replace(/\\/g, "/");
+  const nc = cwd.replace(/\\/g, "/");
+  if (nc && np.startsWith(nc.endsWith("/") ? nc : nc + "/")) {
+    return np.slice(nc.endsWith("/") ? nc.length : nc.length + 1);
   }
-  return p;
+  return np;
 }
 function extractChangedFiles(transcript, cap = CHANGED_FILES_MAX, cwd) {
   const out = /* @__PURE__ */ new Set();
@@ -5922,19 +6150,19 @@ async function preCompactHook(deps = {}) {
 }
 
 // src/hooks/runtime/user-prompt-submit.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
 import { join as join6 } from "node:path";
 var SESSIONS_CAP = 100;
 function defaultSessionsFile() {
-  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join6(homedir4(), ".cybedefend");
+  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join6(homedir5(), ".cybedefend");
   return join6(dir, "user-prompt-seen-sessions.json");
 }
 function defaultSessionTracker(file = defaultSessionsFile()) {
   function load() {
-    if (!existsSync8(file)) return [];
+    if (!existsSync9(file)) return [];
     try {
-      const raw = readFileSync8(file, "utf8");
+      const raw = readFileSync9(file, "utf8");
       const data = JSON.parse(raw);
       if (!Array.isArray(data.sessions)) return [];
       return data.sessions.filter((s) => typeof s === "string");
@@ -5951,8 +6179,8 @@ function defaultSessionTracker(file = defaultSessionsFile()) {
       if (existing.includes(sessionId)) return;
       const next = [...existing, sessionId].slice(-SESSIONS_CAP);
       try {
-        mkdirSync3(join6(file, ".."), { recursive: true });
-        writeFileSync4(file, JSON.stringify({ sessions: next }), "utf8");
+        mkdirSync4(join6(file, ".."), { recursive: true });
+        writeFileSync5(file, JSON.stringify({ sessions: next }), "utf8");
       } catch {
       }
     }
@@ -5961,7 +6189,7 @@ function defaultSessionTracker(file = defaultSessionsFile()) {
 async function userPromptSubmitHook(deps = {}) {
   const readStdin = deps.readStdin ?? readStdinJson;
   const loadConfig = deps.loadConfig ?? loadRuntimeConfig;
-  const resolveProject = deps.resolveProject ?? resolveProjectId;
+  const resolveProject = deps.resolveProject ?? resolveProjectIdWithApi;
   const resolveTok = deps.resolveTokenFn ?? resolveToken;
   const fetchProposals = deps.fetchProposalsFn ?? fetchProposalsCount;
   const emitFn = deps.emitFn ?? emit;
@@ -5974,7 +6202,7 @@ async function userPromptSubmitHook(deps = {}) {
   }
   const config = loadConfig();
   if (!config) return;
-  const { projectId, apiBase: configApiBase } = resolveProject();
+  const { projectId, apiBase: configApiBase } = await resolveProject();
   if (!projectId) return;
   const apiBase = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config.region.apiBase;
   const token = resolveTok(config.region.mcpName);
@@ -6780,7 +7008,7 @@ function nearMissCommand(target, rule) {
 function nearMissFile(target, rule, homeDir) {
   const globs = rule.filePathGlobs;
   if (!globs || globs.length === 0) return false;
-  const path = expandTilde(target.path, homeDir);
+  const path = expandTilde(target.path, homeDir).replace(/\\/g, "/");
   const base = basename(path);
   const segs = path.split("/");
   for (const g of globs) {
@@ -6871,12 +7099,12 @@ function nearMiss(req, rule) {
 }
 
 // src/hooks/runtime/guard-rules-cache.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 import { join as join7 } from "node:path";
 var DEFAULT_CACHE_FILE = join7(
-  homedir5(),
+  homedir6(),
   ".cybedefend",
   "guards-cache.json"
 );
@@ -6974,9 +7202,9 @@ function makeGuardRulesCache(opts) {
     }
   }
   function readCache(projectId) {
-    if (!existsSync9(cacheFile)) return null;
+    if (!existsSync10(cacheFile)) return null;
     try {
-      const raw = readFileSync9(cacheFile, "utf8");
+      const raw = readFileSync10(cacheFile, "utf8");
       const data = JSON.parse(raw);
       if (data.projectId !== projectId) return null;
       return data;
@@ -6987,16 +7215,16 @@ function makeGuardRulesCache(opts) {
   function writeCache(entry) {
     try {
       ensureDirFor2(cacheFile);
-      writeFileSync5(cacheFile, JSON.stringify(entry), "utf8");
+      writeFileSync6(cacheFile, JSON.stringify(entry), "utf8");
     } catch {
     }
   }
   return { refreshIfStale };
 }
 function ensureDirFor2(filePath) {
-  const dir = dirname3(filePath);
-  if (!existsSync9(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = dirname4(filePath);
+  if (!existsSync10(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
 }
 var DEFAULT_TIMEOUT_MS2 = 8e3;
@@ -7079,12 +7307,49 @@ async function callJudge(input, opts = {}) {
   }
 }
 
+// src/hooks/runtime/judge-injection.ts
+var SEP_RUN = /[.\-_/\\+,;\s]+/g;
+var SIGNALS = [
+  // A1a — verdict assignment with '=': decision=allow, answer=allow
+  /\b(decision|verdict|veredict|answer|result|output|response)\s*=\s*["']?(allow|block|approve|permit)\b/,
+  // A1b — verdict with a space separator (covers decision.allow / -allow / _allow)
+  /\b(decision|verdict)\s+["']?(allow|block)\b/,
+  // A2 — literal JSON verdict shape: {"decision":"allow"}
+  /["'](decision|verdict)["']\s*:\s*["'](allow|block)["']/,
+  // A3 — imperative verdict directive: reply allow, respond with allow
+  /\b(reply|respond|answer|say)\s+(with\s+|the\s+)?["']?(allow|block)\b/,
+  // A4 — permission imperative: you may allow this
+  /\byou\s+(must|should|may|can|are\s+to|need\s+to)\s+(allow|permit|approve|unblock)\b/,
+  // A5 — mark-as-safe / do-not-block
+  /\bmark(ed)?\s+(this|it)\s+(as\s+)?(safe|allowed|authori[sz]ed|approved)\b/,
+  /\bdo\s*not\s+block\b/,
+  /\bdon'?t\s+block\b/,
+  // A6 — "let it/this pass|through|proceed" (the reported "laisse passer")
+  /\blet\s+(it|this|the)\s+(command\s+|action\s+|tool\s+)?(pass|through|proceed)\b/,
+  // B — rule/guard nullification: strong verbs + the control-object noun
+  /\b(ignore|disregard|override|bypass|circumvent|nullify)\s+(the\s+|this\s+|all\s+|any\s+|previous\s+|above\s+|prior\s+)*(rule|rules|instruction|instructions|deny|denial|denies|policy|policies|check|checks|guard|guards|guardrail|guardrails|restriction|restrictions)\b/,
+  // C — role/meta break-in
+  /\b(you\s+are|as)\s+(the\s+|a\s+)?(security\s+)?(judge|reviewer|approver|arbiter)\b/,
+  /\bnew\s+instructions?\b/,
+  /<\s*\/?\s*(system|assistant|user|developer|tool)\b/
+];
+function normalize(text) {
+  const folded = text.normalize("NFKC").toLowerCase();
+  return folded.replace(SEP_RUN, " ").trim();
+}
+function detectPromptInjection(text) {
+  if (!text) return false;
+  const normalized = normalize(String(text));
+  if (!normalized) return false;
+  return SIGNALS.some((sig) => sig.test(normalized));
+}
+
 // src/hooks/runtime/judge-cache.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname as dirname5, join as join8 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 var DEFAULT_JUDGE_CACHE_FILE = join8(
-  homedir6(),
+  homedir7(),
   ".cybedefend",
   "guards-judge-cache.json"
 );
@@ -7094,9 +7359,9 @@ function makeJudgeCache(opts = {}) {
   const ttlMs = opts.ttlMs ?? DEFAULT_JUDGE_TTL_MS;
   const now = opts.now ?? (() => Date.now());
   function readAll() {
-    if (!existsSync10(cacheFile)) return {};
+    if (!existsSync11(cacheFile)) return {};
     try {
-      return JSON.parse(readFileSync10(cacheFile, "utf8"));
+      return JSON.parse(readFileSync11(cacheFile, "utf8"));
     } catch {
       return {};
     }
@@ -7116,36 +7381,36 @@ function makeJudgeCache(opts = {}) {
       }
       all[key] = { res, at: t };
       ensureDirFor3(cacheFile);
-      writeFileSync6(cacheFile, JSON.stringify(all), "utf8");
+      writeFileSync7(cacheFile, JSON.stringify(all), "utf8");
     } catch {
     }
   }
   return { get, set };
 }
 function ensureDirFor3(filePath) {
-  const dir = dirname4(filePath);
-  if (!existsSync10(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = dirname5(filePath);
+  if (!existsSync11(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
 }
 
 // src/hooks/runtime/guard-check.ts
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir9 } from "node:os";
 import { join as join10 } from "node:path";
 
 // src/hooks/runtime/guard-violations-buffer.ts
 import {
   appendFileSync,
-  existsSync as existsSync11,
-  readFileSync as readFileSync11,
-  writeFileSync as writeFileSync7,
-  mkdirSync as mkdirSync6
+  existsSync as existsSync12,
+  readFileSync as readFileSync12,
+  writeFileSync as writeFileSync8,
+  mkdirSync as mkdirSync7
 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { dirname as dirname6 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 import { join as join9 } from "node:path";
 var DEFAULT_BUFFER_FILE = join9(
-  homedir7(),
+  homedir8(),
   ".cybedefend",
   "guards-violations-buffer.jsonl"
 );
@@ -7164,10 +7429,10 @@ function makeViolationsBuffer(opts = {}) {
     }
   }
   async function flushViolations2(ctx, postFn) {
-    if (!existsSync11(bufferFile)) return;
+    if (!existsSync12(bufferFile)) return;
     let content;
     try {
-      content = readFileSync11(bufferFile, "utf8").trim();
+      content = readFileSync12(bufferFile, "utf8").trim();
     } catch {
       return;
     }
@@ -7186,7 +7451,7 @@ function makeViolationsBuffer(opts = {}) {
     }
     if (records.length === 0) {
       try {
-        writeFileSync7(bufferFile, "", "utf8");
+        writeFileSync8(bufferFile, "", "utf8");
       } catch {
       }
       return;
@@ -7216,10 +7481,10 @@ function makeViolationsBuffer(opts = {}) {
     }
     try {
       if (failed.length === 0) {
-        writeFileSync7(bufferFile, "", "utf8");
+        writeFileSync8(bufferFile, "", "utf8");
       } else {
         const serialised = failed.map((r) => JSON.stringify(r)).join("\n") + "\n";
-        writeFileSync7(bufferFile, serialised, "utf8");
+        writeFileSync8(bufferFile, serialised, "utf8");
       }
     } catch {
     }
@@ -7227,9 +7492,9 @@ function makeViolationsBuffer(opts = {}) {
   return { bufferViolation: bufferViolation2, flushViolations: flushViolations2 };
 }
 function ensureDirFor4(filePath) {
-  const dir = dirname5(filePath);
-  if (!existsSync11(dir)) {
-    mkdirSync6(dir, { recursive: true });
+  const dir = dirname6(filePath);
+  if (!existsSync12(dir)) {
+    mkdirSync7(dir, { recursive: true });
   }
 }
 var _defaultBuffer = makeViolationsBuffer();
@@ -7239,7 +7504,7 @@ var flushViolations = _defaultBuffer.flushViolations.bind(_defaultBuffer);
 // src/hooks/runtime/guard-check.ts
 function normalizeToolName(tool) {
   if (!tool) return "";
-  const t = tool.trim();
+  const t = (tool.split(/[\r\n]/, 1)[0] ?? "").trim();
   if (/^(read|read_file|cat)$/i.test(t)) return "Read";
   if (/^(write|create_file|new_file)$/i.test(t)) return "Write";
   if (/^(edit|apply_patch|str_replace_editor)$/i.test(t)) return "Edit";
@@ -7255,10 +7520,10 @@ function appendDebugLog(entry) {
   try {
     const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
     if (!homeDir) return;
-    const { mkdirSync: mkdirSync7, appendFileSync: appendFileSync2 } = __require("node:fs");
+    const { mkdirSync: mkdirSync8, appendFileSync: appendFileSync2 } = __require("node:fs");
     const { join: join11 } = __require("node:path");
     const dir = join11(homeDir, ".cybedefend");
-    mkdirSync7(dir, { recursive: true });
+    mkdirSync8(dir, { recursive: true });
     appendFileSync2(join11(dir, "hook-debug.log"), entry + "\n", "utf8");
   } catch {
   }
@@ -7448,6 +7713,14 @@ async function runJudgeStep(args) {
   if (decision.maxSeverity === "critical") return void 0;
   if (llmJudgeHint?.enabled === false) return void 0;
   const targetStr = stringifyTarget(request.target);
+  const injectionSurface = [
+    targetStr,
+    request.tool,
+    ...llmRules.flatMap((r) => [r.name ?? "", r.description ?? ""])
+  ].join("\n");
+  if (detectPromptInjection(injectionSurface)) {
+    return { engine: "llm", outcome: "injection_blocked" };
+  }
   const actionHash = hashTarget(targetStr);
   const ruleIds = llmRules.map((r) => r.id).sort().join(",");
   const cacheKey = `${actionHash}|${ruleIds}|confirm`;
@@ -7716,7 +7989,7 @@ function emitAgentMessage(verdict, message) {
 }
 function makeProductionJudgeDeps() {
   const cache = makeJudgeCache();
-  const warnDir = process.env.CYBEDEFEND_BASELINE_DIR ?? join10(homedir8(), ".cybedefend");
+  const warnDir = process.env.CYBEDEFEND_BASELINE_DIR ?? join10(homedir9(), ".cybedefend");
   const warnTracker = defaultSessionTracker(
     join10(warnDir, "guards-judge-warned-sessions.json")
   );
@@ -7740,7 +8013,7 @@ async function runPreToolUseGuard() {
     const envelope = await readStdinJson();
     const config = loadRuntimeConfig();
     if (!config) return 0;
-    const { projectId, apiBase: configApiBase } = resolveProjectId();
+    const { projectId, apiBase: configApiBase } = await resolveProjectIdWithApi();
     if (!projectId) return 0;
     const apiBaseResolved = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config.region.apiBase;
     const token = await resolveTokenWithRefresh(config.region.mcpName);