trajectories 0.0.0 → 0.1.1

package/legacy/src/scanner.ts

@@ -0,0 +1,591 @@
+import { discoveryHeadBudget, pageDiscoveryInventory, uniqueDiscovered, type DiscoveryCheckpoint } from "./discovery.js";
+import { existsSync, readdirSync, statSync, type Stats } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join } from "node:path";
+import {
+  type AnyTrajectorySource,
+  listTrajectories,
+} from "@letta-ai/trajectory";
+import type {
+  DiscoveredSession,
+  ScanOptions,
+  ScanOutcome,
+  ScanOutcomeStatus,
+  ScanResult,
+} from "./types.js";
+import {
+  type ParentageDiagnostic,
+  type ParentageOptions,
+  readPiSessionIdFromFile,
+} from "./parentage.js";
+import { cursorRoots, discoverCursorSessions } from "./native/cursor.js";
+import { discoverGrokSessions, grokRoots } from "./native/grok.js";
+import { discoverKimiSessions, kimiRoots } from "./native/kimi.js";
+import { openCodeRoots, discoverOpenCodeSessions } from "./native/opencode.js";
+
+export type SessionScanOptions = ScanOptions & Pick<ParentageOptions, "onDiagnostic">;
+
+const DEFAULT_SOURCES = [
+  "claude-code",
+  "codex",
+  "pi",
+  "omp",
+  "hermes",
+  "letta-code",
+  "openclaw",
+  "droid",
+  "deepagents",
+  "openhands",
+];
+
+const KNOWN_EXTRA_LOCATIONS: Record<string, string[]> = {
+  "gemini-cli": [join(homedir(), ".gemini", "sessions")],
+  "copilot-cli": [
+    join(homedir(), ".copilot", "session-state"),
+    join(homedir(), ".copilot", "history-session-state"),
+  ],
+};
+
+/** Outcome details name an error class and code, never message text, which can quote store content. */
+export const SCAN_OUTCOME_DETAIL_LIMIT = 120;
+
+export function capScanDetail(text: string): string {
+  return text.slice(0, SCAN_OUTCOME_DETAIL_LIMIT);
+}
+
+function failureDetail(error: unknown): string {
+  if (!(error instanceof Error)) return `Non-Error failure (${typeof error})`;
+  const code = errnoCode(error);
+  return capScanDetail(code === undefined ? error.name : `${error.name} (${code})`);
+}
+
+function errnoCode(error: unknown): string | undefined {
+  if (typeof error !== "object" || error === null || !("code" in error)) return undefined;
+  const code = error.code;
+  return typeof code === "string" ? code : undefined;
+}
+
+/** The path a listing branch reads, and the shape it must have to read it. */
+interface ScanRoot {
+  path: string;
+  kind: "directory" | "file" | "any";
+}
+
+/**
+ * Where each source reads by default, mirroring @letta-ai/trajectory 0.3.0's
+ * per-adapter resolution (`dist/adapters/<source>/list.js`) so the probe stats
+ * exactly what the lister reads. Keep in step when the pinned library moves.
+ */
+function defaultRoots(source: string): ScanRoot[] {
+  const home = homedir();
+  switch (source) {
+    case "claude-code": return [{ path: join(home, ".claude", "projects"), kind: "directory" }];
+    case "codex": return [{ path: join(home, ".codex", "sessions"), kind: "directory" }];
+    case "pi": return [{ path: join(piAgentDir(), "sessions"), kind: "directory" }];
+    case "omp": return [{ path: ompSessionsDir(), kind: "directory" }];
+    case "hermes": return [{ path: join(home, ".hermes", "state.db"), kind: "file" }];
+    case "letta-code": return [{ path: join(home, ".letta", "transcripts"), kind: "directory" }];
+    case "openclaw": return [{ path: openClawStateDir(), kind: "directory" }];
+    case "droid": return [{ path: join(home, ".factory", "sessions"), kind: "directory" }];
+    case "deepagents": return [{ path: join(home, ".deepagents", "sessions.db"), kind: "file" }];
+    case "openhands": return [{ path: join(home, ".openhands", "sessions"), kind: "directory" }];
+    case "cursor": return cursorRoots().map((path) => ({ path, kind: "directory" }));
+    case "opencode": return openCodeRoots().map((path) => ({ path, kind: "directory" }));
+    case "grok": return grokRoots().map((path) => ({ path, kind: "directory" }));
+    case "kimi": return kimiRoots().map((path) => ({ path, kind: "directory" }));
+    case "cline": return [{ path: process.env.CLINE_SESSION_DATA_DIR?.trim() || join(home, ".cline", "data", "sessions"), kind: "directory" }];
+    case "fx": return [{ path: join(home, ".fx", "sessions"), kind: "directory" }];
+    case "gemini-cli": return [{ path: join(home, ".gemini", "sessions"), kind: "directory" }];
+    case "copilot-cli": return KNOWN_EXTRA_LOCATIONS["copilot-cli"].map((path) => ({ path, kind: "directory" }));
+    default: return [];
+  }
+}
+
+/** Mirror of the pi adapter's `defaultAgentDir()`. */
+function piAgentDir(): string {
+  return process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
+}
+
+/** Mirror of the omp adapter's `resolveOmpSessionsPath()` path inputs. */
+function ompSessionsDir(): string {
+  const home = homedir();
+  const profile = ompProfile();
+  const configRoot = join(home, process.env.PI_CONFIG_DIR || ".omp", ...(profile ? ["profiles", profile] : []));
+  const agentOverride = profile ? undefined : process.env.PI_CODING_AGENT_DIR?.trim() || undefined;
+  const agentDir = agentOverride ?? join(configRoot, "agent");
+  if (agentOverride === undefined && (process.platform === "linux" || process.platform === "darwin")) {
+    const xdgData = process.env.XDG_DATA_HOME?.trim();
+    if (xdgData) {
+      const xdgRoot = join(xdgData, "omp", ...(profile ? ["profiles", profile] : []));
+      if (existsSync(xdgRoot)) return join(xdgRoot, "sessions");
+    }
+  }
+  return join(agentDir, "sessions");
+}
+
+/** Mirror of the omp adapter's profile validation. */
+function ompProfile(): string | undefined {
+  const value = (process.env.OMP_PROFILE !== undefined ? process.env.OMP_PROFILE : process.env.PI_PROFILE)?.trim();
+  if (!value || value === "default") return undefined;
+  if (value === "." ||
+    value === ".." ||
+    value.endsWith(".") ||
+    !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(value) ||
+    /^(?:CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(?:\..*)?$/i.test(value)) {
+    return undefined;
+  }
+  return value;
+}
+
+/** Mirror of the openclaw adapter's `defaultStateDir()`. */
+function openClawStateDir(): string {
+  const override = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
+  if (override) return override;
+  const current = join(homedir(), ".openclaw");
+  return existsSync(current) ? current : join(homedir(), ".clawdbot");
+}
+
+/** Mirror of the SQLite listers' `resolveStorePath()`: a `.db` path, or a directory holding one. */
+function storePath(root: string, filename: string): string {
+  return root.endsWith(".db") ? root : join(root, filename);
+}
+
+/**
+ * The roots a source will read: an explicit override, or the source's standard
+ * local locations. One source's root is another's directory of sessions, and
+ * the SQLite listers accept either a store file or the directory holding it.
+ */
+function resolveScanRoots(source: string, override: string | undefined): ScanRoot[] {
+  if (override === undefined) return defaultRoots(source);
+  switch (source) {
+    case "pi":
+    case "omp": return [{ path: join(override, "sessions"), kind: "directory" }];
+    case "hermes": return [{ path: storePath(override, "state.db"), kind: "file" }];
+    case "deepagents": return [{ path: storePath(override, "sessions.db"), kind: "file" }];
+    case "cursor":
+    case "opencode":
+    case "grok":
+    case "kimi": return [{ path: override, kind: "any" }];
+    default: return DEFAULT_SOURCES.includes(source)
+      ? [{ path: override, kind: "directory" }]
+      : [{ path: override, kind: "any" }];
+  }
+}
+
+type RootVerdict = "readable" | "missing" | "unreadable" | "wrong_shape";
+
+interface RootProbe {
+  status: Exclude<ScanOutcomeStatus, "listing_failed">;
+  /** The path behind the status: the first readable root when listable, the failing path otherwise. */
+  root: string;
+  detail: string | null;
+}
+
+/**
+ * Stat the resolved roots before listing. Upstream listers report a missing,
+ * unreadable, or file-shaped root as an empty listing, so the outcome cannot be
+ * recovered from item counts; it has to be probed here. One healthy root is
+ * enough to list — the remaining roots stay with the listing branch's own error
+ * handling.
+ */
+function probeRoots(candidates: ScanRoot[]): RootProbe {
+  if (candidates.length === 0) {
+    return { status: "missing_root", root: "", detail: "no known store location" };
+  }
+  const verdicts: Array<{ candidate: ScanRoot; verdict: RootVerdict; detail: string | null }> = [];
+  for (const candidate of candidates) {
+    let stat: Stats;
+    try {
+      stat = statSync(candidate.path);
+    } catch (error) {
+      verdicts.push(errnoCode(error) === "ENOENT"
+        ? { candidate, verdict: "missing", detail: null }
+        : { candidate, verdict: "unreadable", detail: failureDetail(error) });
+      continue;
+    }
+    if (candidate.kind === "directory" && !stat.isDirectory()) {
+      verdicts.push({ candidate, verdict: "wrong_shape", detail: null });
+      continue;
+    }
+    if (candidate.kind === "file" && !stat.isFile()) {
+      verdicts.push({ candidate, verdict: "wrong_shape", detail: null });
+      continue;
+    }
+    if (candidate.kind === "directory") {
+      try {
+        readdirSync(candidate.path);
+      } catch (error) {
+        verdicts.push({ candidate, verdict: "unreadable", detail: failureDetail(error) });
+        continue;
+      }
+    }
+    verdicts.push({ candidate, verdict: "readable", detail: null });
+  }
+  const readable = verdicts.find((entry) => entry.verdict === "readable");
+  if (readable) return { status: "listable", root: readable.candidate.path, detail: null };
+  const unreadable = verdicts.find((entry) => entry.verdict === "unreadable");
+  if (unreadable) return { status: "unreadable_root", root: unreadable.candidate.path, detail: unreadable.detail };
+  const wrongShape = verdicts.find((entry) => entry.verdict === "wrong_shape");
+  if (wrongShape) return { status: "root_wrong_shape", root: wrongShape.candidate.path, detail: null };
+  return { status: "missing_root", root: candidates[0].path, detail: null };
+}
+
+function scanOutcome(
+  source: string,
+  root: string,
+  status: ScanOutcomeStatus,
+  discovered: number,
+  detail: string | null = null,
+): ScanOutcome {
+  return { source, root, status, discovered, detail };
+}
+
+export async function scanSessions(
+  options: SessionScanOptions = {},
+): Promise<ScanResult> {
+  const sourcesToScan = options.sources ?? [
+    ...DEFAULT_SOURCES,
+    "cursor",
+    "opencode",
+    "grok",
+    "kimi",
+    "gemini-cli",
+    "copilot-cli",
+  ];
+
+  const sessions: DiscoveredSession[] = [];
+  const outcomes: ScanOutcome[] = [];
+  const discovery: DiscoveryCheckpoint[] = [];
+  const roots = options.roots ?? {};
+  const limitPerSource = options.limit ?? 1000;
+  if (!Number.isSafeInteger(limitPerSource) || limitPerSource < 1) {
+    throw new RangeError("Session scan limit must be a positive safe integer.");
+  }
+
+  for (const source of sourcesToScan) {
+    const candidates = resolveScanRoots(source, roots[source]);
+    const rootKey = JSON.stringify({ version: 1, roots: candidates });
+    const saved = options.discovery?.[source];
+    const previous = saved?.root_key === rootKey ? saved : undefined;
+    let nextCursor = previous?.cursor ?? null;
+    let partial = previous?.cursor ? previous.degraded : false;
+    const finishDiscovery = (outcome: ScanOutcome): void => {
+      if (!options.discovery) return;
+      partial ||= outcome.status !== "listable" || !!outcome.detail;
+      const status = outcome.status !== "listable" ? "unknown"
+        : nextCursor ? "pending" : partial ? "unknown" : "exhausted";
+      const stamp = new Date().toISOString();
+      discovery.push({ source, root_key: rootKey, cursor: nextCursor, status,
+        degraded: partial, updated_at: stamp,
+        last_completed_at: status === "exhausted" ? stamp : previous?.last_completed_at ?? null });
+    };
+    const selectInventory = (inventory: DiscoveredSession[]): DiscoveredSession[] => {
+      const page = pageDiscoveryInventory(inventory, limitPerSource, previous?.cursor ?? null);
+      nextCursor = page.next;
+      return page.items;
+    };
+    const probe = probeRoots(candidates);
+    if (probe.status !== "listable") {
+      // Every branch already yields zero items for a root that cannot be read,
+      // so listing it would only cost time and add no sessions.
+      const outcome = scanOutcome(source, probe.root, probe.status, 0, probe.detail);
+      outcomes.push(outcome);
+      finishDiscovery(outcome);
+      continue;
+    }
+    const root = probe.root;
+
+    if (source === "cursor" || source === "opencode" || source === "grok" || source === "kimi") {
+      const collected: ParentageDiagnostic[] = [];
+      const nativeOptions = {
+        limit: limitPerSource,
+        ...(options.discovery ? { select: selectInventory } : {}),
+        onDiagnostic: (diagnostic: ParentageDiagnostic) => {
+          collected.push(diagnostic);
+          options.onDiagnostic?.(diagnostic);
+        },
+      };
+      let items: DiscoveredSession[] = [];
+      let failure: string | null = null;
+      try {
+        const paths = candidates.map((candidate) => candidate.path);
+        items = source === "cursor"
+          ? discoverCursorSessions(paths, nativeOptions)
+          : source === "grok"
+            ? discoverGrokSessions(paths, nativeOptions)
+            : source === "kimi"
+              ? discoverKimiSessions(paths, nativeOptions)
+              : discoverOpenCodeSessions(paths, nativeOptions);
+      } catch (error) {
+        failure = failureDetail(error);
+      }
+      sessions.push(...items);
+      // The native scanners already report unreadable stores and partial
+      // evidence through diagnostics; the outcome is what a caller can act on.
+      // A diagnostic that still produced sessions is partial evidence, not a
+      // failed listing: the detail carries it and the count stays real.
+      const diagnostic = collected.find((entry) => entry.code === "read_error" || entry.code === "incomplete_evidence");
+      const failedListing = failure !== null || (diagnostic !== undefined && items.length === 0);
+      outcomes.push(scanOutcome(
+        source,
+        root,
+        failedListing ? "listing_failed" : "listable",
+        items.length,
+        failure ?? (diagnostic ? capScanDetail(diagnostic.message) : null),
+      ));
+      finishDiscovery(outcomes.at(-1)!);
+      continue;
+    }
+
+    if (DEFAULT_SOURCES.includes(source)) {
+      const before = sessions.length;
+      let failure: string | null = null;
+      try {
+        if (options.discovery && source !== "omp") {
+          const cursor = previous?.cursor?.startsWith("u:") ? previous.cursor.slice(2) : undefined;
+          const headBudget = discoveryHeadBudget(limitPerSource, previous?.cursor ?? null);
+          const head = headBudget ? await listTrajectories({
+            source: source as AnyTrajectorySource, root: roots[source], limit: headBudget,
+          }) : { items: [] };
+          const historical: DiscoveredSession[] = [];
+          let resume = cursor;
+          do {
+            const page = await listTrajectories({ source: source as AnyTrajectorySource,
+              root: roots[source], limit: Math.min(1000, limitPerSource - headBudget - historical.length),
+              ...(resume ? { cursor: resume } : {}) });
+            if (page.nextCursor && page.nextCursor === resume) throw new Error("Discovery cursor did not advance");
+            historical.push(...page.items.map(item => ({ ...item, source })));
+            resume = page.nextCursor;
+          } while (resume && historical.length < limitPerSource - headBudget);
+          nextCursor = resume ? `u:${resume}` : null;
+          sessions.push(...uniqueDiscovered([...head.items.map(item => ({ ...item, source })), ...historical]));
+        } else {
+          let res = await listTrajectories({
+            source: source as AnyTrajectorySource,
+            root: roots[source],
+            limit: source === "omp" ? 1000 : Math.min(1000, limitPerSource),
+          });
+
+          // A recent child can belong to an old parent outside the requested page.
+          const items = [...res.items];
+          while (res.nextCursor && (source === "omp" || items.length < limitPerSource)) {
+            res = await listTrajectories({
+              source: source as AnyTrajectorySource,
+              root: roots[source],
+              limit: source === "omp" ? 1000 : Math.min(1000, limitPerSource - items.length),
+              cursor: res.nextCursor,
+            });
+            items.push(...res.items);
+          }
+
+          const listed: DiscoveredSession[] = items.map((item) => ({
+            id: item.id,
+            source,
+            path: item.path,
+            updatedAt: item.updatedAt,
+            title: item.title,
+            sizeBytes: item.sizeBytes,
+          }));
+          if (source === "omp") {
+            const candidates = [...listed, ...discoverOmpNestedSubagents(listed, options)].sort(newestFirst);
+            let count = 0;
+            const proved: DiscoveredSession[] = [];
+            for (const candidate of candidates) {
+              if (!options.discovery && count >= limitPerSource) break;
+              const id = candidate.id ?? readPiSessionIdFromFile(candidate.path, options);
+              if (!id) continue;
+              proved.push({ ...candidate, id });
+              count++;
+            }
+            sessions.push(...(options.discovery ? selectInventory(proved) : proved));
+          } else {
+            sessions.push(...listed);
+          }
+        }
+      } catch (error) {
+        // Nested OMP walk failures keep their diagnostics; only a primary
+        // listing failure is the source's outcome.
+        failure = failureDetail(error);
+      }
+      outcomes.push(scanOutcome(
+        source,
+        root,
+        failure ? "listing_failed" : "listable",
+        sessions.length - before,
+        failure,
+      ));
+      finishDiscovery(outcomes.at(-1)!);
+      continue;
+    }
+
+    // Custom or extra directory scanner
+    const byPath = new Map<string, DiscoveredSession>();
+    let failure: string | null = null;
+    let rootFailure = false;
+    for (const candidateRoot of candidates) {
+      if (!existsSync(candidateRoot.path)) continue;
+      const scanned = scanDirectoryForSessions(source, candidateRoot.path, 3);
+      if (failure === null && scanned.error !== null) {
+        failure = scanned.error;
+        // Only the primary location failing outright is an unreadable root: a
+        // failure inside the tree, or under a secondary location, is a partial
+        // listing and keeps the sessions that were read.
+        rootFailure = scanned.rootFailure && candidateRoot.path === candidates[0].path;
+      }
+      for (const item of scanned.items) {
+        byPath.set(item.path, item);
+      }
+    }
+
+    // Extra sources are directory scans rather than trajectory-library
+    // listings. Apply the same per-source limit and deterministic ordering
+    // here so duplicate roots cannot bypass the requested candidate limit.
+    const inventory = [...byPath.values()].sort(newestFirst);
+    const bounded = options.discovery ? selectInventory(inventory) : inventory.slice(0, limitPerSource);
+    sessions.push(...bounded);
+    outcomes.push(scanOutcome(
+      source,
+      root,
+      failure === null || bounded.length > 0
+        ? "listable"
+        : rootFailure ? "unreadable_root" : "listing_failed",
+      bounded.length,
+      failure,
+    ));
+    finishDiscovery(outcomes.at(-1)!);
+  }
+
+  outcomes.sort((a, b) => (a.source < b.source ? -1 : a.source > b.source ? 1 : 0));
+  return { sessions, outcomes, ...(options.discovery ? { discovery } : {}) };
+}
+
+type OmpCandidate = Omit<DiscoveredSession, "id"> & { id?: string };
+
+function newestFirst(a: OmpCandidate, b: OmpCandidate): number {
+  return (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "") || a.path.localeCompare(b.path);
+}
+
+function discoverOmpNestedSubagents(parents: DiscoveredSession[], options: SessionScanOptions): OmpCandidate[] {
+  const extras: OmpCandidate[] = [];
+  const seen = new Set(parents.map((item) => item.path));
+  for (const parent of parents) {
+    if (!parent.path.endsWith(".jsonl")) continue;
+    const nestedDir = parent.path.slice(0, -".jsonl".length);
+    if (!existsSync(nestedDir)) continue;
+    let entries: string[];
+    try {
+      entries = readdirSync(nestedDir);
+    } catch {
+      options.onDiagnostic?.({ code: "read_error", sourcePath: nestedDir, message: "Could not list OMP child transcripts." });
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".jsonl")) continue;
+      const path = join(nestedDir, entry);
+      if (seen.has(path)) continue;
+      try {
+        const stat = statSync(path);
+        if (!stat.isFile()) continue;
+        seen.add(path);
+        extras.push({
+          source: "omp",
+          path,
+          updatedAt: stat.mtime.toISOString(),
+          sizeBytes: stat.size,
+        });
+      } catch {
+        options.onDiagnostic?.({ code: "read_error", sourcePath: path, message: "Could not inspect OMP child transcript." });
+        continue;
+      }
+    }
+  }
+  return extras;
+}
+
+interface DirectoryScan {
+  items: DiscoveredSession[];
+  /** First non-ENOENT filesystem failure met during the walk, as a short content-free detail. */
+  error: string | null;
+  /** True when that failure happened on the scanned root itself rather than inside it. */
+  rootFailure: boolean;
+}
+
+function safeDirectorySessionId(value: string): boolean {
+  return value.length > 0 && value.length <= 255 && value !== "." && value !== ".." && !/[\x00-\x1f/\\]/.test(value);
+}
+
+function genericJsonSidecar(base: string): boolean {
+  return ["meta.json", "package.json", "tsconfig.json", "manifest.json", "config.json", "settings.json", "compaction.json"]
+    .includes(base) || /\.(?:manifest|config|settings|compaction)\.json$/.test(base);
+}
+
+function scanDirectoryForSessions(
+  source: string,
+  dirPath: string,
+  maxDepth: number = 3,
+): DirectoryScan {
+  const items: DiscoveredSession[] = [];
+  let error: string | null = null;
+  let rootFailure = false;
+
+  function walk(current: string, depth: number) {
+    if (depth > maxDepth || !existsSync(current)) return;
+    try {
+      const stat = statSync(current);
+      if (stat.isFile()) {
+        const ext = extname(current).toLowerCase();
+        const base = basename(current).toLowerCase();
+        const nativeBase = basename(current);
+        const parent = basename(dirname(current));
+        if (source === "cline") {
+          const suffix = ".messages.json";
+          const id = nativeBase.endsWith(suffix) ? nativeBase.slice(0, -suffix.length) : "";
+          if (safeDirectorySessionId(id) && parent === id) {
+            items.push({ id, source, path: current, updatedAt: stat.mtime.toISOString(), sizeBytes: stat.size });
+          }
+          return;
+        }
+        if (source === "fx") {
+          if (nativeBase === "session.json" && safeDirectorySessionId(parent)) {
+            items.push({ id: parent, source, path: current, updatedAt: stat.mtime.toISOString(), sizeBytes: stat.size, native: { kind: "fx-directory" } });
+          }
+          return;
+        }
+        const isJsonlSession =
+          (source === "cursor" || source === "copilot-cli") && ext === ".jsonl";
+        const isOtherSessionFile =
+          source !== "cursor" &&
+          source !== "copilot-cli" &&
+          ext === ".json" &&
+          !genericJsonSidecar(base);
+        if (isJsonlSession || isOtherSessionFile) {
+          items.push({
+            id: basename(current, ext),
+            source,
+            path: current,
+            updatedAt: stat.mtime.toISOString(),
+            sizeBytes: stat.size,
+          });
+        }
+        return;
+      }
+
+      if (stat.isDirectory()) {
+        const entries = readdirSync(current);
+        for (const entry of entries) {
+          walk(join(current, entry), depth + 1);
+        }
+      }
+    } catch (caught) {
+      // A vanished entry is normal between listing and stat; anything else
+      // (permissions, I/O) is the source's outcome, not a silent skip.
+      if (error === null && errnoCode(caught) !== "ENOENT") {
+        error = failureDetail(caught);
+        rootFailure = depth === 0;
+      }
+    }
+  }
+
+  walk(dirPath, 0);
+  return { items, error, rootFailure };
+}