failproofai 0.0.13 → 0.0.14-beta.0

package/.next/standalone/lib/openclaw-sessions.ts

@@ -0,0 +1,284 @@
+/**
+ * OpenClaw (openclaw gateway) session transcript loader + parser.
+ *
+ * AUDIT-ONLY (Pillar 2). OpenClaw writes one JSONL transcript per session at
+ * `~/.openclaw/agents/<agentId>/sessions/<sessionId>.jsonl` (sessionId is a
+ * UUID), alongside a much larger `<sessionId>.trajectory.jsonl` OTel trace we
+ * IGNORE, and a `sessions.json` index keyed by sessionKey. Verified live
+ * against openclaw v2026.7.1.
+ *
+ * The transcript is type-discriminated JSONL:
+ *   {type:"session", cwd, …}              — header (carries cwd)
+ *   {type:"model_change" | "thinking_level_change" | "custom", …} — metadata
+ *   {type:"message", timestamp, message:{role, content, …}} — the turns, where
+ *     role ∈ "user" (content string) | "assistant" (content = list of
+ *     {type:"text",text} / {type:"toolCall", id, name, arguments}) |
+ *     "toolResult" ({toolCallId, toolName, content, details, isError}).
+ * `openclawLinesToLogEntries` pairs each assistant `toolCall` with its later
+ * `toolResult` by `toolCallId` (mirrors lib/hermes-sessions.ts) and is PURE, so
+ * it is unit-testable with plain line objects.
+ *
+ * Home override: set `OPENCLAW_HOME` (used by tests / to point at a copied
+ * gateway config dir).
+ */
+import { readFile } from "node:fs/promises";
+import { readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { runtimeCache } from "./runtime-cache";
+import {
+  baseEntry,
+  formatTimestamp,
+  parseRawLines,
+  type LogEntry,
+  type UserEntry,
+  type AssistantEntry,
+  type GenericEntry,
+  type ContentBlock,
+  type ToolUseBlock,
+  type LogSource,
+} from "./log-entries";
+import { formatDuration } from "./format-duration";
+
+/** OpenClaw sessions are stored under UUID filenames. */
+export const OPENCLAW_SESSION_ID_RE = /^[0-9a-fA-F-]{36}$/;
+
+/** Absolute path to OpenClaw's config home (override with OPENCLAW_HOME). */
+export function openclawHome(): string {
+  return process.env.OPENCLAW_HOME || join(homedir(), ".openclaw");
+}
+
+// ── Parsing helpers ──
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+
+/** Text from a `content` field that may be a string or an array of
+ *  `{ type:"text", text }` blocks. */
+function extractText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((c) => (isPlainObject(c) && typeof c.text === "string" ? (c.text as string) : ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}
+
+function toDate(value: unknown, fallbackMs: number): Date {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value > 1e12) return new Date(value);
+    if (value > 1e9) return new Date(value * 1000);
+  }
+  if (typeof value === "string") {
+    const ms = Date.parse(value);
+    if (!Number.isNaN(ms)) return new Date(ms);
+  }
+  return new Date(fallbackMs);
+}
+
+// ── Pure parser: transcript lines → LogEntry[] ──
+
+/**
+ * Convert OpenClaw transcript JSONL lines (parsed objects, in file order) into
+ * `LogEntry[]`. Only `type:"message"` lines carry turns; `session` /
+ * `model_change` / `thinking_level_change` / `custom` lines are metadata and
+ * are skipped (they'd otherwise clutter the audit with empty system entries).
+ * Assistant `toolCall` blocks are paired with their later `toolResult` message
+ * by `toolCallId`. Pure — unit-testable with plain line objects.
+ */
+export function openclawLinesToLogEntries(
+  lines: Record<string, unknown>[],
+  source: LogSource = "session",
+): LogEntry[] {
+  const entries: LogEntry[] = [];
+  const toolUseById = new Map<string, ToolUseBlock>();
+  const toolUseStartMs = new Map<string, number>();
+  const baseMs = Date.now();
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!isPlainObject(line)) continue;
+    if (line.type !== "message") continue; // skip session/model_change/custom/…
+
+    const m = isPlainObject(line.message) ? line.message : undefined;
+    if (!m) continue;
+    const role = typeof m.role === "string" ? m.role : "system";
+
+    // Outer line `timestamp` is an ISO string; message.timestamp is epoch ms.
+    const date = toDate(line.timestamp ?? m.timestamp, baseMs + i);
+    const timestamp = date.toISOString();
+    const raw: Record<string, unknown> = {
+      uuid: line.id != null ? String(line.id) : `openclaw-${i}`,
+      parentUuid: line.parentId != null ? String(line.parentId) : null,
+    };
+    const base = baseEntry(raw, timestamp, date, source);
+
+    if (role === "user") {
+      entries.push({
+        type: "user",
+        ...base,
+        message: { role: "user", content: extractText(m.content) },
+      } satisfies UserEntry);
+      continue;
+    }
+
+    if (role === "assistant") {
+      const blocks: ContentBlock[] = [];
+      const content = m.content;
+      if (Array.isArray(content)) {
+        for (const b of content) {
+          if (!isPlainObject(b)) continue;
+          if (b.type === "text" && typeof b.text === "string") {
+            blocks.push({ type: "text", text: b.text });
+          } else if (b.type === "toolCall") {
+            const id = typeof b.id === "string" ? b.id : `${String(b.name ?? "tool")}-${blocks.length}`;
+            const name = typeof b.name === "string" ? b.name : "tool";
+            const input = isPlainObject(b.arguments) ? b.arguments : {};
+            const block: ToolUseBlock = { type: "tool_use", id, name, input };
+            blocks.push(block);
+            toolUseById.set(id, block);
+            toolUseStartMs.set(id, date.getTime());
+          }
+        }
+      } else {
+        const text = extractText(content);
+        if (text) blocks.push({ type: "text", text });
+      }
+      if (blocks.length === 0) continue; // empty / failed assistant turn
+      entries.push({
+        type: "assistant",
+        ...base,
+        message: { role: "assistant", content: blocks, model: typeof m.model === "string" ? m.model : undefined },
+      } satisfies AssistantEntry);
+      continue;
+    }
+
+    if (role === "toolResult") {
+      const callId = typeof m.toolCallId === "string" ? m.toolCallId : undefined;
+      const block = callId ? toolUseById.get(callId) : undefined;
+      if (block) {
+        const details = isPlainObject(m.details) ? m.details : undefined;
+        const startMs = (callId && toolUseStartMs.get(callId)) || date.getTime();
+        const durationMs =
+          details && typeof details.durationMs === "number"
+            ? details.durationMs
+            : Math.max(0, date.getTime() - startMs);
+        block.result = {
+          timestamp,
+          timestampFormatted: formatTimestamp(date),
+          content: extractText(m.content),
+          durationMs,
+          durationFormatted: formatDuration(durationMs),
+        };
+        continue;
+      }
+      // Orphan tool result — fall through to a system entry.
+    }
+
+    entries.push({ type: "system", ...base, raw } satisfies GenericEntry);
+  }
+
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return entries;
+}
+
+// ── Discovery + file loader ──
+
+export interface OpenClawTranscriptFile {
+  agentId: string;
+  sessionId: string;
+  transcriptPath: string;
+  mtimeMs: number;
+  sizeBytes: number;
+}
+
+/** Enumerate `agents/<agentId>/sessions/<uuid>.jsonl` transcripts, skipping the
+ *  heavy `.trajectory.jsonl` OTel traces and pointer files. */
+export function listOpenClawTranscripts(): OpenClawTranscriptFile[] {
+  const agentsDir = join(openclawHome(), "agents");
+  const out: OpenClawTranscriptFile[] = [];
+  let agentIds: string[];
+  try {
+    agentIds = readdirSync(agentsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return out;
+  }
+  for (const agentId of agentIds) {
+    const sessionsDir = join(agentsDir, agentId, "sessions");
+    let files: string[];
+    try {
+      files = readdirSync(sessionsDir);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      // Only `<uuid>.jsonl` — not `<uuid>.trajectory.jsonl` / `.trajectory-path.json`.
+      if (!file.endsWith(".jsonl") || file.endsWith(".trajectory.jsonl")) continue;
+      const sessionId = file.slice(0, -".jsonl".length);
+      if (!OPENCLAW_SESSION_ID_RE.test(sessionId)) continue;
+      const transcriptPath = join(sessionsDir, file);
+      try {
+        const st = statSync(transcriptPath);
+        out.push({ agentId, sessionId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
+      } catch {
+        // skip unreadable
+      }
+    }
+  }
+  return out;
+}
+
+/** Resolve a session UUID to its on-disk transcript path (host-side). Guards
+ *  against traversal by requiring a UUID filename. Shared by the audit adapter
+ *  and download-session. */
+export function findOpenClawTranscript(sessionId: string): string | null {
+  if (!OPENCLAW_SESSION_ID_RE.test(sessionId)) return null;
+  for (const t of listOpenClawTranscripts()) {
+    if (t.sessionId === sessionId) return t.transcriptPath;
+  }
+  return null;
+}
+
+export interface OpenClawSessionLogData {
+  entries: LogEntry[];
+  rawLines: Record<string, unknown>[];
+  cwd?: string;
+  filePath: string;
+}
+
+/** Load and parse one session transcript by UUID. Returns `null` when the file
+ *  is missing/unreadable or the id fails validation. */
+export async function getOpenClawSessionLog(
+  sessionId: string,
+): Promise<OpenClawSessionLogData | null> {
+  const filePath = findOpenClawTranscript(sessionId);
+  if (!filePath) return null;
+  let content: string;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const rawLines = parseRawLines(content, "session");
+  const entries = openclawLinesToLogEntries(rawLines, "session");
+  // cwd lives on the `type:"session"` header line.
+  let cwd: string | undefined;
+  for (const line of rawLines) {
+    if (isPlainObject(line) && line.type === "session" && typeof line.cwd === "string" && line.cwd.length > 0) {
+      cwd = line.cwd;
+      break;
+    }
+  }
+  return { entries, rawLines, cwd, filePath };
+}
+
+export const getCachedOpenClawSessionLog = runtimeCache(
+  (sessionId: string) => getOpenClawSessionLog(sessionId),
+  2,
+  { maxSize: 50 },
+);

package/.next/standalone/lib/projects.ts

@@ -16,7 +16,7 @@ import { formatDate } from "./format-date";
 export const UUID_RE = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
 export const PATH_TRAVERSAL_RE = /(^|[\\/])\.\.($|[\\/])/;
 
-export type ProjectCli = "claude" | "codex" | "copilot" | "cursor" | "opencode" | "pi" | "gemini" | "hermes";
+export type ProjectCli = "claude" | "codex" | "copilot" | "cursor" | "opencode" | "pi" | "hermes" | "openclaw" | "factory" | "devin" | "antigravity" | "goose";
 
 export interface ProjectFolder {
   name: string;
@@ -143,18 +143,26 @@ export async function getProjectFolders(): Promise<ProjectFolder[]> {
     { getCursorProjects },
     { getOpenCodeProjects },
     { getPiProjects },
-    { getGeminiProjects },
     { getHermesProjects },
+    { getOpenClawProjects },
+    { getFactoryProjects },
+    { getDevinProjects },
+    { getAntigravityProjects },
+    { getGooseProjects },
   ] = await Promise.all([
     import("./codex-projects"),
     import("./copilot-projects"),
     import("./cursor-projects"),
     import("./opencode-projects"),
     import("./pi-projects"),
-    import("./gemini-projects"),
     import("./hermes-projects"),
+    import("./openclaw-projects"),
+    import("./factory-projects"),
+    import("./devin-projects"),
+    import("./antigravity-projects"),
+    import("./goose-projects"),
   ]);
-  const [claude, codex, copilot, cursor, opencode, pi, gemini, hermes] = await Promise.all([
+  const [claude, codex, copilot, cursor, opencode, pi, hermes, openclaw, factory, devin, antigravity, goose] = await Promise.all([
     getClaudeProjectFolders(),
     getCodexProjects().catch((error) => {
       logError("Error reading Codex projects:", error);
@@ -176,16 +184,32 @@ export async function getProjectFolders(): Promise<ProjectFolder[]> {
       logError("Error reading Pi projects:", error);
       return [] as ProjectFolder[];
     }),
-    getGeminiProjects().catch((error) => {
-      logError("Error reading Gemini projects:", error);
-      return [] as ProjectFolder[];
-    }),
     getHermesProjects().catch((error) => {
       logError("Error reading Hermes projects:", error);
       return [] as ProjectFolder[];
     }),
+    getOpenClawProjects().catch((error) => {
+      logError("Error reading OpenClaw projects:", error);
+      return [] as ProjectFolder[];
+    }),
+    getFactoryProjects().catch((error) => {
+      logError("Error reading Factory projects:", error);
+      return [] as ProjectFolder[];
+    }),
+    getDevinProjects().catch((error) => {
+      logError("Error reading Devin projects:", error);
+      return [] as ProjectFolder[];
+    }),
+    getAntigravityProjects().catch((error) => {
+      logError("Error reading Antigravity projects:", error);
+      return [] as ProjectFolder[];
+    }),
+    getGooseProjects().catch((error) => {
+      logError("Error reading Goose projects:", error);
+      return [] as ProjectFolder[];
+    }),
   ]);
-  return mergeProjectFolders(claude, codex, copilot, cursor, opencode, pi, gemini, hermes);
+  return mergeProjectFolders(claude, codex, copilot, cursor, opencode, pi, hermes, openclaw, factory, devin, antigravity, goose);
 }
 
 /**

package/.next/standalone/lib/telemetry-sanitize.ts

@@ -0,0 +1,43 @@
+import os from "node:os";
+
+/** Max length of a telemetry error message; longer strings are truncated. */
+const MAX_ERROR_MESSAGE_LEN = 300;
+
+/**
+ * Turn an error into a telemetry-safe message string for the `error_message`
+ * property on failure events (e.g. `cli_audit_failed`, `audit_run_failed`).
+ *
+ * Two protections keep this consistent with failproofai's telemetry philosophy
+ * (no raw local paths / PII on the wire):
+ *   1. The user's home directory is collapsed to `~`, so an error that embeds a
+ *      path like `/home/alice/.codex/…` is reported as `~/.codex/…`.
+ *   2. The message is truncated to a bounded length (with an ellipsis marker).
+ *
+ * Never throws — falls back to `"unknown"` if the error can't be stringified.
+ */
+export function sanitizeErrorMessage(err: unknown): string {
+  let msg: string;
+  try {
+    msg = err instanceof Error ? err.message : String(err);
+  } catch {
+    return "unknown";
+  }
+  if (!msg) return "";
+
+  let home = "";
+  try {
+    home = os.homedir();
+  } catch {
+    /* homedir unavailable — skip path stripping */
+  }
+  // Only strip a real, non-root home to avoid mangling messages when homedir is
+  // "/" or empty.
+  if (home && home.length > 1) {
+    msg = msg.split(home).join("~");
+  }
+
+  if (msg.length > MAX_ERROR_MESSAGE_LEN) {
+    msg = msg.slice(0, MAX_ERROR_MESSAGE_LEN) + "…";
+  }
+  return msg;
+}

package/.next/standalone/openclaw-plugin/index.js

@@ -0,0 +1,223 @@
+/**
+ * failproofai policy bridge for OpenClaw (openclaw gateway).
+ *
+ * Loaded in-process by the gateway (registered via `plugins.load.paths` +
+ * `plugins.entries.failproofai` in ~/.openclaw/openclaw.json). It subscribes to
+ * OpenClaw's typed PLUGIN hooks — the only surface that can block; OpenClaw's
+ * file-based "internal hooks" are observation-only — and forwards each to the
+ * failproofai binary as `failproofai --hook <event> --cli openclaw`. failproofai
+ * prints a flat `{permission, reason}` verdict on stdout; this shim maps it to
+ * each hook's native return shape.
+ *
+ * Marker comment for failproofai's installer detection (do not remove):
+ *   __failproofai_hook__: true
+ *
+ * Design notes (verified live against openclaw v2026.7.1):
+ *  • ASYNC spawn, never spawnSync — the gateway is a long-running multi-channel
+ *    process; a synchronous spawn on every hook would stall every channel.
+ *    30s guard timer; fail-open on any error (never block on infra failure).
+ *  • Raw forwarding — we send the raw tool name / params and a Claude-shaped
+ *    stdin (params→tool_input, toolName→tool_name, transcriptPath→
+ *    transcript_path, stopHookActive→stop_hook_active, sessionKey→session_id).
+ *    The binary canonicalizes via OPENCLAW_* maps (single source of truth); the
+ *    shim ships NO inline maps (unlike the OpenCode/Pi shims).
+ *  • No top-level `await` — OpenClaw's plugin loader rejects it; all async work
+ *    happens inside register()'s handlers.
+ *
+ * Binary resolution mirrors pi-extension/index.ts: prefer the bundled
+ * dist/cli.mjs (node-compatible), fall back to bin/failproofai.mjs with bun for
+ * dev; honor FAILPROOFAI_BINARY_OVERRIDE. Paths resolve relative to this file
+ * via import.meta.url (the gateway spawns plugins with an undefined cwd).
+ */
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const DIST_BIN = resolve(HERE, "..", "dist", "cli.mjs");
+const SRC_BIN = resolve(HERE, "..", "bin", "failproofai.mjs");
+
+function resolveSpawn() {
+  if (process.env.FAILPROOFAI_BINARY_OVERRIDE) {
+    return { cmd: "node", args: [process.env.FAILPROOFAI_BINARY_OVERRIDE] };
+  }
+  if (existsSync(DIST_BIN)) {
+    return { cmd: "node", args: [DIST_BIN] };
+  }
+  return { cmd: "bun", args: [SRC_BIN] };
+}
+
+function debug(msg) {
+  if (process.env.FAILPROOFAI_OPENCLAW_DEBUG === "1") {
+    process.stderr.write(`[failproofai-openclaw-shim] ${msg}\n`);
+  }
+}
+
+/**
+ * Spawn `failproofai --hook <rawEvent> --cli openclaw`, write the JSON payload
+ * to stdin, and resolve the parsed flat `{permission, reason}` verdict. Async +
+ * fail-open: any spawn/parse error or timeout resolves to `{permission:"allow"}`
+ * so a failproofai fault never blocks the gateway.
+ */
+function callPolicy(rawEvent, payload) {
+  return new Promise((done) => {
+    const { cmd, args } = resolveSpawn();
+    let child;
+    try {
+      child = spawn(cmd, [...args, "--hook", rawEvent, "--cli", "openclaw"], {
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+    } catch (err) {
+      debug(`spawn threw: ${err && err.message ? err.message : String(err)}`);
+      done({ permission: "allow" });
+      return;
+    }
+    let out = "";
+    let settled = false;
+    const finish = (verdict) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      done(verdict);
+    };
+    const timer = setTimeout(() => {
+      debug(`timeout on ${rawEvent}; killing child`);
+      try { child.kill(); } catch { /* ignore */ }
+      finish({ permission: "allow" });
+    }, 30_000);
+    child.stdout.on("data", (d) => { out += d; });
+    child.on("error", (err) => {
+      debug(`child error: ${err && err.message ? err.message : String(err)}`);
+      finish({ permission: "allow" });
+    });
+    child.on("close", () => {
+      const stdout = out.trim();
+      if (!stdout) { finish({ permission: "allow" }); return; }
+      try {
+        finish(JSON.parse(stdout));
+      } catch (err) {
+        debug(`parse error: ${err && err.message ? err.message : String(err)}`);
+        finish({ permission: "allow" });
+      }
+    });
+    try {
+      child.stdin.end(JSON.stringify(payload));
+    } catch (err) {
+      debug(`stdin write failed: ${err && err.message ? err.message : String(err)}`);
+      finish({ permission: "allow" });
+    }
+  });
+}
+
+/** 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) {
+  const p = payload || {};
+  const c = ctx || {};
+  return {
+    session_id: c.sessionId ?? p.sessionId ?? c.sessionKey ?? p.sessionKey,
+    cwd: p.cwd ?? c.workspaceDir ?? process.cwd(),
+    transcript_path: p.transcriptPath,
+    stop_hook_active: p.stopHookActive === true,
+    openclaw: {
+      agentId: c.agentId,
+      sessionKey: c.sessionKey ?? p.sessionKey,
+      runId: c.runId ?? p.runId,
+      provider: p.provider,
+      model: p.model,
+    },
+  };
+}
+
+export default definePluginEntry({
+  id: "failproofai",
+  name: "failproofai",
+  description: "Real-time policy enforcement for OpenClaw by failproofai",
+  register(api) {
+    // before_tool_call → PreToolUse. Full deny: return {block:true, blockReason}.
+    api.on(
+      "before_tool_call",
+      async (payload, ctx) => {
+        const p = payload || {};
+        const verdict = await callPolicy("before_tool_call", {
+          ...baseMeta(payload, ctx),
+          tool_name: p.toolName,
+          tool_input: p.params,
+          hook_event_name: "before_tool_call",
+        });
+        if (verdict.permission === "deny") {
+          return { block: true, blockReason: verdict.reason || "Blocked by failproofai" };
+        }
+        return undefined;
+      },
+      { priority: 100, timeoutMs: 60_000 },
+    );
+
+    // before_agent_run → UserPromptSubmit. Deny: return {outcome:"block", reason}.
+    api.on(
+      "before_agent_run",
+      async (payload, ctx) => {
+        const p = payload || {};
+        const verdict = await callPolicy("before_agent_run", {
+          ...baseMeta(payload, ctx),
+          prompt: p.prompt,
+          hook_event_name: "before_agent_run",
+        });
+        if (verdict.permission === "deny") {
+          return { outcome: "block", reason: verdict.reason || "Blocked by failproofai" };
+        }
+        return undefined;
+      },
+      { priority: 100, timeoutMs: 60_000 },
+    );
+
+    // before_agent_finalize → Stop. The real turn-end gate: a deny becomes a
+    // revise so the agent runs another pass. The evaluator supplies the
+    // MANDATORY ACTION wording; the payload's stop_hook_active guards the
+    // require-*-before-stop builtins against infinite loops.
+    api.on(
+      "before_agent_finalize",
+      async (payload, ctx) => {
+        const verdict = await callPolicy("before_agent_finalize", {
+          ...baseMeta(payload, ctx),
+          hook_event_name: "before_agent_finalize",
+        });
+        if (verdict.permission === "deny") {
+          return { action: "revise", reason: verdict.reason || "Action required by failproofai" };
+        }
+        return undefined;
+      },
+      { priority: 100, timeoutMs: 60_000 },
+    );
+
+    // Observation hooks — await so activity ordering is stable, ignore verdict.
+    // after_tool_call → PostToolUse; session_start/end → SessionStart/End;
+    // subagent_ended → SubagentStop (obs only); before_compaction → PreCompact.
+    for (const ev of [
+      "after_tool_call",
+      "session_start",
+      "session_end",
+      "subagent_ended",
+      "before_compaction",
+    ]) {
+      api.on(
+        ev,
+        async (payload, ctx) => {
+          const p = payload || {};
+          await callPolicy(ev, {
+            ...baseMeta(payload, ctx),
+            tool_name: p.toolName,
+            tool_input: p.params,
+            tool_response: p.result,
+            reason: p.reason,
+            hook_event_name: ev,
+          });
+          return undefined;
+        },
+        { priority: 100, timeoutMs: 60_000 },
+      );
+    }
+  },
+});

package/.next/standalone/openclaw-plugin/openclaw.plugin.json

@@ -0,0 +1,6 @@
+{
+  "id": "failproofai",
+  "name": "failproofai",
+  "description": "Real-time policy enforcement for OpenClaw by failproofai",
+  "configSchema": {}
+}

package/.next/standalone/openclaw-plugin/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@failproofai/openclaw-plugin",
+  "version": "0.0.1",
+  "description": "failproofai policy bridge for OpenClaw (openclaw gateway)",
+  "type": "module",
+  "main": "./index.js",
+  "private": true,
+  "keywords": [
+    "openclaw-plugin",
+    "failproofai"
+  ]
+}

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "0.0.13",
+  "version": "0.0.14-beta.0",
   "description": "The easiest way to manage policies that keep your AI agents reliable, on-task, and running autonomously — for Claude Code & the Agents SDK",
   "bin": {
     "failproofai": "./dist/cli.mjs"
@@ -11,6 +11,7 @@
     "scripts/",
     "lib/",
     "pi-extension/",
+    "openclaw-plugin/",
     ".next/standalone/",
     "dist/",
     "README.md"