failproofai 1.0.4-beta.4 → 1.0.4-beta.7

package/.next/standalone/app/actions/update-scheduled-audit.ts

@@ -8,9 +8,10 @@
  *
  * ## CLI ⟷ dashboard parity
  *   - `setAutoAuditAction(enabled)`  ⟷ `[audit] auto`
+ *   - `setAuditNotifyAction(enabled)` ⟷ `[audit] notify`
  *   - `setAuditIntervalAction(days)` ⟷ `[audit] interval_days`
  *
- * Both go through the same `updateConfig` the CLI uses — `failproofai audit
+ * All go through the same `updateConfig` the CLI uses — `failproofai audit
  * --schedule` / `--no-schedule` call it too — so a value set on either side is
  * byte-identical. That is the whole mechanism behind "the two
  * surfaces are always in sync": there is one file, one writer function, and no
@@ -18,7 +19,6 @@
  */
 
 import { readConfig, updateConfig } from "@/src/hooks/fp-config";
-import { readAuth, whoAmI } from "@/lib/auth/auth-store";
 
 /**
  * The outcome of trying to turn scheduling on.
@@ -34,73 +34,34 @@ import { readAuth, whoAmI } from "@/lib/auth/auth-store";
  * A returned discriminant survives the boundary, so the caller can open the
  * sign-in dialog for the one failure that has an obvious next step.
  */
-export type SetAutoAuditResult =
-  | { ok: true; auto: boolean }
-  | { ok: false; reason: "signed-out" }
-  /**
-   * The session is intact locally and the api-server could not be reached.
-   *
-   * Separated from `signed-out` because `whoAmI()` collapses them: it returns
-   * null for a 401 AND for every transport failure, so an offline machine, a
-   * proxy that blocks the host, and a genuinely expired token were one answer.
-   * The user was told "that sign-in expired" and handed a code prompt that
-   * cannot succeed either — the failure it names is not the failure they have,
-   * and following its advice costs them a real, working session.
-   */
-  | { ok: false; reason: "unreachable" };
+export type SetAutoAuditResult = { ok: true; auto: boolean };
 
 /**
  * Turn the scheduled scan on or off.
  *
- * Turning it ON is refused without a session. Scheduling and mailing are ONE
- * decision — the reason to put a scan on a timer is to be told what it found —
- * so a machine with the timer set and nobody to tell is a switch that reads as
- * on and produces nothing, discoverable only by noticing that no digest ever
- * arrives. The caller signs the user in first and retries.
- *
- * `whoAmI()` asks the SERVER, so this refuses in a case the page cannot see: a
- * session file that exists locally but whose refresh token the api-server has
- * rejected. The local file is what the page reads to show "reports go to …", so
- * the two disagree exactly when a session has expired or was minted against a
- * different server — and that disagreement is the common case, not an edge one.
- *
- * Turning it OFF never checks. An expired session must not be able to trap
- * somebody into keeping a feature they are trying to disable.
- *
- * Note this gates SETTING UP the timer, not the machine's ongoing work: a
- * session that later expires leaves the timer running and the local scan
- * working, and only the digest stops. See `report-harm.ts`.
+ * Scheduling is local and independent of authentication. A signed-in identity
+ * adds email delivery; without one the scan and desktop notification continue.
  *
  * Returns the value actually stored (re-read), so an optimistic UI can confirm
  * against the source of truth rather than assume its own guess landed.
  */
 export async function setAutoAuditAction(enabled: boolean): Promise<SetAutoAuditResult> {
-  if (enabled) {
-    const who = await whoAmI();
-    if (!who) {
-      // `whoAmI()` deletes the session on a 401 and leaves it alone on a
-      // transport failure, so what is left ON DISK is the one thing that tells
-      // the two apart — no extra request, and nothing new that can fail.
-      const local = readAuth();
-      const stillWithinWindow = local && local.refresh_expires_at * 1000 > Date.now();
-      return { ok: false, reason: stillWithinWindow ? "unreachable" : "signed-out" };
-    }
-  }
-  // Enabling stamps consent in the same write, because the `whoAmI()` above is
-  // exactly what makes this a consent record rather than a guess: a person was
-  // present, signed in, and looking at the panel that enumerates what gets
-  // sent. `reportHarm` gates sending on the stamp, not on `auto`, so a machine
-  // that inherited `auto` from a release where it meant "scan locally on a
-  // timer" mails nothing until somebody passes through here or the CLI.
-  //
-  // Disabling leaves the stamp alone. It is a record of something that did
-  // happen, and it grants nothing on its own — sending needs `auto` too.
-  const next = updateConfig({
-    audit: enabled ? { auto: true, reportsConsentedAt: Date.now() } : { auto: false },
-  });
+  const next = updateConfig({ audit: { auto: enabled } });
   return { ok: true, auto: next.audit.auto };
 }
 
+/**
+ * Turn OS notifications for scheduled credential findings on or off.
+ *
+ * This does not change the timer or email delivery. It writes the same setting
+ * as `failproofai audit --notify` / `--no-notify` and returns the value re-read
+ * from the shared config so the dashboard never maintains a second truth.
+ */
+export async function setAuditNotifyAction(enabled: boolean): Promise<{ notify: boolean }> {
+  const next = updateConfig({ audit: { notify: enabled } });
+  return { notify: next.audit.notify };
+}
+
 /**
  * Set the days between scheduled scans.
  *

package/.next/standalone/app/api/auth/status/route.ts

@@ -7,8 +7,9 @@
  * This keeps the dashboard UI and the CLI consistent regardless of whether
  * the api-server is reachable.
  *
- * Reminders are gone: the machine now audits itself on a timer and mails a
- * digest when it finds harm, so there is nothing to nudge anyone about. The
+ * Reminders are gone: the machine now audits itself on a timer and can mail an
+ * alert when it finds a credential leak, so there is nothing to nudge anyone
+ * about. The
  * scheduled-scan state lives in `getScheduledAuditAction`, which reads it from
  * the config and the daemon rather than from here.
  */

package/.next/standalone/app/audit/_components/audit-dashboard.tsx

@@ -366,7 +366,7 @@ function MainReport({
           <AuditReportPlaceholder
             transcripts={result.transcripts.scanned}
             events={result.eventsScanned ?? 0}
-            projects={result.projectsScanned.length}
+            projects={result.projectsScanned?.length ?? 0}
             isRunning={isRunning || rerunStatus.kind === "running"}
             onRerun={() => onRerun("scan_header")}
           />

package/.next/standalone/app/audit/_components/empty-state.tsx

@@ -77,7 +77,7 @@ export function EmptyState({ mode, running, onStarted, onCompleted }: Props) {
             {/* Was "a tier, a score, and a punch-list" — the tier was never
                 rendered and the score is switched off, so this promised two
                 things the page did not show. */}
-            or risky action. you'll get your agent's archetype and a punch-list.
+            or risky action. you'll get a leak report and a scan summary.
           </p>
 
           <div className="empty-actions">

package/.next/standalone/app/audit/_components/leak-section.tsx

@@ -155,7 +155,7 @@ export function LeakSection() {
                   <span className="leak-who">{row.cli}</span>
                   {" · leaked "}
                   <span className="leak-when">{when(row.firstSeen)}</span>
-                  {when(row.firstSeen) !== when(row.lastSeen) ? (
+                  {row.firstSeen !== row.lastSeen ? (
                     <>
                       {" · last seen "}
                       <span className="leak-when">{when(row.lastSeen)}</span>

package/.next/standalone/app/settings/page.tsx

@@ -30,7 +30,7 @@ export const dynamic = "force-dynamic";
 export default async function SettingsPage() {
   // Same gate the audit, policies and projects pages carry. It was dropped in
   // the rewrite, and this is the page that least deserves to lose it: it shows
-  // the address digests go to and can sign the machine out, on a dashboard an
+  // the address credential alerts go to and can sign the machine out, on a dashboard an
   // operator may deliberately be exposing beyond localhost.
   const disabled = (process.env.FAILPROOFAI_DISABLE_PAGES ?? "")
     .split(",").map((s) => s.trim()).filter(Boolean);

package/.next/standalone/app/settings/settings-client.tsx

@@ -29,12 +29,8 @@
  * acts and for anything wrong, mint for the thing that is alive. No third hue,
  * no new webfont, one hard pixel shadow on the console. That is the budget.
  *
- * ## One switch, not two
- *
- * Scheduling and mailing are the same decision — the reason to put a scan on a
- * timer is to be told what it found. So there is one toggle, it requires a
- * sign-in, and "signed out with the timer on" is a real state the page names
- * rather than a contradiction it prevents.
+ * Scheduling and system notifications are separate machine settings. Turning
+ * notifications off must not silently stop the seven-day scan or email alerts.
  */
 
 import { useCallback, useEffect, useRef, useState, type ReactNode } from "react";
@@ -44,6 +40,7 @@ import {
 } from "@/app/actions/get-scheduled-audit";
 import {
   setAutoAuditAction,
+  setAuditNotifyAction,
   setAuditIntervalAction,
 } from "@/app/actions/update-scheduled-audit";
 import { triggerRun, RerunError } from "@/app/audit/_components/rerun-button";
@@ -187,12 +184,9 @@ function Toggle({
  * What the scan does, as three labelled lines. This is the old footer paragraph
  * restructured — same claims, scannable instead of a wall.
  *
- * "sends" ENUMERATES rather than saying "only counts and redacted examples".
- * That was very nearly true, and very nearly true is the worse kind: the report
- * carries the machine's name too — its hostname, which routinely carries its
- * owner's. A list a person can check beats a stronger claim they cannot, and
- * this panel is the one place they would come to check. The digest email states
- * the same three, in the same order.
+ * "sends" names the exact remote payload. The scheduled scan itself stays
+ * local, and no report is attempted unless a credential leak exists and the
+ * machine has a verified email identity.
  */
 const HOW_IT_WORKS: ReadonlyArray<{ label: string; body: string }> = [
   {
@@ -202,7 +196,7 @@ const HOW_IT_WORKS: ReadonlyArray<{ label: string; body: string }> = [
   { label: "runs", body: "entirely on this machine. the transcripts never leave it." },
   {
     label: "sends",
-    body: "counts, redacted examples, and this machine's name — and only when a scan finds something harmful.",
+    body: "only the newest masked credential exposure, its CLI, time, location, and this machine's name — only when email is configured.",
   },
 ];
 
@@ -211,6 +205,7 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
   // about whether scheduled audits are on. See the note in `page.tsx`.
   const [view, setView] = useState<ScheduledAuditView | null>(initial);
   const [auto, setAuto] = useState(initial?.auto ?? false);
+  const [notify, setNotify] = useState(initial?.notify ?? true);
   const [intervalDays, setIntervalDays] = useState(initial?.intervalDays ?? 7);
   const [busy, setBusy] = useState(false);
   const [running, setRunning] = useState(false);
@@ -254,6 +249,7 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
       setView(next);
       hasView.current = true;
       setAuto(next.auto);
+      setNotify(next.notify);
       setIntervalDays(next.intervalDays);
       setNowMs(Date.now());
       setLoadError(false);
@@ -312,26 +308,6 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
     setBusy(true);
     try {
       const res = await setAutoAuditAction(true);
-      if (!res.ok) {
-        setAuto(false);
-        if (res.reason === "unreachable") {
-          // The session is fine and the network is not. Offering a code prompt
-          // here would name a failure the user does not have and hand them a
-          // flow that cannot succeed either — and abandoning it mid-way is how
-          // a working session gets replaced with none at all.
-          toast("could not reach the server. check your connection and try again.");
-          return;
-        }
-        // The server rejected the session this page had been showing an address
-        // for — expired, or minted against a different api-server. The local
-        // file is the only thing that said "signed in", and `whoAmI` has since
-        // cleared it, so re-read before opening the dialog: otherwise the page
-        // asks for an email while still displaying one.
-        await reload();
-        setAuthOpen(true);
-        toast("that sign-in expired. one more code and it's on.");
-        return;
-      }
       setAuto(res.auto);
       toast("scheduled audits on.");
       await reload();
@@ -360,13 +336,23 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
       }
       return;
     }
-    // Turning it on needs somewhere to send the digest.
-    if (!signedIn) {
-      setAuthOpen(true);
-      return;
-    }
     await enable();
-  }, [auto, enable, reload, signedIn]);
+  }, [auto, enable, reload]);
+
+  const onNotifyToggle = useCallback(async () => {
+    const requested = !notify;
+    setBusy(true);
+    try {
+      const res = await setAuditNotifyAction(requested);
+      setNotify(res.notify);
+      setView((v) => (v ? { ...v, notify: res.notify } : v));
+      toast(res.notify ? "system notifications on." : "system notifications off.");
+    } catch {
+      toast(`could not turn system notifications ${requested ? "on" : "off"}.`);
+    } finally {
+      setBusy(false);
+    }
+  }, [notify]);
 
   const commitInterval = useCallback(
     async (raw: number) => {
@@ -403,7 +389,7 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
     setBusy(true);
     try {
       await fetch("/api/auth/logout", { method: "POST" });
-      toast("signed out. scans continue; digests pause.");
+      toast("signed out. scans and desktop notifications continue; email alerts pause.");
       await reload();
     } catch {
       toast("could not sign out.");
@@ -534,7 +520,9 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
                     </span>
                     <span className="set-dim">
                       {auto
-                        ? "you'll get an email only when a scan finds something."
+                        ? signedIn
+                          ? "scheduled scans are active; the latest masked leak is emailed."
+                          : "scheduled scans are active. add an email below for masked alerts."
                         : "off. nothing runs and nothing is sent."}
                     </span>
                   </div>
@@ -566,6 +554,23 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
                   </span>
                 </div>
 
+                <div className="set-row set-row-main">
+                  <Toggle
+                    enabled={notify}
+                    disabled={busy || view === null}
+                    onChange={() => void onNotifyToggle()}
+                    label={notify ? "turn off system notifications" : "turn on system notifications"}
+                  />
+                  <div className="set-row-copy">
+                    <span className="set-strong">system notifications.</span>
+                    <span className="set-dim">
+                      {notify
+                        ? "on when a scheduled scan finds credentials."
+                        : "off. scheduled scans and email alerts continue."}
+                    </span>
+                  </div>
+                </div>
+
                 <div className="set-rule" />
 
                 <div className="set-row set-row-identity">
@@ -593,7 +598,7 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
                     // from it at all.
                     <>
                       <span className="set-warn">
-                        signed out — scans continue, digests are paused.
+                        signed out — scheduled scans continue; email alerts are paused.
                       </span>
                       <button
                         type="button"
@@ -601,13 +606,13 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
                         disabled={busy}
                         onClick={() => setAuthOpen(true)}
                       >
-                        sign in to resume
+                        add email alerts
                       </button>
                     </>
                   ) : (
                     <span className="set-dim">
-                      turning this on asks for an email, so there is somewhere to
-                      send the report.
+                      scans and system notifications work without an account.
+                      add email later if you want alerts in your inbox.
                     </span>
                   )}
                 </div>

package/.next/standalone/lib/auth/api-server-client.ts

@@ -257,7 +257,7 @@ export interface AuditReportBody {
    * Credentials this machine found in its own transcripts.
    *
    * Optional on the wire, so a CLI newer than the api-server sends a field the
-   * server ignores rather than failing the whole digest — the harmful counts
+   * server ignores rather than failing the whole report — the harmful counts
    * are the older half of the contract and must keep arriving either way.
    *
    * Every field here is a mask, a label, a length or a location. There is no
@@ -287,15 +287,15 @@ export interface AuditReportResult {
   report_id: string;
   /** Whether this report produced an email. */
   emailed: boolean;
-  /** `below_threshold`, `cooldown`, `send_failed`, or null when mail went out. */
+  /** `no_leak`, `cooldown`, `send_failed`, or null when mail went out. */
   reason: string | null;
   /**
    * Where the next window starts, per the SERVER.
    *
    * Persisted verbatim rather than computed locally. The server anchors it on
-   * the last DELIVERED digest, so a report held by the cooldown — or one whose
+   * the last DELIVERED alert, so a report held by the cooldown — or one whose
    * send failed — correctly leaves the watermark where it was, and its findings
-   * turn up in the next digest instead of falling into a gap. A machine that
+   * turn up in the next alert instead of falling into a gap. A machine that
    * lost `machine.json` also resyncs here rather than re-reporting from the
    * beginning of time.
    */
@@ -303,11 +303,11 @@ export interface AuditReportResult {
 }
 
 /**
- * Submit one scheduled scan's harmful findings.
+ * Submit one scheduled scan's harmful findings and newest masked credential.
  *
  * Called only by the audit child, and only on `--scheduled`. The destination
  * address is never sent: the api-server takes it from the access-token claims,
- * so a report cannot name where its digest goes.
+ * so a report cannot name where its email alert goes.
  */
 export async function submitAuditReport(
   accessToken: string,

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

@@ -158,6 +158,21 @@ function joinTexts(blocks: CodexContentBlock[] | undefined, wantedType: "input_t
     .join("\n");
 }
 
+/** Text carried by tool outputs. Newer Codex chronicles use an array of
+ * `input_text` blocks for `custom_tool_call_output`, while older releases use
+ * one string for `function_call_output`. */
+function toolOutputText(output: unknown): string {
+  if (typeof output === "string") return output;
+  if (Array.isArray(output)) {
+    return output
+      .filter((block): block is CodexContentBlock => !!block && typeof block === "object")
+      .map((block) => typeof block.text === "string" ? block.text : "")
+      .filter(Boolean)
+      .join("\n");
+  }
+  return output === undefined ? "" : JSON.stringify(output);
+}
+
 /**
  * Parse a Codex JSONL transcript into `LogEntry[]` plus the raw lines.
  * Yields to the event loop every 200 lines so big transcripts don't block.
@@ -250,10 +265,11 @@ export async function parseCodexLog(
         continue;
       }
 
-      if (subType === "function_call") {
+      if (subType === "function_call" || subType === "custom_tool_call") {
         const callId = payload.call_id as string | undefined;
         const name = (payload.name as string | undefined) ?? "function_call";
-        const input = safeJsonParse(payload.arguments as string | undefined);
+        const encodedInput = (payload.arguments ?? payload.input) as string | undefined;
+        const input = safeJsonParse(encodedInput);
         const toolUse: ToolUseBlock = {
           type: "tool_use",
           id: callId ?? `${timestamp}-${name}`,
@@ -273,7 +289,7 @@ export async function parseCodexLog(
         continue;
       }
 
-      if (subType === "function_call_output") {
+      if (subType === "function_call_output" || subType === "custom_tool_call_output") {
         const callId = payload.call_id as string | undefined;
         const block = callId ? toolUseById.get(callId) : undefined;
         if (block) {
@@ -282,7 +298,7 @@ export async function parseCodexLog(
           block.result = {
             timestamp,
             timestampFormatted: formatTimestamp(date),
-            content: typeof payload.output === "string" ? (payload.output as string) : JSON.stringify(payload.output),
+            content: toolOutputText(payload.output),
             durationMs: duration,
             durationFormatted: formatDuration(duration),
           };

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

@@ -151,6 +151,11 @@ interface CopilotToolResult {
   detailedContent?: string;
 }
 
+interface CopilotHookToolResult {
+  textResultForLlm?: string;
+  sessionLog?: string;
+}
+
 interface CopilotToolTelemetry {
   metrics?: { commandTimeMs?: number; durationMs?: number };
   properties?: Record<string, unknown>;
@@ -171,6 +176,8 @@ export async function parseCopilotLog(
   // toolCallId → tool_use block, so we can attach tool.execution_complete back.
   const toolUseById = new Map<string, ToolUseBlock>();
   const toolUseStartMs = new Map<string, number>();
+  let mostRecentToolUse: ToolUseBlock | undefined;
+  let mostRecentToolUseStartMs = 0;
   let cwd: string | undefined;
   let seenSessionStart = false;
 
@@ -273,9 +280,32 @@ export async function parseCopilotLog(
         toolUseById.set(callId, toolUse);
         toolUseStartMs.set(callId, date.getTime());
       }
+      mostRecentToolUse = toolUse;
+      mostRecentToolUseStartMs = date.getTime();
       continue;
     }
 
+    // Copilot CLI 1.0.39 can omit the command's real stdout from
+    // `tool.execution_complete` and expose it only to the PostToolUse hook as
+    // `input.toolResult.textResultForLlm`. That is the value the model saw and
+    // the value failproofai must audit. Keep it on the active tool block; the
+    // later completion record may still contribute timing, but must not replace
+    // this output with its shorter status-only summary.
+    if (recType === "hook.start" && data.hookType === "postToolUse" && mostRecentToolUse) {
+      const input = (data.input as Record<string, unknown> | undefined) ?? {};
+      const hookResult = (input.toolResult as CopilotHookToolResult | undefined) ?? {};
+      const hookContent = hookResult.textResultForLlm ?? hookResult.sessionLog;
+      if (typeof hookContent === "string" && hookContent.length > 0) {
+        mostRecentToolUse.result = {
+          timestamp,
+          timestampFormatted: formatTimestamp(date),
+          content: hookContent,
+          durationMs: Math.max(0, date.getTime() - mostRecentToolUseStartMs),
+          durationFormatted: formatDuration(Math.max(0, date.getTime() - mostRecentToolUseStartMs)),
+        };
+      }
+    }
+
     if (recType === "tool.execution_complete") {
       const callId = data.toolCallId as string | undefined;
       const block = callId ? toolUseById.get(callId) : undefined;
@@ -289,7 +319,8 @@ export async function parseCopilotLog(
           typeof reportedMs === "number" && reportedMs >= 0
             ? reportedMs
             : Math.max(0, date.getTime() - startMs);
-        const content = result.detailedContent ?? result.content ?? "";
+        const completionContent = result.detailedContent ?? result.content ?? "";
+        const content = block.result?.content || completionContent;
         block.result = {
           timestamp,
           timestampFormatted: formatTimestamp(date),

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

@@ -127,7 +127,15 @@ interface CursorRecord {
   /** Cursor 2026-04+ transcript shape: `{role, message: {content: [...]}}`. */
   role?: "user" | "assistant" | "system" | string;
   message?: {
-    content?: Array<{ type?: string; text?: string }>;
+    content?: Array<{
+      type?: string;
+      text?: string;
+      id?: string;
+      name?: string;
+      input?: Record<string, unknown>;
+      tool_use_id?: string;
+      content?: unknown;
+    }>;
   };
 }
 
@@ -183,11 +191,36 @@ export async function parseCursorLog(
     if (!raw.type && raw.role && raw.message?.content) {
       const synthDate = new Date(SYNTH_T0 + i);
       const synthTs = synthDate.toISOString();
-      const textParts = raw.message.content
+      const messageContent = raw.message.content;
+      const textParts = messageContent
         .filter((c) => c?.type === "text" && typeof c.text === "string")
         .map((c) => c.text!)
         .join("");
       if (raw.role === "user") {
+        // Some Cursor builds emit Claude-style tool_result blocks in the next
+        // user record. Pair them before treating any remaining text as a user
+        // turn so command output is available to the credential scanner.
+        let attachedResult = false;
+        for (const block of messageContent) {
+          if (block?.type !== "tool_result") continue;
+          const callId = typeof block.tool_use_id === "string" ? block.tool_use_id : undefined;
+          const toolUse = callId ? toolUseById.get(callId) : undefined;
+          if (!toolUse) continue;
+          const durationMs = Math.max(
+            0,
+            synthDate.getTime() - (toolUseStartMs.get(callId!) ?? synthDate.getTime()),
+          );
+          toolUse.result = {
+            timestamp: synthTs,
+            timestampFormatted: formatTimestamp(synthDate),
+            content: typeof block.content === "string"
+              ? block.content
+              : block.content == null ? "" : JSON.stringify(block.content),
+            durationMs,
+            durationFormatted: formatDuration(durationMs),
+          };
+          attachedResult = true;
+        }
         // Strip the synthesized `<timestamp>...</timestamp>\n<user_query>...\n</user_query>`
         // wrapper Cursor adds for context — keep just the user_query body.
         const queryMatch = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/.exec(textParts);
@@ -198,13 +231,37 @@ export async function parseCursorLog(
             ...baseEntry(rawCopy, synthTs, synthDate, source),
             message: { role: "user", content: text },
           } satisfies UserEntry);
+        } else if (!attachedResult) {
+          entries.push({
+            type: "system",
+            ...baseEntry(rawCopy, synthTs, synthDate, source),
+            raw: rawCopy,
+          } satisfies GenericEntry);
         }
         continue;
       }
       if (raw.role === "assistant") {
-        const blocks: ContentBlock[] = textParts
-          ? [{ type: "text", text: textParts }]
-          : [];
+        const blocks: ContentBlock[] = [];
+        if (textParts) blocks.push({ type: "text", text: textParts });
+        for (let j = 0; j < messageContent.length; j++) {
+          const contentBlock = messageContent[j];
+          if (contentBlock?.type !== "tool_use") continue;
+          const name = typeof contentBlock.name === "string" ? contentBlock.name : "tool";
+          const id = typeof contentBlock.id === "string" && contentBlock.id
+            ? contentBlock.id
+            : `cursor-${i}-${name}-${j}`;
+          const toolUse: ToolUseBlock = {
+            type: "tool_use",
+            id,
+            name,
+            input: contentBlock.input && typeof contentBlock.input === "object"
+              ? contentBlock.input
+              : {},
+          };
+          blocks.push(toolUse);
+          toolUseById.set(id, toolUse);
+          toolUseStartMs.set(id, synthDate.getTime());
+        }
         if (blocks.length === 0) {
           entries.push({
             type: "system",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "1.0.4-beta.4",
+  "version": "1.0.4-beta.7",
   "description": "Observability and enforcement for AI agent harnesses. 39 built-in policies hooked into 12 of them — Claude Code, Codex, Cursor, Hermes, OpenClaw and more — blocking the tool call before it runs. Local dashboard included, no account needed.",
   "bin": {
     "failproofai": "./dist/cli.mjs",
@@ -121,15 +121,15 @@
     "browserslist": "4.28.8"
   },
   "optionalDependencies": {
-    "@failproofai/failproofaid-linux-x64": "1.0.4-beta.4",
-    "@failproofai/failproofaid-linux-arm64": "1.0.4-beta.4",
-    "@failproofai/failproofaid-darwin-x64": "1.0.4-beta.4",
-    "@failproofai/failproofaid-darwin-arm64": "1.0.4-beta.4"
+    "@failproofai/failproofaid-linux-x64": "1.0.4-beta.7",
+    "@failproofai/failproofaid-linux-arm64": "1.0.4-beta.7",
+    "@failproofai/failproofaid-darwin-x64": "1.0.4-beta.7",
+    "@failproofai/failproofaid-darwin-arm64": "1.0.4-beta.7"
   },
   "failproofaidBinaries": {
-    "linux-x64": "4487790ed9b881da2914b5985a23b5adca1f20e226d71c635d8170064e6b2340",
-    "linux-arm64": "c903c5e201198213ccd8295fdab741c7d08d22c8dd5c276e52aa766595bedcc2",
-    "darwin-x64": "f0933584abbf0f9ff95cd153f8c6c704e467af1d6ffc8f42f9c426bd44b1142a",
-    "darwin-arm64": "387a3acbf13f667a557c8ac632fe67dee350cda078e3266e71edfcfacb9ecae6"
+    "linux-x64": "e59735a8f94cd8ac697b2bd67aafdd8d76a8394d53db229876980cc13a18f07e",
+    "linux-arm64": "b9ce50dd2f79b55f4f7112add265a776a4a6d002c2a56f971e666fbb796f3906",
+    "darwin-x64": "b46efc8ec33945a5cc26b7bb288fb87cea65b5983bd83094b5e607d53b8eda4c",
+    "darwin-arm64": "a8cc6112cee5ca8a7d517900e9ce32118855135980f22979fa0ff7aa6f68d954"
   }
 }