@cybedefend/vibedefend 1.4.6 → 1.5.0

package/dist/hook-runner.js

@@ -5764,26 +5764,34 @@ async function resolveProjectIdWithApi(cwd = process.cwd(), deps = {}) {
   const resolveSync = deps.resolveSync ?? resolveProjectId;
   const base = resolveSync(cwd);
   if (base.projectId) return base;
+  let repository;
+  const none = (inactiveReason) => ({
+    ...base,
+    inactiveReason,
+    ...repository ? { repository } : {}
+  });
   try {
     const getOrigin = deps.getOrigin ?? getOriginRemote;
     const originUrl = getOrigin(cwd);
-    if (!originUrl) return base;
+    if (!originUrl) return none("no-git-origin");
     const remote = parseRemoteUrl(originUrl);
-    if (!remote || remote.provider === null) return base;
+    if (!remote) return none("unsupported-remote");
+    repository = `${remote.host}/${remote.slug}`;
+    if (remote.provider === null) return none("unsupported-remote");
     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;
+      return none("no-linked-project");
     }
     const config = (deps.loadConfig ?? loadRuntimeConfig)();
-    if (!config) return base;
+    if (!config) return none("lookup-failed");
     const apiBase = base.apiBase ?? config.region.apiBase;
     const resolveTokenFn = deps.resolveTokenFn ?? resolveTokenWithRefresh;
     const token = await resolveTokenFn(config.region.mcpName);
-    if (!token) return base;
+    if (!token) return none("not-signed-in");
     const resolveByRepo = deps.resolveByRepo ?? resolveProjectByRepository;
     const matches = await resolveByRepo(
       apiBase,
@@ -5791,7 +5799,7 @@ async function resolveProjectIdWithApi(cwd = process.cwd(), deps = {}) {
       { provider: remote.provider, slug: remote.slug, host: remote.host },
       { timeoutMs: deps.timeoutMs ?? RESOLVE_API_TIMEOUT_MS }
     );
-    if (matches === null) return base;
+    if (matches === null) return none("lookup-failed");
     if (matches.length === 1 && matches[0].vibedefendEnabled !== false) {
       const m = matches[0];
       writeCachedRepoLink(
@@ -5802,13 +5810,171 @@ async function resolveProjectIdWithApi(cwd = process.cwd(), deps = {}) {
       return { projectId: m.projectId, apiBase: base.apiBase };
     }
     writeCachedRepoLink(key, { negative: true }, deps.cacheDeps);
-    return base;
+    return none("no-linked-project");
   } catch {
-    return base;
+    return none("lookup-failed");
   }
 }
 
+// src/hooks/runtime/usage-block.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname3, join as join5 } from "node:path";
+var BLOCKED_CODE = "VIBEDEFEND_BLOCKED";
+var USAGE_WARNING_HEADER = "x-vibedefend-usage-warning";
+var UNITS = ["injection", "judgment", "diff_scan"];
+var REASONS = [
+  "free_tier_exhausted",
+  "cap_reached",
+  "unpaid",
+  "product_inactive"
+];
+var WARNINGS = [
+  "approaching_limit",
+  "limit_reached"
+];
+function pick(allowed, value) {
+  return allowed.find((v) => v === value);
+}
+async function readVibedefendBlock(res) {
+  if (res.status !== 402) return null;
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return null;
+  }
+  if (!body || typeof body !== "object") return null;
+  const root = body;
+  const data = root.data && typeof root.data === "object" ? root.data : root;
+  const source = data.code === BLOCKED_CODE ? data : root;
+  if (source.code !== BLOCKED_CODE) return null;
+  return {
+    reason: pick(REASONS, source.reason) ?? "unknown",
+    unit: pick(UNITS, source.unit) ?? "unknown"
+  };
+}
+function readUsageWarning(res) {
+  let raw;
+  try {
+    raw = res.headers?.get?.(USAGE_WARNING_HEADER);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "string") return null;
+  const parts = raw.trim().split(":");
+  if (parts.length !== 2) return null;
+  const unit = pick(UNITS, parts[0]);
+  const warning = pick(WARNINGS, parts[1]);
+  if (!unit || !warning) return null;
+  return { unit, warning };
+}
+var UNIT_LABEL = {
+  injection: "Security rules injection",
+  judgment: "Action Guards judgments",
+  diff_scan: "Diff scans",
+  unknown: "Part of VibeDefend"
+};
+var UNIT_EFFECT = {
+  injection: "no security or business rules are added to your edits",
+  judgment: "Action Guards are off for this session",
+  diff_scan: "no diff scan can be started",
+  unknown: "part of VibeDefend is paused"
+};
+function blockSentence(block) {
+  const label = UNIT_LABEL[block.unit];
+  const effect = UNIT_EFFECT[block.unit];
+  switch (block.reason) {
+    case "free_tier_exhausted":
+      return `VibeDefend paused: ${label} used up this month's free tier, so ${effect}. An administrator of your organisation can add a card in the VibeDefend usage page to continue.`;
+    case "cap_reached":
+      return `VibeDefend paused: ${label} reached the monthly spending cap of your organisation, so ${effect}. An administrator can raise the cap in the VibeDefend usage page.`;
+    case "unpaid":
+      return "VibeDefend paused: your organisation's last VibeDefend invoice is unpaid, so rules, Action Guards and diff scans are off. An administrator can update the card in the VibeDefend usage page.";
+    case "product_inactive":
+      return "VibeDefend is not active for your organisation, so rules, Action Guards and diff scans are off. An administrator can activate it in the CybeDefend dashboard.";
+    default:
+      return `VibeDefend paused: ${label} is blocked for your organisation, so ${effect}. An administrator can check the VibeDefend usage page.`;
+  }
+}
+function warningSentence(w) {
+  const label = UNIT_LABEL[w.unit];
+  if (w.warning === "approaching_limit") {
+    return `VibeDefend: ${label} has used 80 % of this month's allowance of your organisation. An administrator can follow it in the VibeDefend usage page.`;
+  }
+  return `VibeDefend: ${label} has reached this month's limit of your organisation; the next requests will be refused. An administrator can add a card or raise the cap in the VibeDefend usage page.`;
+}
+var ORG_WIDE_REASONS = /* @__PURE__ */ new Set([
+  "unpaid",
+  "product_inactive"
+]);
+function blockKey(block) {
+  return ORG_WIDE_REASONS.has(block.reason) ? `block:${block.reason}` : `block:${block.reason}:${block.unit}`;
+}
+var NOTICES_CAP = 300;
+function defaultUsageNoticesFile() {
+  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join5(homedir6(), ".cybedefend");
+  return join5(dir, "usage-notices-sessions.json");
+}
+function makeUsageNotifier(opts = {}) {
+  const file = opts.file ?? defaultUsageNoticesFile();
+  const write = opts.write ?? ((line) => {
+    try {
+      process.stderr.write(line);
+    } catch {
+    }
+  });
+  function load() {
+    try {
+      if (!existsSync7(file)) return [];
+      const data = JSON.parse(readFileSync6(file, "utf8"));
+      return Array.isArray(data.seen) ? data.seen.filter((s) => typeof s === "string") : [];
+    } catch {
+      return [];
+    }
+  }
+  function once(sessionId, key, sentence) {
+    if (sessionId) {
+      const marker = `${sessionId}|${key}`;
+      const seen = load();
+      if (seen.includes(marker)) return null;
+      try {
+        mkdirSync4(dirname3(file), { recursive: true });
+        writeFileSync3(
+          file,
+          JSON.stringify({ seen: [...seen, marker].slice(-NOTICES_CAP) }),
+          "utf8"
+        );
+      } catch {
+      }
+    }
+    write(`[VibeDefend] ${sentence}
+`);
+    return sentence;
+  }
+  return {
+    notifyBlock: (sessionId, block) => once(sessionId, blockKey(block), blockSentence(block)),
+    notifyWarning: (sessionId, w) => once(sessionId, `warning:${w.unit}:${w.warning}`, warningSentence(w))
+  };
+}
+
 // src/hooks/runtime/api.ts
+async function reportUsageSignal(res, listener) {
+  const emit2 = (signal) => {
+    try {
+      listener?.(signal);
+    } catch {
+    }
+  };
+  if (!res.ok) {
+    const block = await readVibedefendBlock(res);
+    if (block) emit2({ kind: "blocked", block });
+    return false;
+  }
+  const warning = readUsageWarning(res);
+  if (warning) emit2({ kind: "warning", warning });
+  return true;
+}
 var DEFAULT_TIMEOUT_MS = 1e4;
 async function fetchBusinessRules(opts) {
   const f = opts.fetchImpl ?? globalThis.fetch;
@@ -5832,7 +5998,7 @@ async function fetchBusinessRules(opts) {
   } catch {
     return null;
   }
-  if (!res.ok) return null;
+  if (!await reportUsageSignal(res, opts.onUsageSignal)) return null;
   let body;
   try {
     body = await res.json();
@@ -5867,7 +6033,7 @@ async function fetchSecurityRules(opts) {
   } catch {
     return null;
   }
-  if (!res.ok) return null;
+  if (!await reportUsageSignal(res, opts.onUsageSignal)) return null;
   let body;
   try {
     body = await res.json();
@@ -5906,6 +6072,12 @@ async function fetchProposalsCount(opts) {
   return { total, raw: body };
 }
 
+// src/hooks/runtime/session-activation.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join6, resolve as resolvePath2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
 // src/hooks/runtime/emit.ts
 var ENVELOPE_CLIENTS = {
   SessionStart: /* @__PURE__ */ new Set(["codex"]),
@@ -5926,6 +6098,10 @@ function emit(body, client) {
 }
 function emitContext(body, client, hookEventName) {
   if (!body) return;
+  if (client === "cursor" && hookEventName === "SessionStart") {
+    process.stdout.write(JSON.stringify({ additional_context: body }) + "\n");
+    return;
+  }
   if (ENVELOPE_CLIENTS[hookEventName].has(client)) {
     const payload = JSON.stringify({
       hookSpecificOutput: {
@@ -5938,6 +6114,25 @@ function emitContext(body, client, hookEventName) {
   }
   emit(body, client);
 }
+var SYSTEM_MESSAGE_CLIENTS = /* @__PURE__ */ new Set([
+  "claude-code",
+  "codex"
+]);
+function emitSessionNotice(notice, client) {
+  if (SYSTEM_MESSAGE_CLIENTS.has(client)) {
+    process.stdout.write(
+      JSON.stringify({
+        systemMessage: notice.userMessage,
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: notice.modelContext
+        }
+      }) + "\n"
+    );
+    return;
+  }
+  emitContext(notice.modelContext, client, "SessionStart");
+}
 function emitStop(body, client, reason) {
   if (!body) return;
   if (client === "claude-code") {
@@ -5952,6 +6147,143 @@ function emitStop(body, client, reason) {
   emit(body, client);
 }
 
+// src/hooks/runtime/session-activation.ts
+var SETTLED_REASONS = /* @__PURE__ */ new Set([
+  "no-git-origin",
+  "unsupported-remote",
+  "no-linked-project"
+]);
+function isSettledReason(reason) {
+  return SETTLED_REASONS.has(reason);
+}
+var SESSIONS_CAP = 200;
+function defaultStoreFile() {
+  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join6(homedir7(), ".cybedefend");
+  return join6(dir, "inactive-sessions.json");
+}
+function defaultInactiveSessionStore(file = defaultStoreFile(), now = Date.now) {
+  function load() {
+    if (!existsSync8(file)) return {};
+    try {
+      const parsed = JSON.parse(readFileSync7(file, "utf8"));
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  function save(map) {
+    try {
+      mkdirSync5(dirname4(file), { recursive: true });
+      writeFileSync4(file, JSON.stringify(map) + "\n", "utf8");
+    } catch {
+    }
+  }
+  return {
+    get(sessionId) {
+      const rec = load()[sessionId];
+      if (!rec || typeof rec !== "object" || typeof rec.cwd !== "string" || typeof rec.reason !== "string") {
+        return null;
+      }
+      return rec;
+    },
+    mark(sessionId, record) {
+      const map = load();
+      map[sessionId] = { ...record, at: now() };
+      const entries = Object.entries(map);
+      if (entries.length > SESSIONS_CAP) {
+        entries.sort(([, a], [, b]) => (a.at ?? 0) - (b.at ?? 0));
+        save(Object.fromEntries(entries.slice(-SESSIONS_CAP)));
+        return;
+      }
+      save(map);
+    },
+    clear(sessionId) {
+      const map = load();
+      if (!(sessionId in map)) return;
+      delete map[sessionId];
+      save(map);
+    }
+  };
+}
+function sessionIdOf(stdin) {
+  for (const key of ["session_id", "sessionId", "conversation_id", "trajectory_id"]) {
+    const v = stdin[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return null;
+}
+function sessionFolderOf(stdin, client, env = process.env) {
+  const candidates = [];
+  if (client === "cursor") {
+    const roots = stdin.workspace_roots;
+    if (Array.isArray(roots)) candidates.push(roots[0]);
+    candidates.push(env.CURSOR_PROJECT_DIR);
+  }
+  candidates.push(stdin.cwd);
+  for (const c of candidates) {
+    const folder = absoluteFolder(c);
+    if (folder) return folder;
+  }
+  return process.cwd();
+}
+function absoluteFolder(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  let p = value;
+  if (p.startsWith("file://")) {
+    try {
+      p = fileURLToPath(p);
+    } catch {
+      return null;
+    }
+  }
+  return isAbsolute2(p) ? resolvePath2(p) : null;
+}
+function isSessionInactive(stdin, deps = {}) {
+  try {
+    const sessionId = sessionIdOf(stdin);
+    if (!sessionId) return false;
+    const record = (deps.store ?? defaultInactiveSessionStore()).get(sessionId);
+    if (!record || !isSettledReason(record.reason)) return false;
+    const cwd = deps.cwd ?? process.cwd();
+    if (record.cwd !== cwd) return false;
+    const resolveSync = deps.resolveSync ?? resolveProjectId;
+    return !resolveSync(cwd).projectId;
+  } catch {
+    return false;
+  }
+}
+function whyInactive(reason, repository) {
+  const repo = repository ? `\`${repository}\`` : "this folder";
+  switch (reason) {
+    case "no-git-origin":
+      return "this folder has no `.cybedefend/config.json` and no GitHub or GitLab `origin` remote";
+    case "unsupported-remote":
+      return `this folder has no \`.cybedefend/config.json\` and its git \`origin\`${repository ? ` (${repo})` : ""} is not on GitHub or GitLab`;
+    case "no-linked-project":
+      return `this folder has no \`.cybedefend/config.json\` and no CybeDefend project with VibeDefend enabled matches ${repo}`;
+    case "not-signed-in":
+      return `you are not signed in, so the CybeDefend project for ${repo} could not be looked up`;
+    case "lookup-failed":
+      return `the CybeDefend API did not answer, so the project for ${repo} could not be looked up`;
+  }
+}
+function composeInactiveNotice(reason, repository, client) {
+  const why = whyInactive(reason, repository);
+  const settled = isSettledReason(reason);
+  const userMessage = settled ? `\u{1F6E1}\uFE0F CybeDefend is off for this session: ${why}. Run \`vibedefend link\` in this folder to turn it on.` : reason === "not-signed-in" ? `\u{1F6E1}\uFE0F CybeDefend is off for now: ${why}. Run \`vibedefend login\` to turn it on.` : `\u{1F6E1}\uFE0F CybeDefend is off for now: ${why}. It will try again on the next prompt or edit.`;
+  const scope = settled ? "- Its hooks stay off until this session ends: no rules fetch, no proposal inbox, no Action Guards, no end-of-session review." : "- Its hooks stay quiet until the project can be found.";
+  const relay = SYSTEM_MESSAGE_CLIENTS.has(client) ? "- The user has already been shown this notice; do not repeat it." : "- Tell the user once, in one short line, that CybeDefend is off for this session and why.";
+  const modelContext = [
+    "## CybeDefend is not active in this session",
+    `CybeDefend found no project for this folder: ${why}.`,
+    scope,
+    "- Do not call CybeDefend MCP tools, run the CybeDefend workflow or ask for a CybeDefend project id unless the user asks about CybeDefend.",
+    relay,
+    ""
+  ].join("\n");
+  return { userMessage, modelContext };
+}
+
 // src/hooks/runtime/fetch-rules.ts
 function emitPreToolUseContext(body, client) {
   emitContext(body, client, "PreToolUse");
@@ -5971,13 +6303,16 @@ async function fetchRulesHook(deps = {}) {
   const fetchRules = deps.fetchRulesFn ?? fetchBusinessRules;
   const fetchSecRules = deps.fetchSecurityRulesFn ?? fetchSecurityRules;
   const emitFn = deps.emitFn ?? emitPreToolUseContext;
+  const usageNotifier = deps.usageNotifier ?? makeUsageNotifier();
   const stdin = await readStdin();
   const event = sniff(stdin);
   if (!INTERESTED_TOOLS.has(event.toolName)) return;
   if (!event.filePath) return;
   const config = loadConfig();
   if (!config) return;
-  const { projectId, apiBase: configApiBase } = await resolveProject();
+  const folder = sessionFolderOf(stdin, event.client);
+  if (isSessionInactive(stdin, { store: deps.sessionStore, cwd: folder })) return;
+  const { projectId, apiBase: configApiBase } = await resolveProject(folder);
   if (!projectId) return;
   const apiBase = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config.region.apiBase;
   const token = resolveTok(config.region.mcpName, {
@@ -5987,13 +6322,20 @@ async function fetchRulesHook(deps = {}) {
   const intent = buildIntent(event);
   const files = event.filePaths.length > 0 ? event.filePaths : [event.filePath];
   const fileLabel = files.join(", ");
+  const sessionId = sessionIdOf2(stdin);
+  const usageNotices = [];
+  const onUsageSignal = (signal) => {
+    const sentence = signal.kind === "blocked" ? usageNotifier.notifyBlock(sessionId, signal.block) : usageNotifier.notifyWarning(sessionId, signal.warning);
+    if (sentence) usageNotices.push(sentence);
+  };
   const fetchOpts = {
     apiBase,
     projectId,
     token,
     files,
     intent,
-    topK: 5
+    topK: 5,
+    onUsageSignal
   };
   const [businessResult, securityResult] = await Promise.all([
     fetchRules(fetchOpts),
@@ -6017,8 +6359,18 @@ async function fetchRulesHook(deps = {}) {
       )
     );
   }
+  if (usageNotices.length > 0) {
+    blocks.push(
+      ["## CybeDefend VibeDefend usage", ...usageNotices.map((n) => `- ${n}`), ""].join("\n")
+    );
+  }
   if (blocks.length > 0) emitFn(blocks.join("\n"), event.client);
 }
+function sessionIdOf2(stdin) {
+  if (typeof stdin.session_id === "string" && stdin.session_id) return stdin.session_id;
+  if (typeof stdin.sessionId === "string" && stdin.sessionId) return stdin.sessionId;
+  return void 0;
+}
 function buildIntent(event) {
   const limit = parseInt(process.env.CYBEDEFEND_INTENT_BYTES ?? "800", 10);
   const snippet = event.newContent.slice(0, Number.isFinite(limit) ? limit : 800).replace(/\s+/g, " ").trim();
@@ -6099,9 +6451,9 @@ var DIRECT_PROPOSE_DIRECTIVES = {
 
 // src/hooks/runtime/self-update-check.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync8, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join7 } from "node:path";
 
 // src/hooks/runtime/semver.ts
 function parseVersion(input) {
@@ -6128,8 +6480,8 @@ function isNewer(latest, current) {
 }
 
 // src/self-update.ts
-import { fileURLToPath } from "node:url";
-import { existsSync as existsSync7, realpathSync } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { existsSync as existsSync9, realpathSync } from "node:fs";
 var GLOBAL_MODES = /* @__PURE__ */ new Set([
   "npm-global",
   "pnpm-global",
@@ -6157,14 +6509,14 @@ function detectInstallMode(scriptPath) {
 }
 function resolveScriptPath() {
   const fromArgv = process.argv[1];
-  if (fromArgv && existsSync7(fromArgv)) {
+  if (fromArgv && existsSync9(fromArgv)) {
     try {
       return realpathSync(fromArgv);
     } catch {
       return fromArgv;
     }
   }
-  return fileURLToPath(import.meta.url);
+  return fileURLToPath2(import.meta.url);
 }
 
 // src/hooks/runtime/self-update-check.ts
@@ -6179,9 +6531,9 @@ function isValidRegistryVersion(value) {
 }
 async function selfUpdateCheck(deps) {
   const now = deps.now ?? (() => Date.now());
-  const dir = deps.cybeDir ?? join5(process.env.CYBEDEFEND_HOME ?? homedir6(), ".cybedefend");
-  const throttlePath = join5(dir, "update-check.json");
-  const logPath = join5(dir, "last-update.log");
+  const dir = deps.cybeDir ?? join7(process.env.CYBEDEFEND_HOME ?? homedir8(), ".cybedefend");
+  const throttlePath = join7(dir, "update-check.json");
+  const logPath = join7(dir, "last-update.log");
   const installMode = deps.installMode ?? (deps.runnerSource ? detectInstallMode(deps.runnerSource) : detectInstallMode(resolveScriptPath()));
   const priorFailure = takeUpdateLogNotice(logPath);
   const throttle = readThrottle(throttlePath);
@@ -6214,8 +6566,8 @@ function applyOrNotify(deps, installMode, latest, logPath) {
 }
 function readThrottle(path) {
   try {
-    if (!existsSync8(path)) return null;
-    const data = JSON.parse(readFileSync6(path, "utf8"));
+    if (!existsSync10(path)) return null;
+    const data = JSON.parse(readFileSync8(path, "utf8"));
     if (typeof data.lastCheckedAt !== "number") return null;
     return { lastCheckedAt: data.lastCheckedAt };
   } catch {
@@ -6225,16 +6577,16 @@ function readThrottle(path) {
 function writeThrottle(path, throttle) {
   try {
     ensureDirFor(path);
-    writeFileSync3(path, JSON.stringify(throttle) + "\n");
+    writeFileSync5(path, JSON.stringify(throttle) + "\n");
   } catch {
   }
 }
 function takeUpdateLogNotice(logPath) {
   try {
-    if (!existsSync8(logPath)) return null;
+    if (!existsSync10(logPath)) return null;
     let parsed = {};
     try {
-      parsed = JSON.parse(readFileSync6(logPath, "utf8"));
+      parsed = JSON.parse(readFileSync8(logPath, "utf8"));
     } catch {
       parsed = {};
     }
@@ -6309,18 +6661,18 @@ function pmCommand(mode, spec) {
 
 // src/hooks/runtime/hook-refresh-trigger.ts
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname3, join as join6 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname5, join as join8 } from "node:path";
 function maybeRefreshStaleWiring(deps) {
   try {
     const { config, runnerVersion } = deps;
     if (!config.runnerSource || config.installedVersion === runnerVersion) {
       return false;
     }
-    const cliEntry = join6(dirname3(dirname3(config.runnerSource)), "bin", "vibedefend.js");
-    if (!(deps.exists ?? existsSync9)(cliEntry)) return false;
-    const markerPath = deps.markerPath ?? join6(process.env.CYBEDEFEND_HOME ?? homedir7(), ".cybedefend", "hook-refresh.json");
+    const cliEntry = join8(dirname5(dirname5(config.runnerSource)), "bin", "vibedefend.js");
+    if (!(deps.exists ?? existsSync11)(cliEntry)) return false;
+    const markerPath = deps.markerPath ?? join8(process.env.CYBEDEFEND_HOME ?? homedir9(), ".cybedefend", "hook-refresh.json");
     if (readMarkerVersion(markerPath) === runnerVersion) return false;
     (deps.spawnRefresh ?? defaultSpawnRefresh)(cliEntry);
     writeMarker(markerPath, runnerVersion);
@@ -6331,8 +6683,8 @@ function maybeRefreshStaleWiring(deps) {
 }
 function readMarkerVersion(path) {
   try {
-    if (!existsSync9(path)) return null;
-    const data = JSON.parse(readFileSync7(path, "utf8"));
+    if (!existsSync11(path)) return null;
+    const data = JSON.parse(readFileSync9(path, "utf8"));
     return typeof data.version === "string" ? data.version : null;
   } catch {
     return null;
@@ -6341,7 +6693,7 @@ function readMarkerVersion(path) {
 function writeMarker(path, version) {
   try {
     ensureDirFor(path);
-    writeFileSync4(path, JSON.stringify({ version, spawnedAt: Date.now() }) + "\n");
+    writeFileSync6(path, JSON.stringify({ version, spawnedAt: Date.now() }) + "\n");
   } catch {
   }
 }
@@ -6355,18 +6707,18 @@ function defaultSpawnRefresh(cliEntry) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname6, join as join9 } from "node:path";
 var PKG_NAME = "@cybedefend/vibedefend";
 function defaultPkgPath() {
-  return join7(dirname4(fileURLToPath2(import.meta.url)), "..", "package.json");
+  return join9(dirname6(fileURLToPath3(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) => readFileSync8(p, "utf8"));
+  const readFile = opts.readFile ?? ((p) => readFileSync10(p, "utf8"));
   const pkgPath = opts.pkgPath ?? defaultPkgPath();
   try {
     return JSON.parse(readFile(pkgPath));
@@ -6375,13 +6727,22 @@ function readPackageMeta(opts = {}) {
   }
 }
 var pkg = readPackageMeta({
-  bakedVersion: true ? "1.4.6" : void 0
+  bakedVersion: true ? "1.5.0" : void 0
 });
 
 // src/hooks/runtime/session-start.ts
 function emitSessionStartContext(body, client) {
   emitContext(body, client, "SessionStart");
 }
+function announceInactive(resolution, sessionId, cwd, store, client, emitNoticeFn) {
+  const reason = resolution.inactiveReason ?? "no-linked-project";
+  if (sessionId) {
+    const prior = store.get(sessionId);
+    if (prior && prior.cwd === cwd && prior.reason === reason) return;
+    store.mark(sessionId, { cwd, reason });
+  }
+  emitNoticeFn(composeInactiveNotice(reason, resolution.repository, client), client);
+}
 async function sessionStartHook(deps = {}) {
   const readStdin = deps.readStdin ?? readStdinJson;
   const loadConfig = deps.loadConfig ?? loadRuntimeConfig;
@@ -6390,6 +6751,7 @@ async function sessionStartHook(deps = {}) {
   const fetchProposals = deps.fetchProposalsFn ?? fetchProposalsCount;
   const selfUpdateCheckFn = deps.selfUpdateCheckFn ?? selfUpdateCheck;
   const emitFn = deps.emitFn ?? emitSessionStartContext;
+  const emitNoticeFn = deps.emitNoticeFn ?? emitSessionNotice;
   const stdin = await readStdin();
   const event = sniff(stdin);
   const config = loadConfig();
@@ -6398,8 +6760,16 @@ async function sessionStartHook(deps = {}) {
     config,
     runnerVersion: pkg.version
   });
-  const { projectId, apiBase: configApiBase } = await resolveProject();
-  if (!projectId) return;
+  const folder = sessionFolderOf(stdin, event.client);
+  const resolution = await resolveProject(folder);
+  const { projectId, apiBase: configApiBase } = resolution;
+  const sessionStore = deps.sessionStore ?? defaultInactiveSessionStore();
+  const sessionId = sessionIdOf(stdin);
+  if (!projectId) {
+    announceInactive(resolution, sessionId, folder, sessionStore, event.client, emitNoticeFn);
+    return;
+  }
+  if (sessionId) sessionStore.clear(sessionId);
   const apiBase = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config.region.apiBase;
   if (process.env.CYBEDEFEND_DRY_RUN === "1") {
     emitFn(
@@ -6491,7 +6861,7 @@ async function sessionStartHook(deps = {}) {
 }
 
 // src/hooks/runtime/session-review.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
 var COUNTED_TOOLS = /* @__PURE__ */ new Set([
   "Edit",
   "Write",
@@ -6533,6 +6903,10 @@ async function sessionReviewHook(deps = {}) {
   }
   if (editCount === 0) return;
   if (editCount < resolveReviewThreshold(config)) return;
+  const folder = sessionFolderOf(stdin, event.client);
+  if (isSessionInactive(stdin, { store: deps.sessionStore, cwd: folder })) return;
+  const { projectId } = await (deps.resolveProject ?? resolveProjectIdWithApi)(folder);
+  if (!projectId) return;
   const userPrompt = extractFirstUserPrompt(transcript);
   const proposalMode = resolveProposalMode(config);
   let body = composeReviewBody(
@@ -6543,8 +6917,7 @@ async function sessionReviewHook(deps = {}) {
   );
   const withDiffScan = config.hooks.enableDiffScan !== false;
   if (withDiffScan) {
-    const cwd = typeof stdin.cwd === "string" && stdin.cwd ? stdin.cwd : process.cwd();
-    body += "\n" + composeDiffScanBody(extractChangedFiles(transcript, void 0, cwd));
+    body += "\n" + composeDiffScanBody(extractChangedFiles(transcript, void 0, folder));
   }
   emitFn(body, event.client, composeStopReason(withDiffScan, proposalMode));
 }
@@ -6575,9 +6948,9 @@ function loadTranscript(stdin, readFile) {
   return out;
 }
 function defaultReadTranscript(path) {
-  if (!existsSync10(path)) return null;
+  if (!existsSync12(path)) return null;
   try {
-    return readFileSync9(path, "utf8");
+    return readFileSync11(path, "utf8");
   } catch {
     return null;
   }
@@ -6810,6 +7183,10 @@ async function preCompactHook(deps = {}) {
   const config = loadConfig();
   if (!config) return;
   if (!config.hooks.enableSessionReview) return;
+  const folder = sessionFolderOf(stdin, event.client);
+  if (isSessionInactive(stdin, { store: deps.sessionStore, cwd: folder })) return;
+  const { projectId } = await (deps.resolveProject ?? resolveProjectIdWithApi)(folder);
+  if (!projectId) return;
   if (process.env.CYBEDEFEND_DRY_RUN === "1") {
     emitFn(
       `## \u{1F6E1}\uFE0F CybeDefend PreCompact (dry-run, client=${event.client})
@@ -6837,19 +7214,19 @@ async function preCompactHook(deps = {}) {
 }
 
 // src/hooks/runtime/user-prompt-submit.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join8 } from "node:path";
-var SESSIONS_CAP = 100;
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join10 } from "node:path";
+var SESSIONS_CAP2 = 100;
 function defaultSessionsFile() {
-  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join8(homedir8(), ".cybedefend");
-  return join8(dir, "user-prompt-seen-sessions.json");
+  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join10(homedir10(), ".cybedefend");
+  return join10(dir, "user-prompt-seen-sessions.json");
 }
 function defaultSessionTracker(file = defaultSessionsFile()) {
   function load() {
-    if (!existsSync11(file)) return [];
+    if (!existsSync13(file)) return [];
     try {
-      const raw = readFileSync10(file, "utf8");
+      const raw = readFileSync12(file, "utf8");
       const data = JSON.parse(raw);
       if (!Array.isArray(data.sessions)) return [];
       return data.sessions.filter((s) => typeof s === "string");
@@ -6864,10 +7241,10 @@ function defaultSessionTracker(file = defaultSessionsFile()) {
     async markSeen(sessionId) {
       const existing = load();
       if (existing.includes(sessionId)) return;
-      const next = [...existing, sessionId].slice(-SESSIONS_CAP);
+      const next = [...existing, sessionId].slice(-SESSIONS_CAP2);
       try {
-        mkdirSync4(join8(file, ".."), { recursive: true });
-        writeFileSync5(file, JSON.stringify({ sessions: next }), "utf8");
+        mkdirSync6(join10(file, ".."), { recursive: true });
+        writeFileSync7(file, JSON.stringify({ sessions: next }), "utf8");
       } catch {
       }
     }
@@ -6889,7 +7266,9 @@ async function userPromptSubmitHook(deps = {}) {
   }
   const config = loadConfig();
   if (!config) return;
-  const { projectId, apiBase: configApiBase } = await resolveProject();
+  const folder = sessionFolderOf(stdin, event.client);
+  if (isSessionInactive(stdin, { store: deps.sessionStore, cwd: folder })) return;
+  const { projectId, apiBase: configApiBase } = await resolveProject(folder);
   if (!projectId) return;
   const apiBase = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config.region.apiBase;
   const token = resolveTok(config.region.mcpName, {
@@ -7938,10 +8317,10 @@ function nearMiss(req, rule) {
 }
 
 // src/hooks/runtime/guard-rules-cache.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync12, mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
-import { homedir as homedir9 } from "node:os";
-import { join as join9 } from "node:path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync8, existsSync as existsSync14, mkdirSync as mkdirSync7 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join11 } from "node:path";
 
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -12053,8 +12432,8 @@ function parseRuleFields(raw) {
 }
 
 // src/hooks/runtime/guard-rules-cache.ts
-var DEFAULT_CACHE_FILE = join9(
-  homedir9(),
+var DEFAULT_CACHE_FILE = join11(
+  homedir11(),
   ".cybedefend",
   "guards-cache.json"
 );
@@ -12134,14 +12513,26 @@ function makeGuardRulesCache(opts) {
     const entry = readCache(ctx.projectId);
     const ageSec = entry ? (Date.now() - entry.fetchedAt) / 1e3 : Infinity;
     if (entry && ageSec < staleSec) {
+      if (entry.blocked) return { kind: "blocked", block: entry.blocked };
       return { kind: "rules", rules: entry.rules, llmJudge: entry.llmJudge };
     }
     try {
       const result = await fetchFn({
         ...ctx,
-        etag: entry?.etag ?? null
+        etag: entry?.blocked ? null : entry?.etag ?? null
       });
-      if (result.notModified && entry) {
+      if (result.blocked) {
+        writeCache({
+          projectId: ctx.projectId,
+          rules: [],
+          etag: null,
+          fetchedAt: Date.now(),
+          llmJudge: null,
+          blocked: result.blocked
+        });
+        return { kind: "blocked", block: result.blocked };
+      }
+      if (result.notModified && entry && !entry.blocked) {
         writeCache({
           ...entry,
           fetchedAt: Date.now()
@@ -12163,7 +12554,7 @@ function makeGuardRulesCache(opts) {
       return { kind: "rules", rules: fresh.rules, llmJudge: fresh.llmJudge };
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      if (entry?.rules?.length) {
+      if (entry?.rules?.length && !entry.blocked) {
         const ageSec2 = Math.round((Date.now() - entry.fetchedAt) / 1e3);
         process.stderr.write(
           `[VibeDefend] Action Guards: rule refresh failed (${msg}). Using cached rules (age=${ageSec2}s).
@@ -12178,9 +12569,9 @@ function makeGuardRulesCache(opts) {
     }
   }
   function readCache(projectId) {
-    if (!existsSync12(cacheFile)) return null;
+    if (!existsSync14(cacheFile)) return null;
     try {
-      const raw = readFileSync11(cacheFile, "utf8");
+      const raw = readFileSync13(cacheFile, "utf8");
       const data = JSON.parse(raw);
       if (data.projectId !== projectId) return null;
       return data;
@@ -12191,16 +12582,16 @@ function makeGuardRulesCache(opts) {
   function writeCache(entry) {
     try {
       ensureDirFor2(cacheFile);
-      writeFileSync6(cacheFile, JSON.stringify(entry), "utf8");
+      writeFileSync8(cacheFile, JSON.stringify(entry), "utf8");
     } catch {
     }
   }
   return { refreshIfStale };
 }
 function ensureDirFor2(filePath) {
-  const dir = dirname5(filePath);
-  if (!existsSync12(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = dirname7(filePath);
+  if (!existsSync14(dir)) {
+    mkdirSync7(dir, { recursive: true });
   }
 }
 var DEFAULT_TIMEOUT_MS2 = 8e3;
@@ -12223,6 +12614,10 @@ async function fetchEffectiveRulesFromGateway(ctx, opts = {}) {
     return { rules: [], etag: ctx.etag ?? null, notModified: true };
   }
   if (!res.ok) {
+    const blocked = await readVibedefendBlock(res);
+    if (blocked) {
+      return { rules: [], etag: null, notModified: false, blocked };
+    }
     throw new Error(`HTTP ${res.status} from effective-rules endpoint`);
   }
   const body = await res.json();
@@ -12243,6 +12638,9 @@ function parseLlmJudgeHint(raw) {
 }
 
 // src/hooks/runtime/judge.ts
+function isJudgeBlocked(res) {
+  return res !== null && "blocked" in res;
+}
 var DEFAULT_TIMEOUT_MS3 = 1500;
 async function callJudge(input, opts = {}) {
   const f = opts.fetchImpl ?? globalThis.fetch;
@@ -12266,7 +12664,11 @@ async function callJudge(input, opts = {}) {
       }),
       signal: AbortSignal.timeout(timeoutMs)
     });
-    if (!res.ok) return null;
+    if (!res.ok) {
+      const blocked = await readVibedefendBlock(res);
+      return blocked ? { blocked } : null;
+    }
+    const usageWarning = readUsageWarning(res);
     const body = await res.json();
     const data = body.data ?? body;
     const decision = data["decision"];
@@ -12276,7 +12678,8 @@ async function callJudge(input, opts = {}) {
       reason: typeof data["reason"] === "string" ? data["reason"] : "",
       model: typeof data["model"] === "string" ? data["model"] : "",
       quotaRemaining: typeof data["quota_remaining"] === "number" ? data["quota_remaining"] : -1,
-      quotaExceeded: Boolean(data["quota_exceeded"])
+      quotaExceeded: Boolean(data["quota_exceeded"]),
+      ...usageWarning ? { usageWarning } : {}
     };
   } catch {
     return null;
@@ -12321,11 +12724,11 @@ function detectPromptInjection(text) {
 }
 
 // src/hooks/runtime/judge-cache.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname6, join as join10 } from "node:path";
-import { homedir as homedir10 } from "node:os";
-var DEFAULT_JUDGE_CACHE_FILE = join10(
-  homedir10(),
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, existsSync as existsSync15, mkdirSync as mkdirSync8 } from "node:fs";
+import { dirname as dirname8, join as join12 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+var DEFAULT_JUDGE_CACHE_FILE = join12(
+  homedir12(),
   ".cybedefend",
   "guards-judge-cache.json"
 );
@@ -12335,9 +12738,9 @@ function makeJudgeCache(opts = {}) {
   const ttlMs = opts.ttlMs ?? DEFAULT_JUDGE_TTL_MS;
   const now = opts.now ?? (() => Date.now());
   function readAll() {
-    if (!existsSync13(cacheFile)) return {};
+    if (!existsSync15(cacheFile)) return {};
     try {
-      return JSON.parse(readFileSync12(cacheFile, "utf8"));
+      return JSON.parse(readFileSync14(cacheFile, "utf8"));
     } catch {
       return {};
     }
@@ -12357,36 +12760,36 @@ function makeJudgeCache(opts = {}) {
       }
       all[key] = { res, at: t };
       ensureDirFor3(cacheFile);
-      writeFileSync7(cacheFile, JSON.stringify(all), "utf8");
+      writeFileSync9(cacheFile, JSON.stringify(all), "utf8");
     } catch {
     }
   }
   return { get, set };
 }
 function ensureDirFor3(filePath) {
-  const dir = dirname6(filePath);
-  if (!existsSync13(dir)) {
-    mkdirSync6(dir, { recursive: true });
+  const dir = dirname8(filePath);
+  if (!existsSync15(dir)) {
+    mkdirSync8(dir, { recursive: true });
   }
 }
 
 // src/hooks/runtime/guard-check.ts
-import { homedir as homedir12 } from "node:os";
-import { join as join12 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join14 } from "node:path";
 
 // src/hooks/runtime/guard-violations-buffer.ts
 import {
   appendFileSync,
-  existsSync as existsSync14,
-  readFileSync as readFileSync13,
-  writeFileSync as writeFileSync8,
-  mkdirSync as mkdirSync7
+  existsSync as existsSync16,
+  readFileSync as readFileSync15,
+  writeFileSync as writeFileSync10,
+  mkdirSync as mkdirSync9
 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
-import { homedir as homedir11 } from "node:os";
-import { join as join11 } from "node:path";
-var DEFAULT_BUFFER_FILE = join11(
-  homedir11(),
+import { dirname as dirname9 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join13 } from "node:path";
+var DEFAULT_BUFFER_FILE = join13(
+  homedir13(),
   ".cybedefend",
   "guards-violations-buffer.jsonl"
 );
@@ -12405,10 +12808,10 @@ function makeViolationsBuffer(opts = {}) {
     }
   }
   async function flushViolations2(ctx, postFn) {
-    if (!existsSync14(bufferFile)) return;
+    if (!existsSync16(bufferFile)) return;
     let content;
     try {
-      content = readFileSync13(bufferFile, "utf8").trim();
+      content = readFileSync15(bufferFile, "utf8").trim();
     } catch {
       return;
     }
@@ -12427,7 +12830,7 @@ function makeViolationsBuffer(opts = {}) {
     }
     if (records.length === 0) {
       try {
-        writeFileSync8(bufferFile, "", "utf8");
+        writeFileSync10(bufferFile, "", "utf8");
       } catch {
       }
       return;
@@ -12457,10 +12860,10 @@ function makeViolationsBuffer(opts = {}) {
     }
     try {
       if (failed.length === 0) {
-        writeFileSync8(bufferFile, "", "utf8");
+        writeFileSync10(bufferFile, "", "utf8");
       } else {
         const serialised = failed.map((r) => JSON.stringify(r)).join("\n") + "\n";
-        writeFileSync8(bufferFile, serialised, "utf8");
+        writeFileSync10(bufferFile, serialised, "utf8");
       }
     } catch {
     }
@@ -12468,9 +12871,9 @@ function makeViolationsBuffer(opts = {}) {
   return { bufferViolation: bufferViolation2, flushViolations: flushViolations2 };
 }
 function ensureDirFor4(filePath) {
-  const dir = dirname7(filePath);
-  if (!existsSync14(dir)) {
-    mkdirSync7(dir, { recursive: true });
+  const dir = dirname9(filePath);
+  if (!existsSync16(dir)) {
+    mkdirSync9(dir, { recursive: true });
   }
 }
 var _defaultBuffer = makeViolationsBuffer();
@@ -12496,11 +12899,11 @@ function appendDebugLog(entry) {
   try {
     const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
     if (!homeDir) return;
-    const { mkdirSync: mkdirSync8, appendFileSync: appendFileSync2 } = __require("node:fs");
-    const { join: join13 } = __require("node:path");
-    const dir = join13(homeDir, ".cybedefend");
-    mkdirSync8(dir, { recursive: true });
-    appendFileSync2(join13(dir, "hook-debug.log"), entry + "\n", "utf8");
+    const { mkdirSync: mkdirSync10, appendFileSync: appendFileSync2 } = __require("node:fs");
+    const { join: join15 } = __require("node:path");
+    const dir = join15(homeDir, ".cybedefend");
+    mkdirSync10(dir, { recursive: true });
+    appendFileSync2(join15(dir, "hook-debug.log"), entry + "\n", "utf8");
   } catch {
   }
 }
@@ -12671,6 +13074,28 @@ function stringifyTarget(t) {
       return `git ${t.subcommand}`;
   }
 }
+async function consultJudge(judge, sessionId, cacheKey, input) {
+  const cached = judge.cacheGet(cacheKey);
+  if (cached) return { kind: "result", res: cached };
+  if (judge.usage?.isBlocked(sessionId)) return { kind: "blocked" };
+  const answer = await judge.callJudge(input);
+  if (isJudgeBlocked(answer)) {
+    if (judge.usage) {
+      judge.usage.markBlocked(sessionId);
+      judge.usage.notifier.notifyBlock(sessionId, answer.blocked);
+    } else {
+      judge.warnOnce(sessionId, blockSentence(answer.blocked));
+    }
+    return { kind: "blocked" };
+  }
+  if (!answer) return { kind: "result", res: null };
+  const { usageWarning, ...res } = answer;
+  if (usageWarning) {
+    judge.usage?.notifier.notifyWarning(sessionId, usageWarning);
+  }
+  judge.cacheSet(cacheKey, res);
+  return { kind: "result", res };
+}
 async function runJudgeStep(args) {
   const {
     judge,
@@ -12699,30 +13124,30 @@ async function runJudgeStep(args) {
   const actionHash = hashTarget(targetStr);
   const ruleIds = llmRules.map((r) => r.id).sort().join(",");
   const cacheKey = `${actionHash}|${ruleIds}|confirm`;
-  let res = judge.cacheGet(cacheKey);
-  if (!res) {
-    res = await judge.callJudge({
-      apiBaseResolved: projectContext.apiBaseResolved,
-      token: projectContext.token,
-      projectId: request.projectId,
-      tool: request.tool,
-      agent: request.agent,
-      sessionId,
-      phase: "confirm",
-      // Judge over the FULL (schema-bounded 2048) redacted action — the default
-      // redactTarget cap of 256 (right for the DB-stored violation summary) would
-      // truncate a long dangerous action and risk an overturn on a partial view.
-      actionSummary: redactTarget(targetStr, 2048),
-      actionHash,
-      rules: llmRules.map((r) => ({
-        id: r.id,
-        name: r.name ?? r.id,
-        description: r.description ?? "",
-        severity: r.severity
-      }))
-    });
-    if (res) judge.cacheSet(cacheKey, res);
+  const consultation = await consultJudge(judge, sessionId, cacheKey, {
+    apiBaseResolved: projectContext.apiBaseResolved,
+    token: projectContext.token,
+    projectId: request.projectId,
+    tool: request.tool,
+    agent: request.agent,
+    sessionId,
+    phase: "confirm",
+    // Judge over the FULL (schema-bounded 2048) redacted action — the default
+    // redactTarget cap of 256 (right for the DB-stored violation summary) would
+    // truncate a long dangerous action and risk an overturn on a partial view.
+    actionSummary: redactTarget(targetStr, 2048),
+    actionHash,
+    rules: llmRules.map((r) => ({
+      id: r.id,
+      name: r.name ?? r.id,
+      description: r.description ?? "",
+      severity: r.severity
+    }))
+  });
+  if (consultation.kind === "blocked") {
+    return { engine: "llm", outcome: "quota_exceeded" };
   }
+  const res = consultation.res;
   if (!res) {
     return {
       engine: "llm",
@@ -12785,27 +13210,25 @@ async function runCatchJudgeStep(args) {
   const actionHash = hashTarget(targetStr);
   const ruleIds = near.map((r) => r.id).sort();
   const cacheKey = `${actionHash}|${ruleIds.join(",")}|catch`;
-  let res = judge.cacheGet(cacheKey);
-  if (!res) {
-    res = await judge.callJudge({
-      apiBaseResolved: projectContext.apiBaseResolved,
-      token: projectContext.token,
-      projectId: request.projectId,
-      tool: request.tool,
-      agent: request.agent,
-      sessionId,
-      phase: "catch",
-      actionSummary: redactTarget(targetStr, 2048),
-      actionHash,
-      rules: near.map((r) => ({
-        id: r.id,
-        name: r.name ?? r.id,
-        description: r.description ?? "",
-        severity: r.severity
-      }))
-    });
-    if (res) judge.cacheSet(cacheKey, res);
-  }
+  const consultation = await consultJudge(judge, sessionId, cacheKey, {
+    apiBaseResolved: projectContext.apiBaseResolved,
+    token: projectContext.token,
+    projectId: request.projectId,
+    tool: request.tool,
+    agent: request.agent,
+    sessionId,
+    phase: "catch",
+    actionSummary: redactTarget(targetStr, 2048),
+    actionHash,
+    rules: near.map((r) => ({
+      id: r.id,
+      name: r.name ?? r.id,
+      description: r.description ?? "",
+      severity: r.severity
+    }))
+  });
+  if (consultation.kind === "blocked") return void 0;
+  const res = consultation.res;
   if (!res) return void 0;
   if (res.quotaExceeded) {
     judge.warnOnce(
@@ -12851,6 +13274,9 @@ function emitUnverifiedBanner(reason) {
     }
   }
 }
+function sessionIdOf3(envelope) {
+  return typeof envelope.session_id === "string" ? envelope.session_id : typeof envelope.sessionId === "string" ? envelope.sessionId : void 0;
+}
 async function runPreToolUseGuardWith(opts) {
   const {
     stdinEnvelope,
@@ -12866,11 +13292,19 @@ async function runPreToolUseGuardWith(opts) {
     );
     return 0;
   }
+  if (rulesOutcome.kind === "blocked") {
+    const sentence = opts.usageNotifier?.notifyBlock(
+      sessionIdOf3(stdinEnvelope),
+      rulesOutcome.block
+    );
+    if (sentence) emitAgentMessage("warn", sentence);
+    return 0;
+  }
   const rules = rulesOutcome.rules;
   const caller = sniff(stdinEnvelope);
   const partial = mapEnvelopeToGuardRequest(stdinEnvelope, caller.client);
   if (partial === null) return 0;
-  const sessionId = typeof stdinEnvelope.session_id === "string" ? stdinEnvelope.session_id : typeof stdinEnvelope.sessionId === "string" ? stdinEnvelope.sessionId : void 0;
+  const sessionId = sessionIdOf3(stdinEnvelope);
   const guardRequest = {
     ...partial,
     projectId: projectContext.projectId,
@@ -13014,11 +13448,21 @@ function emitAgentMessage(verdict, message) {
 }
 function makeProductionJudgeDeps() {
   const cache = makeJudgeCache();
-  const warnDir = process.env.CYBEDEFEND_BASELINE_DIR ?? join12(homedir12(), ".cybedefend");
+  const warnDir = process.env.CYBEDEFEND_BASELINE_DIR ?? join14(homedir14(), ".cybedefend");
   const warnTracker = defaultSessionTracker(
-    join12(warnDir, "guards-judge-warned-sessions.json")
+    join14(warnDir, "guards-judge-warned-sessions.json")
+  );
+  const blockedTracker = defaultSessionTracker(
+    join14(warnDir, "guards-judge-blocked-sessions.json")
   );
   return {
+    usage: {
+      notifier: makeUsageNotifier(),
+      isBlocked: (sessionId) => sessionId ? blockedTracker.hasSeen(sessionId) : false,
+      markBlocked: (sessionId) => {
+        if (sessionId) void blockedTracker.markSeen(sessionId);
+      }
+    },
     callJudge,
     cacheGet: (k) => cache.get(k),
     cacheSet: (k, r) => cache.set(k, r),
@@ -13038,7 +13482,9 @@ async function runPreToolUseGuard() {
     const envelope = await readStdinJson();
     const config = loadRuntimeConfig();
     if (!config) return 0;
-    const { projectId, apiBase: configApiBase } = await resolveProjectIdWithApi();
+    const folder = sessionFolderOf(envelope, sniff(envelope).client);
+    if (isSessionInactive(envelope, { cwd: folder })) return 0;
+    const { projectId, apiBase: configApiBase } = await resolveProjectIdWithApi(folder);
     if (!projectId) return 0;
     const apiBaseResolved = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config.region.apiBase;
     const token = await resolveTokenWithRefresh(
@@ -13076,7 +13522,10 @@ async function runPreToolUseGuard() {
       judge: makeProductionJudgeDeps(),
       // v1.1 catch — OFF by default; opt in with CYBEDEFEND_JUDGE_CATCH=1 once
       // the call-rate gate is validated in the field.
-      judgeCatch: process.env.CYBEDEFEND_JUDGE_CATCH === "1"
+      judgeCatch: process.env.CYBEDEFEND_JUDGE_CATCH === "1",
+      // The refusal sentence goes out through the agent-message channels
+      // (stderr included), so this notifier itself writes nothing.
+      usageNotifier: makeUsageNotifier({ write: () => void 0 })
     });
     try {
       await buffer.flushViolations(