context-mode 1.0.162 → 1.0.164

package/hooks/antigravity-cli/payload.mjs

@@ -0,0 +1,98 @@
+/**
+ * Shared Antigravity CLI (`agy`) hook payload normalization.
+ *
+ * The only refs-backed field is the working directory: the upstream hook example
+ * (refs/platforms/antigravity-cli/examples/title/title.sh:10, README.md:11)
+ * reads it from `workspace.current_dir` (an OBJECT field). We read that FIRST.
+ *
+ * The remaining fields below are empirically-derived/UNVERIFIED — no upstream
+ * agy doc or example confirms this shape; they are best-effort assumptions:
+ *   { conversationId, stepIdx, toolCall: { name, args }, error,
+ *     workspacePaths: [..], transcriptPath, artifactDirectoryPath }
+ *
+ * The shared context-mode capture/routing code expects Claude-shaped fields, so
+ * keep this mapping in one place for PreToolUse/PostToolUse/Stop.
+ */
+
+export function parseAgyPayload(raw) {
+  try {
+    const cleaned = String(raw ?? "").replace(/^\uFEFF/, "").trim();
+    return cleaned ? JSON.parse(cleaned) : {};
+  } catch {
+    return {};
+  }
+}
+
+export function getAgyProjectDir(payload) {
+  // Refs-backed FIRST: workspace.current_dir is the only upstream-documented
+  // field (examples/title/title.sh:10). `workspacePaths[0]` is an unverified
+  // fallback kept defensively.
+  const workspace = payload?.workspace;
+  if (workspace && typeof workspace === "object" && typeof workspace.current_dir === "string" && workspace.current_dir) {
+    return workspace.current_dir;
+  }
+  return Array.isArray(payload?.workspacePaths) && payload.workspacePaths.length > 0
+    ? String(payload.workspacePaths[0])
+    : undefined;
+}
+
+// agy native tool-name -> canonical map. Keep in sync with the two other copies:
+// hooks/core/routing.mjs (TOOL_ALIASES) and src/session/extract.ts
+// (TOOL_NAME_NORMALIZE). Three layers normalize independently; adding a new agy
+// tool means updating all three (a single shared table is a follow-up cleanup).
+function normalizeAgyToolName(name) {
+  switch (name) {
+    case "run_command":
+      return "Bash";
+    case "view_file":
+      return "Read";
+    case "grep_search":
+      return "Grep";
+    case "list_dir":
+      return "LS";
+    case "web_fetch":
+    case "read_url_content":
+      return "WebFetch";
+    case "search_web":
+      return "WebSearch";
+    default:
+      return name;
+  }
+}
+
+function normalizeAgyToolInput(toolName, args) {
+  const input = args && typeof args === "object" ? { ...args } : {};
+  const canonical = normalizeAgyToolName(toolName);
+  if (canonical === "Bash" && typeof input.CommandLine === "string" && typeof input.command !== "string") {
+    input.command = input.CommandLine;
+  }
+  if (canonical === "WebFetch") {
+    const url = input.url ?? input.URL ?? input.Url;
+    if (typeof url === "string" && typeof input.url !== "string") input.url = url;
+  }
+  if (canonical === "Read") {
+    const filePath = input.file_path ?? input.path ?? input.AbsolutePath ?? input.FilePath;
+    if (typeof filePath === "string" && typeof input.file_path !== "string") input.file_path = filePath;
+  }
+  if (canonical === "Grep") {
+    const pattern = input.pattern ?? input.Pattern ?? input.query ?? input.Query;
+    if (typeof pattern === "string" && typeof input.pattern !== "string") input.pattern = pattern;
+  }
+  return input;
+}
+
+export function fromAgy(payload) {
+  const toolCall = payload?.toolCall ?? {};
+  const rawToolName = toolCall?.name ?? "";
+  return {
+    session_id: payload?.conversationId,
+    transcript_path: payload?.transcriptPath,
+    cwd: getAgyProjectDir(payload),
+    tool_name: normalizeAgyToolName(rawToolName),
+    tool_input: normalizeAgyToolInput(rawToolName, toolCall?.args),
+    tool_response: typeof payload?.error === "string" ? payload.error : "",
+    tool_output: {
+      isError: typeof payload?.error === "string" && payload.error.length > 0,
+    },
+  };
+}

package/hooks/antigravity-cli/posttooluse.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Antigravity CLI (`agy`) PostToolUse hook — session event capture.
+ *
+ * agy fires hooks from a config at ~/.gemini/config/hooks.json (or via an
+ * installed agy plugin's hooks/hooks.json) and pipes a payload whose shape
+ * differs from the Claude-Code/Codex wire format this pipeline expects:
+ *
+ *   { conversationId, stepIdx, toolCall: { name, args }, error,
+ *     workspacePaths: [..], transcriptPath, artifactDirectoryPath }
+ *
+ * The event name arrives as argv (set in hooks.json), NOT in the payload, and
+ * the hook CWD is ~/.gemini/config — so the project dir MUST come from
+ * workspacePaths[0], never process.cwd(). We translate agy's payload into the
+ * Claude-shaped `input` the shared extractor/attribution pipeline consumes,
+ * then reuse it unchanged. This hook is capture-only and emits no stdout.
+ */
+
+import {
+  readStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  ANTIGRAVITY_CLI_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { readFileSync, unlinkSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { fromAgy, parseAgyPayload } from "./payload.mjs";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = ANTIGRAVITY_CLI_OPTS;
+
+try {
+  const input = fromAgy(parseAgyPayload(await readStdin()));
+
+  if (input.tool_name) {
+    const projectDir = getInputProjectDir(input, OPTS);
+
+    const { extractEvents } = await loadExtract();
+    const { resolveProjectAttributions } = await loadProjectAttribution();
+    const { SessionDB } = await loadSessionDB();
+
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+
+    db.ensureSession(sessionId, projectDir);
+
+    const normalizedInput = {
+      tool_name: input.tool_name,
+      tool_input: input.tool_input ?? {},
+      tool_response: input.tool_response ?? "",
+      tool_output: input.tool_output,
+    };
+
+    const events = extractEvents(normalizedInput);
+    attributeAndInsertEvents(db, sessionId, events, input, projectDir, "PostToolUse", resolveProjectAttributions);
+
+    try {
+      const rejectedPath = resolve(tmpdir(), `context-mode-rejected-${sessionId}.txt`);
+      let rejectedData;
+      try {
+        rejectedData = readFileSync(rejectedPath, "utf-8").trim();
+        unlinkSync(rejectedPath);
+      } catch { /* no marker */ }
+      if (rejectedData) {
+        const colonIdx = rejectedData.indexOf(":");
+        const rejTool = colonIdx > 0 ? rejectedData.slice(0, colonIdx) : rejectedData;
+        const rejReason = colonIdx > 0 ? rejectedData.slice(colonIdx + 1) : "denied";
+        attributeAndInsertEvents(
+          db,
+          sessionId,
+          [{
+            type: "rejected",
+            category: "rejected-approach",
+            data: `${rejTool}: ${rejReason}`,
+            priority: 2,
+          }],
+          input,
+          projectDir,
+          "PreToolUse",
+          resolveProjectAttributions,
+        );
+      }
+    } catch { /* best-effort */ }
+
+    try {
+      const redirectPath = resolve(tmpdir(), `context-mode-redirect-${sessionId}.txt`);
+      let redirectData;
+      try {
+        redirectData = readFileSync(redirectPath, "utf-8").trim();
+        unlinkSync(redirectPath);
+      } catch { /* no marker */ }
+
+      if (redirectData) {
+        const i1 = redirectData.indexOf(":");
+        const i2 = i1 >= 0 ? redirectData.indexOf(":", i1 + 1) : -1;
+        const i3 = i2 >= 0 ? redirectData.indexOf(":", i2 + 1) : -1;
+        if (i1 > 0 && i2 > i1 && i3 > i2) {
+          const tool = redirectData.slice(0, i1);
+          const type = redirectData.slice(i1 + 1, i2);
+          const bytesRaw = redirectData.slice(i2 + 1, i3);
+          const summary = redirectData.slice(i3 + 1);
+          const bytesAvoided = Number.parseInt(bytesRaw, 10);
+          if (Number.isFinite(bytesAvoided) && bytesAvoided > 0) {
+            attributeAndInsertEvents(
+              db,
+              sessionId,
+              [{
+                type,
+                category: "redirect",
+                data: `${tool}: ${summary}`,
+                priority: 2,
+                bytes_avoided: bytesAvoided,
+              }],
+              input,
+              projectDir,
+              "PreToolUse",
+              resolveProjectAttributions,
+            );
+          }
+        }
+      }
+    } catch { /* best-effort */ }
+
+    db.close();
+  }
+} catch {
+  // Swallow errors — a hook must never fail the host agent.
+}
+
+// Capture-only hook: emit nothing.

package/hooks/antigravity-cli/pretooluse.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+/**
+ * Antigravity CLI (`agy`) PreToolUse hook — bounded routing enforcement.
+ *
+ * agy honors top-level `{ decision: "deny" | "ask", reason }` responses for
+ * PreToolUse. It does not honor additionalContext, so mapped context guidance is
+ * emitted as a deny-and-retry instruction. We register only tools with existing
+ * core routing branches (Bash/Read/Grep/WebFetch), not LS/search_web.
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { readStdin } from "../core/stdin.mjs";
+import { routePreToolUse, initSecurity } from "../core/routing.mjs";
+import { formatDecision } from "../core/formatters.mjs";
+import { fromAgy, getAgyProjectDir, parseAgyPayload } from "./payload.mjs";
+import { getSessionId, ANTIGRAVITY_CLI_OPTS } from "../session-helpers.mjs";
+
+const __hookDir = dirname(fileURLToPath(import.meta.url));
+
+try {
+  await initSecurity(resolve(__hookDir, "..", "..", "build"));
+
+  const payload = parseAgyPayload(await readStdin());
+  const input = fromAgy(payload);
+
+  const decision = routePreToolUse(
+    String(input.tool_name ?? ""),
+    input.tool_input ?? {},
+    getAgyProjectDir(payload),
+    "antigravity-cli",
+    input.session_id,
+  );
+  const response = formatDecision("antigravity-cli", decision);
+
+  if (decision && input.tool_name) {
+    // Key markers on the SAME id posttooluse.mjs reads. getSessionId prefers the
+    // transcript UUID over conversationId, so deriving it any other way here
+    // (e.g. input.session_id) would miss the handoff whenever agy's transcript
+    // is <uuid>.jsonl and silently drop the rejected/redirect analytics.
+    const sessionId = getSessionId(input, ANTIGRAVITY_CLI_OPTS);
+    const formattedDeny = response && typeof response === "object" && response.decision === "deny";
+    if (formattedDeny || decision.action === "deny" || decision.action === "modify") {
+      try {
+        const reason = formattedDeny
+          ? (response.reason || "denied")
+          : decision.action === "deny"
+            ? (decision.reason || "denied")
+            : "Redirected to context-mode sandbox";
+        writeFileSync(
+          resolve(tmpdir(), `context-mode-rejected-${sessionId}.txt`),
+          `${input.tool_name}:${reason}`,
+          "utf-8",
+        );
+      } catch { /* best-effort */ }
+    }
+    if (decision.redirectMeta) {
+      try {
+        const meta = decision.redirectMeta;
+        const summary = String(meta.commandSummary ?? "").slice(0, 200);
+        writeFileSync(
+          resolve(tmpdir(), `context-mode-redirect-${sessionId}.txt`),
+          `${meta.tool}:${meta.type}:${meta.bytesAvoided}:${summary}`,
+          "utf-8",
+        );
+      } catch { /* best-effort */ }
+    }
+  }
+
+  if (response !== null) {
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+} catch {
+  // Fail OPEN. Empty stdout + exit 0 lets agy continue the tool call.
+}

package/hooks/antigravity-cli/stop.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Antigravity CLI (`agy`) Stop hook — session-end capture.
+ *
+ * agy's verified hook list exposes `Stop` ("when agent tries to exit") and no
+ * separate SessionEnd hook, so this records a single session_end marker when
+ * agy emits it. `agy -p` probes have not emitted Stop, so registration is
+ * best-effort. The hook is capture-only and emits no stdout.
+ */
+
+import {
+  readStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  ANTIGRAVITY_CLI_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { fromAgy, parseAgyPayload } from "./payload.mjs";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+const OPTS = ANTIGRAVITY_CLI_OPTS;
+
+try {
+  const payload = parseAgyPayload(await readStdin());
+  const input = fromAgy(payload);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const { SessionDB } = await loadSessionDB();
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  db.ensureSession(sessionId, projectDir);
+  db.insertEvent(
+    sessionId,
+    {
+      type: "session_end",
+      category: "session",
+      priority: 1,
+      data: JSON.stringify({
+        status: payload?.status ?? "stopped",
+        stepIdx: payload?.stepIdx ?? null,
+        transcriptPath: payload?.transcriptPath ?? null,
+      }),
+    },
+    "Stop",
+  );
+
+  db.close();
+} catch {
+  // A hook must never fail the host agent.
+}

package/hooks/codex/pretooluse.mjs

@@ -4,9 +4,11 @@ import "../suppress-stderr.mjs";
 /**
  * Codex CLI preToolUse hook for context-mode.
  *
- * Codex PreToolUse supports deny only — additionalContext, updatedInput,
- * ask, and allow are rejected by codex-rs output_parser.rs.
- * Source: codex-rs/hooks/src/engine/output_parser.rs
+ * Codex PreToolUse honors `permissionDecision:"deny"` on all builds, and
+ * `permissionDecision:"allow" + updatedInput` / `additionalContext` on
+ * codex-cli >= 0.141.0 (#845). Capability is detected at runtime by
+ * codex-caps.mjs; older builds fail closed (redirect → deny). `ask` is still
+ * unsupported. Source: codex-rs/hooks/src/engine/output_parser.rs
  */
 
 import { dirname, resolve } from "node:path";
@@ -14,6 +16,7 @@ import { fileURLToPath } from "node:url";
 import { readStdin, parseStdin, getInputProjectDir, getSessionId, CODEX_OPTS } from "../session-helpers.mjs";
 import { routePreToolUse, initSecurity } from "../core/routing.mjs";
 import { formatDecision } from "../core/formatters.mjs";
+import { codexSupportsUpdatedInput } from "../core/codex-caps.mjs";
 
 const __hookDir = dirname(fileURLToPath(import.meta.url));
 await initSecurity(resolve(__hookDir, "..", "..", "build"));
@@ -25,7 +28,14 @@ const toolInput = input.tool_input ?? {};
 const projectDir = getInputProjectDir(input, CODEX_OPTS);
 
 const decision = routePreToolUse(tool, toolInput, projectDir, "codex", getSessionId(input, CODEX_OPTS));
-const response = formatDecision("codex", decision);
+// #845: only modify/context depend on Codex's rewrite capability. Detection is
+// cached, but skip the probe entirely for deny / ask / passthrough decisions.
+const needsCaps = decision && (decision.action === "modify" || decision.action === "context");
+const response = formatDecision(
+  "codex",
+  decision,
+  needsCaps ? { codexSupportsRewrite: codexSupportsUpdatedInput() } : {},
+);
 const output = response ?? {
   hookSpecificOutput: { hookEventName: "PreToolUse" },
 };

package/hooks/codex/stop.mjs

@@ -3,7 +3,11 @@ import "./platform.mjs";
 import "../suppress-stderr.mjs";
 import "../ensure-deps.mjs";
 /**
- * Codex CLI Stop hook — record turn/session end state for continuity.
+ * Codex CLI Stop hook — record turn-end state for continuity.
+ *
+ * Stop fires at the end of an assistant turn, not at true session shutdown.
+ * Store a turn_end marker so session_end remains reserved for actual terminal
+ * lifecycle events on platforms that expose one.
  */
 
 import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, CODEX_OPTS } from "../session-helpers.mjs";
@@ -26,13 +30,17 @@ try {
   const sessionId = getSessionId(input, OPTS);
 
   db.ensureSession(sessionId, projectDir);
-  db.insertEvent(sessionId, {
-    type: "session_end",
-    status: "completed",
+  const payload = {
     stop_hook_active: input.stop_hook_active ?? false,
     last_assistant_message: typeof input.last_assistant_message === "string"
       ? input.last_assistant_message.slice(0, 2000)
       : null,
+  };
+  db.insertEvent(sessionId, {
+    type: "turn_end",
+    category: "session",
+    data: JSON.stringify(payload),
+    priority: 1,
   }, "Stop");
 
   db.close();

package/hooks/copilot-cli/posttooluse.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  COPILOT_OPTS,
+  resolveConfigDir,
+} from "../session-helpers.mjs";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = COPILOT_OPTS;
+// Diagnostic log is opt-in via CONTEXT_MODE_DEBUG. PostToolUse fires on every
+// tool call, so an unconditional append-only log grows without bound under the
+// user's config dir. Gate it behind the env flag — same pattern as the kimi
+// hooks — so contributors can still capture it on demand. See #787 review.
+const DEBUG_LOG = process.env.CONTEXT_MODE_DEBUG
+  ? join(resolveConfigDir(OPTS), "context-mode", "posttooluse-debug.log")
+  : null;
+
+function logDebug(line) {
+  if (!DEBUG_LOG) return;
+  try {
+    mkdirSync(dirname(DEBUG_LOG), { recursive: true });
+    appendFileSync(DEBUG_LOG, line);
+  } catch {
+    /* silent */
+  }
+}
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+  const toolName = input.tool_name ?? input.toolName ?? "";
+  const toolInput = input.tool_input ?? input.toolArgs ?? {};
+  const toolResponse =
+    input.tool_result?.text_result_for_llm ??
+    input.toolResult?.textResultForLlm ??
+    input.tool_response ??
+    input.toolResult;
+
+  logDebug(`[${new Date().toISOString()}] CALL: ${toolName}\n`);
+
+  const { extractEvents } = await loadExtract();
+  const { resolveProjectAttributions } = await loadProjectAttribution();
+  const { SessionDB } = await loadSessionDB();
+
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  db.ensureSession(sessionId, projectDir);
+
+  const events = extractEvents({
+    tool_name: toolName,
+    tool_input: toolInput,
+    tool_response: typeof toolResponse === "string"
+      ? toolResponse
+      : JSON.stringify(toolResponse ?? ""),
+    tool_output: input.tool_output,
+  });
+
+  attributeAndInsertEvents(db, sessionId, events, input, projectDir, "PostToolUse", resolveProjectAttributions);
+
+  logDebug(`[${new Date().toISOString()}] OK: ${toolName} -> ${events.length} events\n`);
+  db.close();
+} catch (err) {
+  logDebug(`[${new Date().toISOString()}] ERR: ${err?.message || err}\n`);
+}

package/hooks/copilot-cli/precompact.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+
+import { createSessionLoaders } from "../session-loaders.mjs";
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  COPILOT_OPTS,
+  resolveConfigDir,
+} from "../session-helpers.mjs";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadSnapshot } = createSessionLoaders(HOOK_DIR);
+const OPTS = COPILOT_OPTS;
+// Diagnostic log is opt-in via CONTEXT_MODE_DEBUG (same pattern as the kimi
+// hooks): keep the error telemetry available to contributors without writing an
+// append-only file to every user's config dir on compaction. See #787 review.
+const DEBUG_LOG = process.env.CONTEXT_MODE_DEBUG
+  ? join(resolveConfigDir(OPTS), "context-mode", "precompact-debug.log")
+  : null;
+
+function logDebug(line) {
+  if (!DEBUG_LOG) return;
+  try {
+    mkdirSync(dirname(DEBUG_LOG), { recursive: true });
+    appendFileSync(DEBUG_LOG, line);
+  } catch {
+    /* silent */
+  }
+}
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const { buildResumeSnapshot } = await loadSnapshot();
+  const { SessionDB } = await loadSessionDB();
+
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  const events = db.getEvents(sessionId);
+
+  if (events.length > 0) {
+    const stats = db.getSessionStats(sessionId);
+    const snapshot = buildResumeSnapshot(events, {
+      compactCount: (stats?.compact_count ?? 0) + 1,
+    });
+
+    db.upsertResume(sessionId, snapshot, events.length);
+    db.incrementCompactCount(sessionId);
+  }
+
+  db.close();
+} catch (err) {
+  logDebug(`[${new Date().toISOString()}] ${err?.message || err}\n`);
+}

package/hooks/copilot-cli/pretooluse.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readStdin } from "../core/stdin.mjs";
+import { routePreToolUse, initSecurity } from "../core/routing.mjs";
+import { formatDecision } from "../core/formatters.mjs";
+import { parseStdin, getSessionId, getInputProjectDir, COPILOT_OPTS } from "../session-helpers.mjs";
+
+const __hookDir = dirname(fileURLToPath(import.meta.url));
+
+try {
+  await initSecurity(resolve(__hookDir, "..", "..", "build"));
+
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const tool = input.tool_name ?? input.toolName ?? "";
+  const toolInput = input.tool_input ?? input.toolArgs ?? {};
+  const projectDir = getInputProjectDir(input, COPILOT_OPTS);
+
+  const decision = routePreToolUse(
+    tool,
+    toolInput,
+    projectDir,
+    "copilot-cli",
+    getSessionId(input, COPILOT_OPTS),
+  );
+  const response = formatDecision("copilot-cli", decision);
+  if (response !== null) {
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+} catch {
+  // Fail OPEN. A throw here (better-sqlite3 ABI skew, a routing exception, a
+  // malformed-stdin parse error) must NOT exit non-zero with empty stdout:
+  // GitHub Copilot CLI 1.0.59 treats a failed PreToolUse hook as "Denied by
+  // preToolUse hook (hook errored)" and blocks EVERY tool, bricking the agent.
+  // A legitimate veto is a normal stdout write + normal return (never a throw),
+  // so it is unaffected by this catch. Empty stdout + exit 0 => host ALLOWS the
+  // tool; context-mode routing is skipped for this one call, agent keeps working.
+}