failproofai 0.0.10-beta.2 → 0.0.10-beta.4

package/dist/cli.mjs

@@ -16,7 +16,7 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/hooks/types.ts
-var HOOK_SCOPES, INTEGRATION_TYPES, CODEX_HOOK_SCOPES, CODEX_HOOK_EVENT_TYPES, CODEX_EVENT_MAP, COPILOT_HOOK_SCOPES, COPILOT_HOOK_EVENT_TYPES, COPILOT_TOOL_MAP, CURSOR_HOOK_SCOPES, CURSOR_HOOK_EVENT_TYPES, CURSOR_EVENT_MAP, OPENCODE_HOOK_SCOPES, OPENCODE_HOOK_EVENT_TYPES, PI_HOOK_SCOPES, PI_HOOK_EVENT_TYPES, PI_EVENT_MAP, GEMINI_HOOK_SCOPES, GEMINI_HOOK_EVENT_TYPES, GEMINI_EVENT_MAP, GEMINI_TOOL_MAP, HOOK_EVENT_TYPES, FAILPROOFAI_HOOK_MARKER = "__failproofai_hook__";
+var HOOK_SCOPES, INTEGRATION_TYPES, CODEX_HOOK_SCOPES, CODEX_HOOK_EVENT_TYPES, CODEX_EVENT_MAP, CODEX_TOOL_MAP, COPILOT_HOOK_SCOPES, COPILOT_HOOK_EVENT_TYPES, COPILOT_TOOL_MAP, CURSOR_HOOK_SCOPES, CURSOR_HOOK_EVENT_TYPES, CURSOR_EVENT_MAP, CURSOR_TOOL_MAP, OPENCODE_HOOK_SCOPES, OPENCODE_HOOK_EVENT_TYPES, PI_HOOK_SCOPES, PI_HOOK_EVENT_TYPES, PI_EVENT_MAP, GEMINI_HOOK_SCOPES, GEMINI_HOOK_EVENT_TYPES, GEMINI_EVENT_MAP, GEMINI_TOOL_MAP, HOOK_EVENT_TYPES, FAILPROOFAI_HOOK_MARKER = "__failproofai_hook__";
 var init_types = __esm(() => {
   HOOK_SCOPES = ["user", "project", "local"];
   INTEGRATION_TYPES = ["claude", "codex", "copilot", "cursor", "opencode", "pi", "gemini"];
@@ -37,6 +37,10 @@ var init_types = __esm(() => {
     user_prompt_submit: "UserPromptSubmit",
     stop: "Stop"
   };
+  CODEX_TOOL_MAP = {
+    apply_patch: "Edit",
+    write_stdin: "Bash"
+  };
   COPILOT_HOOK_SCOPES = ["user", "project"];
   COPILOT_HOOK_EVENT_TYPES = [
     "SessionStart",
@@ -44,17 +48,33 @@ var init_types = __esm(() => {
     "UserPromptSubmit",
     "PreToolUse",
     "PostToolUse",
-    "Stop"
+    "Stop",
+    "SubagentStop"
   ];
   COPILOT_TOOL_MAP = {
     bash: "Bash",
+    powershell: "Bash",
+    list_bash: "Bash",
+    read_bash: "Bash",
+    stop_bash: "Bash",
+    write_bash: "Bash",
+    list_powershell: "Bash",
+    read_powershell: "Bash",
+    stop_powershell: "Bash",
+    write_powershell: "Bash",
     read: "Read",
+    view: "Read",
+    show_file: "Read",
     write: "Write",
+    create: "Write",
     edit: "Edit",
+    apply_patch: "Edit",
     str_replace_editor: "Edit",
     glob: "Glob",
     grep: "Grep",
-    ls: "LS"
+    rg: "Grep",
+    ls: "LS",
+    web_fetch: "WebFetch"
   };
   CURSOR_HOOK_SCOPES = ["user", "project"];
   CURSOR_HOOK_EVENT_TYPES = [
@@ -73,6 +93,9 @@ var init_types = __esm(() => {
     postToolUse: "PostToolUse",
     stop: "Stop"
   };
+  CURSOR_TOOL_MAP = {
+    Shell: "Bash"
+  };
   OPENCODE_HOOK_SCOPES = ["user", "project"];
   OPENCODE_HOOK_EVENT_TYPES = [
     "tool.execute.before",
@@ -956,7 +979,8 @@ function blockWorkOnMain(ctx) {
   if (ctx.toolName !== "Bash")
     return allow();
   const cmd = getCommand(ctx);
-  if (!GIT_COMMIT_MERGE_RE.test(cmd))
+  const match = cmd.match(GIT_COMMIT_MERGE_RE);
+  if (!match)
     return allow();
   const cwd = ctx.session?.cwd;
   if (!cwd)
@@ -966,7 +990,7 @@ function blockWorkOnMain(ctx) {
     return allow();
   const protectedBranches = ctx.params?.protectedBranches ?? ["main", "master"];
   if (protectedBranches.includes(branch)) {
-    return deny(`Git ${cmd.match(/git\s+(\S+)/)?.[1] ?? "operation"} on ${branch} is blocked. Create a feature branch first.`);
+    return deny(`Git ${match[1]} on ${branch} is blocked. Create a feature branch first.`);
   }
   return allow();
 }
@@ -1459,7 +1483,7 @@ var init_builtin_policies = __esm(() => {
   SECRET_FILE_RE = /\.(?:pem|key)$/;
   SECRET_FILE_ID_RSA_RE = /id_rsa/;
   SECRET_FILE_CREDENTIALS_RE = /credentials/;
-  GIT_COMMIT_MERGE_RE = /git\s+(?:commit|merge|rebase|cherry-pick)\b/;
+  GIT_COMMIT_MERGE_RE = /git\s+(commit|merge|rebase|cherry-pick)\b/;
   FAILPROOFAI_CLI_RE = /(?:^|;|&&|\|\||\|)\s*failproofai(?:\s|$)/;
   FAILPROOFAI_UNINSTALL_RE = /(?:npm\s+(?:uninstall|remove|un|r)\s.*failproofai|bun\s+remove\s.*failproofai|yarn\s+global\s+remove\s+failproofai|pnpm\s+(?:remove|uninstall|un)\s.*failproofai)/;
   GIT_AMEND_RE = /\bgit\s+commit\b.*--amend\b/;
@@ -2138,13 +2162,24 @@ You MUST complete the above action NOW. Do NOT ask the user for confirmation —
           decision: "deny"
         };
       }
-      if (eventType === "Stop") {
+      if (eventType === "Stop" || eventType === "SubagentStop") {
+        const reasonText = `MANDATORY ACTION REQUIRED from failproofai (policy: ${policy.name}): ${reason}
+
+You MUST complete the above action NOW. Do NOT ask the user for confirmation — execute the required action, then attempt to finish your task again.`;
+        if (session?.cli === "copilot") {
+          return {
+            exitCode: 0,
+            stdout: JSON.stringify({ decision: "block", reason: reasonText }),
+            stderr: "",
+            policyName: policy.name,
+            reason,
+            decision: "deny"
+          };
+        }
         return {
           exitCode: 2,
           stdout: "",
-          stderr: `MANDATORY ACTION REQUIRED from failproofai (policy: ${policy.name}): ${reason}
-
-You MUST complete the above action NOW. Do NOT ask the user for confirmation — execute the required action, then attempt to finish your task again.`,
+          stderr: reasonText,
           policyName: policy.name,
           reason,
           decision: "deny"
@@ -2264,14 +2299,26 @@ You MUST complete the above action(s) NOW. Do NOT ask the user for confirmation
         decision: "instruct"
       };
     }
-    if (eventType === "Stop") {
+    if (eventType === "Stop" || eventType === "SubagentStop") {
       const policyAttribution = policyNames.length === 1 ? `policy: ${policyNames[0]}` : `policies: ${policyNames.join(", ")}`;
+      const reasonText = `MANDATORY ACTION REQUIRED from failproofai (${policyAttribution}): ${combined}
+
+You MUST complete the above action(s) NOW. Do NOT ask the user for confirmation — execute the required action(s), then attempt to finish your task again.`;
+      if (session?.cli === "copilot") {
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({ decision: "block", reason: reasonText }),
+          stderr: "",
+          policyName: policyNames[0],
+          policyNames,
+          reason: combined,
+          decision: "instruct"
+        };
+      }
       return {
         exitCode: 2,
         stdout: "",
-        stderr: `MANDATORY ACTION REQUIRED from failproofai (${policyAttribution}): ${combined}
-
-You MUST complete the above action(s) NOW. Do NOT ask the user for confirmation — execute the required action(s), then attempt to finish your task again.`,
+        stderr: reasonText,
         policyName: policyNames[0],
         policyNames,
         reason: combined,
@@ -2770,7 +2817,7 @@ var init_hook_activity_store = __esm(() => {
 });
 
 // package.json
-var version2 = "0.0.10-beta.2";
+var version2 = "0.0.10-beta.4";
 var init_package = () => {};
 
 // src/posthog-key.ts
@@ -4713,161 +4760,1085 @@ var init_resolve_permission_mode = __esm(() => {
   init_codex_sessions();
 });
 
-// lib/telemetry-id.ts
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import crypto from "node:crypto";
-import { execSync as execSync2 } from "node:child_process";
-function hashToId(raw) {
-  return crypto.createHmac("sha256", NAMESPACE).update(raw).digest("hex");
+// lib/copilot-sessions.ts
+import { readFileSync as readFileSync5, readdirSync as readdirSync4, existsSync as existsSync6, statSync as statSync5 } from "node:fs";
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join14, resolve as resolve6, sep as sep2 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+function getCopilotHome() {
+  return process.env.COPILOT_HOME || join14(homedir13(), ".copilot");
 }
-function getPlatformMachineId() {
+function getCopilotSessionStateRoot2() {
+  return join14(getCopilotHome(), "session-state");
+}
+function getCopilotSessionDir(sessionId) {
+  if (!sessionId)
+    return null;
+  const root = resolve6(getCopilotSessionStateRoot2());
+  const candidate = resolve6(root, sessionId);
+  if (candidate === root || !candidate.startsWith(`${root}${sep2}`))
+    return null;
+  return candidate;
+}
+function resolveSessionFile(sessionId, filename) {
+  const dir = getCopilotSessionDir(sessionId);
+  if (!dir)
+    return null;
+  return join14(dir, filename);
+}
+function findCopilotTranscript(sessionId) {
+  const candidate = resolveSessionFile(sessionId, "events.jsonl");
+  if (!candidate)
+    return null;
+  return existsSync6(candidate) ? candidate : null;
+}
+function findCopilotWorkspace(sessionId) {
+  const candidate = resolveSessionFile(sessionId, "workspace.yaml");
+  if (!candidate)
+    return null;
+  return existsSync6(candidate) ? candidate : null;
+}
+function readYamlScalar(path, key) {
   try {
-    const platform = os.platform();
-    if (platform === "linux") {
-      for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-        try {
-          const id = fs.readFileSync(p, "utf-8").trim();
-          if (id)
-            return id;
-        } catch {}
+    const text = readFileSync5(path, "utf-8");
+    const re = new RegExp(`^${key}\\s*:\\s*(.+?)\\s*$`, "m");
+    const m = text.match(re);
+    if (!m)
+      return;
+    return m[1].replace(/^['"]|['"]$/g, "");
+  } catch {
+    return;
+  }
+}
+function readCopilotWorkspaceCwd(sessionId) {
+  const path = findCopilotWorkspace(sessionId);
+  if (!path)
+    return;
+  return readYamlScalar(path, "cwd");
+}
+async function parseCopilotLog(fileContent, source = "session") {
+  const lines = fileContent.split(`
+`).filter((line) => line.trim() !== "");
+  const entries = [];
+  const rawLines = [];
+  const toolUseById = new Map;
+  const toolUseStartMs = new Map;
+  let cwd;
+  let seenSessionStart = false;
+  for (let i = 0;i < lines.length; i++) {
+    if (i > 0 && i % 200 === 0)
+      await new Promise((r) => setImmediate(r));
+    const line = lines[i];
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const rawCopy = { ...raw, _source: source };
+    rawLines.push(rawCopy);
+    const timestampStr = raw.timestamp;
+    if (!timestampStr)
+      continue;
+    const date = new Date(timestampStr);
+    if (Number.isNaN(date.getTime()))
+      continue;
+    const timestamp = date.toISOString();
+    const recType = raw.type;
+    const data = raw.data ?? {};
+    if (recType === "session.start") {
+      const ctx = data.context;
+      const c = ctx?.cwd;
+      if (typeof c === "string" && !cwd)
+        cwd = c;
+      const label = seenSessionStart ? "Session Resumed" : "Session Started";
+      seenSessionStart = true;
+      entries.push({
+        type: "queue-operation",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        label
+      });
+      continue;
+    }
+    if (recType === "user.message") {
+      const text = data.content ?? "";
+      if (!text)
+        continue;
+      entries.push({
+        type: "user",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        message: { role: "user", content: text }
+      });
+      continue;
+    }
+    if (recType === "system.message") {
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    if (recType === "assistant.message") {
+      const text = data.content ?? "";
+      if (!text) {
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy
+        });
+        continue;
       }
-    } else if (platform === "darwin") {
-      const out = execSync2("ioreg -rd1 -c IOPlatformExpertDevice", {
-        encoding: "utf-8",
-        timeout: 3000
+      const blocks = [{ type: "text", text }];
+      entries.push({
+        type: "assistant",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        message: { role: "assistant", content: blocks }
       });
-      const m = out.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
-      if (m?.[1])
-        return m[1];
-    } else if (platform === "win32") {
-      const out = execSync2('reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid', { encoding: "utf-8", timeout: 3000 });
-      const m = out.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
-      if (m?.[1])
-        return m[1];
+      continue;
     }
-  } catch {}
-  return;
-}
-function getSystemPropertiesId() {
-  return [
-    os.hostname(),
-    os.homedir(),
-    os.platform(),
-    os.arch(),
-    os.cpus()[0]?.model ?? ""
-  ].join(":");
+    if (recType === "tool.execution_start") {
+      const callId = data.toolCallId;
+      const name = data.toolName ?? "tool";
+      const args = data.arguments ?? {};
+      const id = callId ?? `${date.getTime()}-${name}`;
+      const toolUse = {
+        type: "tool_use",
+        id,
+        name,
+        input: args
+      };
+      const entry = {
+        type: "assistant",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        message: { role: "assistant", content: [toolUse] }
+      };
+      entries.push(entry);
+      if (callId) {
+        toolUseById.set(callId, toolUse);
+        toolUseStartMs.set(callId, date.getTime());
+      }
+      continue;
+    }
+    if (recType === "tool.execution_complete") {
+      const callId = data.toolCallId;
+      const block = callId ? toolUseById.get(callId) : undefined;
+      if (block) {
+        const startMs = toolUseStartMs.get(callId) ?? date.getTime();
+        const result = data.result ?? {};
+        const telemetry = data.toolTelemetry ?? {};
+        const reportedMs = telemetry.metrics?.commandTimeMs ?? telemetry.metrics?.durationMs ?? null;
+        const durationMs = typeof reportedMs === "number" && reportedMs >= 0 ? reportedMs : Math.max(0, date.getTime() - startMs);
+        const content = result.detailedContent ?? result.content ?? "";
+        block.result = {
+          timestamp,
+          timestampFormatted: formatTimestamp(date),
+          content: typeof content === "string" ? content : JSON.stringify(content),
+          durationMs,
+          durationFormatted: formatDuration(durationMs)
+        };
+        continue;
+      }
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    entries.push({
+      type: "system",
+      ...baseEntry(rawCopy, timestamp, date, source),
+      raw: rawCopy
+    });
+  }
+  if (entries.length > 500)
+    await new Promise((r) => setImmediate(r));
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return { entries, rawLines, cwd };
 }
-function getFileBasedId() {
-  try {
-    const existing = fs.readFileSync(ID_FILE, "utf-8").trim();
-    if (existing)
-      return existing;
-  } catch {}
-  const id = crypto.randomUUID();
+async function getCopilotSessionLog(sessionId) {
+  const filePath = findCopilotTranscript(sessionId);
+  if (!filePath)
+    return null;
+  let fileContent;
   try {
-    fs.mkdirSync(ID_DIR, { recursive: true });
-    fs.writeFileSync(ID_FILE, id, "utf-8");
-  } catch {}
-  return id;
-}
-function getInstanceId() {
-  if (cachedId)
-    return cachedId;
-  const machineId = getPlatformMachineId();
-  if (machineId) {
-    cachedId = hashToId(machineId);
-    return cachedId;
-  }
-  const sysProps = getSystemPropertiesId();
-  if (sysProps) {
-    cachedId = hashToId(sysProps);
-    return cachedId;
+    fileContent = await readFile9(filePath, "utf-8");
+  } catch {
+    return null;
   }
-  cachedId = getFileBasedId();
-  return cachedId;
+  const { entries, rawLines, cwd } = await parseCopilotLog(fileContent, "session");
+  const resolvedCwd = cwd ?? readCopilotWorkspaceCwd(sessionId);
+  return { entries, rawLines, cwd: resolvedCwd, filePath };
 }
-var NAMESPACE = "failproofai-telemetry-v1", ID_DIR, ID_FILE, cachedId;
-var init_telemetry_id = __esm(() => {
-  ID_DIR = path.join(os.homedir(), ".failproofai");
-  ID_FILE = path.join(ID_DIR, "instance-id");
+var getCachedCopilotSessionLog;
+var init_copilot_sessions = __esm(() => {
+  init_log_entries();
+  getCachedCopilotSessionLog = runtimeCache((sessionId) => getCopilotSessionLog(sessionId), 60, { maxSize: 50 });
 });
 
-// src/auth/token-store.ts
-import {
-  readFileSync as readFileSync5,
-  writeFileSync as writeFileSync4,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync5,
-  unlinkSync as unlinkSync2,
-  renameSync as renameSync3,
-  openSync,
-  closeSync
-} from "node:fs";
-import { join as join14 } from "node:path";
-import { homedir as homedir13 } from "node:os";
-function ensureAuthDir() {
-  if (!existsSync6(AUTH_DIR))
-    mkdirSync5(AUTH_DIR, { recursive: true, mode: 448 });
+// lib/cursor-sessions.ts
+import { readFileSync as readFileSync6, readdirSync as readdirSync5, existsSync as existsSync7, statSync as statSync6 } from "node:fs";
+import { readFile as readFile10 } from "node:fs/promises";
+import { basename as basename3, join as join15, resolve as resolve7, sep as sep3 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+function getCursorHome2() {
+  return process.env.CURSOR_HOME || join15(homedir14(), ".cursor");
 }
-function readTokens() {
-  if (!existsSync6(AUTH_FILE))
+function getCursorSessionDir(sessionId) {
+  if (!sessionId)
     return null;
+  const home = resolve7(getCursorHome2());
+  const projectsRoot = resolve7(home, NEW_PROJECTS_DIR2);
+  let projectEntries = [];
   try {
-    const raw = readFileSync5(AUTH_FILE, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
+    projectEntries = readdirSync5(projectsRoot, { withFileTypes: true });
+  } catch {}
+  for (const entry of projectEntries) {
+    if (!entry.isDirectory())
+      continue;
+    const candidate = resolve7(projectsRoot, entry.name, NEW_AGENT_TRANSCRIPTS_DIR2, sessionId);
+    const transcriptRoot = resolve7(projectsRoot, entry.name, NEW_AGENT_TRANSCRIPTS_DIR2);
+    if (candidate === transcriptRoot || !candidate.startsWith(`${transcriptRoot}${sep3}`))
+      continue;
+    if (existsSync7(candidate))
+      return candidate;
   }
-}
-function writeTokens(tokens) {
-  ensureAuthDir();
-  const tmpPath = `${AUTH_FILE}.tmp`;
-  const fd = openSync(tmpPath, "w", 384);
-  try {
-    writeFileSync4(fd, JSON.stringify(tokens, null, 2));
-  } finally {
-    closeSync(fd);
+  for (const sub of LEGACY_SESSION_ROOT_CANDIDATES2) {
+    const root = resolve7(home, sub);
+    const candidate = resolve7(root, sessionId);
+    if (candidate === root || !candidate.startsWith(`${root}${sep3}`))
+      continue;
+    if (existsSync7(candidate))
+      return candidate;
   }
-  renameSync3(tmpPath, AUTH_FILE);
-}
-function clearTokens() {
-  if (existsSync6(AUTH_FILE))
-    unlinkSync2(AUTH_FILE);
+  return null;
 }
-function isLoggedIn() {
-  return existsSync6(AUTH_FILE);
+function findCursorTranscript(sessionId) {
+  const dir = getCursorSessionDir(sessionId);
+  if (!dir)
+    return null;
+  const newCandidate = join15(dir, `${basename3(dir)}.jsonl`);
+  if (existsSync7(newCandidate))
+    return newCandidate;
+  for (const name of LEGACY_TRANSCRIPT_FILE_CANDIDATES2) {
+    const candidate = join15(dir, name);
+    if (existsSync7(candidate))
+      return candidate;
+  }
+  return null;
 }
-var AUTH_DIR, AUTH_FILE;
-var init_token_store = __esm(() => {
-  AUTH_DIR = join14(homedir13(), ".failproofai");
-  AUTH_FILE = join14(AUTH_DIR, "auth.json");
-});
-
-// src/relay/queue.ts
-var exports_queue = {};
-__export(exports_queue, {
-  readProcessingFile: () => readProcessingFile,
-  queueSizeBytes: () => queueSizeBytes,
-  findOrphanProcessingFiles: () => findOrphanProcessingFiles,
-  deleteProcessingFile: () => deleteProcessingFile,
-  claimPendingBatch: () => claimPendingBatch,
-  appendToServerQueue: () => appendToServerQueue
-});
-import {
+async function parseCursorLog(fileContent, source = "session") {
+  const lines = fileContent.split(`
+`).filter((line) => line.trim() !== "");
+  const entries = [];
+  const rawLines = [];
+  const toolUseById = new Map;
+  const toolUseStartMs = new Map;
+  let cwd;
+  let seenSessionStart = false;
+  const SYNTH_T0 = Date.now();
+  for (let i = 0;i < lines.length; i++) {
+    if (i > 0 && i % 200 === 0)
+      await new Promise((r) => setImmediate(r));
+    const line = lines[i];
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const rawCopy = { ...raw, _source: source };
+    rawLines.push(rawCopy);
+    if (!raw.type && raw.role && raw.message?.content) {
+      const synthDate = new Date(SYNTH_T0 + i);
+      const synthTs = synthDate.toISOString();
+      const textParts = raw.message.content.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
+      if (raw.role === "user") {
+        const queryMatch = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/.exec(textParts);
+        const text = queryMatch ? queryMatch[1] : textParts;
+        if (text) {
+          entries.push({
+            type: "user",
+            ...baseEntry(rawCopy, synthTs, synthDate, source),
+            message: { role: "user", content: text }
+          });
+        }
+        continue;
+      }
+      if (raw.role === "assistant") {
+        const blocks = textParts ? [{ type: "text", text: textParts }] : [];
+        if (blocks.length === 0) {
+          entries.push({
+            type: "system",
+            ...baseEntry(rawCopy, synthTs, synthDate, source),
+            raw: rawCopy
+          });
+        } else {
+          entries.push({
+            type: "assistant",
+            ...baseEntry(rawCopy, synthTs, synthDate, source),
+            message: { role: "assistant", content: blocks }
+          });
+        }
+        continue;
+      }
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, synthTs, synthDate, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    const timestampStr = raw.timestamp;
+    if (!timestampStr)
+      continue;
+    const date = new Date(timestampStr);
+    if (Number.isNaN(date.getTime()))
+      continue;
+    const timestamp = date.toISOString();
+    const recType = raw.type;
+    const data = raw.data ?? {};
+    if (recType === "session.start" || recType === "sessionStart" || recType === "session_start") {
+      const ctx = data.context ?? data;
+      const c = ctx.cwd;
+      if (typeof c === "string" && !cwd)
+        cwd = c;
+      if (!cwd && Array.isArray(ctx.workspace_roots) && typeof ctx.workspace_roots[0] === "string") {
+        cwd = ctx.workspace_roots[0];
+      }
+      const label = seenSessionStart ? "Session Resumed" : "Session Started";
+      seenSessionStart = true;
+      entries.push({
+        type: "queue-operation",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        label
+      });
+      continue;
+    }
+    if (recType === "user.message" || recType === "userMessage") {
+      const text = typeof data.content === "string" ? data.content : typeof data.text === "string" ? data.text : "";
+      if (!text)
+        continue;
+      entries.push({
+        type: "user",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        message: { role: "user", content: text }
+      });
+      continue;
+    }
+    if (recType === "system.message" || recType === "systemMessage") {
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    if (recType === "assistant.message" || recType === "assistantMessage") {
+      const text = typeof data.content === "string" ? data.content : typeof data.text === "string" ? data.text : "";
+      if (!text) {
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy
+        });
+        continue;
+      }
+      const blocks = [{ type: "text", text }];
+      entries.push({
+        type: "assistant",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        message: { role: "assistant", content: blocks }
+      });
+      continue;
+    }
+    if (recType === "tool.execution_start" || recType === "tool.executionStart" || recType === "preToolUse") {
+      const callId = data.toolCallId ?? data.tool_use_id;
+      const name = data.toolName ?? data.tool_name ?? "tool";
+      const args = data.arguments ?? data.tool_input ?? {};
+      const id = callId ?? `${date.getTime()}-${name}`;
+      const toolUse = {
+        type: "tool_use",
+        id,
+        name,
+        input: args
+      };
+      const entry = {
+        type: "assistant",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        message: { role: "assistant", content: [toolUse] }
+      };
+      entries.push(entry);
+      if (callId) {
+        toolUseById.set(callId, toolUse);
+        toolUseStartMs.set(callId, date.getTime());
+      }
+      continue;
+    }
+    if (recType === "tool.execution_complete" || recType === "tool.executionComplete" || recType === "postToolUse") {
+      const callId = data.toolCallId ?? data.tool_use_id;
+      const block = callId ? toolUseById.get(callId) : undefined;
+      if (block) {
+        const startMs = toolUseStartMs.get(callId) ?? date.getTime();
+        const result = data.result ?? {};
+        const reportedMs = data.duration;
+        const durationMs = typeof reportedMs === "number" && reportedMs >= 0 ? reportedMs : Math.max(0, date.getTime() - startMs);
+        const content = result.detailedContent ?? result.content ?? data.tool_output ?? "";
+        block.result = {
+          timestamp,
+          timestampFormatted: formatTimestamp(date),
+          content: typeof content === "string" ? content : JSON.stringify(content),
+          durationMs,
+          durationFormatted: formatDuration(durationMs)
+        };
+        continue;
+      }
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    entries.push({
+      type: "system",
+      ...baseEntry(rawCopy, timestamp, date, source),
+      raw: rawCopy
+    });
+  }
+  if (entries.length > 500)
+    await new Promise((r) => setImmediate(r));
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return { entries, rawLines, cwd };
+}
+async function getCursorSessionLog(sessionId) {
+  const filePath = findCursorTranscript(sessionId);
+  if (!filePath)
+    return null;
+  let fileContent;
+  try {
+    fileContent = await readFile10(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const { entries, rawLines, cwd } = await parseCursorLog(fileContent, "session");
+  return { entries, rawLines, cwd, filePath };
+}
+var LEGACY_SESSION_ROOT_CANDIDATES2, LEGACY_TRANSCRIPT_FILE_CANDIDATES2, NEW_PROJECTS_DIR2 = "projects", NEW_AGENT_TRANSCRIPTS_DIR2 = "agent-transcripts", getCachedCursorSessionLog;
+var init_cursor_sessions = __esm(() => {
+  init_log_entries();
+  LEGACY_SESSION_ROOT_CANDIDATES2 = ["agent-sessions", "conversations", "sessions"];
+  LEGACY_TRANSCRIPT_FILE_CANDIDATES2 = ["events.jsonl", "transcript.jsonl", "messages.jsonl"];
+  getCachedCursorSessionLog = runtimeCache((sessionId) => getCursorSessionLog(sessionId), 60, { maxSize: 50 });
+});
+
+// lib/pi-sessions.ts
+import { readFileSync as readFileSync7, readdirSync as readdirSync6, existsSync as existsSync8, statSync as statSync7 } from "node:fs";
+import { readFile as readFile11 } from "node:fs/promises";
+import { join as join16, resolve as resolve8, sep as sep4 } from "node:path";
+import { homedir as homedir15 } from "node:os";
+function getPiSessionStateRoot() {
+  return process.env.PI_SESSIONS_DIR || join16(homedir15(), ".pi", "agent", "sessions");
+}
+function isSafeSessionId(sessionId) {
+  return UUID_RE.test(sessionId);
+}
+function findPiTranscript(sessionId) {
+  if (!isSafeSessionId(sessionId))
+    return null;
+  const root = resolve8(getPiSessionStateRoot());
+  let cwdDirs;
+  try {
+    cwdDirs = readdirSync6(root);
+  } catch {
+    return null;
+  }
+  for (const cwdDir of cwdDirs) {
+    const cwdPath = resolve8(root, cwdDir);
+    if (!cwdPath.startsWith(`${root}${sep4}`))
+      continue;
+    let files;
+    try {
+      files = readdirSync6(cwdPath);
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      const m = SESSION_FILE_RE3.exec(f);
+      if (!m || m[1].toLowerCase() !== sessionId.toLowerCase())
+        continue;
+      const candidate = resolve8(cwdPath, f);
+      if (!candidate.startsWith(`${cwdPath}${sep4}`))
+        continue;
+      if (existsSync8(candidate))
+        return candidate;
+    }
+  }
+  return null;
+}
+function extractMessageText(content) {
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const block of content) {
+    if (block?.type === "text" && typeof block.text === "string")
+      parts.push(block.text);
+  }
+  return parts.join(`
+
+`);
+}
+function buildAssistantContent(content) {
+  if (!Array.isArray(content))
+    return [];
+  const blocks = [];
+  for (const block of content) {
+    if (block?.type === "text" && typeof block.text === "string" && block.text.length > 0) {
+      blocks.push({ type: "text", text: block.text });
+    }
+    if (block?.type === "thinking" && typeof block.thinking === "string" && block.thinking.length > 0) {
+      blocks.push({ type: "text", text: `[thinking] ${block.thinking}` });
+    }
+  }
+  return blocks;
+}
+async function parsePiLog(fileContent, source = "session") {
+  const lines = fileContent.split(`
+`).filter((line) => line.trim() !== "");
+  const entries = [];
+  const rawLines = [];
+  let cwd;
+  let seenSessionStart = false;
+  for (let i = 0;i < lines.length; i++) {
+    if (i > 0 && i % 200 === 0)
+      await new Promise((r) => setImmediate(r));
+    const line = lines[i];
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const rawCopy = { ...raw, _source: source };
+    rawLines.push(rawCopy);
+    const timestampStr = raw.timestamp;
+    if (!timestampStr)
+      continue;
+    const date = new Date(timestampStr);
+    if (Number.isNaN(date.getTime()))
+      continue;
+    const timestamp = date.toISOString();
+    const recType = raw.type;
+    if (recType === "session") {
+      if (typeof raw.cwd === "string" && !cwd)
+        cwd = raw.cwd;
+      const label = seenSessionStart ? "Session Resumed" : "Session Started";
+      seenSessionStart = true;
+      entries.push({
+        type: "queue-operation",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        label
+      });
+      continue;
+    }
+    if (recType === "message" && raw.message && typeof raw.message === "object") {
+      const role = raw.message.role;
+      const content = raw.message.content;
+      if (role === "user") {
+        const text = extractMessageText(content);
+        if (!text)
+          continue;
+        entries.push({
+          type: "user",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          message: { role: "user", content: text }
+        });
+        continue;
+      }
+      if (role === "assistant") {
+        const blocks = buildAssistantContent(content);
+        if (blocks.length === 0) {
+          entries.push({
+            type: "system",
+            ...baseEntry(rawCopy, timestamp, date, source),
+            raw: rawCopy
+          });
+          continue;
+        }
+        entries.push({
+          type: "assistant",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          message: { role: "assistant", content: blocks }
+        });
+        continue;
+      }
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    entries.push({
+      type: "system",
+      ...baseEntry(rawCopy, timestamp, date, source),
+      raw: rawCopy
+    });
+  }
+  if (entries.length > 500)
+    await new Promise((r) => setImmediate(r));
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return { entries, rawLines, cwd };
+}
+async function getPiSessionLog(sessionId) {
+  const filePath = findPiTranscript(sessionId);
+  if (!filePath)
+    return null;
+  let fileContent;
+  try {
+    fileContent = await readFile11(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = await parsePiLog(fileContent, "session");
+  } catch {
+    return null;
+  }
+  return {
+    entries: parsed.entries,
+    rawLines: parsed.rawLines,
+    cwd: parsed.cwd,
+    filePath
+  };
+}
+var UUID_RE, SESSION_FILE_RE3, getCachedPiSessionLog;
+var init_pi_sessions = __esm(() => {
+  init_log_entries();
+  UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  SESSION_FILE_RE3 = /^[\d-]+T[\d-]+Z_([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+  getCachedPiSessionLog = runtimeCache((sessionId) => getPiSessionLog(sessionId), 60, { maxSize: 50 });
+});
+
+// lib/gemini-sessions.ts
+import { closeSync, openSync, readFileSync as readFileSync8, readSync, readdirSync as readdirSync7, existsSync as existsSync9, statSync as statSync8 } from "node:fs";
+import { readFile as readFile12 } from "node:fs/promises";
+import { join as join17, resolve as resolve9, sep as sep5 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+function getGeminiSessionStateRoot() {
+  return process.env.GEMINI_SESSIONS_DIR || join17(homedir16(), ".gemini", "tmp");
+}
+function isSafeSessionId2(sessionId) {
+  return UUID_RE2.test(sessionId);
+}
+function readFirstLineSync(path) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const buf = Buffer.alloc(4096);
+    const bytesRead = readSync(fd, buf, 0, buf.length, 0);
+    if (bytesRead === 0)
+      return null;
+    const text = buf.subarray(0, bytesRead).toString("utf-8");
+    const nl = text.indexOf(`
+`);
+    return nl >= 0 ? text.slice(0, nl) : text;
+  } catch {
+    return null;
+  } finally {
+    try {
+      closeSync(fd);
+    } catch {}
+  }
+}
+function findGeminiTranscript(sessionId) {
+  if (!isSafeSessionId2(sessionId))
+    return null;
+  const root = resolve9(getGeminiSessionStateRoot());
+  const wantPrefix = sessionId.slice(0, 8).toLowerCase();
+  let projectDirs;
+  try {
+    projectDirs = readdirSync7(root);
+  } catch {
+    return null;
+  }
+  for (const projectDir of projectDirs) {
+    const projectPath = resolve9(root, projectDir);
+    if (!projectPath.startsWith(`${root}${sep5}`))
+      continue;
+    const chatsDir = resolve9(projectPath, "chats");
+    let files;
+    try {
+      files = readdirSync7(chatsDir);
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      const m = SESSION_FILE_RE4.exec(f);
+      if (!m || m[2].toLowerCase() !== wantPrefix)
+        continue;
+      const candidate = resolve9(chatsDir, f);
+      if (!candidate.startsWith(`${chatsDir}${sep5}`))
+        continue;
+      if (!existsSync9(candidate))
+        continue;
+      const firstLine = readFirstLineSync(candidate);
+      if (!firstLine)
+        continue;
+      try {
+        const meta = JSON.parse(firstLine);
+        if (typeof meta.sessionId === "string" && meta.sessionId.toLowerCase() === sessionId.toLowerCase()) {
+          return candidate;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+function extractMessageText2(content) {
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const block of content) {
+    if (typeof block?.text === "string")
+      parts.push(block.text);
+  }
+  return parts.join(`
+
+`);
+}
+function buildAssistantContent2(content) {
+  if (!Array.isArray(content))
+    return [];
+  const blocks = [];
+  for (const block of content) {
+    if (typeof block?.text === "string" && block.text.length > 0) {
+      blocks.push({ type: "text", text: block.text });
+    }
+  }
+  return blocks;
+}
+async function parseGeminiLog(fileContent, source = "session", cwdHint) {
+  const lines = fileContent.split(`
+`).filter((line) => line.trim() !== "");
+  const entries = [];
+  const rawLines = [];
+  let cwd = cwdHint;
+  let seenStart = false;
+  for (let i = 0;i < lines.length; i++) {
+    if (i > 0 && i % 200 === 0)
+      await new Promise((r) => setImmediate(r));
+    const line = lines[i];
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const rawCopy = { ...raw, _source: source };
+    rawLines.push(rawCopy);
+    if (typeof raw.sessionId === "string" && typeof raw.startTime === "string") {
+      const date2 = new Date(raw.startTime);
+      if (!Number.isNaN(date2.getTime())) {
+        const label = seenStart ? "Session Resumed" : "Session Started";
+        seenStart = true;
+        entries.push({
+          type: "queue-operation",
+          ...baseEntry(rawCopy, date2.toISOString(), date2, source),
+          label
+        });
+      }
+      continue;
+    }
+    if (raw.$set)
+      continue;
+    const timestampStr = raw.timestamp;
+    if (!timestampStr)
+      continue;
+    const date = new Date(timestampStr);
+    if (Number.isNaN(date.getTime()))
+      continue;
+    const timestamp = date.toISOString();
+    const recType = raw.type;
+    if (recType === "user") {
+      const text = extractMessageText2(raw.content);
+      if (!text)
+        continue;
+      entries.push({
+        type: "user",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        message: { role: "user", content: text }
+      });
+      continue;
+    }
+    if (recType === "assistant" || recType === "model") {
+      const blocks = buildAssistantContent2(raw.content);
+      if (blocks.length === 0) {
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy
+        });
+        continue;
+      }
+      entries.push({
+        type: "assistant",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        message: { role: "assistant", content: blocks }
+      });
+      continue;
+    }
+    entries.push({
+      type: "system",
+      ...baseEntry(rawCopy, timestamp, date, source),
+      raw: rawCopy
+    });
+  }
+  if (entries.length > 500)
+    await new Promise((r) => setImmediate(r));
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return { entries, rawLines, cwd };
+}
+function readSiblingProjectRoot(transcriptPath) {
+  const chatsDir = resolve9(transcriptPath, "..");
+  const projectDir = resolve9(chatsDir, "..");
+  const rootFile = join17(projectDir, ".project_root");
+  try {
+    const text = readFileSync8(rootFile, "utf-8").trim();
+    return text.length > 0 ? text : undefined;
+  } catch {
+    return;
+  }
+}
+async function getGeminiSessionLog(sessionId) {
+  const filePath = findGeminiTranscript(sessionId);
+  if (!filePath)
+    return null;
+  let fileContent;
+  try {
+    fileContent = await readFile12(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const cwdHint = readSiblingProjectRoot(filePath);
+  let parsed;
+  try {
+    parsed = await parseGeminiLog(fileContent, "session", cwdHint);
+  } catch {
+    return null;
+  }
+  return {
+    entries: parsed.entries,
+    rawLines: parsed.rawLines,
+    cwd: parsed.cwd,
+    filePath
+  };
+}
+var UUID_RE2, SESSION_FILE_RE4, getCachedGeminiSessionLog;
+var init_gemini_sessions = __esm(() => {
+  init_log_entries();
+  UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  SESSION_FILE_RE4 = /^session-(.+)-([0-9a-f]{8})\.jsonl$/i;
+  getCachedGeminiSessionLog = runtimeCache((sessionId) => getGeminiSessionLog(sessionId), 60, { maxSize: 50 });
+});
+
+// src/hooks/resolve-transcript-path.ts
+function resolveTranscriptPath(integration, parsed, sessionId) {
+  const stdinPath = typeof parsed.transcript_path === "string" ? parsed.transcript_path : undefined;
+  if (stdinPath)
+    return stdinPath;
+  if (typeof sessionId !== "string" || sessionId.length === 0)
+    return;
+  switch (integration) {
+    case "claude":
+      return;
+    case "codex":
+      return findCodexTranscript(sessionId) ?? undefined;
+    case "copilot":
+      return findCopilotTranscript(sessionId) ?? undefined;
+    case "cursor":
+      return findCursorTranscript(sessionId) ?? undefined;
+    case "pi":
+      return findPiTranscript(sessionId) ?? undefined;
+    case "gemini":
+      return findGeminiTranscript(sessionId) ?? undefined;
+    case "opencode":
+      return `opencode-db://${sessionId}`;
+    default:
+      return;
+  }
+}
+var init_resolve_transcript_path = __esm(() => {
+  init_codex_sessions();
+  init_copilot_sessions();
+  init_cursor_sessions();
+  init_pi_sessions();
+  init_gemini_sessions();
+});
+
+// lib/telemetry-id.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { execSync as execSync2 } from "node:child_process";
+function hashToId(raw) {
+  return crypto.createHmac("sha256", NAMESPACE).update(raw).digest("hex");
+}
+function getPlatformMachineId() {
+  try {
+    const platform = os.platform();
+    if (platform === "linux") {
+      for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+        try {
+          const id = fs.readFileSync(p, "utf-8").trim();
+          if (id)
+            return id;
+        } catch {}
+      }
+    } else if (platform === "darwin") {
+      const out = execSync2("ioreg -rd1 -c IOPlatformExpertDevice", {
+        encoding: "utf-8",
+        timeout: 3000
+      });
+      const m = out.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (m?.[1])
+        return m[1];
+    } else if (platform === "win32") {
+      const out = execSync2('reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid', { encoding: "utf-8", timeout: 3000 });
+      const m = out.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
+      if (m?.[1])
+        return m[1];
+    }
+  } catch {}
+  return;
+}
+function getSystemPropertiesId() {
+  return [
+    os.hostname(),
+    os.homedir(),
+    os.platform(),
+    os.arch(),
+    os.cpus()[0]?.model ?? ""
+  ].join(":");
+}
+function getFileBasedId() {
+  try {
+    const existing = fs.readFileSync(ID_FILE, "utf-8").trim();
+    if (existing)
+      return existing;
+  } catch {}
+  const id = crypto.randomUUID();
+  try {
+    fs.mkdirSync(ID_DIR, { recursive: true });
+    fs.writeFileSync(ID_FILE, id, "utf-8");
+  } catch {}
+  return id;
+}
+function getInstanceId() {
+  if (cachedId)
+    return cachedId;
+  const machineId = getPlatformMachineId();
+  if (machineId) {
+    cachedId = hashToId(machineId);
+    return cachedId;
+  }
+  const sysProps = getSystemPropertiesId();
+  if (sysProps) {
+    cachedId = hashToId(sysProps);
+    return cachedId;
+  }
+  cachedId = getFileBasedId();
+  return cachedId;
+}
+var NAMESPACE = "failproofai-telemetry-v1", ID_DIR, ID_FILE, cachedId;
+var init_telemetry_id = __esm(() => {
+  ID_DIR = path.join(os.homedir(), ".failproofai");
+  ID_FILE = path.join(ID_DIR, "instance-id");
+});
+
+// src/auth/token-store.ts
+import {
+  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync4,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync5,
+  unlinkSync as unlinkSync2,
+  renameSync as renameSync3,
+  openSync as openSync2,
+  closeSync as closeSync2
+} from "node:fs";
+import { join as join18 } from "node:path";
+import { homedir as homedir17 } from "node:os";
+function ensureAuthDir() {
+  if (!existsSync10(AUTH_DIR))
+    mkdirSync5(AUTH_DIR, { recursive: true, mode: 448 });
+}
+function readTokens() {
+  if (!existsSync10(AUTH_FILE))
+    return null;
+  try {
+    const raw = readFileSync9(AUTH_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeTokens(tokens) {
+  ensureAuthDir();
+  const tmpPath = `${AUTH_FILE}.tmp`;
+  const fd = openSync2(tmpPath, "w", 384);
+  try {
+    writeFileSync4(fd, JSON.stringify(tokens, null, 2));
+  } finally {
+    closeSync2(fd);
+  }
+  renameSync3(tmpPath, AUTH_FILE);
+}
+function clearTokens() {
+  if (existsSync10(AUTH_FILE))
+    unlinkSync2(AUTH_FILE);
+}
+function isLoggedIn() {
+  return existsSync10(AUTH_FILE);
+}
+var AUTH_DIR, AUTH_FILE;
+var init_token_store = __esm(() => {
+  AUTH_DIR = join18(homedir17(), ".failproofai");
+  AUTH_FILE = join18(AUTH_DIR, "auth.json");
+});
+
+// src/relay/queue.ts
+var exports_queue = {};
+__export(exports_queue, {
+  readProcessingFile: () => readProcessingFile,
+  queueSizeBytes: () => queueSizeBytes,
+  findOrphanProcessingFiles: () => findOrphanProcessingFiles,
+  deleteProcessingFile: () => deleteProcessingFile,
+  claimPendingBatch: () => claimPendingBatch,
+  appendToServerQueue: () => appendToServerQueue
+});
+import {
   appendFileSync as appendFileSync3,
   mkdirSync as mkdirSync6,
-  existsSync as existsSync7,
-  readFileSync as readFileSync6,
-  statSync as statSync5,
+  existsSync as existsSync11,
+  readFileSync as readFileSync10,
+  statSync as statSync9,
   renameSync as renameSync4,
   unlinkSync as unlinkSync3,
-  readdirSync as readdirSync4,
+  readdirSync as readdirSync8,
   chmodSync
 } from "node:fs";
-import { join as join15 } from "node:path";
-import { homedir as homedir14 } from "node:os";
+import { join as join19 } from "node:path";
+import { homedir as homedir18 } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 function hashCwd(cwd) {
   if (!cwd)
@@ -4897,7 +5868,7 @@ function sanitize(entry) {
   };
 }
 function ensureDir2() {
-  if (!existsSync7(QUEUE_DIR)) {
+  if (!existsSync11(QUEUE_DIR)) {
     mkdirSync6(QUEUE_DIR, { recursive: true, mode: 448 });
   }
 }
@@ -4906,7 +5877,7 @@ function appendToServerQueue(entry) {
     return;
   ensureDir2();
   try {
-    if (existsSync7(PENDING_FILE) && statSync5(PENDING_FILE).size > MAX_QUEUE_BYTES) {
+    if (existsSync11(PENDING_FILE) && statSync9(PENDING_FILE).size > MAX_QUEUE_BYTES) {
       return;
     }
   } catch {}
@@ -4919,23 +5890,23 @@ function appendToServerQueue(entry) {
 }
 function queueSizeBytes() {
   try {
-    return statSync5(PENDING_FILE).size;
+    return statSync9(PENDING_FILE).size;
   } catch {
     return 0;
   }
 }
 function claimPendingBatch() {
-  if (!existsSync7(PENDING_FILE))
+  if (!existsSync11(PENDING_FILE))
     return null;
   try {
-    const size = statSync5(PENDING_FILE).size;
+    const size = statSync9(PENDING_FILE).size;
     if (size === 0)
       return null;
   } catch {
     return null;
   }
   const seq = `${Date.now()}-${process.pid}`;
-  const processingFile = join15(QUEUE_DIR, `${PROCESSING_PREFIX}${seq}.jsonl`);
+  const processingFile = join19(QUEUE_DIR, `${PROCESSING_PREFIX}${seq}.jsonl`);
   try {
     renameSync4(PENDING_FILE, processingFile);
     try {
@@ -4952,15 +5923,15 @@ function claimPendingBatch() {
 function findOrphanProcessingFiles() {
   ensureDir2();
   try {
-    return readdirSync4(QUEUE_DIR).filter((n) => n.startsWith(PROCESSING_PREFIX) && n.endsWith(".jsonl")).map((n) => join15(QUEUE_DIR, n)).sort();
+    return readdirSync8(QUEUE_DIR).filter((n) => n.startsWith(PROCESSING_PREFIX) && n.endsWith(".jsonl")).map((n) => join19(QUEUE_DIR, n)).sort();
   } catch {
     return [];
   }
 }
 function readProcessingFile(path2) {
-  if (!existsSync7(path2))
+  if (!existsSync11(path2))
     return [];
-  const content = readFileSync6(path2, "utf8");
+  const content = readFileSync10(path2, "utf8");
   const out = [];
   for (const line of content.split(`
 `)) {
@@ -4981,20 +5952,20 @@ function deleteProcessingFile(path2) {
 var QUEUE_DIR, PENDING_FILE, PROCESSING_PREFIX = "processing-", MAX_QUEUE_BYTES;
 var init_queue = __esm(() => {
   init_token_store();
-  QUEUE_DIR = join15(homedir14(), ".failproofai", "cache", "server-queue");
-  PENDING_FILE = join15(QUEUE_DIR, "pending.jsonl");
+  QUEUE_DIR = join19(homedir18(), ".failproofai", "cache", "server-queue");
+  PENDING_FILE = join19(QUEUE_DIR, "pending.jsonl");
   MAX_QUEUE_BYTES = 50 * 1024 * 1024;
 });
 
 // src/relay/pid.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync8, unlinkSync as unlinkSync4, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join16, dirname as dirname4 } from "node:path";
-import { homedir as homedir15 } from "node:os";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync5, existsSync as existsSync12, unlinkSync as unlinkSync4, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join20, dirname as dirname4 } from "node:path";
+import { homedir as homedir19 } from "node:os";
 function readPid() {
-  if (!existsSync8(PID_FILE))
+  if (!existsSync12(PID_FILE))
     return null;
   try {
-    const raw = readFileSync7(PID_FILE, "utf8").trim();
+    const raw = readFileSync11(PID_FILE, "utf8").trim();
     const pid = parseInt(raw, 10);
     if (Number.isNaN(pid) || pid <= 0)
       return null;
@@ -5005,12 +5976,12 @@ function readPid() {
 }
 function writePid(pid) {
   const dir = dirname4(PID_FILE);
-  if (!existsSync8(dir))
+  if (!existsSync12(dir))
     mkdirSync7(dir, { recursive: true, mode: 448 });
   writeFileSync5(PID_FILE, String(pid));
 }
 function clearPid() {
-  if (existsSync8(PID_FILE))
+  if (existsSync12(PID_FILE))
     unlinkSync4(PID_FILE);
 }
 function isProcessAlive(pid) {
@@ -5042,7 +6013,7 @@ function stopRelay() {
 }
 var PID_FILE;
 var init_pid = __esm(() => {
-  PID_FILE = join16(homedir15(), ".failproofai", "relay.pid");
+  PID_FILE = join20(homedir19(), ".failproofai", "relay.pid");
 });
 
 // src/relay/daemon.ts
@@ -5054,9 +6025,9 @@ __export(exports_daemon, {
   ensureRelayRunning: () => ensureRelayRunning
 });
 import { spawn } from "node:child_process";
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join17 } from "node:path";
-import { homedir as homedir16 } from "node:os";
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join21 } from "node:path";
+import { homedir as homedir20 } from "node:os";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function ensureRelayRunning() {
   if (!isLoggedIn())
@@ -5136,16 +6107,16 @@ class Relay {
     try {
       const msg = JSON.parse(data);
       if (msg.ack && this.pendingAcks.has(msg.ack)) {
-        const resolve6 = this.pendingAcks.get(msg.ack);
+        const resolve10 = this.pendingAcks.get(msg.ack);
         this.pendingAcks.delete(msg.ack);
-        resolve6(true);
+        resolve10(true);
       }
     } catch {}
   }
   handleClose() {
     this.closed = true;
-    for (const [, resolve6] of this.pendingAcks) {
-      resolve6(false);
+    for (const [, resolve10] of this.pendingAcks) {
+      resolve10(false);
     }
     this.pendingAcks.clear();
   }
@@ -5161,11 +6132,11 @@ class Relay {
     if (this.closed)
       return false;
     const batchId = randomUUID2();
-    const ackPromise = new Promise((resolve6) => {
-      this.pendingAcks.set(batchId, resolve6);
+    const ackPromise = new Promise((resolve10) => {
+      this.pendingAcks.set(batchId, resolve10);
       setTimeout(() => {
         if (this.pendingAcks.delete(batchId))
-          resolve6(false);
+          resolve10(false);
       }, ACK_TIMEOUT_MS);
     });
     try {
@@ -5183,7 +6154,7 @@ async function connect(wsUrl, token) {
     throw new Error("WebSocket not available in this Node version. Requires Node 22+.");
   }
   const ws = new WSCtor(wsUrl);
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve10, reject) => {
     let settled = false;
     const timeout = setTimeout(() => {
       if (settled)
@@ -5201,7 +6172,7 @@ async function connect(wsUrl, token) {
       clearTimeout(timeout);
       try {
         ws.send(token);
-        resolve6();
+        resolve10();
       } catch (e) {
         reject(e);
       }
@@ -5273,7 +6244,7 @@ async function runDaemon() {
       }
       relay.close();
     } catch {}
-    if (existsSync9(QUEUE_DIR2)) {}
+    if (existsSync13(QUEUE_DIR2)) {}
     await new Promise((r) => setTimeout(r, reconnectDelay));
     reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
   }
@@ -5323,7 +6294,7 @@ var init_daemon = __esm(() => {
   init_token_store();
   init_pid();
   init_queue();
-  QUEUE_DIR2 = join17(homedir16(), ".failproofai", "cache", "server-queue");
+  QUEUE_DIR2 = join21(homedir20(), ".failproofai", "cache", "server-queue");
 });
 
 // src/hooks/handler.ts
@@ -5357,12 +6328,14 @@ function canonicalizeEventType(raw, cli) {
 function canonicalizeToolName(raw, cli) {
   if (!raw)
     return raw;
-  if (cli === "copilot") {
+  if (cli === "copilot")
     return COPILOT_TOOL_MAP[raw] ?? raw;
-  }
-  if (cli === "gemini") {
+  if (cli === "cursor")
+    return CURSOR_TOOL_MAP[raw] ?? raw;
+  if (cli === "codex")
+    return CODEX_TOOL_MAP[raw] ?? raw;
+  if (cli === "gemini")
     return GEMINI_TOOL_MAP[raw] ?? raw;
-  }
   return raw;
 }
 async function handleHookEvent(eventType, cli = "claude") {
@@ -5370,7 +6343,7 @@ async function handleHookEvent(eventType, cli = "claude") {
   const MAX_STDIN_BYTES = 1048576;
   let payload = "";
   try {
-    payload = await new Promise((resolve6, reject) => {
+    payload = await new Promise((resolve10, reject) => {
       const chunks = [];
       let totalBytes = 0;
       process.stdin.setEncoding("utf8");
@@ -5379,15 +6352,15 @@ async function handleHookEvent(eventType, cli = "claude") {
         if (totalBytes > MAX_STDIN_BYTES) {
           hookLogWarn(`stdin payload exceeds 1 MB for ${eventType}, discarding`);
           process.stdin.destroy();
-          resolve6("");
+          resolve10("");
           return;
         }
         chunks.push(chunk);
       });
-      process.stdin.on("end", () => resolve6(chunks.join("")));
+      process.stdin.on("end", () => resolve10(chunks.join("")));
       process.stdin.on("error", reject);
       if (process.stdin.readableEnded)
-        resolve6("");
+        resolve10("");
     });
   } catch {
     hookLogWarn(`stdin read failed for ${eventType}`);
@@ -5409,7 +6382,7 @@ async function handleHookEvent(eventType, cli = "claude") {
   const sessionId = parsed.session_id;
   const session = {
     sessionId,
-    transcriptPath: parsed.transcript_path,
+    transcriptPath: resolveTranscriptPath(cli, parsed, sessionId),
     cwd: parsed.cwd,
     permissionMode: resolvePermissionMode(cli, parsed, sessionId),
     hookEventName: parsed.hook_event_name,
@@ -5541,6 +6514,7 @@ var init_handler = __esm(() => {
   init_hook_activity_store();
   init_hook_telemetry();
   init_resolve_permission_mode();
+  init_resolve_transcript_path();
   init_telemetry_id();
   init_hook_logger();
 });
@@ -5554,9 +6528,9 @@ __export(exports_daemon2, {
   ensureRelayRunning: () => ensureRelayRunning2
 });
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join18 } from "node:path";
-import { homedir as homedir17 } from "node:os";
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join22 } from "node:path";
+import { homedir as homedir21 } from "node:os";
 import { randomUUID as randomUUID3 } from "node:crypto";
 function ensureRelayRunning2() {
   if (!isLoggedIn())
@@ -5636,16 +6610,16 @@ class Relay2 {
     try {
       const msg = JSON.parse(data);
       if (msg.ack && this.pendingAcks.has(msg.ack)) {
-        const resolve6 = this.pendingAcks.get(msg.ack);
+        const resolve10 = this.pendingAcks.get(msg.ack);
         this.pendingAcks.delete(msg.ack);
-        resolve6(true);
+        resolve10(true);
       }
     } catch {}
   }
   handleClose() {
     this.closed = true;
-    for (const [, resolve6] of this.pendingAcks) {
-      resolve6(false);
+    for (const [, resolve10] of this.pendingAcks) {
+      resolve10(false);
     }
     this.pendingAcks.clear();
   }
@@ -5661,11 +6635,11 @@ class Relay2 {
     if (this.closed)
       return false;
     const batchId = randomUUID3();
-    const ackPromise = new Promise((resolve6) => {
-      this.pendingAcks.set(batchId, resolve6);
+    const ackPromise = new Promise((resolve10) => {
+      this.pendingAcks.set(batchId, resolve10);
       setTimeout(() => {
         if (this.pendingAcks.delete(batchId))
-          resolve6(false);
+          resolve10(false);
       }, ACK_TIMEOUT_MS2);
     });
     try {
@@ -5683,7 +6657,7 @@ async function connect2(wsUrl, token) {
     throw new Error("WebSocket not available in this Node version. Requires Node 22+.");
   }
   const ws = new WSCtor(wsUrl);
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve10, reject) => {
     let settled = false;
     const timeout = setTimeout(() => {
       if (settled)
@@ -5701,7 +6675,7 @@ async function connect2(wsUrl, token) {
       clearTimeout(timeout);
       try {
         ws.send(token);
-        resolve6();
+        resolve10();
       } catch (e) {
         reject(e);
       }
@@ -5773,7 +6747,7 @@ async function runDaemon2() {
       }
       relay.close();
     } catch {}
-    if (existsSync10(QUEUE_DIR3)) {}
+    if (existsSync14(QUEUE_DIR3)) {}
     await new Promise((r) => setTimeout(r, reconnectDelay));
     reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS2);
   }
@@ -5823,19 +6797,19 @@ var init_daemon2 = __esm(() => {
   init_token_store();
   init_pid();
   init_queue();
-  QUEUE_DIR3 = join18(homedir17(), ".failproofai", "cache", "server-queue");
+  QUEUE_DIR3 = join22(homedir21(), ".failproofai", "cache", "server-queue");
 });
 
 // src/hooks/integrations.ts
 import { execSync as execSync3 } from "node:child_process";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync11, mkdirSync as mkdirSync8, unlinkSync as unlinkSync5 } from "node:fs";
-import { resolve as resolve6, dirname as dirname5 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, existsSync as existsSync15, mkdirSync as mkdirSync8, unlinkSync as unlinkSync5 } from "node:fs";
+import { resolve as resolve10, dirname as dirname5 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { homedir as homedir18 } from "node:os";
+import { homedir as homedir22 } from "node:os";
 function readJsonFile(path2) {
-  if (!existsSync11(path2))
+  if (!existsSync15(path2))
     return {};
-  const raw = readFileSync8(path2, "utf8");
+  const raw = readFileSync12(path2, "utf8");
   return JSON.parse(raw);
 }
 function writeJsonFile(path2, data) {
@@ -5873,7 +6847,7 @@ function isMarkedCopilotHook(hook) {
   return false;
 }
 function opencodePluginFilePath(settingsPath) {
-  return resolve6(dirname5(settingsPath), "plugins", "failproofai.mjs");
+  return resolve10(dirname5(settingsPath), "plugins", "failproofai.mjs");
 }
 function buildOpenCodePluginShim(binaryPath, scope) {
   const useNpx = scope === "project";
@@ -5906,10 +6880,12 @@ const TOOL_NAME_MAP = {
   read: "Read",
   write: "Write",
   edit: "Edit",
+  apply_patch: "Edit",
   glob: "Glob",
   grep: "Grep",
   list: "LS",
   webfetch: "WebFetch",
+  websearch: "WebSearch",
   todowrite: "TodoWrite",
   todoread: "TodoRead",
 };
@@ -6053,8 +7029,8 @@ export default async function failproofaiPlugin({ client, directory }) {
 function getPiExtensionPath() {
   const fromEnv = process.env.FAILPROOFAI_PACKAGE_ROOT;
   if (fromEnv)
-    return resolve6(fromEnv, "pi-extension");
-  return resolve6(fileURLToPath(import.meta.url), "..", "..", "..", "pi-extension");
+    return resolve10(fromEnv, "pi-extension");
+  return resolve10(fileURLToPath(import.meta.url), "..", "..", "..", "pi-extension");
 }
 function isFailproofaiPiEntry(source) {
   if (typeof source !== "string")
@@ -6065,8 +7041,8 @@ function isFailproofaiPiEntry(source) {
 }
 function makePiProjectRelativeEntry(extPath) {
   const cwd = process.cwd();
-  const cwdResolved = resolve6(cwd);
-  const extResolved = resolve6(extPath);
+  const cwdResolved = resolve10(cwd);
+  const extResolved = resolve10(extPath);
   if (extResolved.startsWith(cwdResolved + "/") || extResolved === cwdResolved) {
     const fromSettingsDir = "../" + extResolved.slice(cwdResolved.length + 1);
     return fromSettingsDir;
@@ -6092,14 +7068,14 @@ var init_integrations = __esm(() => {
     scopes: HOOK_SCOPES,
     eventTypes: HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve6(cwd) : process.cwd();
+      const base = cwd ? resolve10(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir18(), ".claude", "settings.json");
+          return resolve10(homedir22(), ".claude", "settings.json");
         case "project":
-          return resolve6(base, ".claude", "settings.json");
+          return resolve10(base, ".claude", "settings.json");
         case "local":
-          return resolve6(base, ".claude", "settings.local.json");
+          return resolve10(base, ".claude", "settings.local.json");
       }
     },
     readSettings(settingsPath) {
@@ -6171,7 +7147,7 @@ var init_integrations = __esm(() => {
     },
     hooksInstalledInSettings(scope, cwd) {
       const settingsPath = this.getSettingsPath(scope, cwd);
-      if (!existsSync11(settingsPath))
+      if (!existsSync15(settingsPath))
         return false;
       try {
         const settings = this.readSettings(settingsPath);
@@ -6200,14 +7176,14 @@ var init_integrations = __esm(() => {
     scopes: CODEX_HOOK_SCOPES,
     eventTypes: CODEX_HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve6(cwd) : process.cwd();
+      const base = cwd ? resolve10(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir18(), ".codex", "hooks.json");
+          return resolve10(homedir22(), ".codex", "hooks.json");
         case "project":
-          return resolve6(base, ".codex", "hooks.json");
+          return resolve10(base, ".codex", "hooks.json");
         case "local":
-          return resolve6(base, ".codex", "hooks.json");
+          return resolve10(base, ".codex", "hooks.json");
       }
     },
     readSettings(settingsPath) {
@@ -6285,7 +7261,7 @@ var init_integrations = __esm(() => {
     },
     hooksInstalledInSettings(scope, cwd) {
       const settingsPath = this.getSettingsPath(scope, cwd);
-      if (!existsSync11(settingsPath))
+      if (!existsSync15(settingsPath))
         return false;
       try {
         const settings = this.readSettings(settingsPath);
@@ -6314,14 +7290,14 @@ var init_integrations = __esm(() => {
     scopes: COPILOT_HOOK_SCOPES,
     eventTypes: COPILOT_HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve6(cwd) : process.cwd();
+      const base = cwd ? resolve10(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir18(), ".copilot", "hooks", "failproofai.json");
+          return resolve10(homedir22(), ".copilot", "hooks", "failproofai.json");
         case "project":
-          return resolve6(base, ".github", "hooks", "failproofai.json");
+          return resolve10(base, ".github", "hooks", "failproofai.json");
         case "local":
-          return resolve6(base, ".github", "hooks", "failproofai.json");
+          return resolve10(base, ".github", "hooks", "failproofai.json");
       }
     },
     readSettings(settingsPath) {
@@ -6399,7 +7375,7 @@ var init_integrations = __esm(() => {
     },
     hooksInstalledInSettings(scope, cwd) {
       const settingsPath = this.getSettingsPath(scope, cwd);
-      if (!existsSync11(settingsPath))
+      if (!existsSync15(settingsPath))
         return false;
       try {
         const settings = this.readSettings(settingsPath);
@@ -6428,14 +7404,14 @@ var init_integrations = __esm(() => {
     scopes: CURSOR_HOOK_SCOPES,
     eventTypes: CURSOR_HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve6(cwd) : process.cwd();
+      const base = cwd ? resolve10(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir18(), ".cursor", "hooks.json");
+          return resolve10(homedir22(), ".cursor", "hooks.json");
         case "project":
-          return resolve6(base, ".cursor", "hooks.json");
+          return resolve10(base, ".cursor", "hooks.json");
         case "local":
-          return resolve6(base, ".cursor", "hooks.json");
+          return resolve10(base, ".cursor", "hooks.json");
       }
     },
     readSettings(settingsPath) {
@@ -6502,7 +7478,7 @@ var init_integrations = __esm(() => {
     },
     hooksInstalledInSettings(scope, cwd) {
       const settingsPath = this.getSettingsPath(scope, cwd);
-      if (!existsSync11(settingsPath))
+      if (!existsSync15(settingsPath))
         return false;
       try {
         const settings = this.readSettings(settingsPath);
@@ -6527,14 +7503,14 @@ var init_integrations = __esm(() => {
     scopes: OPENCODE_HOOK_SCOPES,
     eventTypes: OPENCODE_HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve6(cwd) : process.cwd();
+      const base = cwd ? resolve10(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir18(), ".config", "opencode", "opencode.json");
+          return resolve10(homedir22(), ".config", "opencode", "opencode.json");
         case "project":
-          return resolve6(base, ".opencode", "opencode.json");
+          return resolve10(base, ".opencode", "opencode.json");
         case "local":
-          return resolve6(base, ".opencode", "opencode.json");
+          return resolve10(base, ".opencode", "opencode.json");
       }
     },
     readSettings(settingsPath) {
@@ -6545,7 +7521,7 @@ var init_integrations = __esm(() => {
     },
     buildHookEntry(_binaryPath, _eventType, scope) {
       if (scope === "user") {
-        const abs = resolve6(homedir18(), ".config", "opencode", "plugins", "failproofai.mjs");
+        const abs = resolve10(homedir22(), ".config", "opencode", "plugins", "failproofai.mjs");
         return { spec: `file://${abs}`, [FAILPROOFAI_HOOK_MARKER]: true };
       }
       return { spec: OPENCODE_PLUGIN_REL_PATH, [FAILPROOFAI_HOOK_MARKER]: true };
@@ -6560,7 +7536,7 @@ var init_integrations = __esm(() => {
     writeHookEntries(settings, binaryPath, scope) {
       const s = settings;
       const effectiveScope = scope ?? "project";
-      const settingsPath = effectiveScope === "user" ? resolve6(homedir18(), ".config", "opencode", "opencode.json") : resolve6(process.cwd(), ".opencode", "opencode.json");
+      const settingsPath = effectiveScope === "user" ? resolve10(homedir22(), ".config", "opencode", "opencode.json") : resolve10(process.cwd(), ".opencode", "opencode.json");
       const pluginPath = opencodePluginFilePath(settingsPath);
       mkdirSync8(dirname5(pluginPath), { recursive: true });
       writeFileSync6(pluginPath, buildOpenCodePluginShim(binaryPath, effectiveScope), "utf8");
@@ -6586,9 +7562,9 @@ var init_integrations = __esm(() => {
       }
       this.writeSettings(settingsPath, settings);
       const pluginPath = opencodePluginFilePath(settingsPath);
-      if (existsSync11(pluginPath)) {
+      if (existsSync15(pluginPath)) {
         try {
-          const content = readFileSync8(pluginPath, "utf8");
+          const content = readFileSync12(pluginPath, "utf8");
           if (content.includes(FAILPROOFAI_HOOK_MARKER)) {
             unlinkSync5(pluginPath);
             if (removed === 0)
@@ -6600,7 +7576,7 @@ var init_integrations = __esm(() => {
     },
     hooksInstalledInSettings(scope, cwd) {
       const settingsPath = this.getSettingsPath(scope, cwd);
-      if (!existsSync11(settingsPath))
+      if (!existsSync15(settingsPath))
         return false;
       try {
         const settings = this.readSettings(settingsPath);
@@ -6610,9 +7586,9 @@ var init_integrations = __esm(() => {
         if (!hasEntry)
           return false;
         const pluginPath = opencodePluginFilePath(settingsPath);
-        if (!existsSync11(pluginPath))
+        if (!existsSync15(pluginPath))
           return false;
-        const content = readFileSync8(pluginPath, "utf8");
+        const content = readFileSync12(pluginPath, "utf8");
         return content.includes(FAILPROOFAI_HOOK_MARKER);
       } catch {
         return false;
@@ -6628,14 +7604,14 @@ var init_integrations = __esm(() => {
     scopes: PI_HOOK_SCOPES,
     eventTypes: PI_HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve6(cwd) : process.cwd();
+      const base = cwd ? resolve10(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir18(), ".pi", "agent", "settings.json");
+          return resolve10(homedir22(), ".pi", "agent", "settings.json");
         case "project":
-          return resolve6(base, ".pi", "settings.json");
+          return resolve10(base, ".pi", "settings.json");
         case "local":
-          return resolve6(base, ".pi", "settings.json");
+          return resolve10(base, ".pi", "settings.json");
       }
     },
     readSettings(settingsPath) {
@@ -6677,7 +7653,7 @@ var init_integrations = __esm(() => {
       }
     },
     removeHooksFromFile(settingsPath) {
-      if (!existsSync11(settingsPath))
+      if (!existsSync15(settingsPath))
         return 0;
       const settings = this.readSettings(settingsPath);
       if (!Array.isArray(settings.packages))
@@ -6692,7 +7668,7 @@ var init_integrations = __esm(() => {
     },
     hooksInstalledInSettings(scope, cwd) {
       const settingsPath = this.getSettingsPath(scope, cwd);
-      if (!existsSync11(settingsPath))
+      if (!existsSync15(settingsPath))
         return false;
       try {
         const settings = this.readSettings(settingsPath);
@@ -6713,14 +7689,14 @@ var init_integrations = __esm(() => {
     scopes: GEMINI_HOOK_SCOPES,
     eventTypes: GEMINI_HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve6(cwd) : process.cwd();
+      const base = cwd ? resolve10(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir18(), ".gemini", "settings.json");
+          return resolve10(homedir22(), ".gemini", "settings.json");
         case "project":
-          return resolve6(base, ".gemini", "settings.json");
+          return resolve10(base, ".gemini", "settings.json");
         case "local":
-          return resolve6(base, ".gemini", "settings.json");
+          return resolve10(base, ".gemini", "settings.json");
       }
     },
     readSettings(settingsPath) {
@@ -6792,7 +7768,7 @@ var init_integrations = __esm(() => {
     },
     hooksInstalledInSettings(scope, cwd) {
       const settingsPath = this.getSettingsPath(scope, cwd);
-      if (!existsSync11(settingsPath))
+      if (!existsSync15(settingsPath))
         return false;
       try {
         const settings = this.readSettings(settingsPath);
@@ -7014,7 +7990,7 @@ async function promptPolicySelection(preSelected, options = {}) {
     process.stdout.write(output);
     lastLineCount = lines.length;
   }
-  return new Promise((resolve7) => {
+  return new Promise((resolve11) => {
     render();
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -7056,7 +8032,7 @@ async function promptPolicySelection(preSelected, options = {}) {
         const selected = items.filter((i) => i.selected).map((i) => i.name);
         process.stdout.write(`
 `);
-        resolve7(selected);
+        resolve11(selected);
       } else if (key.name === "backspace" || key.name === "delete") {
         if (search.length > 0) {
           search = search.slice(0, -1);
@@ -7106,9 +8082,9 @@ __export(exports_manager, {
   getSettingsPath: () => getSettingsPath
 });
 import { execSync as execSync4 } from "node:child_process";
-import { existsSync as existsSync12 } from "node:fs";
-import { resolve as resolve7, basename as basename3 } from "node:path";
-import { homedir as homedir19, platform, arch, release, hostname } from "node:os";
+import { existsSync as existsSync16 } from "node:fs";
+import { resolve as resolve11, basename as basename4 } from "node:path";
+import { homedir as homedir23, platform, arch, release, hostname } from "node:os";
 function getSettingsPath(scope, cwd) {
   return claudeCode.getSettingsPath(scope, cwd);
 }
@@ -7194,7 +8170,7 @@ async function installHooks(policyNames, scope = "user", cwd, includeBeta = fals
   if (removeCustomHooks) {
     delete configToWrite.customPoliciesPath;
   } else if (customPoliciesPath) {
-    configToWrite.customPoliciesPath = resolve7(customPoliciesPath);
+    configToWrite.customPoliciesPath = resolve11(customPoliciesPath);
     let validatedHooks = [];
     try {
       validatedHooks = await loadCustomHooks(configToWrite.customPoliciesPath, { strict: true });
@@ -7329,7 +8305,7 @@ async function removeHooks(policyNames, scope = "user", cwd, opts) {
     const scopesToRemove = scope === "all" ? [...integration.scopes] : integration.scopes.includes(scope) ? [scope] : [];
     for (const s of scopesToRemove) {
       const settingsPath = integration.getSettingsPath(s, cwd);
-      if (!existsSync12(settingsPath)) {
+      if (!existsSync16(settingsPath)) {
         if (scope !== "all" && selectedClis.length === 1) {
           console.log("No settings file found. Nothing to remove.");
           nothingToReport = true;
@@ -7508,7 +8484,7 @@ Failproof AI Hook Policies
   if (config.customPoliciesPath) {
     console.log(`
   ── Custom Policies (${config.customPoliciesPath}) ───────────────────────`);
-    if (!existsSync12(config.customPoliciesPath)) {
+    if (!existsSync16(config.customPoliciesPath)) {
       console.log(`  \x1B[31m✗ File not found: ${config.customPoliciesPath}\x1B[0m`);
     } else {
       const hooks = await loadCustomHooks(config.customPoliciesPath);
@@ -7523,10 +8499,10 @@ Failproof AI Hook Policies
     }
     console.log();
   }
-  const base = cwd ? resolve7(cwd) : process.cwd();
+  const base = cwd ? resolve11(cwd) : process.cwd();
   const conventionDirs = [
-    { label: "Project", dir: resolve7(base, ".failproofai", "policies") },
-    { label: "User", dir: resolve7(homedir19(), ".failproofai", "policies") }
+    { label: "Project", dir: resolve11(base, ".failproofai", "policies") },
+    { label: "User", dir: resolve11(homedir23(), ".failproofai", "policies") }
   ];
   for (const { label, dir } of conventionDirs) {
     const files = discoverPolicyFiles(dir);
@@ -7538,15 +8514,15 @@ Failproof AI Hook Policies
       try {
         const hooks = await loadCustomHooks(file);
         if (hooks.length === 0) {
-          const filename = basename3(file);
+          const filename = basename4(file);
           console.log(`  \x1B[31m✗\x1B[0m       ${filename.padEnd(nameColWidth)}\x1B[31mfailed to load\x1B[0m`);
         } else {
-          const filename = basename3(file);
+          const filename = basename4(file);
           const hookSummary = hooks.map((h) => h.name).join(", ");
           console.log(`  \x1B[32m✓\x1B[0m       ${filename.padEnd(nameColWidth)}${hooks.length} hook(s): ${hookSummary}`);
         }
       } catch {
-        const filename = basename3(file);
+        const filename = basename4(file);
         console.log(`  \x1B[31m✗\x1B[0m       ${filename.padEnd(nameColWidth)}\x1B[31merror\x1B[0m`);
       }
     }
@@ -7675,7 +8651,7 @@ async function promptCliTargetSelection(detected, action = "install") {
     process.stdout.write(output);
     lastLineCount = lines.length;
   }
-  return new Promise((resolve8) => {
+  return new Promise((resolve12) => {
     render();
     readline2.emitKeypressEvents(process.stdin);
     const wasRaw = process.stdin.isRaw;
@@ -7708,7 +8684,7 @@ async function promptCliTargetSelection(detected, action = "install") {
         cleanup();
         process.stdout.write(`
 `);
-        resolve8(options[cursor2].value);
+        resolve12(options[cursor2].value);
       }
     }
     process.stdin.on("keypress", onKey);
@@ -7900,7 +8876,7 @@ async function promptPolicySelection2(preSelected, options = {}) {
     process.stdout.write(output);
     lastLineCount = lines.length;
   }
-  return new Promise((resolve8) => {
+  return new Promise((resolve12) => {
     render();
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -7942,7 +8918,7 @@ async function promptPolicySelection2(preSelected, options = {}) {
         const selected = items.filter((i) => i.selected).map((i) => i.name);
         process.stdout.write(`
 `);
-        resolve8(selected);
+        resolve12(selected);
       } else if (key.name === "backspace" || key.name === "delete") {
         if (search.length > 0) {
           search = search.slice(0, -1);
@@ -8104,14 +9080,14 @@ __export(exports_pid, {
   isProcessAlive: () => isProcessAlive2,
   clearPid: () => clearPid2
 });
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync13, unlinkSync as unlinkSync6, mkdirSync as mkdirSync9 } from "node:fs";
-import { join as join19, dirname as dirname6 } from "node:path";
-import { homedir as homedir20 } from "node:os";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, existsSync as existsSync17, unlinkSync as unlinkSync6, mkdirSync as mkdirSync9 } from "node:fs";
+import { join as join23, dirname as dirname6 } from "node:path";
+import { homedir as homedir24 } from "node:os";
 function readPid2() {
-  if (!existsSync13(PID_FILE2))
+  if (!existsSync17(PID_FILE2))
     return null;
   try {
-    const raw = readFileSync9(PID_FILE2, "utf8").trim();
+    const raw = readFileSync13(PID_FILE2, "utf8").trim();
     const pid = parseInt(raw, 10);
     if (Number.isNaN(pid) || pid <= 0)
       return null;
@@ -8122,12 +9098,12 @@ function readPid2() {
 }
 function writePid2(pid) {
   const dir = dirname6(PID_FILE2);
-  if (!existsSync13(dir))
+  if (!existsSync17(dir))
     mkdirSync9(dir, { recursive: true, mode: 448 });
   writeFileSync7(PID_FILE2, String(pid));
 }
 function clearPid2() {
-  if (existsSync13(PID_FILE2))
+  if (existsSync17(PID_FILE2))
     unlinkSync6(PID_FILE2);
 }
 function isProcessAlive2(pid) {
@@ -8165,18 +9141,18 @@ function relayStatus() {
 }
 var PID_FILE2;
 var init_pid2 = __esm(() => {
-  PID_FILE2 = join19(homedir20(), ".failproofai", "relay.pid");
+  PID_FILE2 = join23(homedir24(), ".failproofai", "relay.pid");
 });
 
 // scripts/parse-script-args.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve12 } from "path";
 function parseStringFlag(flagName, errorLabel, inlineValue, args, index, options) {
   const raw = inlineValue ?? args[index + 1];
   if (raw === undefined || inlineValue === null && raw.startsWith("-")) {
     console.error(`Error: ${flagName} requires ${errorLabel}`);
     process.exit(1);
   }
-  const value = options?.resolve ? resolve8(raw) : raw;
+  const value = options?.resolve ? resolve12(raw) : raw;
   return { value, spliceCount: inlineValue !== null ? 1 : 2 };
 }
 function parseScriptArgs(argv) {
@@ -8232,21 +9208,21 @@ function parseScriptArgs(argv) {
 var init_parse_script_args = () => {};
 
 // scripts/install-diagnosis.mjs
-import { existsSync as existsSync14, readFileSync as readFileSync10, realpathSync } from "node:fs";
-import { dirname as dirname7, resolve as resolve9 } from "node:path";
-import { homedir as homedir21, platform as platform3 } from "node:os";
+import { existsSync as existsSync18, readFileSync as readFileSync14, realpathSync } from "node:fs";
+import { dirname as dirname7, resolve as resolve13 } from "node:path";
+import { homedir as homedir25, platform as platform3 } from "node:os";
 import { spawnSync } from "node:child_process";
 function findPackageRoot(start) {
   try {
     let dir = realpathSync(start);
-    if (existsSync14(dir) && !existsSync14(resolve9(dir, "package.json"))) {
+    if (existsSync18(dir) && !existsSync18(resolve13(dir, "package.json"))) {
       dir = dirname7(dir);
     }
     while (true) {
-      const pkgPath = resolve9(dir, "package.json");
-      if (existsSync14(pkgPath)) {
+      const pkgPath = resolve13(dir, "package.json");
+      if (existsSync18(pkgPath)) {
         try {
-          const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
+          const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
           if (pkg.name === PKG_NAME)
             return dir;
         } catch {}
@@ -8264,7 +9240,7 @@ function readPackageVersion(packageRoot) {
   if (!packageRoot)
     return null;
   try {
-    const pkg = JSON.parse(readFileSync10(resolve9(packageRoot, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync14(resolve13(packageRoot, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -8290,16 +9266,16 @@ function locateNpmGlobal() {
     const root = (res.stdout || "").trim();
     if (!root)
       return null;
-    const candidate = resolve9(root, PKG_NAME);
-    return existsSync14(resolve9(candidate, "package.json")) ? candidate : null;
+    const candidate = resolve13(root, PKG_NAME);
+    return existsSync18(resolve13(candidate, "package.json")) ? candidate : null;
   } catch {
     return null;
   }
 }
 function locateBunGlobal() {
   try {
-    const candidate = resolve9(homedir21(), ".bun", "install", "global", "node_modules", PKG_NAME);
-    return existsSync14(resolve9(candidate, "package.json")) ? candidate : null;
+    const candidate = resolve13(homedir25(), ".bun", "install", "global", "node_modules", PKG_NAME);
+    return existsSync18(resolve13(candidate, "package.json")) ? candidate : null;
   } catch {
     return null;
   }
@@ -8307,8 +9283,8 @@ function locateBunGlobal() {
 function buildRecommendation(pathFirstBin) {
   if (!pathFirstBin)
     return null;
-  const bunBinPrefix = resolve9(homedir21(), ".bun", "bin") + "/";
-  const bunGlobalPrefix = resolve9(homedir21(), ".bun", "install", "global") + "/";
+  const bunBinPrefix = resolve13(homedir25(), ".bun", "bin") + "/";
+  const bunGlobalPrefix = resolve13(homedir25(), ".bun", "install", "global") + "/";
   const isBun = pathFirstBin.startsWith(bunBinPrefix) || pathFirstBin.startsWith(bunGlobalPrefix);
   if (isBun) {
     return `rm -f ~/.bun/bin/${PKG_NAME} && rm -rf ~/.bun/install/global/node_modules/${PKG_NAME}`;
@@ -8369,8 +9345,8 @@ __export(exports_launch, {
   launch: () => launch
 });
 import { spawn as spawn4 } from "child_process";
-import { realpathSync as realpathSync2, existsSync as existsSync15 } from "node:fs";
-import { resolve as resolve10, dirname as dirname8 } from "node:path";
+import { realpathSync as realpathSync2, existsSync as existsSync19 } from "node:fs";
+import { resolve as resolve14, dirname as dirname8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function launch(mode) {
   const { claudeProjectsPath: parsedPath, loggingLevel, disableTelemetry, allowedDevOrigins, remainingArgs } = parseScriptArgs(process.argv.slice(2));
@@ -8402,9 +9378,9 @@ function launch(mode) {
     process.env.PORT = port;
     process.env.HOSTNAME = "0.0.0.0";
     cmd = "node";
-    const packageRoot = process.env.FAILPROOFAI_PACKAGE_ROOT ?? resolve10(dirname8(realpathSync2(fileURLToPath2(import.meta.url))), "..");
-    const serverJsPath = resolve10(packageRoot, ".next/standalone/server.js");
-    if (!existsSync15(serverJsPath)) {
+    const packageRoot = process.env.FAILPROOFAI_PACKAGE_ROOT ?? resolve14(dirname8(realpathSync2(fileURLToPath2(import.meta.url))), "..");
+    const serverJsPath = resolve14(packageRoot, ".next/standalone/server.js");
+    if (!existsSync19(serverJsPath)) {
       let shadowMessage = null;
       try {
         const diag = diagnoseShadow({ selfPackageRoot: packageRoot, selfVersion: version2 });
@@ -8481,17 +9457,17 @@ var init_cli_error2 = __esm(() => {
 
 // bin/failproofai.mjs
 import { realpathSync as realpathSync3 } from "fs";
-import { dirname as dirname9, resolve as resolve11 } from "path";
+import { dirname as dirname9, resolve as resolve15 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 // package.json
-var version = "0.0.10-beta.2";
+var version = "0.0.10-beta.4";
 
 // bin/failproofai.mjs
 if (!process.env.FAILPROOFAI_PACKAGE_ROOT) {
-  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve11(dirname9(realpathSync3(fileURLToPath3(import.meta.url))), "..");
+  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve15(dirname9(realpathSync3(fileURLToPath3(import.meta.url))), "..");
 }
 if (!process.env.FAILPROOFAI_DIST_PATH) {
-  process.env.FAILPROOFAI_DIST_PATH = resolve11(dirname9(realpathSync3(fileURLToPath3(import.meta.url))), "..", "dist");
+  process.env.FAILPROOFAI_DIST_PATH = resolve15(dirname9(realpathSync3(fileURLToPath3(import.meta.url))), "..", "dist");
 }
 var args = process.argv.slice(2);
 if (args[0] === "p")