@cybedefend/vibedefend 1.7.0 → 1.8.1

package/dist/hook-runner.js

@@ -4630,6 +4630,34 @@ var require_re22 = __commonJS({
   }
 });
 
+// src/hooks/runtime/exit-deadlock-guard.ts
+import { setFlagsFromString } from "node:v8";
+
+// src/hooks/runtime/runner-args.ts
+function parseRunnerArgs(argv) {
+  const subcommand = argv[0] ?? "";
+  let client = null;
+  for (let i = 1; i < argv.length - 1; i++) {
+    if (argv[i] === "--client" && argv[i + 1] === "antigravity") {
+      client = "antigravity";
+      break;
+    }
+  }
+  return { subcommand, client };
+}
+
+// src/hooks/runtime/exit-deadlock-guard.ts
+function exitDeadlockFlags(argv) {
+  if (parseRunnerArgs(argv).client !== "antigravity") return [];
+  return ["--no-concurrent-sparkplug", "--no-maglev"];
+}
+for (const flag of exitDeadlockFlags(process.argv.slice(2))) {
+  try {
+    setFlagsFromString(flag);
+  } catch {
+  }
+}
+
 // src/hooks/runtime/sniff.ts
 import { homedir } from "node:os";
 import { isAbsolute, resolve as resolvePath } from "node:path";
@@ -4869,65 +4897,220 @@ function filePathFromPatch(patch) {
   }
   return "";
 }
-function joinMultiEditNewStrings(edits) {
-  if (!Array.isArray(edits)) return "";
-  return edits.map((e) => typeof e.new_string === "string" ? e.new_string : "").filter((s) => s.length > 0).join("\n---\n");
+function joinStringField(entries, field) {
+  if (!Array.isArray(entries)) return "";
+  return entries.map((e) => {
+    if (typeof e !== "object" || e === null) return "";
+    const value = e[field];
+    return typeof value === "string" ? value : "";
+  }).filter((s) => s.length > 0).join("\n---\n");
+}
+function isAntigravityEnvelope(input2) {
+  return typeof input2.conversationId === "string" && Array.isArray(input2.workspacePaths);
+}
+var ANTIGRAVITY_PATH_ARGS = [
+  "TargetFile",
+  "AbsolutePath",
+  "Path",
+  "FilePath",
+  "file_path",
+  "path"
+];
+var ANTIGRAVITY_OWN_PATH_ARG = /* @__PURE__ */ new Map([
+  ["write_to_file", "TargetFile"],
+  ["replace_file_content", "TargetFile"],
+  ["multi_replace_file_content", "TargetFile"],
+  ["view_file", "AbsolutePath"],
+  ["write_file", "Path"],
+  ["edit_file", "Path"],
+  ["read_file", "Path"]
+]);
+function antigravityFilePathArg(toolName, args) {
+  const own2 = ANTIGRAVITY_OWN_PATH_ARG.get(toolName);
+  for (const key of own2 === void 0 ? ANTIGRAVITY_PATH_ARGS : [own2, ...ANTIGRAVITY_PATH_ARGS]) {
+    const value = args[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return "";
 }
-function joinWindsurfEdits(edits) {
-  return joinMultiEditNewStrings(edits);
+var ANTIGRAVITY_KNOWN_TOOLS = /* @__PURE__ */ new Set([
+  ...ANTIGRAVITY_OWN_PATH_ARG.keys(),
+  "run_command",
+  "read_url_content",
+  "call_mcp_tool"
+]);
+var ANTIGRAVITY_CONTENT_KEY_RE = /content|replacement|chunk|edit|patch|diff/i;
+function classifyUnknownAntigravityTool(args) {
+  const pathKeys = new Set(ANTIGRAVITY_PATH_ARGS);
+  for (const key of Object.keys(args)) {
+    if (pathKeys.has(key)) continue;
+    if (ANTIGRAVITY_CONTENT_KEY_RE.test(key)) return "Write";
+  }
+  return "Read";
+}
+function unknownAntigravityContent(args) {
+  const pathKeys = new Set(ANTIGRAVITY_PATH_ARGS);
+  for (const key of Object.keys(args)) {
+    if (pathKeys.has(key)) continue;
+    if (!ANTIGRAVITY_CONTENT_KEY_RE.test(key)) continue;
+    const value = args[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return "";
 }
-function sniff(input2) {
-  if (typeof input2.agent_action_name === "string") {
-    const action = input2.agent_action_name;
-    const toolInfo = input2.tool_info ?? {};
-    const filePath = typeof toolInfo.file_path === "string" ? toolInfo.file_path : "";
-    const newContent = joinWindsurfEdits(
-      toolInfo.edits
-    );
-    let toolName = action;
-    if (action === "pre_write_code" || action === "post_write_code") {
-      toolName = "Write";
-    } else if (action === "pre_read_code" || action === "post_read_code") {
-      toolName = "Read";
+function antigravityAllPathArgs(args) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const key of ANTIGRAVITY_PATH_ARGS) {
+    const value = args[key];
+    if (typeof value === "string" && value.length > 0 && !seen.has(value)) {
+      seen.add(value);
+      out.push(value);
     }
+  }
+  return out;
+}
+function resolveAntigravityTargetFile(value, w) {
+  return value.length > 0 ? resolveWriteTarget(w, value) : "";
+}
+function stringArg(value) {
+  return typeof value === "string" ? value : "";
+}
+function extractAntigravityShape(input2) {
+  const workspacePaths = Array.isArray(input2.workspacePaths) ? input2.workspacePaths : [];
+  const w = workspacePaths.find(
+    (p) => typeof p === "string" && p.length > 0
+  ) ?? process.cwd();
+  const toolCall = typeof input2.toolCall === "object" && input2.toolCall !== null ? input2.toolCall : void 0;
+  if (toolCall === void 0) {
     return {
-      client: "windsurf",
-      toolName,
-      filePath,
-      filePaths: filePath ? [filePath] : [],
-      newContent,
+      client: "antigravity",
+      toolName: "",
+      filePath: "",
+      filePaths: [],
+      newContent: "",
       raw: input2
     };
   }
-  if ("hookEventName" in input2) {
-    return extractToolInputShape(input2, "vscode");
+  const name = typeof toolCall.name === "string" ? toolCall.name : "";
+  const args = toolCall.args ?? {};
+  let toolName = name;
+  let filePath = resolveAntigravityTargetFile(antigravityFilePathArg(name, args), w);
+  let filePaths = [];
+  let newContent = "";
+  switch (name) {
+    case "write_to_file":
+      toolName = "Write";
+      newContent = stringArg(args.CodeContent);
+      break;
+    case "write_file":
+      toolName = "Write";
+      newContent = stringArg(args.Content);
+      break;
+    case "replace_file_content":
+      toolName = "Edit";
+      newContent = stringArg(args.ReplacementContent);
+      break;
+    case "edit_file":
+      toolName = "Edit";
+      newContent = stringArg(args.Replacement);
+      break;
+    case "multi_replace_file_content":
+      toolName = "MultiEdit";
+      newContent = joinStringField(args.ReplacementChunks, "ReplacementContent");
+      break;
+    case "run_command": {
+      toolName = "Bash";
+      const command = typeof args.CommandLine === "string" ? args.CommandLine : "";
+      newContent = command;
+      const cwd = typeof args.Cwd === "string" && args.Cwd.length > 0 ? args.Cwd : w;
+      filePaths = extractShellWriteTargets(command).map(
+        (t) => resolveWriteTarget(cwd, t)
+      );
+      filePath = filePaths[0] ?? "";
+      break;
+    }
+    default:
+      if (name && filePath && !ANTIGRAVITY_KNOWN_TOOLS.has(name)) {
+        if (classifyUnknownAntigravityTool(args) === "Write") {
+          toolName = "Write";
+          newContent = unknownAntigravityContent(args);
+        }
+      }
+      break;
   }
+  if (filePaths.length === 0 && filePath) filePaths = [filePath];
+  return { client: "antigravity", toolName, filePath, filePaths, newContent, raw: input2 };
+}
+function detectClient(input2) {
+  if (isAntigravityEnvelope(input2)) return "antigravity";
+  if (typeof input2.agent_action_name === "string") return "windsurf";
+  if ("hookEventName" in input2) return "vscode";
   if ("hook_event_name" in input2) {
     const evt = typeof input2.hook_event_name === "string" ? input2.hook_event_name : "";
-    let client;
-    if (/^[a-z]/.test(evt)) {
-      client = "cursor";
-    } else {
-      const toolName = typeof input2.tool_name === "string" ? input2.tool_name : "";
-      if (toolName === "apply_patch" || "turn_id" in input2) {
-        client = "codex";
-      } else if (hasIsoTimestamp(input2)) {
-        client = "vscode";
-      } else {
-        client = "claude-code";
-      }
-    }
-    return extractToolInputShape(input2, client);
+    if (/^[a-z]/.test(evt)) return "cursor";
+    const toolName = typeof input2.tool_name === "string" ? input2.tool_name : "";
+    if (toolName === "apply_patch" || "turn_id" in input2) return "codex";
+    if (hasIsoTimestamp(input2)) return "vscode";
+    return "claude-code";
+  }
+  return "unknown";
+}
+function extractWindsurfShape(input2) {
+  const action = input2.agent_action_name;
+  const toolInfo = input2.tool_info ?? {};
+  if (action === "pre_run_command" || action === "post_run_command") {
+    const command = typeof toolInfo.command_line === "string" ? toolInfo.command_line : "";
+    const cwd = typeof toolInfo.cwd === "string" && toolInfo.cwd.length > 0 ? toolInfo.cwd : process.cwd();
+    const filePaths = extractShellWriteTargets(command).map(
+      (t) => resolveWriteTarget(cwd, t)
+    );
+    return {
+      client: "windsurf",
+      toolName: "Bash",
+      filePath: filePaths[0] ?? "",
+      filePaths,
+      newContent: command,
+      raw: input2
+    };
+  }
+  const filePath = typeof toolInfo.file_path === "string" ? toolInfo.file_path : "";
+  const newContent = joinStringField(toolInfo.edits, "new_string");
+  let toolName = action;
+  if (action === "pre_write_code" || action === "post_write_code") {
+    toolName = "Write";
+  } else if (action === "pre_read_code" || action === "post_read_code") {
+    toolName = "Read";
   }
   return {
-    client: "unknown",
-    toolName: "",
-    filePath: "",
-    filePaths: [],
-    newContent: "",
+    client: "windsurf",
+    toolName,
+    filePath,
+    filePaths: filePath ? [filePath] : [],
+    newContent,
     raw: input2
   };
 }
+function sniff(input2) {
+  const client = detectClient(input2);
+  switch (client) {
+    case "antigravity":
+      return extractAntigravityShape(input2);
+    case "windsurf":
+      return extractWindsurfShape(input2);
+    case "unknown":
+      return {
+        client: "unknown",
+        toolName: "",
+        filePath: "",
+        filePaths: [],
+        newContent: "",
+        raw: input2
+      };
+    default:
+      return extractToolInputShape(input2, client);
+  }
+}
 function hasIsoTimestamp(input2) {
   return typeof input2.timestamp === "string" && /^\d{4}-\d{2}-\d{2}T/.test(input2.timestamp);
 }
@@ -4955,9 +5138,7 @@ function extractToolInputShape(input2, client) {
       newContent = typeof toolInput.new_string === "string" ? toolInput.new_string : "";
       break;
     case "MultiEdit":
-      newContent = joinMultiEditNewStrings(
-        toolInput.edits
-      );
+      newContent = joinStringField(toolInput.edits, "new_string");
       break;
     case "apply_patch": {
       const patch = typeof toolInput.patch === "string" ? toolInput.patch : typeof toolInput.command === "string" ? toolInput.command : "";
@@ -6184,9 +6365,15 @@ import { dirname as dirname4, isAbsolute as isAbsolute2, join as join6, resolve
 import { fileURLToPath } from "node:url";
 
 // src/hooks/runtime/emit.ts
+import { writeSync } from "node:fs";
 var ENVELOPE_CLIENTS = {
   SessionStart: /* @__PURE__ */ new Set(["codex"]),
-  PreToolUse: /* @__PURE__ */ new Set(["claude-code", "codex", "vscode"])
+  PreToolUse: /* @__PURE__ */ new Set(["claude-code", "codex", "vscode"]),
+  // Antigravity never reaches this generic envelope: it has its own shapes
+  // per event, handled in `emitAntigravityContext` below. Kept as an empty
+  // set (rather than omitted) so `ENVELOPE_CLIENTS[hookEventName]` stays a
+  // total function over `ContextHookEvent`.
+  PreInvocation: /* @__PURE__ */ new Set()
 };
 var NO_MODEL_CHANNEL = {
   PreToolUse: /* @__PURE__ */ new Set(["cursor"]),
@@ -6195,14 +6382,71 @@ var NO_MODEL_CHANNEL = {
 function hasModelChannel(client, event) {
   return !NO_MODEL_CHANNEL[event]?.has(client);
 }
+var antigravityWritten = false;
+function writeStdoutSync(text) {
+  const buf = Buffer.from(text, "utf8");
+  const deadline = Date.now() + 2e3;
+  let pause;
+  let offset = 0;
+  while (offset < buf.length) {
+    let written = 0;
+    try {
+      written = writeSync(1, buf, offset, buf.length - offset);
+    } catch (e) {
+      if (e?.code !== "EAGAIN") return;
+    }
+    offset += written;
+    if (written > 0) continue;
+    if (Date.now() >= deadline) return;
+    pause ??= new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(pause, 0, 0, 5);
+  }
+}
+var antigravityWriter = writeStdoutSync;
+function writeAntigravityPayload(payload) {
+  if (antigravityWritten) return;
+  antigravityWritten = true;
+  antigravityWriter(JSON.stringify(payload) + "\n");
+}
+function emitAntigravityDecision(decision, reason) {
+  writeAntigravityPayload({ decision, ...reason ? { reason } : {} });
+}
+var PRE_TOOL_USE_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "fetch-rules",
+  "guard-check",
+  "pre-tool-use",
+  "PreToolUse"
+]);
+function finishAntigravityRun(subcommand) {
+  const payload = PRE_TOOL_USE_SUBCOMMANDS.has(subcommand) ? { decision: "allow" } : {};
+  writeAntigravityPayload(payload);
+}
+function emitAntigravityContext(body, hookEventName) {
+  if (hookEventName === "PreToolUse") return;
+  if (hookEventName === "SessionStart") {
+    writeAntigravityPayload({
+      injectSteps: [{ systemMessage: { systemMessage: body } }]
+    });
+    return;
+  }
+  writeAntigravityPayload({ injectSteps: [{ ephemeralMessage: body }] });
+}
 function emit(body, client) {
   if (!body) return;
+  if (client === "antigravity") {
+    writeAntigravityPayload({ injectSteps: [{ ephemeralMessage: body }] });
+    return;
+  }
   if (client === "cursor") return;
   process.stdout.write(body);
   if (!body.endsWith("\n")) process.stdout.write("\n");
 }
 function emitContext(body, client, hookEventName) {
   if (!body) return;
+  if (client === "antigravity") {
+    emitAntigravityContext(body, hookEventName);
+    return;
+  }
   if (!hasModelChannel(client, hookEventName)) return;
   if (client === "cursor" && hookEventName === "SessionStart") {
     writeJson({ additional_context: body });
@@ -6262,6 +6506,9 @@ function emitStop(body, client, reason) {
     case "cursor":
       writeJson({ followup_message: body });
       return;
+    case "antigravity":
+      writeAntigravityPayload({ decision: "continue", reason: body });
+      return;
     default:
       emit(body, client);
   }
@@ -6330,7 +6577,7 @@ function defaultInactiveSessionStore(file2 = defaultStoreFile(), now = Date.now)
   };
 }
 function sessionIdOf(stdin) {
-  for (const key of ["session_id", "sessionId", "conversation_id", "trajectory_id"]) {
+  for (const key of ["session_id", "sessionId", "conversation_id", "trajectory_id", "conversationId"]) {
     const v = stdin[key];
     if (typeof v === "string" && v.length > 0) return v;
   }
@@ -6343,6 +6590,9 @@ function sessionFolderOf(stdin, client, env = process.env) {
     if (Array.isArray(roots)) candidates.push(roots[0]);
     candidates.push(env.CURSOR_PROJECT_DIR);
   }
+  if (client === "antigravity" && Array.isArray(stdin.workspacePaths)) {
+    candidates.push(...stdin.workspacePaths);
+  }
   candidates.push(stdin.cwd);
   for (const c of candidates) {
     const folder = absoluteFolder(c);
@@ -6453,10 +6703,260 @@ function projectDirForFile(file2, workDir) {
   return fileRoot;
 }
 
+// src/hooks/runtime/antigravity-session.ts
+import {
+  appendFileSync,
+  closeSync,
+  constants,
+  lstatSync,
+  mkdirSync as mkdirSync6,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync9,
+  renameSync,
+  rmSync,
+  unlinkSync,
+  utimesSync,
+  writeFileSync as writeFileSync6,
+  writeSync as writeSync2
+} from "node:fs";
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { homedir as homedir8 } from "node:os";
+import { join as join8 } from "node:path";
+var MAX_STASHED_CONTEXTS = 20;
+var DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var STASH_NAME_RE = /^\d+-[0-9a-f]{8}\.md$/;
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+function conversationKey(raw) {
+  const id = raw.conversationId;
+  if (typeof id !== "string" || id.length === 0 || id.length > 256) return null;
+  return createHash2("sha256").update(id).digest("hex").slice(0, 32);
+}
+function antigravityStateDir() {
+  return join8(homedir8(), ".cybedefend", "antigravity");
+}
+function keyDir(key, dir) {
+  return join8(dir, key);
+}
+function isFinalStashName(name) {
+  return STASH_NAME_RE.test(name);
+}
+function isUnsafePath(path) {
+  try {
+    return !lstatSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isUnsafeFilePath(path) {
+  try {
+    return !lstatSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+var NOFOLLOW_SUPPORTED = typeof constants.O_NOFOLLOW === "number";
+function appendLedgerLine(path, line) {
+  if (NOFOLLOW_SUPPORTED) {
+    const fd = openSync(
+      path,
+      constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW,
+      FILE_MODE
+    );
+    try {
+      writeSync2(fd, line, null, "utf8");
+    } finally {
+      closeSync(fd);
+    }
+    return;
+  }
+  if (isUnsafeFilePath(path)) return;
+  appendFileSync(path, line, { mode: FILE_MODE });
+}
+function writeMarkerFile(path, content) {
+  if (NOFOLLOW_SUPPORTED) {
+    const fd = openSync(
+      path,
+      constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW,
+      FILE_MODE
+    );
+    try {
+      writeSync2(fd, content, null, "utf8");
+    } finally {
+      closeSync(fd);
+    }
+    return;
+  }
+  if (isUnsafeFilePath(path)) return;
+  writeFileSync6(path, content, { mode: FILE_MODE });
+}
+function ensureRealDir(path) {
+  if (isUnsafePath(path)) return false;
+  mkdirSync6(path, { recursive: true, mode: DIR_MODE });
+  return true;
+}
+function ensureLiveKeyDir(key, dir, now) {
+  const kd = keyDir(key, dir);
+  if (!ensureRealDir(kd)) return null;
+  try {
+    const t = new Date(now);
+    utimesSync(kd, t, t);
+  } catch {
+  }
+  return kd;
+}
+function stashContext(key, body, dir = antigravityStateDir()) {
+  let tmpPath;
+  try {
+    const now = Date.now();
+    const kd = ensureLiveKeyDir(key, dir, now);
+    if (!kd) return;
+    const contextDir = join8(kd, "context");
+    if (!ensureRealDir(contextDir)) return;
+    const suffix = randomBytes(4).toString("hex");
+    tmpPath = join8(contextDir, `.${now}-${suffix}.tmp`);
+    writeFileSync6(tmpPath, body, { mode: FILE_MODE, flag: "wx" });
+    const finalPath = join8(contextDir, `${now}-${suffix}.md`);
+    renameSync(tmpPath, finalPath);
+    tmpPath = void 0;
+    const kept = readdirSync(contextDir).filter(isFinalStashName).sort();
+    const excess = kept.length - MAX_STASHED_CONTEXTS;
+    if (excess > 0) {
+      for (const stale of kept.slice(0, excess)) {
+        try {
+          unlinkSync(join8(contextDir, stale));
+        } catch {
+        }
+      }
+    }
+  } catch {
+    if (tmpPath) {
+      try {
+        unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+  }
+}
+function drainContext(key, dir = antigravityStateDir()) {
+  try {
+    const kd = keyDir(key, dir);
+    if (isUnsafePath(kd)) return [];
+    const contextDir = join8(kd, "context");
+    if (isUnsafePath(contextDir)) return [];
+    const entries = readdirSync(contextDir).filter(isFinalStashName).sort();
+    const seen = /* @__PURE__ */ new Set();
+    const bodies = [];
+    for (const name of entries) {
+      const filePath = join8(contextDir, name);
+      try {
+        const body = readFileSync9(filePath, "utf8");
+        if (!seen.has(body)) {
+          seen.add(body);
+          bodies.push(body);
+        }
+      } catch {
+      }
+      try {
+        unlinkSync(filePath);
+      } catch {
+      }
+    }
+    return bodies;
+  } catch {
+    return [];
+  }
+}
+function recordEdit(key, file2, dir = antigravityStateDir()) {
+  try {
+    const now = Date.now();
+    const kd = ensureLiveKeyDir(key, dir, now);
+    if (!kd) return;
+    appendLedgerLine(join8(kd, "edits.jsonl"), JSON.stringify({ f: file2 }) + "\n");
+  } catch {
+  }
+}
+function readEdits(key, dir = antigravityStateDir()) {
+  try {
+    const kd = keyDir(key, dir);
+    if (isUnsafePath(kd)) return { count: 0, files: [] };
+    const editsPath = join8(kd, "edits.jsonl");
+    if (isUnsafeFilePath(editsPath)) return { count: 0, files: [] };
+    const content = readFileSync9(editsPath, "utf8");
+    let count = 0;
+    const files = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (typeof parsed.f !== "string") continue;
+      count++;
+      if (!seen.has(parsed.f)) {
+        seen.add(parsed.f);
+        files.push(parsed.f);
+      }
+    }
+    return { count, files };
+  } catch {
+    return { count: 0, files: [] };
+  }
+}
+function markReviewed(key, dir = antigravityStateDir()) {
+  try {
+    const now = Date.now();
+    const kd = ensureLiveKeyDir(key, dir, now);
+    if (!kd) return;
+    writeMarkerFile(join8(kd, "reviewed"), String(now));
+  } catch {
+  }
+}
+function isReviewed(key, dir = antigravityStateDir()) {
+  try {
+    const kd = keyDir(key, dir);
+    if (isUnsafePath(kd)) return false;
+    return lstatSync(join8(kd, "reviewed")).isFile();
+  } catch {
+    return false;
+  }
+}
+function pruneStale(dir = antigravityStateDir(), now = Date.now(), maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  try {
+    const entries = readdirSync(dir);
+    for (const name of entries) {
+      const entryPath = join8(dir, name);
+      try {
+        const { mtimeMs } = lstatSync(entryPath);
+        if (now - mtimeMs > maxAgeMs) {
+          rmSync(entryPath, { recursive: true, force: true });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
 // src/hooks/runtime/fetch-rules.ts
 function emitPreToolUseContext(body, client) {
   emitContext(body, client, "PreToolUse");
 }
+function defaultEmit(stdin, stateDir) {
+  return (body, client) => {
+    if (client === "antigravity") {
+      const key = conversationKey(stdin);
+      if (key) stashContext(key, body, stateDir);
+      return;
+    }
+    emitPreToolUseContext(body, client);
+  };
+}
 var INTERESTED_TOOLS = /* @__PURE__ */ new Set([
   "Edit",
   "Write",
@@ -6471,13 +6971,17 @@ async function fetchRulesHook(deps = {}) {
   const resolveTok = deps.resolveTokenFn ?? resolveToken;
   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);
+  const emitFn = deps.emitFn ?? defaultEmit(stdin, deps.antigravityStateDir);
   if (!INTERESTED_TOOLS.has(event.toolName)) return;
   if (!event.filePath) return;
   if (!hasModelChannel(event.client, "PreToolUse")) return;
+  if (event.client === "antigravity" && (event.toolName === "Write" || event.toolName === "Edit" || event.toolName === "MultiEdit")) {
+    const key = conversationKey(stdin);
+    if (key) recordEdit(key, event.filePath, deps.antigravityStateDir);
+  }
   const config2 = loadConfig();
   if (!config2) return;
   const folder = sessionFolderOf(stdin, event.client);
@@ -6626,9 +7130,9 @@ var DIRECT_PROPOSE_DIRECTIVES = {
 
 // src/hooks/runtime/self-update-check.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync9, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join9 } from "node:path";
 
 // src/hooks/runtime/semver.ts
 function parseVersion(input2) {
@@ -6706,9 +7210,9 @@ function isValidRegistryVersion(value) {
 }
 async function selfUpdateCheck(deps) {
   const now = deps.now ?? (() => Date.now());
-  const dir = deps.cybeDir ?? join8(process.env.CYBEDEFEND_HOME ?? homedir8(), ".cybedefend");
-  const throttlePath = join8(dir, "update-check.json");
-  const logPath = join8(dir, "last-update.log");
+  const dir = deps.cybeDir ?? join9(process.env.CYBEDEFEND_HOME ?? homedir9(), ".cybedefend");
+  const throttlePath = join9(dir, "update-check.json");
+  const logPath = join9(dir, "last-update.log");
   const installMode = deps.installMode ?? (deps.runnerSource ? detectInstallMode(deps.runnerSource) : detectInstallMode(resolveScriptPath()));
   const priorFailure = takeUpdateLogNotice(logPath);
   const throttle = readThrottle(throttlePath);
@@ -6742,7 +7246,7 @@ function applyOrNotify(deps, installMode, latest, logPath) {
 function readThrottle(path) {
   try {
     if (!existsSync11(path)) return null;
-    const data = JSON.parse(readFileSync9(path, "utf8"));
+    const data = JSON.parse(readFileSync10(path, "utf8"));
     if (typeof data.lastCheckedAt !== "number") return null;
     return { lastCheckedAt: data.lastCheckedAt };
   } catch {
@@ -6752,7 +7256,7 @@ function readThrottle(path) {
 function writeThrottle(path, throttle) {
   try {
     ensureDirFor(path);
-    writeFileSync6(path, JSON.stringify(throttle) + "\n");
+    writeFileSync7(path, JSON.stringify(throttle) + "\n");
   } catch {
   }
 }
@@ -6761,11 +7265,11 @@ function takeUpdateLogNotice(logPath) {
     if (!existsSync11(logPath)) return null;
     let parsed = {};
     try {
-      parsed = JSON.parse(readFileSync9(logPath, "utf8"));
+      parsed = JSON.parse(readFileSync10(logPath, "utf8"));
     } catch {
       parsed = {};
     }
-    rmSync(logPath, { force: true });
+    rmSync2(logPath, { force: true });
     if (typeof parsed.exitCode === "number" && parsed.exitCode !== 0) {
       return `\u26A0 vibedefend: last auto-update to ${parsed.to ?? "latest"} failed (exit ${parsed.exitCode}) \u2014 run \`vibedefend update --self\`.`;
     }
@@ -6836,18 +7340,18 @@ function pmCommand(mode, spec) {
 
 // src/hooks/runtime/hook-refresh-trigger.ts
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname6, join as join10 } from "node:path";
 function maybeRefreshStaleWiring(deps) {
   try {
     const { config: config2, runnerVersion } = deps;
     if (!config2.runnerSource || config2.installedVersion === runnerVersion) {
       return false;
     }
-    const cliEntry = join9(dirname6(dirname6(config2.runnerSource)), "bin", "vibedefend.js");
+    const cliEntry = join10(dirname6(dirname6(config2.runnerSource)), "bin", "vibedefend.js");
     if (!(deps.exists ?? existsSync12)(cliEntry)) return false;
-    const markerPath = deps.markerPath ?? join9(process.env.CYBEDEFEND_HOME ?? homedir9(), ".cybedefend", "hook-refresh.json");
+    const markerPath = deps.markerPath ?? join10(process.env.CYBEDEFEND_HOME ?? homedir10(), ".cybedefend", "hook-refresh.json");
     if (readMarkerVersion(markerPath) === runnerVersion) return false;
     (deps.spawnRefresh ?? defaultSpawnRefresh)(cliEntry);
     writeMarker(markerPath, runnerVersion);
@@ -6859,7 +7363,7 @@ function maybeRefreshStaleWiring(deps) {
 function readMarkerVersion(path) {
   try {
     if (!existsSync12(path)) return null;
-    const data = JSON.parse(readFileSync10(path, "utf8"));
+    const data = JSON.parse(readFileSync11(path, "utf8"));
     return typeof data.version === "string" ? data.version : null;
   } catch {
     return null;
@@ -6868,7 +7372,7 @@ function readMarkerVersion(path) {
 function writeMarker(path, version2) {
   try {
     ensureDirFor(path);
-    writeFileSync7(path, JSON.stringify({ version: version2, spawnedAt: Date.now() }) + "\n");
+    writeFileSync8(path, JSON.stringify({ version: version2, spawnedAt: Date.now() }) + "\n");
   } catch {
   }
 }
@@ -6882,18 +7386,18 @@ function defaultSpawnRefresh(cliEntry) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { dirname as dirname7, join as join11 } from "node:path";
 var PKG_NAME = "@cybedefend/vibedefend";
 function defaultPkgPath() {
-  return join10(dirname7(fileURLToPath3(import.meta.url)), "..", "package.json");
+  return join11(dirname7(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) => readFileSync11(p, "utf8"));
+  const readFile = opts.readFile ?? ((p) => readFileSync12(p, "utf8"));
   const pkgPath = opts.pkgPath ?? defaultPkgPath();
   try {
     return JSON.parse(readFile(pkgPath));
@@ -6902,7 +7406,7 @@ function readPackageMeta(opts = {}) {
   }
 }
 var pkg = readPackageMeta({
-  bakedVersion: true ? "1.7.0" : void 0
+  bakedVersion: true ? "1.8.1" : void 0
 });
 
 // src/hooks/runtime/session-start.ts
@@ -6946,6 +7450,9 @@ async function sessionStartHook(deps = {}) {
   }
   if (sessionId) sessionStore.clear(sessionId);
   const apiBase = process.env.CYBEDEFEND_API_BASE ?? configApiBase ?? config2.region.apiBase;
+  if (event.client === "antigravity") {
+    pruneStale(deps.antigravityStateDir);
+  }
   if (process.env.CYBEDEFEND_DRY_RUN === "1") {
     emitFn(
       `## CybeDefend session bootstrap (dry-run, client=${event.client})
@@ -6998,7 +7505,12 @@ async function sessionStartHook(deps = {}) {
       "  **before responding to the user request.**"
     );
   }
-  const HARD_ENFORCEMENT_CLIENTS = /* @__PURE__ */ new Set(["claude-code", "codex", "cursor"]);
+  const HARD_ENFORCEMENT_CLIENTS = /* @__PURE__ */ new Set([
+    "claude-code",
+    "codex",
+    "cursor",
+    "antigravity"
+  ]);
   lines.push("");
   if (HARD_ENFORCEMENT_CLIENTS.has(event.client)) {
     lines.push(
@@ -7036,23 +7548,23 @@ async function sessionStartHook(deps = {}) {
 }
 
 // src/hooks/runtime/session-review.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync14 } from "node:fs";
 
 // src/hooks/runtime/review-sessions.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { dirname as dirname8, join as join11 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { dirname as dirname8, join as join12 } from "node:path";
 var SESSIONS_CAP2 = 200;
 function defaultStoreFile2() {
-  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join11(homedir10(), ".cybedefend");
-  return join11(dir, "review-sessions.json");
+  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join12(homedir11(), ".cybedefend");
+  return join12(dir, "review-sessions.json");
 }
 var isCount = (n) => typeof n === "number" && Number.isInteger(n) && n >= 0;
 function defaultReviewSessionStore(file2 = defaultStoreFile2(), now = Date.now) {
   function load2() {
     if (!existsSync13(file2)) return {};
     try {
-      const parsed = JSON.parse(readFileSync12(file2, "utf8"));
+      const parsed = JSON.parse(readFileSync13(file2, "utf8"));
       return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
     } catch {
       return {};
@@ -7060,8 +7572,8 @@ function defaultReviewSessionStore(file2 = defaultStoreFile2(), now = Date.now)
   }
   function save(map2) {
     try {
-      mkdirSync6(dirname8(file2), { recursive: true });
-      writeFileSync8(file2, JSON.stringify(map2) + "\n", "utf8");
+      mkdirSync7(dirname8(file2), { recursive: true });
+      writeFileSync9(file2, JSON.stringify(map2) + "\n", "utf8");
     } catch {
     }
   }
@@ -7171,6 +7683,32 @@ async function sessionReviewHook(deps = {}) {
   const config2 = loadConfig();
   if (!config2) return;
   if (!config2.hooks.enableSessionReview) return;
+  if (event.client === "antigravity") {
+    const key = conversationKey(stdin);
+    const stateDir = deps.antigravityStateDir;
+    if (!key || isReviewed(key, stateDir)) return;
+    let { count, files } = readEdits(key, stateDir);
+    if (process.env.CYBEDEFEND_DRY_RUN === "1") {
+      count = parseInt(process.env.CYBEDEFEND_DRY_RUN_EDITS ?? "5", 10);
+    }
+    if (count === 0) return;
+    if (count < resolveReviewThreshold(config2)) return;
+    const folder2 = sessionFolderOf(stdin, "antigravity");
+    if (isSessionInactive(stdin, { store: deps.sessionStore, cwd: folder2 })) return;
+    const { projectId: projectId2 } = await (deps.resolveProject ?? resolveProjectIdWithApi)(folder2);
+    if (!projectId2) return;
+    const proposalMode2 = resolveProposalMode(config2);
+    let body2 = composeReviewBody(count, "antigravity", "", proposalMode2);
+    const withDiffScan2 = config2.hooks.enableDiffScan !== false;
+    if (withDiffScan2) {
+      body2 += "\n" + composeDiffScanBody(
+        files.slice(0, CHANGED_FILES_MAX).map((f) => relativizePath(f, folder2))
+      );
+    }
+    emitFn(body2, "antigravity", composeStopReason(withDiffScan2, proposalMode2));
+    markReviewed(key, stateDir);
+    return;
+  }
   const transcript = loadTranscript(stdin, readTranscriptFile);
   const sessionId = sessionIdOf(stdin);
   const store = sessionId ? deps.reviewStore ?? defaultReviewSessionStore() : null;
@@ -7247,7 +7785,7 @@ function loadTranscript(stdin, readFile) {
 function defaultReadTranscript(path) {
   if (!existsSync14(path)) return null;
   try {
-    return readFileSync13(path, "utf8");
+    return readFileSync14(path, "utf8");
   } catch {
     return null;
   }
@@ -7515,19 +8053,19 @@ async function preCompactHook(deps = {}) {
 }
 
 // src/hooks/runtime/user-prompt-submit.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync10 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { join as join13 } from "node:path";
 var SESSIONS_CAP3 = 100;
 function defaultSessionsFile() {
-  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join12(homedir11(), ".cybedefend");
-  return join12(dir, "user-prompt-seen-sessions.json");
+  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join13(homedir12(), ".cybedefend");
+  return join13(dir, "user-prompt-seen-sessions.json");
 }
 function defaultSessionTracker(file2 = defaultSessionsFile()) {
   function load2() {
     if (!existsSync15(file2)) return [];
     try {
-      const raw = readFileSync14(file2, "utf8");
+      const raw = readFileSync15(file2, "utf8");
       const data = JSON.parse(raw);
       if (!Array.isArray(data.sessions)) return [];
       return data.sessions.filter((s) => typeof s === "string");
@@ -7544,8 +8082,8 @@ function defaultSessionTracker(file2 = defaultSessionsFile()) {
       if (existing.includes(sessionId)) return;
       const next = [...existing, sessionId].slice(-SESSIONS_CAP3);
       try {
-        mkdirSync7(join12(file2, ".."), { recursive: true });
-        writeFileSync9(file2, JSON.stringify({ sessions: next }), "utf8");
+        mkdirSync8(join13(file2, ".."), { recursive: true });
+        writeFileSync10(file2, JSON.stringify({ sessions: next }), "utf8");
       } catch {
       }
     }
@@ -7633,6 +8171,20 @@ async function userPromptSubmitHook(deps = {}) {
   }
 }
 
+// src/hooks/runtime/pre-invocation.ts
+var STASH_SEPARATOR = "\n\n---\n\n";
+async function preInvocationHook(deps = {}) {
+  const readStdin = deps.readStdin ?? readStdinJson;
+  const stdin = await readStdin();
+  if (!isAntigravityEnvelope(stdin)) return;
+  const key = conversationKey(stdin);
+  if (!key) return;
+  const dir = deps.stateDir ?? antigravityStateDir();
+  const bodies = drainContext(key, dir);
+  if (bodies.length === 0) return;
+  emitContext(bodies.join(STASH_SEPARATOR), "antigravity", "PreInvocation");
+}
+
 // src/guards-evaluator/glob.ts
 function expandHome(pattern, homeDir) {
   if (pattern === "~") return homeDir;
@@ -8364,7 +8916,7 @@ function buildCommandViews(raw) {
 }
 
 // src/guards-evaluator/redact.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 var REDACTED = "[REDACTED]";
 var PATTERNS = [
   // 1. JWT — three base64url segments separated by dots
@@ -8476,7 +9028,7 @@ function redactScriptText(text) {
   return redactTarget(masked, Number.MAX_SAFE_INTEGER);
 }
 function hashTarget(text) {
-  return createHash2("sha256").update(text, "utf8").digest("hex");
+  return createHash3("sha256").update(text, "utf8").digest("hex");
 }
 
 // src/guards-evaluator/evaluate.ts
@@ -11093,15 +11645,15 @@ function resolveCandidatePaths(rawPath, opts) {
 // src/hooks/runtime/session-writes.ts
 import {
   existsSync as existsSync17,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync16,
-  renameSync,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync17,
+  renameSync as renameSync2,
   rmdirSync,
   statSync as statSync3,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { join as join13, posix } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join14, posix } from "node:path";
 var DEFAULT_MAX_PATHS = 500;
 var DEFAULT_SESSION_WRITES_TTL_MS = 4 * 60 * 60 * 1e3;
 var SESSION_WRITES_FILE = "guards-session-writes.json";
@@ -11115,7 +11667,7 @@ function withLock(lockDir, fn) {
   let held = false;
   while (!held) {
     try {
-      mkdirSync8(lockDir);
+      mkdirSync9(lockDir);
       held = true;
     } catch {
       try {
@@ -11142,7 +11694,7 @@ function withLock(lockDir, fn) {
   }
 }
 function defaultDir() {
-  return process.env.CYBEDEFEND_BASELINE_DIR ?? join13(homedir12(), ".cybedefend");
+  return process.env.CYBEDEFEND_BASELINE_DIR ?? join14(homedir13(), ".cybedefend");
 }
 function normalizePath(p) {
   if (typeof p !== "string") return "";
@@ -11177,14 +11729,14 @@ function coerce(raw) {
 }
 function makeSessionWritesStore(opts = {}) {
   const dir = opts.dir ?? defaultDir();
-  const file2 = join13(dir, SESSION_WRITES_FILE);
+  const file2 = join14(dir, SESSION_WRITES_FILE);
   const now = opts.now ?? (() => Date.now());
   const maxPaths = typeof opts.maxPaths === "number" && opts.maxPaths > 0 ? Math.floor(opts.maxPaths) : DEFAULT_MAX_PATHS;
   const ttlMs = typeof opts.ttlMs === "number" && opts.ttlMs > 0 ? opts.ttlMs : DEFAULT_SESSION_WRITES_TTL_MS;
   function readAll() {
     if (!existsSync17(file2)) return {};
     try {
-      return coerce(JSON.parse(readFileSync16(file2, "utf8")));
+      return coerce(JSON.parse(readFileSync17(file2, "utf8")));
     } catch {
       return {};
     }
@@ -11199,10 +11751,10 @@ function makeSessionWritesStore(opts = {}) {
   }
   function writeAll(all) {
     try {
-      if (!existsSync17(dir)) mkdirSync8(dir, { recursive: true });
+      if (!existsSync17(dir)) mkdirSync9(dir, { recursive: true });
       const tmp = `${file2}.${process.pid}.tmp`;
-      writeFileSync10(tmp, JSON.stringify(all), "utf8");
-      renameSync(tmp, file2);
+      writeFileSync11(tmp, JSON.stringify(all), "utf8");
+      renameSync2(tmp, file2);
     } catch {
     }
   }
@@ -11212,7 +11764,7 @@ function makeSessionWritesStore(opts = {}) {
     const usable = paths.filter(isUsable);
     if (usable.length === 0) return;
     try {
-      if (!existsSync17(dir)) mkdirSync8(dir, { recursive: true });
+      if (!existsSync17(dir)) mkdirSync9(dir, { recursive: true });
       withLock(`${file2}.lock`, () => {
         const t = now();
         const all = pruneExpired(readAll(), t);
@@ -11528,10 +12080,10 @@ function nearMiss(req, rule) {
 import { isAbsolute as isAbsolute6, resolve as resolvePath4 } from "node:path";
 
 // src/hooks/runtime/guard-rules-cache.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync11, existsSync as existsSync18, mkdirSync as mkdirSync9 } from "node:fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, existsSync as existsSync18, mkdirSync as mkdirSync10 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
-import { homedir as homedir13 } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join15 } from "node:path";
 
 // node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -31338,7 +31890,7 @@ function retryAfterOf(e) {
 }
 
 // src/hooks/runtime/retry-policy.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var UNAUTHORIZED_BACKOFF_MS = [
   6e4,
   5 * 6e4,
@@ -31364,12 +31916,12 @@ function unauthorizedBackoffMs(consecutive) {
   return UNAUTHORIZED_BACKOFF_MS[index];
 }
 function tokenFingerprint(token) {
-  return createHash3("sha256").update(token).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(token).digest("hex").slice(0, 16);
 }
 
 // src/hooks/runtime/guard-rules-cache.ts
-var DEFAULT_CACHE_FILE = join14(
-  homedir13(),
+var DEFAULT_CACHE_FILE = join15(
+  homedir14(),
   ".cybedefend",
   "guards-cache.json"
 );
@@ -31444,7 +31996,7 @@ function reportDroppedRules(dropped) {
 }
 function makeGuardRulesCache(opts) {
   const cacheFile = opts.cacheFile ?? DEFAULT_CACHE_FILE;
-  const failuresFile = opts.failuresFile ?? join14(dirname9(cacheFile), "guards-cache-failures.json");
+  const failuresFile = opts.failuresFile ?? join15(dirname9(cacheFile), "guards-cache-failures.json");
   const staleSec = opts.staleSec ?? DEFAULT_STALE_SEC;
   const fetchFn = opts.fetchFn;
   const clock = opts.now ?? Date.now;
@@ -31549,7 +32101,7 @@ function makeGuardRulesCache(opts) {
   function readCache(projectId) {
     if (!existsSync18(cacheFile)) return null;
     try {
-      const raw = readFileSync17(cacheFile, "utf8");
+      const raw = readFileSync18(cacheFile, "utf8");
       const data = JSON.parse(raw);
       if (data.projectId !== projectId) return null;
       return data;
@@ -31560,7 +32112,7 @@ function makeGuardRulesCache(opts) {
   function readFailures() {
     try {
       if (!existsSync18(failuresFile)) return {};
-      const parsed = JSON.parse(readFileSync17(failuresFile, "utf8"));
+      const parsed = JSON.parse(readFileSync18(failuresFile, "utf8"));
       if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
         return {};
       }
@@ -31582,7 +32134,7 @@ function makeGuardRulesCache(opts) {
         if (now - f.at > FAILURE_RETENTION_MS) delete failures[projectId];
       }
       ensureDirFor2(failuresFile);
-      writeFileSync11(failuresFile, JSON.stringify(failures), "utf8");
+      writeFileSync12(failuresFile, JSON.stringify(failures), "utf8");
     } catch {
     }
   }
@@ -31593,7 +32145,7 @@ function makeGuardRulesCache(opts) {
   function writeCache(entry) {
     try {
       ensureDirFor2(cacheFile);
-      writeFileSync11(cacheFile, JSON.stringify(entry), "utf8");
+      writeFileSync12(cacheFile, JSON.stringify(entry), "utf8");
     } catch {
     }
   }
@@ -31602,7 +32154,7 @@ function makeGuardRulesCache(opts) {
 function ensureDirFor2(filePath) {
   const dir = dirname9(filePath);
   if (!existsSync18(dir)) {
-    mkdirSync9(dir, { recursive: true });
+    mkdirSync10(dir, { recursive: true });
   }
 }
 var DEFAULT_TIMEOUT_MS2 = 8e3;
@@ -31742,11 +32294,11 @@ function detectPromptInjection(text) {
 }
 
 // src/hooks/runtime/judge-cache.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, existsSync as existsSync19, mkdirSync as mkdirSync10 } from "node:fs";
-import { dirname as dirname10, join as join15 } from "node:path";
-import { homedir as homedir14 } from "node:os";
-var DEFAULT_JUDGE_CACHE_FILE = join15(
-  homedir14(),
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, existsSync as existsSync19, mkdirSync as mkdirSync11 } from "node:fs";
+import { dirname as dirname10, join as join16 } from "node:path";
+import { homedir as homedir15 } from "node:os";
+var DEFAULT_JUDGE_CACHE_FILE = join16(
+  homedir15(),
   ".cybedefend",
   "guards-judge-cache.json"
 );
@@ -31759,7 +32311,7 @@ function makeJudgeCache(opts = {}) {
   function readAll() {
     if (!existsSync19(cacheFile)) return {};
     try {
-      return JSON.parse(readFileSync18(cacheFile, "utf8"));
+      return JSON.parse(readFileSync19(cacheFile, "utf8"));
     } catch {
       return {};
     }
@@ -31783,7 +32335,7 @@ function makeJudgeCache(opts = {}) {
         for (const k of keys.slice(0, Math.max(0, keys.length - maxEntries))) delete all[k];
       }
       ensureDirFor3(cacheFile);
-      writeFileSync12(cacheFile, JSON.stringify(all), "utf8");
+      writeFileSync13(cacheFile, JSON.stringify(all), "utf8");
     } catch {
     }
   }
@@ -31792,34 +32344,34 @@ function makeJudgeCache(opts = {}) {
 function ensureDirFor3(filePath) {
   const dir = dirname10(filePath);
   if (!existsSync19(dir)) {
-    mkdirSync10(dir, { recursive: true });
+    mkdirSync11(dir, { recursive: true });
   }
 }
 
 // src/hooks/runtime/guard-check.ts
 import { spawn as spawn3 } from "node:child_process";
-import { homedir as homedir17 } from "node:os";
-import { join as join18 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { join as join19 } from "node:path";
 
 // src/hooks/runtime/guard-violations-buffer.ts
 import {
-  appendFileSync,
-  closeSync as closeSync2,
+  appendFileSync as appendFileSync2,
+  closeSync as closeSync3,
   existsSync as existsSync20,
-  openSync as openSync2,
-  readFileSync as readFileSync19,
-  writeFileSync as writeFileSync13,
-  writeSync,
-  mkdirSync as mkdirSync11,
-  rmSync as rmSync2,
+  openSync as openSync3,
+  readFileSync as readFileSync20,
+  writeFileSync as writeFileSync14,
+  writeSync as writeSync3,
+  mkdirSync as mkdirSync12,
+  rmSync as rmSync3,
   statSync as statSync4,
-  utimesSync
+  utimesSync as utimesSync2
 } from "node:fs";
 import { dirname as dirname11 } from "node:path";
-import { homedir as homedir15 } from "node:os";
-import { join as join16 } from "node:path";
-var DEFAULT_BUFFER_FILE = join16(
-  homedir15(),
+import { homedir as homedir16 } from "node:os";
+import { join as join17 } from "node:path";
+var DEFAULT_BUFFER_FILE = join17(
+  homedir16(),
   ".cybedefend",
   "guards-violations-buffer.jsonl"
 );
@@ -31830,8 +32382,8 @@ var MAX_RECORD_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var FLUSH_LOCK_STALE_MS = 6e4;
 function makeViolationsBuffer(opts = {}) {
   const bufferFile = opts.bufferFile ?? DEFAULT_BUFFER_FILE;
-  const holdsFile = opts.holdsFile ?? join16(dirname11(bufferFile), "guards-violations-holds.json");
-  const lockFile = opts.lockFile ?? join16(dirname11(bufferFile), "guards-violations-flush.lock");
+  const holdsFile = opts.holdsFile ?? join17(dirname11(bufferFile), "guards-violations-holds.json");
+  const lockFile = opts.lockFile ?? join17(dirname11(bufferFile), "guards-violations-flush.lock");
   const now = opts.now ?? Date.now;
   function bufferViolation2(ctx, v) {
     const record2 = {
@@ -31841,7 +32393,7 @@ function makeViolationsBuffer(opts = {}) {
     };
     try {
       ensureDirFor4(bufferFile);
-      appendFileSync(bufferFile, JSON.stringify(record2) + "\n", "utf8");
+      appendFileSync2(bufferFile, JSON.stringify(record2) + "\n", "utf8");
     } catch {
     }
   }
@@ -31923,7 +32475,7 @@ function makeViolationsBuffer(opts = {}) {
     writeHolds(holds);
     try {
       const serialised = failed.map((r) => JSON.stringify(r) + "\n").join("");
-      writeFileSync13(bufferFile, serialised + appendedSince(snapshot.bytes), "utf8");
+      writeFileSync14(bufferFile, serialised + appendedSince(snapshot.bytes), "utf8");
     } catch {
     }
   }
@@ -31945,7 +32497,7 @@ function makeViolationsBuffer(opts = {}) {
   }
   function readBuffer() {
     try {
-      const raw = readFileSync19(bufferFile);
+      const raw = readFileSync20(bufferFile);
       return { content: raw.toString("utf8"), bytes: raw.length };
     } catch {
       return null;
@@ -31953,7 +32505,7 @@ function makeViolationsBuffer(opts = {}) {
   }
   function appendedSince(bytes) {
     try {
-      const raw = readFileSync19(bufferFile);
+      const raw = readFileSync20(bufferFile);
       return raw.length > bytes ? raw.subarray(bytes).toString("utf8") : "";
     } catch {
       return "";
@@ -31967,18 +32519,18 @@ function makeViolationsBuffer(opts = {}) {
     }
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        const fd = openSync2(lockFile, "wx");
+        const fd = openSync3(lockFile, "wx");
         try {
-          writeSync(fd, String(process.pid));
+          writeSync3(fd, String(process.pid));
         } finally {
-          closeSync2(fd);
+          closeSync3(fd);
         }
         return true;
       } catch (e) {
         if (e.code !== "EEXIST") return false;
         if (!lockIsStale()) return false;
         try {
-          rmSync2(lockFile, { force: true });
+          rmSync3(lockFile, { force: true });
         } catch {
           return false;
         }
@@ -31996,26 +32548,26 @@ function makeViolationsBuffer(opts = {}) {
   function touchLock() {
     try {
       const t = /* @__PURE__ */ new Date();
-      utimesSync(lockFile, t, t);
+      utimesSync2(lockFile, t, t);
     } catch {
     }
   }
   function releaseLock() {
     try {
-      rmSync2(lockFile, { force: true });
+      rmSync3(lockFile, { force: true });
     } catch {
     }
   }
   function liftHolds() {
     try {
-      rmSync2(holdsFile, { force: true });
+      rmSync3(holdsFile, { force: true });
     } catch {
     }
   }
   function readHolds() {
     try {
       if (!existsSync20(holdsFile)) return {};
-      const parsed = JSON.parse(readFileSync19(holdsFile, "utf8"));
+      const parsed = JSON.parse(readFileSync20(holdsFile, "utf8"));
       if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
         return {};
       }
@@ -32040,11 +32592,11 @@ function makeViolationsBuffer(opts = {}) {
   function writeHolds(holds) {
     try {
       if (Object.keys(holds).length === 0) {
-        rmSync2(holdsFile, { force: true });
+        rmSync3(holdsFile, { force: true });
         return;
       }
       ensureDirFor4(holdsFile);
-      writeFileSync13(holdsFile, JSON.stringify(holds), "utf8");
+      writeFileSync14(holdsFile, JSON.stringify(holds), "utf8");
     } catch {
     }
   }
@@ -32077,7 +32629,7 @@ function capRecords(records, now) {
 function ensureDirFor4(filePath) {
   const dir = dirname11(filePath);
   if (!existsSync20(dir)) {
-    mkdirSync11(dir, { recursive: true });
+    mkdirSync12(dir, { recursive: true });
   }
 }
 var _defaultBuffer = makeViolationsBuffer();
@@ -32086,9 +32638,9 @@ var flushViolations = _defaultBuffer.flushViolations.bind(_defaultBuffer);
 var liftViolationHolds = _defaultBuffer.liftHolds.bind(_defaultBuffer);
 
 // src/hooks/runtime/unmapped-tools.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname12, join as join17 } from "node:path";
-import { homedir as homedir16 } from "node:os";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname12, join as join18 } from "node:path";
+import { homedir as homedir17 } from "node:os";
 var TARGETLESS_TOOL_RE = /^(?:ToolSearch|TodoRead|TodoWrite|Task|Agent|AskUserQuestion|Skill|SlashCommand|EnterPlanMode|ExitPlanMode|EnterWorktree|ExitWorktree|BashOutput|KillShell|KillBash|Monitor|ListMcpResourcesTool|ReadMcpResourceTool|ReadMcpResourceDirTool|ScheduleWakeup|PushNotification|CronCreate|CronDelete|CronList|SendMessage|ListAgents|TaskOutput|TaskStop|ReportFindings|Workflow)$/;
 var OWN_MCP_TOOL_RE = /^mcp__cybedefend(?:-[A-Za-z0-9_-]+)?__/;
 function isTargetlessTool(tool) {
@@ -32100,13 +32652,13 @@ function strictUnmappedPolicy() {
 }
 var MAX_TOOLS = 200;
 function defaultUnmappedToolsFile() {
-  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join17(homedir16(), ".cybedefend");
-  return join17(dir, "guards-unmapped-tools.json");
+  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join18(homedir17(), ".cybedefend");
+  return join18(dir, "guards-unmapped-tools.json");
 }
 function load(file2) {
   try {
     if (!existsSync21(file2)) return { tools: {} };
-    const parsed = JSON.parse(readFileSync20(file2, "utf8"));
+    const parsed = JSON.parse(readFileSync21(file2, "utf8"));
     if (!parsed || typeof parsed !== "object" || typeof parsed.tools !== "object" || !parsed.tools) {
       return { tools: {} };
     }
@@ -32130,8 +32682,8 @@ function makeUnmappedToolTelemetry(file2 = defaultUnmappedToolsFile()) {
         if (names.length > MAX_TOOLS) {
           names.sort((a, b) => data.tools[a].lastSeen.localeCompare(data.tools[b].lastSeen)).slice(0, names.length - MAX_TOOLS).forEach((n) => delete data.tools[n]);
         }
-        mkdirSync12(dirname12(file2), { recursive: true });
-        writeFileSync14(file2, JSON.stringify(data, null, 2) + "\n", "utf8");
+        mkdirSync13(dirname12(file2), { recursive: true });
+        writeFileSync15(file2, JSON.stringify(data, null, 2) + "\n", "utf8");
       } catch {
       }
     }
@@ -32171,9 +32723,16 @@ function extractWriteTargets(req, rawCommand) {
   }
   return [];
 }
-function normalizeToolName(tool) {
+function normalizeToolName(tool, client) {
   if (!tool) return "";
   const t = (tool.split(/[\r\n]/, 1)[0] ?? "").trim();
+  if (client === "antigravity") {
+    if (/^view_file$/i.test(t)) return "Read";
+    if (/^(write_to_file|write_file)$/i.test(t)) return "Write";
+    if (/^(replace_file_content|edit_file)$/i.test(t)) return "Edit";
+    if (/^multi_replace_file_content$/i.test(t)) return "MultiEdit";
+    if (/^read_url_content$/i.test(t)) return "WebFetch";
+  }
   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";
@@ -32189,11 +32748,11 @@ function appendDebugLog(entry) {
   try {
     const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
     if (!homeDir) return;
-    const { mkdirSync: mkdirSync13, appendFileSync: appendFileSync2 } = __require("node:fs");
-    const { join: join19 } = __require("node:path");
-    const dir = join19(homeDir, ".cybedefend");
-    mkdirSync13(dir, { recursive: true });
-    appendFileSync2(join19(dir, "hook-debug.log"), entry + "\n", "utf8");
+    const { mkdirSync: mkdirSync14, appendFileSync: appendFileSync3 } = __require("node:fs");
+    const { join: join20 } = __require("node:path");
+    const dir = join20(homeDir, ".cybedefend");
+    mkdirSync14(dir, { recursive: true });
+    appendFileSync3(join20(dir, "hook-debug.log"), entry + "\n", "utf8");
   } catch {
   }
 }
@@ -32208,9 +32767,63 @@ function debugLog(entry) {
   }
 }
 var UNNAMED_TOOL = "<unnamed>";
+function sniffCaller(envelope) {
+  try {
+    return sniff(envelope);
+  } catch {
+  }
+  let client = "unknown";
+  try {
+    client = detectClient(envelope);
+  } catch {
+  }
+  const rawTool = client === "antigravity" && isRecord(envelope.toolCall) ? envelope.toolCall.name : envelope?.tool_name;
+  return {
+    client,
+    toolName: typeof rawTool === "string" ? rawTool : "",
+    filePath: "",
+    filePaths: [],
+    newContent: "",
+    raw: envelope
+  };
+}
 function argvToCommandLine(argv) {
   return argv.map((a) => /^[A-Za-z0-9_./=:@%+,-]+$/.test(a) ? a : `'${a.replace(/'/g, "'\\''")}'`).join(" ");
 }
+var MCP_SERVER_NAME_RE = /^[A-Za-z0-9]+(?:[-_][A-Za-z0-9]+)*$/;
+var MCP_SERVER_NAME_MAX = 64;
+var MCP_TOOL_NAME_RE = /^[A-Za-z0-9]+(?:[-_.][A-Za-z0-9]+)*$/;
+var MCP_TOOL_NAME_MAX = 128;
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function readAntigravityCall(envelope) {
+  const toolCall = isRecord(envelope.toolCall) ? envelope.toolCall : {};
+  const args = isRecord(toolCall.args) ? toolCall.args : {};
+  const str3 = (v) => typeof v === "string" ? v : void 0;
+  const name = str3(toolCall.name);
+  let tool = name;
+  const server = str3(args.ServerName);
+  const mcpTool = str3(args.ToolName);
+  if (tool === "call_mcp_tool" && server !== void 0 && mcpTool !== void 0 && server.length <= MCP_SERVER_NAME_MAX && MCP_SERVER_NAME_RE.test(server) && mcpTool.length <= MCP_TOOL_NAME_MAX && MCP_TOOL_NAME_RE.test(mcpTool)) {
+    tool = `mcp__${server}__${mcpTool}`;
+  }
+  const params = {};
+  const filePath = antigravityFilePathArg(name ?? "", args);
+  if (filePath) params.file_path = filePath;
+  const command = str3(args.CommandLine);
+  if (command !== void 0) params.command = command;
+  const url2 = str3(args.Url);
+  if (url2 !== void 0) params.url = url2;
+  let classifiedTool;
+  let extraFilePaths = [];
+  if (name !== void 0 && filePath && !ANTIGRAVITY_KNOWN_TOOLS.has(name)) {
+    classifiedTool = classifyUnknownAntigravityTool(args);
+    extraFilePaths = antigravityAllPathArgs(args).filter((p) => p !== filePath);
+  }
+  const cwd = typeof args.Cwd === "string" && args.Cwd.length > 0 ? args.Cwd : sessionFolderOf(envelope, "antigravity");
+  return { tool, classifiedTool, params, extraFilePaths, cwd, argKeys: Object.keys(args) };
+}
 function commandField(params) {
   const v = params.command;
   if (typeof v === "string") return v;
@@ -32219,40 +32832,67 @@ function commandField(params) {
   }
   return null;
 }
-function mapEnvelope(envelope, agent = sniff(envelope).client) {
-  const rawTool = typeof envelope.tool_name === "string" ? envelope.tool_name : typeof envelope.tool === "string" ? envelope.tool : void 0;
-  const params = envelope.tool_input ?? envelope.params ?? envelope.input ?? {};
+function windsurfToolCall(envelope) {
+  const ev = sniffCaller(envelope);
+  switch (ev.toolName) {
+    case "Bash":
+      return { rawTool: ev.toolName, params: { command: ev.newContent } };
+    case "Read":
+    case "Write":
+      return { rawTool: ev.toolName, params: { file_path: ev.filePath } };
+    default:
+      return { rawTool: ev.toolName, params: {} };
+  }
+}
+function fileMapping(agent, tool, params, homeDir, cwd, rawTool, extraFilePaths) {
+  const filePath = typeof params.file_path === "string" ? params.file_path : typeof params.path === "string" ? params.path : null;
+  if (!filePath) return { kind: "unmapped", tool: rawTool ?? UNNAMED_TOOL };
+  const request = {
+    agent,
+    tool,
+    target: { type: "file", path: filePath },
+    homeDir,
+    cwd
+  };
+  if (extraFilePaths.length === 0) return { kind: "mapped", request };
+  return {
+    kind: "mapped",
+    request,
+    additionalRequests: extraFilePaths.map((path) => ({
+      agent,
+      tool,
+      target: { type: "file", path },
+      homeDir,
+      cwd
+    }))
+  };
+}
+function mapEnvelope(envelope, agent = sniffCaller(envelope).client) {
+  const antigravity = agent === "antigravity" ? readAntigravityCall(envelope) : null;
+  const windsurf = agent === "windsurf" ? windsurfToolCall(envelope) : null;
+  const rawTool = antigravity ? antigravity.tool : windsurf ? windsurf.rawTool : typeof envelope.tool_name === "string" ? envelope.tool_name : typeof envelope.tool === "string" ? envelope.tool : void 0;
+  const params = antigravity ? antigravity.params : windsurf ? windsurf.params : envelope.tool_input ?? envelope.params ?? envelope.input ?? {};
+  const loggedKeys = antigravity ? antigravity.argKeys : Object.keys(params);
   debugLog({
     event: "pre_map",
     raw_tool_name: rawTool ?? null,
     has_tool_input: "tool_input" in envelope,
     has_params: "params" in envelope,
-    param_keys: Object.keys(params).slice(0, 12)
+    param_keys: loggedKeys.slice(0, 12)
   });
   const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "/";
-  const cwd = process.cwd();
-  const tool = normalizeToolName(rawTool);
+  const cwd = antigravity ? antigravity.cwd : process.cwd();
+  const tool = antigravity?.classifiedTool ?? normalizeToolName(rawTool, agent);
+  const extraFilePaths = antigravity?.extraFilePaths ?? [];
   switch (tool) {
     case "Read":
     case "Glob":
-    case "Grep": {
-      const filePath = typeof params.file_path === "string" ? params.file_path : typeof params.path === "string" ? params.path : null;
-      if (!filePath) return { kind: "unmapped", tool: rawTool ?? UNNAMED_TOOL };
-      return {
-        kind: "mapped",
-        request: { agent, tool, target: { type: "file", path: filePath }, homeDir, cwd }
-      };
-    }
+    case "Grep":
+      return fileMapping(agent, tool, params, homeDir, cwd, rawTool, extraFilePaths);
     case "Write":
     case "Edit":
-    case "MultiEdit": {
-      const filePath = typeof params.file_path === "string" ? params.file_path : typeof params.path === "string" ? params.path : null;
-      if (!filePath) return { kind: "unmapped", tool: rawTool ?? UNNAMED_TOOL };
-      return {
-        kind: "mapped",
-        request: { agent, tool, target: { type: "file", path: filePath }, homeDir, cwd }
-      };
-    }
+    case "MultiEdit":
+      return fileMapping(agent, tool, params, homeDir, cwd, rawTool, extraFilePaths);
     case "Bash": {
       const command = commandField(params);
       if (!command) return { kind: "unmapped", tool: rawTool ?? UNNAMED_TOOL };
@@ -32334,7 +32974,7 @@ function mapEnvelope(envelope, agent = sniff(envelope).client) {
         JSON.stringify({
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           tool_name: rawTool ?? null,
-          params_keys: Object.keys(params)
+          params_keys: loggedKeys
         })
       );
       return { kind: "unmapped", tool: rawTool ?? UNNAMED_TOOL };
@@ -32383,6 +33023,9 @@ function stringifyTarget(t) {
       return `git ${t.subcommand}`;
   }
 }
+function verdictRank(v) {
+  return v === "deny" ? 2 : v === "warn" ? 1 : 0;
+}
 async function consultJudge(judge, sessionId, cacheKey, input2, cache = { get: (k) => judge.cacheGet(k), set: (k, r) => judge.cacheSet(k, r) }) {
   const cached2 = cache.get(cacheKey);
   if (cached2) return { kind: "result", res: cached2 };
@@ -32601,6 +33244,14 @@ ${JSON.stringify(payload)}` : targetStr);
   }
   return { engine: "llm", outcome: "confirmed", model: res.model };
 }
+var SESSION_ID_MAX = 128;
+function antigravitySessionId(envelope) {
+  const id = envelope.conversationId;
+  return typeof id === "string" && id.length > 0 && id.length <= SESSION_ID_MAX ? id : void 0;
+}
+function denyExitCode(client) {
+  return client === "antigravity" ? 0 : 2;
+}
 async function runCatchJudgeStep(args) {
   const {
     judge,
@@ -32660,7 +33311,7 @@ async function runCatchJudgeStep(args) {
     message
   };
 }
-function emitUnverifiedBanner(reason) {
+function emitUnverifiedBanner(reason, client) {
   const banner = [
     "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
     "\u2588 VibeDefend Action Guards \u2014 UNVERIFIED                                        \u2588",
@@ -32678,7 +33329,7 @@ function emitUnverifiedBanner(reason) {
   ].join("\n") + "\n";
   process.stderr.write(banner);
   const isCodex = typeof process.env.CODEX_SANDBOX !== "undefined" || typeof process.env.CODEX_AGENT !== "undefined";
-  if (isCodex) {
+  if (isCodex && client !== "antigravity") {
     try {
       const ctx = JSON.stringify({
         additionalContext: `VibeDefend Action Guards UNVERIFIED \u2014 ${reason} Tool call allowed WITHOUT enforcement. Run \`vibedefend login\` to restore protection.`
@@ -32688,8 +33339,10 @@ function emitUnverifiedBanner(reason) {
     }
   }
 }
-function sessionIdOf3(envelope) {
-  return typeof envelope.session_id === "string" ? envelope.session_id : typeof envelope.sessionId === "string" ? envelope.sessionId : void 0;
+function sessionIdOf3(envelope, client) {
+  if (typeof envelope.session_id === "string") return envelope.session_id;
+  if (typeof envelope.sessionId === "string") return envelope.sessionId;
+  return client === "antigravity" ? antigravitySessionId(envelope) : void 0;
 }
 async function runPreToolUseGuardWith(opts) {
   const {
@@ -32702,21 +33355,22 @@ async function runPreToolUseGuardWith(opts) {
   if (!projectContext) return 0;
   if (rulesOutcome.kind === "unavailable") {
     emitUnverifiedBanner(
-      `Policy engine unreachable: ${rulesOutcome.reason}`
+      `Policy engine unreachable: ${rulesOutcome.reason}`,
+      sniffCaller(stdinEnvelope).client
     );
     return 0;
   }
   if (rulesOutcome.kind === "blocked") {
     const sentence = opts.usageNotifier?.notifyBlock(
-      sessionIdOf3(stdinEnvelope),
+      sessionIdOf3(stdinEnvelope, sniffCaller(stdinEnvelope).client),
       rulesOutcome.block
     );
-    if (sentence) emitAgentMessage("warn", sentence);
+    if (sentence) emitAgentMessage("warn", sentence, sniffCaller(stdinEnvelope).client);
     return 0;
   }
   const rules = rulesOutcome.rules;
-  const caller = sniff(stdinEnvelope);
-  const sessionId = sessionIdOf3(stdinEnvelope);
+  const caller = sniffCaller(stdinEnvelope);
+  const sessionId = sessionIdOf3(stdinEnvelope, caller.client);
   const mapping = mapEnvelope(stdinEnvelope, caller.client);
   if (mapping.kind === "targetless") return 0;
   if (mapping.kind === "unmapped") {
@@ -32731,9 +33385,10 @@ async function runPreToolUseGuardWith(opts) {
     if (strictUnmappedPolicy()) {
       emitAgentMessage(
         "deny",
-        `Tool "${mapping.tool}" is not evaluated by Action Guards and CYBEDEFEND_GUARDS_STRICT is on \u2014 blocked (strict mode).`
+        `Tool "${mapping.tool}" is not evaluated by Action Guards and CYBEDEFEND_GUARDS_STRICT is on \u2014 blocked (strict mode).`,
+        caller.client
       );
-      return 2;
+      return denyExitCode(caller.client);
     }
     if (opts.unmapped.noticeOnce(sessionId, mapping.tool)) {
       process.stderr.write(
@@ -32744,12 +33399,24 @@ async function runPreToolUseGuardWith(opts) {
     return 0;
   }
   const partial2 = mapping.request;
-  const guardRequest = {
+  let guardRequest = {
     ...partial2,
     projectId: projectContext.projectId,
     sessionId
   };
   let decision = evaluateFn(rules, guardRequest);
+  for (const extra of mapping.additionalRequests ?? []) {
+    const extraRequest = {
+      ...extra,
+      projectId: projectContext.projectId,
+      sessionId
+    };
+    const extraDecision = evaluateFn(rules, extraRequest);
+    if (verdictRank(extraDecision.verdict) > verdictRank(decision.verdict)) {
+      decision = extraDecision;
+      guardRequest = extraRequest;
+    }
+  }
   let hardenedTier = "small";
   let hardenedScripts = [];
   if (opts.hardenedCommandAnalysis && opts.sessionWrites && guardRequest.target.type === "file" && (guardRequest.tool === "Write" || guardRequest.tool === "Edit" || guardRequest.tool === "MultiEdit")) {
@@ -32904,20 +33571,28 @@ async function runPreToolUseGuardWith(opts) {
     matched_rule_ids: decision.matchedRuleIds
   });
   if (decision.verdict === "deny") {
-    emitAgentMessage("deny", decision.message ?? "Action blocked.");
-    return 2;
+    emitAgentMessage("deny", decision.message ?? "Action blocked.", caller.client);
+    return denyExitCode(caller.client);
   }
   if (decision.verdict === "warn") {
-    emitAgentMessage("warn", decision.message ?? "Action flagged.");
+    emitAgentMessage("warn", decision.message ?? "Action flagged.", caller.client);
     return 0;
   }
   return 0;
 }
-function emitAgentMessage(verdict, message) {
+var ANTIGRAVITY_DECISIONS = {
+  deny: "deny",
+  warn: "allow"
+};
+function emitAgentMessage(verdict, message, client) {
   const tag = verdict === "deny" ? "Action Guards" : "Action Guards \xB7 WARN";
   const fullMessage = `[VibeDefend ${tag}] ${message}`;
   process.stderr.write(fullMessage + "\n");
   try {
+    if (client === "antigravity") {
+      emitAntigravityDecision(ANTIGRAVITY_DECISIONS[verdict], fullMessage);
+      return;
+    }
     const payload = verdict === "deny" ? {
       // Claude Code legacy — the call, not the agent, is stopped.
       decision: "block",
@@ -32950,17 +33625,17 @@ function emitAgentMessage(verdict, message) {
 }
 function makeProductionJudgeDeps() {
   const cache = makeJudgeCache();
-  const warnDir = process.env.CYBEDEFEND_BASELINE_DIR ?? join18(homedir17(), ".cybedefend");
+  const warnDir = process.env.CYBEDEFEND_BASELINE_DIR ?? join19(homedir18(), ".cybedefend");
   const scriptCache = makeJudgeCache({
-    cacheFile: join18(warnDir, "guards-judge-script-cache.json"),
+    cacheFile: join19(warnDir, "guards-judge-script-cache.json"),
     ttlMs: SCRIPT_VERDICT_TTL_MS,
     maxEntries: SCRIPT_VERDICT_MAX_ENTRIES
   });
   const warnTracker = defaultSessionTracker(
-    join18(warnDir, "guards-judge-warned-sessions.json")
+    join19(warnDir, "guards-judge-warned-sessions.json")
   );
   const blockedTracker = defaultSessionTracker(
-    join18(warnDir, "guards-judge-blocked-sessions.json")
+    join19(warnDir, "guards-judge-blocked-sessions.json")
   );
   return {
     usage: {
@@ -32988,8 +33663,8 @@ function makeProductionJudgeDeps() {
 }
 function makeProductionUnmappedDeps() {
   const telemetry = makeUnmappedToolTelemetry();
-  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join18(homedir17(), ".cybedefend");
-  const tracker = defaultSessionTracker(join18(dir, "guards-unmapped-notified.json"));
+  const dir = process.env.CYBEDEFEND_BASELINE_DIR ?? join19(homedir18(), ".cybedefend");
+  const tracker = defaultSessionTracker(join19(dir, "guards-unmapped-notified.json"));
   return {
     record: telemetry.record,
     noticeOnce: (sessionId, tool) => {
@@ -33043,7 +33718,8 @@ async function runPreToolUseGuard() {
     });
     if (!token && rulesOutcome.kind === "unavailable") {
       emitUnverifiedBanner(
-        "Not authenticated \u2014 run `vibedefend login` to restore Action Guards."
+        "Not authenticated \u2014 run `vibedefend login` to restore Action Guards.",
+        sniffCaller(envelope).client
       );
       return 0;
     }
@@ -33080,7 +33756,7 @@ async function runPreToolUseGuard() {
       scriptJudge: process.env.CYBEDEFEND_HARDENED_ANALYSIS !== "0" && process.env.CYBEDEFEND_SCRIPT_JUDGE !== "0",
       // Level 1 — real script reader + per-session write memory.
       scriptResolver: process.env.CYBEDEFEND_HARDENED_ANALYSIS !== "0" ? (command, cwd) => resolveExecutedScript(command, { cwd }) : void 0,
-      sessionWrites: process.env.CYBEDEFEND_HARDENED_ANALYSIS !== "0" ? makeSessionWritesPort(sessionIdOf3(envelope)) : void 0,
+      sessionWrites: process.env.CYBEDEFEND_HARDENED_ANALYSIS !== "0" ? makeSessionWritesPort(sessionIdOf3(envelope, sniffCaller(envelope).client)) : void 0,
       resolvePaths: process.env.CYBEDEFEND_HARDENED_ANALYSIS !== "0" ? (rawPath, cwd, homeDir) => resolveCandidatePaths(rawPath, { cwd, homeDir }) : void 0,
       // The refusal sentence goes out through the agent-message channels
       // (stderr included), so this notifier itself writes nothing.
@@ -33177,7 +33853,31 @@ function toApiViolation(r) {
 
 // src/hooks/runtime/index.ts
 async function main() {
-  const subcommand = process.argv[2] ?? "";
+  const { subcommand, client } = parseRunnerArgs(process.argv.slice(2));
+  const isAntigravity = client === "antigravity";
+  const finish = (code) => {
+    if (isAntigravity) {
+      finishAntigravityRun(subcommand);
+      process.exit(0);
+    }
+    process.exit(code);
+  };
+  if (isAntigravity) {
+    let crashed = false;
+    const onCrash = (e) => {
+      if (crashed) return;
+      crashed = true;
+      try {
+        const msg = e instanceof Error ? e.stack || e.message : String(e);
+        process.stderr.write(`[vibedefend hook] ${subcommand}: ${msg}
+`);
+      } catch {
+      }
+      finish(0);
+    };
+    process.on("uncaughtException", onCrash);
+    process.on("unhandledRejection", onCrash);
+  }
   try {
     switch (subcommand) {
       case "fetch-rules":
@@ -33195,6 +33895,9 @@ async function main() {
       case "user-prompt-submit":
         await userPromptSubmitHook();
         break;
+      case "pre-invocation":
+        await preInvocationHook();
+        break;
       case "flush-violations":
         await runViolationsFlush();
         break;
@@ -33202,21 +33905,21 @@ async function main() {
       case "pre-tool-use":
       case "PreToolUse": {
         const code = await runPreToolUseGuard();
-        process.exit(code);
+        finish(code);
         return;
       }
       case "":
       case "--help":
       case "-h":
         process.stderr.write(
-          "Usage: hook-runner.js <fetch-rules|session-start|session-review|pre-compact|user-prompt-submit|guard-check>\n"
+          "Usage: hook-runner.js <fetch-rules|session-start|session-review|pre-compact|user-prompt-submit|pre-invocation|guard-check> [--client antigravity]\n"
         );
-        process.exit(subcommand === "" ? 1 : 0);
+        finish(subcommand === "" ? 1 : 0);
         return;
       default:
         process.stderr.write(`Unknown subcommand: ${subcommand}
 `);
-        process.exit(1);
+        finish(1);
         return;
     }
   } catch (e) {
@@ -33224,6 +33927,6 @@ async function main() {
     process.stderr.write(`[vibedefend hook] ${subcommand}: ${msg}
 `);
   }
-  process.exit(0);
+  finish(0);
 }
 main();