failproofai 1.0.5-beta.1 → 1.0.5

package/dist/worker.mjs

@@ -3483,7 +3483,7 @@ function parsePackPolicyName(canonicalName) {
 }
 
 // package.json
-var version = "1.0.5-beta.1";
+var version = "1.0.5";
 var init_package = () => {};
 
 // src/posthog-key.ts
@@ -5890,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 {
@@ -5914,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);
@@ -5940,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 = () => {};
@@ -6810,7 +6922,7 @@ var init_openclaw_db = __esm(() => {
 
 // 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 join14 } from "node:path";
 function openclawHome() {
@@ -6963,7 +7075,7 @@ function listOpenClawTranscripts() {
         continue;
       const transcriptPath = join14(sessionsDir, file);
       try {
-        const st = statSync6(transcriptPath);
+        const st = statSync7(transcriptPath);
         out.push({
           agentId,
           sessionId,
@@ -7206,7 +7318,7 @@ 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 join16 } from "node:path";
 function factoryHome() {
@@ -7374,7 +7486,7 @@ function listFactoryTranscripts() {
         continue;
       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 {}
     }
@@ -7793,7 +7905,7 @@ 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 join18 } from "node:path";
 function antigravityHome() {
@@ -7928,7 +8040,7 @@ function listAntigravityTranscripts() {
       continue;
     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 });
@@ -7941,7 +8053,7 @@ function findAntigravityTranscript(conversationId) {
     return null;
   const transcriptPath = join18(antigravityBrainRoot(), conversationId, antigravityTranscriptRelPath());
   try {
-    if (statSync8(transcriptPath).isFile())
+    if (statSync9(transcriptPath).isFile())
       return transcriptPath;
   } catch {}
   return null;
@@ -8850,7 +8962,7 @@ var init_log_entries = __esm(() => {
 });
 
 // lib/codex-sessions.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync7, existsSync as existsSync10, 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 join24 } from "node:path";
 import { homedir as homedir16 } from "node:os";
@@ -9178,7 +9290,7 @@ var init_resolve_permission_mode = __esm(() => {
 });
 
 // lib/copilot-sessions.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync8, existsSync as existsSync11, 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 join25, resolve as resolve10, sep as sep2 } from "node:path";
 import { homedir as homedir17 } from "node:os";
@@ -9395,7 +9507,7 @@ var init_copilot_sessions = __esm(() => {
 });
 
 // lib/cursor-sessions.ts
-import { readFileSync as readFileSync11, readdirSync as readdirSync9, existsSync as existsSync12, 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 join26, resolve as resolve11, sep as sep3 } from "node:path";
 import { homedir as homedir18 } from "node:os";
@@ -9651,7 +9763,7 @@ var init_cursor_sessions = __esm(() => {
 });
 
 // lib/pi-sessions.ts
-import { readFileSync as readFileSync12, readdirSync as readdirSync10, existsSync as existsSync13, 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 join27, resolve as resolve12, sep as sep4 } from "node:path";
 import { homedir as homedir19 } from "node:os";
@@ -10136,7 +10248,7 @@ import {
   renameSync as renameSync3,
   rmSync as rmSync3,
   rmdirSync,
-  statSync as statSync13,
+  statSync as statSync14,
   writeFileSync as writeFileSync5
 } from "node:fs";
 function layoutWarningForHook() {

package/lib/openclaw-profiles.ts

@@ -0,0 +1,78 @@
+/**
+ * Lightweight OpenClaw profile discovery shared by hook installation code.
+ *
+ * The default profile lives at `~/.openclaw`; named profiles selected with
+ * `openclaw --profile <name>` live in sibling directories named
+ * `~/.openclaw-<name>`. Each profile owns an independent `openclaw.json`, so
+ * policy enforcement must be installed into every one of them.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+
+export interface OpenClawProfile {
+  name: string;
+  home: string;
+}
+
+export const OPENCLAW_DEFAULT_PROFILE = "default";
+
+/** Active/default OpenClaw state home, respecting OpenClaw's own overrides. */
+export function openclawProfileHome(): string {
+  const stateDir = (process.env.OPENCLAW_STATE_DIR ?? "").trim();
+  if (stateDir) return resolve(stateDir);
+
+  const openclawHome = (process.env.OPENCLAW_HOME ?? "").trim();
+  if (openclawHome) return resolve(openclawHome);
+
+  const configPath = (process.env.OPENCLAW_CONFIG_PATH || "").trim();
+  if (configPath) return dirname(resolve(configPath));
+
+  return join(homedir(), ".openclaw");
+}
+
+/**
+ * Every standard OpenClaw profile on disk, default first and named profiles in
+ * lexical order. A named directory counts as a profile only when it contains
+ * `openclaw.json`; this avoids modifying backup or unrelated `.openclaw-*`
+ * directories.
+ */
+export function listOpenClawProfiles(): OpenClawProfile[] {
+  const activeHome = openclawProfileHome();
+  const activeBase = basename(activeHome);
+
+  // Non-standard OPENCLAW_STATE_DIR locations do not have a well-defined
+  // sibling-profile convention. Keep the explicit location authoritative.
+  if (activeBase !== ".openclaw" && !activeBase.startsWith(".openclaw-")) {
+    return [{ name: OPENCLAW_DEFAULT_PROFILE, home: activeHome }];
+  }
+
+  const parent = dirname(activeHome);
+  const defaultHome = join(parent, ".openclaw");
+  const out: OpenClawProfile[] = [
+    { name: OPENCLAW_DEFAULT_PROFILE, home: defaultHome },
+  ];
+
+  let entries;
+  try {
+    entries = readdirSync(parent, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+
+  const named = entries
+    .filter((entry) =>
+      (entry.isDirectory() || entry.isSymbolicLink()) &&
+      entry.name.startsWith(".openclaw-") &&
+      entry.name.length > ".openclaw-".length &&
+      existsSync(join(parent, entry.name, "openclaw.json")),
+    )
+    .map((entry) => ({
+      name: entry.name.slice(".openclaw-".length),
+      home: join(parent, entry.name),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  out.push(...named);
+  return out;
+}

package/lib/openclaw-projects.ts

@@ -23,9 +23,9 @@ export interface OpenClawSessionRef {
   /** Channel/source the session last ran in (from sessions.json metadata) —
    *  e.g. "telegram", "slack", or "local" for a CLI session. Drives grouping. */
   channel: string;
-  /** Human-readable label from `origin.label` (e.g. "Chetan (@chhhee10) id:…"). */
+  /** Human-readable label from `origin.label` (e.g. "Example User (@example) id:…"). */
   label?: string;
-  /** Chat id (e.g. "telegram:8674922496") + type ("direct"/"group") for the
+  /** Chat id (e.g. "telegram:1234567890") + type ("direct"/"group") for the
    *  gateway-metadata columns. */
   chatId?: string;
   chatType?: string;
@@ -248,7 +248,7 @@ export interface OpenClawProjectByName {
 
 /** Resolve the OpenClaw sessions for a synthetic project name
  *  (`openclaw-<agentId>-<channel>`), for the project-detail page. Session names
- *  use the human-readable `origin.label` (e.g. "Chetan (@chhhee10) id:…")
+ *  use the human-readable `origin.label` (e.g. "Example User (@example) id:…")
  *  rather than the raw session key. */
 export async function getOpenClawSessionsByEncodedName(
   name: string,

package/lib/sqlite-reader.ts

@@ -6,10 +6,10 @@
  *   1. `node:sqlite` — a real connection that reads main DB + WAL together, so
  *      brand-new rows are visible immediately. Built into Node ≥ 22.5 (no native
  *      module, no flag on recent 22.x). Preferred.
- *   2. `sql.js` (pure-JS/asm) — portable fallback for older Node. Reads the main
- *      DB file's bytes only, so it reflects a snapshot up to the last WAL
- *      checkpoint (very recent rows may lag). No native module — survives
- *      `npm install --ignore-scripts`.
+ *   2. `sql.js` (pure-JS/asm) — portable fallback for older Node. Builds a
+ *      consistent in-memory snapshot from the main DB plus committed WAL
+ *      frames, so live rows are visible on Node 20 too. No native module —
+ *      survives `npm install --ignore-scripts`.
  *
  * Either way: read-only, and `null` on any failure (fail-open, so an absent or
  * locked DB makes the audit skip that agent rather than crash).
@@ -17,7 +17,7 @@
  * NOTE: opencode and every CLI that already ships keep their existing CLI
  * shell-out — this layer is only for new SQLite integrations.
  */
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import initSqlJs, { type SqlJsStatic } from "sql.js/dist/sql-asm.js";
 
 export interface SqliteReader {
@@ -26,6 +26,11 @@ export interface SqliteReader {
   close(): void;
 }
 
+export interface SqliteReaderOptions {
+  /** Exercise the Node-20-compatible reader even when `node:sqlite` exists. */
+  forcePortable?: boolean;
+}
+
 // ── Tier 1: node:sqlite (WAL-aware, Node ≥ 22.5) ──
 
 interface NodeSqliteStmt {
@@ -58,7 +63,7 @@ async function tryNodeSqlite(dbPath: string): Promise<SqliteReader | null> {
   }
 }
 
-// ── Tier 2: sql.js (portable snapshot) ──
+// ── Tier 2: sql.js (portable, WAL-aware snapshot) ──
 
 let sqlPromise: Promise<SqlJsStatic> | null = null;
 function loadSqlJs(): Promise<SqlJsStatic> {
@@ -66,10 +71,154 @@ function loadSqlJs(): Promise<SqlJsStatic> {
   return sqlPromise;
 }
 
+interface FileVersion {
+  size: number;
+  mtimeMs: number;
+  ctimeMs: number;
+}
+
+function fileVersion(path: string): FileVersion {
+  const stat = statSync(path);
+  return { size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs };
+}
+
+function sameVersion(a: FileVersion, b: FileVersion): boolean {
+  return a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
+}
+
+function sqlitePageSize(db: Uint8Array): number | null {
+  if (db.length < 100) return null;
+  if (Buffer.from(db.subarray(0, 16)).toString("binary") !== "SQLite format 3\0") return null;
+  const encoded = (db[16] << 8) | db[17];
+  const pageSize = encoded === 1 ? 65_536 : encoded;
+  return pageSize >= 512 && pageSize <= 65_536 && (pageSize & (pageSize - 1)) === 0
+    ? pageSize
+    : null;
+}
+
+function walChecksum(
+  bytes: Uint8Array,
+  offset: number,
+  length: number,
+  bigEndian: boolean,
+  initial: readonly [number, number] = [0, 0],
+): [number, number] {
+  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];
+}
+
+/** Overlay every valid frame through the WAL's last committed transaction. */
+function applyCommittedWal(db: Uint8Array, wal: Uint8Array): Uint8Array {
+  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 !== 0x377f0682 && magic !== 0x377f0683) return db;
+  if (view.getUint32(4, false) !== 3_007_000) 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;
+  // A corrupt WAL must not be allowed to request an unbounded allocation.
+  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;
+    // An earlier transaction in the same WAL may have grown the database and
+    // a later committed transaction may have truncated it again. Frames above
+    // the final committed page count are valid history, but not part of the
+    // snapshot sql.js should open.
+    if (destination >= targetSize) continue;
+    snapshot.set(wal.subarray(offset + 24, offset + frameSize), destination);
+  }
+  return snapshot;
+}
+
+/**
+ * Read the main file before the WAL and verify that no checkpoint changed the
+ * main file in between. WAL appends are safe: only complete committed frames
+ * present in the bytes we read are applied. A checkpoint/reset changes the
+ * main file, which makes us retry instead of combining different generations.
+ */
+function readPortableSnapshot(dbPath: string): Uint8Array {
+  const walPath = `${dbPath}-wal`;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const before = fileVersion(dbPath);
+    const main = readFileSync(dbPath);
+    const afterMain = fileVersion(dbPath);
+    if (!sameVersion(before, afterMain)) continue;
+
+    let wal: Uint8Array | null = null;
+    try {
+      wal = readFileSync(walPath);
+    } catch (error) {
+      // A missing WAL is an ordinary checkpointed database.
+      if ((error as NodeJS.ErrnoException).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: string): Promise<SqliteReader | null> {
   try {
     const SQL = await loadSqlJs();
-    const db = new SQL.Database(readFileSync(dbPath));
+    const db = new SQL.Database(readPortableSnapshot(dbPath));
     return {
       query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[] {
         const stmt = db.prepare(sql);
@@ -96,7 +245,14 @@ async function trySqlJs(dbPath: string): Promise<SqliteReader | null> {
  * connection (live data), falls back to a `sql.js` snapshot. Returns `null` on
  * any failure. Always `close()` the reader when done.
  */
-export async function openSqliteReadonly(dbPath: string): Promise<SqliteReader | null> {
+export async function openSqliteReadonly(
+  dbPath: string,
+  options: SqliteReaderOptions = {},
+): Promise<SqliteReader | null> {
   if (!existsSync(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);
 }

package/openclaw-plugin/index.js

@@ -37,11 +37,13 @@ import { existsSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInstructRetryGate, mapBeforeToolVerdict } from "./instruct-retry-gate.js";
+import { createWorkspaceContext } from "./workspace-context.js";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const DIST_BIN = resolve(HERE, "..", "dist", "cli.mjs");
 const SRC_BIN = resolve(HERE, "..", "bin", "failproofai.mjs");
 const instructRetryGate = createInstructRetryGate();
+const workspaceContext = createWorkspaceContext();
 
 function resolveSpawn() {
   if (process.env.FAILPROOFAI_BINARY_OVERRIDE) {
@@ -117,12 +119,12 @@ function callPolicy(rawEvent, payload) {
 
 /** Claude-shaped stdin base. Extra keys are ignored by the binary's payload
  *  parser; they're forwarded for future use / activity attribution. */
-function baseMeta(payload, ctx) {
+function baseMeta(payload, ctx, config) {
   const p = payload || {};
   const c = ctx || {};
   return {
     session_id: c.sessionId ?? p.sessionId ?? c.sessionKey ?? p.sessionKey,
-    cwd: p.cwd ?? c.workspaceDir ?? process.cwd(),
+    cwd: workspaceContext.resolveWorkspace(p, c, config) ?? process.cwd(),
     transcript_path: p.transcriptPath,
     stop_hook_active: p.stopHookActive === true,
     openclaw: {
@@ -148,7 +150,7 @@ export default definePluginEntry({
       async (payload, ctx) => {
         const p = payload || {};
         const verdict = await callPolicy("before_tool_call", {
-          ...baseMeta(payload, ctx),
+          ...baseMeta(payload, ctx, api.config),
           tool_name: p.toolName,
           tool_input: p.params,
           hook_event_name: "before_tool_call",
@@ -163,8 +165,9 @@ export default definePluginEntry({
       "before_agent_run",
       async (payload, ctx) => {
         const p = payload || {};
+        workspaceContext.remember(payload, ctx);
         const verdict = await callPolicy("before_agent_run", {
-          ...baseMeta(payload, ctx),
+          ...baseMeta(payload, ctx, api.config),
           prompt: p.prompt,
           hook_event_name: "before_agent_run",
         });
@@ -184,7 +187,7 @@ export default definePluginEntry({
       "before_agent_finalize",
       async (payload, ctx) => {
         const verdict = await callPolicy("before_agent_finalize", {
-          ...baseMeta(payload, ctx),
+          ...baseMeta(payload, ctx, api.config),
           hook_event_name: "before_agent_finalize",
         });
         if (verdict.permission === "deny") {
@@ -210,14 +213,17 @@ export default definePluginEntry({
         async (payload, ctx) => {
           const p = payload || {};
           await callPolicy(ev, {
-            ...baseMeta(payload, ctx),
+            ...baseMeta(payload, ctx, api.config),
             tool_name: p.toolName,
             tool_input: p.params,
             tool_response: p.result,
             reason: p.reason,
             hook_event_name: ev,
           });
-          if (ev === "session_end") instructRetryGate.clear(payload, ctx);
+          if (ev === "session_end") {
+            instructRetryGate.clear(payload, ctx);
+            workspaceContext.clear(payload, ctx);
+          }
           return undefined;
         },
         { priority: 100, timeoutMs: 60_000 },