failproofai 0.0.9 → 0.0.10-beta.1

package/dist/cli.mjs

@@ -16,10 +16,10 @@ 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, HOOK_EVENT_TYPES, FAILPROOFAI_HOOK_MARKER = "__failproofai_hook__";
+var HOOK_SCOPES, INTEGRATION_TYPES, CODEX_HOOK_SCOPES, CODEX_HOOK_EVENT_TYPES, CODEX_EVENT_MAP, COPILOT_HOOK_SCOPES, COPILOT_HOOK_EVENT_TYPES, 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 init_types = __esm(() => {
   HOOK_SCOPES = ["user", "project", "local"];
-  INTEGRATION_TYPES = ["claude", "codex"];
+  INTEGRATION_TYPES = ["claude", "codex", "copilot", "cursor", "opencode", "pi", "gemini"];
   CODEX_HOOK_SCOPES = ["user", "project"];
   CODEX_HOOK_EVENT_TYPES = [
     "session_start",
@@ -37,6 +37,103 @@ var init_types = __esm(() => {
     user_prompt_submit: "UserPromptSubmit",
     stop: "Stop"
   };
+  COPILOT_HOOK_SCOPES = ["user", "project"];
+  COPILOT_HOOK_EVENT_TYPES = [
+    "SessionStart",
+    "SessionEnd",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PostToolUse",
+    "Stop"
+  ];
+  CURSOR_HOOK_SCOPES = ["user", "project"];
+  CURSOR_HOOK_EVENT_TYPES = [
+    "sessionStart",
+    "sessionEnd",
+    "beforeSubmitPrompt",
+    "preToolUse",
+    "postToolUse",
+    "stop"
+  ];
+  CURSOR_EVENT_MAP = {
+    sessionStart: "SessionStart",
+    sessionEnd: "SessionEnd",
+    beforeSubmitPrompt: "UserPromptSubmit",
+    preToolUse: "PreToolUse",
+    postToolUse: "PostToolUse",
+    stop: "Stop"
+  };
+  OPENCODE_HOOK_SCOPES = ["user", "project"];
+  OPENCODE_HOOK_EVENT_TYPES = [
+    "tool.execute.before",
+    "tool.execute.after",
+    "session.created",
+    "session.deleted",
+    "session.idle",
+    "message.updated",
+    "permission.ask"
+  ];
+  PI_HOOK_SCOPES = ["user", "project"];
+  PI_HOOK_EVENT_TYPES = [
+    "session_start",
+    "session_shutdown",
+    "input",
+    "tool_call",
+    "user_bash",
+    "tool_result",
+    "agent_end"
+  ];
+  PI_EVENT_MAP = {
+    session_start: "SessionStart",
+    session_shutdown: "SessionEnd",
+    input: "UserPromptSubmit",
+    tool_call: "PreToolUse",
+    user_bash: "PreToolUse",
+    tool_result: "PostToolUse",
+    agent_end: "Stop"
+  };
+  GEMINI_HOOK_SCOPES = ["user", "project"];
+  GEMINI_HOOK_EVENT_TYPES = [
+    "SessionStart",
+    "SessionEnd",
+    "BeforeAgent",
+    "AfterAgent",
+    "BeforeModel",
+    "AfterModel",
+    "BeforeToolSelection",
+    "BeforeTool",
+    "AfterTool",
+    "PreCompress",
+    "Notification"
+  ];
+  GEMINI_EVENT_MAP = {
+    SessionStart: "SessionStart",
+    SessionEnd: "SessionEnd",
+    BeforeAgent: "UserPromptSubmit",
+    AfterAgent: "Stop",
+    BeforeTool: "PreToolUse",
+    AfterTool: "PostToolUse",
+    PreCompress: "PreCompact",
+    Notification: "Notification",
+    BeforeModel: "BeforeModel",
+    AfterModel: "AfterModel",
+    BeforeToolSelection: "BeforeToolSelection"
+  };
+  GEMINI_TOOL_MAP = {
+    run_shell_command: "Bash",
+    read_file: "Read",
+    read_many_files: "Read",
+    write_file: "Write",
+    replace: "Edit",
+    glob: "Glob",
+    grep_search: "Grep",
+    list_directory: "LS",
+    web_fetch: "WebFetch",
+    google_web_search: "WebSearch",
+    write_todos: "TodoWrite",
+    save_memory: "Memory",
+    ask_user: "AskUser"
+  };
   HOOK_EVENT_TYPES = [
     "SessionStart",
     "SessionEnd",
@@ -332,9 +429,15 @@ import { readFile, writeFile } from "node:fs/promises";
 import { execSync, execFileSync } from "node:child_process";
 import { homedir as homedir3 } from "node:os";
 function isAgentInternalPath(resolved2) {
-  for (const dir of [".claude", ".codex"]) {
-    const root = join2(homedir3(), dir);
-    if (resolved2 === root || resolved2.startsWith(root + "/"))
+  const normResolved = resolved2.replaceAll("\\", "/");
+  for (const dir of [".claude", ".codex", ".copilot", ".cursor", ".opencode", ".pi", ".gemini"]) {
+    const root = join2(homedir3(), dir).replaceAll("\\", "/");
+    if (normResolved === root || normResolved.startsWith(root + "/"))
+      return true;
+  }
+  for (const sub of [join2(".config", "opencode"), join2(".local", "share", "opencode")]) {
+    const root = join2(homedir3(), sub).replaceAll("\\", "/");
+    if (normResolved === root || normResolved.startsWith(root + "/"))
       return true;
   }
   return false;
@@ -344,6 +447,30 @@ function isAgentSettingsFile(resolved2) {
     return true;
   if (/[\\/]\.codex[\\/]hooks\.json$/.test(resolved2))
     return true;
+  if (/[\\/]\.copilot[\\/]hooks[\\/][^/\\]+\.json$/.test(resolved2))
+    return true;
+  if (/[\\/]\.github[\\/]hooks[\\/][^/\\]+\.json$/.test(resolved2))
+    return true;
+  if (/[\\/]\.cursor[\\/]hooks\.json$/.test(resolved2))
+    return true;
+  if (/[\\/]\.opencode[\\/]opencode\.jsonc?$/.test(resolved2))
+    return true;
+  if (/[\\/]\.opencode[\\/]plugins[\\/][^/\\]+\.(?:mjs|js|ts)$/.test(resolved2))
+    return true;
+  if (/[\\/]\.config[\\/]opencode[\\/]opencode\.jsonc?$/.test(resolved2))
+    return true;
+  if (/[\\/]\.config[\\/]opencode[\\/]config\.json$/.test(resolved2))
+    return true;
+  if (/[\\/]\.config[\\/]opencode[\\/]plugins[\\/][^/\\]+\.(?:mjs|js|ts)$/.test(resolved2))
+    return true;
+  if (/[\\/]\.pi[\\/](?:agent[\\/])?settings\.json$/.test(resolved2))
+    return true;
+  if (/[\\/]\.pi[\\/](?:agent[\\/])?extensions[\\/]/.test(resolved2))
+    return true;
+  if (/[\\/]\.gemini[\\/]settings\.json$/.test(resolved2))
+    return true;
+  if (/[\\/]\.gemini[\\/]hooks[\\/]/.test(resolved2))
+    return true;
   return false;
 }
 function getCommand(ctx) {
@@ -780,7 +907,7 @@ function blockReadOutsideCwd(ctx) {
     for (const p of paths) {
       const resolved3 = resolve2(cwd, p);
       if (isClaudeSettingsFile(resolved3)) {
-        return deny(`Reading Claude settings file blocked: ${resolved3}`);
+        return deny(`Reading agent settings file blocked: ${resolved3}`);
       }
       if (isClaudeInternalPath(resolved3))
         continue;
@@ -801,7 +928,7 @@ function blockReadOutsideCwd(ctx) {
     return allow();
   const resolved2 = resolve2(cwd, target);
   if (isClaudeSettingsFile(resolved2)) {
-    return deny(`Reading Claude settings file blocked: ${resolved2}`);
+    return deny(`Reading agent settings file blocked: ${resolved2}`);
   }
   if (isClaudeInternalPath(resolved2))
     return allow();
@@ -1228,16 +1355,24 @@ function requireCiGreenBeforeStop(ctx) {
     const branch = getCurrentBranch(cwd);
     if (!branch || branch === "HEAD")
       return allow("Detached HEAD, skipping CI check.");
+    const sha = getHeadSha(cwd);
     let workflowRuns = [];
     try {
-      const runsJson = execFileSync("gh", ["run", "list", "--branch", branch, "--limit", "5", "--json", "status,conclusion,name"], { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 15000 }).trim();
+      const runsJson = execFileSync("gh", ["run", "list", "--branch", branch, "--limit", "20", "--json", "status,conclusion,name,headSha"], { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 15000 }).trim();
       if (runsJson && runsJson !== "[]") {
-        workflowRuns = JSON.parse(runsJson);
+        const allWorkflowRuns = JSON.parse(runsJson);
+        const headRuns = sha ? allWorkflowRuns.filter((r) => r.headSha === sha) : allWorkflowRuns;
+        const seen = new Set;
+        workflowRuns = headRuns.filter((r) => {
+          if (seen.has(r.name))
+            return false;
+          seen.add(r.name);
+          return true;
+        });
       }
     } catch {}
     let thirdPartyChecks = [];
     let commitStatuses = [];
-    const sha = getHeadSha(cwd);
     if (sha) {
       thirdPartyChecks = getThirdPartyCheckRuns(cwd, sha);
       commitStatuses = getCommitStatuses(cwd, sha);
@@ -1803,7 +1938,7 @@ var init_builtin_policies = __esm(() => {
     },
     {
       name: "require-ci-green-before-stop",
-      description: "Require CI checks to pass on the current branch before Claude stops",
+      description: "Require CI checks to pass on the current HEAD commit before Claude stops (ignores stale runs on prior commits)",
       fn: requireCiGreenBeforeStop,
       match: { events: ["Stop"] },
       defaultEnabled: false,
@@ -1874,13 +2009,79 @@ async function evaluatePolicies(eventType, payload, session, config) {
     if (result.decision === "deny") {
       const reason = appendHint(result.reason ?? `Blocked by policy: ${policy.name}`, getConfigParamsFor(config, policy.name)?.hint);
       hookLogInfo(`deny by "${policy.name}": ${reason}`);
-      const displayTool = ctx.toolName ?? "unknown tool";
+      let displayTool;
+      if (ctx.toolName) {
+        displayTool = ctx.toolName;
+      } else if (eventType === "UserPromptSubmit") {
+        displayTool = "prompt";
+      } else if (eventType === "SessionStart") {
+        displayTool = "session start";
+      } else if (eventType === "SessionEnd") {
+        displayTool = "session end";
+      } else if (eventType === "Stop") {
+        displayTool = "stop";
+      } else {
+        displayTool = "operation";
+      }
+      const blockedMessage = `Blocked ${displayTool} by failproofai because: ${reason}, as per the policy configured by the user`;
+      if (session?.cli === "cursor") {
+        const response = {
+          permission: "deny",
+          user_message: blockedMessage,
+          agent_message: blockedMessage
+        };
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify(response),
+          stderr: "",
+          policyName: policy.name,
+          reason,
+          decision: "deny"
+        };
+      }
+      if (session?.cli === "pi") {
+        const response = {
+          permission: "deny",
+          reason: blockedMessage
+        };
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify(response),
+          stderr: "",
+          policyName: policy.name,
+          reason,
+          decision: "deny"
+        };
+      }
+      if (session?.cli === "gemini") {
+        if (eventType === "Stop") {
+          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.`;
+          return {
+            exitCode: 0,
+            stdout: JSON.stringify({ decision: "block", reason: reasonText }),
+            stderr: "",
+            policyName: policy.name,
+            reason,
+            decision: "deny"
+          };
+        }
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({ decision: "deny", reason: blockedMessage }),
+          stderr: "",
+          policyName: policy.name,
+          reason,
+          decision: "deny"
+        };
+      }
       if (eventType === "PreToolUse") {
         const response = {
           hookSpecificOutput: {
             hookEventName: eventType,
             permissionDecision: "deny",
-            permissionDecisionReason: `Blocked ${displayTool} by failproofai because: ${reason}, as per the policy configured by the user`
+            permissionDecisionReason: blockedMessage
           }
         };
         return {
@@ -1961,6 +2162,98 @@ You MUST complete the above action NOW. Do NOT ask the user for confirmation —
     const combined = instructEntries.map((e) => e.reason).join(`
 `);
     const policyNames = instructEntries.map((e) => e.policyName);
+    if (session?.cli === "cursor") {
+      if (eventType === "Stop") {
+        const response3 = {
+          followup_message: `Instruction from failproofai: ${combined}`
+        };
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify(response3),
+          stderr: "",
+          policyName: policyNames[0],
+          policyNames,
+          reason: combined,
+          decision: "instruct"
+        };
+      }
+      const response2 = {
+        permission: "allow",
+        additional_context: `Instruction from failproofai: ${combined}`
+      };
+      return {
+        exitCode: 0,
+        stdout: JSON.stringify(response2),
+        stderr: "",
+        policyName: policyNames[0],
+        policyNames,
+        reason: combined,
+        decision: "instruct"
+      };
+    }
+    if (session?.cli === "pi") {
+      const response2 = {
+        permission: "allow",
+        reason: `Instruction from failproofai: ${combined}`
+      };
+      return {
+        exitCode: 0,
+        stdout: JSON.stringify(response2),
+        stderr: "",
+        policyName: policyNames[0],
+        policyNames,
+        reason: combined,
+        decision: "instruct"
+      };
+    }
+    if (session?.cli === "gemini") {
+      if (eventType === "Stop") {
+        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.`;
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({ decision: "block", reason: reasonText }),
+          stderr: "",
+          policyName: policyNames[0],
+          policyNames,
+          reason: combined,
+          decision: "instruct"
+        };
+      }
+      const supportsContext = eventType === "UserPromptSubmit" || eventType === "PreToolUse" || eventType === "PostToolUse" || eventType === "SessionStart";
+      if (supportsContext) {
+        const hookEventName = session?.hookEventName ?? session?.rawHookEventName ?? eventType;
+        const response2 = {
+          hookSpecificOutput: {
+            hookEventName,
+            additionalContext: `Instruction from failproofai: ${combined}`
+          }
+        };
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify(response2),
+          stderr: "",
+          policyName: policyNames[0],
+          policyNames,
+          reason: combined,
+          decision: "instruct"
+        };
+      }
+      const stderrMsg = instructEntries.map((e) => `[failproofai] ${e.policyName}: ${e.reason}`).join(`
+`);
+      return {
+        exitCode: 0,
+        stdout: "",
+        stderr: stderrMsg + `
+`,
+        policyName: policyNames[0],
+        policyNames,
+        reason: combined,
+        decision: "instruct"
+      };
+    }
     if (eventType === "Stop") {
       const policyAttribution = policyNames.length === 1 ? `policy: ${policyNames[0]}` : `policies: ${policyNames.join(", ")}`;
       return {
@@ -1995,6 +2288,76 @@ You MUST complete the above action(s) NOW. Do NOT ask the user for confirmation
     const combined = allowEntries.map((e) => e.reason).join(`
 `);
     const policyNames = allowEntries.map((e) => e.policyName);
+    if (session?.cli === "cursor") {
+      const response2 = {
+        permission: "allow",
+        additional_context: `Note from failproofai: ${combined}`
+      };
+      const stderrMsg2 = allowEntries.map((e) => `[failproofai] ${e.policyName}: ${e.reason}`).join(`
+`);
+      return {
+        exitCode: 0,
+        stdout: JSON.stringify(response2),
+        stderr: stderrMsg2 + `
+`,
+        policyName: policyNames[0],
+        policyNames,
+        reason: combined,
+        decision: "allow"
+      };
+    }
+    if (session?.cli === "pi") {
+      const response2 = {
+        permission: "allow",
+        reason: `Note from failproofai: ${combined}`
+      };
+      const stderrMsg2 = allowEntries.map((e) => `[failproofai] ${e.policyName}: ${e.reason}`).join(`
+`);
+      return {
+        exitCode: 0,
+        stdout: JSON.stringify(response2),
+        stderr: stderrMsg2 + `
+`,
+        policyName: policyNames[0],
+        policyNames,
+        reason: combined,
+        decision: "allow"
+      };
+    }
+    if (session?.cli === "gemini") {
+      const supportsContext = eventType === "UserPromptSubmit" || eventType === "PreToolUse" || eventType === "PostToolUse" || eventType === "SessionStart";
+      const stderrMsg2 = allowEntries.map((e) => `[failproofai] ${e.policyName}: ${e.reason}`).join(`
+`);
+      if (supportsContext) {
+        const hookEventName = session?.hookEventName ?? session?.rawHookEventName ?? eventType;
+        const response2 = {
+          hookSpecificOutput: {
+            hookEventName,
+            additionalContext: `Note from failproofai: ${combined}`
+          }
+        };
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify(response2),
+          stderr: stderrMsg2 + `
+`,
+          policyName: policyNames[0],
+          policyNames,
+          reason: combined,
+          decision: "allow"
+        };
+      }
+      return {
+        exitCode: 0,
+        stdout: "",
+        stderr: stderrMsg2 + `
+`,
+        policyName: policyNames[0],
+        policyNames,
+        reason: combined,
+        decision: "allow"
+      };
+    }
     const supportsHookSpecificOutput = eventType === "PreToolUse" || eventType === "PostToolUse" || eventType === "UserPromptSubmit" || eventType === "PermissionRequest";
     const response = supportsHookSpecificOutput ? { hookSpecificOutput: { hookEventName: eventType, additionalContext: `Note from failproofai: ${combined}` } } : { reason: combined };
     const stderrMsg = allowEntries.map((e) => `[failproofai] ${e.policyName}: ${e.reason}`).join(`
@@ -2397,7 +2760,7 @@ var init_hook_activity_store = __esm(() => {
 });
 
 // package.json
-var version2 = "0.0.9";
+var version2 = "0.0.10-beta.1";
 var init_package = () => {};
 
 // src/posthog-key.ts
@@ -2465,6 +2828,12 @@ import { join as join4 } from "path";
 function getDefaultClaudeProjectsPath() {
   return join4(homedir6(), ".claude", "projects");
 }
+function decodeFolderName(name) {
+  if (/^[A-Za-z]--/.test(name)) {
+    return name[0] + ":/" + name.slice(3).replace(/-/g, "/");
+  }
+  return name.replace(/-/g, "/");
+}
 function encodeFolderName(path) {
   const driveMatch = /^([A-Za-z]):[\\/](.*)$/.exec(path);
   if (driveMatch) {
@@ -2550,9 +2919,9 @@ __export(exports_codex_projects, {
   getCachedCodexSessionsByEncodedName: () => getCachedCodexSessionsByEncodedName,
   getCachedCodexProjects: () => getCachedCodexProjects
 });
-import { open as open2, readdir } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { join as join5 } from "path";
+import { open as open2, readdir } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join5 } from "node:path";
 async function safeReaddir(dir) {
   try {
     return await readdir(dir, { withFileTypes: true });
@@ -2739,115 +3108,984 @@ var init_codex_projects = __esm(() => {
   getCachedCodexSessionsByEncodedName = runtimeCache((name) => getCodexSessionsByEncodedName(name), 30, { maxSize: 50 });
 });
 
-// lib/projects.ts
-import { readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join6, resolve as resolve5, sep } from "path";
-async function getMtime(path, label) {
+// lib/copilot-projects.ts
+var exports_copilot_projects = {};
+__export(exports_copilot_projects, {
+  getCopilotSessionsForCwd: () => getCopilotSessionsForCwd,
+  getCopilotSessionsByEncodedName: () => getCopilotSessionsByEncodedName,
+  getCopilotProjects: () => getCopilotProjects,
+  getCachedCopilotSessionsForCwd: () => getCachedCopilotSessionsForCwd,
+  getCachedCopilotSessionsByEncodedName: () => getCachedCopilotSessionsByEncodedName,
+  getCachedCopilotProjects: () => getCachedCopilotProjects
+});
+import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { join as join6 } from "node:path";
+function getCopilotSessionStateRoot() {
+  return join6(process.env.COPILOT_HOME || join6(homedir8(), ".copilot"), "session-state");
+}
+async function safeReaddir2(dir) {
   try {
-    return (await stat2(path)).mtime;
-  } catch (error) {
-    logWarn(`Failed to stat ${label}:`, error);
-    return new Date(0);
+    return await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return null;
   }
 }
-async function safeReaddir2(dirPath) {
+function parseCwdFromWorkspace(text) {
+  const m = text.match(/^cwd\s*:\s*(.+?)\s*$/m);
+  if (!m)
+    return;
+  return m[1].replace(/^['"]|['"]$/g, "");
+}
+async function statMtime(path) {
   try {
-    const s = await stat2(dirPath);
-    if (!s.isDirectory())
-      return null;
-    return await readdir2(dirPath, { withFileTypes: true });
+    return (await stat2(path)).mtime;
   } catch {
     return null;
   }
 }
-async function getClaudeProjectFolders() {
+async function scanCopilotSessions() {
+  const root = getCopilotSessionStateRoot();
+  const entries = await safeReaddir2(root);
+  if (!entries)
+    return [];
+  const candidates = entries.filter((e) => e.isDirectory()).map((e) => ({
+    sessionId: e.name,
+    workspacePath: join6(root, e.name, "workspace.yaml"),
+    eventsPath: join6(root, e.name, "events.jsonl")
+  }));
+  const settled = await batchAll(candidates.map((c) => async () => {
+    let workspaceText;
+    try {
+      workspaceText = await readFile3(c.workspacePath, "utf-8");
+    } catch {
+      return null;
+    }
+    const cwd = parseCwdFromWorkspace(workspaceText);
+    if (!cwd)
+      return null;
+    const eventsMtime = await statMtime(c.eventsPath);
+    const wsMtime = await statMtime(c.workspacePath);
+    const hasTranscript = eventsMtime !== null;
+    const fileMtime = eventsMtime && wsMtime ? new Date(Math.max(eventsMtime.getTime(), wsMtime.getTime())) : eventsMtime ?? wsMtime ?? new Date(0);
+    return {
+      workspacePath: c.workspacePath,
+      eventsPath: c.eventsPath,
+      sessionId: c.sessionId,
+      cwd,
+      fileMtime,
+      hasTranscript
+    };
+  }), 16);
+  return settled.filter((r) => r.status === "fulfilled").map((r) => r.value).filter((v) => v !== null);
+}
+async function getCopilotProjects() {
+  let metas;
   try {
-    const projectsPath = getClaudeProjectsPath();
-    const entries = await safeReaddir2(projectsPath);
-    if (!entries)
-      return [];
-    const settled = await batchAll(entries.filter((entry) => entry.isDirectory()).map((entry) => async () => {
-      const folderPath = join6(projectsPath, entry.name);
-      const mtime = await getMtime(folderPath, entry.name);
-      return {
-        name: entry.name,
-        path: folderPath,
-        isDirectory: true,
-        lastModified: mtime,
-        lastModifiedFormatted: formatDate(mtime),
-        cli: ["claude"]
-      };
-    }), 16);
-    const folders = settled.filter((r) => r.status === "fulfilled").map((r) => r.value);
-    folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
-    return folders;
+    metas = await cachedScan2();
   } catch (error) {
-    logError("Error reading Claude project folders:", error);
+    logWarn("Failed to scan Copilot sessions:", error);
     return [];
   }
-}
-function mergeProjectFolders(claude, codex) {
-  const byName = new Map;
-  for (const f of claude)
-    byName.set(f.name, { ...f, cli: [...f.cli] });
-  for (const f of codex) {
-    const existing = byName.get(f.name);
-    if (!existing) {
-      byName.set(f.name, { ...f, cli: [...f.cli] });
+  const byCwd = new Map;
+  for (const m of metas) {
+    if (!m.hasTranscript)
       continue;
+    const existing = byCwd.get(m.cwd);
+    if (!existing || m.fileMtime.getTime() > existing.latest.getTime()) {
+      byCwd.set(m.cwd, { latest: m.fileMtime, cwd: m.cwd });
     }
-    const mergedCli = [...existing.cli];
-    for (const c of f.cli)
-      if (!mergedCli.includes(c))
-        mergedCli.push(c);
-    const newer = f.lastModified.getTime() > existing.lastModified.getTime() ? f : existing;
-    byName.set(f.name, {
-      ...existing,
-      cli: mergedCli,
-      lastModified: newer.lastModified,
-      lastModifiedFormatted: newer.lastModifiedFormatted
+  }
+  const folders = [];
+  for (const { cwd, latest } of byCwd.values()) {
+    folders.push({
+      name: encodeFolderName(cwd),
+      path: cwd,
+      isDirectory: true,
+      lastModified: latest,
+      lastModifiedFormatted: formatDate(latest),
+      cli: ["copilot"]
     });
   }
-  const merged = Array.from(byName.values());
-  merged.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
-  return merged;
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
 }
-async function getProjectFolders() {
-  const { getCodexProjects: getCodexProjects2 } = await Promise.resolve().then(() => (init_codex_projects(), exports_codex_projects));
-  const [claude, codex] = await Promise.all([
-    getClaudeProjectFolders(),
-    getCodexProjects2().catch((error) => {
-      logError("Error reading Codex projects:", error);
-      return [];
-    })
-  ]);
-  return mergeProjectFolders(claude, codex);
+function metasToSessionFiles2(metas) {
+  const files = metas.filter((m) => m.hasTranscript).map((m) => ({
+    name: m.sessionId,
+    path: m.eventsPath,
+    lastModified: m.fileMtime,
+    lastModifiedFormatted: formatDate(m.fileMtime),
+    sessionId: m.sessionId,
+    cli: "copilot"
+  }));
+  files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return files;
 }
-function resolveProjectPath(projectName) {
-  if (!projectName)
-    throw new RangeError("Empty project name");
-  if (/^[/\\]/.test(projectName))
-    throw new RangeError("Absolute project name");
-  const projectsPath = resolve5(getClaudeProjectsPath());
-  const candidate = resolve5(join6(projectsPath, projectName));
-  if (!candidate.startsWith(projectsPath + sep)) {
-    throw new RangeError("Project path escapes root");
+async function getCopilotSessionsForCwd(cwd) {
+  let metas;
+  try {
+    metas = await cachedScan2();
+  } catch (error) {
+    logWarn("Failed to scan Copilot sessions:", error);
+    return [];
   }
-  return candidate;
-}
-function extractSessionId2(filename) {
-  const uuidPattern = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
-  const match = filename.match(uuidPattern);
-  return match ? match[0] : undefined;
+  return metasToSessionFiles2(metas.filter((m) => m.cwd === cwd));
+}
+async function getCopilotSessionsByEncodedName(name) {
+  let metas;
+  try {
+    metas = await cachedScan2();
+  } catch (error) {
+    logWarn("Failed to scan Copilot sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  const matches = metas.filter((m) => m.hasTranscript && encodeFolderName(m.cwd) === name);
+  return {
+    cwd: matches[0]?.cwd ?? null,
+    sessions: metasToSessionFiles2(matches)
+  };
+}
+var cachedScan2, getCachedCopilotProjects, getCachedCopilotSessionsForCwd, getCachedCopilotSessionsByEncodedName;
+var init_copilot_projects = __esm(() => {
+  init_paths();
+  init_logger();
+  cachedScan2 = runtimeCache(scanCopilotSessions, 30);
+  getCachedCopilotProjects = runtimeCache(getCopilotProjects, 30);
+  getCachedCopilotSessionsForCwd = runtimeCache((cwd) => getCopilotSessionsForCwd(cwd), 30, { maxSize: 50 });
+  getCachedCopilotSessionsByEncodedName = runtimeCache((name) => getCopilotSessionsByEncodedName(name), 30, { maxSize: 50 });
+});
+
+// lib/cursor-projects.ts
+var exports_cursor_projects = {};
+__export(exports_cursor_projects, {
+  getCursorSessionsForCwd: () => getCursorSessionsForCwd,
+  getCursorSessionsByEncodedName: () => getCursorSessionsByEncodedName,
+  getCursorProjects: () => getCursorProjects,
+  getCachedCursorSessionsForCwd: () => getCachedCursorSessionsForCwd,
+  getCachedCursorSessionsByEncodedName: () => getCachedCursorSessionsByEncodedName,
+  getCachedCursorProjects: () => getCachedCursorProjects
+});
+import { readdir as readdir3, readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { join as join7 } from "node:path";
+function getCursorHome() {
+  return process.env.CURSOR_HOME || join7(homedir9(), ".cursor");
+}
+async function safeReaddir3(dir) {
+  try {
+    return await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+async function statMtime2(path) {
+  try {
+    return (await stat3(path)).mtime;
+  } catch {
+    return null;
+  }
+}
+function parseCwdFromMetaText(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed.cwd === "string" && parsed.cwd.length > 0)
+      return parsed.cwd;
+  } catch {}
+  const yaml = text.match(/^\s*cwd\s*:\s*(.+?)\s*$/m);
+  if (yaml) {
+    const stripped = yaml[1].replace(/^['"]|['"]$/g, "");
+    if (stripped.length > 0)
+      return stripped;
+  }
+  return;
+}
+async function findFirstUsableMeta(dir, candidates) {
+  for (const name of candidates) {
+    const path = join7(dir, name);
+    if (await statMtime2(path) === null)
+      continue;
+    let text;
+    try {
+      text = await readFile4(path, "utf-8");
+    } catch {
+      continue;
+    }
+    const cwd = parseCwdFromMetaText(text);
+    if (cwd)
+      return { path, cwd };
+  }
+  return null;
+}
+async function findFirstExistingPath(dir, candidates) {
+  for (const name of candidates) {
+    const path = join7(dir, name);
+    if (await statMtime2(path) !== null)
+      return path;
+  }
+  return null;
+}
+async function scanCursorSessions() {
+  const home = getCursorHome();
+  const newCandidates = [];
+  const legacyCandidates = [];
+  const projectsRoot = join7(home, NEW_PROJECTS_DIR);
+  const projectEntries = await safeReaddir3(projectsRoot);
+  if (projectEntries) {
+    for (const proj of projectEntries) {
+      if (!proj.isDirectory())
+        continue;
+      const decoded = decodeFolderName(proj.name);
+      const cwd = decoded.startsWith("/") || /^[A-Za-z]:\//.test(decoded) ? decoded : `/${decoded}`;
+      const transcriptsRoot = join7(projectsRoot, proj.name, NEW_AGENT_TRANSCRIPTS_DIR);
+      const sessionDirs = await safeReaddir3(transcriptsRoot);
+      if (!sessionDirs)
+        continue;
+      for (const sd of sessionDirs) {
+        if (!sd.isDirectory())
+          continue;
+        newCandidates.push({
+          sessionId: sd.name,
+          dir: join7(transcriptsRoot, sd.name),
+          cwd
+        });
+      }
+    }
+  }
+  for (const sub of LEGACY_SESSION_ROOT_CANDIDATES) {
+    const root = join7(home, sub);
+    const entries = await safeReaddir3(root);
+    if (!entries)
+      continue;
+    for (const e of entries) {
+      if (!e.isDirectory())
+        continue;
+      legacyCandidates.push({ sessionId: e.name, dir: join7(root, e.name) });
+    }
+  }
+  if (newCandidates.length === 0 && legacyCandidates.length === 0)
+    return [];
+  const settled = await batchAll([
+    ...newCandidates.map((c) => async () => {
+      const transcriptPath = join7(c.dir, `${c.sessionId}.jsonl`);
+      const transcriptMtime = await statMtime2(transcriptPath);
+      if (!transcriptMtime)
+        return null;
+      return {
+        metaPath: c.dir,
+        transcriptPath,
+        sessionId: c.sessionId,
+        cwd: c.cwd,
+        fileMtime: transcriptMtime,
+        hasTranscript: true
+      };
+    }),
+    ...legacyCandidates.map((c) => async () => {
+      const meta = await findFirstUsableMeta(c.dir, META_FILE_CANDIDATES);
+      if (!meta)
+        return null;
+      const transcriptPath = await findFirstExistingPath(c.dir, LEGACY_TRANSCRIPT_FILE_CANDIDATES);
+      const transcriptMtime = transcriptPath ? await statMtime2(transcriptPath) : null;
+      const metaMtime = await statMtime2(meta.path);
+      const fileMtime = transcriptMtime && metaMtime ? new Date(Math.max(transcriptMtime.getTime(), metaMtime.getTime())) : transcriptMtime ?? metaMtime ?? new Date(0);
+      return {
+        metaPath: meta.path,
+        transcriptPath,
+        sessionId: c.sessionId,
+        cwd: meta.cwd,
+        fileMtime,
+        hasTranscript: transcriptPath !== null
+      };
+    })
+  ], 16);
+  return settled.filter((r) => r.status === "fulfilled").map((r) => r.value).filter((v) => v !== null);
+}
+async function getCursorProjects() {
+  let metas;
+  try {
+    metas = await cachedScan3();
+  } catch (error) {
+    logWarn("Failed to scan Cursor sessions:", error);
+    return [];
+  }
+  const byCwd = new Map;
+  for (const m of metas) {
+    if (!m.hasTranscript)
+      continue;
+    const existing = byCwd.get(m.cwd);
+    if (!existing || m.fileMtime.getTime() > existing.latest.getTime()) {
+      byCwd.set(m.cwd, { latest: m.fileMtime, cwd: m.cwd });
+    }
+  }
+  const folders = [];
+  for (const { cwd, latest } of byCwd.values()) {
+    folders.push({
+      name: encodeFolderName(cwd),
+      path: cwd,
+      isDirectory: true,
+      lastModified: latest,
+      lastModifiedFormatted: formatDate(latest),
+      cli: ["cursor"]
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+function metasToSessionFiles3(metas) {
+  const files = metas.filter((m) => m.hasTranscript && m.transcriptPath).map((m) => ({
+    name: m.sessionId,
+    path: m.transcriptPath,
+    lastModified: m.fileMtime,
+    lastModifiedFormatted: formatDate(m.fileMtime),
+    sessionId: m.sessionId,
+    cli: "cursor"
+  }));
+  files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return files;
+}
+async function getCursorSessionsForCwd(cwd) {
+  let metas;
+  try {
+    metas = await cachedScan3();
+  } catch (error) {
+    logWarn("Failed to scan Cursor sessions:", error);
+    return [];
+  }
+  return metasToSessionFiles3(metas.filter((m) => m.cwd === cwd));
+}
+async function getCursorSessionsByEncodedName(name) {
+  let metas;
+  try {
+    metas = await cachedScan3();
+  } catch (error) {
+    logWarn("Failed to scan Cursor sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  const matches = metas.filter((m) => m.hasTranscript && encodeFolderName(m.cwd) === name);
+  return {
+    cwd: matches[0]?.cwd ?? null,
+    sessions: metasToSessionFiles3(matches)
+  };
+}
+var LEGACY_SESSION_ROOT_CANDIDATES, META_FILE_CANDIDATES, LEGACY_TRANSCRIPT_FILE_CANDIDATES, NEW_PROJECTS_DIR = "projects", NEW_AGENT_TRANSCRIPTS_DIR = "agent-transcripts", cachedScan3, getCachedCursorProjects, getCachedCursorSessionsForCwd, getCachedCursorSessionsByEncodedName;
+var init_cursor_projects = __esm(() => {
+  init_paths();
+  init_logger();
+  LEGACY_SESSION_ROOT_CANDIDATES = ["agent-sessions", "conversations", "sessions"];
+  META_FILE_CANDIDATES = ["meta.json", "session.json", "workspace.json", "workspace.yaml"];
+  LEGACY_TRANSCRIPT_FILE_CANDIDATES = ["events.jsonl", "transcript.jsonl", "messages.jsonl"];
+  cachedScan3 = runtimeCache(scanCursorSessions, 30);
+  getCachedCursorProjects = runtimeCache(getCursorProjects, 30);
+  getCachedCursorSessionsForCwd = runtimeCache((cwd) => getCursorSessionsForCwd(cwd), 30, { maxSize: 50 });
+  getCachedCursorSessionsByEncodedName = runtimeCache((name) => getCursorSessionsByEncodedName(name), 30, { maxSize: 50 });
+});
+
+// lib/opencode-projects.ts
+var exports_opencode_projects = {};
+__export(exports_opencode_projects, {
+  getOpenCodeSessionsForCwd: () => getOpenCodeSessionsForCwd,
+  getOpenCodeSessionsByEncodedName: () => getOpenCodeSessionsByEncodedName,
+  getOpenCodeProjects: () => getOpenCodeProjects,
+  getCachedOpenCodeSessionsForCwd: () => getCachedOpenCodeSessionsForCwd,
+  getCachedOpenCodeSessionsByEncodedName: () => getCachedOpenCodeSessionsByEncodedName,
+  getCachedOpenCodeProjects: () => getCachedOpenCodeProjects
+});
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { basename as basename2 } from "node:path";
+function runOpenCodeDb(sql) {
+  try {
+    const stdout = execFileSync2("opencode", ["db", "--format", "json", sql], {
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (!stdout.trim())
+      return [];
+    const parsed = JSON.parse(stdout);
+    if (!Array.isArray(parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function readSessionRows() {
+  return runOpenCodeDb(`SELECT id, project_id, slug, directory, title, time_created, time_updated FROM session ORDER BY time_updated DESC LIMIT ${SESSION_LIMIT}`);
+}
+function readProjectRows() {
+  return runOpenCodeDb(`SELECT id, worktree, vcs, name, time_created, time_updated FROM project`);
+}
+async function getOpenCodeProjects() {
+  const sessions = readSessionRows();
+  const projects = readProjectRows();
+  if (sessions === null && projects === null) {
+    return [];
+  }
+  const projectMap = new Map;
+  for (const p of projects ?? [])
+    projectMap.set(p.id, p);
+  const groups = new Map;
+  for (const s of sessions ?? []) {
+    if (!s.project_id)
+      continue;
+    let g = groups.get(s.project_id);
+    if (!g) {
+      g = { rows: [], latest: 0 };
+      groups.set(s.project_id, g);
+    }
+    g.rows.push(s);
+    if (s.time_updated > g.latest)
+      g.latest = s.time_updated;
+  }
+  const seen = new Set;
+  const out = [];
+  for (const [projectId, group] of groups) {
+    seen.add(projectId);
+    const proj = projectMap.get(projectId);
+    const worktree = proj?.worktree ?? group.rows[0]?.directory ?? null;
+    const name = proj?.name?.trim() || (worktree ? basename2(worktree) : projectId);
+    const path = worktree ?? "";
+    const lastModified = new Date(Math.max(group.latest, proj?.time_updated ?? 0));
+    out.push({
+      name,
+      path,
+      isDirectory: true,
+      lastModified,
+      lastModifiedFormatted: formatDate(lastModified),
+      cli: ["opencode"]
+    });
+  }
+  for (const p of projects ?? []) {
+    if (seen.has(p.id))
+      continue;
+    const worktree = p.worktree ?? "";
+    const name = p.name?.trim() || (worktree ? basename2(worktree) : p.id);
+    const lastModified = new Date(p.time_updated);
+    out.push({
+      name,
+      path: worktree,
+      isDirectory: true,
+      lastModified,
+      lastModifiedFormatted: formatDate(lastModified),
+      cli: ["opencode"]
+    });
+  }
+  out.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return out;
+}
+async function getOpenCodeSessionsForCwd(cwd) {
+  const sessions = readSessionRows();
+  if (!sessions)
+    return [];
+  const matches = sessions.filter((s) => s.directory === cwd);
+  return matches.map((s) => {
+    const lastModified = new Date(s.time_updated);
+    return {
+      name: s.title ?? s.slug ?? s.id,
+      path: `opencode://${s.id}`,
+      lastModified,
+      lastModifiedFormatted: formatDate(lastModified),
+      sessionId: s.id,
+      cli: "opencode"
+    };
+  });
+}
+async function getOpenCodeSessionsByEncodedName(name) {
+  let projects;
+  let sessions;
+  try {
+    projects = readProjectRows();
+    sessions = readSessionRows();
+  } catch (error) {
+    logWarn("Failed to read OpenCode DB:", error);
+    return { cwd: null, sessions: [] };
+  }
+  if (!projects || !sessions)
+    return { cwd: null, sessions: [] };
+  const matchingProject = projects.find((p) => p.worktree && encodeFolderName(p.worktree) === name);
+  if (!matchingProject || !matchingProject.worktree)
+    return { cwd: null, sessions: [] };
+  const matched = sessions.filter((s) => s.project_id === matchingProject.id);
+  return {
+    cwd: matchingProject.worktree,
+    sessions: matched.map((s) => {
+      const lastModified = new Date(s.time_updated);
+      return {
+        name: s.title ?? s.slug ?? s.id,
+        path: `opencode://${s.id}`,
+        lastModified,
+        lastModifiedFormatted: formatDate(lastModified),
+        sessionId: s.id,
+        cli: "opencode"
+      };
+    })
+  };
+}
+var SESSION_LIMIT = 1000, getCachedOpenCodeProjects, getCachedOpenCodeSessionsForCwd, getCachedOpenCodeSessionsByEncodedName;
+var init_opencode_projects = __esm(() => {
+  init_paths();
+  init_logger();
+  getCachedOpenCodeProjects = runtimeCache(getOpenCodeProjects, 30);
+  getCachedOpenCodeSessionsForCwd = runtimeCache((cwd) => getOpenCodeSessionsForCwd(cwd), 30, { maxSize: 50 });
+  getCachedOpenCodeSessionsByEncodedName = runtimeCache((name) => getOpenCodeSessionsByEncodedName(name), 30, { maxSize: 50 });
+});
+
+// lib/pi-projects.ts
+var exports_pi_projects = {};
+__export(exports_pi_projects, {
+  getPiSessionsForCwd: () => getPiSessionsForCwd,
+  getPiSessionsByEncodedName: () => getPiSessionsByEncodedName,
+  getPiProjects: () => getPiProjects,
+  getCachedPiSessionsForCwd: () => getCachedPiSessionsForCwd,
+  getCachedPiSessionsByEncodedName: () => getCachedPiSessionsByEncodedName,
+  getCachedPiProjects: () => getCachedPiProjects
+});
+import { readdir as readdir4, readFile as readFile5, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir10 } from "node:os";
+import { join as join8 } from "node:path";
+function getPiSessionsRoot() {
+  return process.env.PI_SESSIONS_DIR || join8(homedir10(), ".pi", "agent", "sessions");
+}
+async function safeReaddir4(dir) {
+  try {
+    return await readdir4(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+async function statMtime3(path) {
+  try {
+    return (await stat4(path)).mtime;
+  } catch {
+    return null;
+  }
+}
+async function readSessionCwd(filePath) {
+  let text;
+  try {
+    text = await readFile5(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const firstLine = text.indexOf(`
+`) >= 0 ? text.slice(0, text.indexOf(`
+`)) : text;
+  if (!firstLine)
+    return null;
+  try {
+    const parsed = JSON.parse(firstLine);
+    if (parsed.type !== "session")
+      return null;
+    if (typeof parsed.cwd !== "string" || parsed.cwd.length === 0)
+      return null;
+    return parsed.cwd;
+  } catch {
+    return null;
+  }
+}
+async function scanPiSessions() {
+  const root = getPiSessionsRoot();
+  const cwdDirs = await safeReaddir4(root);
+  if (!cwdDirs)
+    return [];
+  const candidates = [];
+  for (const cwdDir of cwdDirs) {
+    if (!cwdDir.isDirectory())
+      continue;
+    const cwdPath = join8(root, cwdDir.name);
+    const sessionFiles = await safeReaddir4(cwdPath);
+    if (!sessionFiles)
+      continue;
+    for (const f of sessionFiles) {
+      if (!f.isFile())
+        continue;
+      const m = SESSION_FILE_RE.exec(f.name);
+      if (!m)
+        continue;
+      candidates.push({ sessionId: m[1], filePath: join8(cwdPath, f.name) });
+    }
+  }
+  if (candidates.length === 0)
+    return [];
+  const settled = await batchAll(candidates.map((c) => async () => {
+    const cwd = await readSessionCwd(c.filePath);
+    if (!cwd)
+      return null;
+    const mtime = await statMtime3(c.filePath);
+    if (!mtime)
+      return null;
+    return {
+      filePath: c.filePath,
+      sessionId: c.sessionId,
+      cwd,
+      fileMtime: mtime
+    };
+  }), 16);
+  return settled.filter((r) => r.status === "fulfilled").map((r) => r.value).filter((v) => v !== null);
+}
+async function getPiProjects() {
+  let metas;
+  try {
+    metas = await cachedScan4();
+  } catch (error) {
+    logWarn("Failed to scan Pi sessions:", error);
+    return [];
+  }
+  const byCwd = new Map;
+  for (const m of metas) {
+    const existing = byCwd.get(m.cwd);
+    if (!existing || m.fileMtime.getTime() > existing.latest.getTime()) {
+      byCwd.set(m.cwd, { latest: m.fileMtime, cwd: m.cwd });
+    }
+  }
+  const folders = [];
+  for (const { cwd, latest } of byCwd.values()) {
+    folders.push({
+      name: encodeFolderName(cwd),
+      path: cwd,
+      isDirectory: true,
+      lastModified: latest,
+      lastModifiedFormatted: formatDate(latest),
+      cli: ["pi"]
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+function metasToSessionFiles4(metas) {
+  const files = metas.map((m) => ({
+    name: m.sessionId,
+    path: m.filePath,
+    lastModified: m.fileMtime,
+    lastModifiedFormatted: formatDate(m.fileMtime),
+    sessionId: m.sessionId,
+    cli: "pi"
+  }));
+  files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return files;
+}
+async function getPiSessionsForCwd(cwd) {
+  let metas;
+  try {
+    metas = await cachedScan4();
+  } catch (error) {
+    logWarn("Failed to scan Pi sessions:", error);
+    return [];
+  }
+  return metasToSessionFiles4(metas.filter((m) => m.cwd === cwd));
+}
+async function getPiSessionsByEncodedName(name) {
+  let metas;
+  try {
+    metas = await cachedScan4();
+  } catch (error) {
+    logWarn("Failed to scan Pi sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  const matches = metas.filter((m) => encodeFolderName(m.cwd) === name);
+  const uniqueCwds = Array.from(new Set(matches.map((m) => m.cwd)));
+  if (uniqueCwds.length !== 1) {
+    return { cwd: null, sessions: [] };
+  }
+  return {
+    cwd: uniqueCwds[0],
+    sessions: metasToSessionFiles4(matches)
+  };
+}
+var SESSION_FILE_RE, cachedScan4, getCachedPiProjects, getCachedPiSessionsForCwd, getCachedPiSessionsByEncodedName;
+var init_pi_projects = __esm(() => {
+  init_paths();
+  init_logger();
+  SESSION_FILE_RE = /^[\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;
+  cachedScan4 = runtimeCache(scanPiSessions, 30);
+  getCachedPiProjects = runtimeCache(getPiProjects, 30);
+  getCachedPiSessionsForCwd = runtimeCache((cwd) => getPiSessionsForCwd(cwd), 30, { maxSize: 50 });
+  getCachedPiSessionsByEncodedName = runtimeCache((name) => getPiSessionsByEncodedName(name), 30, { maxSize: 50 });
+});
+
+// lib/gemini-projects.ts
+var exports_gemini_projects = {};
+__export(exports_gemini_projects, {
+  getGeminiSessionsForCwd: () => getGeminiSessionsForCwd,
+  getGeminiSessionsByEncodedName: () => getGeminiSessionsByEncodedName,
+  getGeminiProjects: () => getGeminiProjects,
+  getCachedGeminiSessionsByEncodedName: () => getCachedGeminiSessionsByEncodedName,
+  getCachedGeminiProjects: () => getCachedGeminiProjects
+});
+import { readdir as readdir5, readFile as readFile6, stat as stat5 } from "node:fs/promises";
+import { homedir as homedir11 } from "node:os";
+import { join as join9 } from "node:path";
+function getGeminiTmpRoot() {
+  return process.env.GEMINI_SESSIONS_DIR || join9(homedir11(), ".gemini", "tmp");
+}
+async function safeReaddir5(dir) {
+  try {
+    return await readdir5(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+async function statMtime4(path) {
+  try {
+    return (await stat5(path)).mtime;
+  } catch {
+    return null;
+  }
+}
+async function readProjectRoot(projectDir) {
+  try {
+    const text = await readFile6(join9(projectDir, ".project_root"), "utf-8");
+    const trimmed = text.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+async function scanGeminiSessions() {
+  const root = getGeminiTmpRoot();
+  const projectDirs = await safeReaddir5(root);
+  if (!projectDirs)
+    return [];
+  const out = [];
+  await batchAll(projectDirs.filter((d) => d.isDirectory()).map((d) => async () => {
+    const projectDir = join9(root, d.name);
+    const cwd = await readProjectRoot(projectDir);
+    if (!cwd)
+      return;
+    const chatsDir = join9(projectDir, "chats");
+    const files = await safeReaddir5(chatsDir);
+    if (!files)
+      return;
+    for (const f of files) {
+      if (!f.isFile())
+        continue;
+      if (!SESSION_FILE_RE2.test(f.name))
+        continue;
+      const filePath = join9(chatsDir, f.name);
+      const mtime = await statMtime4(filePath);
+      if (!mtime)
+        continue;
+      out.push({ filePath, sessionFilename: f.name, cwd, fileMtime: mtime });
+    }
+  }), 16);
+  return out;
+}
+async function getGeminiProjects() {
+  const sessions = await scanGeminiSessions();
+  const byCwd = new Map;
+  for (const s of sessions) {
+    const existing = byCwd.get(s.cwd);
+    if (!existing || s.fileMtime.getTime() > existing.mtime.getTime()) {
+      byCwd.set(s.cwd, { mtime: s.fileMtime });
+    }
+  }
+  const folders = [...byCwd.entries()].map(([cwd, { mtime }]) => ({
+    name: encodeFolderName(cwd),
+    path: cwd,
+    isDirectory: true,
+    lastModified: mtime,
+    lastModifiedFormatted: formatDate(mtime),
+    cli: ["gemini"]
+  }));
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+async function getGeminiSessionsForCwd(cwd) {
+  const sessions = await scanGeminiSessions();
+  const matches = sessions.filter((s) => s.cwd === cwd);
+  const files = matches.map((s) => {
+    const m = s.sessionFilename.match(SESSION_FILE_RE2);
+    return {
+      name: s.sessionFilename,
+      path: s.filePath,
+      lastModified: s.fileMtime,
+      lastModifiedFormatted: formatDate(s.fileMtime),
+      sessionId: m ? m[2] : undefined,
+      cli: "gemini"
+    };
+  });
+  files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return files;
+}
+async function getGeminiSessionsByEncodedName(name) {
+  let metas;
+  try {
+    metas = await scanGeminiSessions();
+  } catch (error) {
+    logWarn("Failed to scan Gemini sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  const matches = metas.filter((m) => encodeFolderName(m.cwd) === name);
+  const uniqueCwds = Array.from(new Set(matches.map((m) => m.cwd)));
+  if (uniqueCwds.length !== 1) {
+    return { cwd: null, sessions: [] };
+  }
+  const sessions = matches.map((s) => {
+    const m = s.sessionFilename.match(SESSION_FILE_RE2);
+    return {
+      name: s.sessionFilename,
+      path: s.filePath,
+      lastModified: s.fileMtime,
+      lastModifiedFormatted: formatDate(s.fileMtime),
+      sessionId: m ? m[2] : undefined,
+      cli: "gemini"
+    };
+  });
+  sessions.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return { cwd: uniqueCwds[0], sessions };
+}
+var SESSION_FILE_RE2, getCachedGeminiProjects, getCachedGeminiSessionsByEncodedName;
+var init_gemini_projects = __esm(() => {
+  init_paths();
+  init_logger();
+  SESSION_FILE_RE2 = /^session-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2})-([0-9a-f]{8})\.jsonl$/i;
+  getCachedGeminiProjects = runtimeCache(getGeminiProjects, 30);
+  getCachedGeminiSessionsByEncodedName = runtimeCache((name) => getGeminiSessionsByEncodedName(name), 30, { maxSize: 50 });
+});
+
+// lib/projects.ts
+import { readdir as readdir6, stat as stat6 } from "node:fs/promises";
+import { join as join10, resolve as resolve5, sep } from "node:path";
+async function getMtime(path, label) {
+  try {
+    return (await stat6(path)).mtime;
+  } catch (error) {
+    logWarn(`Failed to stat ${label}:`, error);
+    return new Date(0);
+  }
+}
+async function safeReaddir6(dirPath) {
+  try {
+    const s = await stat6(dirPath);
+    if (!s.isDirectory())
+      return null;
+    return await readdir6(dirPath, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+async function getClaudeProjectFolders() {
+  try {
+    const projectsPath = getClaudeProjectsPath();
+    const entries = await safeReaddir6(projectsPath);
+    if (!entries)
+      return [];
+    const settled = await batchAll(entries.filter((entry) => entry.isDirectory()).map((entry) => async () => {
+      const folderPath = join10(projectsPath, entry.name);
+      const mtime = await getMtime(folderPath, entry.name);
+      return {
+        name: entry.name,
+        path: folderPath,
+        isDirectory: true,
+        lastModified: mtime,
+        lastModifiedFormatted: formatDate(mtime),
+        cli: ["claude"]
+      };
+    }), 16);
+    const folders = settled.filter((r) => r.status === "fulfilled").map((r) => r.value);
+    folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    return folders;
+  } catch (error) {
+    logError("Error reading Claude project folders:", error);
+    return [];
+  }
+}
+function mergeProjectFolders(...sources) {
+  const byName = new Map;
+  for (const list of sources) {
+    for (const f of list) {
+      const existing = byName.get(f.name);
+      if (!existing) {
+        byName.set(f.name, { ...f, cli: [...f.cli] });
+        continue;
+      }
+      const mergedCli = [...existing.cli];
+      for (const c of f.cli)
+        if (!mergedCli.includes(c))
+          mergedCli.push(c);
+      const newer = f.lastModified.getTime() > existing.lastModified.getTime() ? f : existing;
+      byName.set(f.name, {
+        ...existing,
+        cli: mergedCli,
+        lastModified: newer.lastModified,
+        lastModifiedFormatted: newer.lastModifiedFormatted
+      });
+    }
+  }
+  const merged = Array.from(byName.values());
+  merged.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return merged;
+}
+async function getProjectFolders() {
+  const [
+    { getCodexProjects: getCodexProjects2 },
+    { getCopilotProjects: getCopilotProjects2 },
+    { getCursorProjects: getCursorProjects2 },
+    { getOpenCodeProjects: getOpenCodeProjects2 },
+    { getPiProjects: getPiProjects2 },
+    { getGeminiProjects: getGeminiProjects2 }
+  ] = await Promise.all([
+    Promise.resolve().then(() => (init_codex_projects(), exports_codex_projects)),
+    Promise.resolve().then(() => (init_copilot_projects(), exports_copilot_projects)),
+    Promise.resolve().then(() => (init_cursor_projects(), exports_cursor_projects)),
+    Promise.resolve().then(() => (init_opencode_projects(), exports_opencode_projects)),
+    Promise.resolve().then(() => (init_pi_projects(), exports_pi_projects)),
+    Promise.resolve().then(() => (init_gemini_projects(), exports_gemini_projects))
+  ]);
+  const [claude, codex, copilot, cursor, opencode, pi, gemini] = await Promise.all([
+    getClaudeProjectFolders(),
+    getCodexProjects2().catch((error) => {
+      logError("Error reading Codex projects:", error);
+      return [];
+    }),
+    getCopilotProjects2().catch((error) => {
+      logError("Error reading Copilot projects:", error);
+      return [];
+    }),
+    getCursorProjects2().catch((error) => {
+      logError("Error reading Cursor projects:", error);
+      return [];
+    }),
+    getOpenCodeProjects2().catch((error) => {
+      logError("Error reading OpenCode projects:", error);
+      return [];
+    }),
+    getPiProjects2().catch((error) => {
+      logError("Error reading Pi projects:", error);
+      return [];
+    }),
+    getGeminiProjects2().catch((error) => {
+      logError("Error reading Gemini projects:", error);
+      return [];
+    })
+  ]);
+  return mergeProjectFolders(claude, codex, copilot, cursor, opencode, pi, gemini);
+}
+function resolveProjectPath(projectName) {
+  if (!projectName)
+    throw new RangeError("Empty project name");
+  if (/^[/\\]/.test(projectName))
+    throw new RangeError("Absolute project name");
+  const projectsPath = resolve5(getClaudeProjectsPath());
+  const candidate = resolve5(join10(projectsPath, projectName));
+  if (!candidate.startsWith(projectsPath + sep)) {
+    throw new RangeError("Project path escapes root");
+  }
+  return candidate;
+}
+function extractSessionId2(filename) {
+  const uuidPattern = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+  const match = filename.match(uuidPattern);
+  return match ? match[0] : undefined;
 }
 async function getSessionFiles(projectPath) {
   try {
-    const entries = await safeReaddir2(projectPath);
+    const entries = await safeReaddir6(projectPath);
     if (!entries)
       return [];
     const jsonlEntries = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl") && extractSessionId2(entry.name));
     const settled = await batchAll(jsonlEntries.map((entry) => async () => {
-      const filePath = join6(projectPath, entry.name);
+      const filePath = join10(projectPath, entry.name);
       const mtime = await getMtime(filePath, entry.name);
       return {
         name: entry.name,
@@ -2876,13 +4114,13 @@ var init_projects = __esm(() => {
 
 // lib/resolve-subagent-path.ts
 import { access as access2 } from "fs/promises";
-import { join as join7, relative as relative2 } from "path";
+import { join as join11, relative as relative2 } from "path";
 async function resolveSubagentPath(projectsPath, projectName, sessionId, agentId) {
   const fileName = `agent-${agentId}.jsonl`;
   const candidatePaths = [
-    join7(projectsPath, projectName, fileName),
-    join7(projectsPath, projectName, sessionId, fileName),
-    join7(projectsPath, projectName, sessionId, "subagents", fileName)
+    join11(projectsPath, projectName, fileName),
+    join11(projectsPath, projectName, sessionId, fileName),
+    join11(projectsPath, projectName, sessionId, "subagents", fileName)
   ];
   for (const candidatePath of candidatePaths) {
     if (relative2(projectsPath, candidatePath).startsWith("..")) {
@@ -2920,8 +4158,8 @@ function formatDuration(ms) {
 }
 
 // lib/log-entries.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { join as join12 } from "path";
 function formatTimestamp(date) {
   const base = formatDate(date);
   const ms = date.getMilliseconds().toString().padStart(3, "0");
@@ -3102,8 +4340,8 @@ async function parseFileContent(fileContent, source) {
 async function parseSessionLog(projectName, sessionId) {
   const projectDir = resolveProjectPath(projectName);
   const projectsPath = getClaudeProjectsPath();
-  const filePath = join8(projectDir, `${sessionId}.jsonl`);
-  const fileContent = await readFile3(filePath, "utf-8");
+  const filePath = join12(projectDir, `${sessionId}.jsonl`);
+  const fileContent = await readFile7(filePath, "utf-8");
   const { entries: sessionEntries, rawLines: sessionRawLines, subagentIds } = await parseFileContent(fileContent, "session");
   if (subagentIds.length === 0) {
     return { entries: sessionEntries, rawLines: sessionRawLines, subagentIds: [] };
@@ -3113,7 +4351,7 @@ async function parseSessionLog(projectName, sessionId) {
     const agentPath = await resolveSubagentPath(projectsPath, projectName, sessionId, agentId);
     if (!agentPath)
       return null;
-    const agentContent = await readFile3(agentPath, "utf-8");
+    const agentContent = await readFile7(agentPath, "utf-8");
     const { entries, rawLines } = await parseFileContent(agentContent, agentSource);
     return { entries, rawLines };
   }), SUBAGENT_CONCURRENCY);
@@ -3140,9 +4378,9 @@ var init_log_entries = __esm(() => {
 
 // lib/codex-sessions.ts
 import { readFileSync as readFileSync3, readdirSync as readdirSync3, existsSync as existsSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, statSync as statSync4 } from "node:fs";
-import { readFile as readFile4 } from "node:fs/promises";
-import { dirname as dirname3, join as join9 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { readFile as readFile8 } from "node:fs/promises";
+import { dirname as dirname3, join as join13 } from "node:path";
+import { homedir as homedir12 } from "node:os";
 function readCache() {
   try {
     if (!existsSync5(CACHE_PATH))
@@ -3164,7 +4402,7 @@ function dirSearch(dir, sessionId) {
   try {
     for (const f of readdirSync3(dir, { withFileTypes: true })) {
       if (f.isFile() && f.name.includes(sessionId) && f.name.endsWith(".jsonl")) {
-        return join9(dir, f.name);
+        return join13(dir, f.name);
       }
     }
   } catch {}
@@ -3175,14 +4413,14 @@ function findCodexTranscript(sessionId) {
   const cached = cache[sessionId];
   if (cached && existsSync5(cached))
     return cached;
-  const root = join9(homedir8(), ".codex", "sessions");
+  const root = join13(homedir12(), ".codex", "sessions");
   const today = new Date;
   const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
   const datedDirs = [today, yesterday].map((d) => {
     const y = String(d.getUTCFullYear());
     const m = String(d.getUTCMonth() + 1).padStart(2, "0");
     const day = String(d.getUTCDate()).padStart(2, "0");
-    return join9(root, y, m, day);
+    return join13(root, y, m, day);
   });
   for (const dir of datedDirs) {
     const hit = dirSearch(dir, sessionId);
@@ -3195,13 +4433,13 @@ function findCodexTranscript(sessionId) {
     for (const y of readdirSync3(root, { withFileTypes: true })) {
       if (!y.isDirectory())
         continue;
-      for (const m of readdirSync3(join9(root, y.name), { withFileTypes: true })) {
+      for (const m of readdirSync3(join13(root, y.name), { withFileTypes: true })) {
         if (!m.isDirectory())
           continue;
-        for (const d of readdirSync3(join9(root, y.name, m.name), { withFileTypes: true })) {
+        for (const d of readdirSync3(join13(root, y.name, m.name), { withFileTypes: true })) {
           if (!d.isDirectory())
             continue;
-          const hit = dirSearch(join9(root, y.name, m.name, d.name), sessionId);
+          const hit = dirSearch(join13(root, y.name, m.name, d.name), sessionId);
           if (hit) {
             writeCacheEntry(sessionId, hit);
             return hit;
@@ -3414,14 +4652,14 @@ async function getCodexSessionLog(sessionId) {
   const filePath = findCodexTranscript(sessionId);
   if (!filePath)
     return null;
-  const fileContent = await readFile4(filePath, "utf-8");
+  const fileContent = await readFile8(filePath, "utf-8");
   const { entries, rawLines, cwd } = await parseCodexLog(fileContent, "session");
   return { entries, rawLines, cwd, filePath };
 }
 var CACHE_PATH, getCachedCodexSessionLog;
 var init_codex_sessions = __esm(() => {
   init_log_entries();
-  CACHE_PATH = join9(homedir8(), ".failproofai", "cache", "codex-session-paths.json");
+  CACHE_PATH = join13(homedir12(), ".failproofai", "cache", "codex-session-paths.json");
   getCachedCodexSessionLog = runtimeCache((sessionId) => getCodexSessionLog(sessionId), 60, { maxSize: 50 });
 });
 
@@ -3557,8 +4795,8 @@ import {
   openSync,
   closeSync
 } from "node:fs";
-import { join as join10 } from "node:path";
-import { homedir as homedir9 } from "node:os";
+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 });
@@ -3593,8 +4831,8 @@ function isLoggedIn() {
 }
 var AUTH_DIR, AUTH_FILE;
 var init_token_store = __esm(() => {
-  AUTH_DIR = join10(homedir9(), ".failproofai");
-  AUTH_FILE = join10(AUTH_DIR, "auth.json");
+  AUTH_DIR = join14(homedir13(), ".failproofai");
+  AUTH_FILE = join14(AUTH_DIR, "auth.json");
 });
 
 // src/relay/queue.ts
@@ -3618,8 +4856,8 @@ import {
   readdirSync as readdirSync4,
   chmodSync
 } from "node:fs";
-import { join as join11 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { join as join15 } from "node:path";
+import { homedir as homedir14 } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 function hashCwd(cwd) {
   if (!cwd)
@@ -3687,7 +4925,7 @@ function claimPendingBatch() {
     return null;
   }
   const seq = `${Date.now()}-${process.pid}`;
-  const processingFile = join11(QUEUE_DIR, `${PROCESSING_PREFIX}${seq}.jsonl`);
+  const processingFile = join15(QUEUE_DIR, `${PROCESSING_PREFIX}${seq}.jsonl`);
   try {
     renameSync4(PENDING_FILE, processingFile);
     try {
@@ -3704,7 +4942,7 @@ function claimPendingBatch() {
 function findOrphanProcessingFiles() {
   ensureDir2();
   try {
-    return readdirSync4(QUEUE_DIR).filter((n) => n.startsWith(PROCESSING_PREFIX) && n.endsWith(".jsonl")).map((n) => join11(QUEUE_DIR, n)).sort();
+    return readdirSync4(QUEUE_DIR).filter((n) => n.startsWith(PROCESSING_PREFIX) && n.endsWith(".jsonl")).map((n) => join15(QUEUE_DIR, n)).sort();
   } catch {
     return [];
   }
@@ -3733,15 +4971,15 @@ function deleteProcessingFile(path2) {
 var QUEUE_DIR, PENDING_FILE, PROCESSING_PREFIX = "processing-", MAX_QUEUE_BYTES;
 var init_queue = __esm(() => {
   init_token_store();
-  QUEUE_DIR = join11(homedir10(), ".failproofai", "cache", "server-queue");
-  PENDING_FILE = join11(QUEUE_DIR, "pending.jsonl");
+  QUEUE_DIR = join15(homedir14(), ".failproofai", "cache", "server-queue");
+  PENDING_FILE = join15(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 join12, dirname as dirname4 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+import { join as join16, dirname as dirname4 } from "node:path";
+import { homedir as homedir15 } from "node:os";
 function readPid() {
   if (!existsSync8(PID_FILE))
     return null;
@@ -3794,7 +5032,7 @@ function stopRelay() {
 }
 var PID_FILE;
 var init_pid = __esm(() => {
-  PID_FILE = join12(homedir11(), ".failproofai", "relay.pid");
+  PID_FILE = join16(homedir15(), ".failproofai", "relay.pid");
 });
 
 // src/relay/daemon.ts
@@ -3807,8 +5045,8 @@ __export(exports_daemon, {
 });
 import { spawn } from "node:child_process";
 import { existsSync as existsSync9 } from "node:fs";
-import { join as join13 } from "node:path";
-import { homedir as homedir12 } from "node:os";
+import { join as join17 } from "node:path";
+import { homedir as homedir16 } from "node:os";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function ensureRelayRunning() {
   if (!isLoggedIn())
@@ -4075,7 +5313,7 @@ var init_daemon = __esm(() => {
   init_token_store();
   init_pid();
   init_queue();
-  QUEUE_DIR2 = join13(homedir12(), ".failproofai", "cache", "server-queue");
+  QUEUE_DIR2 = join17(homedir16(), ".failproofai", "cache", "server-queue");
 });
 
 // src/hooks/handler.ts
@@ -4089,6 +5327,29 @@ function canonicalizeEventType(raw, cli) {
     if (mapped)
       return mapped;
   }
+  if (cli === "cursor") {
+    const mapped = CURSOR_EVENT_MAP[raw];
+    if (mapped)
+      return mapped;
+  }
+  if (cli === "pi") {
+    const mapped = PI_EVENT_MAP[raw];
+    if (mapped)
+      return mapped;
+  }
+  if (cli === "gemini") {
+    const mapped = GEMINI_EVENT_MAP[raw];
+    if (mapped)
+      return mapped;
+  }
+  return raw;
+}
+function canonicalizeToolName(raw, cli) {
+  if (!raw)
+    return raw;
+  if (cli === "gemini") {
+    return GEMINI_TOOL_MAP[raw] ?? raw;
+  }
   return raw;
 }
 async function handleHookEvent(eventType, cli = "claude") {
@@ -4127,6 +5388,11 @@ async function handleHookEvent(eventType, cli = "claude") {
     }
   }
   const canonicalEventType = canonicalizeEventType(eventType, cli);
+  const rawToolName = parsed.tool_name;
+  const canonicalToolName = canonicalizeToolName(rawToolName, cli);
+  if (canonicalToolName !== rawToolName) {
+    parsed.tool_name = canonicalToolName;
+  }
   const sessionId = parsed.session_id;
   const session = {
     sessionId,
@@ -4134,6 +5400,7 @@ async function handleHookEvent(eventType, cli = "claude") {
     cwd: parsed.cwd,
     permissionMode: resolvePermissionMode(cli, parsed, sessionId),
     hookEventName: parsed.hook_event_name,
+    rawHookEventName: eventType,
     cli
   };
   const config = readMergedHooksConfig(session.cwd);
@@ -4275,8 +5542,8 @@ __export(exports_daemon2, {
 });
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join14 } from "node:path";
-import { homedir as homedir13 } from "node:os";
+import { join as join18 } from "node:path";
+import { homedir as homedir17 } from "node:os";
 import { randomUUID as randomUUID3 } from "node:crypto";
 function ensureRelayRunning2() {
   if (!isLoggedIn())
@@ -4543,14 +5810,15 @@ var init_daemon2 = __esm(() => {
   init_token_store();
   init_pid();
   init_queue();
-  QUEUE_DIR3 = join14(homedir13(), ".failproofai", "cache", "server-queue");
+  QUEUE_DIR3 = join18(homedir17(), ".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 } from "node:fs";
+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 { homedir as homedir14 } from "node:os";
+import { fileURLToPath } from "node:url";
+import { homedir as homedir18 } from "node:os";
 function readJsonFile(path2) {
   if (!existsSync11(path2))
     return {};
@@ -4563,9 +5831,12 @@ function writeJsonFile(path2, data) {
 `, "utf8");
 }
 function isMarkedHook(hook) {
-  if (hook[FAILPROOFAI_HOOK_MARKER] === true)
+  if (!hook || typeof hook !== "object")
+    return false;
+  const h = hook;
+  if (h[FAILPROOFAI_HOOK_MARKER] === true)
     return true;
-  const cmd = typeof hook.command === "string" ? hook.command : "";
+  const cmd = typeof h.command === "string" ? h.command : "";
   return cmd.includes("failproofai") && cmd.includes("--hook");
 }
 function binaryExists(name) {
@@ -4577,6 +5848,194 @@ function binaryExists(name) {
     return false;
   }
 }
+function isMarkedCopilotHook(hook) {
+  if (hook[FAILPROOFAI_HOOK_MARKER] === true)
+    return true;
+  const bash = typeof hook.bash === "string" ? hook.bash : "";
+  const ps = typeof hook.powershell === "string" ? hook.powershell : "";
+  for (const cmd of [bash, ps]) {
+    if (cmd.includes("failproofai") && cmd.includes("--hook"))
+      return true;
+  }
+  return false;
+}
+function opencodePluginFilePath(settingsPath) {
+  return resolve6(dirname5(settingsPath), "plugins", "failproofai.mjs");
+}
+function buildOpenCodePluginShim(binaryPath, scope) {
+  const useNpx = scope === "project";
+  const escapedBin = useNpx ? '""' : JSON.stringify(binaryPath);
+  return `// AUTO-GENERATED by failproofai. ${FAILPROOFAI_HOOK_MARKER}
+// Re-generate via: failproofai policies --install --cli opencode
+// Plugin shim that bridges OpenCode's plugin API to the failproofai binary.
+// See: https://opencode.ai/docs/plugins/
+import { spawnSync } from "node:child_process";
+
+// Map opencode bus-event types → canonical failproofai event names.
+// (The binary sees PascalCase — the binary's --cli=opencode flag is for
+// telemetry / activity tagging only; no opencode branch in handler.ts.)
+const BUS_EVENT_MAP = {
+  "session.created": "SessionStart",
+  "session.deleted": "SessionEnd",
+  "session.idle":    "Stop",
+  // message.updated is handled separately (filter to role:user); see below.
+};
+
+const FAILPROOFAI_BIN = ${escapedBin};
+const USE_NPX = ${useNpx};
+
+function runFailproofai(eventName, payload, directory) {
+  const cmd = USE_NPX ? "npx" : FAILPROOFAI_BIN;
+  const args = USE_NPX
+    ? ["-y", "failproofai", "--hook", eventName, "--cli", "opencode"]
+    : ["--hook", eventName, "--cli", "opencode"];
+  const r = spawnSync(cmd, args, {
+    input: JSON.stringify(payload),
+    encoding: "utf8",
+    timeout: 60_000,
+    cwd: directory,
+  });
+  return { exitCode: r.status ?? 0, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+
+function applyDecision(result, ctx) {
+  // Deny path 1: exit 2 (Claude Stop-style or any non-Pre/Post deny).
+  if (result.exitCode === 2) {
+    throw new Error((result.stderr || "").trim() || "Blocked by failproofai");
+  }
+  // Deny path 2: stdout JSON with hookSpecificOutput.permissionDecision === "deny".
+  let parsed = null;
+  try { parsed = JSON.parse(result.stdout); } catch { /* fail-open allow */ }
+  if (!parsed) return;
+  const out = parsed.hookSpecificOutput;
+  if (out && out.permissionDecision === "deny") {
+    throw new Error(out.permissionDecisionReason || "Blocked by failproofai");
+  }
+  // Codex-shape PermissionRequest deny: hookSpecificOutput.decision.behavior.
+  if (out && out.decision && out.decision.behavior === "deny") {
+    throw new Error((out.decision.message) || "Blocked by failproofai");
+  }
+  // Instruct: forward the additional context as a prompt to the session.
+  const ctxText = out && out.additionalContext;
+  if (ctxText && ctx && ctx.client && ctx.sessionID) {
+    // Fire-and-forget: don't block the tool call on the SDK round-trip.
+    Promise.resolve(ctx.client.session.prompt({
+      path: { id: ctx.sessionID },
+      body: { parts: [{ type: "text", text: ctxText }] },
+    })).catch(() => {});
+  }
+}
+
+export default async function failproofaiPlugin({ client, directory }) {
+  return {
+    // Generic bus events: session lifecycle + user-prompt detection.
+    event: async ({ event }) => {
+      if (!event || !event.type) return;
+
+      // UserPromptSubmit — filter message.updated to user role only so we
+      // don't fire on every assistant token. Forward the prompt text so
+      // prompt-based policies (sanitize-* on input, content checks) see it.
+      if (event.type === "message.updated") {
+        const props = event.properties || {};
+        const info = props.info || props.message || {};
+        const role = info.role || props.role;
+        if (role !== "user") return;
+        const sessionID = info.sessionID || info.sessionId || info.session_id || props.sessionID;
+        // OpenCode's message shape: parts is an array of {type, text, ...}.
+        // Concatenate text parts to reconstruct the user-facing prompt.
+        // Fall back to direct text/content fields if a future shape differs.
+        let prompt = "";
+        const parts = info.parts || props.parts || [];
+        if (Array.isArray(parts)) {
+          for (const p of parts) {
+            if (p && typeof p === "object" && typeof p.text === "string") prompt += p.text;
+          }
+        }
+        if (!prompt) prompt = (info.text || info.content || props.text || "").toString();
+        const r = runFailproofai("UserPromptSubmit", {
+          session_id: sessionID, cwd: directory, hook_event_name: "UserPromptSubmit", prompt,
+        }, directory);
+        applyDecision(r, { client, sessionID });
+        return;
+      }
+
+      const claudeEvent = BUS_EVENT_MAP[event.type];
+      if (!claudeEvent) return;
+      const props = event.properties || {};
+      const sessionID = props.sessionID || (props.session && props.session.id) || props.id;
+      const r = runFailproofai(claudeEvent, {
+        session_id: sessionID, cwd: directory, hook_event_name: claudeEvent,
+      }, directory);
+      applyDecision(r, { client, sessionID });
+    },
+
+    // First-class PreToolUse hook. Note: tool args live on output.args (mutable).
+    "tool.execute.before": async (input, output) => {
+      const r = runFailproofai("PreToolUse", {
+        session_id: input.sessionID,
+        cwd: directory,
+        tool_name: input.tool,
+        tool_input: output.args,
+        hook_event_name: "PreToolUse",
+      }, directory);
+      applyDecision(r, { client, sessionID: input.sessionID });
+    },
+
+    // First-class PostToolUse hook. Note: tool args live on input.args here.
+    "tool.execute.after": async (input, output) => {
+      const r = runFailproofai("PostToolUse", {
+        session_id: input.sessionID,
+        cwd: directory,
+        tool_name: input.tool,
+        tool_input: input.args,
+        tool_response: { title: output.title, output: output.output, metadata: output.metadata },
+        hook_event_name: "PostToolUse",
+      }, directory);
+      applyDecision(r, { client, sessionID: input.sessionID });
+    },
+
+    // Cleaner deny UX for prompted tools — mutate output.status instead of throwing.
+    "permission.ask": async (input, output) => {
+      const r = runFailproofai("PermissionRequest", {
+        session_id: input.sessionID,
+        cwd: directory,
+        tool_name: input.tool || input.command || "permission",
+        tool_input: input,
+        hook_event_name: "PermissionRequest",
+      }, directory);
+      try {
+        applyDecision(r, { client, sessionID: input.sessionID });
+      } catch {
+        output.status = "deny";
+      }
+    },
+  };
+}
+`;
+}
+function getPiExtensionPath() {
+  const fromEnv = process.env.FAILPROOFAI_PACKAGE_ROOT;
+  if (fromEnv)
+    return resolve6(fromEnv, "pi-extension");
+  return resolve6(fileURLToPath(import.meta.url), "..", "..", "..", "pi-extension");
+}
+function isFailproofaiPiEntry(source) {
+  if (typeof source !== "string")
+    return false;
+  if (/(?:^|\/)pi-extension\/?$/.test(source))
+    return true;
+  return source.includes("pi-extension") && source.includes("failproofai");
+}
+function makePiProjectRelativeEntry(extPath) {
+  const cwd = process.cwd();
+  const cwdResolved = resolve6(cwd);
+  const extResolved = resolve6(extPath);
+  if (extResolved.startsWith(cwdResolved + "/") || extResolved === cwdResolved) {
+    const fromSettingsDir = "../" + extResolved.slice(cwdResolved.length + 1);
+    return fromSettingsDir;
+  }
+  return extResolved;
+}
 function getIntegration(id) {
   const integration = INTEGRATIONS[id];
   if (!integration) {
@@ -4587,7 +6046,7 @@ function getIntegration(id) {
 function detectInstalledClis() {
   return INTEGRATION_TYPES.filter((id) => INTEGRATIONS[id].detectInstalled());
 }
-var claudeCode, codex, INTEGRATIONS;
+var claudeCode, codex, copilot, cursor, OPENCODE_PLUGIN_REL_PATH = "./plugins/failproofai.mjs", opencode, pi, gemini, INTEGRATIONS;
 var init_integrations = __esm(() => {
   init_types();
   claudeCode = {
@@ -4599,34 +6058,262 @@ var init_integrations = __esm(() => {
       const base = cwd ? resolve6(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir14(), ".claude", "settings.json");
+          return resolve6(homedir18(), ".claude", "settings.json");
+        case "project":
+          return resolve6(base, ".claude", "settings.json");
+        case "local":
+          return resolve6(base, ".claude", "settings.local.json");
+      }
+    },
+    readSettings(settingsPath) {
+      return readJsonFile(settingsPath);
+    },
+    writeSettings(settingsPath, settings) {
+      writeJsonFile(settingsPath, settings);
+    },
+    buildHookEntry(binaryPath, eventType, scope) {
+      const command = scope === "project" ? `npx -y failproofai --hook ${eventType}` : `"${binaryPath}" --hook ${eventType}`;
+      return {
+        type: "command",
+        command,
+        timeout: 60000,
+        [FAILPROOFAI_HOOK_MARKER]: true
+      };
+    },
+    isFailproofaiHook: isMarkedHook,
+    writeHookEntries(settings, binaryPath, scope) {
+      const s = settings;
+      if (!s.hooks)
+        s.hooks = {};
+      for (const eventType of HOOK_EVENT_TYPES) {
+        const hookEntry = this.buildHookEntry(binaryPath, eventType, scope);
+        if (!s.hooks[eventType])
+          s.hooks[eventType] = [];
+        const matchers = s.hooks[eventType];
+        let found = false;
+        for (const matcher of matchers) {
+          if (!matcher.hooks)
+            continue;
+          const idx = matcher.hooks.findIndex((h) => isMarkedHook(h));
+          if (idx >= 0) {
+            matcher.hooks[idx] = hookEntry;
+            found = true;
+            break;
+          }
+        }
+        if (!found)
+          matchers.push({ hooks: [hookEntry] });
+      }
+    },
+    removeHooksFromFile(settingsPath) {
+      const settings = this.readSettings(settingsPath);
+      if (!settings.hooks)
+        return 0;
+      let removed = 0;
+      for (const eventType of Object.keys(settings.hooks)) {
+        const matchers = settings.hooks[eventType];
+        if (!Array.isArray(matchers))
+          continue;
+        for (let i = matchers.length - 1;i >= 0; i--) {
+          const matcher = matchers[i];
+          if (!matcher.hooks)
+            continue;
+          const before = matcher.hooks.length;
+          matcher.hooks = matcher.hooks.filter((h) => !isMarkedHook(h));
+          removed += before - matcher.hooks.length;
+          if (matcher.hooks.length === 0)
+            matchers.splice(i, 1);
+        }
+        if (matchers.length === 0)
+          delete settings.hooks[eventType];
+      }
+      if (Object.keys(settings.hooks).length === 0)
+        delete settings.hooks;
+      this.writeSettings(settingsPath, settings);
+      return removed;
+    },
+    hooksInstalledInSettings(scope, cwd) {
+      const settingsPath = this.getSettingsPath(scope, cwd);
+      if (!existsSync11(settingsPath))
+        return false;
+      try {
+        const settings = this.readSettings(settingsPath);
+        if (!settings.hooks)
+          return false;
+        for (const matchers of Object.values(settings.hooks)) {
+          if (!Array.isArray(matchers))
+            continue;
+          for (const matcher of matchers) {
+            if (!matcher.hooks)
+              continue;
+            if (matcher.hooks.some((h) => isMarkedHook(h)))
+              return true;
+          }
+        }
+      } catch {}
+      return false;
+    },
+    detectInstalled() {
+      return binaryExists("claude") || binaryExists("claude-code");
+    }
+  };
+  codex = {
+    id: "codex",
+    displayName: "OpenAI Codex",
+    scopes: CODEX_HOOK_SCOPES,
+    eventTypes: CODEX_HOOK_EVENT_TYPES,
+    getSettingsPath(scope, cwd) {
+      const base = cwd ? resolve6(cwd) : process.cwd();
+      switch (scope) {
+        case "user":
+          return resolve6(homedir18(), ".codex", "hooks.json");
+        case "project":
+          return resolve6(base, ".codex", "hooks.json");
+        case "local":
+          return resolve6(base, ".codex", "hooks.json");
+      }
+    },
+    readSettings(settingsPath) {
+      const raw = readJsonFile(settingsPath);
+      if (raw.version === undefined)
+        raw.version = 1;
+      return raw;
+    },
+    writeSettings(settingsPath, settings) {
+      writeJsonFile(settingsPath, settings);
+    },
+    buildHookEntry(binaryPath, eventType, scope) {
+      const command = scope === "project" ? `npx -y failproofai --hook ${eventType} --cli codex` : `"${binaryPath}" --hook ${eventType} --cli codex`;
+      return {
+        type: "command",
+        command,
+        timeout: 60000,
+        [FAILPROOFAI_HOOK_MARKER]: true
+      };
+    },
+    isFailproofaiHook: isMarkedHook,
+    writeHookEntries(settings, binaryPath, scope) {
+      const s = settings;
+      if (s.version === undefined)
+        s.version = 1;
+      if (!s.hooks)
+        s.hooks = {};
+      for (const eventType of CODEX_HOOK_EVENT_TYPES) {
+        const pascalKey = CODEX_EVENT_MAP[eventType];
+        const hookEntry = this.buildHookEntry(binaryPath, eventType, scope);
+        if (!s.hooks[pascalKey])
+          s.hooks[pascalKey] = [];
+        const matchers = s.hooks[pascalKey];
+        let found = false;
+        for (const matcher of matchers) {
+          if (!matcher.hooks)
+            continue;
+          const idx = matcher.hooks.findIndex((h) => isMarkedHook(h));
+          if (idx >= 0) {
+            matcher.hooks[idx] = hookEntry;
+            found = true;
+            break;
+          }
+        }
+        if (!found)
+          matchers.push({ hooks: [hookEntry] });
+      }
+    },
+    removeHooksFromFile(settingsPath) {
+      const settings = this.readSettings(settingsPath);
+      if (!settings.hooks)
+        return 0;
+      let removed = 0;
+      for (const eventType of Object.keys(settings.hooks)) {
+        const matchers = settings.hooks[eventType];
+        if (!Array.isArray(matchers))
+          continue;
+        for (let i = matchers.length - 1;i >= 0; i--) {
+          const matcher = matchers[i];
+          if (!matcher.hooks)
+            continue;
+          const before = matcher.hooks.length;
+          matcher.hooks = matcher.hooks.filter((h) => !isMarkedHook(h));
+          removed += before - matcher.hooks.length;
+          if (matcher.hooks.length === 0)
+            matchers.splice(i, 1);
+        }
+        if (matchers.length === 0)
+          delete settings.hooks[eventType];
+      }
+      if (Object.keys(settings.hooks).length === 0)
+        delete settings.hooks;
+      this.writeSettings(settingsPath, settings);
+      return removed;
+    },
+    hooksInstalledInSettings(scope, cwd) {
+      const settingsPath = this.getSettingsPath(scope, cwd);
+      if (!existsSync11(settingsPath))
+        return false;
+      try {
+        const settings = this.readSettings(settingsPath);
+        if (!settings.hooks)
+          return false;
+        for (const matchers of Object.values(settings.hooks)) {
+          if (!Array.isArray(matchers))
+            continue;
+          for (const matcher of matchers) {
+            if (!matcher.hooks)
+              continue;
+            if (matcher.hooks.some((h) => isMarkedHook(h)))
+              return true;
+          }
+        }
+      } catch {}
+      return false;
+    },
+    detectInstalled() {
+      return binaryExists("codex");
+    }
+  };
+  copilot = {
+    id: "copilot",
+    displayName: "GitHub Copilot",
+    scopes: COPILOT_HOOK_SCOPES,
+    eventTypes: COPILOT_HOOK_EVENT_TYPES,
+    getSettingsPath(scope, cwd) {
+      const base = cwd ? resolve6(cwd) : process.cwd();
+      switch (scope) {
+        case "user":
+          return resolve6(homedir18(), ".copilot", "hooks", "failproofai.json");
         case "project":
-          return resolve6(base, ".claude", "settings.json");
+          return resolve6(base, ".github", "hooks", "failproofai.json");
         case "local":
-          return resolve6(base, ".claude", "settings.local.json");
+          return resolve6(base, ".github", "hooks", "failproofai.json");
       }
     },
     readSettings(settingsPath) {
-      return readJsonFile(settingsPath);
+      const raw = readJsonFile(settingsPath);
+      if (raw.version === undefined)
+        raw.version = 1;
+      return raw;
     },
     writeSettings(settingsPath, settings) {
       writeJsonFile(settingsPath, settings);
     },
     buildHookEntry(binaryPath, eventType, scope) {
-      const command = scope === "project" ? `npx -y failproofai --hook ${eventType}` : `"${binaryPath}" --hook ${eventType}`;
+      const cmd = scope === "project" ? `npx -y failproofai --hook ${eventType} --cli copilot` : `"${binaryPath}" --hook ${eventType} --cli copilot`;
       return {
         type: "command",
-        command,
-        timeout: 60000,
+        bash: cmd,
+        powershell: cmd,
+        timeoutSec: 60,
         [FAILPROOFAI_HOOK_MARKER]: true
       };
     },
-    isFailproofaiHook: isMarkedHook,
+    isFailproofaiHook: isMarkedCopilotHook,
     writeHookEntries(settings, binaryPath, scope) {
       const s = settings;
+      if (s.version === undefined)
+        s.version = 1;
       if (!s.hooks)
         s.hooks = {};
-      for (const eventType of HOOK_EVENT_TYPES) {
+      for (const eventType of COPILOT_HOOK_EVENT_TYPES) {
         const hookEntry = this.buildHookEntry(binaryPath, eventType, scope);
         if (!s.hooks[eventType])
           s.hooks[eventType] = [];
@@ -4635,7 +6322,7 @@ var init_integrations = __esm(() => {
         for (const matcher of matchers) {
           if (!matcher.hooks)
             continue;
-          const idx = matcher.hooks.findIndex((h) => isMarkedHook(h));
+          const idx = matcher.hooks.findIndex((h) => isMarkedCopilotHook(h));
           if (idx >= 0) {
             matcher.hooks[idx] = hookEntry;
             found = true;
@@ -4660,7 +6347,7 @@ var init_integrations = __esm(() => {
           if (!matcher.hooks)
             continue;
           const before = matcher.hooks.length;
-          matcher.hooks = matcher.hooks.filter((h) => !isMarkedHook(h));
+          matcher.hooks = matcher.hooks.filter((h) => !isMarkedCopilotHook(h));
           removed += before - matcher.hooks.length;
           if (matcher.hooks.length === 0)
             matchers.splice(i, 1);
@@ -4687,7 +6374,7 @@ var init_integrations = __esm(() => {
           for (const matcher of matchers) {
             if (!matcher.hooks)
               continue;
-            if (matcher.hooks.some((h) => isMarkedHook(h)))
+            if (matcher.hooks.some((h) => isMarkedCopilotHook(h)))
               return true;
           }
         }
@@ -4695,23 +6382,23 @@ var init_integrations = __esm(() => {
       return false;
     },
     detectInstalled() {
-      return binaryExists("claude") || binaryExists("claude-code");
+      return binaryExists("copilot");
     }
   };
-  codex = {
-    id: "codex",
-    displayName: "OpenAI Codex",
-    scopes: CODEX_HOOK_SCOPES,
-    eventTypes: CODEX_HOOK_EVENT_TYPES,
+  cursor = {
+    id: "cursor",
+    displayName: "Cursor Agent",
+    scopes: CURSOR_HOOK_SCOPES,
+    eventTypes: CURSOR_HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
       const base = cwd ? resolve6(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve6(homedir14(), ".codex", "hooks.json");
+          return resolve6(homedir18(), ".cursor", "hooks.json");
         case "project":
-          return resolve6(base, ".codex", "hooks.json");
+          return resolve6(base, ".cursor", "hooks.json");
         case "local":
-          return resolve6(base, ".codex", "hooks.json");
+          return resolve6(base, ".cursor", "hooks.json");
       }
     },
     readSettings(settingsPath) {
@@ -4724,7 +6411,7 @@ var init_integrations = __esm(() => {
       writeJsonFile(settingsPath, settings);
     },
     buildHookEntry(binaryPath, eventType, scope) {
-      const command = scope === "project" ? `npx -y failproofai --hook ${eventType} --cli codex` : `"${binaryPath}" --hook ${eventType} --cli codex`;
+      const command = scope === "project" ? `npx -y failproofai --hook ${eventType} --cli cursor` : `"${binaryPath}" --hook ${eventType} --cli cursor`;
       return {
         type: "command",
         command,
@@ -4739,12 +6426,291 @@ var init_integrations = __esm(() => {
         s.version = 1;
       if (!s.hooks)
         s.hooks = {};
-      for (const eventType of CODEX_HOOK_EVENT_TYPES) {
-        const pascalKey = CODEX_EVENT_MAP[eventType];
+      for (const eventType of CURSOR_HOOK_EVENT_TYPES) {
         const hookEntry = this.buildHookEntry(binaryPath, eventType, scope);
-        if (!s.hooks[pascalKey])
-          s.hooks[pascalKey] = [];
-        const matchers = s.hooks[pascalKey];
+        const existing = s.hooks[eventType];
+        const entries = existing ?? [];
+        if (!existing)
+          s.hooks[eventType] = entries;
+        const idx = entries.findIndex((h) => isMarkedHook(h));
+        if (idx >= 0) {
+          entries[idx] = hookEntry;
+        } else {
+          entries.push(hookEntry);
+        }
+      }
+    },
+    removeHooksFromFile(settingsPath) {
+      const settings = this.readSettings(settingsPath);
+      if (!settings.hooks)
+        return 0;
+      let removed = 0;
+      for (const eventType of Object.keys(settings.hooks)) {
+        const entries = settings.hooks[eventType];
+        if (!Array.isArray(entries))
+          continue;
+        const before = entries.length;
+        const filtered = entries.filter((h) => !isMarkedHook(h));
+        removed += before - filtered.length;
+        if (filtered.length === 0) {
+          delete settings.hooks[eventType];
+        } else {
+          settings.hooks[eventType] = filtered;
+        }
+      }
+      if (Object.keys(settings.hooks).length === 0)
+        delete settings.hooks;
+      this.writeSettings(settingsPath, settings);
+      return removed;
+    },
+    hooksInstalledInSettings(scope, cwd) {
+      const settingsPath = this.getSettingsPath(scope, cwd);
+      if (!existsSync11(settingsPath))
+        return false;
+      try {
+        const settings = this.readSettings(settingsPath);
+        if (!settings.hooks)
+          return false;
+        for (const entries of Object.values(settings.hooks)) {
+          if (!Array.isArray(entries))
+            continue;
+          if (entries.some((h) => isMarkedHook(h)))
+            return true;
+        }
+      } catch {}
+      return false;
+    },
+    detectInstalled() {
+      return binaryExists("cursor-agent") || binaryExists("agent");
+    }
+  };
+  opencode = {
+    id: "opencode",
+    displayName: "OpenCode",
+    scopes: OPENCODE_HOOK_SCOPES,
+    eventTypes: OPENCODE_HOOK_EVENT_TYPES,
+    getSettingsPath(scope, cwd) {
+      const base = cwd ? resolve6(cwd) : process.cwd();
+      switch (scope) {
+        case "user":
+          return resolve6(homedir18(), ".config", "opencode", "opencode.json");
+        case "project":
+          return resolve6(base, ".opencode", "opencode.json");
+        case "local":
+          return resolve6(base, ".opencode", "opencode.json");
+      }
+    },
+    readSettings(settingsPath) {
+      return readJsonFile(settingsPath);
+    },
+    writeSettings(settingsPath, settings) {
+      writeJsonFile(settingsPath, settings);
+    },
+    buildHookEntry(_binaryPath, _eventType, scope) {
+      if (scope === "user") {
+        const abs = resolve6(homedir18(), ".config", "opencode", "plugins", "failproofai.mjs");
+        return { spec: `file://${abs}`, [FAILPROOFAI_HOOK_MARKER]: true };
+      }
+      return { spec: OPENCODE_PLUGIN_REL_PATH, [FAILPROOFAI_HOOK_MARKER]: true };
+    },
+    isFailproofaiHook(hook) {
+      if (typeof hook === "string")
+        return hook.includes("failproofai.mjs");
+      if (Array.isArray(hook))
+        return typeof hook[0] === "string" && hook[0].includes("failproofai.mjs");
+      return false;
+    },
+    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 pluginPath = opencodePluginFilePath(settingsPath);
+      mkdirSync8(dirname5(pluginPath), { recursive: true });
+      writeFileSync6(pluginPath, buildOpenCodePluginShim(binaryPath, effectiveScope), "utf8");
+      if (!Array.isArray(s.plugin))
+        s.plugin = [];
+      const desired = effectiveScope === "user" ? `file://${pluginPath}` : OPENCODE_PLUGIN_REL_PATH;
+      const idx = s.plugin.findIndex((entry) => this.isFailproofaiHook(entry));
+      if (idx >= 0) {
+        s.plugin[idx] = desired;
+      } else {
+        s.plugin.push(desired);
+      }
+    },
+    removeHooksFromFile(settingsPath) {
+      let removed = 0;
+      const settings = this.readSettings(settingsPath);
+      if (Array.isArray(settings.plugin)) {
+        const before = settings.plugin.length;
+        settings.plugin = settings.plugin.filter((entry) => !this.isFailproofaiHook(entry));
+        removed += before - settings.plugin.length;
+        if (settings.plugin.length === 0)
+          delete settings.plugin;
+      }
+      this.writeSettings(settingsPath, settings);
+      const pluginPath = opencodePluginFilePath(settingsPath);
+      if (existsSync11(pluginPath)) {
+        try {
+          const content = readFileSync8(pluginPath, "utf8");
+          if (content.includes(FAILPROOFAI_HOOK_MARKER)) {
+            unlinkSync5(pluginPath);
+            if (removed === 0)
+              removed = 1;
+          }
+        } catch {}
+      }
+      return removed;
+    },
+    hooksInstalledInSettings(scope, cwd) {
+      const settingsPath = this.getSettingsPath(scope, cwd);
+      if (!existsSync11(settingsPath))
+        return false;
+      try {
+        const settings = this.readSettings(settingsPath);
+        if (!Array.isArray(settings.plugin))
+          return false;
+        const hasEntry = settings.plugin.some((entry) => this.isFailproofaiHook(entry));
+        if (!hasEntry)
+          return false;
+        const pluginPath = opencodePluginFilePath(settingsPath);
+        if (!existsSync11(pluginPath))
+          return false;
+        const content = readFileSync8(pluginPath, "utf8");
+        return content.includes(FAILPROOFAI_HOOK_MARKER);
+      } catch {
+        return false;
+      }
+    },
+    detectInstalled() {
+      return binaryExists("opencode");
+    }
+  };
+  pi = {
+    id: "pi",
+    displayName: "Pi",
+    scopes: PI_HOOK_SCOPES,
+    eventTypes: PI_HOOK_EVENT_TYPES,
+    getSettingsPath(scope, cwd) {
+      const base = cwd ? resolve6(cwd) : process.cwd();
+      switch (scope) {
+        case "user":
+          return resolve6(homedir18(), ".pi", "agent", "settings.json");
+        case "project":
+          return resolve6(base, ".pi", "settings.json");
+        case "local":
+          return resolve6(base, ".pi", "settings.json");
+      }
+    },
+    readSettings(settingsPath) {
+      return readJsonFile(settingsPath);
+    },
+    writeSettings(settingsPath, settings) {
+      writeJsonFile(settingsPath, settings);
+    },
+    buildHookEntry(_binaryPath, _eventType, scope) {
+      return {
+        [FAILPROOFAI_HOOK_MARKER]: true,
+        _piPackagePath: getPiExtensionPath(),
+        _piScope: scope
+      };
+    },
+    isFailproofaiHook(hook) {
+      if (typeof hook === "string")
+        return isFailproofaiPiEntry(hook);
+      if (!hook || typeof hook !== "object")
+        return false;
+      const h = hook;
+      if (h[FAILPROOFAI_HOOK_MARKER] === true)
+        return true;
+      if (typeof h.source === "string")
+        return isFailproofaiPiEntry(h.source);
+      return false;
+    },
+    writeHookEntries(settings, _binaryPath, scope) {
+      const s = settings;
+      if (!Array.isArray(s.packages))
+        s.packages = [];
+      const extPath = getPiExtensionPath();
+      const entry = scope === "project" ? makePiProjectRelativeEntry(extPath) : extPath;
+      const idx = s.packages.findIndex((p) => isFailproofaiPiEntry(p));
+      if (idx >= 0) {
+        s.packages[idx] = entry;
+      } else {
+        s.packages.push(entry);
+      }
+    },
+    removeHooksFromFile(settingsPath) {
+      if (!existsSync11(settingsPath))
+        return 0;
+      const settings = this.readSettings(settingsPath);
+      if (!Array.isArray(settings.packages))
+        return 0;
+      const before = settings.packages.length;
+      settings.packages = settings.packages.filter((p) => !isFailproofaiPiEntry(p));
+      const removed = before - settings.packages.length;
+      if (settings.packages.length === 0)
+        delete settings.packages;
+      this.writeSettings(settingsPath, settings);
+      return removed;
+    },
+    hooksInstalledInSettings(scope, cwd) {
+      const settingsPath = this.getSettingsPath(scope, cwd);
+      if (!existsSync11(settingsPath))
+        return false;
+      try {
+        const settings = this.readSettings(settingsPath);
+        if (!Array.isArray(settings.packages))
+          return false;
+        return settings.packages.some((p) => isFailproofaiPiEntry(p));
+      } catch {
+        return false;
+      }
+    },
+    detectInstalled() {
+      return binaryExists("pi");
+    }
+  };
+  gemini = {
+    id: "gemini",
+    displayName: "Gemini CLI",
+    scopes: GEMINI_HOOK_SCOPES,
+    eventTypes: GEMINI_HOOK_EVENT_TYPES,
+    getSettingsPath(scope, cwd) {
+      const base = cwd ? resolve6(cwd) : process.cwd();
+      switch (scope) {
+        case "user":
+          return resolve6(homedir18(), ".gemini", "settings.json");
+        case "project":
+          return resolve6(base, ".gemini", "settings.json");
+        case "local":
+          return resolve6(base, ".gemini", "settings.json");
+      }
+    },
+    readSettings(settingsPath) {
+      return readJsonFile(settingsPath);
+    },
+    writeSettings(settingsPath, settings) {
+      writeJsonFile(settingsPath, settings);
+    },
+    buildHookEntry(binaryPath, eventType, scope) {
+      const command = scope === "project" ? `npx -y failproofai --hook ${eventType} --cli gemini` : `"${binaryPath}" --hook ${eventType} --cli gemini`;
+      return {
+        type: "command",
+        command,
+        timeout: 60000,
+        [FAILPROOFAI_HOOK_MARKER]: true
+      };
+    },
+    isFailproofaiHook: isMarkedHook,
+    writeHookEntries(settings, binaryPath, scope) {
+      const s = settings;
+      if (!s.hooks)
+        s.hooks = {};
+      for (const eventType of GEMINI_HOOK_EVENT_TYPES) {
+        const hookEntry = this.buildHookEntry(binaryPath, eventType, scope);
+        if (!s.hooks[eventType])
+          s.hooks[eventType] = [];
+        const matchers = s.hooks[eventType];
         let found = false;
         for (const matcher of matchers) {
           if (!matcher.hooks)
@@ -4757,7 +6723,7 @@ var init_integrations = __esm(() => {
           }
         }
         if (!found)
-          matchers.push({ hooks: [hookEntry] });
+          matchers.push({ matcher: "*", hooks: [hookEntry] });
       }
     },
     removeHooksFromFile(settingsPath) {
@@ -4809,12 +6775,17 @@ var init_integrations = __esm(() => {
       return false;
     },
     detectInstalled() {
-      return binaryExists("codex");
+      return binaryExists("gemini");
     }
   };
   INTEGRATIONS = {
     claude: claudeCode,
-    codex
+    codex,
+    copilot,
+    cursor,
+    opencode,
+    pi,
+    gemini
   };
 });
 
@@ -4838,7 +6809,7 @@ async function promptPolicySelection(preSelected, options = {}) {
   }));
   const total = items.length;
   const WINDOW_SIZE = 8;
-  let cursor = 0;
+  let cursor2 = 0;
   let search = "";
   let lastLineCount = 0;
   let cursorHidden = false;
@@ -4920,8 +6891,8 @@ async function promptPolicySelection(preSelected, options = {}) {
     hideCursor();
     const filtered = getFiltered();
     const shown = filtered.length;
-    if (shown > 0 && cursor >= shown)
-      cursor = shown - 1;
+    if (shown > 0 && cursor2 >= shown)
+      cursor2 = shown - 1;
     const lines = [];
     lines.push("  Failproof AI — Policy Manager");
     lines.push("");
@@ -4944,7 +6915,7 @@ async function promptPolicySelection(preSelected, options = {}) {
       let cursorDisplayRow = 0;
       for (let i = 0;i < displayRows.length; i++) {
         const row = displayRows[i];
-        if (row.kind === "item" && row.filteredIndex === cursor) {
+        if (row.kind === "item" && row.filteredIndex === cursor2) {
           cursorDisplayRow = i;
           break;
         }
@@ -4969,7 +6940,7 @@ async function promptPolicySelection(preSelected, options = {}) {
           lines.push(`  \x1B[2m${prefix}${label}${"─".repeat(dashLen)}\x1B[0m`);
         } else {
           const item = row.item;
-          const isActive = row.filteredIndex === cursor;
+          const isActive = row.filteredIndex === cursor2;
           const pointer = isActive ? "\x1B[36m❯\x1B[0m" : " ";
           const check = item.selected ? "\x1B[32m[✓]\x1B[0m" : "[ ]";
           const namePart = isActive ? `\x1B[1;36m${item.name}\x1B[0m` : item.name;
@@ -5021,22 +6992,22 @@ async function promptPolicySelection(preSelected, options = {}) {
       const filtered = getFiltered();
       if (key.name === "up") {
         if (filtered.length > 0) {
-          cursor = cursor > 0 ? cursor - 1 : filtered.length - 1;
+          cursor2 = cursor2 > 0 ? cursor2 - 1 : filtered.length - 1;
         }
         render();
       } else if (key.name === "down") {
         if (filtered.length > 0) {
-          cursor = cursor < filtered.length - 1 ? cursor + 1 : 0;
+          cursor2 = cursor2 < filtered.length - 1 ? cursor2 + 1 : 0;
         }
         render();
       } else if (key.name === "return" || key.name === "space") {
-        const item = filtered[cursor];
+        const item = filtered[cursor2];
         if (item)
           item.selected = !item.selected;
         render();
       } else if (key.name === "escape") {
         search = "";
-        cursor = 0;
+        cursor2 = 0;
         render();
       } else if (key.ctrl && key.name === "a") {
         const allSelected = filtered.length > 0 && filtered.every((i) => i.selected);
@@ -5052,12 +7023,12 @@ async function promptPolicySelection(preSelected, options = {}) {
       } else if (key.name === "backspace" || key.name === "delete") {
         if (search.length > 0) {
           search = search.slice(0, -1);
-          cursor = 0;
+          cursor2 = 0;
           render();
         }
       } else if (_str && _str.length === 1 && !key.ctrl && !key.meta) {
         search += _str;
-        cursor = 0;
+        cursor2 = 0;
         render();
       }
     }
@@ -5099,8 +7070,8 @@ __export(exports_manager, {
 });
 import { execSync as execSync4 } from "node:child_process";
 import { existsSync as existsSync12 } from "node:fs";
-import { resolve as resolve7, basename as basename2 } from "node:path";
-import { homedir as homedir15, platform, arch, release, hostname } from "node:os";
+import { resolve as resolve7, basename as basename3 } from "node:path";
+import { homedir as homedir19, platform, arch, release, hostname } from "node:os";
 function getSettingsPath(scope, cwd) {
   return claudeCode.getSettingsPath(scope, cwd);
 }
@@ -5518,7 +7489,7 @@ Failproof AI Hook Policies
   const base = cwd ? resolve7(cwd) : process.cwd();
   const conventionDirs = [
     { label: "Project", dir: resolve7(base, ".failproofai", "policies") },
-    { label: "User", dir: resolve7(homedir15(), ".failproofai", "policies") }
+    { label: "User", dir: resolve7(homedir19(), ".failproofai", "policies") }
   ];
   for (const { label, dir } of conventionDirs) {
     const files = discoverPolicyFiles(dir);
@@ -5530,15 +7501,15 @@ Failproof AI Hook Policies
       try {
         const hooks = await loadCustomHooks(file);
         if (hooks.length === 0) {
-          const filename = basename2(file);
+          const filename = basename3(file);
           console.log(`  \x1B[31m✗\x1B[0m       ${filename.padEnd(nameColWidth)}\x1B[31mfailed to load\x1B[0m`);
         } else {
-          const filename = basename2(file);
+          const filename = basename3(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 = basename2(file);
+        const filename = basename3(file);
         console.log(`  \x1B[31m✗\x1B[0m       ${filename.padEnd(nameColWidth)}\x1B[31merror\x1B[0m`);
       }
     }
@@ -5566,34 +7537,40 @@ __export(exports_install_prompt, {
   promptPolicySelection: () => promptPolicySelection2
 });
 import * as readline2 from "node:readline";
-async function resolveTargetClis(explicit) {
+async function resolveTargetClis(explicit, action = "install") {
   if (explicit && explicit.length > 0)
     return [...new Set(explicit)];
   const detected = detectInstalledClis();
   if (detected.length === 0) {
-    console.log("\x1B[33mWarning: no agent CLI binary found in PATH (claude, codex). " + "Defaulting to Claude Code; hooks will activate when an agent is installed.\x1B[0m");
+    if (action === "uninstall") {
+      console.log("\x1B[33mWarning: no agent CLI binary found in PATH (claude, codex, copilot, cursor-agent, opencode, pi, gemini). " + "Defaulting to Claude Code; nothing will be removed if no settings file exists.\x1B[0m");
+      return ["claude"];
+    }
+    console.log("\x1B[33mWarning: no agent CLI binary found in PATH (claude, codex, copilot, cursor-agent, opencode, pi, gemini). " + "Defaulting to Claude Code; hooks will activate when an agent is installed.\x1B[0m");
     return ["claude"];
   }
   if (detected.length === 1) {
     const integration = getIntegration(detected[0]);
-    console.log(`Detected ${integration.displayName}; installing hooks for it.`);
+    const verb = action === "uninstall" ? "removing hooks from" : "installing hooks for";
+    console.log(`Detected ${integration.displayName}; ${verb} it.`);
     return detected;
   }
   if (!process.stdin.isTTY)
     return detected;
-  return promptCliTargetSelection(detected);
+  return promptCliTargetSelection(detected, action);
 }
-async function promptCliTargetSelection(detected) {
+async function promptCliTargetSelection(detected, action = "install") {
   const labels = detected.map((id) => getIntegration(id).displayName).join(" + ");
+  const allLabel = detected.length > 2 ? "All" : "Both";
   const options = [
-    { label: "Both", description: labels, value: detected },
+    { label: allLabel, description: labels, value: detected },
     ...detected.map((id) => ({
       label: `${getIntegration(id).displayName} only`,
       description: "",
       value: [id]
     }))
   ];
-  let cursor = 0;
+  let cursor2 = 0;
   let lastLineCount = 0;
   let cursorHidden = false;
   function hideCursor() {
@@ -5630,17 +7607,19 @@ async function promptCliTargetSelection(detected) {
     }
     return result;
   }
+  const heading = action === "uninstall" ? "Remove Hooks" : "Install Hooks";
+  const verb = action === "uninstall" ? "remove from" : "install";
   function render() {
     const cols = process.stdout.columns || 120;
     hideCursor();
     const lines = [];
-    lines.push("  Failproof AI — Install Hooks");
+    lines.push(`  Failproof AI — ${heading}`);
     lines.push("");
-    lines.push(`  \x1B[2mDetected ${labels}. Choose where to install:\x1B[0m`);
+    lines.push(`  \x1B[2mDetected ${labels}. Choose where to ${verb}:\x1B[0m`);
     lines.push("");
     for (let i = 0;i < options.length; i++) {
       const opt = options[i];
-      const isActive = i === cursor;
+      const isActive = i === cursor2;
       const pointer = isActive ? "\x1B[36m❯\x1B[0m" : " ";
       const labelPart = isActive ? `\x1B[1;36m${opt.label}\x1B[0m` : opt.label;
       const pad = opt.description ? " ".repeat(Math.max(2, 22 - opt.label.length)) : "";
@@ -5683,16 +7662,16 @@ async function promptCliTargetSelection(detected) {
         process.exit(130);
       }
       if (key.name === "up") {
-        cursor = cursor > 0 ? cursor - 1 : options.length - 1;
+        cursor2 = cursor2 > 0 ? cursor2 - 1 : options.length - 1;
         render();
       } else if (key.name === "down") {
-        cursor = cursor < options.length - 1 ? cursor + 1 : 0;
+        cursor2 = cursor2 < options.length - 1 ? cursor2 + 1 : 0;
         render();
       } else if (key.name === "return" || key.name === "space") {
         cleanup();
         process.stdout.write(`
 `);
-        resolve8(options[cursor].value);
+        resolve8(options[cursor2].value);
       }
     }
     process.stdin.on("keypress", onKey);
@@ -5716,7 +7695,7 @@ async function promptPolicySelection2(preSelected, options = {}) {
   }));
   const total = items.length;
   const WINDOW_SIZE = 8;
-  let cursor = 0;
+  let cursor2 = 0;
   let search = "";
   let lastLineCount = 0;
   let cursorHidden = false;
@@ -5798,8 +7777,8 @@ async function promptPolicySelection2(preSelected, options = {}) {
     hideCursor();
     const filtered = getFiltered();
     const shown = filtered.length;
-    if (shown > 0 && cursor >= shown)
-      cursor = shown - 1;
+    if (shown > 0 && cursor2 >= shown)
+      cursor2 = shown - 1;
     const lines = [];
     lines.push("  Failproof AI — Policy Manager");
     lines.push("");
@@ -5822,7 +7801,7 @@ async function promptPolicySelection2(preSelected, options = {}) {
       let cursorDisplayRow = 0;
       for (let i = 0;i < displayRows.length; i++) {
         const row = displayRows[i];
-        if (row.kind === "item" && row.filteredIndex === cursor) {
+        if (row.kind === "item" && row.filteredIndex === cursor2) {
           cursorDisplayRow = i;
           break;
         }
@@ -5847,7 +7826,7 @@ async function promptPolicySelection2(preSelected, options = {}) {
           lines.push(`  \x1B[2m${prefix}${label}${"─".repeat(dashLen)}\x1B[0m`);
         } else {
           const item = row.item;
-          const isActive = row.filteredIndex === cursor;
+          const isActive = row.filteredIndex === cursor2;
           const pointer = isActive ? "\x1B[36m❯\x1B[0m" : " ";
           const check = item.selected ? "\x1B[32m[✓]\x1B[0m" : "[ ]";
           const namePart = isActive ? `\x1B[1;36m${item.name}\x1B[0m` : item.name;
@@ -5899,22 +7878,22 @@ async function promptPolicySelection2(preSelected, options = {}) {
       const filtered = getFiltered();
       if (key.name === "up") {
         if (filtered.length > 0) {
-          cursor = cursor > 0 ? cursor - 1 : filtered.length - 1;
+          cursor2 = cursor2 > 0 ? cursor2 - 1 : filtered.length - 1;
         }
         render();
       } else if (key.name === "down") {
         if (filtered.length > 0) {
-          cursor = cursor < filtered.length - 1 ? cursor + 1 : 0;
+          cursor2 = cursor2 < filtered.length - 1 ? cursor2 + 1 : 0;
         }
         render();
       } else if (key.name === "return" || key.name === "space") {
-        const item = filtered[cursor];
+        const item = filtered[cursor2];
         if (item)
           item.selected = !item.selected;
         render();
       } else if (key.name === "escape") {
         search = "";
-        cursor = 0;
+        cursor2 = 0;
         render();
       } else if (key.ctrl && key.name === "a") {
         const allSelected = filtered.length > 0 && filtered.every((i) => i.selected);
@@ -5930,12 +7909,12 @@ async function promptPolicySelection2(preSelected, options = {}) {
       } else if (key.name === "backspace" || key.name === "delete") {
         if (search.length > 0) {
           search = search.slice(0, -1);
-          cursor = 0;
+          cursor2 = 0;
           render();
         }
       } else if (_str && _str.length === 1 && !key.ctrl && !key.meta) {
         search += _str;
-        cursor = 0;
+        cursor2 = 0;
         render();
       }
     }
@@ -6088,9 +8067,9 @@ __export(exports_pid, {
   isProcessAlive: () => isProcessAlive2,
   clearPid: () => clearPid2
 });
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync13, unlinkSync as unlinkSync5, mkdirSync as mkdirSync9 } from "node:fs";
-import { join as join15, dirname as dirname6 } from "node:path";
-import { homedir as homedir16 } from "node:os";
+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";
 function readPid2() {
   if (!existsSync13(PID_FILE2))
     return null;
@@ -6112,7 +8091,7 @@ function writePid2(pid) {
 }
 function clearPid2() {
   if (existsSync13(PID_FILE2))
-    unlinkSync5(PID_FILE2);
+    unlinkSync6(PID_FILE2);
 }
 function isProcessAlive2(pid) {
   try {
@@ -6149,7 +8128,7 @@ function relayStatus() {
 }
 var PID_FILE2;
 var init_pid2 = __esm(() => {
-  PID_FILE2 = join15(homedir16(), ".failproofai", "relay.pid");
+  PID_FILE2 = join19(homedir20(), ".failproofai", "relay.pid");
 });
 
 // scripts/parse-script-args.ts
@@ -6215,15 +8194,147 @@ 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 { spawnSync } from "node:child_process";
+function findPackageRoot(start) {
+  try {
+    let dir = realpathSync(start);
+    if (existsSync14(dir) && !existsSync14(resolve9(dir, "package.json"))) {
+      dir = dirname7(dir);
+    }
+    while (true) {
+      const pkgPath = resolve9(dir, "package.json");
+      if (existsSync14(pkgPath)) {
+        try {
+          const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
+          if (pkg.name === PKG_NAME)
+            return dir;
+        } catch {}
+      }
+      const parent = dirname7(dir);
+      if (parent === dir)
+        return null;
+      dir = parent;
+    }
+  } catch {
+    return null;
+  }
+}
+function readPackageVersion(packageRoot) {
+  if (!packageRoot)
+    return null;
+  try {
+    const pkg = JSON.parse(readFileSync10(resolve9(packageRoot, "package.json"), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function resolvePathFirstBinary() {
+  try {
+    const isWin = platform3() === "win32";
+    const res = isWin ? spawnSync("where", [PKG_NAME], { encoding: "utf8" }) : spawnSync("sh", ["-c", `command -v ${PKG_NAME}`], { encoding: "utf8" });
+    if (res.status !== 0)
+      return null;
+    const first = (res.stdout || "").split(/\r?\n/).find((l) => l.trim().length > 0);
+    return first ? first.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function locateNpmGlobal() {
+  try {
+    const res = spawnSync("npm", ["root", "-g"], { encoding: "utf8" });
+    if (res.status !== 0)
+      return null;
+    const root = (res.stdout || "").trim();
+    if (!root)
+      return null;
+    const candidate = resolve9(root, PKG_NAME);
+    return existsSync14(resolve9(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;
+  } catch {
+    return null;
+  }
+}
+function buildRecommendation(pathFirstBin) {
+  if (!pathFirstBin)
+    return null;
+  const bunBinPrefix = resolve9(homedir21(), ".bun", "bin") + "/";
+  const bunGlobalPrefix = resolve9(homedir21(), ".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}`;
+  }
+  return `npm rm -g ${PKG_NAME}`;
+}
+function diagnoseShadow(self) {
+  const selfPackageRoot = (() => {
+    try {
+      return self?.selfPackageRoot ? realpathSync(self.selfPackageRoot) : null;
+    } catch {
+      return self?.selfPackageRoot ?? null;
+    }
+  })();
+  const selfVersion = self?.selfVersion ?? null;
+  const pathFirstBin = resolvePathFirstBinary();
+  const pathFirstPackageRoot = pathFirstBin ? findPackageRoot(pathFirstBin) : null;
+  const pathFirstVersion = readPackageVersion(pathFirstPackageRoot);
+  const npmGlobalPath = locateNpmGlobal();
+  const npmGlobalVersion = readPackageVersion(npmGlobalPath);
+  const bunGlobalPath = locateBunGlobal();
+  const bunGlobalVersion = readPackageVersion(bunGlobalPath);
+  let shadowed = false;
+  if (selfPackageRoot && pathFirstPackageRoot && pathFirstPackageRoot !== selfPackageRoot) {
+    shadowed = true;
+  } else if (pathFirstPackageRoot) {
+    if (npmGlobalPath && npmGlobalPath !== pathFirstPackageRoot)
+      shadowed = true;
+    else if (bunGlobalPath && bunGlobalPath !== pathFirstPackageRoot)
+      shadowed = true;
+  }
+  const recommendation = shadowed ? buildRecommendation(pathFirstBin) : null;
+  let shadowDescription = null;
+  if (shadowed) {
+    shadowDescription = `PATH resolves to ${pathFirstPackageRoot}` + (pathFirstVersion ? ` (v${pathFirstVersion})` : "") + `, but you just installed ${selfPackageRoot}` + (selfVersion ? ` (v${selfVersion})` : "") + ".";
+  }
+  return {
+    selfPackageRoot,
+    selfVersion,
+    pathFirstBin,
+    pathFirstPath: pathFirstPackageRoot,
+    pathFirstVersion,
+    npmGlobalPath,
+    npmGlobalVersion,
+    bunGlobalPath,
+    bunGlobalVersion,
+    shadowed,
+    shadowDescription,
+    recommendation
+  };
+}
+var PKG_NAME = "failproofai";
+var init_install_diagnosis = () => {};
+
 // scripts/launch.ts
 var exports_launch = {};
 __export(exports_launch, {
   launch: () => launch
 });
 import { spawn as spawn4 } from "child_process";
-import { realpathSync, existsSync as existsSync14 } from "node:fs";
-import { resolve as resolve9, dirname as dirname7 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { realpathSync as realpathSync2, existsSync as existsSync15 } from "node:fs";
+import { resolve as resolve10, 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));
   console.log(`
@@ -6254,10 +8365,27 @@ function launch(mode) {
     process.env.PORT = port;
     process.env.HOSTNAME = "0.0.0.0";
     cmd = "node";
-    const packageRoot = process.env.FAILPROOFAI_PACKAGE_ROOT ?? resolve9(dirname7(realpathSync(fileURLToPath(import.meta.url))), "..");
-    const serverJsPath = resolve9(packageRoot, ".next/standalone/server.js");
-    if (!existsSync14(serverJsPath)) {
-      console.error(`
+    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)) {
+      let shadowMessage = null;
+      try {
+        const diag = diagnoseShadow({ selfPackageRoot: packageRoot, selfVersion: version2 });
+        if (diag.shadowed) {
+          const alt = (diag.npmGlobalPath && diag.npmGlobalPath !== diag.pathFirstPath ? { path: diag.npmGlobalPath, version: diag.npmGlobalVersion } : null) ?? (diag.bunGlobalPath && diag.bunGlobalPath !== diag.pathFirstPath ? { path: diag.bunGlobalPath, version: diag.bunGlobalVersion } : null);
+          const newer = alt?.path ?? "(unknown)";
+          const newerVer = alt?.version ?? "?";
+          shadowMessage = `
+Error: failproofai on your PATH is a stale install that no longer has its build output.
+` + `  Running:    ${diag.pathFirstPath}` + (diag.pathFirstVersion ? `  (v${diag.pathFirstVersion})` : "") + `
+` + `  Newer copy: ${newer}  (v${newerVer})
+
+` + `Remove the shadow with:
+  ${diag.recommendation}
+`;
+        }
+      } catch {}
+      console.error(shadowMessage ?? `
 Error: Cannot find server.js at:
   ${serverJsPath}
 
@@ -6293,6 +8421,7 @@ Error: Cannot find server.js at:
 var init_launch = __esm(() => {
   init_paths();
   init_parse_script_args();
+  init_install_diagnosis();
   init_package();
 });
 
@@ -6314,18 +8443,18 @@ var init_cli_error2 = __esm(() => {
 });
 
 // bin/failproofai.mjs
-import { realpathSync as realpathSync2 } from "fs";
-import { dirname as dirname8, resolve as resolve10 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { realpathSync as realpathSync3 } from "fs";
+import { dirname as dirname9, resolve as resolve11 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 // package.json
-var version = "0.0.9";
+var version = "0.0.10-beta.1";
 
 // bin/failproofai.mjs
 if (!process.env.FAILPROOFAI_PACKAGE_ROOT) {
-  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve10(dirname8(realpathSync2(fileURLToPath2(import.meta.url))), "..");
+  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve11(dirname9(realpathSync3(fileURLToPath3(import.meta.url))), "..");
 }
 if (!process.env.FAILPROOFAI_DIST_PATH) {
-  process.env.FAILPROOFAI_DIST_PATH = resolve10(dirname8(realpathSync2(fileURLToPath2(import.meta.url))), "..", "dist");
+  process.env.FAILPROOFAI_DIST_PATH = resolve11(dirname9(realpathSync3(fileURLToPath3(import.meta.url))), "..", "dist");
 }
 var args = process.argv.slice(2);
 if (args[0] === "p")
@@ -6334,13 +8463,13 @@ var hookIdx = args.indexOf("--hook");
 if (hookIdx >= 0) {
   if (!args[hookIdx + 1]) {
     console.error("Error: Missing event type after --hook");
-    console.error("Usage: failproofai --hook <event> [--cli <claude|codex>]");
+    console.error("Usage: failproofai --hook <event> [--cli <claude|codex|copilot|cursor|opencode|pi|gemini>]");
     process.exit(1);
   }
   const eventType = args[hookIdx + 1];
   const cliIdx = args.indexOf("--cli");
   const cliArg = cliIdx >= 0 ? args[cliIdx + 1] : undefined;
-  const cli = cliArg && (cliArg === "claude" || cliArg === "codex") ? cliArg : "claude";
+  const cli = cliArg && (cliArg === "claude" || cliArg === "codex" || cliArg === "copilot" || cliArg === "cursor" || cliArg === "opencode" || cliArg === "pi" || cliArg === "gemini") ? cliArg : "claude";
   try {
     const { handleHookEvent: handleHookEvent2 } = await Promise.resolve().then(() => (init_handler(), exports_handler));
     const exitCode = await handleHookEvent2(eventType, cli);
@@ -6382,17 +8511,19 @@ COMMANDS
   policies, p                    List all available policies and their status
   policies --install, -i         Enable policies in agent CLI settings
     [names...]                     Specific policy names to enable
-    --cli claude|codex             Agent CLI(s) to install for; space-separated
-                                   (e.g. --cli claude codex) or repeated.
+    --cli claude|codex|copilot|cursor|opencode|pi|gemini
+                                   Agent CLI(s) to install for; space-separated
+                                   (e.g. --cli claude codex copilot cursor opencode pi gemini) or repeated.
                                    Default: detect installed CLIs and prompt.
     --scope user|project|local     Config scope to write to (default: user)
-                                   (Codex supports user|project only)
+                                   (Codex / Copilot / Cursor / OpenCode / Pi / Gemini support user|project only)
     --beta                         Include beta policies
     --custom, -c <path>            Path to a JS file of custom policies
 
   policies --uninstall, -u       Disable policies or remove hooks
     [names...]                     Specific policy names to disable
-    --cli claude|codex        Agent CLI(s) to uninstall from
+    --cli claude|codex|copilot|cursor|opencode|pi|gemini
+                                   Agent CLI(s) to uninstall from
     --scope user|project|local|all Config scope to remove from (default: user)
     --beta                         Remove only beta policies
     --custom, -c                   Clear the customPoliciesPath from config
@@ -6418,11 +8549,21 @@ EXAMPLES
   failproofai policies --install
   failproofai policies --install block-sudo sanitize-api-keys --scope project
   failproofai policies --install --cli codex --scope project
-  failproofai policies --install --cli claude codex
+  failproofai policies --install --cli copilot --scope project
+  failproofai policies --install --cli cursor --scope project
+  failproofai policies --install --cli opencode --scope project
+  failproofai policies --install --cli pi --scope project
+  failproofai policies --install --cli gemini --scope project
+  failproofai policies --install --cli claude codex copilot cursor opencode pi gemini
   failproofai policies --install --custom ./my-policies.js
   failproofai policies -i -c ./my-policies.js
   failproofai policies --uninstall block-sudo
   failproofai policies --uninstall --cli codex
+  failproofai policies --uninstall --cli copilot
+  failproofai policies --uninstall --cli cursor
+  failproofai policies --uninstall --cli opencode
+  failproofai policies --uninstall --cli pi
+  failproofai policies --uninstall --cli gemini
   failproofai policies --uninstall --custom
 
 LINKS
@@ -6457,19 +8598,21 @@ USAGE
 
 OPTIONS (install)
   [names...]                     Specific policy names to enable (omit for interactive)
-  --cli claude|codex             Agent CLI(s) to install for; space-separated
-                                 (e.g. --cli claude codex) or repeated. Omit to
-                                 detect installed CLIs and prompt (or auto-pick
-                                 if only one is found).
+  --cli claude|codex|copilot|cursor|opencode|pi|gemini
+                                 Agent CLI(s) to install for; space-separated
+                                 (e.g. --cli claude codex copilot cursor opencode pi gemini) or repeated.
+                                 Omit to detect installed CLIs and prompt (or
+                                 auto-pick if only one is found).
   --scope user|project|local     Config scope to write to (default: user)
-                                 (Codex supports user|project only)
+                                 (Codex / Copilot / Cursor / OpenCode / Pi / Gemini support user|project only)
   --beta                         Include beta policies
   --custom, -c <path>            Path to a JS file of custom policies
                                  (skips interactive prompt; validates file first)
 
 OPTIONS (uninstall)
   [names...]                     Specific policy names to disable (omit to remove hooks)
-  --cli claude|codex        Agent CLI(s) to uninstall from
+  --cli claude|codex|copilot|cursor|opencode|pi|gemini
+                                 Agent CLI(s) to uninstall from
   --scope user|project|local|all Config scope to remove from (default: user)
   --beta                         Remove only beta policies
   --custom, -c                   Clear the customPoliciesPath from config
@@ -6479,11 +8622,20 @@ EXAMPLES
   failproofai policies --install
   failproofai policies --install block-sudo sanitize-api-keys
   failproofai policies --install --cli codex --scope project
-  failproofai policies --install --cli claude codex
+  failproofai policies --install --cli copilot --scope project
+  failproofai policies --install --cli cursor --scope project
+  failproofai policies --install --cli opencode --scope project
+  failproofai policies --install --cli pi --scope project
+  failproofai policies --install --cli gemini --scope project
+  failproofai policies --install --cli claude codex copilot cursor opencode pi gemini
   failproofai policies --install --custom ./my-policies.js
   failproofai policies -i -c ./my-policies.js
   failproofai policies --uninstall block-sudo
   failproofai policies --uninstall --cli codex
+  failproofai policies --uninstall --cli copilot
+  failproofai policies --uninstall --cli cursor
+  failproofai policies --uninstall --cli opencode
+  failproofai policies --uninstall --cli pi
   failproofai policies -u
   failproofai policies --uninstall --custom
 `.trimStart());
@@ -6506,7 +8658,7 @@ EXAMPLES
         throw new CliError3(`Missing path after --custom/-c
 Usage: --custom <path>  (e.g. --custom ./my-policies.js)`);
       }
-      const VALID_CLIS = new Set(["claude", "codex"]);
+      const VALID_CLIS = new Set(["claude", "codex", "copilot", "cursor", "opencode", "pi", "gemini"]);
       const cliFlagValues = [];
       const cliConsumedIdxs = new Set;
       const cliFlagIdxs = subArgs.map((a, i) => a === "--cli" ? i : -1).filter((i) => i >= 0);
@@ -6523,7 +8675,7 @@ Usage: --custom <path>  (e.g. --custom ./my-policies.js)`);
           consumed++;
         }
         if (consumed === 0) {
-          throw new CliError3("Missing value(s) for --cli. Usage: --cli claude codex (or any subset)");
+          throw new CliError3("Missing value(s) for --cli. Usage: --cli claude codex copilot cursor opencode pi gemini (or any subset)");
         }
       }
       const includeBeta = subArgs.includes("--beta");
@@ -6542,7 +8694,7 @@ Run \`failproofai policies --help\` for usage.`);
       }
       const explicitPolicyNames = subArgs.filter((a, idx) => !a.startsWith("-") && !consumedIdxs.has(idx));
       const policyNames = explicitPolicyNames.length > 0 ? explicitPolicyNames : customPoliciesPath !== undefined ? [] : undefined;
-      const cli = await resolveTargetClis2(cliFlagValues.length > 0 ? cliFlagValues : undefined);
+      const cli = await resolveTargetClis2(cliFlagValues.length > 0 ? cliFlagValues : undefined, "install");
       await installHooks2(policyNames, scope, undefined, includeBeta, undefined, customPoliciesPath, false, cli);
       process.exit(0);
     }
@@ -6557,7 +8709,7 @@ Run \`failproofai policies --help\` for usage.`);
       if (scopeIdx >= 0 && !["user", "project", "local", "all"].includes(scope)) {
         throw new CliError3(`Invalid scope: ${scope}. Valid values: user, project, local, all`);
       }
-      const VALID_CLIS = new Set(["claude", "codex"]);
+      const VALID_CLIS = new Set(["claude", "codex", "copilot", "cursor", "opencode", "pi", "gemini"]);
       const cliFlagValues = [];
       const cliConsumedIdxs = new Set;
       const cliFlagIdxs = subArgs.map((a, i) => a === "--cli" ? i : -1).filter((i) => i >= 0);
@@ -6574,7 +8726,7 @@ Run \`failproofai policies --help\` for usage.`);
           consumed++;
         }
         if (consumed === 0) {
-          throw new CliError3("Missing value(s) for --cli. Usage: --cli claude codex (or any subset)");
+          throw new CliError3("Missing value(s) for --cli. Usage: --cli claude codex copilot cursor opencode pi gemini (or any subset)");
         }
       }
       const betaOnly = subArgs.includes("--beta");
@@ -6591,7 +8743,7 @@ Run \`failproofai policies --help\` for usage.`);
 Run \`failproofai policies --help\` for usage.`);
       }
       const policyNames = subArgs.filter((a, idx) => !a.startsWith("-") && !consumedIdxs.has(idx));
-      const cli = await resolveTargetClis2(cliFlagValues.length > 0 ? cliFlagValues : undefined);
+      const cli = await resolveTargetClis2(cliFlagValues.length > 0 ? cliFlagValues : undefined, "uninstall");
       await removeHooks2(policyNames.length > 0 ? policyNames : undefined, scope, undefined, { betaOnly, removeCustomHooks, cli });
       process.exit(0);
     }