failproofai 1.0.4-beta.8 → 1.0.5-beta.0

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

@@ -29,8 +29,12 @@
  * 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.
  *
- * Scheduling and system notifications are separate machine settings. Turning
- * notifications off must not silently stop the seven-day scan or email alerts.
+ * ## 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.
  */
 
 import { useCallback, useEffect, useRef, useState, type ReactNode } from "react";
@@ -40,7 +44,6 @@ 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";
@@ -184,9 +187,12 @@ 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" 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.
+ * "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.
  */
 const HOW_IT_WORKS: ReadonlyArray<{ label: string; body: string }> = [
   {
@@ -196,7 +202,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: "only the newest masked credential exposure, its CLI, time, location, and this machine's name — only when email is configured.",
+    body: "counts, redacted examples, and this machine's name — and only when a scan finds something harmful.",
   },
 ];
 
@@ -205,7 +211,6 @@ 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);
@@ -249,7 +254,6 @@ 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);
@@ -308,6 +312,26 @@ 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();
@@ -336,23 +360,13 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
       }
       return;
     }
-    await enable();
-  }, [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);
+    // Turning it on needs somewhere to send the digest.
+    if (!signedIn) {
+      setAuthOpen(true);
+      return;
     }
-  }, [notify]);
+    await enable();
+  }, [auto, enable, reload, signedIn]);
 
   const commitInterval = useCallback(
     async (raw: number) => {
@@ -389,7 +403,7 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
     setBusy(true);
     try {
       await fetch("/api/auth/logout", { method: "POST" });
-      toast("signed out. scans and desktop notifications continue; email alerts pause.");
+      toast("signed out. scans continue; digests pause.");
       await reload();
     } catch {
       toast("could not sign out.");
@@ -520,9 +534,7 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
                     </span>
                     <span className="set-dim">
                       {auto
-                        ? signedIn
-                          ? "scheduled scans are active; the latest masked leak is emailed."
-                          : "scheduled scans are active. add an email below for masked alerts."
+                        ? "you'll get an email only when a scan finds something."
                         : "off. nothing runs and nothing is sent."}
                     </span>
                   </div>
@@ -554,23 +566,6 @@ 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">
@@ -598,7 +593,7 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
                     // from it at all.
                     <>
                       <span className="set-warn">
-                        signed out — scheduled scans continue; email alerts are paused.
+                        signed out — scans continue, digests are paused.
                       </span>
                       <button
                         type="button"
@@ -606,13 +601,13 @@ export default function SettingsClient({ initial }: { initial: ScheduledAuditVie
                         disabled={busy}
                         onClick={() => setAuthOpen(true)}
                       >
-                        add email alerts
+                        sign in to resume
                       </button>
                     </>
                   ) : (
                     <span className="set-dim">
-                      scans and system notifications work without an account.
-                      add email later if you want alerts in your inbox.
+                      turning this on asks for an email, so there is somewhere to
+                      send the report.
                     </span>
                   )}
                 </div>

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

@@ -253,49 +253,21 @@ export interface AuditReportBody {
     last_seen?: string;
     examples: string[];
   }[];
-  /**
-   * 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 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
-   * shape of this object that carries a secret, because the record it is built
-   * from never stores one: `recordLeaks` fingerprints at detection time and
-   * keeps only the masked rendering.
-   */
-  leaks?: {
-    id: string;
-    display: string;
-    label: string;
-    length: number;
-    attributed: boolean;
-    name: string | null;
-    confidence: string;
-    first_seen: string;
-    last_seen: string;
-    occurrences: number;
-    cli: string;
-    project: string;
-    mechanism: string;
-    direction: "input" | "result";
-  }[];
 }
 
 export interface AuditReportResult {
   report_id: string;
   /** Whether this report produced an email. */
   emailed: boolean;
-  /** `no_leak`, `cooldown`, `send_failed`, or null when mail went out. */
+  /** `below_threshold`, `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 alert, so a report held by the cooldown — or one whose
+   * the last DELIVERED digest, 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 alert instead of falling into a gap. A machine that
+   * turn up in the next digest 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 +275,11 @@ export interface AuditReportResult {
 }
 
 /**
- * Submit one scheduled scan's harmful findings and newest masked credential.
+ * Submit one scheduled scan's harmful findings.
  *
  * 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 email alert goes.
+ * so a report cannot name where its digest goes.
  */
 export async function submitAuditReport(
   accessToken: string,

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

@@ -4,14 +4,8 @@
  * Claude stores transcripts at:
  *   <CLAUDE_PROJECTS_PATH>/<encoded-cwd>/<sessionId>.jsonl
  *
- * Subagent transcripts (when a session spawned subagents) live alongside, in two
- * shapes — a direct child, and one nested per workflow run:
+ * Subagent transcripts (when a session spawned subagents) live alongside:
  *   <CLAUDE_PROJECTS_PATH>/<encoded-cwd>/<sessionId>/subagents/<agentId>.jsonl
- *   <CLAUDE_PROJECTS_PATH>/<encoded-cwd>/<sessionId>/subagents/workflows/<runId>/<agentId>.jsonl
- *
- * Everything below `subagents/` is walked to a bounded depth rather than one
- * level, because the second shape arrived after this module was written and the
- * miss was most of the corpus. See `collectSubagentTranscripts`.
  *
  * The parser for these files lives in `lib/log-entries.ts` (`parseLogContent`,
  * `parseSessionLog`). This module exposes discovery only — the audit pipeline
@@ -76,99 +70,6 @@ export function listClaudeProjects(): ClaudeProjectFolder[] {
 /** Lists every JSONL transcript under one Claude project folder, including
  *  subagent transcripts under `<sessionId>/subagents/`. Returns [] on missing
  *  or unreadable paths. */
-/**
- * Depth of nesting allowed below `subagents/`.
- *
- * The two shapes that exist today need 0 and 2 (`<agent>.jsonl` and
- * `workflows/<runId>/<agent>.jsonl`). The cap is here so an unexpected layout —
- * or a symlink cycle a future Claude build introduces — costs a bounded walk
- * rather than an audit that never returns, and it is deliberately loose enough
- * that a third shape lands inside it without another release.
- */
-const MAX_SUBAGENT_DEPTH = 5;
-
-/**
- * Collect every `.jsonl` beneath a session's `subagents/` directory.
- *
- * This used to read only the DIRECT children of `subagents/`, which was correct
- * for the layout Claude shipped when it was written and silently wrong the day
- * workflow runs started nesting their agents one level further down. On a
- * machine that uses them the miss is most of the corpus: 1,839 transcripts on
- * disk, 1,741 under `subagents/`, and 1,679 of those inside
- * `subagents/workflows/<runId>/` — so the audit was walking 160 files, 8.7% of
- * the evidence, and reporting the result as though it had read everything.
- *
- * ## Session ids come from the relative path, not the basename
- *
- * Every workflow run writes a `journal.jsonl` beside its agents, so basenames
- * are NOT unique below this directory — 1,741 files share 1,613 distinct names
- * on the machine this was found on. A basename id would collide those 128 files
- * onto ~one row each, and `sessionId` is what the cache, the per-session
- * detector state and the example attribution are keyed by, so the collision
- * would silently merge unrelated sessions rather than fail.
- *
- * Nor is the path below `subagents/` unique on its own. A workflow run id is
- * reused when its session is resumed, so `wf_3d609e92-a38/journal.jsonl` exists
- * under two different parent sessions in the same project — found by asserting
- * uniqueness over the real corpus, not by reasoning about it.
- *
- * The id is therefore the PARENT SESSION id followed by the path relative to
- * `subagents/`, minus the extension, joined with `__`:
- * `<parentUuid>__workflows__wf_123__agent-abc`. That is a filesystem path
- * within the project, so it is unique by construction rather than by argument,
- * and it names the session the subagent belongs to. `__` is safe as the joiner
- * because no id Claude generates contains one — verified against 1,741 real
- * files, zero hits. Top-level session ids are untouched.
- *
- * Symlinks are not followed. Nothing in the layout uses them, and following one
- * is how a directory walk turns into an infinite loop.
- */
-function collectSubagentTranscripts(
-  dir: string,
-  relPrefix: string,
-  project: ClaudeProjectFolder,
-  out: ClaudeTranscriptFile[],
-  depth: number,
-): void {
-  if (depth > MAX_SUBAGENT_DEPTH) return;
-  let entries: import("node:fs").Dirent[];
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isSymbolicLink()) continue;
-    if (entry.isDirectory()) {
-      collectSubagentTranscripts(
-        join(dir, entry.name),
-        relPrefix ? `${relPrefix}__${entry.name}` : entry.name,
-        project,
-        out,
-        depth + 1,
-      );
-      continue;
-    }
-    if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const stem = entry.name.slice(0, -".jsonl".length);
-    const transcriptPath = join(dir, entry.name);
-    try {
-      const s = statSync(transcriptPath);
-      out.push({
-        projectName: project.name,
-        cwd: project.cwd,
-        sessionId: relPrefix ? `${relPrefix}__${stem}` : stem,
-        transcriptPath,
-        mtimeMs: s.mtimeMs,
-        sizeBytes: s.size,
-        isSubagent: true,
-      });
-    } catch {
-      // unreadable — skip
-    }
-  }
-}
-
 export function listClaudeTranscripts(project: ClaudeProjectFolder): ClaudeTranscriptFile[] {
   const out: ClaudeTranscriptFile[] = [];
   let entries: import("node:fs").Dirent[];
@@ -198,9 +99,34 @@ export function listClaudeTranscripts(project: ClaudeProjectFolder): ClaudeTrans
         // unreadable — skip
       }
     } else if (entry.isDirectory() && UUID_RE.test(entry.name)) {
+      // Subagent transcripts at <sessionId>/subagents/<agentId>.jsonl
       const subDir = join(project.path, entry.name, "subagents");
       if (!existsSync(subDir)) continue;
-      collectSubagentTranscripts(subDir, entry.name, project, out, 0);
+      let subEntries: import("node:fs").Dirent[];
+      try {
+        subEntries = readdirSync(subDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const sub of subEntries) {
+        if (!sub.isFile() || !sub.name.endsWith(".jsonl")) continue;
+        const agentId = sub.name.slice(0, -".jsonl".length);
+        const transcriptPath = join(subDir, sub.name);
+        try {
+          const s = statSync(transcriptPath);
+          out.push({
+            projectName: project.name,
+            cwd: project.cwd,
+            sessionId: agentId,
+            transcriptPath,
+            mtimeMs: s.mtimeMs,
+            sizeBytes: s.size,
+            isSubagent: true,
+          });
+        } catch {
+          // unreadable — skip
+        }
+      }
     }
   }
 

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

@@ -158,21 +158,6 @@ 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.
@@ -265,11 +250,10 @@ export async function parseCodexLog(
         continue;
       }
 
-      if (subType === "function_call" || subType === "custom_tool_call") {
+      if (subType === "function_call") {
         const callId = payload.call_id as string | undefined;
         const name = (payload.name as string | undefined) ?? "function_call";
-        const encodedInput = (payload.arguments ?? payload.input) as string | undefined;
-        const input = safeJsonParse(encodedInput);
+        const input = safeJsonParse(payload.arguments as string | undefined);
         const toolUse: ToolUseBlock = {
           type: "tool_use",
           id: callId ?? `${timestamp}-${name}`,
@@ -289,7 +273,7 @@ export async function parseCodexLog(
         continue;
       }
 
-      if (subType === "function_call_output" || subType === "custom_tool_call_output") {
+      if (subType === "function_call_output") {
         const callId = payload.call_id as string | undefined;
         const block = callId ? toolUseById.get(callId) : undefined;
         if (block) {
@@ -298,7 +282,7 @@ export async function parseCodexLog(
           block.result = {
             timestamp,
             timestampFormatted: formatTimestamp(date),
-            content: toolOutputText(payload.output),
+            content: typeof payload.output === "string" ? (payload.output as string) : JSON.stringify(payload.output),
             durationMs: duration,
             durationFormatted: formatDuration(duration),
           };

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

@@ -151,11 +151,6 @@ interface CopilotToolResult {
   detailedContent?: string;
 }
 
-interface CopilotHookToolResult {
-  textResultForLlm?: string;
-  sessionLog?: string;
-}
-
 interface CopilotToolTelemetry {
   metrics?: { commandTimeMs?: number; durationMs?: number };
   properties?: Record<string, unknown>;
@@ -176,8 +171,6 @@ 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;
 
@@ -280,32 +273,9 @@ 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;
@@ -319,8 +289,7 @@ export async function parseCopilotLog(
           typeof reportedMs === "number" && reportedMs >= 0
             ? reportedMs
             : Math.max(0, date.getTime() - startMs);
-        const completionContent = result.detailedContent ?? result.content ?? "";
-        const content = block.result?.content || completionContent;
+        const content = result.detailedContent ?? result.content ?? "";
         block.result = {
           timestamp,
           timestampFormatted: formatTimestamp(date),

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

@@ -127,15 +127,7 @@ interface CursorRecord {
   /** Cursor 2026-04+ transcript shape: `{role, message: {content: [...]}}`. */
   role?: "user" | "assistant" | "system" | string;
   message?: {
-    content?: Array<{
-      type?: string;
-      text?: string;
-      id?: string;
-      name?: string;
-      input?: Record<string, unknown>;
-      tool_use_id?: string;
-      content?: unknown;
-    }>;
+    content?: Array<{ type?: string; text?: string }>;
   };
 }
 
@@ -191,36 +183,11 @@ export async function parseCursorLog(
     if (!raw.type && raw.role && raw.message?.content) {
       const synthDate = new Date(SYNTH_T0 + i);
       const synthTs = synthDate.toISOString();
-      const messageContent = raw.message.content;
-      const textParts = messageContent
+      const textParts = raw.message.content
         .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);
@@ -231,37 +198,13 @@ 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[] = [];
-        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());
-        }
+        const blocks: ContentBlock[] = textParts
+          ? [{ type: "text", text: textParts }]
+          : [];
         if (blocks.length === 0) {
           entries.push({
             type: "system",