failproofai 0.0.9-beta.1 → 0.0.9

package/dist/cli.mjs

@@ -727,7 +727,7 @@ function blockSecretsWrite(ctx) {
 }
 function extractAbsolutePaths(command) {
   const paths = [];
-  const pathRe = /(?<![a-zA-Z0-9_.\-~\\])(?:~\/[^\s;|&"'()\[\]{}]*|~(?=\s|$|[;|&"'()\[\]{}])|\/[^\s;|&"'()\[\]{}]*)/g;
+  const pathRe = /(?<![a-zA-Z0-9_.\-~\\*?:=])(?:~\/[^\s;|&"'()\[\]{}]*|~(?=\s|$|[;|&"'()\[\]{}])|\/[^\s;|&"'()\[\]{}]*)/g;
   function addPaths(s) {
     pathRe.lastIndex = 0;
     let m;
@@ -2397,7 +2397,7 @@ var init_hook_activity_store = __esm(() => {
 });
 
 // package.json
-var version2 = "0.0.9-beta.1";
+var version2 = "0.0.9";
 var init_package = () => {};
 
 // src/posthog-key.ts
@@ -2428,19 +2428,721 @@ var init_hook_telemetry = __esm(() => {
   API_KEY = POSTHOG_API_KEY;
 });
 
-// src/hooks/resolve-permission-mode.ts
-import { readFileSync as readFileSync3, readdirSync as readdirSync3, existsSync as existsSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
-import { dirname as dirname3, join as join4 } from "node:path";
-import { homedir as homedir6 } from "node:os";
-function resolvePermissionMode(integration, parsed, sessionId) {
-  if (integration === "claude") {
-    return parsed.permission_mode ?? "default";
+// lib/runtime-cache.ts
+function runtimeCache(fn, revalidateSeconds, options) {
+  const cache = new Map;
+  const inflight = new Map;
+  const maxSize = options?.maxSize;
+  return async (...args) => {
+    const key = JSON.stringify(args);
+    const entry = cache.get(key);
+    if (entry && Date.now() < entry.expiry) {
+      return entry.data;
+    }
+    const existing = inflight.get(key);
+    if (existing)
+      return existing;
+    const promise = fn(...args).then((data) => {
+      inflight.delete(key);
+      if (maxSize && cache.size >= maxSize) {
+        const oldestKey = cache.keys().next().value;
+        cache.delete(oldestKey);
+      }
+      cache.set(key, { data, expiry: Date.now() + revalidateSeconds * 1000 });
+      return data;
+    }, (err) => {
+      inflight.delete(key);
+      throw err;
+    });
+    inflight.set(key, promise);
+    return promise;
+  };
+}
+
+// lib/paths.ts
+import { homedir as homedir6 } from "os";
+import { join as join4 } from "path";
+function getDefaultClaudeProjectsPath() {
+  return join4(homedir6(), ".claude", "projects");
+}
+function encodeFolderName(path) {
+  const driveMatch = /^([A-Za-z]):[\\/](.*)$/.exec(path);
+  if (driveMatch) {
+    return driveMatch[1] + "--" + driveMatch[2].replace(/[\\/]/g, "-");
   }
-  if (integration === "codex" && sessionId) {
-    return resolveCodexMode(sessionId) ?? "default";
+  return path.replace(/[\\/]/g, "-");
+}
+function getClaudeProjectsPath() {
+  const envPath = process.env.CLAUDE_PROJECTS_PATH;
+  if (envPath) {
+    return envPath;
   }
-  return "default";
+  return getDefaultClaudeProjectsPath();
 }
+var init_paths = () => {};
+
+// lib/concurrency.ts
+async function batchAll(tasks, concurrency) {
+  const results = new Array(tasks.length);
+  let next = 0;
+  async function worker() {
+    while (next < tasks.length) {
+      const idx = next++;
+      try {
+        results[idx] = { status: "fulfilled", value: await tasks[idx]() };
+      } catch (reason) {
+        results[idx] = { status: "rejected", reason };
+      }
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, tasks.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
+// lib/logger.ts
+function shouldEmit2(level) {
+  return LEVEL_ORDER2[level] >= LEVEL_ORDER2[currentLevel2];
+}
+function stamp(label) {
+  return `[failproofai${new Date().toISOString()}] ${label}`;
+}
+function logWarn(msg, detail) {
+  if (!shouldEmit2("warn"))
+    return;
+  if (detail !== undefined) {
+    console.warn(stamp("WARN"), msg, detail);
+  } else {
+    console.warn(stamp("WARN"), msg);
+  }
+}
+function logError(msg, detail) {
+  if (detail !== undefined) {
+    console.error(stamp("ERROR"), msg, detail);
+  } else {
+    console.error(stamp("ERROR"), msg);
+  }
+}
+var LEVEL_ORDER2, currentLevel2 = "warn";
+var init_logger = __esm(() => {
+  LEVEL_ORDER2 = { info: 0, warn: 1, error: 2 };
+});
+
+// lib/format-date.ts
+function formatDate(date) {
+  return new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  }).format(date);
+}
+
+// lib/codex-projects.ts
+var exports_codex_projects = {};
+__export(exports_codex_projects, {
+  getCodexSessionsForCwd: () => getCodexSessionsForCwd,
+  getCodexSessionsByEncodedName: () => getCodexSessionsByEncodedName,
+  getCodexProjects: () => getCodexProjects,
+  getCachedCodexSessionsForCwd: () => getCachedCodexSessionsForCwd,
+  getCachedCodexSessionsByEncodedName: () => getCachedCodexSessionsByEncodedName,
+  getCachedCodexProjects: () => getCachedCodexProjects
+});
+import { open as open2, readdir } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join5 } from "path";
+async function safeReaddir(dir) {
+  try {
+    return await readdir(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+async function readFirstLine(filePath) {
+  let fh = null;
+  try {
+    fh = await open2(filePath, "r");
+    const buf = Buffer.alloc(FIRST_LINE_CHUNK_BYTES);
+    const { bytesRead } = await fh.read(buf, 0, FIRST_LINE_CHUNK_BYTES, 0);
+    if (bytesRead === 0)
+      return null;
+    const slice = buf.subarray(0, bytesRead);
+    const nl = slice.indexOf(10);
+    const end = nl === -1 ? bytesRead : nl;
+    return slice.subarray(0, end).toString("utf-8");
+  } catch {
+    return null;
+  } finally {
+    if (fh)
+      await fh.close().catch(() => {});
+  }
+}
+function extractSessionMeta(line) {
+  try {
+    const obj = JSON.parse(line);
+    if (obj.type !== "session_meta")
+      return {};
+    const cwd = obj.payload?.cwd;
+    if (typeof cwd !== "string" || cwd.length === 0)
+      return {};
+    return { cwd };
+  } catch {
+    return {};
+  }
+}
+function extractSessionId(filename) {
+  const m = filename.match(SESSION_ID_RE);
+  return m ? m[0] : null;
+}
+async function listJsonlFiles(dir) {
+  const entries = await safeReaddir(dir);
+  if (!entries)
+    return [];
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join5(dir, e.name));
+}
+async function scanCodexSessions() {
+  const yearDirs = await safeReaddir(CODEX_SESSIONS_ROOT);
+  if (!yearDirs)
+    return [];
+  const filePaths = [];
+  for (const y of yearDirs) {
+    if (!y.isDirectory())
+      continue;
+    const monthDirs = await safeReaddir(join5(CODEX_SESSIONS_ROOT, y.name));
+    if (!monthDirs)
+      continue;
+    for (const m of monthDirs) {
+      if (!m.isDirectory())
+        continue;
+      const dayDirs = await safeReaddir(join5(CODEX_SESSIONS_ROOT, y.name, m.name));
+      if (!dayDirs)
+        continue;
+      for (const d of dayDirs) {
+        if (!d.isDirectory())
+          continue;
+        const dayPath = join5(CODEX_SESSIONS_ROOT, y.name, m.name, d.name);
+        filePaths.push(...await listJsonlFiles(dayPath));
+      }
+    }
+  }
+  if (filePaths.length === 0)
+    return [];
+  const settled = await batchAll(filePaths.map((filePath) => async () => {
+    const sessionId = extractSessionId(filePath.split("/").pop() ?? "");
+    if (!sessionId)
+      return null;
+    const line = await readFirstLine(filePath);
+    if (!line)
+      return null;
+    const { cwd } = extractSessionMeta(line);
+    if (!cwd)
+      return null;
+    let fileMtime;
+    try {
+      const fh = await open2(filePath, "r");
+      try {
+        const stat2 = await fh.stat();
+        fileMtime = stat2.mtime;
+      } finally {
+        await fh.close().catch(() => {});
+      }
+    } catch {
+      fileMtime = new Date(0);
+    }
+    return {
+      filePath,
+      fileName: filePath.split("/").pop() ?? "",
+      cwd,
+      sessionId,
+      fileMtime
+    };
+  }), 16);
+  return settled.filter((r) => r.status === "fulfilled").map((r) => r.value).filter((v) => v !== null);
+}
+async function getCodexProjects() {
+  let metas;
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Codex 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: ["codex"]
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+function metasToSessionFiles(metas) {
+  const files = metas.map((m) => ({
+    name: m.fileName.replace(/\.jsonl$/, ""),
+    path: m.filePath,
+    lastModified: m.fileMtime,
+    lastModifiedFormatted: formatDate(m.fileMtime),
+    sessionId: m.sessionId,
+    cli: "codex"
+  }));
+  files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return files;
+}
+async function getCodexSessionsForCwd(cwd) {
+  let metas;
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Codex sessions:", error);
+    return [];
+  }
+  return metasToSessionFiles(metas.filter((m) => m.cwd === cwd));
+}
+async function getCodexSessionsByEncodedName(name) {
+  let metas;
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Codex sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  const matches = metas.filter((m) => encodeFolderName(m.cwd) === name);
+  return {
+    cwd: matches[0]?.cwd ?? null,
+    sessions: metasToSessionFiles(matches)
+  };
+}
+var CODEX_SESSIONS_ROOT, SESSION_ID_RE, FIRST_LINE_CHUNK_BYTES, cachedScan, getCachedCodexProjects, getCachedCodexSessionsForCwd, getCachedCodexSessionsByEncodedName;
+var init_codex_projects = __esm(() => {
+  init_paths();
+  init_logger();
+  CODEX_SESSIONS_ROOT = join5(homedir7(), ".codex", "sessions");
+  SESSION_ID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+  FIRST_LINE_CHUNK_BYTES = 256 * 1024;
+  cachedScan = runtimeCache(scanCodexSessions, 30);
+  getCachedCodexProjects = runtimeCache(getCodexProjects, 30);
+  getCachedCodexSessionsForCwd = runtimeCache((cwd) => getCodexSessionsForCwd(cwd), 30, { maxSize: 50 });
+  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) {
+  try {
+    return (await stat2(path)).mtime;
+  } catch (error) {
+    logWarn(`Failed to stat ${label}:`, error);
+    return new Date(0);
+  }
+}
+async function safeReaddir2(dirPath) {
+  try {
+    const s = await stat2(dirPath);
+    if (!s.isDirectory())
+      return null;
+    return await readdir2(dirPath, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+async function getClaudeProjectFolders() {
+  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;
+  } catch (error) {
+    logError("Error reading Claude project folders:", 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] });
+      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 } = 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 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");
+  }
+  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);
+    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 mtime = await getMtime(filePath, entry.name);
+      return {
+        name: entry.name,
+        path: filePath,
+        lastModified: mtime,
+        lastModifiedFormatted: formatDate(mtime),
+        sessionId: extractSessionId2(entry.name),
+        cli: "claude"
+      };
+    }), 16);
+    const files = settled.filter((r) => r.status === "fulfilled").map((r) => r.value);
+    files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    return files;
+  } catch (error) {
+    logError("Error reading session files:", error);
+    return [];
+  }
+}
+var getCachedProjectFolders, getCachedSessionFiles;
+var init_projects = __esm(() => {
+  init_paths();
+  init_logger();
+  getCachedProjectFolders = runtimeCache(getProjectFolders, 30);
+  getCachedSessionFiles = runtimeCache((projectPath) => getSessionFiles(projectPath), 30);
+});
+
+// lib/resolve-subagent-path.ts
+import { access as access2 } from "fs/promises";
+import { join as join7, 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)
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (relative2(projectsPath, candidatePath).startsWith("..")) {
+      continue;
+    }
+    try {
+      await access2(candidatePath);
+      return candidatePath;
+    } catch (e) {
+      const code = e.code;
+      if (code === "ENOENT")
+        continue;
+      break;
+    }
+  }
+  return null;
+}
+var init_resolve_subagent_path = () => {};
+
+// lib/format-duration.ts
+function formatDuration(ms) {
+  if (ms < 1000)
+    return `${ms}ms`;
+  const seconds = ms / 1000;
+  if (seconds < 60)
+    return `${seconds.toFixed(1)}s`;
+  const totalMinutes = Math.floor(seconds / 60);
+  if (totalMinutes >= 60) {
+    const hours = Math.floor(totalMinutes / 60);
+    const remainingMinutes = totalMinutes % 60;
+    return `${hours}h ${remainingMinutes}m`;
+  }
+  const remainingSeconds = (seconds % 60).toFixed(0);
+  return `${totalMinutes}m ${remainingSeconds}s`;
+}
+
+// lib/log-entries.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join8 } from "path";
+function formatTimestamp(date) {
+  const base = formatDate(date);
+  const ms = date.getMilliseconds().toString().padStart(3, "0");
+  return `${base}.${ms}`;
+}
+function baseEntry(raw, timestamp, date, source) {
+  return {
+    _source: source,
+    uuid: raw.uuid || "",
+    parentUuid: raw.parentUuid ?? null,
+    timestamp,
+    timestampMs: date.getTime(),
+    timestampFormatted: formatTimestamp(date)
+  };
+}
+function extractToolResultContent(block) {
+  const resultContent = block.content;
+  if (typeof resultContent === "string")
+    return { text: resultContent };
+  if (Array.isArray(resultContent)) {
+    const arr = resultContent;
+    const textParts = arr.filter((r) => r.type === "text").map((r) => r.text);
+    const images = arr.filter((r) => r.type === "image").map((r) => {
+      const source = r.source;
+      return {
+        base64: source.data,
+        mediaType: source.media_type
+      };
+    }).filter((img) => img.base64 && img.mediaType);
+    return {
+      text: textParts.length > 0 ? textParts.join(`
+`) : undefined,
+      images: images.length > 0 ? images : undefined
+    };
+  }
+  return {};
+}
+async function parseFileContent(fileContent, source) {
+  const lines = fileContent.split(`
+`).filter((line) => line.trim() !== "");
+  const toolResultMap = new Map;
+  const entries = [];
+  const rawLines = [];
+  const subagentIdSet = new Set;
+  let seenQueue = false;
+  for (let i = 0;i < lines.length; i++) {
+    if (i > 0 && i % 200 === 0)
+      await new Promise((r) => setImmediate(r));
+    const line = lines[i];
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const rawCopy = { ...raw, _source: source };
+    rawLines.push(rawCopy);
+    const type = raw.type;
+    const timestamp = raw.timestamp;
+    if (!timestamp)
+      continue;
+    const date = new Date(timestamp);
+    const timestampMs = date.getTime();
+    if (type === "user") {
+      const message = raw.message;
+      if (Array.isArray(message?.content)) {
+        const blocks = message.content;
+        const hasToolResult = blocks.some((b) => b.type === "tool_result");
+        if (hasToolResult) {
+          const toolUseResult = raw.toolUseResult;
+          const agentId = typeof toolUseResult?.agentId === "string" ? toolUseResult.agentId : undefined;
+          if (agentId && /^[a-f0-9]+$/.test(agentId)) {
+            subagentIdSet.add(agentId);
+          }
+          for (const block of blocks) {
+            if (block.type !== "tool_result")
+              continue;
+            const toolUseId = block.tool_use_id;
+            if (!toolUseId)
+              continue;
+            const { text, images } = extractToolResultContent(block);
+            toolResultMap.set(toolUseId, {
+              timestamp,
+              timestampMs,
+              content: text,
+              images,
+              agentId
+            });
+          }
+          continue;
+        }
+      }
+      const content = typeof message?.content === "string" ? message.content : "";
+      entries.push({ type: "user", ...baseEntry(raw, timestamp, date, source), message: { role: "user", content } });
+      continue;
+    }
+    if (type === "assistant") {
+      const message = raw.message;
+      let content = [];
+      if (Array.isArray(message?.content)) {
+        content = message.content.filter((block) => ["text", "tool_use", "thinking"].includes(block.type)).map((block) => {
+          if (block.type === "text") {
+            return { type: "text", text: block.text };
+          }
+          if (block.type === "tool_use") {
+            const input = block.input;
+            return {
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input ?? {},
+              ...block.name === "Task" && input ? {
+                subagentType: input.subagent_type,
+                subagentDescription: input.description
+              } : {}
+            };
+          }
+          return {
+            type: "thinking",
+            thinking: block.thinking,
+            signature: block.signature
+          };
+        });
+      }
+      if (content.length === 0)
+        continue;
+      entries.push({
+        type: "assistant",
+        ...baseEntry(raw, timestamp, date, source),
+        message: { role: "assistant", content, model: message?.model }
+      });
+      continue;
+    }
+    if (type === "file-history-snapshot" || type === "progress" || type === "system") {
+      entries.push({ type, ...baseEntry(raw, timestamp, date, source), raw: { ...raw } });
+      continue;
+    }
+    if (type === "queue-operation") {
+      const label = seenQueue ? "Session Resumed" : "Session Started";
+      seenQueue = true;
+      entries.push({ type: "queue-operation", ...baseEntry(raw, timestamp, date, source), label });
+      continue;
+    }
+  }
+  let enrichCount = 0;
+  for (const entry of entries) {
+    if (entry.type !== "assistant")
+      continue;
+    enrichCount++;
+    if (enrichCount % 200 === 0)
+      await new Promise((r) => setImmediate(r));
+    for (const block of entry.message.content) {
+      if (block.type !== "tool_use")
+        continue;
+      const resultInfo = toolResultMap.get(block.id);
+      if (!resultInfo)
+        continue;
+      const returnDate = new Date(resultInfo.timestamp);
+      const durationMs = Math.max(0, resultInfo.timestampMs - entry.timestampMs);
+      block.result = {
+        timestamp: resultInfo.timestamp,
+        timestampFormatted: formatTimestamp(returnDate),
+        content: resultInfo.content,
+        images: resultInfo.images,
+        durationMs,
+        durationFormatted: formatDuration(durationMs)
+      };
+      if (resultInfo.agentId) {
+        block.subagentId = resultInfo.agentId;
+      }
+    }
+  }
+  if (entries.length > 500)
+    await new Promise((r) => setImmediate(r));
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return { entries, rawLines, subagentIds: Array.from(subagentIdSet) };
+}
+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 { entries: sessionEntries, rawLines: sessionRawLines, subagentIds } = await parseFileContent(fileContent, "session");
+  if (subagentIds.length === 0) {
+    return { entries: sessionEntries, rawLines: sessionRawLines, subagentIds: [] };
+  }
+  const results = await batchAll(subagentIds.map((agentId) => async () => {
+    const agentSource = `agent-${agentId}`;
+    const agentPath = await resolveSubagentPath(projectsPath, projectName, sessionId, agentId);
+    if (!agentPath)
+      return null;
+    const agentContent = await readFile3(agentPath, "utf-8");
+    const { entries, rawLines } = await parseFileContent(agentContent, agentSource);
+    return { entries, rawLines };
+  }), SUBAGENT_CONCURRENCY);
+  const allEntries = [...sessionEntries];
+  const allRawLines = [...sessionRawLines];
+  for (const result of results) {
+    if (result.status === "fulfilled" && result.value) {
+      allEntries.push(...result.value.entries);
+      allRawLines.push(...result.value.rawLines);
+    }
+  }
+  if (allEntries.length > 500)
+    await new Promise((r) => setImmediate(r));
+  allEntries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return { entries: allEntries, rawLines: allRawLines, subagentIds };
+}
+var SUBAGENT_CONCURRENCY = 4, getCachedSessionLog;
+var init_log_entries = __esm(() => {
+  init_paths();
+  init_projects();
+  init_resolve_subagent_path();
+  getCachedSessionLog = runtimeCache((projectName, sessionId) => parseSessionLog(projectName, sessionId), 60, { maxSize: 50 });
+});
+
+// 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";
 function readCache() {
   try {
     if (!existsSync5(CACHE_PATH))
@@ -2462,25 +3164,25 @@ 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 join4(dir, f.name);
+        return join9(dir, f.name);
       }
     }
   } catch {}
   return null;
 }
-function findCodexTranscriptSync(sessionId) {
+function findCodexTranscript(sessionId) {
   const cache = readCache();
   const cached = cache[sessionId];
   if (cached && existsSync5(cached))
     return cached;
-  const root = join4(homedir6(), ".codex", "sessions");
+  const root = join9(homedir8(), ".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 join4(root, y, m, day);
+    return join9(root, y, m, day);
   });
   for (const dir of datedDirs) {
     const hit = dirSearch(dir, sessionId);
@@ -2493,13 +3195,13 @@ function findCodexTranscriptSync(sessionId) {
     for (const y of readdirSync3(root, { withFileTypes: true })) {
       if (!y.isDirectory())
         continue;
-      for (const m of readdirSync3(join4(root, y.name), { withFileTypes: true })) {
+      for (const m of readdirSync3(join9(root, y.name), { withFileTypes: true })) {
         if (!m.isDirectory())
           continue;
-        for (const d of readdirSync3(join4(root, y.name, m.name), { withFileTypes: true })) {
+        for (const d of readdirSync3(join9(root, y.name, m.name), { withFileTypes: true })) {
           if (!d.isDirectory())
             continue;
-          const hit = dirSearch(join4(root, y.name, m.name, d.name), sessionId);
+          const hit = dirSearch(join9(root, y.name, m.name, d.name), sessionId);
           if (hit) {
             writeCacheEntry(sessionId, hit);
             return hit;
@@ -2510,12 +3212,236 @@ function findCodexTranscriptSync(sessionId) {
   } catch {}
   return null;
 }
+function safeJsonParse(s) {
+  if (!s)
+    return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+function joinTexts(blocks, wantedType) {
+  if (!Array.isArray(blocks))
+    return "";
+  return blocks.filter((b) => b?.type === wantedType && typeof b.text === "string").map((b) => b.text).join(`
+`);
+}
+async function parseCodexLog(fileContent, source = "session") {
+  const lines = fileContent.split(`
+`).filter((line) => line.trim() !== "");
+  const entries = [];
+  const rawLines = [];
+  const toolUseById = new Map;
+  const toolUseStartMs = new Map;
+  let cwd;
+  let seenTaskStart = false;
+  for (let i = 0;i < lines.length; i++) {
+    if (i > 0 && i % 200 === 0)
+      await new Promise((r) => setImmediate(r));
+    const line = lines[i];
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const rawCopy = { ...raw, _source: source };
+    rawLines.push(rawCopy);
+    const timestamp = raw.timestamp;
+    if (!timestamp)
+      continue;
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime()))
+      continue;
+    const recType = raw.type;
+    const payload = raw.payload ?? {};
+    if (recType === "session_meta") {
+      const c = payload.cwd;
+      if (typeof c === "string" && !cwd)
+        cwd = c;
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    if (recType === "response_item") {
+      const subType = payload.type;
+      if (subType === "message") {
+        const role = payload.role;
+        const content = payload.content;
+        if (role === "user" || role === "developer") {
+          const text = joinTexts(content, "input_text");
+          if (!text)
+            continue;
+          const message = role === "developer" ? `[developer] ${text}` : text;
+          entries.push({
+            type: "user",
+            ...baseEntry(rawCopy, timestamp, date, source),
+            message: { role: "user", content: message }
+          });
+          continue;
+        }
+        if (role === "assistant") {
+          const text = joinTexts(content, "output_text");
+          if (!text)
+            continue;
+          const blocks = [{ type: "text", text }];
+          entries.push({
+            type: "assistant",
+            ...baseEntry(rawCopy, timestamp, date, source),
+            message: { role: "assistant", content: blocks }
+          });
+          continue;
+        }
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy
+        });
+        continue;
+      }
+      if (subType === "function_call") {
+        const callId = payload.call_id;
+        const name = payload.name ?? "function_call";
+        const input = safeJsonParse(payload.arguments);
+        const toolUse = {
+          type: "tool_use",
+          id: callId ?? `${timestamp}-${name}`,
+          name,
+          input
+        };
+        const entry = {
+          type: "assistant",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          message: { role: "assistant", content: [toolUse] }
+        };
+        entries.push(entry);
+        if (callId) {
+          toolUseById.set(callId, toolUse);
+          toolUseStartMs.set(callId, date.getTime());
+        }
+        continue;
+      }
+      if (subType === "function_call_output") {
+        const callId = payload.call_id;
+        const block = callId ? toolUseById.get(callId) : undefined;
+        if (block) {
+          const startMs = toolUseStartMs.get(callId) ?? date.getTime();
+          const duration = Math.max(0, date.getTime() - startMs);
+          block.result = {
+            timestamp,
+            timestampFormatted: formatTimestamp(date),
+            content: typeof payload.output === "string" ? payload.output : JSON.stringify(payload.output),
+            durationMs: duration,
+            durationFormatted: formatDuration(duration)
+          };
+          continue;
+        }
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy
+        });
+        continue;
+      }
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    if (recType === "event_msg") {
+      const subType = payload.type;
+      if (subType === "task_started") {
+        const label = seenTaskStart ? "Session Resumed" : "Session Started";
+        seenTaskStart = true;
+        entries.push({
+          type: "queue-operation",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          label
+        });
+        continue;
+      }
+      if (subType === "exec_command_end") {
+        const callId = payload.call_id;
+        const block = callId ? toolUseById.get(callId) : undefined;
+        if (block) {
+          const duration = payload.duration;
+          const durationMs = duration ? (duration.secs ?? 0) * 1000 + Math.round((duration.nanos ?? 0) / 1e6) : Math.max(0, date.getTime() - (toolUseStartMs.get(callId) ?? date.getTime()));
+          const aggregated = payload.aggregated_output;
+          block.result = {
+            timestamp,
+            timestampFormatted: formatTimestamp(date),
+            content: typeof aggregated === "string" ? aggregated : JSON.stringify(aggregated),
+            durationMs,
+            durationFormatted: formatDuration(durationMs)
+          };
+          continue;
+        }
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy
+        });
+        continue;
+      }
+      if (subType === "user_message" || subType === "agent_message") {
+        continue;
+      }
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy
+      });
+      continue;
+    }
+    entries.push({
+      type: "system",
+      ...baseEntry(rawCopy, timestamp, date, source),
+      raw: rawCopy
+    });
+  }
+  if (entries.length > 500)
+    await new Promise((r) => setImmediate(r));
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return { entries, rawLines, cwd };
+}
+async function getCodexSessionLog(sessionId) {
+  const filePath = findCodexTranscript(sessionId);
+  if (!filePath)
+    return null;
+  const fileContent = await readFile4(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");
+  getCachedCodexSessionLog = runtimeCache((sessionId) => getCodexSessionLog(sessionId), 60, { maxSize: 50 });
+});
+
+// src/hooks/resolve-permission-mode.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+function resolvePermissionMode(integration, parsed, sessionId) {
+  if (integration === "claude") {
+    return parsed.permission_mode ?? "default";
+  }
+  if (integration === "codex" && sessionId) {
+    return resolveCodexMode(sessionId) ?? "default";
+  }
+  return "default";
+}
 function resolveCodexMode(sessionId) {
   try {
-    const path = findCodexTranscriptSync(sessionId);
+    const path = findCodexTranscript(sessionId);
     if (!path)
       return;
-    for (const line of readFileSync3(path, "utf-8").split(`
+    for (const line of readFileSync4(path, "utf-8").split(`
 `)) {
       if (!line.includes("turn_context"))
         continue;
@@ -2535,9 +3461,8 @@ function resolveCodexMode(sessionId) {
   } catch {}
   return;
 }
-var CACHE_PATH;
 var init_resolve_permission_mode = __esm(() => {
-  CACHE_PATH = join4(homedir6(), ".failproofai", "cache", "codex-session-paths.json");
+  init_codex_sessions();
 });
 
 // lib/telemetry-id.ts
@@ -2623,7 +3548,7 @@ var init_telemetry_id = __esm(() => {
 
 // src/auth/token-store.ts
 import {
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   writeFileSync as writeFileSync4,
   existsSync as existsSync6,
   mkdirSync as mkdirSync5,
@@ -2632,8 +3557,8 @@ import {
   openSync,
   closeSync
 } from "node:fs";
-import { join as join5 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { join as join10 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 function ensureAuthDir() {
   if (!existsSync6(AUTH_DIR))
     mkdirSync5(AUTH_DIR, { recursive: true, mode: 448 });
@@ -2642,7 +3567,7 @@ function readTokens() {
   if (!existsSync6(AUTH_FILE))
     return null;
   try {
-    const raw = readFileSync4(AUTH_FILE, "utf8");
+    const raw = readFileSync5(AUTH_FILE, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2668,8 +3593,8 @@ function isLoggedIn() {
 }
 var AUTH_DIR, AUTH_FILE;
 var init_token_store = __esm(() => {
-  AUTH_DIR = join5(homedir7(), ".failproofai");
-  AUTH_FILE = join5(AUTH_DIR, "auth.json");
+  AUTH_DIR = join10(homedir9(), ".failproofai");
+  AUTH_FILE = join10(AUTH_DIR, "auth.json");
 });
 
 // src/relay/queue.ts
@@ -2686,15 +3611,15 @@ import {
   appendFileSync as appendFileSync3,
   mkdirSync as mkdirSync6,
   existsSync as existsSync7,
-  readFileSync as readFileSync5,
-  statSync as statSync4,
+  readFileSync as readFileSync6,
+  statSync as statSync5,
   renameSync as renameSync4,
   unlinkSync as unlinkSync3,
   readdirSync as readdirSync4,
   chmodSync
 } from "node:fs";
-import { join as join6 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { join as join11 } from "node:path";
+import { homedir as homedir10 } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 function hashCwd(cwd) {
   if (!cwd)
@@ -2733,7 +3658,7 @@ function appendToServerQueue(entry) {
     return;
   ensureDir2();
   try {
-    if (existsSync7(PENDING_FILE) && statSync4(PENDING_FILE).size > MAX_QUEUE_BYTES) {
+    if (existsSync7(PENDING_FILE) && statSync5(PENDING_FILE).size > MAX_QUEUE_BYTES) {
       return;
     }
   } catch {}
@@ -2746,7 +3671,7 @@ function appendToServerQueue(entry) {
 }
 function queueSizeBytes() {
   try {
-    return statSync4(PENDING_FILE).size;
+    return statSync5(PENDING_FILE).size;
   } catch {
     return 0;
   }
@@ -2755,14 +3680,14 @@ function claimPendingBatch() {
   if (!existsSync7(PENDING_FILE))
     return null;
   try {
-    const size = statSync4(PENDING_FILE).size;
+    const size = statSync5(PENDING_FILE).size;
     if (size === 0)
       return null;
   } catch {
     return null;
   }
   const seq = `${Date.now()}-${process.pid}`;
-  const processingFile = join6(QUEUE_DIR, `${PROCESSING_PREFIX}${seq}.jsonl`);
+  const processingFile = join11(QUEUE_DIR, `${PROCESSING_PREFIX}${seq}.jsonl`);
   try {
     renameSync4(PENDING_FILE, processingFile);
     try {
@@ -2779,7 +3704,7 @@ function claimPendingBatch() {
 function findOrphanProcessingFiles() {
   ensureDir2();
   try {
-    return readdirSync4(QUEUE_DIR).filter((n) => n.startsWith(PROCESSING_PREFIX) && n.endsWith(".jsonl")).map((n) => join6(QUEUE_DIR, n)).sort();
+    return readdirSync4(QUEUE_DIR).filter((n) => n.startsWith(PROCESSING_PREFIX) && n.endsWith(".jsonl")).map((n) => join11(QUEUE_DIR, n)).sort();
   } catch {
     return [];
   }
@@ -2787,7 +3712,7 @@ function findOrphanProcessingFiles() {
 function readProcessingFile(path2) {
   if (!existsSync7(path2))
     return [];
-  const content = readFileSync5(path2, "utf8");
+  const content = readFileSync6(path2, "utf8");
   const out = [];
   for (const line of content.split(`
 `)) {
@@ -2808,20 +3733,20 @@ function deleteProcessingFile(path2) {
 var QUEUE_DIR, PENDING_FILE, PROCESSING_PREFIX = "processing-", MAX_QUEUE_BYTES;
 var init_queue = __esm(() => {
   init_token_store();
-  QUEUE_DIR = join6(homedir8(), ".failproofai", "cache", "server-queue");
-  PENDING_FILE = join6(QUEUE_DIR, "pending.jsonl");
+  QUEUE_DIR = join11(homedir10(), ".failproofai", "cache", "server-queue");
+  PENDING_FILE = join11(QUEUE_DIR, "pending.jsonl");
   MAX_QUEUE_BYTES = 50 * 1024 * 1024;
 });
 
 // src/relay/pid.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync8, unlinkSync as unlinkSync4, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join7, dirname as dirname4 } from "node:path";
-import { homedir as homedir9 } from "node:os";
+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";
 function readPid() {
   if (!existsSync8(PID_FILE))
     return null;
   try {
-    const raw = readFileSync6(PID_FILE, "utf8").trim();
+    const raw = readFileSync7(PID_FILE, "utf8").trim();
     const pid = parseInt(raw, 10);
     if (Number.isNaN(pid) || pid <= 0)
       return null;
@@ -2869,7 +3794,7 @@ function stopRelay() {
 }
 var PID_FILE;
 var init_pid = __esm(() => {
-  PID_FILE = join7(homedir9(), ".failproofai", "relay.pid");
+  PID_FILE = join12(homedir11(), ".failproofai", "relay.pid");
 });
 
 // src/relay/daemon.ts
@@ -2882,8 +3807,8 @@ __export(exports_daemon, {
 });
 import { spawn } from "node:child_process";
 import { existsSync as existsSync9 } from "node:fs";
-import { join as join8 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { join as join13 } from "node:path";
+import { homedir as homedir12 } from "node:os";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function ensureRelayRunning() {
   if (!isLoggedIn())
@@ -2963,16 +3888,16 @@ class Relay {
     try {
       const msg = JSON.parse(data);
       if (msg.ack && this.pendingAcks.has(msg.ack)) {
-        const resolve5 = this.pendingAcks.get(msg.ack);
+        const resolve6 = this.pendingAcks.get(msg.ack);
         this.pendingAcks.delete(msg.ack);
-        resolve5(true);
+        resolve6(true);
       }
     } catch {}
   }
   handleClose() {
     this.closed = true;
-    for (const [, resolve5] of this.pendingAcks) {
-      resolve5(false);
+    for (const [, resolve6] of this.pendingAcks) {
+      resolve6(false);
     }
     this.pendingAcks.clear();
   }
@@ -2988,11 +3913,11 @@ class Relay {
     if (this.closed)
       return false;
     const batchId = randomUUID2();
-    const ackPromise = new Promise((resolve5) => {
-      this.pendingAcks.set(batchId, resolve5);
+    const ackPromise = new Promise((resolve6) => {
+      this.pendingAcks.set(batchId, resolve6);
       setTimeout(() => {
         if (this.pendingAcks.delete(batchId))
-          resolve5(false);
+          resolve6(false);
       }, ACK_TIMEOUT_MS);
     });
     try {
@@ -3010,7 +3935,7 @@ async function connect(wsUrl, token) {
     throw new Error("WebSocket not available in this Node version. Requires Node 22+.");
   }
   const ws = new WSCtor(wsUrl);
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     let settled = false;
     const timeout = setTimeout(() => {
       if (settled)
@@ -3028,7 +3953,7 @@ async function connect(wsUrl, token) {
       clearTimeout(timeout);
       try {
         ws.send(token);
-        resolve5();
+        resolve6();
       } catch (e) {
         reject(e);
       }
@@ -3150,7 +4075,7 @@ var init_daemon = __esm(() => {
   init_token_store();
   init_pid();
   init_queue();
-  QUEUE_DIR2 = join8(homedir10(), ".failproofai", "cache", "server-queue");
+  QUEUE_DIR2 = join13(homedir12(), ".failproofai", "cache", "server-queue");
 });
 
 // src/hooks/handler.ts
@@ -3171,7 +4096,7 @@ async function handleHookEvent(eventType, cli = "claude") {
   const MAX_STDIN_BYTES = 1048576;
   let payload = "";
   try {
-    payload = await new Promise((resolve5, reject) => {
+    payload = await new Promise((resolve6, reject) => {
       const chunks = [];
       let totalBytes = 0;
       process.stdin.setEncoding("utf8");
@@ -3180,15 +4105,15 @@ async function handleHookEvent(eventType, cli = "claude") {
         if (totalBytes > MAX_STDIN_BYTES) {
           hookLogWarn(`stdin payload exceeds 1 MB for ${eventType}, discarding`);
           process.stdin.destroy();
-          resolve5("");
+          resolve6("");
           return;
         }
         chunks.push(chunk);
       });
-      process.stdin.on("end", () => resolve5(chunks.join("")));
+      process.stdin.on("end", () => resolve6(chunks.join("")));
       process.stdin.on("error", reject);
       if (process.stdin.readableEnded)
-        resolve5("");
+        resolve6("");
     });
   } catch {
     hookLogWarn(`stdin read failed for ${eventType}`);
@@ -3350,8 +4275,8 @@ __export(exports_daemon2, {
 });
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join9 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+import { join as join14 } from "node:path";
+import { homedir as homedir13 } from "node:os";
 import { randomUUID as randomUUID3 } from "node:crypto";
 function ensureRelayRunning2() {
   if (!isLoggedIn())
@@ -3431,16 +4356,16 @@ class Relay2 {
     try {
       const msg = JSON.parse(data);
       if (msg.ack && this.pendingAcks.has(msg.ack)) {
-        const resolve5 = this.pendingAcks.get(msg.ack);
+        const resolve6 = this.pendingAcks.get(msg.ack);
         this.pendingAcks.delete(msg.ack);
-        resolve5(true);
+        resolve6(true);
       }
     } catch {}
   }
   handleClose() {
     this.closed = true;
-    for (const [, resolve5] of this.pendingAcks) {
-      resolve5(false);
+    for (const [, resolve6] of this.pendingAcks) {
+      resolve6(false);
     }
     this.pendingAcks.clear();
   }
@@ -3456,11 +4381,11 @@ class Relay2 {
     if (this.closed)
       return false;
     const batchId = randomUUID3();
-    const ackPromise = new Promise((resolve5) => {
-      this.pendingAcks.set(batchId, resolve5);
+    const ackPromise = new Promise((resolve6) => {
+      this.pendingAcks.set(batchId, resolve6);
       setTimeout(() => {
         if (this.pendingAcks.delete(batchId))
-          resolve5(false);
+          resolve6(false);
       }, ACK_TIMEOUT_MS2);
     });
     try {
@@ -3478,7 +4403,7 @@ async function connect2(wsUrl, token) {
     throw new Error("WebSocket not available in this Node version. Requires Node 22+.");
   }
   const ws = new WSCtor(wsUrl);
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     let settled = false;
     const timeout = setTimeout(() => {
       if (settled)
@@ -3496,7 +4421,7 @@ async function connect2(wsUrl, token) {
       clearTimeout(timeout);
       try {
         ws.send(token);
-        resolve5();
+        resolve6();
       } catch (e) {
         reject(e);
       }
@@ -3618,18 +4543,18 @@ var init_daemon2 = __esm(() => {
   init_token_store();
   init_pid();
   init_queue();
-  QUEUE_DIR3 = join9(homedir11(), ".failproofai", "cache", "server-queue");
+  QUEUE_DIR3 = join14(homedir13(), ".failproofai", "cache", "server-queue");
 });
 
 // src/hooks/integrations.ts
 import { execSync as execSync3 } from "node:child_process";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync11, mkdirSync as mkdirSync8 } from "node:fs";
-import { resolve as resolve5, dirname as dirname5 } from "node:path";
-import { homedir as homedir12 } from "node:os";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync11, mkdirSync as mkdirSync8 } from "node:fs";
+import { resolve as resolve6, dirname as dirname5 } from "node:path";
+import { homedir as homedir14 } from "node:os";
 function readJsonFile(path2) {
   if (!existsSync11(path2))
     return {};
-  const raw = readFileSync7(path2, "utf8");
+  const raw = readFileSync8(path2, "utf8");
   return JSON.parse(raw);
 }
 function writeJsonFile(path2, data) {
@@ -3671,14 +4596,14 @@ var init_integrations = __esm(() => {
     scopes: HOOK_SCOPES,
     eventTypes: HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve5(cwd) : process.cwd();
+      const base = cwd ? resolve6(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve5(homedir12(), ".claude", "settings.json");
+          return resolve6(homedir14(), ".claude", "settings.json");
         case "project":
-          return resolve5(base, ".claude", "settings.json");
+          return resolve6(base, ".claude", "settings.json");
         case "local":
-          return resolve5(base, ".claude", "settings.local.json");
+          return resolve6(base, ".claude", "settings.local.json");
       }
     },
     readSettings(settingsPath) {
@@ -3779,14 +4704,14 @@ var init_integrations = __esm(() => {
     scopes: CODEX_HOOK_SCOPES,
     eventTypes: CODEX_HOOK_EVENT_TYPES,
     getSettingsPath(scope, cwd) {
-      const base = cwd ? resolve5(cwd) : process.cwd();
+      const base = cwd ? resolve6(cwd) : process.cwd();
       switch (scope) {
         case "user":
-          return resolve5(homedir12(), ".codex", "hooks.json");
+          return resolve6(homedir14(), ".codex", "hooks.json");
         case "project":
-          return resolve5(base, ".codex", "hooks.json");
+          return resolve6(base, ".codex", "hooks.json");
         case "local":
-          return resolve5(base, ".codex", "hooks.json");
+          return resolve6(base, ".codex", "hooks.json");
       }
     },
     readSettings(settingsPath) {
@@ -4081,7 +5006,7 @@ async function promptPolicySelection(preSelected, options = {}) {
     process.stdout.write(output);
     lastLineCount = lines.length;
   }
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     render();
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -4123,7 +5048,7 @@ async function promptPolicySelection(preSelected, options = {}) {
         const selected = items.filter((i) => i.selected).map((i) => i.name);
         process.stdout.write(`
 `);
-        resolve6(selected);
+        resolve7(selected);
       } else if (key.name === "backspace" || key.name === "delete") {
         if (search.length > 0) {
           search = search.slice(0, -1);
@@ -4174,8 +5099,8 @@ __export(exports_manager, {
 });
 import { execSync as execSync4 } from "node:child_process";
 import { existsSync as existsSync12 } from "node:fs";
-import { resolve as resolve6, basename as basename2 } from "node:path";
-import { homedir as homedir13, platform, arch, release, hostname } from "node:os";
+import { resolve as resolve7, basename as basename2 } from "node:path";
+import { homedir as homedir15, platform, arch, release, hostname } from "node:os";
 function getSettingsPath(scope, cwd) {
   return claudeCode.getSettingsPath(scope, cwd);
 }
@@ -4261,7 +5186,7 @@ async function installHooks(policyNames, scope = "user", cwd, includeBeta = fals
   if (removeCustomHooks) {
     delete configToWrite.customPoliciesPath;
   } else if (customPoliciesPath) {
-    configToWrite.customPoliciesPath = resolve6(customPoliciesPath);
+    configToWrite.customPoliciesPath = resolve7(customPoliciesPath);
     let validatedHooks = [];
     try {
       validatedHooks = await loadCustomHooks(configToWrite.customPoliciesPath, { strict: true });
@@ -4278,7 +5203,8 @@ Validated ${validatedHooks.length} custom hook(s): ${validatedHooks.map((h) => h
   }
   writeScopedHooksConfig(configToWrite, scope, cwd);
   console.log(`
-Enabled ${selectedPolicies.length} policy(ies): ${selectedPolicies.join(", ")}`);
+Enabled ${selectedPolicies.length} policy(ies): ${selectedPolicies.join(", ")}
+`);
   if (removeCustomHooks) {
     console.log("Custom hooks path cleared.");
   } else if (configToWrite.customPoliciesPath) {
@@ -4589,10 +5515,10 @@ Failproof AI Hook Policies
     }
     console.log();
   }
-  const base = cwd ? resolve6(cwd) : process.cwd();
+  const base = cwd ? resolve7(cwd) : process.cwd();
   const conventionDirs = [
-    { label: "Project", dir: resolve6(base, ".failproofai", "policies") },
-    { label: "User", dir: resolve6(homedir13(), ".failproofai", "policies") }
+    { label: "Project", dir: resolve7(base, ".failproofai", "policies") },
+    { label: "User", dir: resolve7(homedir15(), ".failproofai", "policies") }
   ];
   for (const { label, dir } of conventionDirs) {
     const files = discoverPolicyFiles(dir);
@@ -4733,7 +5659,7 @@ async function promptCliTargetSelection(detected) {
     process.stdout.write(output);
     lastLineCount = lines.length;
   }
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     render();
     readline2.emitKeypressEvents(process.stdin);
     const wasRaw = process.stdin.isRaw;
@@ -4766,7 +5692,7 @@ async function promptCliTargetSelection(detected) {
         cleanup();
         process.stdout.write(`
 `);
-        resolve7(options[cursor].value);
+        resolve8(options[cursor].value);
       }
     }
     process.stdin.on("keypress", onKey);
@@ -4958,7 +5884,7 @@ async function promptPolicySelection2(preSelected, options = {}) {
     process.stdout.write(output);
     lastLineCount = lines.length;
   }
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     render();
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -5000,7 +5926,7 @@ async function promptPolicySelection2(preSelected, options = {}) {
         const selected = items.filter((i) => i.selected).map((i) => i.name);
         process.stdout.write(`
 `);
-        resolve7(selected);
+        resolve8(selected);
       } else if (key.name === "backspace" || key.name === "delete") {
         if (search.length > 0) {
           search = search.slice(0, -1);
@@ -5162,14 +6088,14 @@ __export(exports_pid, {
   isProcessAlive: () => isProcessAlive2,
   clearPid: () => clearPid2
 });
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync13, unlinkSync as unlinkSync5, mkdirSync as mkdirSync9 } from "node:fs";
-import { join as join10, dirname as dirname6 } from "node:path";
-import { homedir as homedir14 } from "node:os";
+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";
 function readPid2() {
   if (!existsSync13(PID_FILE2))
     return null;
   try {
-    const raw = readFileSync8(PID_FILE2, "utf8").trim();
+    const raw = readFileSync9(PID_FILE2, "utf8").trim();
     const pid = parseInt(raw, 10);
     if (Number.isNaN(pid) || pid <= 0)
       return null;
@@ -5223,26 +6149,18 @@ function relayStatus() {
 }
 var PID_FILE2;
 var init_pid2 = __esm(() => {
-  PID_FILE2 = join10(homedir14(), ".failproofai", "relay.pid");
+  PID_FILE2 = join15(homedir16(), ".failproofai", "relay.pid");
 });
 
-// lib/paths.ts
-import { homedir as homedir15 } from "os";
-import { join as join11 } from "path";
-function getDefaultClaudeProjectsPath() {
-  return join11(homedir15(), ".claude", "projects");
-}
-var init_paths = () => {};
-
 // scripts/parse-script-args.ts
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 function parseStringFlag(flagName, errorLabel, inlineValue, args, index, options) {
   const raw = inlineValue ?? args[index + 1];
   if (raw === undefined || inlineValue === null && raw.startsWith("-")) {
     console.error(`Error: ${flagName} requires ${errorLabel}`);
     process.exit(1);
   }
-  const value = options?.resolve ? resolve7(raw) : raw;
+  const value = options?.resolve ? resolve8(raw) : raw;
   return { value, spliceCount: inlineValue !== null ? 1 : 2 };
 }
 function parseScriptArgs(argv) {
@@ -5304,7 +6222,7 @@ __export(exports_launch, {
 });
 import { spawn as spawn4 } from "child_process";
 import { realpathSync, existsSync as existsSync14 } from "node:fs";
-import { resolve as resolve8, dirname as dirname7 } from "node:path";
+import { resolve as resolve9, dirname as dirname7 } from "node:path";
 import { fileURLToPath } from "node:url";
 function launch(mode) {
   const { claudeProjectsPath: parsedPath, loggingLevel, disableTelemetry, allowedDevOrigins, remainingArgs } = parseScriptArgs(process.argv.slice(2));
@@ -5317,7 +6235,8 @@ function launch(mode) {
                /_/   v${version2}
 `);
   console.log(`  ⭐ Star us:      https://github.com/exospherehost/failproofai`);
-  console.log(`  \uD83D\uDCD6 Docs:         https://befailproof.ai
+  console.log(`  \uD83D\uDCD6 Docs:         https://befailproof.ai`);
+  console.log(`  \uD83D\uDCAC Slack:        https://join.slack.com/t/failproofai/shared_invite/zt-3v63b7k5e-O3NBHmj8X6n9gZSGDx6ggQ
 `);
   let claudeProjectsPath = parsedPath;
   if (!claudeProjectsPath) {
@@ -5335,8 +6254,8 @@ function launch(mode) {
     process.env.PORT = port;
     process.env.HOSTNAME = "0.0.0.0";
     cmd = "node";
-    const packageRoot = process.env.FAILPROOFAI_PACKAGE_ROOT ?? resolve8(dirname7(realpathSync(fileURLToPath(import.meta.url))), "..");
-    const serverJsPath = resolve8(packageRoot, ".next/standalone/server.js");
+    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(`
 Error: Cannot find server.js at:
@@ -5396,17 +6315,17 @@ var init_cli_error2 = __esm(() => {
 
 // bin/failproofai.mjs
 import { realpathSync as realpathSync2 } from "fs";
-import { dirname as dirname8, resolve as resolve9 } from "path";
+import { dirname as dirname8, resolve as resolve10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 // package.json
-var version = "0.0.9-beta.1";
+var version = "0.0.9";
 
 // bin/failproofai.mjs
 if (!process.env.FAILPROOFAI_PACKAGE_ROOT) {
-  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve9(dirname8(realpathSync2(fileURLToPath2(import.meta.url))), "..");
+  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve10(dirname8(realpathSync2(fileURLToPath2(import.meta.url))), "..");
 }
 if (!process.env.FAILPROOFAI_DIST_PATH) {
-  process.env.FAILPROOFAI_DIST_PATH = resolve9(dirname8(realpathSync2(fileURLToPath2(import.meta.url))), "..", "dist");
+  process.env.FAILPROOFAI_DIST_PATH = resolve10(dirname8(realpathSync2(fileURLToPath2(import.meta.url))), "..", "dist");
 }
 var args = process.argv.slice(2);
 if (args[0] === "p")
@@ -5509,6 +6428,7 @@ EXAMPLES
 LINKS
   \u2B50 Star us:      https://github.com/exospherehost/failproofai
   \uD83D\uDCD6 Docs:         https://befailproof.ai
+  \uD83D\uDCAC Slack:        https://join.slack.com/t/failproofai/shared_invite/zt-3v63b7k5e-O3NBHmj8X6n9gZSGDx6ggQ
 `.trimStart());
     process.exit(0);
   }