codesesh 0.18.0 → 0.19.0

package/dist/{chunk-HIYT2ZJL.js → chunk-G2BTNW3C.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../core/dist/chunk-DKIXFG56.mjs
+// ../core/dist/chunk-B67H5WZJ.mjs
 function toRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -123,14 +123,14 @@ function normalizeMessageParts(value) {
 function mergeSessionsUpdatedEvents(previous, next) {
   const changedSessionHeads = /* @__PURE__ */ new Map();
   const removedSessionRefs = /* @__PURE__ */ new Map();
-  const sessionKey = (agentName, sessionId) => `${agentName}\0${sessionId}`;
+  const sessionKey2 = (agentName, sessionId) => `${agentName}\0${sessionId}`;
   const addChanged = (item) => {
-    const key = sessionKey(item.reference.agentName, item.reference.sessionId);
+    const key = sessionKey2(item.reference.agentName, item.reference.sessionId);
     removedSessionRefs.delete(key);
     changedSessionHeads.set(key, item);
   };
   const addRemoved = (item) => {
-    const key = sessionKey(item.agentName, item.sessionId);
+    const key = sessionKey2(item.agentName, item.sessionId);
     changedSessionHeads.delete(key);
     removedSessionRefs.set(key, item);
   };
@@ -253,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",
@@ -352,28 +390,38 @@ import { createRequire } from "module";
 import { createHash } from "crypto";
 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 { closeSync as closeSync2, existsSync as existsSync8, openSync as openSync2, readFileSync as readFileSync4, readSync as readSync2, statSync as statSync5 } from "fs";
-import { join as join9, basename as basename6 } from "path";
-import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync5, statSync as statSync6 } from "fs";
+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 join10, normalize } from "path";
-import { existsSync as existsSync10 } from "fs";
-import { basename as basename7, join as join11 } 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 join12 } from "path";
+import { join as join13 } from "path";
 import { availableParallelism } from "os";
 import { Worker } from "worker_threads";
-import { existsSync as existsSync11, 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 existsSync13, rmSync as rmSync2, unlinkSync } from "fs";
-import { existsSync as existsSync12 } from "fs";
-import { join as join13 } 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 join14 } from "path";
+import { join as join15 } from "path";
 var registrations = [];
 function registerAgent(reg) {
   registrations.push(reg);
@@ -468,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}`;
   }
@@ -475,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 = [];
@@ -572,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);
@@ -1527,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");
 }
@@ -1583,6 +1643,10 @@ 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(join5(resolveClaudeCodeDataRoot(), "projects"), "data/claudecode");
   }
@@ -1615,18 +1679,97 @@ 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: basename3(file, ".jsonl"),
-      sourcePath: file,
-      fingerprint: this.sourceFingerprint(stat, indexMtimes.get(dirname2(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 = dirname2(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);
@@ -1636,12 +1779,19 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
     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 {
       }
     }
@@ -1652,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,
@@ -1668,25 +1819,125 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
       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 = dirname2(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 join5(projectDir, "sessions-index.json");
@@ -1716,11 +1967,11 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
     this.sessionsIndexMtime[cacheKey] = mtime;
     return map;
   }
-  parseSessionHeadResult(filePath, projectDir) {
-    const sessionId = basename3(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;
@@ -1819,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: {
@@ -1851,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"]) ?? [];
@@ -1903,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);
@@ -2305,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;
@@ -2360,28 +2638,48 @@ var OpenCodeSqliteAgent = class extends DatabaseSessionSource {
       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 });
@@ -2423,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: {
@@ -2434,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, p.id 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");
@@ -2498,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 = {
@@ -2521,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([
@@ -2551,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();
@@ -2573,9 +2989,6 @@ 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, id ASC").all(sessionId);
       const partsByMessage = this.buildPartsByMessage(this.readSessionPartRows(db, sessionId));
@@ -2611,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
       };
@@ -3076,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,
@@ -3085,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" }
           );
@@ -3265,22 +3691,592 @@ var KimiAgent = class extends FileSystemSessionSource {
     if (stats.total_cost > 0) {
       stats.cost_source = "estimated";
     }
-    return stats;
+    return stats;
+  }
+  buildSessionData(meta, builder, stats) {
+    const transcript = builder.finish(stats);
+    return {
+      reference: { agentName: this.name, sessionId: meta.id },
+      id: meta.id,
+      title: meta.title,
+      slug: `kimi/${meta.id}`,
+      directory: meta.cwd,
+      time_created: meta.createdAt,
+      time_updated: meta.createdAt,
+      stats: transcript.stats,
+      messages: transcript.messages
+    };
+  }
+};
+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 } : {}
+    };
   }
-  buildSessionData(meta, builder, stats) {
-    const transcript = builder.finish(stats);
+  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: `kimi/${meta.id}`,
-      directory: meta.cwd,
+      slug: `${this.name}/${meta.id}`,
+      directory: meta.workDir,
       time_created: meta.createdAt,
-      time_updated: 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?/;
@@ -3543,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");
 }
@@ -3566,7 +4562,7 @@ var CODEX_TOOL_TITLE_MAP = {
   subagent: "subagent"
 };
 function extractSessionId(filename) {
-  const stem = basename6(filename, ".jsonl");
+  const stem = basename7(filename, ".jsonl");
   const parts = stem.split("-");
   if (parts.length >= 5) {
     return parts.slice(-5).join("-");
@@ -3595,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 {
@@ -3620,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);
@@ -3647,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*(.+)/;
@@ -3729,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";
@@ -3736,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(join9(resolveCodexDataRoot(), "sessions"));
+    return firstExisting(join10(resolveCodexDataRoot(), "sessions"));
   }
   getSessionWatchPlan() {
     const dataRoot = resolveCodexDataRoot();
     return {
       status: "supported",
       targets: [
-        { path: join9(dataRoot, "sessions") },
-        { path: join9(dataRoot, "session_index.jsonl") }
+        { path: join10(dataRoot, "sessions") },
+        { path: join10(dataRoot, "session_index.jsonl") }
       ]
     };
   }
@@ -3758,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 (!existsSync8(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;
@@ -3850,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 [];
@@ -3871,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;
@@ -3883,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
       }
     });
   }
@@ -3899,7 +5180,7 @@ var CodexAgent = class extends SingleFileSessionSource {
     ]);
   }
   getSessionIndexPath() {
-    this.sessionIndexPath ??= join9(resolveCodexDataRoot(), "session_index.jsonl");
+    this.sessionIndexPath ??= join10(resolveCodexDataRoot(), "session_index.jsonl");
     return this.sessionIndexPath;
   }
   // ---- Session index ----
@@ -3913,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();
@@ -3945,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));
@@ -3956,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;
@@ -3985,7 +5269,9 @@ var CodexAgent = class extends SingleFileSessionSource {
           return skippedSession("malformed first record");
         }
         firstPayload = extractPayload(firstRecord);
-        createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(firstPayload) || statSync5(filePath).mtimeMs;
+        const threadMeta = extractThreadMeta(firstRecord);
+        parentThreadId = threadMeta?.threadSource === "subagent" ? threadMeta.parentThreadId : null;
+        createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(firstPayload) || statSync6(filePath).mtimeMs;
         updatedAt = createdAt;
       }
       try {
@@ -4079,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: {
@@ -4092,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());
@@ -4106,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 = statSync5(filePath);
+    const stat = statSync6(filePath);
     const createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(payload) || stat.mtimeMs;
     const indexTitle = this.getTitleForSession(sessionId);
     const messageTitle = this.extractTitleFromLines(lines);
@@ -4119,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: {
@@ -4214,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();
@@ -4341,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,
@@ -4356,7 +5632,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4388,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,
@@ -4402,7 +5678,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4419,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,
@@ -4433,7 +5709,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4518,15 +5794,15 @@ function resolveCursorDataRoot() {
   if (override) return override;
   const currentPlatform = platform2();
   if (currentPlatform === "darwin") {
-    return firstExisting(join10(homedir3(), "Library", "Application Support", "Cursor", "User"));
+    return firstExisting(join11(homedir3(), "Library", "Application Support", "Cursor", "User"));
   }
   if (currentPlatform === "linux") {
-    const configRoot = readEnvPath("XDG_CONFIG_HOME") ?? join10(homedir3(), ".config");
-    return firstExisting(join10(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") ?? join10(homedir3(), "AppData", "Roaming");
-    return firstExisting(join10(appData, "Cursor", "User"));
+    const appData = readEnvPath("APPDATA") ?? join11(homedir3(), "AppData", "Roaming");
+    return firstExisting(join11(appData, "Cursor", "User"));
   }
   return null;
 }
@@ -4655,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) {
@@ -4716,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
   };
@@ -4764,7 +6040,7 @@ var CursorAgent = class extends DatabaseSessionSource {
     if (!isSqliteAvailable()) return null;
     const dataPath = resolveCursorDataRoot();
     if (!dataPath) return null;
-    return join10(dataPath, "globalStorage", "state.vscdb");
+    return join11(dataPath, "globalStorage", "state.vscdb");
   }
   getSessionWatchPlan() {
     const dataPath = resolveCursorDataRoot();
@@ -4773,9 +6049,9 @@ var CursorAgent = class extends DatabaseSessionSource {
       targets: dataPath ? [
         {
           root: dataPath,
-          path: join10(dataPath, "globalStorage", "state.vscdb")
+          path: join11(dataPath, "globalStorage", "state.vscdb")
         },
-        { root: dataPath, path: join10(dataPath, "workspaceStorage") }
+        { root: dataPath, path: join11(dataPath, "workspaceStorage") }
       ] : []
     };
   }
@@ -4787,34 +6063,34 @@ var CursorAgent = class extends DatabaseSessionSource {
     const map = /* @__PURE__ */ new Map();
     const dataPath = resolveCursorDataRoot();
     if (!dataPath) return map;
-    const wsStoragePath = join10(dataPath, "workspaceStorage");
-    if (!existsSync9(wsStoragePath)) return map;
+    const wsStoragePath = join11(dataPath, "workspaceStorage");
+    if (!existsSync10(wsStoragePath)) return map;
     let entryNames;
     try {
-      entryNames = readdirSync5(wsStoragePath);
+      entryNames = readdirSync7(wsStoragePath);
     } catch {
       return map;
     }
     for (const name of entryNames) {
-      const wsDir = join10(wsStoragePath, name);
+      const wsDir = join11(wsStoragePath, name);
       try {
-        if (!statSync6(wsDir).isDirectory()) continue;
+        if (!statSync7(wsDir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const wsJsonPath = join10(wsDir, "workspace.json");
-      if (!existsSync9(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 = join10(wsDir, "state.vscdb");
-      if (!existsSync9(wsDbPath)) continue;
+      const wsDbPath = join11(wsDir, "state.vscdb");
+      if (!existsSync10(wsDbPath)) continue;
       const wsDb = openDbReadOnly(wsDbPath);
       if (!wsDb) continue;
       try {
@@ -4837,7 +6113,7 @@ var CursorAgent = class extends DatabaseSessionSource {
   }
   isAvailable() {
     this.dbPath = this.findDbPath();
-    return this.dbPath !== null && existsSync9(this.dbPath);
+    return this.dbPath !== null && existsSync10(this.dbPath);
   }
   scan(options) {
     if (!this.dbPath) return [];
@@ -5192,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;
@@ -5225,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"
     };
@@ -5353,7 +6629,7 @@ function narrowTimestampMs(field, value) {
   return shaped === void 0 ? 0 : parseTimestampMs3(shaped);
 }
 function extractSessionIdFromFilename(filePath) {
-  const stem = basename7(filePath, ".jsonl");
+  const stem = basename8(filePath, ".jsonl");
   const underscore = stem.indexOf("_");
   return underscore >= 0 ? stem.slice(underscore + 1) || stem : stem;
 }
@@ -5409,14 +6685,14 @@ var PiAgent = class extends SingleFileSessionSource {
   displayName = "Pi";
   basePath = null;
   findBasePath() {
-    return firstExisting(join11(resolvePiDataRoot(), "agent", "sessions"), "data/pi");
+    return firstExisting(join12(resolvePiDataRoot(), "agent", "sessions"), "data/pi");
   }
   getSessionWatchPlan() {
     const dataRoot = resolvePiDataRoot();
     return {
       status: "supported",
       targets: [
-        { root: dataRoot, path: join11(dataRoot, "agent", "sessions") },
+        { root: dataRoot, path: join12(dataRoot, "agent", "sessions") },
         { root: "data/pi", path: "data/pi" }
       ]
     };
@@ -5437,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 (!existsSync10(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 {
@@ -5530,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() || basename7(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)),
@@ -5673,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}`,
@@ -5684,7 +6960,7 @@ var PiAgent = class extends SingleFileSessionSource {
             input: item["arguments"] ?? {}
           }
         };
-        parts.push(toolPart);
+        parts.push(toolPart2);
       }
     }
     return parts;
@@ -5780,19 +7056,19 @@ var PiAgent = class extends SingleFileSessionSource {
 function resolveZCodeDataRoot() {
   const currentPlatform = platform3();
   if (currentPlatform !== "darwin" && currentPlatform !== "win32") return null;
-  return join12(homedir4(), ".zcode");
+  return join13(homedir4(), ".zcode");
 }
 function findZCodeDbPath() {
   if (!isSqliteAvailable()) return null;
   const dataRoot = resolveZCodeDataRoot();
   if (!dataRoot) return null;
-  return firstExisting(join12(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: join12(dataRoot, "cli", "db", "db.sqlite") }] : []
+    targets: dataRoot ? [{ root: dataRoot, path: join13(dataRoot, "cli", "db", "db.sqlite") }] : []
   };
 }
 var ZCodeAgent = class extends OpenCodeSqliteAgent {
@@ -5834,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,
@@ -5863,11 +7146,11 @@ function fallbackDisplayName(input) {
 }
 var realFs = {
   exists(path2) {
-    return existsSync11(path2);
+    return existsSync12(path2);
   },
   readText(path2) {
     try {
-      return readFileSync6(path2, "utf8");
+      return readFileSync7(path2, "utf8");
     } catch {
       return null;
     }
@@ -6038,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;
@@ -6090,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",
@@ -6365,16 +7649,16 @@ function setSchemaEnsuredPath(path2) {
   schemaEnsuredPath = path2;
 }
 function getCacheDir2() {
-  return join13(homedir6(), ".cache", "codesesh");
+  return join14(homedir6(), ".cache", "codesesh");
 }
 function getCachePath2() {
-  return join13(getCacheDir2(), CACHE_FILENAME);
+  return join14(getCacheDir2(), CACHE_FILENAME);
 }
 function getLegacyCachePath() {
-  return join13(getCacheDir2(), LEGACY_CACHE_FILENAME);
+  return join14(getCacheDir2(), LEGACY_CACHE_FILENAME);
 }
 function hasCacheStorage() {
-  return existsSync12(getCachePath2());
+  return existsSync13(getCachePath2());
 }
 function likePattern(value) {
   return `%${value.trim().toLowerCase().replace(/[\\%_]/g, "\\$&")}%`;
@@ -6415,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,
@@ -6433,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,
@@ -6470,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,
@@ -6488,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,
@@ -6523,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,
@@ -6600,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);
   }
@@ -6817,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);
@@ -6917,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,
@@ -6944,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,
@@ -7233,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
@@ -7243,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;
   `);
 }
@@ -7640,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;
@@ -7654,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;
@@ -7763,6 +9107,8 @@ function ensureSchema(db, dbPath) {
     createLatestCacheSchema(db);
     setCacheSchemaVersion(db);
     migrateCodexExecDecode(db);
+    migrateOpenCodeSubagentFold(db);
+    migrateSubagentTree(db);
     return;
   }
   runSchemaMigrations(db, {
@@ -7794,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,
@@ -7825,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);
@@ -7833,6 +9186,8 @@ function ensureSchema(db, dbPath) {
     setCacheSchemaVersion(db);
   }
   migrateCodexExecDecode(db);
+  migrateOpenCodeSubagentFold(db);
+  migrateSubagentTree(db);
 }
 function escapeFtsTerm(value) {
   return value.replaceAll('"', '""');
@@ -7963,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;
@@ -8222,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,
@@ -8847,6 +10229,7 @@ function searchFileActivitySessions(query, options = {}) {
   }));
 }
 var CACHE_INITIALIZATION_VERSION = "session-cache-v2";
+var FULL_SYNC_CURSOR_PREFIX = "full_sync_cursor:";
 function parseCachedSessionMeta(value) {
   if (!value) return null;
   try {
@@ -8857,7 +10240,7 @@ function parseCachedSessionMeta(value) {
 }
 function deleteLegacyCacheFile() {
   const legacyPath = getLegacyCachePath();
-  if (!existsSync13(legacyPath)) {
+  if (!existsSync14(legacyPath)) {
     return;
   }
   try {
@@ -8884,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,
@@ -8946,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;
@@ -8972,6 +10394,7 @@ function markAgentFullSyncCompleted(agentName) {
       `
     ).run(Date.now(), agentName);
   });
+  clearAgentFullSyncCursor(agentName);
 }
 function loadCachedSessionRawEntry(agentName, sessionId) {
   if (!hasCacheStorage()) {
@@ -8987,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,
@@ -9114,9 +10539,6 @@ function saveCachedSessions(agentName, sessions, meta = {}) {
   return persisted ?? false;
 }
 function saveCachedSessionChanges(agentName, changes, removedSessionIds, meta = {}) {
-  if (changes.length === 0 && removedSessionIds.length === 0) {
-    return true;
-  }
   const persisted = withCacheDb((db) => {
     const deleteSession = db.prepare(
       "DELETE FROM sessions WHERE agent_name = ? AND session_id = ?"
@@ -9191,7 +10613,7 @@ function clearCache() {
   const walPath = `${cachePath}-wal`;
   const shmPath = `${cachePath}-shm`;
   for (const filePath of [walPath, shmPath]) {
-    if (!existsSync13(filePath)) {
+    if (!existsSync14(filePath)) {
       continue;
     }
     try {
@@ -9220,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,
@@ -9273,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);
@@ -9301,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,
@@ -9319,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) => {
@@ -9434,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,
@@ -9515,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,
@@ -9750,16 +11204,16 @@ function getStateDir() {
   if (process.env.CODESESH_STATE_DIR) return process.env.CODESESH_STATE_DIR;
   const currentPlatform = platform4();
   if (currentPlatform === "darwin") {
-    return join14(homedir7(), "Library", "Application Support", "codesesh");
+    return join15(homedir7(), "Library", "Application Support", "codesesh");
   }
   if (currentPlatform === "win32") {
     const appData = process.env.APPDATA ?? process.env.LOCALAPPDATA;
-    return join14(appData ?? join14(homedir7(), "AppData", "Roaming"), "codesesh");
+    return join15(appData ?? join15(homedir7(), "AppData", "Roaming"), "codesesh");
   }
-  return join14(process.env.XDG_DATA_HOME ?? join14(homedir7(), ".local", "share"), "codesesh");
+  return join15(process.env.XDG_DATA_HOME ?? join15(homedir7(), ".local", "share"), "codesesh");
 }
 function getStateDbPath() {
-  return join14(getStateDir(), STATE_DB_FILENAME);
+  return join15(getStateDir(), STATE_DB_FILENAME);
 }
 function useMemoryStateStore() {
   return process.env.CODESESH_STATE_STORE === MEMORY_STATE_STORE;
@@ -10203,7 +11657,9 @@ function buildDashboard(sessions, options) {
       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) {
@@ -10213,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;
@@ -10319,6 +11773,7 @@ function emptyMetrics() {
 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 = getProjectIdentityKey(identity);
@@ -10501,6 +11956,9 @@ export {
   getSessionAgentKey,
   sessionRoutePath,
   mergeSortedSessions,
+  isChildSession,
+  getRootSessions,
+  filterSessionTreeByActivityWindow,
   registerAgent,
   createRegisteredAgents,
   getRegisteredAgents,
@@ -10529,6 +11987,9 @@ export {
   loadCachedSessions,
   isAgentCacheInitialized,
   markAgentCacheInitialized,
+  markAgentFullSyncStarted,
+  getAgentFullSyncCursor,
+  markAgentFullSyncProgress,
   getAgentLastFullSyncAt,
   markAgentFullSyncCompleted,
   saveCachedSessions,
@@ -10558,4 +12019,4 @@ export {
   executeSessionSearch,
   filterSessionSearchCandidates
 };
-//# sourceMappingURL=chunk-HIYT2ZJL.js.map
+//# sourceMappingURL=chunk-G2BTNW3C.js.map