codesesh 0.17.0 → 0.19.0

package/dist/{chunk-7APNDHQ6.js → chunk-G2BTNW3C.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../core/dist/chunk-BOTICQC6.mjs
+// ../core/dist/chunk-B67H5WZJ.mjs
 function toRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -120,6 +120,76 @@ function normalizeMessageParts(value) {
     return normalized ? [normalized] : [];
   });
 }
+function mergeSessionsUpdatedEvents(previous, next) {
+  const changedSessionHeads = /* @__PURE__ */ new Map();
+  const removedSessionRefs = /* @__PURE__ */ new Map();
+  const sessionKey2 = (agentName, sessionId) => `${agentName}\0${sessionId}`;
+  const addChanged = (item) => {
+    const key = sessionKey2(item.reference.agentName, item.reference.sessionId);
+    removedSessionRefs.delete(key);
+    changedSessionHeads.set(key, item);
+  };
+  const addRemoved = (item) => {
+    const key = sessionKey2(item.agentName, item.sessionId);
+    changedSessionHeads.delete(key);
+    removedSessionRefs.set(key, item);
+  };
+  for (const item of previous.changedSessionHeads) addChanged(item);
+  for (const item of previous.removedSessionRefs) addRemoved(item);
+  for (const item of next.changedSessionHeads) addChanged(item);
+  for (const item of next.removedSessionRefs) addRemoved(item);
+  return {
+    type: "sessions-updated",
+    changedAgents: Array.from(/* @__PURE__ */ new Set([...previous.changedAgents, ...next.changedAgents])),
+    newSessions: previous.newSessions + next.newSessions,
+    updatedSessions: previous.updatedSessions + next.updatedSessions,
+    removedSessions: previous.removedSessions + next.removedSessions,
+    totalSessions: next.totalSessions,
+    timestamp: next.timestamp,
+    changedSessionHeads: [...changedSessionHeads.values()],
+    removedSessionRefs: [...removedSessionRefs.values()]
+  };
+}
+function startOfCalendarDay(timestamp) {
+  const date = new Date(timestamp);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function addCalendarDays(timestamp, days) {
+  const date = new Date(timestamp);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days).getTime();
+}
+function toCalendarDayNumber(timestamp) {
+  const date = new Date(timestamp);
+  return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) / 864e5;
+}
+function countCalendarDays(from, to) {
+  return Math.max(1, toCalendarDayNumber(to) - toCalendarDayNumber(from) + 1);
+}
+function toCalendarDayKey(timestamp) {
+  const date = new Date(timestamp);
+  return `${String(date.getFullYear()).padStart(4, "0")}-${String(date.getMonth() + 1).padStart(
+    2,
+    "0"
+  )}-${String(date.getDate()).padStart(2, "0")}`;
+}
+var PROJECT_IDENTITY_KINDS = [
+  "git_remote",
+  "git_common_dir",
+  "manifest_path",
+  "synthetic",
+  "path",
+  "loose"
+];
+var KIND_LOOKUP = new Set(PROJECT_IDENTITY_KINDS);
+function isProjectIdentityKind(value) {
+  return KIND_LOOKUP.has(value);
+}
+function getProjectIdentityKey(identity) {
+  return `${identity.kind}:${identity.key}`;
+}
+function matchesProjectIdentity(identity, expected) {
+  return identity?.kind === expected.kind && identity.key === expected.key;
+}
 var UNKNOWN_AGENT_NAME = "unknown";
 function normalizeSessionReference(reference) {
   return {
@@ -144,6 +214,13 @@ function formatSessionReference(reference) {
 function getSessionAgentKey(session) {
   return parseSessionReference(session.slug)?.agentName ?? UNKNOWN_AGENT_NAME;
 }
+function agentRoutePath(agentName) {
+  return `/${encodeURIComponent(agentName.trim().toLowerCase())}`;
+}
+function sessionRoutePath(reference) {
+  const normalized = normalizeSessionReference(reference);
+  return `${agentRoutePath(normalized.agentName)}/${encodeURIComponent(normalized.sessionId)}`;
+}
 function compareSessionActivityDesc(a, b) {
   return (b.time_updated ?? b.time_created) - (a.time_updated ?? a.time_created);
 }
@@ -176,6 +253,44 @@ function mergeSortedSessions(shards) {
   }
   return merged;
 }
+function referenceKey(reference) {
+  return `${reference.agentName.trim().toLowerCase()}\0${reference.sessionId}`;
+}
+function sessionKey(session) {
+  return `${getSessionAgentKey(session)}\0${session.id}`;
+}
+function hasActivityInWindow(session, from, to) {
+  const activity = session.time_updated ?? session.time_created;
+  return (from == null || activity >= from) && (to == null || activity <= to);
+}
+function isChildSession(session) {
+  return session.parent_reference != null;
+}
+function getRootSessions(sessions) {
+  return sessions.filter((session) => !session.parent_reference);
+}
+function filterSessionTreeByActivityWindow(sessions, from, to) {
+  if (from == null && to == null) return sessions;
+  const available = new Set(sessions.map(sessionKey));
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const parent = session.parent_reference;
+    if (!parent || !available.has(referenceKey(parent))) continue;
+    const parentKey = referenceKey(parent);
+    const children = childrenByParent.get(parentKey);
+    if (children) children.push(sessionKey(session));
+    else childrenByParent.set(parentKey, [sessionKey(session)]);
+  }
+  const visible = /* @__PURE__ */ new Set();
+  const pending2 = getRootSessions(sessions).filter((session) => hasActivityInWindow(session, from, to)).map(sessionKey);
+  while (pending2.length > 0) {
+    const key = pending2.pop();
+    if (visible.has(key)) continue;
+    visible.add(key);
+    for (const childKey of childrenByParent.get(key) ?? []) pending2.push(childKey);
+  }
+  return sessions.filter((session) => visible.has(sessionKey(session)));
+}
 var SAMPLE_SESSION_HEAD = {
   id: "session-1",
   slug: "claudecode/session-1",
@@ -253,8 +368,8 @@ var SAMPLE_DASHBOARD_DATA = {
 };
 
 // ../core/dist/index.mjs
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import { join as join4, basename as basename2, dirname } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
+import { join as join5, basename as basename3, dirname as dirname2 } from "path";
 import { existsSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 import { existsSync as existsSync2 } from "fs";
@@ -263,38 +378,50 @@ import { join as join2 } from "path";
 import { closeSync, openSync, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { basename } from "path";
-import { existsSync as existsSync3, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync4, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-import { join as join6 } from "path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { basename as basename3, dirname as dirname2, join as join5 } from "path";
+import { join as join4 } from "path";
+import { chmodSync, existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { basename as basename2, dirname, join as join3 } from "path";
+import { join as join7 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { basename as basename4, dirname as dirname3, join as join6 } from "path";
 import { createRequire } from "module";
 import { createHash } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { join as join7, basename as basename4, dirname as dirname3 } from "path";
-import { closeSync as closeSync2, existsSync as existsSync7, openSync as openSync2, readFileSync as readFileSync4, readSync as readSync2, statSync as statSync4 } from "fs";
-import { join as join8, basename as basename5 } from "path";
-import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync3, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { join as join8, basename as basename5, dirname as dirname4 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync4, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { basename as basename6, dirname as dirname5, join as join9, resolve } from "path";
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync9,
+  openSync as openSync2,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync5,
+  readSync as readSync2,
+  statSync as statSync6
+} from "fs";
+import { join as join10, basename as basename7 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync6, statSync as statSync7 } from "fs";
 import { homedir as homedir3, platform as platform2 } from "os";
-import { join as join9, normalize } from "path";
-import { existsSync as existsSync9 } from "fs";
-import { basename as basename6, join as join10 } from "path";
+import { join as join11, normalize } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { basename as basename8, join as join12 } from "path";
 import { homedir as homedir4, platform as platform3 } from "os";
-import { join as join11 } from "path";
+import { join as join13 } from "path";
 import { availableParallelism } from "os";
 import { Worker } from "worker_threads";
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
 import { spawnSync } from "child_process";
 import * as os from "os";
 import * as path from "path";
-import { resolve, sep } from "path";
-import { existsSync as existsSync12, rmSync, unlinkSync } from "fs";
-import { existsSync as existsSync11 } from "fs";
-import { join as join12 } from "path";
+import { resolve as resolve2, sep } from "path";
+import { existsSync as existsSync14, rmSync as rmSync2, unlinkSync } from "fs";
+import { existsSync as existsSync13 } from "fs";
+import { join as join14 } from "path";
 import { homedir as homedir6 } from "os";
 import { homedir as homedir7, platform as platform4 } from "os";
-import { join as join13 } from "path";
+import { join as join15 } from "path";
 var registrations = [];
 function registerAgent(reg) {
   registrations.push(reg);
@@ -389,6 +516,9 @@ function diffSessionSources(refs, cachedSessions, cachedMeta, options) {
   return { changedIds, removedIds };
 }
 var BaseAgent = class {
+  filterCachedSessions(sessions) {
+    return sessions;
+  }
   getUri(sessionId) {
     return `${this.name}://${sessionId}`;
   }
@@ -396,6 +526,14 @@ var BaseAgent = class {
 var FileSystemSessionSource = class extends BaseAgent {
   sessionMetaMap = /* @__PURE__ */ new Map();
   sourceFileStats = /* @__PURE__ */ new Map();
+  /**
+   * 变更集合扩展：当某些会话变更会影响其他会话的派生数据时
+   * （如 subagent 文件变更需要父会话重新聚合 token 统计），
+   * 子类返回需要一并重解析的会话 ID 集合。默认无关联，原样返回。
+   */
+  expandChangedSessionIds(changedIds, _refs) {
+    return changedIds;
+  }
   scan(options) {
     const sources = this.listSessionSources(options);
     const sessions = [];
@@ -493,10 +631,11 @@ var FileSystemSessionSource = class extends BaseAgent {
    * refs 未传时回退为自行枚举，供独立调用方（如测试）沿用旧行为。
    */
   incrementalScan(cachedSessions, changedIds, refs) {
+    const sources = refs ?? this.listSessionSources();
     const sessionMap = new Map(cachedSessions.map((session) => [session.id, session]));
-    const changedSet = new Set(changedIds);
+    const changedSet = new Set(this.expandChangedSessionIds(changedIds, sources));
     const currentIds = /* @__PURE__ */ new Set();
-    for (const ref of refs ?? this.listSessionSources()) {
+    for (const ref of sources) {
       currentIds.add(ref.sessionId);
       if (!changedSet.has(ref.sessionId)) continue;
       const head = this.scanSessionSource(ref.sourcePath);
@@ -547,8 +686,41 @@ var SingleFileSessionSource = class extends FileSystemSessionSource {
     };
   }
 };
+var SessionScanError = class extends Error {
+  constructor(agentName, stage, options) {
+    super(`${agentName} session scan failed while ${stage}`, options);
+    this.agentName = agentName;
+    this.stage = stage;
+    this.name = "SessionScanError";
+  }
+  agentName;
+  stage;
+};
+function sqliteSourceFiles(dbPath) {
+  return [dbPath, `${dbPath}-wal`];
+}
+function statOrNull(path2) {
+  try {
+    return statSync(path2);
+  } catch {
+    return null;
+  }
+}
+function sqliteSourceFingerprint(dbPath) {
+  return sqliteSourceFiles(dbPath).map((path2) => {
+    const stats = statOrNull(path2);
+    return stats ? `${stats.size}:${Math.round(stats.mtimeMs)}` : "-";
+  }).join("|");
+}
+function latestSqliteSourceMtime(dbPath) {
+  return sqliteSourceFiles(dbPath).reduce((latest, path2) => {
+    const stats = statOrNull(path2);
+    return stats && stats.mtimeMs > latest ? stats.mtimeMs : latest;
+  }, 0);
+}
 var DatabaseSessionSource = class extends BaseAgent {
   sessionMetaMap = /* @__PURE__ */ new Map();
+  lastSourceFingerprint = null;
   /** 记录单个会话的缓存 meta（sourcePath = dbPath）。 */
   rememberSession(sessionId) {
     const dbPath = this.getDatabasePath();
@@ -562,7 +734,12 @@ var DatabaseSessionSource = class extends BaseAgent {
     this.sessionMetaMap = meta;
   }
   /**
-   * 变更检测：数据库内部变更难以按行定位，按库文件 mtime 判定。
+   * 变更检测：数据库内部变更难以按行定位，按库文件集合的指纹判定。
+   *
+   * In WAL mode a commit appends to the sidecar and leaves the main file
+   * untouched until checkpoint, so watching the database alone misses recent
+   * writes entirely. Size is part of the fingerprint because an uncheckpointed
+   * commit may land in the same millisecond as the previous one.
    */
   checkForChanges(sinceTimestamp, _cachedSessions) {
     const dbPath = this.getDatabasePath();
@@ -570,7 +747,10 @@ var DatabaseSessionSource = class extends BaseAgent {
       return { hasChanges: false, timestamp: Date.now() };
     }
     try {
-      const hasChanges = statSync(dbPath).mtimeMs > sinceTimestamp;
+      const fingerprint = sqliteSourceFingerprint(dbPath);
+      const previous = this.lastSourceFingerprint;
+      this.lastSourceFingerprint = fingerprint;
+      const hasChanges = previous == null ? latestSqliteSourceMtime(dbPath) > sinceTimestamp : fingerprint !== previous;
       return {
         hasChanges,
         timestamp: Date.now()
@@ -630,17 +810,17 @@ function* readJsonlFileLines(filePath, chunkBytes = READ_CHUNK_BYTES) {
   try {
     const buffer = Buffer.alloc(chunkBytes);
     const decoder = new StringDecoder("utf8");
-    let pending = [];
+    let pending2 = [];
     let bytesRead = readSync(fd, buffer, 0, chunkBytes, -1);
     while (bytesRead > 0) {
       const decoded = decoder.write(buffer.subarray(0, bytesRead));
       const lastBreak = decoded.lastIndexOf("\n");
       if (lastBreak === -1) {
-        if (decoded) pending.push(decoded);
+        if (decoded) pending2.push(decoded);
       } else {
-        pending.push(decoded.slice(0, lastBreak));
-        const complete = pending.join("");
-        pending = [decoded.slice(lastBreak + 1)];
+        pending2.push(decoded.slice(0, lastBreak));
+        const complete = pending2.join("");
+        pending2 = [decoded.slice(lastBreak + 1)];
         for (const line of complete.split("\n")) {
           const trimmed = line.trim();
           if (trimmed) yield trimmed;
@@ -648,8 +828,8 @@ function* readJsonlFileLines(filePath, chunkBytes = READ_CHUNK_BYTES) {
       }
       bytesRead = readSync(fd, buffer, 0, chunkBytes, -1);
     }
-    pending.push(decoder.end());
-    const tail = pending.join("").trim();
+    pending2.push(decoder.end());
+    const tail = pending2.join("").trim();
     if (tail) yield tail;
   } finally {
     closeSync(fd);
@@ -833,6 +1013,56 @@ var aliases_default = {
   "gpt-5.1-codex-high": "gpt-5.3-codex",
   "gpt-5.2-low": "gpt-5.2"
 };
+var PRIVATE_DIR_MODE = 448;
+var PRIVATE_FILE_MODE = 384;
+var SQLITE_SIDECAR_SUFFIXES = ["-wal", "-shm", "-journal"];
+var isPosix = process.platform !== "win32";
+function reportChmodFailure(path2, error) {
+  getCoreDiagnostics()?.warn("storage.permissions_failed", {
+    path: path2,
+    message: error instanceof Error ? error.message : String(error)
+  });
+}
+function restrict(path2, mode) {
+  if (!isPosix || !existsSync3(path2)) return;
+  try {
+    if ((statSync2(path2).mode & 511) === mode) return;
+    chmodSync(path2, mode);
+  } catch (error) {
+    reportChmodFailure(path2, error);
+  }
+}
+function ensurePrivateDirectory(path2) {
+  mkdirSync(path2, { recursive: true, mode: PRIVATE_DIR_MODE });
+  restrict(path2, PRIVATE_DIR_MODE);
+}
+function restrictPrivateFile(path2) {
+  restrict(path2, PRIVATE_FILE_MODE);
+}
+function restrictExistingPrivateFiles(directory, owns) {
+  try {
+    for (const entry of readdirSync2(directory)) {
+      if (owns(entry)) restrictPrivateFile(join3(directory, entry));
+    }
+  } catch (error) {
+    reportChmodFailure(directory, error);
+  }
+}
+var sweptBackupsFor = /* @__PURE__ */ new Set();
+function restrictExistingBackups(dbPath) {
+  if (sweptBackupsFor.has(dbPath)) return;
+  sweptBackupsFor.add(dbPath);
+  const prefix = `${basename2(dbPath)}.`;
+  restrictExistingPrivateFiles(
+    dirname(dbPath),
+    (name) => name.startsWith(prefix) && name.endsWith(".bak")
+  );
+}
+function restrictPrivateDatabase(dbPath) {
+  restrictPrivateFile(dbPath);
+  for (const suffix of SQLITE_SIDECAR_SUFFIXES) restrictPrivateFile(`${dbPath}${suffix}`);
+  restrictExistingBackups(dbPath);
+}
 var snapshot_default = {
   "claude-3-5-haiku": [8e-7, 4e-6, 1e-6, 8e-8],
   "claude-3-5-sonnet": [3e-6, 15e-6, 375e-8, 3e-7],
@@ -879,7 +1109,9 @@ var snapshot_default = {
 var LITELLM_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var WEB_SEARCH_COST = 0.01;
-var pricingCache = loadSnapshot();
+var REFRESH_TIMEOUT_MS = 1e4;
+var published = { id: 1, pricing: loadSnapshot() };
+var pending = null;
 loadDiskCache();
 function normalizeKey(key) {
   return key.trim().toLowerCase();
@@ -888,10 +1120,10 @@ function costNumber(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 function getCacheDir() {
-  return join3(homedir2(), ".cache", "codesesh");
+  return join4(homedir2(), ".cache", "codesesh");
 }
 function getCachePath() {
-  return join3(getCacheDir(), "litellm-pricing.json");
+  return join4(getCacheDir(), "litellm-pricing.json");
 }
 function loadSnapshot() {
   const map = /* @__PURE__ */ new Map();
@@ -957,7 +1189,7 @@ function parseLiteLLMData(data) {
 }
 function loadDiskCache() {
   const path2 = getCachePath();
-  if (!existsSync3(path2)) return;
+  if (!existsSync4(path2)) return;
   try {
     const cached = JSON.parse(readFileSync(path2, "utf-8"));
     if (Date.now() - cached.timestamp <= CACHE_TTL_MS) {
@@ -967,20 +1199,51 @@ function loadDiskCache() {
         if (!pricing) continue;
         next.set(normalizeKey(name), pricing);
       }
-      pricingCache = next;
+      published = { id: published.id + 1, pricing: next };
     }
   } catch {
   }
 }
 function getPricingRegistry() {
-  return pricingCache;
+  return published.pricing;
+}
+function getPricingGeneration() {
+  return published;
+}
+function publishPendingPricing() {
+  if (!pending) return false;
+  published = { id: published.id + 1, pricing: pending };
+  pending = null;
+  getCoreDiagnostics()?.info?.("pricing.generation.published", {
+    generation: published.id,
+    models: published.pricing.size
+  });
+  return true;
+}
+function hasPendingPricing() {
+  return pending !== null;
 }
 function hasBillablePricing(pricing) {
   return pricing.inputCostPerToken > 0 || pricing.outputCostPerToken > 0 || pricing.cacheReadCostPerToken > 0 || pricing.cacheCreateCostPerToken > 0;
 }
-async function refreshPricingCache() {
+function writeDiskCacheAtomically(path2, pricing) {
+  const temporaryPath = `${path2}.${process.pid}.tmp`;
+  const payload = JSON.stringify({ timestamp: Date.now(), data: Object.fromEntries(pricing) });
+  try {
+    ensurePrivateDirectory(getCacheDir());
+    writeFileSync(temporaryPath, payload);
+    restrictPrivateFile(temporaryPath);
+    renameSync(temporaryPath, path2);
+  } catch (error) {
+    rmSync(temporaryPath, { force: true });
+    getCoreDiagnostics()?.warn("pricing.cache_write_failed", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function refreshPricingCache(options = {}) {
   const path2 = getCachePath();
-  if (existsSync3(path2)) {
+  if (existsSync4(path2)) {
     try {
       const cached = JSON.parse(readFileSync(path2, "utf-8"));
       if (typeof cached.timestamp === "number" && Date.now() - cached.timestamp <= CACHE_TTL_MS) {
@@ -989,8 +1252,11 @@ async function refreshPricingCache() {
     } catch {
     }
   }
+  const timeout = AbortSignal.timeout(options.timeoutMs ?? REFRESH_TIMEOUT_MS);
+  const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+  getCoreDiagnostics()?.info?.("pricing.refresh.started", { generation: published.id });
   try {
-    const response = await fetch(LITELLM_URL);
+    const response = await fetch(LITELLM_URL, { signal });
     if (!response.ok) return false;
     const data = await response.json();
     const remote = parseLiteLLMData(data);
@@ -999,11 +1265,19 @@ async function refreshPricingCache() {
     for (const [name, pricing] of remote.entries()) {
       next.set(name, pricing);
     }
-    pricingCache = next;
-    mkdirSync(getCacheDir(), { recursive: true });
-    writeFileSync(path2, JSON.stringify({ timestamp: Date.now(), data: Object.fromEntries(next) }));
+    pending = next;
+    writeDiskCacheAtomically(path2, next);
+    getCoreDiagnostics()?.info?.("pricing.refresh.completed", {
+      generation: published.id,
+      models: next.size
+    });
     return true;
-  } catch {
+  } catch (error) {
+    getCoreDiagnostics()?.warn("pricing.refresh.failed", {
+      generation: published.id,
+      aborted: signal.aborted,
+      message: error instanceof Error ? error.message : String(error)
+    });
     return false;
   }
 }
@@ -1313,7 +1587,7 @@ var TranscriptBuilder = class {
     };
   }
 };
-var HEAD_INDEX_VERSION = "claudecode-head-v2";
+var HEAD_INDEX_VERSION = "claudecode-head-v4";
 function resolveClaudeCodeDataRoot() {
   return resolveHomePath("CLAUDE_CONFIG_DIR", ".claude");
 }
@@ -1369,23 +1643,27 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   sessionsIndexCache = {};
   sessionsIndexMtime = {};
+  childContextsBySource = /* @__PURE__ */ new Map();
+  childContextCache = /* @__PURE__ */ new Map();
+  childSessionIdByToolUseId = /* @__PURE__ */ new Map();
+  childIndexReady = false;
   findBasePath() {
-    return firstExisting(join4(resolveClaudeCodeDataRoot(), "projects"), "data/claudecode");
+    return firstExisting(join5(resolveClaudeCodeDataRoot(), "projects"), "data/claudecode");
   }
   getSessionWatchPlan() {
     const dataRoot = resolveClaudeCodeDataRoot();
     return {
       status: "supported",
-      targets: [{ root: dataRoot, path: join4(dataRoot, "projects") }, { path: "data/claudecode" }]
+      targets: [{ root: dataRoot, path: join5(dataRoot, "projects") }, { path: "data/claudecode" }]
     };
   }
   isAvailable() {
     this.basePath = this.findBasePath();
     if (!this.basePath) return false;
     try {
-      for (const entry of readdirSync2(this.basePath)) {
-        const dir = join4(this.basePath, entry);
-        if (existsSync4(dir) && readdirSync2(dir).some((f) => f.endsWith(".jsonl"))) {
+      for (const entry of readdirSync3(this.basePath)) {
+        const dir = join5(this.basePath, entry);
+        if (existsSync5(dir) && readdirSync3(dir).some((f) => f.endsWith(".jsonl"))) {
           return true;
         }
       }
@@ -1401,33 +1679,119 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
       const indexPath = this.getSessionsIndexPath(projectDir);
       indexMtimes.set(projectDir, this.readFileMtimeMs(indexPath));
     }
-    return this.walkFiles(projectDirs, (entry) => entry.name.endsWith(".jsonl"), {
-      recursive: false,
-      scanWindow: options
-    }).map(({ file, stat }) => ({
-      sessionId: basename2(file, ".jsonl"),
-      sourcePath: file,
-      fingerprint: this.sourceFingerprint(stat, indexMtimes.get(dirname(file)) ?? null)
-    }));
+    const projectDirSet = new Set(projectDirs);
+    const allSources = this.walkFiles(projectDirs, (entry) => entry.name.endsWith(".jsonl"), {
+      recursive: true
+    });
+    this.indexChildContexts(allSources, projectDirs);
+    const indexedSources = allSources.flatMap((source) => {
+      const child = this.childContextsBySource.get(source.file);
+      if (!child && !projectDirSet.has(dirname2(source.file))) return [];
+      return [
+        {
+          source,
+          sessionId: child?.sessionId ?? basename3(source.file, ".jsonl"),
+          child
+        }
+      ];
+    });
+    let selectedSources = indexedSources.filter(
+      ({ source }) => matchesScanWindow(source.stat.mtimeMs, options)
+    );
+    if (options?.from != null || options?.to != null) {
+      const childrenByParent = /* @__PURE__ */ new Map();
+      for (const indexed of indexedSources) {
+        const parentId = indexed.child?.parentSessionId;
+        if (!parentId) continue;
+        const children = childrenByParent.get(parentId);
+        if (children) children.push(indexed);
+        else childrenByParent.set(parentId, [indexed]);
+      }
+      const windowSelectedById = new Map(
+        selectedSources.map((indexed) => [indexed.sessionId, indexed])
+      );
+      const connectedSelected = /* @__PURE__ */ new Map();
+      const acceptedIds = /* @__PURE__ */ new Set();
+      const visitingIds = /* @__PURE__ */ new Set();
+      const hasSelectedParent = (sessionId) => {
+        if (acceptedIds.has(sessionId)) return true;
+        if (visitingIds.has(sessionId)) return false;
+        const indexed = windowSelectedById.get(sessionId);
+        if (!indexed) return false;
+        const parentId = indexed.child?.parentSessionId;
+        if (!parentId) {
+          acceptedIds.add(sessionId);
+          return true;
+        }
+        visitingIds.add(sessionId);
+        const connected = hasSelectedParent(parentId);
+        visitingIds.delete(sessionId);
+        if (connected) acceptedIds.add(sessionId);
+        return connected;
+      };
+      for (const indexed of selectedSources) {
+        if (hasSelectedParent(indexed.sessionId)) {
+          connectedSelected.set(indexed.sessionId, indexed);
+        }
+      }
+      if (options?.includeRelatedSessions !== false) {
+        const pending2 = [...connectedSelected.values()].filter(({ child }) => !child?.parentSessionId).map(({ sessionId }) => sessionId);
+        while (pending2.length > 0) {
+          const parentId = pending2.pop();
+          for (const child of childrenByParent.get(parentId) ?? []) {
+            if (connectedSelected.has(child.sessionId)) continue;
+            connectedSelected.set(child.sessionId, child);
+            pending2.push(child.sessionId);
+          }
+        }
+      }
+      selectedSources = [...connectedSelected.values()];
+    }
+    return selectedSources.map(({ source: { file, stat }, sessionId, child }) => {
+      const projectDir = child?.projectDir ?? dirname2(file);
+      return {
+        sessionId,
+        sourcePath: file,
+        fingerprint: this.sourceFingerprint(
+          stat,
+          indexMtimes.get(projectDir) ?? null,
+          child?.metaMtimeMs
+        )
+      };
+    });
+  }
+  setSessionMetaMap(meta) {
+    super.setSessionMetaMap(meta);
+    this.childContextsBySource.clear();
+    this.childSessionIdByToolUseId.clear();
+    this.childIndexReady = false;
   }
   parseFileSessionHead(sourcePath) {
-    const projectDir = dirname(sourcePath);
-    return getParsedSession(this.parseSessionHeadResult(sourcePath, projectDir));
+    const child = this.getChildContext(sourcePath);
+    const projectDir = child?.projectDir ?? dirname2(sourcePath);
+    return getParsedSession(this.parseSessionHeadResult(sourcePath, projectDir, child));
   }
   getSessionData(sessionId) {
     const meta = this.sessionMetaMap.get(sessionId);
     if (!meta) {
       throw new Error(`Session not found: ${sessionId}`);
     }
-    if (!existsSync4(meta.sourcePath)) {
+    if (!existsSync5(meta.sourcePath)) {
       throw new Error(`Session file missing: ${meta.sourcePath}`);
     }
+    this.ensureChildIndex();
     const builder = new TranscriptBuilder();
     const assistantUuidToToolCalls = /* @__PURE__ */ new Map();
     const countedUsageKeys = /* @__PURE__ */ new Set();
     for (const record of readJsonlFile(meta.sourcePath)) {
       try {
-        this.convertRecord(record, builder, assistantUuidToToolCalls, countedUsageKeys);
+        this.convertRecord(
+          record,
+          builder,
+          assistantUuidToToolCalls,
+          countedUsageKeys,
+          this.childSessionIdByToolUseId
+        );
       } catch {
       }
     }
@@ -1438,6 +1802,7 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
       title: meta.title,
       slug: `claudecode/${meta.id}`,
       directory: meta.directory,
+      parent_reference: meta.parentSessionId == null ? void 0 : { agentName: this.name, sessionId: meta.parentSessionId },
       version: void 0,
       time_created: meta.createdAt,
       time_updated: meta.updatedAt,
@@ -1449,43 +1814,143 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
   listProjectDirs() {
     if (!this.basePath) return [];
     try {
-      return readdirSync2(this.basePath).map((e) => join4(this.basePath, e)).filter((p) => existsSync4(p));
+      return readdirSync3(this.basePath).map((e) => join5(this.basePath, e)).filter((p) => existsSync5(p));
     } catch {
       return [];
     }
   }
+  ensureChildIndex() {
+    if (this.childIndexReady) return;
+    this.basePath ??= this.findBasePath();
+    if (!this.basePath) {
+      this.childIndexReady = true;
+      return;
+    }
+    const projectDirs = this.listProjectDirs();
+    this.indexChildContexts(
+      this.walkFiles(projectDirs, (entry) => entry.name.endsWith(".jsonl"), {
+        recursive: true
+      }),
+      projectDirs
+    );
+  }
+  indexChildContexts(sources, projectDirs) {
+    this.childContextsBySource.clear();
+    this.childSessionIdByToolUseId.clear();
+    const projectDirSet = new Set(projectDirs);
+    const contexts = /* @__PURE__ */ new Map();
+    const knownSessionIds = /* @__PURE__ */ new Set();
+    for (const source of sources) {
+      const child = this.readChildContext(source.file);
+      if (!child) {
+        if (projectDirSet.has(dirname2(source.file))) {
+          knownSessionIds.add(basename3(source.file, ".jsonl"));
+        }
+        continue;
+      }
+      contexts.set(source.file, child);
+      knownSessionIds.add(child.sessionId);
+    }
+    for (const [sourcePath, child] of contexts) {
+      const parentSessionId = child.parentSessionId && knownSessionIds.has(child.parentSessionId) ? child.parentSessionId : null;
+      const normalized = parentSessionId === child.parentSessionId ? child : { ...child, parentSessionId };
+      this.childContextsBySource.set(sourcePath, normalized);
+      if (child.toolUseId) {
+        this.childSessionIdByToolUseId.set(child.toolUseId, normalized.sessionId);
+      }
+    }
+    this.childIndexReady = true;
+  }
+  getChildContext(sourcePath) {
+    const cached = this.childContextsBySource.get(sourcePath);
+    if (cached) return cached;
+    const child = this.readChildContext(sourcePath);
+    if (!child) return null;
+    this.childContextsBySource.set(sourcePath, child);
+    if (child.toolUseId) {
+      this.childSessionIdByToolUseId.set(child.toolUseId, child.sessionId);
+    }
+    return child;
+  }
+  readChildContext(sourcePath) {
+    const subagentsDir = dirname2(sourcePath);
+    if (basename3(subagentsDir) !== "subagents") return null;
+    const parentDir = dirname2(subagentsDir);
+    const projectDir = dirname2(parentDir);
+    const fileStem = basename3(sourcePath, ".jsonl");
+    const metaPath = join5(subagentsDir, fileStem + ".meta.json");
+    const metaMtimeMs = this.readFileMtimeMs(metaPath);
+    const cached = this.childContextCache.get(sourcePath);
+    if (cached?.metaMtimeMs === metaMtimeMs) return cached.context;
+    let metadata = null;
+    if (metaMtimeMs !== null) {
+      try {
+        metadata = asRecord(JSON.parse(readFileSync2(metaPath, "utf-8"))) ?? null;
+      } catch {
+      }
+    }
+    const sessionId = asString(metadata?.["agentId"])?.trim() || fileStem.replace(/^agent-/, "");
+    if (!sessionId) return null;
+    const parentAgentId = asString(metadata?.["parentAgentId"])?.trim();
+    const candidateParentId = parentAgentId || basename3(parentDir) || null;
+    const parentSessionId = candidateParentId && this.hasChildParent(sourcePath, projectDir, candidateParentId) ? candidateParentId : null;
+    const name = asString(metadata?.["name"])?.trim();
+    const description = asString(metadata?.["description"])?.trim();
+    const context = {
+      sessionId,
+      projectDir,
+      parentSessionId,
+      explicitTitle: name || description || null,
+      metaMtimeMs,
+      toolUseId: asString(metadata?.["toolUseId"])?.trim() || null
+    };
+    this.childContextCache.set(sourcePath, { metaMtimeMs, context });
+    return context;
+  }
+  hasChildParent(sourcePath, projectDir, parentSessionId) {
+    const subagentsDir = dirname2(sourcePath);
+    return [
+      join5(projectDir, parentSessionId + ".jsonl"),
+      join5(subagentsDir, "agent-" + parentSessionId + ".jsonl"),
+      join5(subagentsDir, parentSessionId + ".jsonl")
+    ].some((path2) => existsSync5(path2));
+  }
   createFileSessionMeta(head, source) {
-    const projectDir = dirname(source.file);
+    const child = this.getChildContext(source.file);
+    const projectDir = child?.projectDir ?? dirname2(source.file);
     const indexPath = this.getSessionsIndexPath(projectDir);
     const indexMtime = this.readFileMtimeMs(indexPath);
     return this.buildFileSessionMeta({
       head,
       source,
-      fingerprint: this.sourceFingerprint(source.stat, indexMtime),
+      fingerprint: this.sourceFingerprint(source.stat, indexMtime, child?.metaMtimeMs),
       extras: {
         indexPath: indexMtime === null ? null : indexPath,
         indexMtimeMs: indexMtime,
         headIndexVersion: HEAD_INDEX_VERSION,
-        model: head.stats.total_tokens ? "unknown" : void 0
+        model: head.stats.total_tokens ? "unknown" : void 0,
+        parentSessionId: head.parent_reference?.sessionId ?? null
       }
     });
   }
   /** Fingerprint depends on an already-fetched stat to avoid re-statting the same file. */
-  sourceFingerprint(stat, indexMtime) {
-    return JSON.stringify([HEAD_INDEX_VERSION, stat.mtimeMs, stat.size, indexMtime]);
+  sourceFingerprint(stat, indexMtime, metaMtime) {
+    const fingerprint = [HEAD_INDEX_VERSION, stat.mtimeMs, stat.size, indexMtime];
+    if (metaMtime !== void 0) fingerprint.push(metaMtime);
+    return JSON.stringify(fingerprint);
   }
   getSessionsIndexPath(projectDir) {
-    return join4(projectDir, "sessions-index.json");
+    return join5(projectDir, "sessions-index.json");
   }
   loadSessionsIndex(projectDir) {
-    const cacheKey = basename2(projectDir);
+    const cacheKey = basename3(projectDir);
     const indexPath = this.getSessionsIndexPath(projectDir);
     const mtime = this.readFileMtimeMs(indexPath);
     if (cacheKey in this.sessionsIndexCache && this.sessionsIndexMtime[cacheKey] === mtime) {
       return this.sessionsIndexCache[cacheKey];
     }
     const map = /* @__PURE__ */ new Map();
-    if (existsSync4(indexPath)) {
+    if (existsSync5(indexPath)) {
       try {
         const data = JSON.parse(readFileSync2(indexPath, "utf-8"));
         const entries = data?.entries ?? [];
@@ -1502,11 +1967,11 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
     this.sessionsIndexMtime[cacheKey] = mtime;
     return map;
   }
-  parseSessionHeadResult(filePath, projectDir) {
-    const sessionId = basename2(filePath, ".jsonl");
+  parseSessionHeadResult(filePath, projectDir, child) {
+    const sessionId = child?.sessionId ?? basename3(filePath, ".jsonl");
     const index = this.loadSessionsIndex(projectDir);
     const indexEntry = index.get(sessionId);
-    const explicitTitle = indexEntry?.summary ? String(indexEntry.summary) : null;
+    const explicitTitle = child?.explicitTitle ?? (indexEntry?.summary ? String(indexEntry.summary) : null);
     let createdAt = 0;
     let updatedAt = 0;
     let lineIndex = 0;
@@ -1531,7 +1996,7 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
         continue;
       }
       if (lineIndex === 0) {
-        createdAt = parseTimestampMs(data) || statSync2(filePath).mtimeMs;
+        createdAt = parseTimestampMs(data) || statSync3(filePath).mtimeMs;
         updatedAt = createdAt;
       }
       const recordIndex = lineIndex;
@@ -1605,6 +2070,7 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
       slug: `claudecode/${sessionId}`,
       title,
       directory,
+      parent_reference: child?.parentSessionId == null ? void 0 : { agentName: this.name, sessionId: child.parentSessionId },
       time_created: createdAt,
       time_updated: updatedAt,
       stats: {
@@ -1637,19 +2103,25 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
     return null;
   }
   // --- Record conversion ---
-  convertRecord(data, builder, assistantUuidToToolCalls, countedUsageKeys) {
+  convertRecord(data, builder, assistantUuidToToolCalls, countedUsageKeys, childSessionIdByToolUseId) {
     if (data["isMeta"] === true) return;
     const msgType = String(data["type"] ?? "");
     if (isInternalEventType(msgType)) return;
     if (msgType === "assistant") {
-      this.convertAssistantRecord(data, builder, assistantUuidToToolCalls, countedUsageKeys);
+      this.convertAssistantRecord(
+        data,
+        builder,
+        assistantUuidToToolCalls,
+        countedUsageKeys,
+        childSessionIdByToolUseId
+      );
     } else if (msgType === "user") {
       this.convertUserRecord(data, builder, assistantUuidToToolCalls);
     } else if (msgType === "tool_result") {
       this.convertToolResultRecord(data, builder);
     }
   }
-  convertAssistantRecord(data, builder, assistantUuidToToolCalls, countedUsageKeys) {
+  convertAssistantRecord(data, builder, assistantUuidToToolCalls, countedUsageKeys, childSessionIdByToolUseId) {
     const msg = asRecord(data["message"]) ?? {};
     const timestampMs = parseTimestampMs(data);
     const rawContent = asArray(msg["content"]) ?? [];
@@ -1689,12 +2161,14 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
       }
       if (partType !== "tool_use") continue;
       const toolCallId = String(part["id"] ?? "").trim();
-      const toolPart = this.buildToolPart(part, timestampMs);
+      const subagentId = childSessionIdByToolUseId.get(toolCallId);
+      const toolPart2 = this.buildToolPart(part, timestampMs);
       const message = builder.appendToolCall(
-        toolPart,
-        { id: uuid, timestampMs, agent: "claude" },
+        toolPart2,
+        { id: uuid, timestampMs, agent: "claude", subagentId },
         { modeOnCreate: "tool" }
       );
+      if (subagentId) message.subagent_id = subagentId;
       this.applyAssistantMetadata(message, data, msg, countedUsageKeys);
       if (toolCallId) {
         toolCallIds.push(toolCallId);
@@ -1967,11 +2441,12 @@ function backupDatabase(db, dbPath, label) {
     return null;
   }
   const timestamp = new Date(Date.now()).toISOString().replaceAll(":", "").replaceAll(".", "-");
-  let backupPath = join5(dirname2(dbPath), `${basename3(dbPath)}.${timestamp}.${label}.bak`);
-  for (let counter = 1; existsSync5(backupPath); counter += 1) {
-    backupPath = join5(dirname2(dbPath), `${basename3(dbPath)}.${timestamp}.${label}.${counter}.bak`);
+  let backupPath = join6(dirname3(dbPath), `${basename4(dbPath)}.${timestamp}.${label}.bak`);
+  for (let counter = 1; existsSync6(backupPath); counter += 1) {
+    backupPath = join6(dirname3(dbPath), `${basename4(dbPath)}.${timestamp}.${label}.${counter}.bak`);
   }
   db.exec(`VACUUM INTO ${quoteSqlString(backupPath)}`);
+  restrictPrivateFile(backupPath);
   return backupPath;
 }
 function backupDatabaseIfPopulated(db, dbPath, label, tables) {
@@ -2066,8 +2541,9 @@ function openDb(dbPath) {
     return null;
   }
   try {
-    mkdirSync2(dirname2(dbPath), { recursive: true });
+    ensurePrivateDirectory(dirname3(dbPath));
     const db = DatabaseConstructor(dbPath);
+    restrictPrivateDatabase(dbPath);
     try {
       db.pragma("journal_mode = WAL");
       db.pragma("synchronous = NORMAL");
@@ -2089,6 +2565,24 @@ function isSqliteAvailable() {
   return DatabaseConstructor !== null;
 }
 var MESSAGE_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool"]);
+var SESSION_ID_QUERY_CHUNK_SIZE = 500;
+function compareSessionRowsByActivityDesc(left, right) {
+  const leftUpdated = Number(left.time_updated ?? left.time_created ?? 0);
+  const rightUpdated = Number(right.time_updated ?? right.time_created ?? 0);
+  return rightUpdated - leftUpdated || Number(right.time_created ?? 0) - Number(left.time_created ?? 0) || String(right.id ?? "").localeCompare(String(left.id ?? ""));
+}
+function accumulateTokenStats(stats, msgData, agentName) {
+  const cost = Number(msgData.cost ?? 0);
+  const tokens = parseTokens(msgData.tokens, agentName);
+  const inputTokens = Number(tokens?.input ?? 0);
+  const outputTokens = Number(tokens?.output ?? 0);
+  const model = parseModel(msgData.modelID, agentName);
+  const estimatedCost = cost > 0 ? null : estimateTokenCost(model, { input: inputTokens, output: outputTokens });
+  if (estimatedCost !== null) stats.cost_source = "estimated";
+  stats.total_cost += cost || estimatedCost || 0;
+  stats.total_input_tokens += inputTokens;
+  stats.total_output_tokens += outputTokens;
+}
 function parseJsonRecord(raw, agentName, field) {
   const parsed = asRecord(JSON.parse(String(raw ?? "{}")));
   if (parsed) return parsed;
@@ -2138,34 +2632,54 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
   scan(options) {
     if (!this.dbPath) return [];
     const db = openDbReadOnly(this.dbPath);
-    if (!db) return [];
+    if (!db) throw new SessionScanError(this.name, "opening the database");
     try {
       const cutoffTime = options?.from ?? Date.now() - 3650 * 24 * 60 * 60 * 1e3;
       const hasMessageTable = Boolean(
         db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'message'").get()
       );
+      const hasTaskType = columnExists(db, "session", "task_type");
+      const hasParentId = columnExists(db, "session", "parent_id");
+      const childPredicate = hasParentId ? "AND s.parent_id IS NULL" : hasTaskType ? "AND (s.task_type IS NULL OR s.task_type != 'subagent_child')" : "";
       let rows;
+      const parentIdSelect = hasParentId ? ", s.parent_id" : "";
       if (hasMessageTable) {
         rows = db.prepare(`
           SELECT
             s.id, s.title, s.time_created, s.time_updated, s.slug, s.directory,
-            s.version, s.summary_files
+            s.version, s.summary_files${parentIdSelect}
           FROM session s
           WHERE COALESCE(s.time_updated, s.time_created) >= ?
-          ORDER BY s.time_created DESC
+          ${childPredicate}
+          ORDER BY COALESCE(s.time_updated, s.time_created) DESC, s.time_created DESC, s.id DESC
         `).all(cutoffTime);
       } else {
         rows = db.prepare(`
           SELECT s.id, s.title, s.time_created, s.time_updated, s.slug, s.directory,
-            s.version, s.summary_files, 0 AS message_count, NULL AS model_message_data
+            s.version, s.summary_files, 0 AS message_count, NULL AS model_message_data${parentIdSelect}
           FROM session s
           WHERE COALESCE(s.time_updated, s.time_created) >= ?
-          ORDER BY s.time_created DESC
+          ${childPredicate}
+          ORDER BY COALESCE(s.time_updated, s.time_created) DESC, s.time_created DESC, s.id DESC
         `).all(cutoffTime);
       }
+      if (hasParentId && options?.includeRelatedSessions !== false) {
+        const rootIds = rows.map((row) => String(row.id ?? "")).filter(Boolean);
+        const relatedRows = this.readRelatedSessionRows(db, rootIds);
+        const knownIds = new Set(rootIds);
+        rows.push(...relatedRows.filter((row) => !knownIds.has(String(row.id ?? ""))));
+      }
+      rows.sort(compareSessionRowsByActivityDesc);
+      const sessionIds = new Set(rows.map((row) => String(row.id ?? "")).filter(Boolean));
       const headContexts = hasMessageTable ? this.buildHeadContexts(
-        this.readHeadMessageRows(db, cutoffTime),
-        this.readHeadPartRows(db, cutoffTime)
+        this.readHeadMessageRows(
+          db,
+          cutoffTime,
+          hasParentId,
+          sessionIds.size > 0 ? sessionIds : void 0
+        ),
+        this.readHeadPartRows(db, cutoffTime, sessionIds.size > 0 ? sessionIds : void 0),
+        hasParentId
       ) : /* @__PURE__ */ new Map();
       const heads = [];
       options?.onProgress?.({ total: rows.length, processed: 0, sessions: 0 });
@@ -2187,8 +2701,8 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
         options?.onProgress?.({ total: rows.length, processed, sessions: heads.length });
       }
       return heads;
-    } catch {
-      return [];
+    } catch (error) {
+      throw new SessionScanError(this.name, "reading sessions", { cause: error });
     } finally {
       db.close();
     }
@@ -2207,6 +2721,7 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
       slug: `${this.name}/${id}`,
       title: resolveSessionTitle(String(row.title ?? ""), messageTitle, null),
       directory: String(row.directory ?? ""),
+      parent_reference: row.parent_id == null || String(row.parent_id) === "" ? void 0 : { agentName: this.name, sessionId: String(row.parent_id) },
       time_created: timeCreated,
       time_updated: timeUpdated,
       stats: {
@@ -2218,28 +2733,103 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
       }
     });
   }
-  readHeadMessageRows(db, cutoffTime) {
-    return db.prepare(
-      `
-          SELECT m.id, m.session_id, m.data, m.time_created
-          FROM message m
-          JOIN session s ON s.id = m.session_id
-          WHERE COALESCE(s.time_updated, s.time_created) >= ?
-          ORDER BY m.session_id, m.time_created ASC
+  readHeadMessageRows(db, cutoffTime, withParentId, sessionIds) {
+    const parentIdSelect = withParentId ? ", s.parent_id" : "";
+    const ids = sessionIds ? [...sessionIds] : [];
+    if (ids.length === 0) {
+      return db.prepare(
         `
-    ).all(cutoffTime);
+            SELECT m.id, m.session_id, m.data, m.time_created${parentIdSelect}
+            FROM message m
+            JOIN session s ON s.id = m.session_id
+            WHERE COALESCE(s.time_updated, s.time_created) >= ?
+            ORDER BY m.session_id, m.time_created ASC
+          `
+      ).all(cutoffTime);
+    }
+    const rows = [];
+    for (let offset = 0; offset < ids.length; offset += SESSION_ID_QUERY_CHUNK_SIZE) {
+      const chunk = ids.slice(offset, offset + SESSION_ID_QUERY_CHUNK_SIZE);
+      rows.push(
+        ...db.prepare(
+          `
+              SELECT m.id, m.session_id, m.data, m.time_created${parentIdSelect}
+              FROM message m
+              JOIN session s ON s.id = m.session_id
+              WHERE s.id IN (${chunk.map(() => "?").join(",")})
+              ORDER BY m.session_id, m.time_created ASC
+            `
+        ).all(...chunk)
+      );
+    }
+    return rows;
   }
-  readHeadPartRows(db, cutoffTime) {
-    return db.prepare(
+  readHeadPartRows(db, cutoffTime, sessionIds) {
+    const ids = sessionIds ? [...sessionIds] : [];
+    if (ids.length === 0) {
+      return db.prepare(
+        `
+            SELECT p.message_id, p.data, p.time_created
+            FROM part p
+            JOIN message m ON m.id = p.message_id
+            JOIN session s ON s.id = m.session_id
+            WHERE COALESCE(s.time_updated, s.time_created) >= ?
+            ORDER BY p.message_id, p.time_created ASC, p.id ASC
+          `
+      ).all(cutoffTime);
+    }
+    const rows = [];
+    for (let offset = 0; offset < ids.length; offset += SESSION_ID_QUERY_CHUNK_SIZE) {
+      const chunk = ids.slice(offset, offset + SESSION_ID_QUERY_CHUNK_SIZE);
+      rows.push(
+        ...db.prepare(
+          `
+              SELECT p.message_id, p.data, p.time_created
+              FROM part p
+              JOIN message m ON m.id = p.message_id
+              JOIN session s ON s.id = m.session_id
+              WHERE s.id IN (${chunk.map(() => "?").join(",")})
+              ORDER BY p.message_id, p.time_created ASC, p.id ASC
+            `
+        ).all(...chunk)
+      );
+    }
+    return rows;
+  }
+  readRelatedSessionRows(db, rootIds) {
+    if (rootIds.length === 0) return [];
+    const rows = db.prepare(
       `
-          SELECT p.message_id, p.data, p.time_created
-          FROM part p
-          JOIN message m ON m.id = p.message_id
-          JOIN session s ON s.id = m.session_id
-          WHERE COALESCE(s.time_updated, s.time_created) >= ?
-          ORDER BY p.message_id, p.time_created ASC
+          SELECT
+            s.id, s.title, s.time_created, s.time_updated, s.slug, s.directory,
+            s.version, s.summary_files, s.parent_id
+          FROM session s
+          WHERE s.parent_id IS NOT NULL
+          ORDER BY s.time_created ASC
         `
-    ).all(cutoffTime);
+    ).all();
+    const childrenByParent = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const parentId = String(row.parent_id ?? "");
+      if (!parentId) continue;
+      const children = childrenByParent.get(parentId);
+      if (children) children.push(row);
+      else childrenByParent.set(parentId, [row]);
+    }
+    const result = [];
+    const pending2 = [...rootIds];
+    const seen = /* @__PURE__ */ new Set();
+    while (pending2.length > 0) {
+      const parentId = pending2.pop();
+      for (const row of childrenByParent.get(parentId) ?? []) {
+        const id = String(row.id ?? "");
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        result.push(row);
+        pending2.push(id);
+      }
+    }
+    return result;
   }
   parsePartRow(partRow) {
     const partData = parseJsonRecord(partRow.data, this.name, "part.data");
@@ -2250,9 +2840,21 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
     ]);
     return part ? cleanMessagePart(part) : null;
   }
-  readMessageParts(db, messageId) {
-    const partRows = db.prepare("SELECT data, time_created FROM part WHERE message_id = ? ORDER BY time_created ASC").all(messageId);
-    return partRows.map((partRow) => this.parsePartRow(partRow)).filter((part) => part !== null);
+  /**
+   * Every part of one session in a single read. Fetching per message turned a
+   * detail into M+2 queries, and without an index on part(message_id) each one
+   * scanned the whole table.
+   */
+  readSessionPartRows(db, sessionId) {
+    return db.prepare(
+      `
+          SELECT p.message_id, p.data, p.time_created
+          FROM part p
+          JOIN message m ON m.id = p.message_id
+          WHERE m.session_id = ?
+          ORDER BY p.message_id, p.time_created ASC, p.id ASC
+        `
+    ).all(sessionId);
   }
   buildPartsByMessage(partRows) {
     const partsByMessage = /* @__PURE__ */ new Map();
@@ -2270,16 +2872,10 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
     }
     return partsByMessage;
   }
-  buildHeadContexts(messageRows, partRows) {
+  buildHeadContexts(messageRows, partRows, withParentId) {
     const partsByMessage = this.buildPartsByMessage(partRows);
     const contexts = /* @__PURE__ */ new Map();
-    for (const row of messageRows) {
-      const sessionId = String(row.session_id ?? "");
-      if (!sessionId) continue;
-      const msgData = parseJsonRecord(row.data, this.name, "message.data");
-      if (isInternalEventType(msgData.type)) continue;
-      const parts = partsByMessage.get(String(row.id ?? "")) ?? [];
-      if (parts.length === 0) continue;
+    const ensureContext = (sessionId) => {
       let context = contexts.get(sessionId);
       if (!context) {
         context = {
@@ -2293,16 +2889,41 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
         };
         contexts.set(sessionId, context);
       }
-      const cost = Number(msgData.cost ?? 0);
-      const tokens = parseTokens(msgData.tokens, this.name);
-      const inputTokens = Number(tokens?.input ?? 0);
-      const outputTokens = Number(tokens?.output ?? 0);
-      const model = parseModel(msgData.modelID, this.name);
-      const estimatedCost = cost > 0 ? null : estimateTokenCost(model, { input: inputTokens, output: outputTokens });
-      if (estimatedCost !== null) context.stats.cost_source = "estimated";
-      context.stats.total_cost += cost || estimatedCost || 0;
-      context.stats.total_input_tokens += inputTokens;
-      context.stats.total_output_tokens += outputTokens;
+      return context;
+    };
+    for (const row of messageRows) {
+      const sessionId = String(row.session_id ?? "");
+      if (!sessionId) continue;
+      const msgData = parseJsonRecord(row.data, this.name, "message.data");
+      if (isInternalEventType(msgData.type)) continue;
+      const parentId = withParentId ? String(row.parent_id ?? "") : "";
+      const isChild = parentId !== "";
+      if (isChild) {
+        const childContext = ensureContext(sessionId);
+        const parts2 = partsByMessage.get(String(row.id ?? "")) ?? [];
+        if (parts2.length > 0) {
+          accumulateTokenStats(childContext.stats, msgData, this.name);
+          childContext.stats.message_count += 1;
+          if (!childContext.messageTitle && String(msgData.role ?? "") === "user") {
+            childContext.messageTitle = firstUserMessageTitle([
+              {
+                id: String(row.id ?? ""),
+                role: "user",
+                agent: null,
+                time_created: Number(row.time_created ?? 0),
+                parts: parts2
+              }
+            ]);
+          }
+        }
+        const parentContext = ensureContext(parentId);
+        accumulateTokenStats(parentContext.stats, msgData, this.name);
+        continue;
+      }
+      const parts = partsByMessage.get(String(row.id ?? "")) ?? [];
+      if (parts.length === 0) continue;
+      const context = ensureContext(sessionId);
+      accumulateTokenStats(context.stats, msgData, this.name);
       context.stats.message_count += 1;
       if (!context.messageTitle && String(msgData.role ?? "") === "user") {
         context.messageTitle = firstUserMessageTitle([
@@ -2323,6 +2944,29 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
     }
     return contexts;
   }
+  sumChildTokenStats(db, parentSessionId) {
+    if (!columnExists(db, "session", "parent_id")) return [];
+    const childRows = db.prepare("SELECT id FROM session WHERE parent_id = ?").all(parentSessionId);
+    const results = [];
+    for (const child of childRows) {
+      const childId = String(child.id ?? "");
+      if (!childId) continue;
+      const msgRows = db.prepare("SELECT data FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(childId);
+      const stats = {
+        message_count: 0,
+        total_input_tokens: 0,
+        total_output_tokens: 0,
+        total_cost: 0
+      };
+      for (const row of msgRows) {
+        const msgData = parseJsonRecord(row.data, this.name, "message.data");
+        if (isInternalEventType(msgData.type)) continue;
+        accumulateTokenStats(stats, msgData, this.name);
+      }
+      results.push(stats);
+    }
+    return results;
+  }
   getSessionData(sessionId) {
     if (!this.dbPath) {
       this.dbPath = this.findDbPath();
@@ -2345,11 +2989,9 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
       const timeCreated = Number(sessionRow.time_created ?? 0);
       const timeUpdated = Number(sessionRow.time_updated ?? timeCreated);
       const messages = [];
-      let totalCost = 0;
-      let totalInputTokens = 0;
-      let totalOutputTokens = 0;
       let hasEstimatedCost = false;
-      const msgRows = db.prepare("SELECT * FROM message WHERE session_id = ? ORDER BY time_created ASC").all(sessionId);
+      const msgRows = db.prepare("SELECT * FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId);
+      const partsByMessage = this.buildPartsByMessage(this.readSessionPartRows(db, sessionId));
       for (const msgRow of msgRows) {
         const msgData = parseJsonRecord(msgRow.data, this.name, "message.data");
         if (isInternalEventType(msgData.type)) continue;
@@ -2360,7 +3002,7 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
         const model = parseModel(msgData.modelID, this.name);
         const estimatedCost = cost > 0 ? null : estimateTokenCost(model, { input: inputTokens, output: outputTokens });
         const resolvedCost = cost || estimatedCost || 0;
-        const parts = this.readMessageParts(db, msgRow.id);
+        const parts = partsByMessage.get(String(msgRow.id ?? "")) ?? [];
         if (parts.length === 0) continue;
         messages.push({
           id: String(msgRow.id ?? ""),
@@ -2382,28 +3024,41 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
         firstUserMessageTitle(cleanedMessages),
         null
       );
+      const stats = {
+        message_count: cleanedMessages.length,
+        total_input_tokens: 0,
+        total_output_tokens: 0,
+        total_cost: 0
+      };
       for (const message of cleanedMessages) {
-        totalCost += message.cost ?? 0;
-        totalInputTokens += message.tokens?.input ?? 0;
-        totalOutputTokens += message.tokens?.output ?? 0;
+        stats.total_cost += message.cost ?? 0;
+        stats.total_input_tokens += message.tokens?.input ?? 0;
+        stats.total_output_tokens += message.tokens?.output ?? 0;
         if (message.cost_source === "estimated") hasEstimatedCost = true;
       }
+      for (const childStats of this.sumChildTokenStats(db, sessionId)) {
+        stats.total_cost += childStats.total_cost;
+        stats.total_input_tokens += childStats.total_input_tokens;
+        stats.total_output_tokens += childStats.total_output_tokens;
+        if (childStats.cost_source === "estimated") hasEstimatedCost = true;
+      }
       return {
         reference: { agentName: this.name, sessionId: id },
         id,
         title,
         slug,
         directory,
+        parent_reference: sessionRow.parent_id == null || String(sessionRow.parent_id) === "" ? void 0 : { agentName: this.name, sessionId: String(sessionRow.parent_id) },
         version: asString(sessionRow.version) ?? void 0,
         time_created: timeCreated,
         time_updated: timeUpdated,
         summary_files: sessionRow.summary_files ?? void 0,
         stats: {
-          message_count: cleanedMessages.length,
-          total_input_tokens: totalInputTokens,
-          total_output_tokens: totalOutputTokens,
-          total_cost: totalCost,
-          cost_source: totalCost > 0 ? hasEstimatedCost ? "estimated" : "recorded" : void 0
+          message_count: stats.message_count,
+          total_input_tokens: stats.total_input_tokens,
+          total_output_tokens: stats.total_output_tokens,
+          total_cost: stats.total_cost,
+          cost_source: stats.total_cost > 0 ? hasEstimatedCost ? "estimated" : "recorded" : void 0
         },
         messages: cleanedMessages
       };
@@ -2413,18 +3068,18 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
   }
 };
 function resolveOpenCodeDataRoot() {
-  return join6(resolveDataHome(), "opencode");
+  return join7(resolveDataHome(), "opencode");
 }
 function findOpenCodeDbPath() {
   if (!isSqliteAvailable()) return null;
-  return firstExisting(join6(resolveOpenCodeDataRoot(), "opencode.db"), "data/opencode/opencode.db");
+  return firstExisting(join7(resolveOpenCodeDataRoot(), "opencode.db"), "data/opencode/opencode.db");
 }
 function getOpenCodeSessionWatchPlan() {
   const dataRoot = resolveOpenCodeDataRoot();
   return {
     status: "supported",
     targets: [
-      { root: dataRoot, path: join6(dataRoot, "opencode.db") },
+      { root: dataRoot, path: join7(dataRoot, "opencode.db") },
       { root: "data/opencode", path: "data/opencode/opencode.db" }
     ]
   };
@@ -2521,14 +3176,14 @@ function kimiContentText(content) {
   }).join(" ");
 }
 function extractFirstUserTitle(contextFile, wireFile) {
-  if (contextFile && existsSync6(contextFile)) {
+  if (contextFile && existsSync7(contextFile)) {
     for (const record of readJsonlFile(contextFile)) {
       if (record.role !== "user") continue;
       const title = normalizeTitleText(kimiContentText(record.content));
       if (title) return title;
     }
   }
-  if (wireFile && existsSync6(wireFile)) {
+  if (wireFile && existsSync7(wireFile)) {
     for (const record of readJsonlFile(wireFile)) {
       const message = asRecord(record.message) ?? {};
       if (message.type !== "TurnBegin") continue;
@@ -2548,25 +3203,25 @@ var KimiAgent = class extends FileSystemSessionSource {
   projectMap = /* @__PURE__ */ new Map();
   defaultModel = null;
   findBasePath() {
-    return firstExisting(join7(resolveKimiDataRoot(), "sessions"), "data/kimi");
+    return firstExisting(join8(resolveKimiDataRoot(), "sessions"), "data/kimi");
   }
   getSessionWatchPlan() {
     const dataRoot = resolveKimiDataRoot();
     return {
       status: "supported",
-      targets: [{ root: dataRoot, path: join7(dataRoot, "sessions") }, { path: "data/kimi" }]
+      targets: [{ root: dataRoot, path: join8(dataRoot, "sessions") }, { path: "data/kimi" }]
     };
   }
   /** Parse kimi.json and build md5(project_path) → cwd mapping */
   loadKimiConfig() {
     const dataRoot = resolveKimiDataRoot();
-    const configPath = join7(dataRoot, "kimi.json");
-    const tomlPath = join7(dataRoot, "config.toml");
-    if (existsSync6(tomlPath)) {
+    const configPath = join8(dataRoot, "kimi.json");
+    const tomlPath = join8(dataRoot, "config.toml");
+    if (existsSync7(tomlPath)) {
       const configText = readFileSync3(tomlPath, "utf-8");
       this.defaultModel = configText.match(/^default_model\s*=\s*"([^"]+)"/m)?.[1] ?? null;
     }
-    if (!existsSync6(configPath)) return;
+    if (!existsSync7(configPath)) return;
     try {
       const raw = asRecord(JSON.parse(readFileSync3(configPath, "utf-8")));
       const workDirs = asArray(raw?.work_dirs);
@@ -2595,14 +3250,14 @@ var KimiAgent = class extends FileSystemSessionSource {
     if (!this.basePath) return [];
     const dirs = [];
     try {
-      for (const hashEntry of readdirSync3(this.basePath, { withFileTypes: true })) {
+      for (const hashEntry of readdirSync4(this.basePath, { withFileTypes: true })) {
         if (!hashEntry.isDirectory()) continue;
-        const hashPath = join7(this.basePath, hashEntry.name);
+        const hashPath = join8(this.basePath, hashEntry.name);
         try {
-          for (const sessionEntry of readdirSync3(hashPath, { withFileTypes: true })) {
+          for (const sessionEntry of readdirSync4(hashPath, { withFileTypes: true })) {
             if (!sessionEntry.isDirectory()) continue;
-            const sessionPath = join7(hashPath, sessionEntry.name);
-            if (existsSync6(join7(sessionPath, "metadata.json")) || existsSync6(join7(sessionPath, "state.json"))) {
+            const sessionPath = join8(hashPath, sessionEntry.name);
+            if (existsSync7(join8(sessionPath, "metadata.json")) || existsSync7(join8(sessionPath, "state.json"))) {
               dirs.push(sessionPath);
             }
           }
@@ -2619,32 +3274,32 @@ var KimiAgent = class extends FileSystemSessionSource {
    */
   resolveSessionSourceResult(sessionDir) {
     try {
-      const sessionId = basename4(sessionDir);
-      const projectHash = basename4(dirname3(sessionDir));
-      const contextFile = join7(sessionDir, "context.jsonl");
-      const wireFile = join7(sessionDir, "wire.jsonl");
-      const existingContextFile = existsSync6(contextFile) ? contextFile : null;
-      const existingWireFile = existsSync6(wireFile) ? wireFile : null;
+      const sessionId = basename5(sessionDir);
+      const projectHash = basename5(dirname4(sessionDir));
+      const contextFile = join8(sessionDir, "context.jsonl");
+      const wireFile = join8(sessionDir, "wire.jsonl");
+      const existingContextFile = existsSync7(contextFile) ? contextFile : null;
+      const existingWireFile = existsSync7(wireFile) ? wireFile : null;
       if (!existingContextFile && !existingWireFile) {
         return skippedSession("missing transcript");
       }
-      const statePath = join7(sessionDir, "state.json");
-      const metaPath = join7(sessionDir, "metadata.json");
+      const statePath = join8(sessionDir, "state.json");
+      const metaPath = join8(sessionDir, "metadata.json");
       let explicitTitle = "";
       let wireMtime = null;
       let metaFile = "";
-      if (existsSync6(statePath)) {
+      if (existsSync7(statePath)) {
         const state = asRecord(JSON.parse(readFileSync3(statePath, "utf-8"))) ?? {};
         explicitTitle = String(state.custom_title ?? "");
         wireMtime = readWireMtime(state);
         metaFile = statePath;
-      } else if (existsSync6(metaPath)) {
+      } else if (existsSync7(metaPath)) {
         const meta = asRecord(JSON.parse(readFileSync3(metaPath, "utf-8"))) ?? {};
         explicitTitle = String(meta.title ?? "");
         wireMtime = readWireMtime(meta);
         metaFile = metaPath;
       }
-      const createdAt = wireMtime !== null ? wireMtime * 1e3 : metaFile ? statSync3(metaFile).mtimeMs : statSync3(sessionDir).mtimeMs;
+      const createdAt = wireMtime !== null ? wireMtime * 1e3 : metaFile ? statSync4(metaFile).mtimeMs : statSync4(sessionDir).mtimeMs;
       return parsedSession({
         id: sessionId,
         sourcePath: sessionDir,
@@ -2765,8 +3420,8 @@ var KimiAgent = class extends FileSystemSessionSource {
     return this.buildSessionData(meta, builder, stats);
   }
   getSessionDataFromWire(meta) {
-    const wirePath = meta.wireFile ?? join7(meta.sourcePath, "wire.jsonl");
-    if (!existsSync6(wirePath)) throw new Error("wire.jsonl is missing");
+    const wirePath = meta.wireFile ?? join8(meta.sourcePath, "wire.jsonl");
+    if (!existsSync7(wirePath)) throw new Error("wire.jsonl is missing");
     const builder = new TranscriptBuilder();
     const ignoredToolCallIds = /* @__PURE__ */ new Set();
     const openToolArgumentBuffer = /* @__PURE__ */ new Map();
@@ -2847,7 +3502,7 @@ var KimiAgent = class extends FileSystemSessionSource {
           const rawArgs = function_.arguments;
           const normalizedArgs = normalizeToolArguments(rawArgs);
           const buffer = typeof rawArgs === "string" && typeof normalizedArgs !== "string" ? rawArgs : null;
-          const toolPart = {
+          const toolPart2 = {
             type: "tool",
             tool: toolName,
             callID: callId,
@@ -2856,7 +3511,7 @@ var KimiAgent = class extends FileSystemSessionSource {
             time_created: timestampMs
           };
           builder.appendToolCall(
-            toolPart,
+            toolPart2,
             { id: `wire-${seq}`, timestampMs: 0, agent: "kimi" },
             { markModeAsTool: true, target: "current" }
           );
@@ -3004,10 +3659,10 @@ var KimiAgent = class extends FileSystemSessionSource {
       total_tokens: 0,
       message_count: 0
     };
-    const wirePath = join7(sessionDir, "wire.jsonl");
-    if (!existsSync6(wirePath)) return stats;
-    const contextPath = join7(sessionDir, "context.jsonl");
-    const hasContext = existsSync6(contextPath);
+    const wirePath = join8(sessionDir, "wire.jsonl");
+    if (!existsSync7(wirePath)) return stats;
+    const contextPath = join8(sessionDir, "context.jsonl");
+    const hasContext = existsSync7(contextPath);
     try {
       for (const record of readJsonlFile(wirePath)) {
         const tokenUsage = asRecord(asRecord(record.message)?.usage);
@@ -3053,6 +3708,576 @@ var KimiAgent = class extends FileSystemSessionSource {
     };
   }
 };
+var KIMI_CODE_TOOL_TITLE_MAP = {
+  Read: "read",
+  Write: "write",
+  Edit: "edit",
+  Bash: "bash",
+  TodoList: "todo",
+  AskUserQuestion: "ask",
+  EnterPlanMode: "plan mode",
+  ExitPlanMode: "plan approved",
+  ReadFile: "read",
+  Glob: "glob",
+  StrReplaceFile: "edit",
+  Grep: "grep",
+  WriteFile: "write",
+  Shell: "bash"
+};
+var KIMI_CODE_IGNORED_TOOLS = /* @__PURE__ */ new Set(["SetTodoList"]);
+function resolveKimiCodeDataRoot() {
+  return resolveHomePath("KIMI_CODE_HOME", ".kimi-code");
+}
+function mapToolTitle2(toolName) {
+  return KIMI_CODE_TOOL_TITLE_MAP[toolName] ?? toolName;
+}
+function normalizeToolArguments2(raw) {
+  if (typeof raw !== "string") return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseTimestamp(raw) {
+  if (typeof raw === "number") return Number.isFinite(raw) ? raw : null;
+  if (typeof raw !== "string" || raw.trim() === "") return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric)) return numeric;
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function timestampFromRecord(record) {
+  return parseTimestamp(record.time) ?? 0;
+}
+function contentText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) {
+    const record = asRecord(content);
+    return record ? String(record.text ?? "") : "";
+  }
+  return content.map((item) => {
+    if (typeof item === "string") return item;
+    const record = asRecord(item);
+    return record ? String(record.text ?? "") : "";
+  }).join(" ");
+}
+function contentParts(content, timestampMs) {
+  const values = Array.isArray(content) ? content : [content];
+  const parts = [];
+  for (const value of values) {
+    if (typeof value === "string") {
+      const text = cleanInternalText(value);
+      if (text) parts.push({ type: "text", text, time_created: timestampMs });
+      continue;
+    }
+    const record = asRecord(value);
+    if (!record) continue;
+    const type = asString(record.type) ?? "";
+    if (type === "text") {
+      const text = cleanInternalText(asString(record.text) ?? "");
+      if (text) parts.push({ type: "text", text, time_created: timestampMs });
+      continue;
+    }
+    if (type === "think") {
+      const text = cleanInternalText(asString(record.think) ?? "");
+      if (text) parts.push({ type: "reasoning", text, time_created: timestampMs });
+      continue;
+    }
+    if (type === "plan") {
+      const text = cleanInternalText(asString(record.text) ?? "");
+      if (text) {
+        parts.push({
+          type: "plan",
+          text,
+          approval_status: record.approved === false ? "fail" : "success",
+          time_created: timestampMs
+        });
+      }
+      continue;
+    }
+    if (type === "image") {
+      const source = asRecord(record.source);
+      const imageUrl = asRecord(record.imageUrl);
+      const url = asString(record.url) ?? asString(imageUrl?.url) ?? (source?.kind === "url" ? asString(source.url) : void 0);
+      const data = asString(record.data) ?? (source?.kind === "base64" ? asString(source.data) : void 0);
+      const mimeType = asString(record.mime_type) ?? asString(record.media_type) ?? (source?.kind === "base64" ? asString(source.media_type) : void 0) ?? "application/octet-stream";
+      if (url) parts.push({ type: "image", url, mime_type: mimeType, time_created: timestampMs });
+      else if (data) {
+        parts.push({
+          type: "image",
+          data,
+          mime_type: mimeType,
+          time_created: timestampMs
+        });
+      }
+      continue;
+    }
+    if (type === "image_url") {
+      const imageUrl = asRecord(record.imageUrl);
+      const url = asString(imageUrl?.url) ?? asString(record.url);
+      if (url) parts.push({ type: "image", url, time_created: timestampMs });
+    }
+  }
+  return parts;
+}
+function toolOutputParts(output, timestampMs) {
+  if (typeof output === "string") {
+    const text2 = cleanInternalText(output);
+    return text2 ? [{ type: "text", text: text2, time_created: timestampMs }] : [];
+  }
+  if (Array.isArray(output)) return contentParts(output, timestampMs);
+  if (output == null) return [];
+  const record = asRecord(output);
+  if (record?.type === "text") return contentParts([record], timestampMs);
+  const text = cleanInternalText(JSON.stringify(output, null, 2));
+  return text ? [{ type: "text", text, time_created: timestampMs }] : [];
+}
+function toolPart(toolName, callId, input, timestampMs) {
+  return {
+    type: "tool",
+    tool: toolName,
+    callID: callId,
+    title: mapToolTitle2(toolName),
+    state: {
+      status: "running",
+      ...input === void 0 ? {} : { input },
+      output: null
+    },
+    time_created: timestampMs
+  };
+}
+function toolCallParts(message, timestampMs, ignoredToolCallIds) {
+  const calls = asArray(message.toolCalls) ?? [];
+  const parts = [];
+  for (const call of calls) {
+    const callRecord = asRecord(call);
+    const functionRecord = asRecord(callRecord?.function) ?? callRecord;
+    const toolName = asString(functionRecord?.name)?.trim() ?? "";
+    const callId = asString(callRecord?.id)?.trim() ?? "";
+    if (!toolName || !callId) continue;
+    if (KIMI_CODE_IGNORED_TOOLS.has(toolName)) {
+      ignoredToolCallIds.add(callId);
+      continue;
+    }
+    const rawArguments = functionRecord?.arguments ?? callRecord?.arguments;
+    parts.push(toolPart(toolName, callId, normalizeToolArguments2(rawArguments), timestampMs));
+  }
+  return parts;
+}
+function addToolResolution(builder, callId, output, timestampMs, isError = false, note) {
+  const outputParts = toolOutputParts(output, timestampMs);
+  return builder.resolveToolCall(callId, {
+    output: outputParts,
+    status: isError ? "error" : "completed",
+    ...note ? { metadata: { note: cleanInternalText(note) } } : {}
+  });
+}
+function usageNumber(usage, field) {
+  return asNumber(usage[field]) ?? 0;
+}
+function emptyStats() {
+  return {
+    message_count: 0,
+    total_input_tokens: 0,
+    total_output_tokens: 0,
+    total_cost: 0
+  };
+}
+function buildUsageTotals() {
+  return {
+    totalCost: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheReadTokens: 0,
+    totalCacheCreateTokens: 0,
+    modelUsage: {}
+  };
+}
+function applyUsage(builder, record, activeModel, totals) {
+  const usage = asRecord(record.usage);
+  if (!usage) return;
+  const cacheRead = usageNumber(usage, "inputCacheRead");
+  const cacheCreate = usageNumber(usage, "inputCacheCreation");
+  const inputOther = usageNumber(usage, "inputOther");
+  const output = usageNumber(usage, "output");
+  const input = inputOther + cacheRead + cacheCreate;
+  const model = asString(record.model) ?? activeModel;
+  const tokens = {
+    input,
+    output,
+    cache_read: cacheRead,
+    cache_create: cacheCreate
+  };
+  const cost = estimateTokenCost(model, tokens);
+  totals.totalInputTokens += input;
+  totals.totalOutputTokens += output;
+  totals.totalCacheReadTokens += cacheRead;
+  totals.totalCacheCreateTokens += cacheCreate;
+  if (model) totals.modelUsage[model] = (totals.modelUsage[model] ?? 0) + input + output;
+  if (cost !== null) totals.totalCost += cost;
+  builder.attachUsageToLatestAssistant(tokens, {
+    model,
+    cost: cost ?? void 0,
+    costSource: cost === null ? void 0 : "estimated"
+  });
+}
+function readState(stateFile) {
+  try {
+    return asRecord(JSON.parse(readFileSync4(stateFile, "utf-8"))) ?? null;
+  } catch {
+    return null;
+  }
+}
+var KimiCodeAgent = class extends FileSystemSessionSource {
+  name = "kimi-code";
+  displayName = "Kimi-Code";
+  basePath = null;
+  workDirBySessionPath = /* @__PURE__ */ new Map();
+  findBasePath() {
+    const sessionsPath = join9(resolveKimiCodeDataRoot(), "sessions");
+    return existsSync8(sessionsPath) ? sessionsPath : null;
+  }
+  getSessionWatchPlan() {
+    const dataRoot = resolveKimiCodeDataRoot();
+    return {
+      status: "supported",
+      targets: [
+        { root: dataRoot, path: join9(dataRoot, "sessions") },
+        { root: dataRoot, path: join9(dataRoot, "session_index.jsonl") }
+      ]
+    };
+  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    if (!this.basePath) return false;
+    try {
+      return this.listSessionDirs().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  loadSessionIndex() {
+    this.workDirBySessionPath.clear();
+    if (!this.basePath) return;
+    const indexPath = join9(dirname5(this.basePath), "session_index.jsonl");
+    if (!existsSync8(indexPath)) return;
+    for (const record of readJsonlFile(indexPath)) {
+      const sessionPath = asString(record.sessionDir);
+      const workDir = asString(record.workDir);
+      if (!sessionPath || !workDir) continue;
+      this.workDirBySessionPath.set(resolve(sessionPath), workDir);
+    }
+  }
+  listSessionDirs() {
+    if (!this.basePath) return [];
+    const dirs = [];
+    try {
+      for (const bucket of readdirSync5(this.basePath, { withFileTypes: true })) {
+        if (!bucket.isDirectory()) continue;
+        const bucketPath = join9(this.basePath, bucket.name);
+        for (const session of readdirSync5(bucketPath, { withFileTypes: true })) {
+          if (!session.isDirectory()) continue;
+          const sessionPath = join9(bucketPath, session.name);
+          if (existsSync8(join9(sessionPath, "state.json")) && existsSync8(join9(sessionPath, "agents", "main", "wire.jsonl"))) {
+            dirs.push(sessionPath);
+          }
+        }
+      }
+    } catch {
+      return dirs;
+    }
+    return dirs;
+  }
+  resolveSessionSourceResult(sessionDir) {
+    try {
+      const stateFile = join9(sessionDir, "state.json");
+      const wireFile = join9(sessionDir, "agents", "main", "wire.jsonl");
+      if (!existsSync8(stateFile) || !existsSync8(wireFile)) return skippedSession("missing wire");
+      const state = readState(stateFile);
+      if (!state) return skippedSession("malformed state");
+      const stateMtime = statSync5(stateFile).mtimeMs;
+      const wireMtime = statSync5(wireFile).mtimeMs;
+      const createdAt = parseTimestamp(state.createdAt) ?? parseTimestamp(state.created_at) ?? stateMtime;
+      const updatedAt = Math.max(
+        parseTimestamp(state.updatedAt) ?? parseTimestamp(state.updated_at) ?? createdAt,
+        wireMtime
+      );
+      const custom = asRecord(state.custom);
+      const workDir = asString(state.workDir) ?? asString(custom?.cwd) ?? this.workDirBySessionPath.get(resolve(sessionDir)) ?? "";
+      const explicitTitle = asString(state.title) ?? asString(state.customTitle) ?? "";
+      return parsedSession({
+        id: basename6(sessionDir),
+        sourcePath: sessionDir,
+        stateFile,
+        wireFile,
+        workDir,
+        createdAt,
+        updatedAt,
+        explicitTitle
+      });
+    } catch {
+      return skippedSession("malformed session");
+    }
+  }
+  sourceFingerprint(source) {
+    return JSON.stringify([
+      this.readFileMtimeMs(source.stateFile),
+      this.readFileMtimeMs(source.wireFile),
+      source.workDir
+    ]);
+  }
+  listSessionSources(options) {
+    if (!this.basePath) return [];
+    this.loadSessionIndex();
+    const refs = [];
+    for (const sessionDir of this.listSessionDirs()) {
+      const source = getParsedSession(this.resolveSessionSourceResult(sessionDir));
+      if (!source || !matchesScanWindow(source.createdAt, options)) continue;
+      refs.push({
+        sessionId: source.id,
+        sourcePath: source.sourcePath,
+        fingerprint: this.sourceFingerprint(source)
+      });
+    }
+    return refs;
+  }
+  checkForChanges(sinceTimestamp, cachedSessions) {
+    const result = super.checkForChanges(sinceTimestamp, cachedSessions);
+    const emptySessionIds = cachedSessions.filter((session) => !this.hasMessages(session)).map((session) => session.id);
+    if (emptySessionIds.length === 0) return result;
+    return {
+      ...result,
+      hasChanges: true,
+      changedIds: [.../* @__PURE__ */ new Set([...result.changedIds ?? [], ...emptySessionIds])]
+    };
+  }
+  filterCachedSessions(sessions) {
+    return this.removeEmptyCachedSessions(sessions);
+  }
+  incrementalScan(cachedSessions, changedIds, refs) {
+    const visibleSessions = this.removeEmptyCachedSessions(cachedSessions);
+    return super.incrementalScan(visibleSessions, changedIds, refs);
+  }
+  hasMessages(session) {
+    return session.stats.message_count > 0;
+  }
+  removeEmptyCachedSessions(sessions) {
+    return sessions.filter((session) => {
+      if (this.hasMessages(session)) return true;
+      this.sessionMetaMap.delete(session.id);
+      return false;
+    });
+  }
+  scanSessionSource(sourcePath) {
+    this.loadSessionIndex();
+    const source = getParsedSession(this.resolveSessionSourceResult(sourcePath));
+    if (!source) return null;
+    const parsed = this.parseWire(source);
+    const transcript = parsed.builder.finish(parsed.stats);
+    if (transcript.messages.length === 0) {
+      this.sessionMetaMap.delete(source.id);
+      return null;
+    }
+    const title = resolveSessionTitle(source.explicitTitle, parsed.firstUserTitle, null);
+    const meta = {
+      ...source,
+      title,
+      sourceMtimeMs: source.createdAt,
+      sourceFingerprint: this.sourceFingerprint(source)
+    };
+    this.sessionMetaMap.set(meta.id, meta);
+    return {
+      id: meta.id,
+      slug: `${this.name}/${meta.id}`,
+      title: meta.title,
+      directory: meta.workDir,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: transcript.stats,
+      ...Object.keys(parsed.modelUsage).length > 0 ? { model_usage: parsed.modelUsage } : {}
+    };
+  }
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) throw new Error(`Session not found: ${sessionId}`);
+    const parsed = this.parseWire(meta);
+    const transcript = parsed.builder.finish(parsed.stats);
+    return {
+      reference: { agentName: this.name, sessionId: meta.id },
+      id: meta.id,
+      title: meta.title,
+      slug: `${this.name}/${meta.id}`,
+      directory: meta.workDir,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: transcript.stats,
+      messages: transcript.messages
+    };
+  }
+  parseWire(source) {
+    const builder = new TranscriptBuilder();
+    const totals = buildUsageTotals();
+    const ignoredToolCallIds = /* @__PURE__ */ new Set();
+    let activeModel = null;
+    let activeProvider = null;
+    let firstUserTitle = null;
+    let sequence = 0;
+    for (const record of readJsonlFile(source.wireFile)) {
+      sequence += 1;
+      try {
+        const timestampMs = timestampFromRecord(record);
+        const recordType = asString(record.type) ?? "";
+        if (recordType === "llm.request") {
+          activeModel = asString(record.model) ?? activeModel;
+          activeProvider = asString(record.provider) ?? activeProvider;
+          continue;
+        }
+        if (recordType === "config.update") {
+          activeModel = asString(record.modelAlias) ?? activeModel;
+          continue;
+        }
+        if (recordType === "usage.record") {
+          applyUsage(builder, record, activeModel, totals);
+          continue;
+        }
+        if (recordType === "context.append_message") {
+          const message = asRecord(record.message);
+          if (!message) continue;
+          const role = asString(message.role) ?? "";
+          const messageTimestamp = timestampMs;
+          if (role === "user") {
+            const text = normalizeTitleText(contentText(message.content));
+            if (!firstUserTitle && text) firstUserTitle = text;
+          }
+          if (role === "tool") {
+            const callId = asString(message.toolCallId)?.trim() ?? "";
+            const output = message.content;
+            if (callId && ignoredToolCallIds.has(callId)) continue;
+            if (callId && addToolResolution(builder, callId, output, messageTimestamp)) continue;
+            const outputParts = toolOutputParts(output, messageTimestamp);
+            if (outputParts.length > 0) {
+              builder.appendMessage({
+                id: `wire-${sequence}`,
+                role: "tool",
+                timestampMs: messageTimestamp,
+                parts: outputParts
+              });
+            }
+            continue;
+          }
+          if (role !== "user" && role !== "assistant") continue;
+          const parts = [
+            ...contentParts(message.content, messageTimestamp),
+            ...role === "assistant" ? toolCallParts(message, messageTimestamp, ignoredToolCallIds) : []
+          ];
+          if (parts.length === 0) continue;
+          const allTools = parts.every((part) => part.type === "tool");
+          const input = {
+            id: `wire-${sequence}`,
+            role,
+            timestampMs: messageTimestamp,
+            parts,
+            ...role === "assistant" ? {
+              agent: this.name,
+              mode: allTools ? "tool" : void 0,
+              model: activeModel,
+              provider: activeProvider
+            } : {}
+          };
+          builder.appendMessage(input);
+          continue;
+        }
+        if (recordType === "context.append_loop_event") {
+          const event = asRecord(record.event);
+          if (!event) continue;
+          const eventType = asString(event.type) ?? "";
+          const metadata = {
+            id: `wire-${sequence}`,
+            timestampMs,
+            agent: this.name,
+            model: activeModel,
+            provider: activeProvider
+          };
+          if (eventType === "step.begin") {
+            builder.beginTurn();
+            continue;
+          }
+          if (eventType === "content.part") {
+            const part = asRecord(event.part);
+            if (!part) continue;
+            const parts = contentParts([part], timestampMs);
+            for (const contentPart of parts) {
+              if (contentPart.type === "tool") continue;
+              if (contentPart.type === "image" && builder.appendToCurrentAssistant(contentPart)) {
+                continue;
+              }
+              builder.appendAssistantPart(contentPart, metadata, { grouping: "current" });
+            }
+            continue;
+          }
+          if (eventType === "tool.call") {
+            const toolName = asString(event.name)?.trim() ?? "";
+            const callId = asString(event.toolCallId)?.trim() ?? "";
+            if (!toolName || !callId) continue;
+            if (KIMI_CODE_IGNORED_TOOLS.has(toolName)) {
+              ignoredToolCallIds.add(callId);
+              continue;
+            }
+            builder.appendToolCall(toolPart(toolName, callId, event.args, timestampMs), metadata, {
+              markModeAsTool: true,
+              target: "current"
+            });
+            continue;
+          }
+          if (eventType === "tool.result") {
+            const callId = asString(event.toolCallId)?.trim() ?? "";
+            const result = asRecord(event.result);
+            if (!callId || ignoredToolCallIds.has(callId)) continue;
+            const output = result?.output;
+            const isError = result?.isError === true;
+            const note = asString(result?.note);
+            if (addToolResolution(builder, callId, output, timestampMs, isError, note)) continue;
+            const outputParts = toolOutputParts(output, timestampMs);
+            if (outputParts.length > 0) {
+              builder.appendMessage({
+                id: `wire-${sequence}`,
+                role: "tool",
+                timestampMs,
+                parts: outputParts
+              });
+            }
+          }
+          continue;
+        }
+        if (recordType === "context.apply_compaction") {
+          const summary = cleanInternalText(asString(record.summary) ?? "");
+          if (summary) {
+            builder.appendMessage({
+              id: `wire-${sequence}`,
+              role: "user",
+              timestampMs,
+              parts: [{ type: "text", text: summary, time_created: timestampMs }]
+            });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    const stats = {
+      ...emptyStats(),
+      total_input_tokens: totals.totalInputTokens,
+      total_output_tokens: totals.totalOutputTokens,
+      total_cost: Number(totals.totalCost.toFixed(8)),
+      total_tokens: totals.totalInputTokens + totals.totalOutputTokens,
+      ...totals.totalCacheReadTokens > 0 ? { total_cache_read_tokens: totals.totalCacheReadTokens } : {},
+      ...totals.totalCacheCreateTokens > 0 ? { total_cache_create_tokens: totals.totalCacheCreateTokens } : {},
+      ...totals.totalCost > 0 ? { cost_source: "estimated" } : {}
+    };
+    return { builder, stats, firstUserTitle, modelUsage: totals.modelUsage };
+  }
+};
 var PARSE_FAIL = /* @__PURE__ */ Symbol("parse-fail");
 var EXEC_OUTPUT_ENVELOPE_RE = /^Script completed\nWall time [^\n]*\nOutput:\n?/;
 function stripExecOutputEnvelope(text) {
@@ -3314,7 +4539,7 @@ var PROPOSED_PLAN_PATTERN = /<proposed_plan>\s*([\s\S]*?)\s*<\/proposed_plan>/;
 var PLAN_APPROVAL_PREFIX = "PLEASE IMPLEMENT THIS PLAN";
 var SUBAGENT_NOTIFICATION_PATTERN = /<subagent_notification>\s*([\s\S]*?)\s*<\/subagent_notification>/;
 var HEAD_INDEX_VERSION2 = "codex-head-v1";
-var PARSER_VERSION = "codex-parser-v4";
+var PARSER_VERSION = "codex-parser-v6";
 function resolveCodexDataRoot() {
   return resolveHomePath("CODEX_HOME", ".codex");
 }
@@ -3337,7 +4562,7 @@ var CODEX_TOOL_TITLE_MAP = {
   subagent: "subagent"
 };
 function extractSessionId(filename) {
-  const stem = basename5(filename, ".jsonl");
+  const stem = basename7(filename, ".jsonl");
   const parts = stem.split("-");
   if (parts.length >= 5) {
     return parts.slice(-5).join("-");
@@ -3366,6 +4591,14 @@ function narrowRecordField(value, field) {
 function extractPayload(data) {
   return narrowRecordField(data["payload"], "payload") ?? {};
 }
+function extractThreadMeta(firstRecord) {
+  if (firstRecord["type"] !== "session_meta") return null;
+  const payload = extractPayload(firstRecord);
+  const threadSource = asString(payload["thread_source"]) ?? "";
+  const parentThreadId = asString(payload["parent_thread_id"]) ?? null;
+  const agentNickname = asString(payload["agent_nickname"]) ?? null;
+  return { threadSource, parentThreadId, agentNickname };
+}
 function extractTokenUsage(payload) {
   const info = narrowRecordField(payload["info"], "token_count.info");
   return {
@@ -3391,7 +4624,7 @@ function resolveToolIdentity(name, namespace) {
     metadata: { name, namespace: namespaceText }
   };
 }
-function normalizeToolArguments2(raw) {
+function normalizeToolArguments3(raw) {
   if (typeof raw === "string") {
     try {
       return JSON.parse(raw);
@@ -3418,6 +4651,16 @@ function flattenOutputText(output) {
   }
   return "";
 }
+function extractAssistantOutputText(payload) {
+  const content = payload["content"];
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      const record = asRecord(item);
+      return record && String(record["type"] ?? "") === "output_text" ? String(record["text"] ?? "") : "";
+    }).filter(Boolean).join("\n");
+  }
+  return "";
+}
 var PATCH_BEGIN_RE = /\*\*\* Begin Patch/;
 var PATCH_END_RE = /\*\*\* End Patch/;
 var PATCH_HEADER_RE = /\*\*\*\s+(Add|Delete|Update|Move)\s+File:\s*(.+)/;
@@ -3500,6 +4743,18 @@ function extractPatchContent(lines, startIndex) {
   }
   return { text: contentLines.join("\n"), nextLineIndex: i };
 }
+function compareSourceActivityDesc(left, right) {
+  const leftTimestamp = sourceTimestamp(left.file, left.stat.mtimeMs);
+  const rightTimestamp = sourceTimestamp(right.file, right.stat.mtimeMs);
+  return rightTimestamp - leftTimestamp || left.file.localeCompare(right.file);
+}
+function sourceTimestamp(filePath, fallback) {
+  const match = basename7(filePath).match(/^rollout-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})-/);
+  if (!match) return fallback;
+  const timestamp = match[1].replace(/-(\d{2})-(\d{2})$/, ":$1:$2");
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
 var CodexAgent = class extends SingleFileSessionSource {
   name = "codex";
   displayName = "Codex";
@@ -3507,17 +4762,19 @@ var CodexAgent = class extends SingleFileSessionSource {
   sessionIndexCache = /* @__PURE__ */ new Map();
   sessionIndexMtime;
   sessionIndexPath;
+  subagentIndex = null;
+  subagentStatsByParent = /* @__PURE__ */ new Map();
   // ---- BaseAgent implementation ----
   findBasePath() {
-    return firstExisting(join8(resolveCodexDataRoot(), "sessions"));
+    return firstExisting(join10(resolveCodexDataRoot(), "sessions"));
   }
   getSessionWatchPlan() {
     const dataRoot = resolveCodexDataRoot();
     return {
       status: "supported",
       targets: [
-        { path: join8(dataRoot, "sessions") },
-        { path: join8(dataRoot, "session_index.jsonl") }
+        { path: join10(dataRoot, "sessions") },
+        { path: join10(dataRoot, "session_index.jsonl") }
       ]
     };
   }
@@ -3529,16 +4786,119 @@ var CodexAgent = class extends SingleFileSessionSource {
   listSessionSources(options) {
     if (!this.basePath) return [];
     this.loadSessionIndex();
-    return this.listRolloutFiles(options).map(({ file, stat }) => ({
+    return this.listScanSources(options).map(({ file, stat }) => ({
       sessionId: extractSessionId(file),
       sourcePath: file,
       fingerprint: this.sourceFingerprint(file, stat)
     }));
   }
+  setSessionMetaMap(meta) {
+    super.setSessionMetaMap(meta);
+    this.subagentIndex = null;
+    this.subagentStatsByParent.clear();
+  }
+  /**
+   * A changed subagent file leaves its parent's aggregated token stats stale,
+   * so the parent must re-parse alongside the child.
+   */
+  expandChangedSessionIds(changedIds, refs) {
+    if (changedIds.length === 0) return changedIds;
+    const pathById = new Map((refs ?? []).map((ref) => [ref.sessionId, ref.sourcePath]));
+    const expanded = new Set(changedIds);
+    for (const id of changedIds) {
+      const sourcePath = pathById.get(id) ?? this.sessionMetaMap.get(id)?.sourcePath;
+      const threadMeta = sourcePath ? this.readThreadMeta(sourcePath) : null;
+      const parentId = threadMeta ? threadMeta.threadSource === "subagent" ? threadMeta.parentThreadId : null : this.sessionMetaMap.get(id)?.parentThreadId ?? null;
+      if (!parentId) continue;
+      expanded.add(parentId);
+      this.subagentIndex = null;
+      this.subagentStatsByParent.delete(parentId);
+    }
+    return [...expanded];
+  }
+  readThreadMeta(filePath) {
+    try {
+      const firstLine = this.readFilePrefix(filePath).split("\n").filter((l) => l.trim())[0];
+      if (!firstLine) return null;
+      return extractThreadMeta(JSON.parse(firstLine));
+    } catch {
+      return null;
+    }
+  }
+  parseTokenStats(filePath) {
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCost = 0;
+    let activeModel = null;
+    let prevCumulativeTotal = 0;
+    let prevInput = 0;
+    let prevOutput = 0;
+    let prevReasoning = 0;
+    let prevCachedInput = 0;
+    for (const line of readJsonlFileLines(filePath)) {
+      try {
+        const data = JSON.parse(line);
+        const recordType = String(data["type"] ?? "");
+        const payload = extractPayload(data);
+        if (recordType === "session_meta" || recordType === "turn_context") {
+          const nextModel = extractModelName(payload["model"]);
+          if (nextModel) activeModel = nextModel;
+          continue;
+        }
+        if (recordType === "event_msg" && String(payload["type"] ?? "") === "token_count") {
+          const { totalUsage, lastUsage } = extractTokenUsage(payload);
+          const cumulativeTotal = Number(totalUsage?.["total_tokens"] ?? 0);
+          if (cumulativeTotal <= 0 || cumulativeTotal === prevCumulativeTotal) continue;
+          prevCumulativeTotal = cumulativeTotal;
+          let inputTokens = 0;
+          let outputTokens = 0;
+          let reasoningTokens = 0;
+          let cacheReadTokens = 0;
+          if (lastUsage) {
+            inputTokens = Number(lastUsage["input_tokens"] ?? 0);
+            outputTokens = Number(lastUsage["output_tokens"] ?? 0);
+            reasoningTokens = Number(lastUsage["reasoning_output_tokens"] ?? 0);
+            cacheReadTokens = extractCachedInputTokens(lastUsage);
+          } else if (totalUsage) {
+            inputTokens = Number(totalUsage["input_tokens"] ?? 0) - prevInput;
+            outputTokens = Number(totalUsage["output_tokens"] ?? 0) - prevOutput;
+            reasoningTokens = Number(totalUsage["reasoning_output_tokens"] ?? 0) - prevReasoning;
+            cacheReadTokens = extractCachedInputTokens(totalUsage) - prevCachedInput;
+            prevInput = Number(totalUsage["input_tokens"] ?? 0);
+            prevOutput = Number(totalUsage["output_tokens"] ?? 0);
+            prevReasoning = Number(totalUsage["reasoning_output_tokens"] ?? 0);
+            prevCachedInput = extractCachedInputTokens(totalUsage);
+          }
+          const totalInput = Math.max(0, inputTokens);
+          const totalCacheRead = Math.max(0, cacheReadTokens);
+          totalInputTokens += totalInput;
+          totalOutputTokens += outputTokens + reasoningTokens;
+          totalCacheReadTokens += totalCacheRead;
+          totalCost += estimateTokenCost(activeModel, {
+            input: totalInput,
+            output: outputTokens,
+            reasoning: reasoningTokens || void 0,
+            cache_read: totalCacheRead || void 0
+          }) ?? 0;
+        }
+      } catch {
+      }
+    }
+    return {
+      message_count: 0,
+      total_input_tokens: totalInputTokens,
+      total_output_tokens: totalOutputTokens,
+      total_cache_read_tokens: totalCacheReadTokens || void 0,
+      total_cost: totalCost,
+      cost_source: totalCost > 0 ? "estimated" : void 0
+    };
+  }
   getSessionData(sessionId) {
     const meta = this.sessionMetaMap.get(sessionId);
     if (!meta) throw new Error(`Session not found: ${sessionId}`);
-    if (!existsSync7(meta.sourcePath)) throw new Error(`Session file missing: ${meta.sourcePath}`);
+    if (!existsSync9(meta.sourcePath)) throw new Error(`Session file missing: ${meta.sourcePath}`);
+    this.basePath ??= this.findBasePath();
     const transcript = new TranscriptBuilder();
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
@@ -3621,18 +4981,119 @@ var CodexAgent = class extends SingleFileSessionSource {
       total_cost: totalCost,
       cost_source: totalCost > 0 ? "estimated" : void 0
     });
+    this.applyChildStats(result.stats, meta.id);
+    const childMessages = this.collectChildMessages(meta.id);
+    for (const message of childMessages) {
+      const messageText = message.parts.find((part) => part.type === "text")?.text;
+      const alreadyVisible = result.messages.some(
+        (existing) => message.subagent_id !== void 0 && existing.subagent_id === message.subagent_id || existing.subagent_id === void 0 && message.nickname !== void 0 && messageText !== void 0 && existing.nickname === message.nickname && existing.parts.some((part) => part.type === "text" && part.text === messageText)
+      );
+      if (!alreadyVisible) result.messages.push(message);
+    }
+    result.stats.message_count = result.messages.length;
     return {
       reference: { agentName: this.name, sessionId: meta.id },
       id: meta.id,
       title: meta.title,
       slug: `codex/${meta.id}`,
       directory: meta.directory,
+      parent_reference: meta.parentThreadId == null ? void 0 : { agentName: this.name, sessionId: meta.parentThreadId },
       time_created: meta.createdAt,
       time_updated: meta.updatedAt,
       stats: result.stats,
       messages: result.messages
     };
   }
+  /**
+   * Builds the complete parent→children map in one prefix sweep. A cache miss
+   * afterwards means "no children", so per-session directory rescans (the old
+   * O(N²) finalization hotspot) never happen.
+   */
+  ensureSubagentIndex() {
+    if (this.subagentIndex) return this.subagentIndex;
+    this.basePath ??= this.findBasePath();
+    const index = { childFilesByParent: /* @__PURE__ */ new Map(), subagentFiles: /* @__PURE__ */ new Set() };
+    for (const file of this.listRolloutFilePaths()) {
+      const threadMeta = this.readThreadMeta(file);
+      if (threadMeta?.threadSource !== "subagent") continue;
+      index.subagentFiles.add(file);
+      if (!threadMeta.parentThreadId) continue;
+      const files = index.childFilesByParent.get(threadMeta.parentThreadId);
+      if (files) files.push(file);
+      else index.childFilesByParent.set(threadMeta.parentThreadId, [file]);
+    }
+    this.subagentIndex = index;
+    return index;
+  }
+  applyChildStats(target, sessionId) {
+    for (const stats of this.collectChildStats(sessionId)) {
+      target.total_input_tokens += stats.total_input_tokens ?? 0;
+      target.total_output_tokens += stats.total_output_tokens ?? 0;
+      target.total_cost += stats.total_cost ?? 0;
+      if (stats.total_cache_read_tokens) {
+        target.total_cache_read_tokens = (target.total_cache_read_tokens ?? 0) + stats.total_cache_read_tokens;
+      }
+    }
+  }
+  collectChildStats(parentSessionId) {
+    const files = this.collectChildFiles(parentSessionId);
+    if (files.length === 0) return [];
+    const cached = this.subagentStatsByParent.get(parentSessionId);
+    if (cached) return cached;
+    const stats = files.map((file) => this.parseTokenStats(file));
+    this.subagentStatsByParent.set(parentSessionId, stats);
+    return stats;
+  }
+  collectChildFiles(parentSessionId) {
+    return this.ensureSubagentIndex().childFilesByParent.get(parentSessionId) ?? [];
+  }
+  collectChildMessages(parentSessionId) {
+    return this.collectChildFiles(parentSessionId).flatMap((file) => {
+      const message = this.parseChildFinalMessage(file);
+      return message ? [message] : [];
+    }).sort((left, right) => left.time_created - right.time_created);
+  }
+  parseChildFinalMessage(filePath) {
+    const sessionId = extractSessionId(filePath);
+    const threadMeta = this.readThreadMeta(filePath);
+    let latestOutput = null;
+    let finalOutput = null;
+    for (const record of readJsonlFile(filePath)) {
+      try {
+        const recordType = String(record["type"] ?? "");
+        if (recordType !== "response_item") continue;
+        const payload = extractPayload(record);
+        if (String(payload["type"] ?? "") !== "message") continue;
+        if (String(payload["role"] ?? "") !== "assistant") continue;
+        const text = cleanInternalText(extractAssistantOutputText(payload));
+        if (!text) continue;
+        const candidate = {
+          id: asString(payload["id"]) ?? `codex-subagent-${sessionId}`,
+          text,
+          timestampMs: parseTimestampMs2(record) || parseTimestampMs2(payload) || statSync6(filePath).mtimeMs,
+          isFinal: String(record["phase"] ?? "") === "final_answer" || String(payload["phase"] ?? "") === "final_answer"
+        };
+        latestOutput = candidate;
+        if (candidate.isFinal) finalOutput = candidate;
+      } catch {
+      }
+    }
+    const selected = finalOutput ?? latestOutput;
+    if (!selected) return null;
+    return {
+      id: selected.id,
+      role: "assistant",
+      agent: "codex",
+      time_created: selected.timestampMs,
+      mode: null,
+      model: null,
+      provider: null,
+      cost: 0,
+      subagent_id: sessionId,
+      nickname: threadMeta?.agentNickname ?? void 0,
+      parts: [{ type: "text", text: selected.text, time_created: selected.timestampMs }]
+    };
+  }
   // ---- File listing ----
   listRolloutFiles(options) {
     if (!this.basePath) return [];
@@ -3642,6 +5103,54 @@ var CodexAgent = class extends SingleFileSessionSource {
       { scanWindow: options }
     );
   }
+  /** Path-only listing for the subagent index: no per-file stat needed. */
+  listRolloutFilePaths() {
+    if (!this.basePath) return [];
+    const paths = [];
+    const walk = (directory) => {
+      let entries;
+      try {
+        entries = readdirSync6(directory, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        const filePath = join10(directory, entry.name);
+        if (entry.isDirectory()) walk(filePath);
+        else if (entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl")) {
+          paths.push(filePath);
+        }
+      }
+    };
+    walk(this.basePath);
+    return paths;
+  }
+  listScanSources(options) {
+    const windowed = this.listRolloutFiles(options).sort(compareSourceActivityDesc);
+    if (options?.from == null && options?.to == null) return windowed;
+    const { childFilesByParent, subagentFiles } = this.ensureSubagentIndex();
+    const rootFiles = windowed.filter((source) => !subagentFiles.has(source.file));
+    const rootIds = new Set(rootFiles.map(({ file }) => extractSessionId(file)));
+    if (rootIds.size === 0) return rootFiles;
+    const selected = new Map(rootFiles.map((source) => [source.file, source]));
+    const pending2 = [...rootIds];
+    const seenParents = /* @__PURE__ */ new Set();
+    while (pending2.length > 0) {
+      const parentId = pending2.pop();
+      if (seenParents.has(parentId)) continue;
+      seenParents.add(parentId);
+      for (const file of childFilesByParent.get(parentId) ?? []) {
+        if (selected.has(file)) continue;
+        try {
+          selected.set(file, this.sessionSourceFile(file));
+        } catch {
+          continue;
+        }
+        pending2.push(extractSessionId(file));
+      }
+    }
+    return [...selected.values()].sort(compareSourceActivityDesc);
+  }
   createFileSessionMeta(head, source) {
     const indexPath = this.getSessionIndexPath();
     const indexMtime = this.sessionIndexMtime ?? null;
@@ -3654,7 +5163,8 @@ var CodexAgent = class extends SingleFileSessionSource {
         indexMtimeMs: indexMtime,
         headIndexVersion: HEAD_INDEX_VERSION2,
         parserVersion: PARSER_VERSION,
-        model: null
+        model: null,
+        parentThreadId: head.parent_reference?.sessionId ?? null
       }
     });
   }
@@ -3670,7 +5180,7 @@ var CodexAgent = class extends SingleFileSessionSource {
     ]);
   }
   getSessionIndexPath() {
-    this.sessionIndexPath ??= join8(resolveCodexDataRoot(), "session_index.jsonl");
+    this.sessionIndexPath ??= join10(resolveCodexDataRoot(), "session_index.jsonl");
     return this.sessionIndexPath;
   }
   // ---- Session index ----
@@ -3684,7 +5194,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       return;
     }
     try {
-      const content = readFileSync4(indexPath, "utf-8");
+      const content = readFileSync5(indexPath, "utf-8");
       const cache = /* @__PURE__ */ new Map();
       for (const record of parseJsonlLines(content)) {
         const sid = String(record["id"] ?? "").trim();
@@ -3716,7 +5226,9 @@ var CodexAgent = class extends SingleFileSessionSource {
   }
   parseFileSessionHead(filePath, options) {
     this.loadSessionIndex();
-    return this.parseSessionHead(filePath, options);
+    const head = this.parseSessionHead(filePath, options);
+    if (head) this.applyChildStats(head.stats, head.id);
+    return head;
   }
   parseSessionHead(filePath, options) {
     return getParsedSession(this.parseSessionHeadResult(filePath, options));
@@ -3727,6 +5239,7 @@ var CodexAgent = class extends SingleFileSessionSource {
     }
     const sessionId = extractSessionId(filePath);
     let firstPayload = {};
+    let parentThreadId = null;
     let createdAt = 0;
     let lineCount = 0;
     let messageTitle = null;
@@ -3756,7 +5269,9 @@ var CodexAgent = class extends SingleFileSessionSource {
           return skippedSession("malformed first record");
         }
         firstPayload = extractPayload(firstRecord);
-        createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(firstPayload) || statSync4(filePath).mtimeMs;
+        const threadMeta = extractThreadMeta(firstRecord);
+        parentThreadId = threadMeta?.threadSource === "subagent" ? threadMeta.parentThreadId : null;
+        createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(firstPayload) || statSync6(filePath).mtimeMs;
         updatedAt = createdAt;
       }
       try {
@@ -3850,6 +5365,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       slug: `codex/${sessionId}`,
       title,
       directory,
+      parent_reference: parentThreadId == null ? void 0 : { agentName: this.name, sessionId: parentThreadId },
       time_created: createdAt,
       time_updated: updatedAt,
       stats: {
@@ -3863,9 +5379,6 @@ var CodexAgent = class extends SingleFileSessionSource {
       model_usage: Object.keys(modelUsageMap).length > 0 ? modelUsageMap : void 0
     });
   }
-  parseFastSessionHead(filePath) {
-    return getParsedSession(this.parseFastSessionHeadResult(filePath));
-  }
   parseFastSessionHeadResult(filePath) {
     const prefix = this.readFilePrefix(filePath);
     const lines = prefix.split("\n").filter((l) => l.trim());
@@ -3877,8 +5390,10 @@ var CodexAgent = class extends SingleFileSessionSource {
     } catch {
       return skippedSession("malformed first record");
     }
+    const threadMeta = extractThreadMeta(firstRecord);
+    const parentThreadId = threadMeta?.threadSource === "subagent" ? threadMeta.parentThreadId : null;
     const payload = extractPayload(firstRecord);
-    const stat = statSync4(filePath);
+    const stat = statSync6(filePath);
     const createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(payload) || stat.mtimeMs;
     const indexTitle = this.getTitleForSession(sessionId);
     const messageTitle = this.extractTitleFromLines(lines);
@@ -3890,6 +5405,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       slug: `codex/${sessionId}`,
       title,
       directory,
+      parent_reference: parentThreadId == null ? void 0 : { agentName: this.name, sessionId: parentThreadId },
       time_created: createdAt,
       time_updated: stat.mtimeMs,
       stats: {
@@ -3985,19 +5501,8 @@ var CodexAgent = class extends SingleFileSessionSource {
   }
   // ---- Assistant message ----
   convertAssistantMessage(payload, transcript, timestampMs, pendingPlan, activeModel) {
-    const content = payload["content"];
-    if (!Array.isArray(content)) return pendingPlan;
-    const textParts = [];
-    for (const item of content) {
-      const ci = asRecord(item);
-      if (!ci) continue;
-      if (String(ci["type"] ?? "") === "output_text") {
-        const text = String(ci["text"] ?? "");
-        if (text.trim()) textParts.push(text);
-      }
-    }
-    if (textParts.length === 0) return pendingPlan;
-    const fullText = textParts.join("\n");
+    const fullText = extractAssistantOutputText(payload);
+    if (!fullText) return pendingPlan;
     const planMatch = fullText.match(PROPOSED_PLAN_PATTERN);
     if (planMatch) {
       const planText2 = planMatch[1].trim();
@@ -4112,8 +5617,8 @@ var CodexAgent = class extends SingleFileSessionSource {
     const name = String(payload["name"] ?? "").trim();
     if (!name) return;
     const toolIdentity = resolveToolIdentity(name, payload["namespace"]);
-    const arguments_ = normalizeToolArguments2(payload["arguments"]);
-    const toolPart = {
+    const arguments_ = normalizeToolArguments3(payload["arguments"]);
+    const toolPart2 = {
       type: "tool",
       tool: toolIdentity.tool,
       callID: callId,
@@ -4127,7 +5632,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4159,7 +5664,7 @@ var CodexAgent = class extends SingleFileSessionSource {
     const toolIdentity = resolveToolIdentity(name, payload["namespace"]);
     const rawInput = payload["input"];
     const normalizedInput = normalizeCustomToolArguments(name, rawInput);
-    const toolPart = {
+    const toolPart2 = {
       type: "tool",
       tool: toolIdentity.tool,
       callID: callId,
@@ -4173,7 +5678,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4190,7 +5695,7 @@ var CodexAgent = class extends SingleFileSessionSource {
     const { name, namespace } = splitExecToolName(call.name);
     const toolIdentity = resolveToolIdentity(name, namespace);
     const arguments_ = name === "apply_patch" ? parseApplyPatchInput(getExecPatchText(call.args)) : call.args;
-    const toolPart = {
+    const toolPart2 = {
       type: "tool",
       tool: toolIdentity.tool,
       callID: callId,
@@ -4204,7 +5709,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4289,15 +5794,15 @@ function resolveCursorDataRoot() {
   if (override) return override;
   const currentPlatform = platform2();
   if (currentPlatform === "darwin") {
-    return firstExisting(join9(homedir3(), "Library", "Application Support", "Cursor", "User"));
+    return firstExisting(join11(homedir3(), "Library", "Application Support", "Cursor", "User"));
   }
   if (currentPlatform === "linux") {
-    const configRoot = readEnvPath("XDG_CONFIG_HOME") ?? join9(homedir3(), ".config");
-    return firstExisting(join9(configRoot, "Cursor", "User"));
+    const configRoot = readEnvPath("XDG_CONFIG_HOME") ?? join11(homedir3(), ".config");
+    return firstExisting(join11(configRoot, "Cursor", "User"));
   }
   if (currentPlatform === "win32") {
-    const appData = readEnvPath("APPDATA") ?? join9(homedir3(), "AppData", "Roaming");
-    return firstExisting(join9(appData, "Cursor", "User"));
+    const appData = readEnvPath("APPDATA") ?? join11(homedir3(), "AppData", "Roaming");
+    return firstExisting(join11(appData, "Cursor", "User"));
   }
   return null;
 }
@@ -4358,6 +5863,24 @@ function parseComposerRow(value) {
     chatMessages: parseChatMessages(record.chatMessages)
   };
 }
+function composerIdFromBubbleKey(key) {
+  const start = key.indexOf(":") + 1;
+  const end = key.indexOf(":", start);
+  return end === -1 ? key.slice(start) : key.slice(start, end);
+}
+function groupBubbleRows(rows) {
+  const byKey = [];
+  for (const row of rows) {
+    const bubble = parseBubbleRow(row.value);
+    if (bubble) byKey.push({ rowId: row.row_id, key: row.key, bubble });
+  }
+  byKey.sort((left, right) => left.key.localeCompare(right.key));
+  return {
+    composerId: rows.length > 0 ? composerIdFromBubbleKey(rows[0].key) : "",
+    byKey,
+    byRowId: [...byKey].sort((left, right) => left.rowId - right.rowId)
+  };
+}
 function parseBubbleRow(value) {
   const record = safeParseJsonRecord(value);
   if (!record) return null;
@@ -4408,7 +5931,7 @@ var CURSOR_TOOL_TITLE_MAP = {
   ripgrep_raw_search: "grep",
   glob_file_search: "glob"
 };
-function mapToolTitle2(toolName) {
+function mapToolTitle3(toolName) {
   return CURSOR_TOOL_TITLE_MAP[toolName] ?? toolName;
 }
 function normalizeToolOutputParts2(output, timestampMs) {
@@ -4469,9 +5992,9 @@ function buildToolPart(action, timestampMs) {
   const toolName = action.tool ?? "unknown";
   return {
     type: "tool",
-    tool: mapToolTitle2(toolName),
+    tool: mapToolTitle3(toolName),
     callID: action.type ? `${action.type}:${String(action.input?.id ?? "")}` : "",
-    title: `Tool: ${mapToolTitle2(toolName)}`,
+    title: `Tool: ${mapToolTitle3(toolName)}`,
     state: buildToolState(action),
     time_created: timestampMs
   };
@@ -4517,7 +6040,7 @@ var CursorAgent = class extends DatabaseSessionSource {
     if (!isSqliteAvailable()) return null;
     const dataPath = resolveCursorDataRoot();
     if (!dataPath) return null;
-    return join9(dataPath, "globalStorage", "state.vscdb");
+    return join11(dataPath, "globalStorage", "state.vscdb");
   }
   getSessionWatchPlan() {
     const dataPath = resolveCursorDataRoot();
@@ -4526,9 +6049,9 @@ var CursorAgent = class extends DatabaseSessionSource {
       targets: dataPath ? [
         {
           root: dataPath,
-          path: join9(dataPath, "globalStorage", "state.vscdb")
+          path: join11(dataPath, "globalStorage", "state.vscdb")
         },
-        { root: dataPath, path: join9(dataPath, "workspaceStorage") }
+        { root: dataPath, path: join11(dataPath, "workspaceStorage") }
       ] : []
     };
   }
@@ -4540,34 +6063,34 @@ var CursorAgent = class extends DatabaseSessionSource {
     const map = /* @__PURE__ */ new Map();
     const dataPath = resolveCursorDataRoot();
     if (!dataPath) return map;
-    const wsStoragePath = join9(dataPath, "workspaceStorage");
-    if (!existsSync8(wsStoragePath)) return map;
+    const wsStoragePath = join11(dataPath, "workspaceStorage");
+    if (!existsSync10(wsStoragePath)) return map;
     let entryNames;
     try {
-      entryNames = readdirSync4(wsStoragePath);
+      entryNames = readdirSync7(wsStoragePath);
     } catch {
       return map;
     }
     for (const name of entryNames) {
-      const wsDir = join9(wsStoragePath, name);
+      const wsDir = join11(wsStoragePath, name);
       try {
-        if (!statSync5(wsDir).isDirectory()) continue;
+        if (!statSync7(wsDir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const wsJsonPath = join9(wsDir, "workspace.json");
-      if (!existsSync8(wsJsonPath)) continue;
+      const wsJsonPath = join11(wsDir, "workspace.json");
+      if (!existsSync10(wsJsonPath)) continue;
       let workspacePath;
       try {
-        const data = asRecord(JSON.parse(readFileSync5(wsJsonPath, "utf-8")));
+        const data = asRecord(JSON.parse(readFileSync6(wsJsonPath, "utf-8")));
         const uri = narrowString("workspaceJson.folder", data?.folder) ?? narrowString("workspaceJson.workspace", data?.workspace) ?? "";
         if (!uri) continue;
         workspacePath = normalize(decodeURIComponent(uri.replace(/^file:\/\//, "")));
       } catch {
         continue;
       }
-      const wsDbPath = join9(wsDir, "state.vscdb");
-      if (!existsSync8(wsDbPath)) continue;
+      const wsDbPath = join11(wsDir, "state.vscdb");
+      if (!existsSync10(wsDbPath)) continue;
       const wsDb = openDbReadOnly(wsDbPath);
       if (!wsDb) continue;
       try {
@@ -4590,7 +6113,7 @@ var CursorAgent = class extends DatabaseSessionSource {
   }
   isAvailable() {
     this.dbPath = this.findDbPath();
-    return this.dbPath !== null && existsSync8(this.dbPath);
+    return this.dbPath !== null && existsSync10(this.dbPath);
   }
   scan(options) {
     if (!this.dbPath) return [];
@@ -4598,13 +6121,15 @@ var CursorAgent = class extends DatabaseSessionSource {
     const dbMarker = perf.start("openDatabase");
     const db = this.openDatabase();
     perf.end(dbMarker);
-    if (!db) return [];
+    if (!db) throw new SessionScanError(this.name, "opening the database");
     const wsMarker = perf.start("buildWorkspacePathMap");
     const workspacePathMap = this.buildWorkspacePathMap();
     perf.end(wsMarker);
     try {
       const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'").all();
-      const heads = [];
+      const emitted = /* @__PURE__ */ new Map();
+      const pending2 = [];
+      let order = 0;
       options?.onProgress?.({ total: rows.length, processed: 0, sessions: 0 });
       let processed = 0;
       for (const row of rows) {
@@ -4620,8 +6145,8 @@ var CursorAgent = class extends DatabaseSessionSource {
           const fastMessageCount = composer.chatMessages?.length ?? 0;
           const hasSubagents = Array.isArray(composer.subagentInfos) && composer.subagentInfos.length > 0;
           if (options?.fast) {
-            const directory2 = workspacePathMap.get(composerId) ?? "";
-            const totalCost2 = estimateTokenCost(composer.modelConfig?.modelName ?? composer.model, {
+            const directory = workspacePathMap.get(composerId) ?? "";
+            const totalCost = estimateTokenCost(composer.modelConfig?.modelName ?? composer.model, {
               input: composer.inputTokenCount ?? 0,
               output: composer.outputTokenCount ?? 0
             }) ?? 0;
@@ -4630,20 +6155,21 @@ var CursorAgent = class extends DatabaseSessionSource {
                 id: composerId,
                 slug: `cursor/${composerId}`,
                 title: fastTitle,
-                directory: directory2,
+                directory,
                 time_created: createdAt,
                 time_updated: updatedAt || void 0,
                 stats: {
                   message_count: fastMessageCount,
                   total_input_tokens: composer.inputTokenCount ?? 0,
                   total_output_tokens: composer.outputTokenCount ?? 0,
-                  total_cost: totalCost2,
-                  cost_source: totalCost2 > 0 ? "estimated" : void 0
+                  total_cost: totalCost,
+                  cost_source: totalCost > 0 ? "estimated" : void 0
                 }
               })
             );
             if (!head) continue;
-            heads.push(head);
+            emitted.set(order, head);
+            order += 1;
             this.composerCache.set(composerId, composer);
             this.sessionMetaMap.set(composerId, {
               id: composerId,
@@ -4651,74 +6177,38 @@ var CursorAgent = class extends DatabaseSessionSource {
             });
             continue;
           }
-          const requestId = this.extractRequestIdFromBubbles(db, composerId);
-          const sessionId = requestId || composerId;
-          const parsedMessages = cleanParsedMessages(
-            this.loadMessagesFromBubbles(
-              db,
-              composerId,
-              sessionId,
-              composer.modelConfig?.modelName ?? composer.model ?? null
-            )
-          );
-          const messages = getParsedSession(
-            parsedMessages.length === 0 && !hasSubagents ? filteredSession("no visible messages") : parsedSession(parsedMessages)
-          );
-          if (!messages) continue;
-          const messageCount = messages.length;
-          const title = this.extractTitle(composer, messages);
-          const directory = workspacePathMap.get(composerId) ?? "";
-          const modelUsageMap = {};
-          let totalCost = 0;
-          for (const msg of messages) {
-            totalCost += msg.cost ?? 0;
-            if (msg.model) {
-              const msgTokens = (msg.tokens?.input ?? 0) + (msg.tokens?.output ?? 0);
-              if (msgTokens > 0) {
-                modelUsageMap[msg.model] = (modelUsageMap[msg.model] ?? 0) + msgTokens;
-              }
-            }
-          }
-          const hasModelUsage = Object.keys(modelUsageMap).length > 0;
-          heads.push({
-            id: sessionId,
-            slug: `cursor/${sessionId}`,
-            title,
-            directory,
-            time_created: createdAt,
-            time_updated: updatedAt || void 0,
-            stats: {
-              message_count: messageCount,
-              total_input_tokens: composer.inputTokenCount ?? 0,
-              total_output_tokens: composer.outputTokenCount ?? 0,
-              total_cost: totalCost,
-              cost_source: totalCost > 0 ? "estimated" : void 0
-            },
-            model_usage: hasModelUsage ? modelUsageMap : void 0
-          });
-          this.composerCache.set(sessionId, composer);
-          this.composerCache.set(`__mapping__${composerId}`, {
-            sessionId
-          });
-          if (directory) {
-            this.composerCache.set(`__dir__${composerId}`, {
-              directory
-            });
-          }
-          this.sessionMetaMap.set(sessionId, {
-            id: sessionId,
-            sourcePath: this.dbPath || ""
-          });
+          pending2.push({ composer, composerId, createdAt, updatedAt, hasSubagents, order });
+          order += 1;
         } catch {
         } finally {
           processed += 1;
-          options?.onProgress?.({ total: rows.length, processed, sessions: heads.length });
+          options?.onProgress?.({ total: rows.length, processed, sessions: emitted.size });
         }
       }
+      const bubbleMarker = perf.start("cursor:bubbles");
+      const wanted = new Map(pending2.map((entry) => [entry.composerId, entry]));
+      this.forEachComposerBubbles(db, wanted, (bubbles) => {
+        const entry = wanted.get(bubbles.composerId);
+        if (!entry) return;
+        wanted.delete(bubbles.composerId);
+        const head = this.buildScanHead(entry, bubbles, workspacePathMap);
+        if (head) emitted.set(entry.order, head);
+      });
+      for (const entry of wanted.values()) {
+        const head = this.buildScanHead(
+          entry,
+          { composerId: entry.composerId, byKey: [], byRowId: [] },
+          workspacePathMap
+        );
+        if (head) emitted.set(entry.order, head);
+      }
+      perf.end(bubbleMarker);
+      const heads = [...emitted.entries()].sort(([left], [right]) => left - right).map(([, head]) => head);
+      options?.onProgress?.({ total: rows.length, processed, sessions: heads.length });
       perf.end(scanMarker);
       return heads;
-    } catch {
-      return [];
+    } catch (error) {
+      throw new SessionScanError(this.name, "reading composers", { cause: error });
     } finally {
       db.close();
     }
@@ -4806,20 +6296,90 @@ var CursorAgent = class extends DatabaseSessionSource {
     if (!this.dbPath) return null;
     return openDbReadOnly(this.dbPath);
   }
-  /** Extract requestId from bubbles for a composer (like agent-dump) */
-  extractRequestIdFromBubbles(db, composerId) {
-    try {
-      const rows = db.prepare("SELECT value FROM cursorDiskKV WHERE key LIKE ? ORDER BY key").all(`bubbleId:${composerId}:%`);
-      for (const row of rows) {
-        try {
-          const bubble = parseBubbleRow(row.value);
-          if (bubble?.requestId?.trim()) {
-            return bubble.requestId.trim();
-          }
-        } catch {
+  /**
+   * Streams every bubble row once, in key order, handing each composer's group
+   * to the caller. A key-ordered scan keeps a composer's bubbles contiguous, so
+   * only one group is materialized at a time.
+   */
+  forEachComposerBubbles(db, wanted, onGroup) {
+    if (wanted.size === 0) return;
+    let currentId = null;
+    let group = [];
+    const flush = () => {
+      if (currentId != null && group.length > 0) onGroup(groupBubbleRows(group));
+      group = [];
+    };
+    const rows = db.prepare(
+      "SELECT rowid AS row_id, key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' ORDER BY key"
+    ).iterate();
+    for (const row of rows) {
+      const composerId = composerIdFromBubbleKey(row.key);
+      if (composerId !== currentId) {
+        flush();
+        currentId = composerId;
+      }
+      if (wanted.has(composerId)) group.push(row);
+    }
+    flush();
+  }
+  /** Builds the head for one composer from bubbles that were parsed once. */
+  buildScanHead(entry, bubbles, workspacePathMap) {
+    const { composer, composerId, createdAt, updatedAt, hasSubagents } = entry;
+    const requestId = this.requestIdFromBubbles(bubbles);
+    const sessionId = requestId || composerId;
+    const parsedMessages = cleanParsedMessages(
+      this.messagesFromBubbles(bubbles, composer.modelConfig?.modelName ?? composer.model ?? null)
+    );
+    const messages = getParsedSession(
+      parsedMessages.length === 0 && !hasSubagents ? filteredSession("no visible messages") : parsedSession(parsedMessages)
+    );
+    if (!messages) return null;
+    const title = this.extractTitle(composer, messages);
+    const directory = workspacePathMap.get(composerId) ?? "";
+    const modelUsageMap = {};
+    let totalCost = 0;
+    for (const msg of messages) {
+      totalCost += msg.cost ?? 0;
+      if (msg.model) {
+        const msgTokens = (msg.tokens?.input ?? 0) + (msg.tokens?.output ?? 0);
+        if (msgTokens > 0) {
+          modelUsageMap[msg.model] = (modelUsageMap[msg.model] ?? 0) + msgTokens;
         }
       }
-    } catch {
+    }
+    const hasModelUsage = Object.keys(modelUsageMap).length > 0;
+    this.composerCache.set(sessionId, composer);
+    this.composerCache.set(`__mapping__${composerId}`, {
+      sessionId
+    });
+    if (directory) {
+      this.composerCache.set(`__dir__${composerId}`, {
+        directory
+      });
+    }
+    this.sessionMetaMap.set(sessionId, { id: sessionId, sourcePath: this.dbPath || "" });
+    return {
+      id: sessionId,
+      slug: `cursor/${sessionId}`,
+      title,
+      directory,
+      time_created: createdAt,
+      time_updated: updatedAt || void 0,
+      stats: {
+        message_count: messages.length,
+        total_input_tokens: composer.inputTokenCount ?? 0,
+        total_output_tokens: composer.outputTokenCount ?? 0,
+        total_cost: totalCost,
+        cost_source: totalCost > 0 ? "estimated" : void 0
+      },
+      model_usage: hasModelUsage ? modelUsageMap : void 0
+    };
+  }
+  /** First request id in key order, matching what agent-dump reports. */
+  requestIdFromBubbles(bubbles) {
+    for (const entry of bubbles.byKey) {
+      const requestId = entry.bubble.requestId?.trim();
+      if (requestId) return requestId;
     }
     return null;
   }
@@ -4868,18 +6428,26 @@ var CursorAgent = class extends DatabaseSessionSource {
       return 0;
     }
   }
-  /** Load messages from bubbles (like agent-dump) */
+  /** Load one composer's bubbles, for the detail path that only needs a single session. */
   loadMessagesFromBubbles(db, composerId, _sessionId, initialModelName) {
-    const messages = [];
     try {
-      const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE ? ORDER BY rowid ASC").all(`bubbleId:${composerId}:%`);
+      const rows = db.prepare("SELECT rowid AS row_id, key, value FROM cursorDiskKV WHERE key LIKE ?").all(`bubbleId:${composerId}:%`);
+      return this.messagesFromBubbles(groupBubbleRows(rows), initialModelName);
+    } catch {
+      return [];
+    }
+  }
+  /** Build messages from bubbles already parsed once, in insertion order. */
+  messagesFromBubbles(bubbles, initialModelName) {
+    const messages = [];
+    {
       let activeModelName = initialModelName;
       let messageIndex = 0;
-      for (const row of rows) {
-        try {
-          const bubble = parseBubbleRow(row.value);
-          if (!bubble || isInternalBubble(bubble)) continue;
-          const bubbleId = row.key.split(":").pop() || String(messageIndex);
+      for (const entry of bubbles.byRowId) {
+        {
+          const bubble = entry.bubble;
+          if (isInternalBubble(bubble)) continue;
+          const bubbleId = entry.key.split(":").pop() || String(messageIndex);
           const role = bubble.type === 2 ? "assistant" : "user";
           let timestampMs = 0;
           if (bubble.timingInfo?.clientRpcSendTime) {
@@ -4900,9 +6468,9 @@ var CursorAgent = class extends DatabaseSessionSource {
             parts.push({ type: "text", text, time_created: timestampMs });
           }
           if (bubble.toolFormerData) {
-            const toolPart = this.convertToolFormerData(bubble.toolFormerData, timestampMs);
-            if (toolPart) {
-              parts.push(toolPart);
+            const toolPart2 = this.convertToolFormerData(bubble.toolFormerData, timestampMs);
+            if (toolPart2) {
+              parts.push(toolPart2);
             }
           }
           if (parts.length === 0) continue;
@@ -4910,7 +6478,7 @@ var CursorAgent = class extends DatabaseSessionSource {
           const tokens = { input: inputTokens, output: outputTokens };
           const cost = estimateTokenCost(modelName, tokens);
           messages.push({
-            id: `cursor-${composerId}-${bubbleId}`,
+            id: `cursor-${bubbles.composerId}-${bubbleId}`,
             role,
             agent: "cursor",
             time_created: timestampMs,
@@ -4924,10 +6492,8 @@ var CursorAgent = class extends DatabaseSessionSource {
             parts
           });
           messageIndex++;
-        } catch {
         }
       }
-    } catch {
     }
     return messages;
   }
@@ -4935,7 +6501,7 @@ var CursorAgent = class extends DatabaseSessionSource {
   convertToolFormerData(toolData, timestampMs) {
     if (!toolData || !toolData.name) return null;
     const toolName = toolData.name;
-    const normalizedName = toolName === "create_plan" ? "plan" : mapToolTitle2(toolName);
+    const normalizedName = toolName === "create_plan" ? "plan" : mapToolTitle3(toolName);
     const state = {
       status: toolData.status === "completed" ? "completed" : "running"
     };
@@ -5063,7 +6629,7 @@ function narrowTimestampMs(field, value) {
   return shaped === void 0 ? 0 : parseTimestampMs3(shaped);
 }
 function extractSessionIdFromFilename(filePath) {
-  const stem = basename6(filePath, ".jsonl");
+  const stem = basename8(filePath, ".jsonl");
   const underscore = stem.indexOf("_");
   return underscore >= 0 ? stem.slice(underscore + 1) || stem : stem;
 }
@@ -5119,14 +6685,14 @@ var PiAgent = class extends SingleFileSessionSource {
   displayName = "Pi";
   basePath = null;
   findBasePath() {
-    return firstExisting(join10(resolvePiDataRoot(), "agent", "sessions"), "data/pi");
+    return firstExisting(join12(resolvePiDataRoot(), "agent", "sessions"), "data/pi");
   }
   getSessionWatchPlan() {
     const dataRoot = resolvePiDataRoot();
     return {
       status: "supported",
       targets: [
-        { root: dataRoot, path: join10(dataRoot, "agent", "sessions") },
+        { root: dataRoot, path: join12(dataRoot, "agent", "sessions") },
         { root: "data/pi", path: "data/pi" }
       ]
     };
@@ -5147,7 +6713,7 @@ var PiAgent = class extends SingleFileSessionSource {
   getSessionData(sessionId) {
     const meta = this.sessionMetaMap.get(sessionId);
     if (!meta) throw new Error(`Session not found: ${sessionId}`);
-    if (!existsSync9(meta.sourcePath)) throw new Error(`Session file missing: ${meta.sourcePath}`);
+    if (!existsSync11(meta.sourcePath)) throw new Error(`Session file missing: ${meta.sourcePath}`);
     const parsed = this.parsePiFile(meta.sourcePath);
     const state = this.convertEntries(parsed.pathEntries);
     return {
@@ -5240,7 +6806,7 @@ var PiAgent = class extends SingleFileSessionSource {
     const sessionId = String(header["id"] ?? extractSessionIdFromFilename(filePath)).trim();
     if (!sessionId) throw new Error("missing session id");
     const stat = this.sessionSourceFile(filePath).stat;
-    const directory = String(header["cwd"] ?? "").trim() || basename6(filePath, ".jsonl");
+    const directory = String(header["cwd"] ?? "").trim() || basename8(filePath, ".jsonl");
     const createdAt = narrowTimestampMs("session.timestamp", header["timestamp"]) || stat.mtimeMs;
     const updatedAt = pathEntries.reduce(
       (max, entry) => Math.max(max, getEntryTimestamp(entry)),
@@ -5383,7 +6949,7 @@ var PiAgent = class extends SingleFileSessionSource {
       if (type === "toolCall") {
         const callId = String(item["id"] ?? "").trim();
         const toolName = String(item["name"] ?? "").trim() || "tool";
-        const toolPart = {
+        const toolPart2 = {
           type: "tool",
           tool: toolName,
           title: `Tool: ${toolName}`,
@@ -5394,7 +6960,7 @@ var PiAgent = class extends SingleFileSessionSource {
             input: item["arguments"] ?? {}
           }
         };
-        parts.push(toolPart);
+        parts.push(toolPart2);
       }
     }
     return parts;
@@ -5490,19 +7056,19 @@ var PiAgent = class extends SingleFileSessionSource {
 function resolveZCodeDataRoot() {
   const currentPlatform = platform3();
   if (currentPlatform !== "darwin" && currentPlatform !== "win32") return null;
-  return join11(homedir4(), ".zcode");
+  return join13(homedir4(), ".zcode");
 }
 function findZCodeDbPath() {
   if (!isSqliteAvailable()) return null;
   const dataRoot = resolveZCodeDataRoot();
   if (!dataRoot) return null;
-  return firstExisting(join11(dataRoot, "cli", "db", "db.sqlite"));
+  return firstExisting(join13(dataRoot, "cli", "db", "db.sqlite"));
 }
 function getZCodeSessionWatchPlan() {
   const dataRoot = resolveZCodeDataRoot();
   return {
     status: "supported",
-    targets: dataRoot ? [{ root: dataRoot, path: join11(dataRoot, "cli", "db", "db.sqlite") }] : []
+    targets: dataRoot ? [{ root: dataRoot, path: join13(dataRoot, "cli", "db", "db.sqlite") }] : []
   };
 }
 var ZCodeAgent = class extends OpenCodeSqliteAgent {
@@ -5544,6 +7110,13 @@ registerAgent({
   toolStrategy: "custom",
   create: () => new KimiAgent()
 });
+registerAgent({
+  icon: "/icon/agent/kimi.svg",
+  resolveDataRoot: resolveKimiCodeDataRoot,
+  resumeCommandPrefix: "kimi -r",
+  toolStrategy: "custom",
+  create: () => new KimiCodeAgent()
+});
 registerAgent({
   icon: "/icon/agent/codex.svg",
   resolveDataRoot: resolveCodexDataRoot,
@@ -5573,11 +7146,11 @@ function fallbackDisplayName(input) {
 }
 var realFs = {
   exists(path2) {
-    return existsSync10(path2);
+    return existsSync12(path2);
   },
   readText(path2) {
     try {
-      return readFileSync6(path2, "utf8");
+      return readFileSync7(path2, "utf8");
     } catch {
       return null;
     }
@@ -5602,23 +7175,6 @@ var MANIFESTS = [
 var PARSEABLE_MANIFESTS = ["package.json", "Cargo.toml", "pyproject.toml"];
 var LOOSE_DIRS = /* @__PURE__ */ new Set(["/tmp", "/private/tmp"]);
 var LOOSE_HOME_DIRS = ["Desktop", "Downloads", "Documents"];
-var PROJECT_IDENTITY_KINDS = /* @__PURE__ */ new Set([
-  "git_remote",
-  "git_common_dir",
-  "manifest_path",
-  "synthetic",
-  "path",
-  "loose"
-]);
-function isProjectIdentityKind(value) {
-  return PROJECT_IDENTITY_KINDS.has(value);
-}
-function getProjectIdentityKey(identity) {
-  return `${identity.kind}:${identity.key}`;
-}
-function matchesProjectIdentity(identity, expected) {
-  return identity?.kind === expected.kind && identity.key === expected.key;
-}
 function normalizeGitRemote(url) {
   if (!url) return null;
   let value = url.trim().replace(/\.git$/, "");
@@ -5765,6 +7321,7 @@ function parseManifestName(file, text) {
 function buildProjectGroups(sessions) {
   const groups = /* @__PURE__ */ new Map();
   for (const session of sessions) {
+    if (isChildSession(session)) continue;
     const identity = session.project_identity;
     if (!identity) continue;
     const activity = session.time_updated ?? session.time_created;
@@ -5817,7 +7374,7 @@ function isPathScopeMatch(queryPath, sessionPath) {
   return session === queryPath || session.startsWith(queryPath + "/") || queryPath.startsWith(session + "/");
 }
 function normalizeScopePath(path2) {
-  return resolve(path2).replaceAll(sep, "/");
+  return resolve2(path2).replaceAll(sep, "/");
 }
 var TAG_ORDER = [
   "bugfix",
@@ -6092,16 +7649,16 @@ function setSchemaEnsuredPath(path2) {
   schemaEnsuredPath = path2;
 }
 function getCacheDir2() {
-  return join12(homedir6(), ".cache", "codesesh");
+  return join14(homedir6(), ".cache", "codesesh");
 }
 function getCachePath2() {
-  return join12(getCacheDir2(), CACHE_FILENAME);
+  return join14(getCacheDir2(), CACHE_FILENAME);
 }
 function getLegacyCachePath() {
-  return join12(getCacheDir2(), LEGACY_CACHE_FILENAME);
+  return join14(getCacheDir2(), LEGACY_CACHE_FILENAME);
 }
 function hasCacheStorage() {
-  return existsSync11(getCachePath2());
+  return existsSync13(getCachePath2());
 }
 function likePattern(value) {
   return `%${value.trim().toLowerCase().replace(/[\\%_]/g, "\\$&")}%`;
@@ -6142,6 +7699,8 @@ function prepareUpsertSession(db) {
       title,
       source_path,
       directory,
+      parent_agent_name,
+      parent_session_id,
       project_identity_kind,
       project_identity_key,
       project_display_name,
@@ -6160,13 +7719,15 @@ function prepareUpsertSession(db) {
       smart_tags_json,
       smart_tags_source_updated_at,
       meta_json
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(agent_name, session_id) DO UPDATE SET
       sort_index = excluded.sort_index,
       slug = excluded.slug,
       title = excluded.title,
       source_path = excluded.source_path,
       directory = excluded.directory,
+      parent_agent_name = excluded.parent_agent_name,
+      parent_session_id = excluded.parent_session_id,
       project_identity_kind = excluded.project_identity_kind,
       project_identity_key = excluded.project_identity_key,
       project_display_name = excluded.project_display_name,
@@ -6197,6 +7758,8 @@ function prepareUpsertIndexedSession(db) {
       title,
       source_path,
       directory,
+      parent_agent_name,
+      parent_session_id,
       project_identity_kind,
       project_identity_key,
       project_display_name,
@@ -6215,11 +7778,13 @@ function prepareUpsertIndexedSession(db) {
       smart_tags_json,
       smart_tags_source_updated_at,
       meta_json
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(agent_name, session_id) DO UPDATE SET
       slug = excluded.slug,
       title = excluded.title,
       directory = excluded.directory,
+      parent_agent_name = excluded.parent_agent_name,
+      parent_session_id = excluded.parent_session_id,
       project_identity_kind = excluded.project_identity_kind,
       project_identity_key = excluded.project_identity_key,
       project_display_name = excluded.project_display_name,
@@ -6250,6 +7815,8 @@ function upsertSessionRow(statement, agentName, session, metaJson, sortIndex, so
     session.title,
     sourcePath,
     session.directory,
+    session.parent_reference?.agentName ?? null,
+    session.parent_reference?.sessionId ?? null,
     identity.kind,
     identity.key,
     identity.displayName,
@@ -6327,6 +7894,12 @@ function sessionFromRow(row) {
       displayName: String(row.project_display_name ?? "")
     };
   }
+  if (row.parent_agent_name && row.parent_session_id) {
+    session.parent_reference = {
+      agentName: String(row.parent_agent_name),
+      sessionId: String(row.parent_session_id)
+    };
+  }
   if (row.time_updated != null) {
     session.time_updated = Number(row.time_updated);
   }
@@ -6544,7 +8117,7 @@ function buildSessionContentFromMessages(title, messages) {
   }
   return chunks.join("\n");
 }
-var CACHE_SCHEMA_VERSION = 17;
+var CACHE_SCHEMA_VERSION = 18;
 function withCacheDb(fn) {
   const cachePath = getCachePath2();
   const db = openDb(cachePath);
@@ -6644,6 +8217,8 @@ function createSessionTables(db) {
       title TEXT NOT NULL,
       source_path TEXT,
       directory TEXT NOT NULL,
+      parent_agent_name TEXT,
+      parent_session_id TEXT,
       project_identity_kind TEXT NOT NULL,
       project_identity_key TEXT NOT NULL,
       project_display_name TEXT NOT NULL,
@@ -6671,6 +8246,9 @@ function createSessionTables(db) {
     CREATE INDEX IF NOT EXISTS idx_sessions_project
       ON sessions(project_identity_kind, project_identity_key, activity_time);
 
+    CREATE INDEX IF NOT EXISTS idx_sessions_parent
+      ON sessions(parent_agent_name, parent_session_id);
+
     CREATE TABLE IF NOT EXISTS messages (
       agent_name TEXT NOT NULL,
       session_id TEXT NOT NULL,
@@ -6960,6 +8538,7 @@ function createProjectGroupsView(db) {
     `);
     return;
   }
+  const hasParentReference = columnExists(db, "sessions", "parent_agent_name") && columnExists(db, "sessions", "parent_session_id");
   db.exec(`
     CREATE VIEW IF NOT EXISTS project_groups_v AS
       SELECT
@@ -6970,6 +8549,7 @@ function createProjectGroupsView(db) {
         COUNT(*) AS session_count,
         MAX(activity_time) AS last_activity
       FROM sessions
+      ${hasParentReference ? "WHERE parent_agent_name IS NULL OR parent_session_id IS NULL" : ""}
       GROUP BY project_identity_kind, project_identity_key;
   `);
 }
@@ -7367,6 +8947,19 @@ function addMessagePartsFormatVersion(db) {
   }
   db.exec("ALTER TABLE messages ADD COLUMN parts_format_version INTEGER NOT NULL DEFAULT 0");
 }
+function addSessionParentReference(db) {
+  if (!tableExists(db, "sessions")) return;
+  if (!columnExists(db, "sessions", "parent_agent_name")) {
+    db.exec("ALTER TABLE sessions ADD COLUMN parent_agent_name TEXT");
+  }
+  if (!columnExists(db, "sessions", "parent_session_id")) {
+    db.exec("ALTER TABLE sessions ADD COLUMN parent_session_id TEXT");
+  }
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_agent_name, parent_session_id)"
+  );
+  recreateProjectGroupsView(db);
+}
 var CODEX_EXEC_DECODE_MIGRATION_KEY = "codex_exec_decode_migrated_v3";
 function migrateCodexExecDecode(db) {
   if (!tableExists(db, "cache_meta")) return;
@@ -7381,6 +8974,30 @@ function migrateCodexExecDecode(db) {
     "INSERT INTO cache_meta(key, value) VALUES (?, '1') ON CONFLICT(key) DO UPDATE SET value = '1'"
   ).run(CODEX_EXEC_DECODE_MIGRATION_KEY);
 }
+var OPENCODE_SUBAGENT_FOLD_KEY = "opencode_subagent_fold_v1";
+var SUBAGENT_TREE_KEY = "subagent_tree_v1";
+function migrateOpenCodeSubagentFold(db) {
+  if (!tableExists(db, "cache_meta")) return;
+  const done = db.prepare("SELECT value FROM cache_meta WHERE key = ?").get(OPENCODE_SUBAGENT_FOLD_KEY);
+  if (done) return;
+  if (tableExists(db, "agent_cache")) {
+    db.prepare("DELETE FROM agent_cache WHERE agent_name IN ('zcode', 'opencode')").run();
+  }
+  db.prepare(
+    "INSERT INTO cache_meta(key, value) VALUES (?, '1') ON CONFLICT(key) DO UPDATE SET value = '1'"
+  ).run(OPENCODE_SUBAGENT_FOLD_KEY);
+}
+function migrateSubagentTree(db) {
+  if (!tableExists(db, "cache_meta")) return;
+  const done = db.prepare("SELECT value FROM cache_meta WHERE key = ?").get(SUBAGENT_TREE_KEY);
+  if (done) return;
+  if (tableExists(db, "agent_cache")) {
+    db.prepare("DELETE FROM agent_cache WHERE agent_name IN ('codex', 'zcode', 'opencode')").run();
+  }
+  db.prepare(
+    "INSERT INTO cache_meta(key, value) VALUES (?, '1') ON CONFLICT(key) DO UPDATE SET value = '1'"
+  ).run(SUBAGENT_TREE_KEY);
+}
 function rebuildSearchIndex(db) {
   if (!tableExists(db, "session_documents_fts")) {
     return;
@@ -7490,6 +9107,8 @@ function ensureSchema(db, dbPath) {
     createLatestCacheSchema(db);
     setCacheSchemaVersion(db);
     migrateCodexExecDecode(db);
+    migrateOpenCodeSubagentFold(db);
+    migrateSubagentTree(db);
     return;
   }
   runSchemaMigrations(db, {
@@ -7521,7 +9140,13 @@ function ensureSchema(db, dbPath) {
           invalidateSearchContentHashes(db2);
         }
       },
-      { version: 7, migrate: backfillStructuredSessions },
+      {
+        version: 7,
+        migrate(db2) {
+          addSessionParentReference(db2);
+          backfillStructuredSessions(db2);
+        }
+      },
       { version: 8, migrate: backfillFileActivity },
       {
         version: 9,
@@ -7552,7 +9177,8 @@ function ensureSchema(db, dbPath) {
       { version: 13, migrate: createCacheTables },
       { version: 14, migrate: addIndexedMessageCount },
       { version: 15, destructive: true, migrate: compactSessionDocuments },
-      { version: 17, migrate: addMessagePartsFormatVersion }
+      { version: 17, migrate: addMessagePartsFormatVersion },
+      { version: 18, migrate: addSessionParentReference }
     ]
   });
   createLatestCacheSchema(db);
@@ -7560,6 +9186,8 @@ function ensureSchema(db, dbPath) {
     setCacheSchemaVersion(db);
   }
   migrateCodexExecDecode(db);
+  migrateOpenCodeSubagentFold(db);
+  migrateSubagentTree(db);
 }
 function escapeFtsTerm(value) {
   return value.replaceAll('"', '""');
@@ -7690,6 +9318,7 @@ function readPendingReindexIds(db, agentName) {
   return new Set(rows.map((row) => String(row.session_id)));
 }
 var SEARCH_INDEX_STATE_BATCH_SIZE = 900;
+var SEARCH_INDEX_COMMIT_CHUNK_SIZE = 64;
 function shouldBulkSyncSearchIndex(options, changedCount) {
   if (options.isBulk != null) {
     return options.isBulk;
@@ -7949,6 +9578,32 @@ function syncSessionSearchIndex(agentName, sessions, loadSessionData, options =
       sortIndex: sessionSortIndexMap.get(session.id) ?? 0
     }));
     let indexed = 0;
+    if (changes.length > SEARCH_INDEX_COMMIT_CHUNK_SIZE) {
+      runSearchIndexWrite(db, false, () => {
+        indexed += writeSearchIndexRows(db, agentName, toDelete, []);
+      });
+      for (let offset = 0; offset < changes.length; offset += SEARCH_INDEX_COMMIT_CHUNK_SIZE) {
+        const chunk = changes.slice(offset, offset + SEARCH_INDEX_COMMIT_CHUNK_SIZE);
+        runSearchIndexWrite(db, false, () => {
+          indexed += writeSearchIndexRows(
+            db,
+            agentName,
+            [],
+            loadSearchIndexEntries(agentName, chunk, loadSessionData)
+          );
+        });
+      }
+      return {
+        agentName,
+        mode: "incremental",
+        sessions: sessions.length,
+        changed: toUpsert.length,
+        deleted: toDelete.length,
+        indexed,
+        skipped: toUpsert.length - indexed,
+        durationMs: performance.now() - startedAt
+      };
+    }
     const writeRows = () => {
       indexed = writeSearchIndexRows(
         db,
@@ -8445,55 +10100,90 @@ function buildFileActivityWhere(options) {
     params
   };
 }
+var FILE_ACTIVITY_COLUMNS = `
+  fa.agent_name,
+  fa.session_id,
+  fa.project_identity_key,
+  fa.path,
+  fa.kind,
+  fa.count,
+  fa.latest_time,
+  s.slug,
+  s.title,
+  s.directory,
+  s.project_identity_kind,
+  s.project_display_name,
+  s.time_created,
+  s.time_updated,
+  s.message_count,
+  s.total_input_tokens,
+  s.total_output_tokens,
+  s.total_cache_read_tokens,
+  s.total_cache_create_tokens,
+  s.total_cost,
+  s.cost_source,
+  s.total_tokens,
+  s.model_usage_json,
+  s.smart_tags_json,
+  s.smart_tags_source_updated_at
+`;
+var FILE_ACTIVITY_JOIN = `
+  FROM session_file_activity fa
+  JOIN sessions s ON s.agent_name = fa.agent_name AND s.session_id = fa.session_id
+`;
+var FILE_ACTIVITY_ORDER = "fa.latest_time DESC, fa.count DESC, fa.path";
 function listFileActivity(options = {}) {
   return queryFileActivity(options);
 }
-function queryFileActivity(options, sessionSearchOptions) {
-  if (!hasCacheStorage()) {
-    return [];
-  }
-  const filters = buildFileActivityWhere(options);
-  const sessionFilters = sessionSearchOptions ? buildSessionSearchFilters(sessionSearchOptions) : { where: "", params: [] };
-  const whereClauses = [
+function fileActivityWhere(query) {
+  const filters = buildFileActivityWhere(query.options);
+  const sessionFilters = query.sessionSearchOptions ? buildSessionSearchFilters(query.sessionSearchOptions) : { where: "", params: [] };
+  const clauses = [
     filters.where.replace(/^WHERE /, ""),
     sessionFilters.where.replace(/^ AND /, "")
   ].filter(Boolean);
-  const where = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-  const queryRows = (db) => db.prepare(
-    `
-          SELECT
-            fa.agent_name,
-            fa.session_id,
-            fa.project_identity_key,
-            fa.path,
-            fa.kind,
-            fa.count,
-            fa.latest_time,
-            s.slug,
-            s.title,
-            s.directory,
-            s.project_identity_kind,
-            s.project_display_name,
-            s.time_created,
-            s.time_updated,
-            s.message_count,
-            s.total_input_tokens,
-            s.total_output_tokens,
-            s.total_cache_read_tokens,
-            s.total_cache_create_tokens,
-            s.total_cost,
-            s.cost_source,
-            s.total_tokens,
-            s.model_usage_json,
-            s.smart_tags_json,
-            s.smart_tags_source_updated_at
-          FROM session_file_activity fa
-          JOIN sessions s ON s.agent_name = fa.agent_name AND s.session_id = fa.session_id
-          ${where}
-          ORDER BY fa.latest_time DESC, fa.count DESC, fa.path
-          LIMIT ?
-        `
-  ).all(...filters.params, ...sessionFilters.params, options.limit ?? 50);
+  return {
+    where: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
+    params: [...filters.params, ...sessionFilters.params]
+  };
+}
+function fileActivitySql(query, where) {
+  if (!query.onePerSession) {
+    return `
+      SELECT ${FILE_ACTIVITY_COLUMNS}
+      ${FILE_ACTIVITY_JOIN}
+      ${where}
+      ORDER BY ${FILE_ACTIVITY_ORDER}
+      LIMIT ?
+    `;
+  }
+  return `
+    SELECT ${FILE_ACTIVITY_COLUMNS}
+    FROM (
+      SELECT
+        fa.rowid AS activity_rowid,
+        ROW_NUMBER() OVER (
+          PARTITION BY fa.agent_name, fa.session_id
+          ORDER BY ${FILE_ACTIVITY_ORDER}
+        ) AS session_rank
+      ${FILE_ACTIVITY_JOIN}
+      ${where}
+    ) ranked
+    JOIN session_file_activity fa ON fa.rowid = ranked.activity_rowid
+    JOIN sessions s ON s.agent_name = fa.agent_name AND s.session_id = fa.session_id
+    WHERE ranked.session_rank = 1
+    ORDER BY ${FILE_ACTIVITY_ORDER}
+    LIMIT ?
+  `;
+}
+function queryFileActivity(options, sessionSearchOptions, onePerSession = false) {
+  if (!hasCacheStorage()) {
+    return [];
+  }
+  const query = { options, sessionSearchOptions, onePerSession };
+  const { where, params } = fileActivityWhere(query);
+  const sql = fileActivitySql(query, where);
+  const queryRows = (db) => db.prepare(sql).all(...params, options.limit ?? 50);
   let rows = withCacheDbReadOnly(queryRows);
   if (rows == null && options.path) {
     rows = withCacheDb(queryRows);
@@ -8526,27 +10216,20 @@ function searchFileActivitySessions(query, options = {}) {
     {
       path: path2,
       kind: search.options.fileKind,
-      limit: (search.options.limit ?? 50) * 3
+      limit: search.options.limit ?? 50
     },
-    search.options
+    search.options,
+    true
   );
-  const seen = /* @__PURE__ */ new Set();
-  const results = [];
-  for (const row of rows) {
-    const key = `${row.reference.agentName}/${row.reference.sessionId}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    results.push({
-      reference: row.reference,
-      session: row.session,
-      snippet: `${row.kind} ${highlightFilePath(row.path, path2)} \xB7 ${row.count} events`,
-      matchType: "file_path"
-    });
-    if (results.length >= (search.options.limit ?? 50)) break;
-  }
-  return results;
+  return rows.map((row) => ({
+    reference: row.reference,
+    session: row.session,
+    snippet: `${row.kind} ${highlightFilePath(row.path, path2)} \xB7 ${row.count} events`,
+    matchType: "file_path"
+  }));
 }
 var CACHE_INITIALIZATION_VERSION = "session-cache-v2";
+var FULL_SYNC_CURSOR_PREFIX = "full_sync_cursor:";
 function parseCachedSessionMeta(value) {
   if (!value) return null;
   try {
@@ -8557,7 +10240,7 @@ function parseCachedSessionMeta(value) {
 }
 function deleteLegacyCacheFile() {
   const legacyPath = getLegacyCachePath();
-  if (!existsSync12(legacyPath)) {
+  if (!existsSync14(legacyPath)) {
     return;
   }
   try {
@@ -8584,6 +10267,8 @@ function loadCachedSessions(agentName) {
             title,
             source_path,
             directory,
+            parent_agent_name,
+            parent_session_id,
             project_identity_kind,
             project_identity_key,
             project_display_name,
@@ -8646,6 +10331,43 @@ function markAgentCacheInitialized(agentName, indexVersion = CACHE_INITIALIZATIO
     ).run(agentName, Date.now(), indexVersion);
   });
 }
+function markAgentFullSyncStarted(agentName) {
+  withCacheDb((db) => {
+    db.prepare(
+      `
+        UPDATE cache_initialization
+        SET last_sync_at = 0
+        WHERE agent_name = ?
+      `
+    ).run(agentName);
+  });
+}
+function getAgentFullSyncCursor(agentName) {
+  if (!hasCacheStorage()) return null;
+  return withCacheDbReadOnly((db) => {
+    const row = db.prepare("SELECT value FROM cache_meta WHERE key = ?").get(`${FULL_SYNC_CURSOR_PREFIX}${agentName}`);
+    return row?.value || null;
+  }) ?? null;
+}
+function markAgentFullSyncProgress(agentName, cursor) {
+  if (!cursor) return;
+  withCacheDb((db) => {
+    db.prepare(
+      `
+        INSERT INTO cache_meta(key, value)
+        VALUES (?, ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value
+      `
+    ).run(`${FULL_SYNC_CURSOR_PREFIX}${agentName}`, cursor);
+  });
+}
+function clearAgentFullSyncCursor(agentName) {
+  withCacheDb((db) => {
+    db.prepare("DELETE FROM cache_meta WHERE key = ?").run(
+      `${FULL_SYNC_CURSOR_PREFIX}${agentName}`
+    );
+  });
+}
 function getAgentLastFullSyncAt(agentName) {
   if (!hasCacheStorage()) {
     return null;
@@ -8672,6 +10394,7 @@ function markAgentFullSyncCompleted(agentName) {
       `
     ).run(Date.now(), agentName);
   });
+  clearAgentFullSyncCursor(agentName);
 }
 function loadCachedSessionRawEntry(agentName, sessionId) {
   if (!hasCacheStorage()) {
@@ -8687,6 +10410,8 @@ function loadCachedSessionRawEntry(agentName, sessionId) {
             title,
             source_path,
             directory,
+            parent_agent_name,
+            parent_session_id,
             project_identity_kind,
             project_identity_key,
             project_display_name,
@@ -8757,7 +10482,7 @@ function loadCachedSessionRawEntry(agentName, sessionId) {
   });
 }
 function saveCachedSessions(agentName, sessions, meta = {}) {
-  withCacheDb((db) => {
+  const persisted = withCacheDb((db) => {
     const deleteSession = db.prepare(
       "DELETE FROM sessions WHERE agent_name = ? AND session_id = ?"
     );
@@ -8809,13 +10534,12 @@ function saveCachedSessions(agentName, sessions, meta = {}) {
     });
     write();
     deleteLegacyCacheFile();
+    return true;
   });
+  return persisted ?? false;
 }
 function saveCachedSessionChanges(agentName, changes, removedSessionIds, meta = {}) {
-  if (changes.length === 0 && removedSessionIds.length === 0) {
-    return;
-  }
-  withCacheDb((db) => {
+  const persisted = withCacheDb((db) => {
     const deleteSession = db.prepare(
       "DELETE FROM sessions WHERE agent_name = ? AND session_id = ?"
     );
@@ -8861,7 +10585,9 @@ function saveCachedSessionChanges(agentName, changes, removedSessionIds, meta =
     });
     write();
     deleteLegacyCacheFile();
+    return true;
   });
+  return persisted ?? false;
 }
 function clearCache() {
   setSchemaEnsuredPath(null);
@@ -8887,11 +10613,11 @@ function clearCache() {
   const walPath = `${cachePath}-wal`;
   const shmPath = `${cachePath}-shm`;
   for (const filePath of [walPath, shmPath]) {
-    if (!existsSync12(filePath)) {
+    if (!existsSync14(filePath)) {
       continue;
     }
     try {
-      rmSync(filePath, { force: true });
+      rmSync2(filePath, { force: true });
     } catch {
     }
   }
@@ -8916,6 +10642,8 @@ function sessionSignature(session) {
   return JSON.stringify([
     session.title,
     session.directory,
+    session.parent_reference?.agentName ?? null,
+    session.parent_reference?.sessionId ?? null,
     session.time_created,
     session.time_updated ?? session.time_created,
     session.stats.message_count,
@@ -8969,13 +10697,7 @@ function filterSessions(sessions, options) {
   if (options.cwd) {
     result = filterSessionsByProjectScope(result, options.cwd);
   }
-  if (options.from != null) {
-    result = result.filter((s) => (s.time_updated ?? s.time_created) >= options.from);
-  }
-  if (options.to != null) {
-    result = result.filter((s) => (s.time_updated ?? s.time_created) <= options.to);
-  }
-  return result;
+  return filterSessionTreeByActivityWindow(result, options.from, options.to);
 }
 function saveCachedSessionDiff(agent, cachedSessions, updatedSessions, changedIds = []) {
   const diff = computeSessionDiff(cachedSessions, updatedSessions, changedIds, sessionSignature);
@@ -8997,17 +10719,47 @@ function chunkSessions(items, chunkCount) {
   });
   return chunks.filter((chunk) => chunk.length > 0);
 }
-function ensureSessionTagsSync(agent, sessions) {
+function ensureSessionTagsSync(agent, sessions, onProgress) {
   let changed = false;
+  let processed = 0;
+  const total = sessions.length;
+  const timing = {
+    sessions: total,
+    cacheHits: 0,
+    staleSessions: 0,
+    failedSessions: 0,
+    getSessionDataCalls: 0,
+    getSessionDataMs: 0,
+    classifySessionTagsCalls: 0,
+    classifySessionTagsMs: 0
+  };
   const tagged = sessions.map((session) => {
     const sourceUpdatedAt = session.time_updated ?? session.time_created;
     const currentTags = Array.isArray(session.smart_tags) ? session.smart_tags : null;
     if (currentTags && session.smart_tags_source_updated_at === sourceUpdatedAt) {
+      timing.cacheHits += 1;
+      processed += 1;
+      onProgress?.(processed, total);
       return session;
     }
+    timing.staleSessions += 1;
     try {
-      const data = agent.getSessionData(session.id);
-      const tags = classifySessionTags(data);
+      timing.getSessionDataCalls += 1;
+      const getSessionDataStartedAt = performance.now();
+      let data;
+      try {
+        data = agent.getSessionData(session.id);
+      } finally {
+        timing.getSessionDataMs += performance.now() - getSessionDataStartedAt;
+      }
+      timing.classifySessionTagsCalls += 1;
+      const classifySessionTagsStartedAt = performance.now();
+      let tags;
+      try {
+        tags = classifySessionTags(data);
+      } finally {
+        timing.classifySessionTagsMs += performance.now() - classifySessionTagsStartedAt;
+      }
       changed = true;
       return {
         ...session,
@@ -9015,10 +10767,14 @@ function ensureSessionTagsSync(agent, sessions) {
         smart_tags_source_updated_at: getSmartTagSourceTimestamp(data)
       };
     } catch {
+      timing.failedSessions += 1;
       return session;
+    } finally {
+      processed += 1;
+      onProgress?.(processed, total);
     }
   });
-  return { sessions: tagged, changed };
+  return { sessions: tagged, changed, timing };
 }
 async function classifySessionTagsInWorker(workerUrl, agentName, sessionIds, meta) {
   return new Promise((resolveWorker, rejectWorker) => {
@@ -9130,12 +10886,13 @@ async function scanAgentSmart(agent, options, onProgress) {
       }
       agent.setSessionMetaMap(metaMap);
       if (options.cacheOnly) {
+        const visibleSessions = agent.filterCachedSessions(cached.sessions);
         onProgress?.({
           agent: agent.name,
           phase: "cache",
-          cachedCount: cached.sessions.length
+          cachedCount: visibleSessions.length
         });
-        return finalizeAgentScan(agent, cached.sessions, {
+        return finalizeAgentScan(agent, visibleSessions, {
           finalization: { kind: "cache-only", cached },
           options,
           timing,
@@ -9211,6 +10968,7 @@ async function scanAgentFull(agent, options, onProgress, timing = { total: 0 },
       from: options.from,
       to: options.to,
       fast: options.fast,
+      includeRelatedSessions: true,
       onProgress: (progress) => {
         onProgress?.({
           agent: agent.name,
@@ -9231,11 +10989,17 @@ async function scanAgentFull(agent, options, onProgress, timing = { total: 0 },
     timing.tags = performance.now() - t2;
     const meta = buildAgentCacheMeta(agent);
     if (options.writeCache !== false) {
-      if (options.from == null && options.to == null) {
-        saveCachedSessions(agent.name, tagged.sessions, meta);
-        markAgentFullSyncCompleted(agent.name);
+      const isFullWindow = options.from == null && options.to == null;
+      const persisted = isFullWindow ? saveCachedSessions(agent.name, tagged.sessions, meta) : true;
+      if (persisted) {
+        if (isFullWindow) markAgentFullSyncCompleted(agent.name);
+        markAgentCacheInitialized(agent.name);
+      } else {
+        getCoreDiagnostics()?.warn("cache.save_failed", {
+          agent: agent.name,
+          sessions: tagged.sessions.length
+        });
       }
-      markAgentCacheInitialized(agent.name);
     }
     onProgress?.({ agent: agent.name, phase: "complete", newCount: tagged.sessions.length });
     const filtered = filterSessions(tagged.sessions, options);
@@ -9440,16 +11204,16 @@ function getStateDir() {
   if (process.env.CODESESH_STATE_DIR) return process.env.CODESESH_STATE_DIR;
   const currentPlatform = platform4();
   if (currentPlatform === "darwin") {
-    return join13(homedir7(), "Library", "Application Support", "codesesh");
+    return join15(homedir7(), "Library", "Application Support", "codesesh");
   }
   if (currentPlatform === "win32") {
     const appData = process.env.APPDATA ?? process.env.LOCALAPPDATA;
-    return join13(appData ?? join13(homedir7(), "AppData", "Roaming"), "codesesh");
+    return join15(appData ?? join15(homedir7(), "AppData", "Roaming"), "codesesh");
   }
-  return join13(process.env.XDG_DATA_HOME ?? join13(homedir7(), ".local", "share"), "codesesh");
+  return join15(process.env.XDG_DATA_HOME ?? join15(homedir7(), ".local", "share"), "codesesh");
 }
 function getStateDbPath() {
-  return join13(getStateDir(), STATE_DB_FILENAME);
+  return join15(getStateDir(), STATE_DB_FILENAME);
 }
 function useMemoryStateStore() {
   return process.env.CODESESH_STATE_STORE === MEMORY_STATE_STORE;
@@ -9866,17 +11630,6 @@ function getSessionAgentName(session) {
 function getSessionActivityTime(session) {
   return session.time_updated ?? session.time_created;
 }
-function toLocalDateKey(ts) {
-  const d = new Date(ts);
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(
-    d.getDate()
-  ).padStart(2, "0")}`;
-}
-function startOfLocalDay(ts) {
-  const d = new Date(ts);
-  d.setHours(0, 0, 0, 0);
-  return d.getTime();
-}
 function buildDashboard(sessions, options) {
   const { byAgentNames, scope, from, to, agentInfoMap } = options;
   const agentMetrics = /* @__PURE__ */ new Map();
@@ -9897,16 +11650,16 @@ function buildDashboard(sessions, options) {
   const dailyMap = /* @__PURE__ */ new Map();
   const dailyTokenMap = /* @__PURE__ */ new Map();
   if (from != null) {
-    const bucketStart = startOfLocalDay(from);
-    const bucketDays = Math.floor((startOfLocalDay(to) - bucketStart) / 864e5) + 1;
+    const bucketDays = countCalendarDays(from, to);
     for (let i = 0; i < bucketDays; i += 1) {
-      const ts = bucketStart + i * 864e5;
-      const key = toLocalDateKey(ts);
+      const key = toCalendarDayKey(addCalendarDays(from, i));
       dailyMap.set(key, { date: key, sessions: 0, messages: 0 });
       dailyTokenMap.set(key, { date: key, input: 0, output: 0, cache_read: 0, cache_create: 0 });
     }
   }
-  for (const session of sessions) {
+  const visibleSessions = filterSessionTreeByActivityWindow(sessions, from, to);
+  for (const session of visibleSessions) {
+    if (isChildSession(session)) continue;
     const agentName = getSessionAgentName(session);
     if (scope.agent && agentName !== scope.agent) continue;
     if (scope.projectKind || scope.projectKey) {
@@ -9916,8 +11669,6 @@ function buildDashboard(sessions, options) {
       }
     }
     const activity = getSessionActivityTime(session);
-    if (from != null && activity < from) continue;
-    if (activity > to) continue;
     const messageCount = session.stats.message_count;
     const sessionTokens = getTotalTokens(session.stats);
     totalSessions += 1;
@@ -9933,7 +11684,7 @@ function buildDashboard(sessions, options) {
       metric.messages += messageCount;
       metric.tokens += sessionTokens;
     }
-    const key = toLocalDateKey(activity);
+    const key = toCalendarDayKey(activity);
     let bucket = dailyMap.get(key);
     if (!bucket) {
       bucket = { date: key, sessions: 0, messages: 0 };
@@ -10016,18 +11767,16 @@ function buildDashboard(sessions, options) {
     recentSessions
   };
 }
-function getProjectGroupKey(identityKind, identityKey) {
-  return `${identityKind}:${identityKey}`;
-}
 function emptyMetrics() {
   return { messages: 0, tokens: 0, cost: 0, hasEstimatedCost: false, agentStats: /* @__PURE__ */ new Map() };
 }
 function attachProjectMetrics(projects, sessions) {
   const metrics = /* @__PURE__ */ new Map();
   for (const session of sessions) {
+    if (isChildSession(session)) continue;
     const identity = session.project_identity;
     if (!identity) continue;
-    const key = getProjectGroupKey(identity.kind, identity.key);
+    const key = getProjectIdentityKey(identity);
     let current = metrics.get(key);
     if (!current) {
       current = emptyMetrics();
@@ -10057,7 +11806,9 @@ function attachProjectMetrics(projects, sessions) {
     }
   }
   return projects.map((project) => {
-    const metric = metrics.get(getProjectGroupKey(project.identityKind, project.identityKey));
+    const metric = metrics.get(
+      getProjectIdentityKey({ kind: project.identityKind, key: project.identityKey })
+    );
     return {
       ...project,
       messages: metric?.messages ?? 0,
@@ -10194,10 +11945,20 @@ function searchIndexedSessions(query, textQuery, parsed, options) {
 }
 
 export {
+  mergeSessionsUpdatedEvents,
+  startOfCalendarDay,
+  addCalendarDays,
+  countCalendarDays,
+  isProjectIdentityKind,
+  matchesProjectIdentity,
   normalizeSessionReference,
   formatSessionReference,
   getSessionAgentKey,
+  sessionRoutePath,
   mergeSortedSessions,
+  isChildSession,
+  getRootSessions,
+  filterSessionTreeByActivityWindow,
   registerAgent,
   createRegisteredAgents,
   getRegisteredAgents,
@@ -10206,10 +11967,14 @@ export {
   diffSessionSources,
   BaseAgent,
   FileSystemSessionSource,
+  ensurePrivateDirectory,
+  restrictPrivateFile,
+  restrictExistingPrivateFiles,
+  getPricingGeneration,
+  publishPendingPricing,
+  hasPendingPricing,
   refreshPricingCache,
   perf,
-  isProjectIdentityKind,
-  matchesProjectIdentity,
   createProjectScopeMatcher,
   matchesProjectScope,
   getSmartTagSourceTimestamp,
@@ -10222,6 +11987,9 @@ export {
   loadCachedSessions,
   isAgentCacheInitialized,
   markAgentCacheInitialized,
+  markAgentFullSyncStarted,
+  getAgentFullSyncCursor,
+  markAgentFullSyncProgress,
   getAgentLastFullSyncAt,
   markAgentFullSyncCompleted,
   saveCachedSessions,
@@ -10246,10 +12014,9 @@ export {
   upsertSessionAlias,
   deleteSessionAlias,
   getSessionActivityTime,
-  startOfLocalDay,
   buildDashboard,
   attachProjectMetrics,
   executeSessionSearch,
   filterSessionSearchCandidates
 };
-//# sourceMappingURL=chunk-7APNDHQ6.js.map
+//# sourceMappingURL=chunk-G2BTNW3C.js.map