failproofai 1.0.4-beta.8 → 1.0.4

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",

package/.next/standalone/lib/download-session.ts

@@ -2,8 +2,8 @@
  * Per-CLI dispatcher for the dashboard's Download Logs endpoint.
  *
  * Returns either a real on-disk path (so the route can `createReadStream` and
- * stream the bytes verbatim) or a synthesized JSON/JSONL body for agents whose
- * transcripts live in SQLite.
+ * stream the bytes verbatim) or a synthesized JSONL body (used only by
+ * OpenCode, whose transcripts live in SQLite rather than on disk).
  *
  * Per-CLI session loaders / transcript finders already exist in their own
  * files; this module is the thin glue that picks the right one. Imports of
@@ -34,12 +34,7 @@ export const GOOSE_SESSION_RE = /^\d{8}_\d+$/;
 
 export type DownloadSource =
   | { kind: "file"; path: string }
-  | {
-      kind: "synthesized";
-      body: string;
-      contentType: string;
-      extension: string;
-    };
+  | { kind: "synthesized"; body: string; contentType: string; extension: string };
 
 /** Validate a session ID against the per-CLI shape. OpenCode uses `ses_*`
  *  prefixes; everyone else is a UUID. */
@@ -103,12 +98,7 @@ export async function resolveDownloadSource(
     const result = await getOpenCodeSessionExport(sessionId);
     if (!result) return null;
     const body = JSON.stringify(result, null, 2) + "\n";
-    return {
-      kind: "synthesized",
-      body,
-      contentType: "application/json",
-      extension: "json",
-    };
+    return { kind: "synthesized", body, contentType: "application/json", extension: "json" };
   }
 
   if (cli === "hermes") {
@@ -117,35 +107,13 @@ export async function resolveDownloadSource(
     const { getHermesSessionLog } = await import("./hermes-sessions");
     const result = await getHermesSessionLog(sessionId);
     if (!result) return null;
-    const body =
-      result.rawLines.map((r) => JSON.stringify(r)).join("\n") + "\n";
-    return {
-      kind: "synthesized",
-      body,
-      contentType: "application/x-ndjson",
-      extension: "jsonl",
-    };
+    const body = result.rawLines.map((r) => JSON.stringify(r)).join("\n") + "\n";
+    return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
   }
 
   if (cli === "openclaw") {
-    // New OpenClaw versions keep live transcripts in SQLite. Export the exact
-    // event_json rows as JSONL; fall back to streaming archived JSONL files.
-    const { findOpenClawTranscript, listOpenClawAgents, openclawHome } =
-      await import("./openclaw-sessions");
-    const { readOpenClawSqliteTranscript } = await import("./openclaw-db");
-    const sqlite = await readOpenClawSqliteTranscript(
-      openclawHome(),
-      listOpenClawAgents(),
-      sessionId,
-    );
-    if (sqlite) {
-      return {
-        kind: "synthesized",
-        body: sqlite.eventJsonLines.join("\n") + "\n",
-        contentType: "application/x-ndjson",
-        extension: "jsonl",
-      };
-    }
+    // OpenClaw writes real JSONL transcripts on disk — stream the file verbatim.
+    const { findOpenClawTranscript } = await import("./openclaw-sessions");
     const path = findOpenClawTranscript(sessionId);
     return path ? { kind: "file", path } : null;
   }
@@ -163,20 +131,13 @@ export async function resolveDownloadSource(
     const { getDevinSessionLog } = await import("./devin-sessions");
     const result = await getDevinSessionLog(sessionId);
     if (!result) return null;
-    const body =
-      result.rawLines.map((r) => JSON.stringify(r)).join("\n") + "\n";
-    return {
-      kind: "synthesized",
-      body,
-      contentType: "application/x-ndjson",
-      extension: "jsonl",
-    };
+    const body = result.rawLines.map((r) => JSON.stringify(r)).join("\n") + "\n";
+    return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
   }
 
   if (cli === "antigravity") {
     // Antigravity (agy) writes real JSONL transcripts on disk — stream verbatim.
-    const { findAntigravityTranscript } =
-      await import("./antigravity-sessions");
+    const { findAntigravityTranscript } = await import("./antigravity-sessions");
     const path = findAntigravityTranscript(sessionId);
     return path ? { kind: "file", path } : null;
   }
@@ -187,14 +148,8 @@ export async function resolveDownloadSource(
     const { getGooseSessionLog } = await import("./goose-sessions");
     const result = await getGooseSessionLog(sessionId);
     if (!result) return null;
-    const body =
-      result.rawLines.map((r) => JSON.stringify(r)).join("\n") + "\n";
-    return {
-      kind: "synthesized",
-      body,
-      contentType: "application/x-ndjson",
-      extension: "jsonl",
-    };
+    const body = result.rawLines.map((r) => JSON.stringify(r)).join("\n") + "\n";
+    return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
   }
 
   // Exhaustive — but TypeScript can't always see CliId is exhausted across the

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

@@ -1,21 +1,18 @@
 /**
  * OpenClaw (openclaw gateway) session enumeration — AUDIT-ONLY.
  *
- * Surfaces both legacy JSONL transcripts and OpenClaw 2026.9.2+ per-agent
- * SQLite transcripts as synthetic dashboard "projects" grouped by
- * (agentId, channel).
+ * Surfaces the on-disk transcripts (agents/<agentId>/sessions/<uuid>.jsonl) as
+ * synthetic dashboard "projects" grouped by (agentId, channel). The per-agent
+ * `sessions.json` index maps sessionKey → {sessionId, timestamps}; we read it to
+ * recover the sessionKey (which encodes the channel for gateway sessions) and a
+ * reliable last-activity time. Verified live against openclaw v2026.7.1.
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { runtimeCache } from "./runtime-cache";
-import {
-  listOpenClawAgents,
-  listOpenClawTranscripts,
-  openclawHome,
-} from "./openclaw-sessions";
+import { listOpenClawAgents, listOpenClawTranscripts, openclawHome } from "./openclaw-sessions";
 import type { ProjectFolder, SessionFile } from "./projects";
 import { formatDate } from "./format-date";
-import { listOpenClawSqliteSessions } from "./openclaw-db";
 
 export interface OpenClawSessionRef {
   sessionId: string;
@@ -54,13 +51,7 @@ function str(v: unknown): string | undefined {
  *  than in the key — verified live against v2026.7.1. */
 function readSessionsIndex(agentId: string): Map<string, SessionIndexMeta> {
   const out = new Map<string, SessionIndexMeta>();
-  const indexPath = join(
-    openclawHome(),
-    "agents",
-    agentId,
-    "sessions",
-    "sessions.json",
-  );
+  const indexPath = join(openclawHome(), "agents", agentId, "sessions", "sessions.json");
   let raw: unknown;
   try {
     raw = JSON.parse(readFileSync(indexPath, "utf-8"));
@@ -73,9 +64,7 @@ function readSessionsIndex(agentId: string): Map<string, SessionIndexMeta> {
     const e = v as Record<string, unknown>;
     const sessionId = str(e.sessionId);
     if (!sessionId) continue;
-    const origin = (
-      e.origin && typeof e.origin === "object" ? e.origin : {}
-    ) as Record<string, unknown>;
+    const origin = (e.origin && typeof e.origin === "object" ? e.origin : {}) as Record<string, unknown>;
     const lastMs =
       typeof e.lastInteractionAt === "number"
         ? e.lastInteractionAt
@@ -84,8 +73,7 @@ function readSessionsIndex(agentId: string): Map<string, SessionIndexMeta> {
           : undefined;
     out.set(sessionId, {
       lastMs,
-      channel:
-        str(e.lastChannel) ?? str(origin.provider) ?? str(origin.surface),
+      channel: str(e.lastChannel) ?? str(origin.provider) ?? str(origin.surface),
       chatType: str(e.chatType) ?? str(origin.chatType),
       label: str(origin.label),
       chatId: str(e.lastTo) ?? str(origin.from),
@@ -98,7 +86,7 @@ function readSessionsIndex(agentId: string): Map<string, SessionIndexMeta> {
 export async function getOpenClawSessions(): Promise<OpenClawSessionRef[]> {
   const transcripts = listOpenClawTranscripts();
   const indexByAgent = new Map<string, Map<string, SessionIndexMeta>>();
-  const refs = new Map<string, OpenClawSessionRef>();
+  const refs: OpenClawSessionRef[] = [];
   for (const t of transcripts) {
     let idx = indexByAgent.get(t.agentId);
     if (!idx) {
@@ -106,7 +94,7 @@ export async function getOpenClawSessions(): Promise<OpenClawSessionRef[]> {
       indexByAgent.set(t.agentId, idx);
     }
     const meta = idx.get(t.sessionId);
-    refs.set(`${t.agentId}\0${t.sessionId}`, {
+    refs.push({
       sessionId: t.sessionId,
       agentId: t.agentId,
       // Gateway sessions group by channel; CLI/local runs have none.
@@ -119,18 +107,8 @@ export async function getOpenClawSessions(): Promise<OpenClawSessionRef[]> {
       sizeBytes: t.sizeBytes,
     });
   }
-
-  // SQLite is the live source on OpenClaw 2026.9.2+. Insert it second so it
-  // replaces an archived JSONL copy of the same agent/session.
-  const sqliteSessions = await listOpenClawSqliteSessions(
-    openclawHome(),
-    listOpenClawAgents(),
-  );
-  for (const s of sqliteSessions) {
-    refs.set(`${s.agentId}\0${s.sessionId}`, s);
-  }
-
-  return [...refs.values()].sort((a, b) => b.mtimeMs - a.mtimeMs);
+  refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return refs;
 }
 
 export const getCachedOpenClawSessions = runtimeCache(getOpenClawSessions, 2);
@@ -167,9 +145,7 @@ export interface OpenClawNameSplit {
  * form (`agentId: null`), so links shared before agents became part of the name
  * keep resolving — to every agent on that channel, which is what they meant.
  */
-export function openClawProjectNameCandidates(
-  name: string,
-): OpenClawNameSplit[] {
+export function openClawProjectNameCandidates(name: string): OpenClawNameSplit[] {
   if (!name.startsWith("openclaw-")) return [];
   const rest = name.slice("openclaw-".length);
   if (!rest) return [];
@@ -187,9 +163,7 @@ export function openClawProjectNameCandidates(
 }
 
 /** The best-guess split for a project name — `null` if it isn't an OpenClaw one. */
-export function parseOpenClawProjectName(
-  name: string,
-): OpenClawNameSplit | null {
+export function parseOpenClawProjectName(name: string): OpenClawNameSplit | null {
   return openClawProjectNameCandidates(name)[0] ?? null;
 }
 
@@ -216,12 +190,7 @@ export async function getOpenClawProjects(): Promise<ProjectFolder[]> {
       prev.latest = Math.max(prev.latest, s.mtimeMs);
       prev.count += 1;
     } else {
-      groups.set(key, {
-        agentId: s.agentId,
-        channel: s.channel,
-        latest: s.mtimeMs,
-        count: 1,
-      });
+      groups.set(key, { agentId: s.agentId, channel: s.channel, latest: s.mtimeMs, count: 1 });
     }
   }
   const out: ProjectFolder[] = [];
@@ -259,9 +228,7 @@ export async function getOpenClawSessionsByEncodedName(
   const sessions = await getOpenClawSessions();
   const matching = (split: OpenClawNameSplit) =>
     sessions.filter(
-      (s) =>
-        s.channel === split.channel &&
-        (split.agentId === null || s.agentId === split.agentId),
+      (s) => s.channel === split.channel && (split.agentId === null || s.agentId === split.agentId),
     );
 
   // Take the first split that actually owns sessions — length alone picks the
@@ -283,10 +250,7 @@ export async function getOpenClawSessionsByEncodedName(
   return {
     // Legacy channel-only names keep their old cwd label, since they really do
     // span every agent on that channel.
-    cwd:
-      agentId === null
-        ? `openclaw:${channel}`
-        : openClawProjectPath(agentId, channel),
+    cwd: agentId === null ? `openclaw:${channel}` : openClawProjectPath(agentId, channel),
     sessions: matched.map((s) => {
       const lastModified = new Date(s.mtimeMs);
       return {