failproofai 1.0.5-beta.0 → 1.0.5-beta.2

package/dist/worker.mjs

@@ -3483,7 +3483,7 @@ function parsePackPolicyName(canonicalName) {
 }
 
 // package.json
-var version = "1.0.5-beta.0";
+var version = "1.0.5-beta.2";
 var init_package = () => {};
 
 // src/posthog-key.ts
@@ -4290,6 +4290,22 @@ You MUST complete the above action(s) NOW. Do NOT ask the user for confirmation
           decision: "instruct"
         };
       }
+      if (eventType === "PreToolUse") {
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({
+            permission: "instruct",
+            reason: `Instruction from failproofai: ${combined}`,
+            policyName: policyNames[0],
+            policyNames
+          }),
+          stderr: "",
+          policyName: policyNames[0],
+          policyNames,
+          reason: combined,
+          decision: "instruct"
+        };
+      }
       const stderrMsg = instructEntries.map((e) => `[failproofai] ${e.policyName}: ${e.reason}`).join(`
 `);
       return {
@@ -5874,7 +5890,7 @@ var init_cursor_projects = __esm(() => {
 });
 
 // lib/sqlite-reader.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync6 } from "node:fs";
 import initSqlJs from "sql.js/dist/sql-asm.js";
 async function tryNodeSqlite(dbPath) {
   try {
@@ -5898,10 +5914,117 @@ function loadSqlJs() {
     sqlPromise = initSqlJs();
   return sqlPromise;
 }
+function fileVersion(path) {
+  const stat = statSync6(path);
+  return { size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs };
+}
+function sameVersion(a, b) {
+  return a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
+}
+function sqlitePageSize(db) {
+  if (db.length < 100)
+    return null;
+  if (Buffer.from(db.subarray(0, 16)).toString("binary") !== "SQLite format 3\x00")
+    return null;
+  const encoded = db[16] << 8 | db[17];
+  const pageSize = encoded === 1 ? 65536 : encoded;
+  return pageSize >= 512 && pageSize <= 65536 && (pageSize & pageSize - 1) === 0 ? pageSize : null;
+}
+function walChecksum(bytes, offset, length, bigEndian, initial = [0, 0]) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let [sum1, sum2] = initial;
+  for (let cursor = offset;cursor < offset + length; cursor += 8) {
+    const first = view.getUint32(cursor, !bigEndian);
+    const second = view.getUint32(cursor + 4, !bigEndian);
+    sum1 = sum1 + first + sum2 >>> 0;
+    sum2 = sum2 + second + sum1 >>> 0;
+  }
+  return [sum1, sum2];
+}
+function applyCommittedWal(db, wal) {
+  const pageSize = sqlitePageSize(db);
+  if (pageSize === null || wal.length < 32)
+    return db;
+  const view = new DataView(wal.buffer, wal.byteOffset, wal.byteLength);
+  const magic = view.getUint32(0, false);
+  if (magic !== 931071618 && magic !== 931071619)
+    return db;
+  if (view.getUint32(4, false) !== 3007000)
+    return db;
+  if (view.getUint32(8, false) !== pageSize)
+    return db;
+  const checksumBigEndian = (magic & 1) === 1;
+  let checksum = walChecksum(wal, 0, 24, checksumBigEndian);
+  if (view.getUint32(24, false) !== checksum[0] || view.getUint32(28, false) !== checksum[1]) {
+    return db;
+  }
+  const salt1 = view.getUint32(16, false);
+  const salt2 = view.getUint32(20, false);
+  const frameSize = 24 + pageSize;
+  const frameCount = Math.floor((wal.length - 32) / frameSize);
+  let lastCommit = -1;
+  let committedPages = 0;
+  for (let index = 0;index < frameCount; index += 1) {
+    const offset = 32 + index * frameSize;
+    const pageNumber = view.getUint32(offset, false);
+    if (pageNumber === 0 || view.getUint32(offset + 8, false) !== salt1 || view.getUint32(offset + 12, false) !== salt2) {
+      break;
+    }
+    checksum = walChecksum(wal, offset, 8, checksumBigEndian, checksum);
+    checksum = walChecksum(wal, offset + 24, pageSize, checksumBigEndian, checksum);
+    if (view.getUint32(offset + 16, false) !== checksum[0] || view.getUint32(offset + 20, false) !== checksum[1]) {
+      break;
+    }
+    const databasePages = view.getUint32(offset + 4, false);
+    if (databasePages > 0) {
+      lastCommit = index;
+      committedPages = databasePages;
+    }
+  }
+  if (lastCommit < 0 || committedPages === 0)
+    return db;
+  const targetSize = committedPages * pageSize;
+  if (!Number.isSafeInteger(targetSize) || targetSize > db.length + frameCount * pageSize) {
+    return db;
+  }
+  const snapshot = new Uint8Array(targetSize);
+  snapshot.set(db.subarray(0, targetSize));
+  for (let index = 0;index <= lastCommit; index += 1) {
+    const offset = 32 + index * frameSize;
+    const pageNumber = view.getUint32(offset, false);
+    const destination = (pageNumber - 1) * pageSize;
+    if (destination >= targetSize)
+      continue;
+    snapshot.set(wal.subarray(offset + 24, offset + frameSize), destination);
+  }
+  return snapshot;
+}
+function readPortableSnapshot(dbPath) {
+  const walPath = `${dbPath}-wal`;
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    const before = fileVersion(dbPath);
+    const main = readFileSync6(dbPath);
+    const afterMain = fileVersion(dbPath);
+    if (!sameVersion(before, afterMain))
+      continue;
+    let wal = null;
+    try {
+      wal = readFileSync6(walPath);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    const afterWal = fileVersion(dbPath);
+    if (!sameVersion(before, afterWal))
+      continue;
+    return wal ? applyCommittedWal(main, wal) : main;
+  }
+  throw new Error(`SQLite database changed while reading: ${dbPath}`);
+}
 async function trySqlJs(dbPath) {
   try {
     const SQL = await loadSqlJs();
-    const db = new SQL.Database(readFileSync6(dbPath));
+    const db = new SQL.Database(readPortableSnapshot(dbPath));
     return {
       query(sql, params) {
         const stmt = db.prepare(sql);
@@ -5924,10 +6047,15 @@ async function trySqlJs(dbPath) {
     return null;
   }
 }
-async function openSqliteReadonly(dbPath) {
+async function openSqliteReadonly(dbPath, options = {}) {
   if (!existsSync8(dbPath))
     return null;
-  return await tryNodeSqlite(dbPath) ?? await trySqlJs(dbPath);
+  if (!options.forcePortable) {
+    const native = await tryNodeSqlite(dbPath);
+    if (native)
+      return native;
+  }
+  return trySqlJs(dbPath);
 }
 var sqlPromise = null;
 var init_sqlite_reader = () => {};
@@ -6636,13 +6764,169 @@ var init_hermes_projects = __esm(() => {
   getCachedHermesSessionsByEncodedName = runtimeCache((name) => getHermesSessionsByEncodedName(name), 2, { maxSize: 50 });
 });
 
+// lib/openclaw-db.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join13 } from "node:path";
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function parseObject(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function syntheticPath(agentId, sessionId) {
+  return `openclaw-sqlite://${encodeURIComponent(agentId)}/${sessionId}`;
+}
+function listOpenClawDatabases(home, agentIds) {
+  const out = [];
+  for (const agentId of agentIds) {
+    const dbPath = join13(home, "agents", agentId, "agent", DB_NAME);
+    if (existsSync9(dbPath))
+      out.push({ agentId, dbPath });
+  }
+  return out;
+}
+function readNodeMetadata(db) {
+  const out = new Map;
+  let rows;
+  try {
+    rows = db.query(`SELECT current_session_id, entry_json, label, display_name
+         FROM session_nodes`);
+  } catch {
+    return out;
+  }
+  for (const row of rows) {
+    const entry = parseObject(row.entry_json) ?? {};
+    const origin = entry.origin && typeof entry.origin === "object" && !Array.isArray(entry.origin) ? entry.origin : {};
+    out.set(row.current_session_id, {
+      channel: str(entry.lastChannel) ?? str(origin.provider) ?? str(origin.surface),
+      label: str(row.label) ?? str(row.display_name) ?? str(entry.displayName) ?? str(origin.label),
+      chatId: str(entry.lastTo) ?? str(origin.from),
+      chatType: str(entry.chatType) ?? str(origin.chatType)
+    });
+  }
+  return out;
+}
+function readConversationMetadata(db) {
+  const out = new Map;
+  let rows;
+  try {
+    rows = db.query(`SELECT sc.session_id, c.channel, c.kind, c.peer_id,
+              c.delivery_target, c.label
+         FROM session_conversations sc
+         JOIN conversations c ON c.conversation_id = sc.conversation_id
+        ORDER BY CASE sc.role WHEN 'primary' THEN 0 ELSE 1 END, sc.last_seen_at DESC`);
+  } catch {
+    return out;
+  }
+  for (const row of rows) {
+    if (out.has(row.session_id))
+      continue;
+    out.set(row.session_id, {
+      channel: str(row.channel),
+      label: str(row.label),
+      chatId: str(row.delivery_target) ?? str(row.peer_id),
+      chatType: str(row.kind)
+    });
+  }
+  return out;
+}
+async function listOpenClawSqliteSessions(home, agentIds) {
+  const sessions = [];
+  for (const { agentId, dbPath } of listOpenClawDatabases(home, agentIds)) {
+    const db = await openSqliteReadonly(dbPath);
+    if (!db)
+      continue;
+    try {
+      let rows;
+      try {
+        rows = db.query(`SELECT w.session_id, w.session_key, w.updated_at,
+                  w.transcript_updated_at, w.ended_at, w.channel,
+                  w.chat_type, w.display_name,
+                  COALESCE((SELECT MAX(e.created_at)
+                              FROM transcript_events e
+                             WHERE e.session_id = w.session_id), 0) AS event_updated_at,
+                  COALESCE((SELECT SUM(length(e.event_json) + 1)
+                              FROM transcript_events e
+                             WHERE e.session_id = w.session_id), 0) AS size_bytes
+             FROM session_windows w
+            WHERE EXISTS (SELECT 1 FROM transcript_events e
+                           WHERE e.session_id = w.session_id)`);
+      } catch {
+        continue;
+      }
+      const nodes = readNodeMetadata(db);
+      const conversations = readConversationMetadata(db);
+      for (const row of rows) {
+        const node = nodes.get(row.session_id);
+        const conversation = conversations.get(row.session_id);
+        sessions.push({
+          sessionId: row.session_id,
+          agentId,
+          dbPath,
+          transcriptPath: syntheticPath(agentId, row.session_id),
+          mtimeMs: Math.max(Number(row.updated_at) || 0, Number(row.transcript_updated_at) || 0, Number(row.ended_at) || 0, Number(row.event_updated_at) || 0),
+          sizeBytes: Number(row.size_bytes) || 0,
+          channel: str(row.channel) ?? conversation?.channel ?? node?.channel ?? "local",
+          label: str(row.display_name) ?? conversation?.label ?? node?.label,
+          chatId: conversation?.chatId ?? node?.chatId,
+          chatType: str(row.chat_type) ?? conversation?.chatType ?? node?.chatType
+        });
+      }
+    } finally {
+      db.close();
+    }
+  }
+  return sessions;
+}
+async function readOpenClawSqliteTranscript(home, agentIds, sessionId) {
+  for (const { agentId, dbPath } of listOpenClawDatabases(home, agentIds)) {
+    const db = await openSqliteReadonly(dbPath);
+    if (!db)
+      continue;
+    try {
+      let rows;
+      try {
+        rows = db.query(`SELECT event_json
+             FROM transcript_events
+            WHERE session_id = ?
+            ORDER BY seq ASC`, [sessionId]);
+      } catch {
+        continue;
+      }
+      if (rows.length === 0)
+        continue;
+      const eventJsonLines = rows.map((row) => row.event_json);
+      const rawLines = eventJsonLines.map(parseObject).filter((line) => line !== undefined);
+      return {
+        agentId,
+        dbPath,
+        filePath: syntheticPath(agentId, sessionId),
+        rawLines,
+        eventJsonLines
+      };
+    } finally {
+      db.close();
+    }
+  }
+  return null;
+}
+var DB_NAME = "openclaw-agent.sqlite";
+var init_openclaw_db = __esm(() => {
+  init_sqlite_reader();
+});
+
 // lib/openclaw-sessions.ts
 import { readFile as readFile7 } from "node:fs/promises";
-import { readdirSync as readdirSync4, statSync as statSync6 } from "node:fs";
+import { readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function openclawHome() {
-  return process.env.OPENCLAW_HOME || join13(homedir11(), ".openclaw");
+  return process.env.OPENCLAW_STATE_DIR || process.env.OPENCLAW_HOME || join14(homedir11(), ".openclaw");
 }
 function isPlainObject2(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
@@ -6729,7 +7013,11 @@ function openclawLinesToLogEntries(lines, source = "session") {
       entries.push({
         type: "assistant",
         ...base,
-        message: { role: "assistant", content: blocks, model: typeof m.model === "string" ? m.model : undefined }
+        message: {
+          role: "assistant",
+          content: blocks,
+          model: typeof m.model === "string" ? m.model : undefined
+        }
       });
       continue;
     }
@@ -6757,13 +7045,13 @@ function openclawLinesToLogEntries(lines, source = "session") {
 }
 function listOpenClawAgents() {
   try {
-    return readdirSync4(join13(openclawHome(), "agents"), { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name).sort();
+    return readdirSync4(join14(openclawHome(), "agents"), { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name).sort();
   } catch {
     return [];
   }
 }
 function listOpenClawTranscripts() {
-  const agentsDir = join13(openclawHome(), "agents");
+  const agentsDir = join14(openclawHome(), "agents");
   const out = [];
   let agentIds;
   try {
@@ -6772,7 +7060,7 @@ function listOpenClawTranscripts() {
     return out;
   }
   for (const agentId of agentIds) {
-    const sessionsDir = join13(agentsDir, agentId, "sessions");
+    const sessionsDir = join14(agentsDir, agentId, "sessions");
     let files;
     try {
       files = readdirSync4(sessionsDir);
@@ -6785,10 +7073,16 @@ function listOpenClawTranscripts() {
       const sessionId = file.slice(0, -".jsonl".length);
       if (!OPENCLAW_SESSION_ID_RE.test(sessionId))
         continue;
-      const transcriptPath = join13(sessionsDir, file);
+      const transcriptPath = join14(sessionsDir, file);
       try {
-        const st = statSync6(transcriptPath);
-        out.push({ agentId, sessionId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
+        const st = statSync7(transcriptPath);
+        out.push({
+          agentId,
+          sessionId,
+          transcriptPath,
+          mtimeMs: st.mtimeMs,
+          sizeBytes: st.size
+        });
       } catch {}
     }
   }
@@ -6804,6 +7098,25 @@ function findOpenClawTranscript(sessionId) {
   return null;
 }
 async function getOpenClawSessionLog(sessionId) {
+  if (!OPENCLAW_SESSION_ID_RE.test(sessionId))
+    return null;
+  const sqlite = await readOpenClawSqliteTranscript(openclawHome(), listOpenClawAgents(), sessionId);
+  if (sqlite) {
+    const entries = openclawLinesToLogEntries(sqlite.rawLines, "session");
+    let cwd;
+    for (const line of sqlite.rawLines) {
+      if (line.type === "session" && typeof line.cwd === "string" && line.cwd.length > 0) {
+        cwd = line.cwd;
+        break;
+      }
+    }
+    return {
+      entries,
+      rawLines: sqlite.rawLines,
+      cwd,
+      filePath: sqlite.filePath
+    };
+  }
   const filePath = findOpenClawTranscript(sessionId);
   if (!filePath)
     return null;
@@ -6827,6 +7140,7 @@ async function getOpenClawSessionLog(sessionId) {
 var OPENCLAW_SESSION_ID_RE, getCachedOpenClawSessionLog;
 var init_openclaw_sessions = __esm(() => {
   init_log_entries();
+  init_openclaw_db();
   OPENCLAW_SESSION_ID_RE = /^[0-9a-fA-F-]{36}$/;
   getCachedOpenClawSessionLog = runtimeCache((sessionId) => getOpenClawSessionLog(sessionId), 2, { maxSize: 50 });
 });
@@ -6837,13 +7151,13 @@ __export(exports_openclaw_projects, {
   getOpenClawProjects: () => getOpenClawProjects
 });
 import { readFileSync as readFileSync7 } from "node:fs";
-import { join as join14 } from "node:path";
-function str(v) {
+import { join as join15 } from "node:path";
+function str2(v) {
   return typeof v === "string" && v.length > 0 ? v : undefined;
 }
 function readSessionsIndex(agentId) {
   const out = new Map;
-  const indexPath = join14(openclawHome(), "agents", agentId, "sessions", "sessions.json");
+  const indexPath = join15(openclawHome(), "agents", agentId, "sessions", "sessions.json");
   let raw;
   try {
     raw = JSON.parse(readFileSync7(indexPath, "utf-8"));
@@ -6856,17 +7170,17 @@ function readSessionsIndex(agentId) {
     if (!v || typeof v !== "object")
       continue;
     const e = v;
-    const sessionId = str(e.sessionId);
+    const sessionId = str2(e.sessionId);
     if (!sessionId)
       continue;
     const origin = e.origin && typeof e.origin === "object" ? e.origin : {};
     const lastMs = typeof e.lastInteractionAt === "number" ? e.lastInteractionAt : typeof e.updatedAt === "number" ? e.updatedAt : undefined;
     out.set(sessionId, {
       lastMs,
-      channel: str(e.lastChannel) ?? str(origin.provider) ?? str(origin.surface),
-      chatType: str(e.chatType) ?? str(origin.chatType),
-      label: str(origin.label),
-      chatId: str(e.lastTo) ?? str(origin.from)
+      channel: str2(e.lastChannel) ?? str2(origin.provider) ?? str2(origin.surface),
+      chatType: str2(e.chatType) ?? str2(origin.chatType),
+      label: str2(origin.label),
+      chatId: str2(e.lastTo) ?? str2(origin.from)
     });
   }
   return out;
@@ -6874,7 +7188,7 @@ function readSessionsIndex(agentId) {
 async function getOpenClawSessions() {
   const transcripts = listOpenClawTranscripts();
   const indexByAgent = new Map;
-  const refs = [];
+  const refs = new Map;
   for (const t of transcripts) {
     let idx = indexByAgent.get(t.agentId);
     if (!idx) {
@@ -6882,7 +7196,7 @@ async function getOpenClawSessions() {
       indexByAgent.set(t.agentId, idx);
     }
     const meta = idx.get(t.sessionId);
-    refs.push({
+    refs.set(`${t.agentId}\x00${t.sessionId}`, {
       sessionId: t.sessionId,
       agentId: t.agentId,
       channel: meta?.channel ?? "local",
@@ -6894,8 +7208,11 @@ async function getOpenClawSessions() {
       sizeBytes: t.sizeBytes
     });
   }
-  refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  return refs;
+  const sqliteSessions = await listOpenClawSqliteSessions(openclawHome(), listOpenClawAgents());
+  for (const s of sqliteSessions) {
+    refs.set(`${s.agentId}\x00${s.sessionId}`, s);
+  }
+  return [...refs.values()].sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 function openClawProjectName(agentId, channel) {
   return `openclaw-${agentId}-${channel}`;
@@ -6930,7 +7247,12 @@ async function getOpenClawProjects() {
       prev.latest = Math.max(prev.latest, s.mtimeMs);
       prev.count += 1;
     } else {
-      groups.set(key, { agentId: s.agentId, channel: s.channel, latest: s.mtimeMs, count: 1 });
+      groups.set(key, {
+        agentId: s.agentId,
+        channel: s.channel,
+        latest: s.mtimeMs,
+        count: 1
+      });
     }
   }
   const out = [];
@@ -6988,6 +7310,7 @@ async function getOpenClawSessionsByEncodedName(name) {
 var getCachedOpenClawSessions, getCachedOpenClawProjects, getCachedOpenClawSessionsByEncodedName;
 var init_openclaw_projects = __esm(() => {
   init_openclaw_sessions();
+  init_openclaw_db();
   getCachedOpenClawSessions = runtimeCache(getOpenClawSessions, 2);
   getCachedOpenClawProjects = runtimeCache(getOpenClawProjects, 2);
   getCachedOpenClawSessionsByEncodedName = runtimeCache((name) => getOpenClawSessionsByEncodedName(name), 2, { maxSize: 50 });
@@ -6995,14 +7318,14 @@ var init_openclaw_projects = __esm(() => {
 
 // lib/factory-sessions.ts
 import { readFile as readFile8 } from "node:fs/promises";
-import { readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
+import { readdirSync as readdirSync5, statSync as statSync8 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function factoryHome() {
-  return process.env.FACTORY_HOME || join15(homedir12(), ".factory");
+  return process.env.FACTORY_HOME || join16(homedir12(), ".factory");
 }
 function factorySessionsRoot() {
-  return join15(factoryHome(), "sessions");
+  return join16(factoryHome(), "sessions");
 }
 function isPlainObject3(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
@@ -7148,7 +7471,7 @@ function listFactoryTranscripts() {
   for (const dir of projectDirs) {
     const projectName = dir.name;
     const cwd = decodeFolderName(projectName);
-    const projectPath = join15(root, projectName);
+    const projectPath = join16(root, projectName);
     let files;
     try {
       files = readdirSync5(projectPath);
@@ -7161,9 +7484,9 @@ function listFactoryTranscripts() {
       const sessionId = file.slice(0, -".jsonl".length);
       if (!FACTORY_SESSION_ID_RE.test(sessionId))
         continue;
-      const transcriptPath = join15(projectPath, file);
+      const transcriptPath = join16(projectPath, file);
       try {
-        const st = statSync7(transcriptPath);
+        const st = statSync8(transcriptPath);
         out.push({ projectName, cwd, sessionId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
       } catch {}
     }
@@ -7285,12 +7608,12 @@ var init_factory_projects = __esm(() => {
 
 // lib/devin-sessions.ts
 import { homedir as homedir13 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function devinHome() {
-  return process.env.DEVIN_HOME || join16(homedir13(), ".local", "share", "devin");
+  return process.env.DEVIN_HOME || join17(homedir13(), ".local", "share", "devin");
 }
 function devinDbPath() {
-  return process.env.DEVIN_DB_PATH || join16(devinHome(), "cli", "sessions.db");
+  return process.env.DEVIN_DB_PATH || join17(devinHome(), "cli", "sessions.db");
 }
 function devinEpochToMs(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -7582,17 +7905,17 @@ var init_devin_projects = __esm(() => {
 
 // lib/antigravity-sessions.ts
 import { readFile as readFile9 } from "node:fs/promises";
-import { readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
+import { readdirSync as readdirSync6, statSync as statSync9 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function antigravityHome() {
-  return process.env.ANTIGRAVITY_HOME || join17(homedir14(), ".gemini", "antigravity-cli");
+  return process.env.ANTIGRAVITY_HOME || join18(homedir14(), ".gemini", "antigravity-cli");
 }
 function antigravityBrainRoot() {
-  return join17(antigravityHome(), "brain");
+  return join18(antigravityHome(), "brain");
 }
 function antigravityTranscriptRelPath() {
-  return join17(".system_generated", "logs", "transcript_full.jsonl");
+  return join18(".system_generated", "logs", "transcript_full.jsonl");
 }
 function isPlainObject5(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
@@ -7715,9 +8038,9 @@ function listAntigravityTranscripts() {
     const conversationId = dir.name;
     if (!ANTIGRAVITY_CONVERSATION_ID_RE.test(conversationId))
       continue;
-    const transcriptPath = join17(root, conversationId, rel);
+    const transcriptPath = join18(root, conversationId, rel);
     try {
-      const st = statSync8(transcriptPath);
+      const st = statSync9(transcriptPath);
       if (!st.isFile())
         continue;
       out.push({ conversationId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
@@ -7728,9 +8051,9 @@ function listAntigravityTranscripts() {
 function findAntigravityTranscript(conversationId) {
   if (!ANTIGRAVITY_CONVERSATION_ID_RE.test(conversationId))
     return null;
-  const transcriptPath = join17(antigravityBrainRoot(), conversationId, antigravityTranscriptRelPath());
+  const transcriptPath = join18(antigravityBrainRoot(), conversationId, antigravityTranscriptRelPath());
   try {
-    if (statSync8(transcriptPath).isFile())
+    if (statSync9(transcriptPath).isFile())
       return transcriptPath;
   } catch {}
   return null;
@@ -7763,9 +8086,9 @@ var exports_antigravity_projects = {};
 __export(exports_antigravity_projects, {
   getAntigravityProjects: () => getAntigravityProjects
 });
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function antigravitySummariesDbPath() {
-  return join18(antigravityHome(), "conversation_summaries.db");
+  return join19(antigravityHome(), "conversation_summaries.db");
 }
 function parseWorkspaceCwd(raw) {
   if (!raw)
@@ -7909,15 +8232,15 @@ var init_antigravity_projects = __esm(() => {
 
 // lib/goose-sessions.ts
 import { homedir as homedir15 } from "node:os";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 function gooseHome() {
   if (process.env.GOOSE_HOME)
     return process.env.GOOSE_HOME;
   const xdg = process.env.XDG_DATA_HOME;
-  return join19(xdg && xdg.length > 0 ? xdg : join19(homedir15(), ".local", "share"), "goose");
+  return join20(xdg && xdg.length > 0 ? xdg : join20(homedir15(), ".local", "share"), "goose");
 }
 function gooseDbPath() {
-  return process.env.GOOSE_DB_PATH || join19(gooseHome(), "sessions", "sessions.db");
+  return process.env.GOOSE_DB_PATH || join20(gooseHome(), "sessions", "sessions.db");
 }
 function gooseTimestampToMs(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -8180,7 +8503,7 @@ var init_goose_projects = __esm(() => {
 
 // lib/projects.ts
 import { readdir as readdir5, stat as stat4 } from "node:fs/promises";
-import { join as join20, resolve as resolve9, sep } from "node:path";
+import { join as join21, resolve as resolve9, sep } from "node:path";
 async function getMtime(path, label) {
   try {
     return (await stat4(path)).mtime;
@@ -8206,7 +8529,7 @@ async function getClaudeProjectFolders() {
     if (!entries)
       return [];
     const settled = await batchAll(entries.filter((entry) => entry.isDirectory()).map((entry) => async () => {
-      const folderPath = join20(projectsPath, entry.name);
+      const folderPath = join21(projectsPath, entry.name);
       const mtime = await getMtime(folderPath, entry.name);
       return {
         name: entry.name,
@@ -8333,7 +8656,7 @@ function resolveProjectPath(projectName) {
   if (/^[/\\]/.test(projectName))
     throw new RangeError("Absolute project name");
   const projectsPath = resolve9(getClaudeProjectsPath());
-  const candidate = resolve9(join20(projectsPath, projectName));
+  const candidate = resolve9(join21(projectsPath, projectName));
   if (!candidate.startsWith(projectsPath + sep)) {
     throw new RangeError("Project path escapes root");
   }
@@ -8351,7 +8674,7 @@ async function getSessionFiles(projectPath) {
       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 = join20(projectPath, entry.name);
+      const filePath = join21(projectPath, entry.name);
       const mtime = await getMtime(filePath, entry.name);
       return {
         name: entry.name,
@@ -8380,13 +8703,13 @@ var init_projects = __esm(() => {
 
 // lib/resolve-subagent-path.ts
 import { access as access2 } from "fs/promises";
-import { join as join21, relative as relative3 } from "path";
+import { join as join22, relative as relative3 } from "path";
 async function resolveSubagentPath(projectsPath, projectName, sessionId, agentId) {
   const fileName = `agent-${agentId}.jsonl`;
   const candidatePaths = [
-    join21(projectsPath, projectName, fileName),
-    join21(projectsPath, projectName, sessionId, fileName),
-    join21(projectsPath, projectName, sessionId, "subagents", fileName)
+    join22(projectsPath, projectName, fileName),
+    join22(projectsPath, projectName, sessionId, fileName),
+    join22(projectsPath, projectName, sessionId, "subagents", fileName)
   ];
   for (const candidatePath of candidatePaths) {
     if (relative3(projectsPath, candidatePath).startsWith("..")) {
@@ -8408,7 +8731,7 @@ var init_resolve_subagent_path = () => {};
 
 // lib/log-entries.ts
 import { readFile as readFile10 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function formatTimestamp(date) {
   const base = formatDate(date);
   const ms = date.getMilliseconds().toString().padStart(3, "0");
@@ -8602,7 +8925,7 @@ async function parseFileContent(fileContent, source) {
 async function parseSessionLog(projectName, sessionId) {
   const projectDir = resolveProjectPath(projectName);
   const projectsPath = getClaudeProjectsPath();
-  const filePath = join22(projectDir, `${sessionId}.jsonl`);
+  const filePath = join23(projectDir, `${sessionId}.jsonl`);
   const fileContent = await readFile10(filePath, "utf-8");
   const { entries: sessionEntries, rawLines: sessionRawLines, subagentIds } = await parseFileContent(fileContent, "session");
   if (subagentIds.length === 0) {
@@ -8639,13 +8962,13 @@ var init_log_entries = __esm(() => {
 });
 
 // lib/codex-sessions.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync7, existsSync as existsSync9, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, statSync as statSync9 } from "node:fs";
+import { readFileSync as readFileSync8, readdirSync as readdirSync7, existsSync as existsSync10, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, statSync as statSync10 } from "node:fs";
 import { readFile as readFile11 } from "node:fs/promises";
-import { dirname as dirname4, join as join23 } from "node:path";
+import { dirname as dirname4, join as join24 } from "node:path";
 import { homedir as homedir16 } from "node:os";
 function readCache() {
   try {
-    if (!existsSync9(CACHE_PATH))
+    if (!existsSync10(CACHE_PATH))
       return {};
     return JSON.parse(readFileSync8(CACHE_PATH, "utf-8"));
   } catch {
@@ -8664,7 +8987,7 @@ function dirSearch(dir, sessionId) {
   try {
     for (const f of readdirSync7(dir, { withFileTypes: true })) {
       if (f.isFile() && f.name.includes(sessionId) && f.name.endsWith(".jsonl")) {
-        return join23(dir, f.name);
+        return join24(dir, f.name);
       }
     }
   } catch {}
@@ -8673,16 +8996,16 @@ function dirSearch(dir, sessionId) {
 function findCodexTranscript(sessionId) {
   const cache = readCache();
   const cached = cache[sessionId];
-  if (cached && existsSync9(cached))
+  if (cached && existsSync10(cached))
     return cached;
-  const root = join23(homedir16(), ".codex", "sessions");
+  const root = join24(homedir16(), ".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 join23(root, y, m, day);
+    return join24(root, y, m, day);
   });
   for (const dir of datedDirs) {
     const hit = dirSearch(dir, sessionId);
@@ -8695,13 +9018,13 @@ function findCodexTranscript(sessionId) {
     for (const y of readdirSync7(root, { withFileTypes: true })) {
       if (!y.isDirectory())
         continue;
-      for (const m of readdirSync7(join23(root, y.name), { withFileTypes: true })) {
+      for (const m of readdirSync7(join24(root, y.name), { withFileTypes: true })) {
         if (!m.isDirectory())
           continue;
-        for (const d of readdirSync7(join23(root, y.name, m.name), { withFileTypes: true })) {
+        for (const d of readdirSync7(join24(root, y.name, m.name), { withFileTypes: true })) {
           if (!d.isDirectory())
             continue;
-          const hit = dirSearch(join23(root, y.name, m.name, d.name), sessionId);
+          const hit = dirSearch(join24(root, y.name, m.name, d.name), sessionId);
           if (hit) {
             writeCacheEntry(sessionId, hit);
             return hit;
@@ -8967,15 +9290,15 @@ var init_resolve_permission_mode = __esm(() => {
 });
 
 // lib/copilot-sessions.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync8, existsSync as existsSync10, statSync as statSync10 } from "node:fs";
+import { readFileSync as readFileSync10, readdirSync as readdirSync8, existsSync as existsSync11, statSync as statSync11 } from "node:fs";
 import { readFile as readFile12 } from "node:fs/promises";
-import { join as join24, resolve as resolve10, sep as sep2 } from "node:path";
+import { join as join25, resolve as resolve10, sep as sep2 } from "node:path";
 import { homedir as homedir17 } from "node:os";
 function getCopilotHome() {
-  return process.env.COPILOT_HOME || join24(homedir17(), ".copilot");
+  return process.env.COPILOT_HOME || join25(homedir17(), ".copilot");
 }
 function getCopilotSessionStateRoot2() {
-  return join24(getCopilotHome(), "session-state");
+  return join25(getCopilotHome(), "session-state");
 }
 function getCopilotSessionDir(sessionId) {
   if (!sessionId)
@@ -8990,19 +9313,19 @@ function resolveSessionFile(sessionId, filename) {
   const dir = getCopilotSessionDir(sessionId);
   if (!dir)
     return null;
-  return join24(dir, filename);
+  return join25(dir, filename);
 }
 function findCopilotTranscript(sessionId) {
   const candidate = resolveSessionFile(sessionId, "events.jsonl");
   if (!candidate)
     return null;
-  return existsSync10(candidate) ? candidate : null;
+  return existsSync11(candidate) ? candidate : null;
 }
 function findCopilotWorkspace(sessionId) {
   const candidate = resolveSessionFile(sessionId, "workspace.yaml");
   if (!candidate)
     return null;
-  return existsSync10(candidate) ? candidate : null;
+  return existsSync11(candidate) ? candidate : null;
 }
 function readYamlScalar(path, key) {
   try {
@@ -9184,12 +9507,12 @@ var init_copilot_sessions = __esm(() => {
 });
 
 // lib/cursor-sessions.ts
-import { readFileSync as readFileSync11, readdirSync as readdirSync9, existsSync as existsSync11, statSync as statSync11 } from "node:fs";
+import { readFileSync as readFileSync11, readdirSync as readdirSync9, existsSync as existsSync12, statSync as statSync12 } from "node:fs";
 import { readFile as readFile13 } from "node:fs/promises";
-import { basename as basename3, join as join25, resolve as resolve11, sep as sep3 } from "node:path";
+import { basename as basename3, join as join26, resolve as resolve11, sep as sep3 } from "node:path";
 import { homedir as homedir18 } from "node:os";
 function getCursorHome2() {
-  return process.env.CURSOR_HOME || join25(homedir18(), ".cursor");
+  return process.env.CURSOR_HOME || join26(homedir18(), ".cursor");
 }
 function getCursorSessionDir(sessionId) {
   if (!sessionId)
@@ -9207,7 +9530,7 @@ function getCursorSessionDir(sessionId) {
     const transcriptRoot = resolve11(projectsRoot, entry.name, NEW_AGENT_TRANSCRIPTS_DIR2);
     if (candidate === transcriptRoot || !candidate.startsWith(`${transcriptRoot}${sep3}`))
       continue;
-    if (existsSync11(candidate))
+    if (existsSync12(candidate))
       return candidate;
   }
   for (const sub of LEGACY_SESSION_ROOT_CANDIDATES2) {
@@ -9215,7 +9538,7 @@ function getCursorSessionDir(sessionId) {
     const candidate = resolve11(root, sessionId);
     if (candidate === root || !candidate.startsWith(`${root}${sep3}`))
       continue;
-    if (existsSync11(candidate))
+    if (existsSync12(candidate))
       return candidate;
   }
   return null;
@@ -9224,12 +9547,12 @@ function findCursorTranscript(sessionId) {
   const dir = getCursorSessionDir(sessionId);
   if (!dir)
     return null;
-  const newCandidate = join25(dir, `${basename3(dir)}.jsonl`);
-  if (existsSync11(newCandidate))
+  const newCandidate = join26(dir, `${basename3(dir)}.jsonl`);
+  if (existsSync12(newCandidate))
     return newCandidate;
   for (const name of LEGACY_TRANSCRIPT_FILE_CANDIDATES2) {
-    const candidate = join25(dir, name);
-    if (existsSync11(candidate))
+    const candidate = join26(dir, name);
+    if (existsSync12(candidate))
       return candidate;
   }
   return null;
@@ -9440,12 +9763,12 @@ var init_cursor_sessions = __esm(() => {
 });
 
 // lib/pi-sessions.ts
-import { readFileSync as readFileSync12, readdirSync as readdirSync10, existsSync as existsSync12, statSync as statSync12 } from "node:fs";
+import { readFileSync as readFileSync12, readdirSync as readdirSync10, existsSync as existsSync13, statSync as statSync13 } from "node:fs";
 import { readFile as readFile14 } from "node:fs/promises";
-import { join as join26, resolve as resolve12, sep as sep4 } from "node:path";
+import { join as join27, resolve as resolve12, sep as sep4 } from "node:path";
 import { homedir as homedir19 } from "node:os";
 function getPiSessionStateRoot() {
-  return process.env.PI_SESSIONS_DIR || join26(homedir19(), ".pi", "agent", "sessions");
+  return process.env.PI_SESSIONS_DIR || join27(homedir19(), ".pi", "agent", "sessions");
 }
 function isSafeSessionId(sessionId) {
   return UUID_RE.test(sessionId);
@@ -9477,7 +9800,7 @@ function findPiTranscript(sessionId) {
       const candidate = resolve12(cwdPath, f);
       if (!candidate.startsWith(`${cwdPath}${sep4}`))
         continue;
-      if (existsSync12(candidate))
+      if (existsSync13(candidate))
         return candidate;
     }
   }
@@ -9837,9 +10160,9 @@ var init_pack_failclosed = __esm(() => {
 var init_atomic_write = () => {};
 
 // src/hooks/session-pause.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readdirSync as readdirSync11, readFileSync as readFileSync13, rmSync as rmSync2 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readdirSync as readdirSync11, readFileSync as readFileSync13, rmSync as rmSync2 } from "node:fs";
 import { createHash as createHash5 } from "node:crypto";
-import { join as join27, resolve as resolve13 } from "node:path";
+import { join as join28, resolve as resolve13 } from "node:path";
 function pauseStateDir() {
   const override = process.env.FAILPROOFAI_STATE_DIR;
   if (override)
@@ -9848,7 +10171,7 @@ function pauseStateDir() {
 }
 function pauseFilePath(sessionId) {
   const digest = createHash5("sha256").update(sessionId).digest("hex").slice(0, 32);
-  return join27(pauseStateDir(), `${digest}.json`);
+  return join28(pauseStateDir(), `${digest}.json`);
 }
 function parseStored(raw) {
   if (!raw || typeof raw !== "object")
@@ -9877,7 +10200,7 @@ function readActivePause(sessionId, now = Date.now()) {
     return null;
   try {
     const path = pauseFilePath(sessionId);
-    if (!existsSync13(path))
+    if (!existsSync14(path))
       return null;
     const stored = parseStored(JSON.parse(readFileSync13(path, "utf8")));
     if (!stored)
@@ -9918,14 +10241,14 @@ var init_daemon_service = __esm(() => {
 // src/hooks/fp-reset.ts
 import {
   copyFileSync,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync14,
   readdirSync as readdirSync12,
   renameSync as renameSync3,
   rmSync as rmSync3,
   rmdirSync,
-  statSync as statSync13,
+  statSync as statSync14,
   writeFileSync as writeFileSync5
 } from "node:fs";
 function layoutWarningForHook() {
@@ -9935,7 +10258,7 @@ function layoutWarningForHook() {
   if (state.kind === "future") {
     return `[failproofai] this directory was written by a newer version (layout ${state.found} vs ${LAYOUT_VERSION}) — policies are NOT being enforced. ` + `Upgrade failproofai.`;
   }
-  if (existsSync14(globalPolicyConfigFile()))
+  if (existsSync15(globalPolicyConfigFile()))
     return null;
   return `[failproofai] setup predates this version — global policies are NOT being enforced. ` + `Run \`failproofai config\` to re-create it.`;
 }
@@ -10312,7 +10635,7 @@ var init_handler = __esm(() => {
 
 // src/hooks/worker-server.ts
 import { createConnection, createServer } from "node:net";
-import { existsSync as existsSync15, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync16, unlinkSync as unlinkSync2 } from "node:fs";
 function isWorkerHookRequest(msg) {
   if (!msg || typeof msg !== "object")
     return false;
@@ -10445,14 +10768,14 @@ function requestExistingWorkerShutdown(socketPath) {
 function startWorkerServer(socketPath, shutdown) {
   const server = createServer((socket) => handleConnection(socket, shutdown ?? (() => server.close())));
   const listen = () => {
-    if (existsSync15(socketPath)) {
+    if (existsSync16(socketPath)) {
       try {
         unlinkSync2(socketPath);
       } catch {}
     }
     server.listen(socketPath);
   };
-  if (!existsSync15(socketPath))
+  if (!existsSync16(socketPath))
     listen();
   else
     requestExistingWorkerShutdown(socketPath).then(listen, (err) => server.emit("error", err));