codesesh 0.18.0 → 1.0.0

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../core/dist/chunk-DKIXFG56.mjs
+// ../core/dist/chunk-TXYCGCSU.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,159 @@ function mergeSortedSessions(shards) {
   }
   return merged;
 }
+function getSessionRouteKey(agentName, sessionId) {
+  return formatSessionReference({ agentName, sessionId });
+}
+function sessionKey(session) {
+  return getSessionRouteKey(getSessionAgentKey(session), session.id);
+}
+function parentKey(session) {
+  return session.parent_reference ? formatSessionReference(session.parent_reference) : null;
+}
+function activityTime(session) {
+  return session.time_updated ?? session.time_created;
+}
+function hasActivityInWindow(session, from, to) {
+  const activity = activityTime(session);
+  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 ownStats(session) {
+  const stats = session.stats;
+  const cost = stats.total_cost ?? 0;
+  return {
+    messageCount: stats.message_count,
+    inputTokens: stats.total_input_tokens,
+    outputTokens: stats.total_output_tokens,
+    cacheReadTokens: stats.total_cache_read_tokens ?? 0,
+    cacheCreateTokens: stats.total_cache_create_tokens ?? 0,
+    totalTokens: stats.total_tokens ?? stats.total_input_tokens + stats.total_output_tokens,
+    cost,
+    costSource: cost > 0 ? stats.cost_source ?? "recorded" : void 0
+  };
+}
+function addStats(target, source) {
+  target.messageCount += source.messageCount;
+  target.inputTokens += source.inputTokens;
+  target.outputTokens += source.outputTokens;
+  target.cacheReadTokens += source.cacheReadTokens;
+  target.cacheCreateTokens += source.cacheCreateTokens;
+  target.totalTokens += source.totalTokens;
+  target.cost += source.cost;
+  if (source.costSource === "estimated") target.costSource = "estimated";
+}
+function rollUpSubtree(entry) {
+  const order = [];
+  const pending2 = [entry];
+  while (pending2.length > 0) {
+    const node = pending2.pop();
+    order.push(node);
+    for (const child of node.children) pending2.push(child);
+  }
+  for (let index = order.length - 1; index >= 0; index -= 1) {
+    const node = order[index];
+    const stats = node.inclusiveStats;
+    let descendants = 0;
+    for (const child of node.children) {
+      descendants += 1 + child.descendantCount;
+      addStats(stats, child.inclusiveStats);
+    }
+    if (stats.cost > 0 && stats.costSource == null) stats.costSource = "recorded";
+    node.descendantCount = descendants;
+  }
+}
+function buildSessionTree(sessions) {
+  const byRouteKey = /* @__PURE__ */ new Map();
+  const nodes = sessions.map((session) => ({
+    session,
+    children: [],
+    descendantCount: 0,
+    inclusiveStats: ownStats(session)
+  }));
+  for (const node of nodes) {
+    const key = sessionKey(node.session);
+    if (!byRouteKey.has(key)) byRouteKey.set(key, node);
+  }
+  const chainTerminates = /* @__PURE__ */ new Map();
+  function reachesRoot(startKey) {
+    const path2 = [];
+    const onPath = /* @__PURE__ */ new Set();
+    let key = startKey;
+    let terminates = true;
+    while (key != null) {
+      const memo = chainTerminates.get(key);
+      if (memo != null) {
+        terminates = memo;
+        break;
+      }
+      if (onPath.has(key)) {
+        terminates = false;
+        break;
+      }
+      onPath.add(key);
+      path2.push(key);
+      const parent = parentKey(byRouteKey.get(key).session);
+      key = parent != null && byRouteKey.has(parent) ? parent : null;
+    }
+    for (const visited of path2) chainTerminates.set(visited, terminates);
+    return terminates;
+  }
+  const mountStates = /* @__PURE__ */ new Map();
+  const roots = [];
+  const orphans = [];
+  const entries = [];
+  for (const node of nodes) {
+    const key = sessionKey(node.session);
+    const parent = parentKey(node.session);
+    const state = parent == null ? "root" : byRouteKey.has(parent) && reachesRoot(key) ? "mounted-child" : "orphan";
+    mountStates.set(key, state);
+    if (state === "mounted-child") {
+      byRouteKey.get(parent).children.push(node);
+      continue;
+    }
+    (state === "root" ? roots : orphans).push(node);
+    entries.push(node);
+  }
+  for (const entry of entries) rollUpSubtree(entry);
+  return {
+    roots,
+    orphans,
+    entries,
+    byRouteKey,
+    mountStateOf(session) {
+      return mountStates.get(sessionKey(session)) ?? (session.parent_reference ? "orphan" : "root");
+    }
+  };
+}
+function filterSessionTreeByActivityWindow(sessions, from, to) {
+  if (from == null && to == null) return sessions;
+  const available = new Set(sessions.map(sessionKey));
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const pending2 = [];
+  for (const session of sessions) {
+    const parent = parentKey(session);
+    if (parent != null && available.has(parent)) {
+      const children = childrenByParent.get(parent);
+      if (children) children.push(sessionKey(session));
+      else childrenByParent.set(parent, [sessionKey(session)]);
+      continue;
+    }
+    if (hasActivityInWindow(session, from, to)) pending2.push(sessionKey(session));
+  }
+  const visible = /* @__PURE__ */ new Set();
+  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",
@@ -301,9 +454,15 @@ var SAMPLE_DASHBOARD_DATA = {
     messages: 12,
     tokens: 6e3,
     cost: 0.042,
+    costRecorded: 0.042,
+    costEstimated: 0,
+    cacheReadTokens: 3e3,
     cost_source: "recorded",
-    latestActivity: 17000036e5
+    latestActivity: 17000036e5,
+    latestActivityProject: "example/project",
+    latestActivityAgent: "claudecode"
   },
+  scopeCounts: { projects: 1, agents: 1 },
   perAgent: [
     {
       name: "claudecode",
@@ -311,14 +470,38 @@ var SAMPLE_DASHBOARD_DATA = {
       icon: "claude",
       sessions: 1,
       messages: 12,
-      tokens: 6e3
+      tokens: 6e3,
+      cost: 0.042
     }
   ],
-  dailyActivity: [{ date: "2023-11-14", sessions: 1, messages: 12 }],
-  dailyTokenActivity: [
-    { date: "2023-11-14", input: 700, output: 1800, cache_read: 3e3, cache_create: 500 }
+  dailyActivity: [
+    {
+      date: "2023-11-14",
+      sessions: 1,
+      messages: 12,
+      cost: 0.042,
+      input: 700,
+      output: 1800,
+      cache_read: 3e3,
+      cache_create: 500
+    }
   ],
   modelDistribution: [{ model: "claude-5-sonnet", tokens: 6e3, sessions: 1 }],
+  perProject: [
+    {
+      identityKind: "git_remote",
+      identityKey: "github.com/example/project",
+      displayName: "example/project",
+      sessions: 1,
+      messages: 12,
+      tokens: 6e3,
+      cost: 0.042,
+      cost_source: "recorded",
+      agents: ["claudecode"],
+      sparkline: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.042]
+    }
+  ],
+  projectRollup: { projects: 0, sessions: 0, tokens: 0, cost: 0 },
   recentSessions: [
     {
       reference: { agentName: "claudecode", sessionId: SAMPLE_SESSION_HEAD.id },
@@ -326,6 +509,7 @@ var SAMPLE_DASHBOARD_DATA = {
     }
   ],
   recentFileActivities: [],
+  modelCost: null,
   window: { from: 16999e8, to: 17000036e5, days: 1 }
 };
 
@@ -352,28 +536,40 @@ 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 { existsSync as existsSync12, readFileSync as readFileSync7, statSync as statSync8 } from "fs";
+import { dirname as dirname6, join as join14 } from "path";
 import { availableParallelism } from "os";
 import { Worker } from "worker_threads";
-import { existsSync as existsSync11, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8 } 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 existsSync15, rmSync as rmSync2, unlinkSync } from "fs";
+import { existsSync as existsSync14 } from "fs";
+import { join as join15 } 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 join16 } from "path";
 var registrations = [];
 function registerAgent(reg) {
   registrations.push(reg);
@@ -432,9 +628,9 @@ function filteredSession(reason) {
 function getParsedSession(result) {
   return result.status === "parsed" ? result.data : null;
 }
-function matchesScanWindow(activityTime, options) {
-  if (options?.from != null && activityTime < options.from) return false;
-  if (options?.to != null && activityTime > options.to) return false;
+function matchesScanWindow(activityTime2, options) {
+  if (options?.from != null && activityTime2 < options.from) return false;
+  if (options?.to != null && activityTime2 > options.to) return false;
   return true;
 }
 function readCachedMeta(meta, sessionId) {
@@ -468,6 +664,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 +674,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 +779,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 +1735,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 +1791,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 +1827,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 +1927,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 +1950,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 +1967,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 +2115,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 +2218,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 +2251,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 +2309,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);
@@ -2231,7 +2639,7 @@ function runSchemaMigrations(db, options) {
         migration.migrate(db);
         setUserVersion(db, migration.version);
       });
-      apply();
+      apply.immediate();
       currentVersion = migration.version;
       getCoreDiagnostics()?.info?.("sqlite.migration.completed", {
         label: options.backupLabel,
@@ -2285,10 +2693,10 @@ function openDb(dbPath) {
     const db = DatabaseConstructor(dbPath);
     restrictPrivateDatabase(dbPath);
     try {
+      db.pragma("busy_timeout = 5000");
       db.pragma("journal_mode = WAL");
       db.pragma("synchronous = NORMAL");
       db.pragma("foreign_keys = ON");
-      db.pragma("busy_timeout = 5000");
     } catch {
     }
     return db;
@@ -2305,6 +2713,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 +2786,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 +2869,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 +2881,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(
+        `
+            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, sessionIds) {
+    const ids = sessionIds ? [...sessionIds] : [];
+    if (ids.length === 0) {
+      return db.prepare(
         `
-    ).all(cutoffTime);
+            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;
   }
-  readHeadPartRows(db, cutoffTime) {
-    return db.prepare(
+  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 +3020,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 +3037,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 +3092,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 +3137,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 +3172,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 +3650,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 +3659,7 @@ var KimiAgent = class extends FileSystemSessionSource {
             time_created: timestampMs
           };
           builder.appendToolCall(
-            toolPart,
+            toolPart2,
             { id: `wire-${seq}`, timestampMs: 0, agent: "kimi" },
             { markModeAsTool: true, target: "current" }
           );
@@ -3282,66 +3856,636 @@ var KimiAgent = class extends FileSystemSessionSource {
     };
   }
 };
-var PARSE_FAIL = /* @__PURE__ */ Symbol("parse-fail");
-var EXEC_OUTPUT_ENVELOPE_RE = /^Script completed\nWall time [^\n]*\nOutput:\n?/;
-function stripExecOutputEnvelope(text) {
-  return text.replace(EXEC_OUTPUT_ENVELOPE_RE, "");
+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 splitExecToolName(name) {
-  if (name.startsWith("mcp__")) {
-    const separator = name.lastIndexOf("__");
-    if (separator > 0 && separator + 2 < name.length) {
-      return { name: name.slice(separator + 2), namespace: name.slice(0, separator + 2) };
-    }
-  }
-  return { name };
+function mapToolTitle2(toolName) {
+  return KIMI_CODE_TOOL_TITLE_MAP[toolName] ?? toolName;
 }
-function pickExecOutputTarget(calls) {
-  for (let index = calls.length - 1; index >= 0; index -= 1) {
-    const { name } = splitExecToolName(calls[index].name);
-    if (name !== "apply_patch" && name !== "update_plan") return index;
+function normalizeToolArguments2(raw) {
+  if (typeof raw !== "string") return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
   }
-  return calls.length - 1;
 }
-function getExecPatchText(args) {
-  if (typeof args === "string") return args;
-  if (args && typeof args === "object") {
-    const patch = args["patch"];
-    if (typeof patch === "string") return patch;
+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 "";
+  return content.map((item) => {
+    if (typeof item === "string") return item;
+    const record = asRecord(item);
+    return record ? String(record.text ?? "") : "";
+  }).join(" ");
 }
-function decodeExecCalls(input) {
-  if (typeof input !== "string" || !input.includes("tools.")) return [];
-  const scope = collectStringVars(input);
-  const calls = [];
-  const callRe = /tools\.([A-Za-z_$][\w$]*)\s*\(/g;
-  let match;
-  while ((match = callRe.exec(input)) !== null) {
-    const reader = new JsValueReader(input, callRe.lastIndex, scope);
-    const args = reader.parseValue();
-    if (args !== PARSE_FAIL) {
-      calls.push({ name: match[1], args });
-      callRe.lastIndex = reader.pos;
+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 calls;
+  return parts;
 }
-function collectStringVars(input) {
-  const scope = /* @__PURE__ */ new Map();
-  const assignRe = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*/g;
-  let match;
-  while ((match = assignRe.exec(input)) !== null) {
-    const reader = new JsValueReader(input, assignRe.lastIndex, scope);
-    const value = reader.parseValue();
-    if (value !== PARSE_FAIL) {
-      if (typeof value === "string") scope.set(match[1], value);
-      assignRe.lastIndex = reader.pos;
-    }
+function toolOutputParts(output, timestampMs) {
+  if (typeof output === "string") {
+    const text2 = cleanInternalText(output);
+    return text2 ? [{ type: "text", text: text2, time_created: timestampMs }] : [];
   }
-  return scope;
+  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 }] : [];
 }
-var IDENT_START_RE = /[A-Za-z_$]/;
+function toolPart(toolName, callId, input, timestampMs) {
+  return {
+    type: "tool",
+    tool: toolName,
+    callID: callId,
+    title: mapToolTitle2(toolName),
+    state: {
+      status: "running",
+      ...input === void 0 ? {} : { input },
+      output: null
+    },
+    time_created: timestampMs
+  };
+}
+function toolCallParts(message, timestampMs, ignoredToolCallIds) {
+  const calls = asArray(message.toolCalls) ?? [];
+  const parts = [];
+  for (const call of calls) {
+    const callRecord = asRecord(call);
+    const functionRecord = asRecord(callRecord?.function) ?? callRecord;
+    const toolName = asString(functionRecord?.name)?.trim() ?? "";
+    const callId = asString(callRecord?.id)?.trim() ?? "";
+    if (!toolName || !callId) continue;
+    if (KIMI_CODE_IGNORED_TOOLS.has(toolName)) {
+      ignoredToolCallIds.add(callId);
+      continue;
+    }
+    const rawArguments = functionRecord?.arguments ?? callRecord?.arguments;
+    parts.push(toolPart(toolName, callId, normalizeToolArguments2(rawArguments), timestampMs));
+  }
+  return parts;
+}
+function addToolResolution(builder, callId, output, timestampMs, isError = false, note) {
+  const outputParts = toolOutputParts(output, timestampMs);
+  return builder.resolveToolCall(callId, {
+    output: outputParts,
+    status: isError ? "error" : "completed",
+    ...note ? { metadata: { note: cleanInternalText(note) } } : {}
+  });
+}
+function usageNumber(usage, field) {
+  return asNumber(usage[field]) ?? 0;
+}
+function emptyStats() {
+  return {
+    message_count: 0,
+    total_input_tokens: 0,
+    total_output_tokens: 0,
+    total_cost: 0
+  };
+}
+function buildUsageTotals() {
+  return {
+    totalCost: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheReadTokens: 0,
+    totalCacheCreateTokens: 0,
+    modelUsage: {}
+  };
+}
+function applyUsage(builder, record, activeModel, totals) {
+  const usage = asRecord(record.usage);
+  if (!usage) return;
+  const cacheRead = usageNumber(usage, "inputCacheRead");
+  const cacheCreate = usageNumber(usage, "inputCacheCreation");
+  const inputOther = usageNumber(usage, "inputOther");
+  const output = usageNumber(usage, "output");
+  const input = inputOther + cacheRead + cacheCreate;
+  const model = asString(record.model) ?? activeModel;
+  const tokens = {
+    input,
+    output,
+    cache_read: cacheRead,
+    cache_create: cacheCreate
+  };
+  const cost = estimateTokenCost(model, tokens);
+  totals.totalInputTokens += input;
+  totals.totalOutputTokens += output;
+  totals.totalCacheReadTokens += cacheRead;
+  totals.totalCacheCreateTokens += cacheCreate;
+  if (model) totals.modelUsage[model] = (totals.modelUsage[model] ?? 0) + input + output;
+  if (cost !== null) totals.totalCost += cost;
+  builder.attachUsageToLatestAssistant(tokens, {
+    model,
+    cost: cost ?? void 0,
+    costSource: cost === null ? void 0 : "estimated"
+  });
+}
+function readState(stateFile) {
+  try {
+    return asRecord(JSON.parse(readFileSync4(stateFile, "utf-8"))) ?? null;
+  } catch {
+    return null;
+  }
+}
+var KimiCodeAgent = class extends FileSystemSessionSource {
+  name = "kimi-code";
+  displayName = "Kimi-Code";
+  basePath = null;
+  workDirBySessionPath = /* @__PURE__ */ new Map();
+  findBasePath() {
+    const sessionsPath = join9(resolveKimiCodeDataRoot(), "sessions");
+    return existsSync8(sessionsPath) ? sessionsPath : null;
+  }
+  getSessionWatchPlan() {
+    const dataRoot = resolveKimiCodeDataRoot();
+    return {
+      status: "supported",
+      targets: [
+        { root: dataRoot, path: join9(dataRoot, "sessions") },
+        { root: dataRoot, path: join9(dataRoot, "session_index.jsonl") }
+      ]
+    };
+  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    if (!this.basePath) return false;
+    try {
+      return this.listSessionDirs().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  loadSessionIndex() {
+    this.workDirBySessionPath.clear();
+    if (!this.basePath) return;
+    const indexPath = join9(dirname5(this.basePath), "session_index.jsonl");
+    if (!existsSync8(indexPath)) return;
+    for (const record of readJsonlFile(indexPath)) {
+      const sessionPath = asString(record.sessionDir);
+      const workDir = asString(record.workDir);
+      if (!sessionPath || !workDir) continue;
+      this.workDirBySessionPath.set(resolve(sessionPath), workDir);
+    }
+  }
+  listSessionDirs() {
+    if (!this.basePath) return [];
+    const dirs = [];
+    try {
+      for (const bucket of readdirSync5(this.basePath, { withFileTypes: true })) {
+        if (!bucket.isDirectory()) continue;
+        const bucketPath = join9(this.basePath, bucket.name);
+        for (const session of readdirSync5(bucketPath, { withFileTypes: true })) {
+          if (!session.isDirectory()) continue;
+          const sessionPath = join9(bucketPath, session.name);
+          if (existsSync8(join9(sessionPath, "state.json")) && existsSync8(join9(sessionPath, "agents", "main", "wire.jsonl"))) {
+            dirs.push(sessionPath);
+          }
+        }
+      }
+    } catch {
+      return dirs;
+    }
+    return dirs;
+  }
+  resolveSessionSourceResult(sessionDir) {
+    try {
+      const stateFile = join9(sessionDir, "state.json");
+      const wireFile = join9(sessionDir, "agents", "main", "wire.jsonl");
+      if (!existsSync8(stateFile) || !existsSync8(wireFile)) return skippedSession("missing wire");
+      const state = readState(stateFile);
+      if (!state) return skippedSession("malformed state");
+      const stateMtime = statSync5(stateFile).mtimeMs;
+      const wireMtime = statSync5(wireFile).mtimeMs;
+      const createdAt = parseTimestamp(state.createdAt) ?? parseTimestamp(state.created_at) ?? stateMtime;
+      const updatedAt = Math.max(
+        parseTimestamp(state.updatedAt) ?? parseTimestamp(state.updated_at) ?? createdAt,
+        wireMtime
+      );
+      const custom = asRecord(state.custom);
+      const workDir = asString(state.workDir) ?? asString(custom?.cwd) ?? this.workDirBySessionPath.get(resolve(sessionDir)) ?? "";
+      const explicitTitle = asString(state.title) ?? asString(state.customTitle) ?? "";
+      return parsedSession({
+        id: basename6(sessionDir),
+        sourcePath: sessionDir,
+        stateFile,
+        wireFile,
+        workDir,
+        createdAt,
+        updatedAt,
+        explicitTitle
+      });
+    } catch {
+      return skippedSession("malformed session");
+    }
+  }
+  sourceFingerprint(source) {
+    return JSON.stringify([
+      this.readFileMtimeMs(source.stateFile),
+      this.readFileMtimeMs(source.wireFile),
+      source.workDir
+    ]);
+  }
+  listSessionSources(options) {
+    if (!this.basePath) return [];
+    this.loadSessionIndex();
+    const refs = [];
+    for (const sessionDir of this.listSessionDirs()) {
+      const source = getParsedSession(this.resolveSessionSourceResult(sessionDir));
+      if (!source || !matchesScanWindow(source.createdAt, options)) continue;
+      refs.push({
+        sessionId: source.id,
+        sourcePath: source.sourcePath,
+        fingerprint: this.sourceFingerprint(source)
+      });
+    }
+    return refs;
+  }
+  checkForChanges(sinceTimestamp, cachedSessions) {
+    const result = super.checkForChanges(sinceTimestamp, cachedSessions);
+    const emptySessionIds = cachedSessions.filter((session) => !this.hasMessages(session)).map((session) => session.id);
+    if (emptySessionIds.length === 0) return result;
+    return {
+      ...result,
+      hasChanges: true,
+      changedIds: [.../* @__PURE__ */ new Set([...result.changedIds ?? [], ...emptySessionIds])]
+    };
+  }
+  filterCachedSessions(sessions) {
+    return this.removeEmptyCachedSessions(sessions);
+  }
+  incrementalScan(cachedSessions, changedIds, refs) {
+    const visibleSessions = this.removeEmptyCachedSessions(cachedSessions);
+    return super.incrementalScan(visibleSessions, changedIds, refs);
+  }
+  hasMessages(session) {
+    return session.stats.message_count > 0;
+  }
+  removeEmptyCachedSessions(sessions) {
+    return sessions.filter((session) => {
+      if (this.hasMessages(session)) return true;
+      this.sessionMetaMap.delete(session.id);
+      return false;
+    });
+  }
+  scanSessionSource(sourcePath) {
+    this.loadSessionIndex();
+    const source = getParsedSession(this.resolveSessionSourceResult(sourcePath));
+    if (!source) return null;
+    const parsed = this.parseWire(source);
+    const transcript = parsed.builder.finish(parsed.stats);
+    if (transcript.messages.length === 0) {
+      this.sessionMetaMap.delete(source.id);
+      return null;
+    }
+    const title = resolveSessionTitle(source.explicitTitle, parsed.firstUserTitle, null);
+    const meta = {
+      ...source,
+      title,
+      sourceMtimeMs: source.createdAt,
+      sourceFingerprint: this.sourceFingerprint(source)
+    };
+    this.sessionMetaMap.set(meta.id, meta);
+    return {
+      id: meta.id,
+      slug: `${this.name}/${meta.id}`,
+      title: meta.title,
+      directory: meta.workDir,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: transcript.stats,
+      ...Object.keys(parsed.modelUsage).length > 0 ? { model_usage: parsed.modelUsage } : {}
+    };
+  }
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) throw new Error(`Session not found: ${sessionId}`);
+    const parsed = this.parseWire(meta);
+    const transcript = parsed.builder.finish(parsed.stats);
+    return {
+      reference: { agentName: this.name, sessionId: meta.id },
+      id: meta.id,
+      title: meta.title,
+      slug: `${this.name}/${meta.id}`,
+      directory: meta.workDir,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: transcript.stats,
+      messages: transcript.messages
+    };
+  }
+  parseWire(source) {
+    const builder = new TranscriptBuilder();
+    const totals = buildUsageTotals();
+    const ignoredToolCallIds = /* @__PURE__ */ new Set();
+    let activeModel = null;
+    let activeProvider = null;
+    let firstUserTitle = null;
+    let sequence = 0;
+    for (const record of readJsonlFile(source.wireFile)) {
+      sequence += 1;
+      try {
+        const timestampMs = timestampFromRecord(record);
+        const recordType = asString(record.type) ?? "";
+        if (recordType === "llm.request") {
+          activeModel = asString(record.model) ?? activeModel;
+          activeProvider = asString(record.provider) ?? activeProvider;
+          continue;
+        }
+        if (recordType === "config.update") {
+          activeModel = asString(record.modelAlias) ?? activeModel;
+          continue;
+        }
+        if (recordType === "usage.record") {
+          applyUsage(builder, record, activeModel, totals);
+          continue;
+        }
+        if (recordType === "context.append_message") {
+          const message = asRecord(record.message);
+          if (!message) continue;
+          const role = asString(message.role) ?? "";
+          const messageTimestamp = timestampMs;
+          if (role === "user") {
+            const text = normalizeTitleText(contentText(message.content));
+            if (!firstUserTitle && text) firstUserTitle = text;
+          }
+          if (role === "tool") {
+            const callId = asString(message.toolCallId)?.trim() ?? "";
+            const output = message.content;
+            if (callId && ignoredToolCallIds.has(callId)) continue;
+            if (callId && addToolResolution(builder, callId, output, messageTimestamp)) continue;
+            const outputParts = toolOutputParts(output, messageTimestamp);
+            if (outputParts.length > 0) {
+              builder.appendMessage({
+                id: `wire-${sequence}`,
+                role: "tool",
+                timestampMs: messageTimestamp,
+                parts: outputParts
+              });
+            }
+            continue;
+          }
+          if (role !== "user" && role !== "assistant") continue;
+          const parts = [
+            ...contentParts(message.content, messageTimestamp),
+            ...role === "assistant" ? toolCallParts(message, messageTimestamp, ignoredToolCallIds) : []
+          ];
+          if (parts.length === 0) continue;
+          const allTools = parts.every((part) => part.type === "tool");
+          const input = {
+            id: `wire-${sequence}`,
+            role,
+            timestampMs: messageTimestamp,
+            parts,
+            ...role === "assistant" ? {
+              agent: this.name,
+              mode: allTools ? "tool" : void 0,
+              model: activeModel,
+              provider: activeProvider
+            } : {}
+          };
+          builder.appendMessage(input);
+          continue;
+        }
+        if (recordType === "context.append_loop_event") {
+          const event = asRecord(record.event);
+          if (!event) continue;
+          const eventType = asString(event.type) ?? "";
+          const metadata = {
+            id: `wire-${sequence}`,
+            timestampMs,
+            agent: this.name,
+            model: activeModel,
+            provider: activeProvider
+          };
+          if (eventType === "step.begin") {
+            builder.beginTurn();
+            continue;
+          }
+          if (eventType === "content.part") {
+            const part = asRecord(event.part);
+            if (!part) continue;
+            const parts = contentParts([part], timestampMs);
+            for (const contentPart of parts) {
+              if (contentPart.type === "tool") continue;
+              if (contentPart.type === "image" && builder.appendToCurrentAssistant(contentPart)) {
+                continue;
+              }
+              builder.appendAssistantPart(contentPart, metadata, { grouping: "current" });
+            }
+            continue;
+          }
+          if (eventType === "tool.call") {
+            const toolName = asString(event.name)?.trim() ?? "";
+            const callId = asString(event.toolCallId)?.trim() ?? "";
+            if (!toolName || !callId) continue;
+            if (KIMI_CODE_IGNORED_TOOLS.has(toolName)) {
+              ignoredToolCallIds.add(callId);
+              continue;
+            }
+            builder.appendToolCall(toolPart(toolName, callId, event.args, timestampMs), metadata, {
+              markModeAsTool: true,
+              target: "current"
+            });
+            continue;
+          }
+          if (eventType === "tool.result") {
+            const callId = asString(event.toolCallId)?.trim() ?? "";
+            const result = asRecord(event.result);
+            if (!callId || ignoredToolCallIds.has(callId)) continue;
+            const output = result?.output;
+            const isError = result?.isError === true;
+            const note = asString(result?.note);
+            if (addToolResolution(builder, callId, output, timestampMs, isError, note)) continue;
+            const outputParts = toolOutputParts(output, timestampMs);
+            if (outputParts.length > 0) {
+              builder.appendMessage({
+                id: `wire-${sequence}`,
+                role: "tool",
+                timestampMs,
+                parts: outputParts
+              });
+            }
+          }
+          continue;
+        }
+        if (recordType === "context.apply_compaction") {
+          const summary = cleanInternalText(asString(record.summary) ?? "");
+          if (summary) {
+            builder.appendMessage({
+              id: `wire-${sequence}`,
+              role: "user",
+              timestampMs,
+              parts: [{ type: "text", text: summary, time_created: timestampMs }]
+            });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    const stats = {
+      ...emptyStats(),
+      total_input_tokens: totals.totalInputTokens,
+      total_output_tokens: totals.totalOutputTokens,
+      total_cost: Number(totals.totalCost.toFixed(8)),
+      total_tokens: totals.totalInputTokens + totals.totalOutputTokens,
+      ...totals.totalCacheReadTokens > 0 ? { total_cache_read_tokens: totals.totalCacheReadTokens } : {},
+      ...totals.totalCacheCreateTokens > 0 ? { total_cache_create_tokens: totals.totalCacheCreateTokens } : {},
+      ...totals.totalCost > 0 ? { cost_source: "estimated" } : {}
+    };
+    return { builder, stats, firstUserTitle, modelUsage: totals.modelUsage };
+  }
+};
+var PARSE_FAIL = /* @__PURE__ */ Symbol("parse-fail");
+var EXEC_OUTPUT_ENVELOPE_RE = /^Script completed\nWall time [^\n]*\nOutput:\n?/;
+function stripExecOutputEnvelope(text) {
+  return text.replace(EXEC_OUTPUT_ENVELOPE_RE, "");
+}
+function splitExecToolName(name) {
+  if (name.startsWith("mcp__")) {
+    const separator = name.lastIndexOf("__");
+    if (separator > 0 && separator + 2 < name.length) {
+      return { name: name.slice(separator + 2), namespace: name.slice(0, separator + 2) };
+    }
+  }
+  return { name };
+}
+function pickExecOutputTarget(calls) {
+  for (let index = calls.length - 1; index >= 0; index -= 1) {
+    const { name } = splitExecToolName(calls[index].name);
+    if (name !== "apply_patch" && name !== "update_plan") return index;
+  }
+  return calls.length - 1;
+}
+function getExecPatchText(args) {
+  if (typeof args === "string") return args;
+  if (args && typeof args === "object") {
+    const patch = args["patch"];
+    if (typeof patch === "string") return patch;
+  }
+  return "";
+}
+function decodeExecCalls(input) {
+  if (typeof input !== "string" || !input.includes("tools.")) return [];
+  const scope = collectStringVars(input);
+  const calls = [];
+  const callRe = /tools\.([A-Za-z_$][\w$]*)\s*\(/g;
+  let match;
+  while ((match = callRe.exec(input)) !== null) {
+    const reader = new JsValueReader(input, callRe.lastIndex, scope);
+    const args = reader.parseValue();
+    if (args !== PARSE_FAIL) {
+      calls.push({ name: match[1], args });
+      callRe.lastIndex = reader.pos;
+    }
+  }
+  return calls;
+}
+function collectStringVars(input) {
+  const scope = /* @__PURE__ */ new Map();
+  const assignRe = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*/g;
+  let match;
+  while ((match = assignRe.exec(input)) !== null) {
+    const reader = new JsValueReader(input, assignRe.lastIndex, scope);
+    const value = reader.parseValue();
+    if (value !== PARSE_FAIL) {
+      if (typeof value === "string") scope.set(match[1], value);
+      assignRe.lastIndex = reader.pos;
+    }
+  }
+  return scope;
+}
+var IDENT_START_RE = /[A-Za-z_$]/;
 var IDENT_PART_RE = /[\w$]/;
 var JsValueReader = class {
   pos;
@@ -3543,7 +4687,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 +4710,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 +4739,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 +4772,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 +4799,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 +4891,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,38 +4910,143 @@ 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") }
       ]
     };
   }
-  isAvailable() {
-    this.basePath = this.findBasePath();
-    if (!this.basePath) return false;
-    return this.listRolloutFiles().length > 0;
-  }
-  listSessionSources(options) {
-    if (!this.basePath) return [];
-    this.loadSessionIndex();
-    return this.listRolloutFiles(options).map(({ file, stat }) => ({
-      sessionId: extractSessionId(file),
-      sourcePath: file,
-      fingerprint: this.sourceFingerprint(file, stat)
-    }));
-  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    if (!this.basePath) return false;
+    return this.listRolloutFiles().length > 0;
+  }
+  listSessionSources(options) {
+    if (!this.basePath) return [];
+    this.loadSessionIndex();
+    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 +5129,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 +5251,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 +5311,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 +5328,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 +5342,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 +5374,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 +5387,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 +5417,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 +5513,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 +5527,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 +5538,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 +5553,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,29 +5649,18 @@ 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();
-      const planPart = {
+      const planPart2 = {
         type: "plan",
         text: planText2,
         approval_status: "success",
         time_created: timestampMs
       };
-      pendingPlan = planPart;
+      pendingPlan = planPart2;
     }
     const displayText = cleanInternalText(fullText.replace(PROPOSED_PLAN_PATTERN, ""));
     if (!displayText) return pendingPlan;
@@ -4341,8 +5765,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 +5780,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4388,7 +5812,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 +5826,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4419,7 +5843,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 +5857,7 @@ var CodexAgent = class extends SingleFileSessionSource {
       time_created: timestampMs
     };
     transcript.appendToolCall(
-      toolPart,
+      toolPart2,
       { id: "", timestampMs, agent: "codex", model: activeModel },
       { markModeAsTool: true }
     );
@@ -4518,15 +5942,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 +6079,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 +6140,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 +6188,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 +6197,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 +6211,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 +6261,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 +6616,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 +6649,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 +6777,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 +6833,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 +6861,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 +6954,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 +7097,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 +7108,7 @@ var PiAgent = class extends SingleFileSessionSource {
             input: item["arguments"] ?? {}
           }
         };
-        parts.push(toolPart);
+        parts.push(toolPart2);
       }
     }
     return parts;
@@ -5739,70 +7163,790 @@ var PiAgent = class extends SingleFileSessionSource {
     const text = cleanInternalText(rawText);
     if (!text) return null;
     return {
-      id: narrowPiField("summary.id", entry["id"], asString) ?? "",
-      role: type === "custom_message" ? "user" : "assistant",
-      agent: type === "custom_message" ? void 0 : "pi",
-      timestampMs,
-      parts: [{ type: "text", text, time_created: timestampMs }]
+      id: narrowPiField("summary.id", entry["id"], asString) ?? "",
+      role: type === "custom_message" ? "user" : "assistant",
+      agent: type === "custom_message" ? void 0 : "pi",
+      timestampMs,
+      parts: [{ type: "text", text, time_created: timestampMs }]
+    };
+  }
+  normalizeUsage(raw) {
+    const usage = narrowPiField("message.usage", raw, asRecord) ?? {};
+    const inputTokens = narrowPiField("message.usage.input", usage["input"], asNumber) ?? 0;
+    const outputTokens = narrowPiField("message.usage.output", usage["output"], asNumber) ?? 0;
+    const cacheReadTokens = narrowPiField("message.usage.cacheRead", usage["cacheRead"], asNumber) ?? 0;
+    const cacheCreateTokens = narrowPiField("message.usage.cacheWrite", usage["cacheWrite"], asNumber) ?? 0;
+    const totalTokens = narrowPiField("message.usage.totalTokens", usage["totalTokens"], asNumber) ?? inputTokens + outputTokens + cacheReadTokens + cacheCreateTokens;
+    const cost = isObject(usage["cost"]) ? Number(usage["cost"]["total"] ?? 0) : null;
+    return {
+      inputTokens: inputTokens + cacheReadTokens + cacheCreateTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheCreateTokens,
+      totalTokens,
+      cost: cost && Number.isFinite(cost) ? cost : null,
+      tokens: {
+        input: inputTokens + cacheReadTokens + cacheCreateTokens,
+        output: outputTokens,
+        cache_read: cacheReadTokens || void 0,
+        cache_create: cacheCreateTokens || void 0
+      }
+    };
+  }
+  emptyUsageResult(message) {
+    return {
+      message,
+      totalTokens: 0,
+      model: null
+    };
+  }
+};
+function resolveZCodeDataRoot() {
+  const currentPlatform = platform3();
+  if (currentPlatform !== "darwin" && currentPlatform !== "win32") return null;
+  return join13(homedir4(), ".zcode");
+}
+function findZCodeDbPath() {
+  if (!isSqliteAvailable()) return null;
+  const dataRoot = resolveZCodeDataRoot();
+  if (!dataRoot) return null;
+  return firstExisting(join13(dataRoot, "cli", "db", "db.sqlite"));
+}
+function getZCodeSessionWatchPlan() {
+  const dataRoot = resolveZCodeDataRoot();
+  return {
+    status: "supported",
+    targets: dataRoot ? [{ root: dataRoot, path: join13(dataRoot, "cli", "db", "db.sqlite") }] : []
+  };
+}
+var ZCodeAgent = class extends OpenCodeSqliteAgent {
+  constructor() {
+    super({
+      name: "zcode",
+      displayName: "ZCode",
+      findDbPath: findZCodeDbPath,
+      getSessionWatchPlan: getZCodeSessionWatchPlan
+    });
+  }
+};
+var HEAD_INDEX_VERSION4 = "grok-head-v1";
+var PARSER_VERSION3 = "grok-parser-v1";
+var SUMMARY_FILE = "summary.json";
+var UPDATES_FILE = "updates.jsonl";
+var ACP_UPDATE_METHOD = "session/update";
+var XAI_UPDATE_METHOD = "_x.ai/session/update";
+var USD_TICKS_PER_USD = 1e10;
+var GROK_TOOL_TITLE_MAP = {
+  get_command_or_subagent_output: "task",
+  grep: "grep",
+  list_dir: "list",
+  read_file: "read",
+  run_terminal_command: "bash",
+  search_replace: "edit",
+  todo_write: "todo",
+  web_fetch: "web fetch"
+};
+function resolveGrokDataRoot() {
+  return resolveHomePath("GROK_HOME", ".grok");
+}
+function safeCount(value) {
+  const number = asNumber(value);
+  return number !== void 0 && Number.isSafeInteger(number) && number >= 0 ? number : 0;
+}
+function addCount(total, value) {
+  return Math.min(Number.MAX_SAFE_INTEGER, total + value);
+}
+function timestampFromIso(value) {
+  const text = asString(value);
+  if (!text) return null;
+  const timestamp = Date.parse(text);
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+function readJsonRecord(filePath) {
+  try {
+    return asRecord(JSON.parse(readFileSync7(filePath, "utf8"))) ?? null;
+  } catch {
+    return null;
+  }
+}
+function parseSummary(source) {
+  const summary = readJsonRecord(source.file);
+  const info = asRecord(summary?.info);
+  const id = asString(info?.id)?.trim();
+  const cwd = asString(info?.cwd)?.trim();
+  if (!id || !cwd) return null;
+  const createdAt = timestampFromIso(summary?.created_at) ?? source.stat.mtimeMs;
+  const updatedAt = timestampFromIso(summary?.last_active_at) ?? timestampFromIso(summary?.updated_at) ?? createdAt;
+  const generatedTitle = asString(summary?.generated_title)?.trim();
+  const sessionSummary = asString(summary?.session_summary)?.trim();
+  const parentSessionId = asString(summary?.parent_session_id)?.trim() || null;
+  return {
+    id,
+    cwd,
+    title: generatedTitle || sessionSummary || null,
+    createdAt,
+    updatedAt,
+    messageCount: safeCount(summary?.num_chat_messages),
+    currentModel: asString(summary?.current_model_id)?.trim() || null,
+    parentSessionId: parentSessionId === id ? null : parentSessionId
+  };
+}
+function optionalFileFingerprint(filePath) {
+  try {
+    const stat = statSync8(filePath);
+    return [stat.mtimeMs, stat.size];
+  } catch {
+    return null;
+  }
+}
+function unpackUpdate(record, fallbackTimestampMs) {
+  const method = asString(record.method) ?? ACP_UPDATE_METHOD;
+  const params = asRecord(record.params) ?? record;
+  const update = asRecord(params.update);
+  if (!update) return null;
+  const paramsMeta = asRecord(params._meta);
+  const agentTimestampMs = asNumber(paramsMeta?.agentTimestampMs);
+  const envelopeTimestamp = asNumber(record.timestamp);
+  const timestampMs = agentTimestampMs !== void 0 && Number.isSafeInteger(agentTimestampMs) && agentTimestampMs >= 0 ? agentTimestampMs : envelopeTimestamp !== void 0 && Number.isSafeInteger(envelopeTimestamp) && envelopeTimestamp >= 0 && envelopeTimestamp <= Number.MAX_SAFE_INTEGER / 1e3 ? envelopeTimestamp * 1e3 : fallbackTimestampMs;
+  return { method, params, update, timestampMs };
+}
+function isHostTurn(update) {
+  return asRecord(update._meta)?.hostTurn === true;
+}
+function updateType(update) {
+  return asString(update.update.sessionUpdate) ?? "";
+}
+function parseUsage(update) {
+  const usage = asRecord(update.usage);
+  if (!usage) return null;
+  const input = safeCount(usage.inputTokens);
+  const output = safeCount(usage.outputTokens);
+  const reasoning = safeCount(usage.reasoningTokens);
+  const cacheRead = safeCount(usage.cachedReadTokens);
+  const cacheCreate = safeCount(usage.cacheCreationTokens);
+  const totalTokens = safeCount(usage.totalTokens) || addCount(input, output);
+  const isIncomplete = usage.usageIsIncomplete === true || usage.costIsPartial === true;
+  const costTicks = safeCount(usage.costUsdTicks);
+  const cost = !isIncomplete && costTicks > 0 ? costTicks / USD_TICKS_PER_USD : null;
+  const modelUsage = {};
+  const modelUsageRecord = asRecord(usage.modelUsage);
+  if (modelUsageRecord) {
+    for (const [model, rawUsage] of Object.entries(modelUsageRecord)) {
+      const modelRecord = asRecord(rawUsage);
+      if (!modelRecord) continue;
+      const modelTotal = safeCount(modelRecord.totalTokens) || addCount(safeCount(modelRecord.inputTokens), safeCount(modelRecord.outputTokens));
+      if (modelTotal > 0) modelUsage[model] = modelTotal;
+    }
+  }
+  const models = Object.keys(modelUsage);
+  return {
+    tokens: {
+      input,
+      output,
+      reasoning: reasoning || void 0,
+      cache_read: cacheRead || void 0,
+      cache_create: cacheCreate || void 0
+    },
+    totalTokens,
+    cost,
+    modelUsage,
+    primaryModel: models.length === 1 ? models[0] : null
+  };
+}
+function textFromContentBlock(value) {
+  const content = asRecord(value);
+  if (!content) return "";
+  if (content.type === "text") return asString(content.text) ?? "";
+  const resource = asRecord(content.resource);
+  return asString(resource?.text) ?? "";
+}
+function messagePartFromContentBlock(value, timestampMs) {
+  const content = asRecord(value);
+  if (!content) return null;
+  if (content.type === "text") {
+    const text2 = asString(content.text) ?? "";
+    return text2 ? { type: "text", text: text2, time_created: timestampMs } : null;
+  }
+  if (content.type === "image") {
+    const data = asString(content.data);
+    const url = asString(content.uri) ?? asString(content.url);
+    const mimeType = asString(content.mimeType) ?? asString(content.mime_type);
+    if (data && mimeType) {
+      return { type: "image", data, mime_type: mimeType, url, time_created: timestampMs };
+    }
+    if (url) return { type: "image", url, mime_type: mimeType, time_created: timestampMs };
+  }
+  const text = textFromContentBlock(content);
+  return text ? { type: "text", text, time_created: timestampMs } : null;
+}
+var GrokMessageCounter = class {
+  firstUserText = null;
+  messageCount = 0;
+  activeAssistant = false;
+  activeAssistantPromptId = null;
+  activeUser = false;
+  activeUserPromptIndex = null;
+  process(envelope) {
+    if (envelope.method === XAI_UPDATE_METHOD) return;
+    switch (updateType(envelope)) {
+      case "user_message_chunk":
+        this.appendUser(envelope);
+        break;
+      case "agent_thought_chunk":
+      case "agent_message_chunk":
+        if (cleanInternalText(textFromContentBlock(envelope.update.content))) {
+          this.appendAssistant(envelope);
+        }
+        break;
+      case "tool_call":
+        if (asString(envelope.update.toolCallId)?.trim()) this.appendAssistant(envelope);
+        break;
+      case "plan":
+        if (planPart(envelope.update, envelope.timestampMs)) this.appendAssistant(envelope);
+        break;
+    }
+  }
+  appendUser(envelope) {
+    if (isHostTurn(envelope.update)) return;
+    const part = messagePartFromContentBlock(envelope.update.content, envelope.timestampMs);
+    if (!part) return;
+    if (part.type === "text" && !cleanInternalText(part.text)) return;
+    const promptIndexValue = asNumber(asRecord(envelope.update._meta)?.promptIndex);
+    const promptIndex = promptIndexValue !== void 0 && Number.isSafeInteger(promptIndexValue) ? promptIndexValue : null;
+    const canReuse = this.activeUser && (promptIndex === null || this.activeUserPromptIndex === null || promptIndex === this.activeUserPromptIndex);
+    if (!canReuse) this.messageCount += 1;
+    if (this.firstUserText === null && part.type === "text") {
+      this.firstUserText = cleanInternalText(part.text) || null;
+    }
+    this.activeUser = true;
+    this.activeUserPromptIndex = promptIndex;
+    this.activeAssistant = false;
+    this.activeAssistantPromptId = null;
+  }
+  appendAssistant(envelope) {
+    const promptId = asString(asRecord(envelope.params._meta)?.promptId)?.trim() || null;
+    if (promptId && this.activeAssistantPromptId && promptId !== this.activeAssistantPromptId) {
+      this.activeAssistant = false;
+    }
+    if (promptId) this.activeAssistantPromptId = promptId;
+    this.activeUser = false;
+    this.activeUserPromptIndex = null;
+    if (!this.activeAssistant) this.messageCount += 1;
+    this.activeAssistant = true;
+  }
+};
+function scanCanonicalMessages(updatesPath, fallbackTimestampMs) {
+  const rewindIndex = new RewindIndex();
+  let recordIndex = 0;
+  for (const record of readJsonlFile(updatesPath)) {
+    rewindIndex.process(record, recordIndex, fallbackTimestampMs);
+    recordIndex += 1;
+  }
+  const survivingIndexes = new Set(rewindIndex.survivingRecordIndexes);
+  const counter = new GrokMessageCounter();
+  recordIndex = 0;
+  for (const record of readJsonlFile(updatesPath)) {
+    if (survivingIndexes.has(recordIndex)) {
+      const envelope = unpackUpdate(record, fallbackTimestampMs);
+      if (envelope) counter.process(envelope);
+    }
+    recordIndex += 1;
+  }
+  return counter;
+}
+function scanHeadData(updatesPath, fallbackTimestampMs) {
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalCacheCreateTokens = 0;
+  let totalTokens = 0;
+  let totalCost = 0;
+  let hasUnknownCost = false;
+  let hasRewinds = false;
+  const modelUsage = {};
+  let messageCounter = new GrokMessageCounter();
+  if (updatesPath && existsSync12(updatesPath)) {
+    for (const line of readJsonlFileLines(updatesPath)) {
+      const affectsMessages = line.includes('"user_message_chunk"') || line.includes('"agent_thought_chunk"') || line.includes('"agent_message_chunk"') || line.includes('"tool_call"') || line.includes('"plan"');
+      const isTurnCompleted = line.includes('"turn_completed"');
+      const isRewind = line.includes('"rewind_marker"');
+      if (!affectsMessages && !isTurnCompleted && !isRewind) continue;
+      let record;
+      try {
+        record = asRecord(JSON.parse(line)) ?? {};
+      } catch {
+        continue;
+      }
+      const envelope = unpackUpdate(record, fallbackTimestampMs);
+      if (!envelope) continue;
+      const type = updateType(envelope);
+      if (affectsMessages) messageCounter.process(envelope);
+      if (envelope.method === XAI_UPDATE_METHOD && type === "rewind_marker") {
+        hasRewinds = true;
+      }
+      if (envelope.method !== XAI_UPDATE_METHOD || type !== "turn_completed") continue;
+      const usage = parseUsage(envelope.update);
+      if (!usage) continue;
+      totalInputTokens = addCount(totalInputTokens, usage.tokens.input ?? 0);
+      totalOutputTokens = addCount(totalOutputTokens, usage.tokens.output ?? 0);
+      totalCacheReadTokens = addCount(totalCacheReadTokens, usage.tokens.cache_read ?? 0);
+      totalCacheCreateTokens = addCount(totalCacheCreateTokens, usage.tokens.cache_create ?? 0);
+      totalTokens = addCount(totalTokens, usage.totalTokens);
+      if (usage.cost === null && usage.totalTokens > 0) hasUnknownCost = true;
+      else totalCost += usage.cost ?? 0;
+      for (const [model, tokens] of Object.entries(usage.modelUsage)) {
+        modelUsage[model] = addCount(modelUsage[model] ?? 0, tokens);
+      }
+    }
+    if (hasRewinds) messageCounter = scanCanonicalMessages(updatesPath, fallbackTimestampMs);
+  }
+  return {
+    firstUserText: messageCounter.firstUserText,
+    visibleMessageCount: messageCounter.messageCount,
+    stats: {
+      total_input_tokens: totalInputTokens,
+      total_output_tokens: totalOutputTokens,
+      total_cache_read_tokens: totalCacheReadTokens || void 0,
+      total_cache_create_tokens: totalCacheCreateTokens || void 0,
+      total_tokens: totalTokens || addCount(totalInputTokens, totalOutputTokens),
+      total_cost: totalCost,
+      cost_source: totalCost > 0 && !hasUnknownCost ? "recorded" : void 0
+    },
+    modelUsage
+  };
+}
+function toolTitle(toolName) {
+  return GROK_TOOL_TITLE_MAP[toolName] ?? toolName;
+}
+function toolStatus(value) {
+  switch (asString(value)?.toLowerCase()) {
+    case "completed":
+      return "completed";
+    case "failed":
+      return "error";
+    case "in_progress":
+    case "pending":
+      return "running";
+    default:
+      return null;
+  }
+}
+function toolOutput(update) {
+  if (update.rawOutput !== void 0 && update.rawOutput !== null) return update.rawOutput;
+  const content = asArray(update.content);
+  if (!content) return void 0;
+  const texts = content.flatMap((item) => {
+    const wrapper = asRecord(item);
+    const block = wrapper?.type === "content" ? wrapper.content : item;
+    const text = textFromContentBlock(block);
+    return text ? [text] : [];
+  });
+  if (texts.length === 0) return content;
+  return texts.join("\n");
+}
+function planPart(update, timestampMs) {
+  const entries = asArray(update.entries)?.flatMap((value) => {
+    const entry = asRecord(value);
+    const content = cleanInternalText(asString(entry?.content) ?? "");
+    if (!entry || !content) return [];
+    return [{ content, status: asString(entry.status) ?? "pending" }];
+  });
+  if (!entries || entries.length === 0) return null;
+  const text = entries.map(({ content, status }) => `- [${status === "completed" ? "x" : " "}] ${content}`).join("\n");
+  return {
+    type: "plan",
+    text,
+    approval_status: entries.every(({ status }) => status === "completed") ? "success" : "fail",
+    time_created: timestampMs
+  };
+}
+var GrokTranscriptReducer = class {
+  constructor(sessionId, currentModel, fallbackTimestampMs) {
+    this.sessionId = sessionId;
+    this.fallbackTimestampMs = fallbackTimestampMs;
+    this.currentModel = currentModel;
+  }
+  sessionId;
+  fallbackTimestampMs;
+  builder = new TranscriptBuilder();
+  activeAssistant = null;
+  activeAssistantPromptId = null;
+  activeUser = null;
+  activeUserPromptIndex = null;
+  latestPlan = null;
+  currentMode = null;
+  currentModel;
+  process(record) {
+    const envelope = unpackUpdate(record, this.fallbackTimestampMs);
+    if (!envelope) return;
+    if (envelope.method === XAI_UPDATE_METHOD) {
+      this.processXaiUpdate(envelope);
+      return;
+    }
+    this.processAcpUpdate(envelope);
+  }
+  finish(stats) {
+    return this.builder.finish(stats);
+  }
+  processAcpUpdate(envelope) {
+    switch (updateType(envelope)) {
+      case "user_message_chunk":
+        this.appendUserChunk(envelope);
+        break;
+      case "agent_thought_chunk":
+        this.appendAssistantText(envelope, "reasoning");
+        break;
+      case "agent_message_chunk":
+        this.appendAssistantText(envelope, "text");
+        break;
+      case "tool_call":
+        this.appendToolCall(envelope);
+        break;
+      case "tool_call_update":
+        this.updateToolCall(envelope);
+        break;
+      case "plan":
+        this.updatePlan(envelope);
+        break;
+      case "current_mode_update":
+        this.currentMode = asString(envelope.update.currentModeId)?.trim() || null;
+        break;
+    }
+  }
+  processXaiUpdate(envelope) {
+    switch (updateType(envelope)) {
+      case "turn_completed": {
+        const usage = parseUsage(envelope.update);
+        if (!usage) return;
+        this.builder.attachUsageToLatestAssistant(usage.tokens, {
+          model: usage.primaryModel ?? this.currentModel,
+          cost: usage.cost ?? void 0,
+          costSource: usage.cost === null ? void 0 : "recorded"
+        });
+        return;
+      }
+      case "model_changed":
+        this.currentModel = asString(envelope.update.model_id)?.trim() || this.currentModel;
+        return;
+      case "model_auto_switched":
+        this.currentModel = asString(envelope.update.new_model_id)?.trim() || this.currentModel;
+        return;
+      case "subagent_spawned": {
+        const childSessionId = asString(envelope.update.child_session_id)?.trim();
+        if (childSessionId && this.activeAssistant && !this.activeAssistant.subagent_id) {
+          this.activeAssistant.subagent_id = childSessionId;
+        }
+      }
+    }
+  }
+  appendUserChunk(envelope) {
+    if (isHostTurn(envelope.update)) return;
+    const part = messagePartFromContentBlock(envelope.update.content, envelope.timestampMs);
+    if (!part) return;
+    const promptIndexValue = asNumber(asRecord(envelope.update._meta)?.promptIndex);
+    const promptIndex = promptIndexValue !== void 0 && Number.isSafeInteger(promptIndexValue) ? promptIndexValue : null;
+    const canReuse = this.activeUser !== null && (promptIndex === null || this.activeUserPromptIndex === null || promptIndex === this.activeUserPromptIndex);
+    if (canReuse) {
+      const tail = this.activeUser.parts.at(-1);
+      if (tail?.type === "text" && part.type === "text") tail.text += part.text;
+      else this.activeUser.parts.push(part);
+    } else {
+      const eventId = asString(asRecord(envelope.params._meta)?.eventId);
+      this.activeUser = this.builder.appendMessage({
+        id: eventId || `${this.sessionId}-user-${envelope.timestampMs}`,
+        role: "user",
+        timestampMs: envelope.timestampMs,
+        parts: [part]
+      });
+    }
+    this.activeUserPromptIndex = promptIndex;
+    this.activeAssistant = null;
+    this.activeAssistantPromptId = null;
+    this.latestPlan = null;
+  }
+  prepareAssistant(envelope) {
+    const promptId = asString(asRecord(envelope.params._meta)?.promptId)?.trim() || null;
+    if (promptId && this.activeAssistantPromptId && promptId !== this.activeAssistantPromptId) {
+      this.builder.beginTurn();
+      this.activeAssistant = null;
+      this.latestPlan = null;
+    }
+    if (promptId) this.activeAssistantPromptId = promptId;
+    this.activeUser = null;
+    this.activeUserPromptIndex = null;
+  }
+  assistantInput(envelope) {
+    const paramsMeta = asRecord(envelope.params._meta);
+    return {
+      id: asString(paramsMeta?.promptId) || asString(paramsMeta?.eventId) || `${this.sessionId}-assistant-${envelope.timestampMs}`,
+      timestampMs: envelope.timestampMs,
+      agent: "grok",
+      mode: this.currentMode,
+      model: this.currentModel,
+      provider: "xai"
+    };
+  }
+  appendAssistantText(envelope, type) {
+    const text = textFromContentBlock(envelope.update.content);
+    if (!text) return;
+    this.prepareAssistant(envelope);
+    const tail = this.activeAssistant?.parts.at(-1);
+    if (tail?.type === type) {
+      tail.text += text;
+      return;
+    }
+    this.activeAssistant = this.builder.appendAssistantPart(
+      { type, text, time_created: envelope.timestampMs },
+      this.assistantInput(envelope),
+      { grouping: "current" }
+    );
+  }
+  appendToolCall(envelope) {
+    const callId = asString(envelope.update.toolCallId)?.trim();
+    const updateMeta = asRecord(envelope.update._meta);
+    const nativeTool = asRecord(updateMeta?.["x.ai/tool"]);
+    const name = asString(nativeTool?.name)?.trim() || asString(envelope.update.title)?.trim() || "tool";
+    if (!callId) return;
+    this.prepareAssistant(envelope);
+    const metadata = {
+      kind: asString(nativeTool?.kind) ?? asString(envelope.update.kind),
+      locations: envelope.update.locations
+    };
+    const part = {
+      type: "tool",
+      tool: name,
+      title: toolTitle(name),
+      callID: callId,
+      state: {
+        status: toolStatus(envelope.update.status) ?? "running",
+        input: envelope.update.rawInput,
+        output: null,
+        metadata
+      },
+      time_created: envelope.timestampMs
+    };
+    this.activeAssistant = this.builder.appendToolCall(part, this.assistantInput(envelope), {
+      markModeAsTool: true,
+      target: "current"
+    });
+  }
+  updateToolCall(envelope) {
+    const callId = asString(envelope.update.toolCallId)?.trim();
+    if (!callId) return;
+    this.builder.updateToolCall(callId, (part) => {
+      const status = toolStatus(envelope.update.status);
+      if (status) part.state.status = status;
+      if (envelope.update.rawInput !== void 0) part.state.input = envelope.update.rawInput;
+      const output = toolOutput(envelope.update);
+      if (output !== void 0) {
+        if (status === "error") part.state.error = output;
+        else part.state.output = output;
+      }
+      const metadata = asRecord(part.state.metadata) ?? {};
+      if (envelope.update.kind !== void 0) metadata.kind = envelope.update.kind;
+      if (envelope.update.locations !== void 0) metadata.locations = envelope.update.locations;
+      part.state.metadata = metadata;
+    });
+  }
+  updatePlan(envelope) {
+    const part = planPart(envelope.update, envelope.timestampMs);
+    if (!part) return;
+    this.prepareAssistant(envelope);
+    if (this.latestPlan) {
+      this.latestPlan.text = part.text;
+      this.latestPlan.approval_status = part.approval_status;
+      this.latestPlan.time_created = part.time_created;
+      return;
+    }
+    this.latestPlan = part;
+    this.activeAssistant = this.builder.appendAssistantPart(part, this.assistantInput(envelope), {
+      grouping: "current"
+    });
+  }
+};
+var UserRunTracker = class {
+  hasSeenPromptIndex = false;
+  isInUserRun = false;
+  currentPromptIndex = null;
+  onUser(promptIndex) {
+    if (promptIndex !== null) this.hasSeenPromptIndex = true;
+    const isCounted = this.hasSeenPromptIndex ? promptIndex !== null : true;
+    const isNewRun = !this.isInUserRun || (this.hasSeenPromptIndex || promptIndex !== null) && promptIndex !== this.currentPromptIndex;
+    this.isInUserRun = true;
+    if (!isNewRun) return false;
+    this.currentPromptIndex = promptIndex;
+    return isCounted;
+  }
+  onNonUser() {
+    this.isInUserRun = false;
+    this.currentPromptIndex = null;
+  }
+};
+var RewindIndex = class {
+  survivingRecordIndexes = [];
+  hasRewinds = false;
+  promptStarts = [];
+  userRuns = new UserRunTracker();
+  process(record, recordIndex, fallbackTimestampMs) {
+    const envelope = unpackUpdate(record, fallbackTimestampMs);
+    if (!envelope) {
+      this.userRuns.onNonUser();
+      this.survivingRecordIndexes.push(recordIndex);
+      return;
+    }
+    const type = updateType(envelope);
+    if (envelope.method === XAI_UPDATE_METHOD && type === "rewind_marker") {
+      const target = asNumber(envelope.update.target_prompt_index);
+      if (target === void 0 || !Number.isSafeInteger(target) || target < 0) {
+        this.userRuns.onNonUser();
+        this.survivingRecordIndexes.push(recordIndex);
+        return;
+      }
+      const truncateAt = this.promptStarts[target] ?? this.survivingRecordIndexes.length;
+      this.survivingRecordIndexes.length = truncateAt;
+      this.promptStarts.length = Math.min(this.promptStarts.length, target);
+      this.userRuns.onNonUser();
+      this.hasRewinds = true;
+      return;
+    }
+    if (envelope.method !== XAI_UPDATE_METHOD && type === "user_message_chunk" && !isHostTurn(envelope.update)) {
+      const rawPromptIndex = asNumber(asRecord(envelope.update._meta)?.promptIndex);
+      const promptIndex = rawPromptIndex !== void 0 && Number.isSafeInteger(rawPromptIndex) && rawPromptIndex >= 0 ? rawPromptIndex : null;
+      if (this.userRuns.onUser(promptIndex)) {
+        this.promptStarts.push(this.survivingRecordIndexes.length);
+      }
+    } else {
+      this.userRuns.onNonUser();
+    }
+    this.survivingRecordIndexes.push(recordIndex);
+  }
+};
+function parseTranscript(meta) {
+  const reducer = new GrokTranscriptReducer(meta.id, meta.currentModel, meta.createdAt);
+  if (!meta.updatesPath || !existsSync12(meta.updatesPath)) return reducer.finish(meta.stats);
+  const rewindIndex = new RewindIndex();
+  let recordIndex = 0;
+  for (const record of readJsonlFile(meta.updatesPath)) {
+    rewindIndex.process(record, recordIndex, meta.createdAt);
+    reducer.process(record);
+    recordIndex += 1;
+  }
+  if (!rewindIndex.hasRewinds) return reducer.finish(meta.stats);
+  const survivingIndexes = new Set(rewindIndex.survivingRecordIndexes);
+  const replay = new GrokTranscriptReducer(meta.id, meta.currentModel, meta.createdAt);
+  recordIndex = 0;
+  for (const record of readJsonlFile(meta.updatesPath)) {
+    if (survivingIndexes.has(recordIndex)) replay.process(record);
+    recordIndex += 1;
+  }
+  return replay.finish(meta.stats);
+}
+var GrokAgent = class extends FileSystemSessionSource {
+  name = "grok";
+  displayName = "Grok";
+  basePath = null;
+  findBasePath() {
+    return firstExisting(join14(resolveGrokDataRoot(), "sessions"), "data/grok");
+  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    return this.basePath !== null && this.listSessionSources().length > 0;
+  }
+  getSessionWatchPlan() {
+    const dataRoot = resolveGrokDataRoot();
+    return {
+      status: "supported",
+      targets: [{ root: dataRoot, path: join14(dataRoot, "sessions") }, { path: "data/grok" }]
     };
   }
-  normalizeUsage(raw) {
-    const usage = narrowPiField("message.usage", raw, asRecord) ?? {};
-    const inputTokens = narrowPiField("message.usage.input", usage["input"], asNumber) ?? 0;
-    const outputTokens = narrowPiField("message.usage.output", usage["output"], asNumber) ?? 0;
-    const cacheReadTokens = narrowPiField("message.usage.cacheRead", usage["cacheRead"], asNumber) ?? 0;
-    const cacheCreateTokens = narrowPiField("message.usage.cacheWrite", usage["cacheWrite"], asNumber) ?? 0;
-    const totalTokens = narrowPiField("message.usage.totalTokens", usage["totalTokens"], asNumber) ?? inputTokens + outputTokens + cacheReadTokens + cacheCreateTokens;
-    const cost = isObject(usage["cost"]) ? Number(usage["cost"]["total"] ?? 0) : null;
-    return {
-      inputTokens: inputTokens + cacheReadTokens + cacheCreateTokens,
-      outputTokens,
-      cacheReadTokens,
-      cacheCreateTokens,
-      totalTokens,
-      cost: cost && Number.isFinite(cost) ? cost : null,
-      tokens: {
-        input: inputTokens + cacheReadTokens + cacheCreateTokens,
-        output: outputTokens,
-        cache_read: cacheReadTokens || void 0,
-        cache_create: cacheCreateTokens || void 0
-      }
+  listSessionSources(options) {
+    this.basePath ??= this.findBasePath();
+    if (!this.basePath) return [];
+    const sources = this.walkFiles(this.basePath, (entry) => entry.name === SUMMARY_FILE);
+    return sources.flatMap((source) => {
+      const summary = parseSummary(source);
+      if (!summary || !matchesScanWindow(summary.updatedAt, options)) return [];
+      return [
+        {
+          sessionId: summary.id,
+          sourcePath: source.file,
+          fingerprint: this.sourceFingerprint(source)
+        }
+      ];
+    });
+  }
+  scanSessionSource(sourcePath) {
+    const source = this.sessionSourceFile(sourcePath);
+    const summary = parseSummary(source);
+    if (!summary) return null;
+    const sessionDir = dirname6(source.file);
+    const updatesPath = join14(sessionDir, UPDATES_FILE);
+    const existingUpdatesPath = existsSync12(updatesPath) ? updatesPath : null;
+    const headData = scanHeadData(existingUpdatesPath, summary.createdAt);
+    const messageCount = headData.visibleMessageCount || summary.messageCount;
+    if (messageCount === 0) return null;
+    const title = resolveSessionTitle(
+      summary.title,
+      headData.firstUserText,
+      basenameTitle(summary.cwd)
+    );
+    const stats = { message_count: messageCount, ...headData.stats };
+    const fingerprint = this.sourceFingerprint(source);
+    const head = {
+      id: summary.id,
+      slug: `grok/${summary.id}`,
+      title,
+      directory: summary.cwd,
+      parent_reference: summary.parentSessionId ? { agentName: this.name, sessionId: summary.parentSessionId } : void 0,
+      time_created: summary.createdAt,
+      time_updated: summary.updatedAt,
+      stats,
+      model_usage: Object.keys(headData.modelUsage).length > 0 ? headData.modelUsage : void 0
     };
+    this.sessionMetaMap.set(summary.id, {
+      id: summary.id,
+      title,
+      sourcePath: source.file,
+      sourceFingerprint: fingerprint,
+      sourceMtimeMs: summary.updatedAt,
+      directory: summary.cwd,
+      messageCount,
+      createdAt: summary.createdAt,
+      updatedAt: summary.updatedAt,
+      currentModel: summary.currentModel,
+      parentSessionId: summary.parentSessionId,
+      updatesPath: existingUpdatesPath,
+      stats
+    });
+    return head;
   }
-  emptyUsageResult(message) {
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) throw new Error(`Session not found: ${sessionId}`);
+    const transcript = parseTranscript(meta);
     return {
-      message,
-      totalTokens: 0,
-      model: null
+      reference: { agentName: this.name, sessionId: meta.id },
+      id: meta.id,
+      title: meta.title,
+      slug: `grok/${meta.id}`,
+      directory: meta.directory,
+      parent_reference: meta.parentSessionId ? { agentName: this.name, sessionId: meta.parentSessionId } : void 0,
+      version: void 0,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: transcript.stats,
+      messages: transcript.messages
     };
   }
-};
-function resolveZCodeDataRoot() {
-  const currentPlatform = platform3();
-  if (currentPlatform !== "darwin" && currentPlatform !== "win32") return null;
-  return join12(homedir4(), ".zcode");
-}
-function findZCodeDbPath() {
-  if (!isSqliteAvailable()) return null;
-  const dataRoot = resolveZCodeDataRoot();
-  if (!dataRoot) return null;
-  return firstExisting(join12(dataRoot, "cli", "db", "db.sqlite"));
-}
-function getZCodeSessionWatchPlan() {
-  const dataRoot = resolveZCodeDataRoot();
-  return {
-    status: "supported",
-    targets: dataRoot ? [{ root: dataRoot, path: join12(dataRoot, "cli", "db", "db.sqlite") }] : []
-  };
-}
-var ZCodeAgent = class extends OpenCodeSqliteAgent {
-  constructor() {
-    super({
-      name: "zcode",
-      displayName: "ZCode",
-      findDbPath: findZCodeDbPath,
-      getSessionWatchPlan: getZCodeSessionWatchPlan
-    });
+  sourceFingerprint(source) {
+    const sessionDir = dirname6(source.file);
+    return JSON.stringify([
+      HEAD_INDEX_VERSION4,
+      PARSER_VERSION3,
+      source.stat.mtimeMs,
+      source.stat.size,
+      optionalFileFingerprint(join14(sessionDir, UPDATES_FILE))
+    ]);
   }
 };
 registerAgent({
@@ -5834,6 +7978,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,
@@ -5841,6 +7992,13 @@ registerAgent({
   toolStrategy: "custom",
   create: () => new CodexAgent()
 });
+registerAgent({
+  icon: "/icon/agent/grok.svg",
+  resolveDataRoot: resolveGrokDataRoot,
+  resumeCommandPrefix: "grok --resume",
+  toolStrategy: "custom",
+  create: () => new GrokAgent()
+});
 registerAgent({
   icon: "/icon/agent/pi.svg",
   resolveDataRoot: resolvePiDataRoot,
@@ -5863,11 +8021,11 @@ function fallbackDisplayName(input) {
 }
 var realFs = {
   exists(path2) {
-    return existsSync11(path2);
+    return existsSync13(path2);
   },
   readText(path2) {
     try {
-      return readFileSync6(path2, "utf8");
+      return readFileSync8(path2, "utf8");
     } catch {
       return null;
     }
@@ -6037,7 +8195,9 @@ function parseManifestName(file, text) {
 }
 function buildProjectGroups(sessions) {
   const groups = /* @__PURE__ */ new Map();
+  const tree = buildSessionTree(sessions);
   for (const session of sessions) {
+    if (tree.mountStateOf(session) === "mounted-child") continue;
     const identity = session.project_identity;
     if (!identity) continue;
     const activity = session.time_updated ?? session.time_created;
@@ -6090,7 +8250,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 +8525,16 @@ function setSchemaEnsuredPath(path2) {
   schemaEnsuredPath = path2;
 }
 function getCacheDir2() {
-  return join13(homedir6(), ".cache", "codesesh");
+  return join15(homedir6(), ".cache", "codesesh");
 }
 function getCachePath2() {
-  return join13(getCacheDir2(), CACHE_FILENAME);
+  return join15(getCacheDir2(), CACHE_FILENAME);
 }
 function getLegacyCachePath() {
-  return join13(getCacheDir2(), LEGACY_CACHE_FILENAME);
+  return join15(getCacheDir2(), LEGACY_CACHE_FILENAME);
 }
 function hasCacheStorage() {
-  return existsSync12(getCachePath2());
+  return existsSync14(getCachePath2());
 }
 function likePattern(value) {
   return `%${value.trim().toLowerCase().replace(/[\\%_]/g, "\\$&")}%`;
@@ -6415,6 +8575,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 +8595,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 +8634,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 +8654,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,
@@ -6514,7 +8682,7 @@ function prepareUpsertIndexedSession(db) {
 }
 function upsertSessionRow(statement, agentName, session, metaJson, sortIndex, sourcePath) {
   const identity = session.project_identity ?? computeIdentity(session.directory, realFs);
-  const activityTime = session.time_updated ?? session.time_created;
+  const activityTime2 = session.time_updated ?? session.time_created;
   statement.run(
     agentName,
     session.id,
@@ -6523,12 +8691,14 @@ 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,
     session.time_created,
     session.time_updated ?? null,
-    activityTime,
+    activityTime2,
     session.stats.message_count,
     session.stats.total_input_tokens,
     session.stats.total_output_tokens,
@@ -6600,6 +8770,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 +8993,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);
@@ -6830,7 +9006,9 @@ function withCacheDb(fn) {
     return fn(db);
   } catch (error) {
     getCoreDiagnostics()?.warn("cache.write_failed", {
-      message: error instanceof Error ? error.message : String(error)
+      message: error instanceof Error ? error.message : String(error),
+      code: error?.code,
+      stack: error instanceof Error ? error.stack : void 0
     });
     return null;
   } finally {
@@ -6871,7 +9049,7 @@ function runSearchIndexWrite(db, rebuild, write) {
       createMessageSearchTriggers(db);
     }
     return { value, rebuildDurationMs };
-  })();
+  }).immediate();
 }
 function createCacheTables(db) {
   db.exec(`
@@ -6917,6 +9095,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 +9124,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 +9416,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 +9427,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 +9825,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 +9852,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 +9985,8 @@ function ensureSchema(db, dbPath) {
     createLatestCacheSchema(db);
     setCacheSchemaVersion(db);
     migrateCodexExecDecode(db);
+    migrateOpenCodeSubagentFold(db);
+    migrateSubagentTree(db);
     return;
   }
   runSchemaMigrations(db, {
@@ -7794,7 +10018,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,14 +10055,17 @@ 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);
-  if (getUserVersion(db) <= CACHE_SCHEMA_VERSION) {
+  if (getUserVersion(db) < CACHE_SCHEMA_VERSION) {
     setCacheSchemaVersion(db);
   }
   migrateCodexExecDecode(db);
+  migrateOpenCodeSubagentFold(db);
+  migrateSubagentTree(db);
 }
 function escapeFtsTerm(value) {
   return value.replaceAll('"', '""');
@@ -7963,6 +10196,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 +10456,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 +11107,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 +11118,7 @@ function parseCachedSessionMeta(value) {
 }
 function deleteLegacyCacheFile() {
   const legacyPath = getLegacyCachePath();
-  if (!existsSync13(legacyPath)) {
+  if (!existsSync15(legacyPath)) {
     return;
   }
   try {
@@ -8884,6 +11145,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 +11209,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 +11272,7 @@ function markAgentFullSyncCompleted(agentName) {
       `
     ).run(Date.now(), agentName);
   });
+  clearAgentFullSyncCursor(agentName);
 }
 function loadCachedSessionRawEntry(agentName, sessionId) {
   if (!hasCacheStorage()) {
@@ -8987,6 +11288,8 @@ function loadCachedSessionRawEntry(agentName, sessionId) {
             title,
             source_path,
             directory,
+            parent_agent_name,
+            parent_session_id,
             project_identity_kind,
             project_identity_key,
             project_display_name,
@@ -9107,16 +11410,13 @@ function saveCachedSessions(agentName, sessions, meta = {}) {
         );
       });
     });
-    write();
+    write.immediate();
     deleteLegacyCacheFile();
     return true;
   });
   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 = ?"
@@ -9161,7 +11461,7 @@ function saveCachedSessionChanges(agentName, changes, removedSessionIds, meta =
         );
       }
     });
-    write();
+    write.immediate();
     deleteLegacyCacheFile();
     return true;
   });
@@ -9191,7 +11491,7 @@ function clearCache() {
   const walPath = `${cachePath}-wal`;
   const shmPath = `${cachePath}-shm`;
   for (const filePath of [walPath, shmPath]) {
-    if (!existsSync13(filePath)) {
+    if (!existsSync15(filePath)) {
       continue;
     }
     try {
@@ -9220,6 +11520,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 +11575,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 +11597,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 +11645,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 +11764,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 +11846,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,
@@ -9730,6 +12062,66 @@ function listCachedProjectGroups(sessions) {
     lastActivity: row.last_activity == null ? null : Number(row.last_activity)
   }));
 }
+var DEFAULT_MODEL_COST_LIMIT = 20;
+function buildModelCostWhere(options) {
+  const clauses = ["m.model IS NOT NULL", "m.model <> ''"];
+  const params = [];
+  if (options.agent != null) {
+    clauses.push("s.agent_name = ?");
+    params.push(options.agent);
+  }
+  if (options.projectKind != null || options.projectKey != null) {
+    if (options.projectKind != null && options.projectKey != null) {
+      clauses.push("s.project_identity_kind = ? AND s.project_identity_key = ?");
+      params.push(options.projectKind, options.projectKey);
+    } else {
+      clauses.push("0");
+    }
+  }
+  if (options.from != null) {
+    clauses.push("s.activity_time >= ?");
+    params.push(options.from);
+  }
+  if (options.to != null) {
+    clauses.push("s.activity_time <= ?");
+    params.push(options.to);
+  }
+  return { where: `WHERE ${clauses.join(" AND ")}`, params };
+}
+var MODEL_COST_SQL = `
+  SELECT
+    m.model AS model,
+    SUM(COALESCE(m.cost, 0)) AS cost,
+    SUM(CASE WHEN m.cost_source = 'recorded' THEN COALESCE(m.cost, 0) ELSE 0 END) AS cost_recorded,
+    SUM(CASE WHEN m.cost_source = 'recorded' THEN 0 ELSE COALESCE(m.cost, 0) END) AS cost_estimated
+  FROM messages m
+  JOIN sessions s ON s.agent_name = m.agent_name AND s.session_id = m.session_id
+`;
+function listModelCostDistribution(options = {}) {
+  if (!hasCacheStorage()) {
+    return null;
+  }
+  const { where, params } = buildModelCostWhere(options);
+  const sql = `
+    ${MODEL_COST_SQL}
+    ${where}
+    GROUP BY m.model
+    ORDER BY cost DESC, m.model
+    LIMIT ?
+  `;
+  const rows = withCacheDbReadOnly(
+    (db) => db.prepare(sql).all(...params, options.limit ?? DEFAULT_MODEL_COST_LIMIT)
+  );
+  if (rows == null) {
+    return null;
+  }
+  return rows.map((row) => ({
+    model: String(row.model ?? ""),
+    cost: Number(row.cost ?? 0),
+    costRecorded: Number(row.cost_recorded ?? 0),
+    costEstimated: Number(row.cost_estimated ?? 0)
+  }));
+}
 var STATE_DB_FILENAME = "state.db";
 var STATE_SCHEMA_VERSION = 2;
 var MEMORY_STATE_STORE = "memory";
@@ -9750,16 +12142,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 join16(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 join16(appData ?? join16(homedir7(), "AppData", "Roaming"), "codesesh");
   }
-  return join14(process.env.XDG_DATA_HOME ?? join14(homedir7(), ".local", "share"), "codesesh");
+  return join16(process.env.XDG_DATA_HOME ?? join16(homedir7(), ".local", "share"), "codesesh");
 }
 function getStateDbPath() {
-  return join14(getStateDir(), STATE_DB_FILENAME);
+  return join16(getStateDir(), STATE_DB_FILENAME);
 }
 function useMemoryStateStore() {
   return process.env.CODESESH_STATE_STORE === MEMORY_STATE_STORE;
@@ -10049,7 +12441,7 @@ function importBookmarks(bookmarks) {
         );
       }
     });
-    write();
+    write.immediate();
     const rows = db.prepare(
       `
           SELECT
@@ -10167,159 +12559,267 @@ function deleteSessionAlias(reference) {
   });
 }
 var DASHBOARD_RECENT_LIMIT = 10;
-function getTotalTokens(stats) {
-  return stats.total_tokens ?? stats.total_input_tokens + stats.total_output_tokens;
-}
+var DASHBOARD_PROJECT_LIMIT = 12;
+var PROJECT_SPARKLINE_DAYS = 14;
 function getSessionAgentName(session) {
   return getSessionAgentKey(session);
 }
 function getSessionActivityTime(session) {
   return session.time_updated ?? session.time_created;
 }
-function buildDashboard(sessions, options) {
-  const { byAgentNames, scope, from, to, agentInfoMap } = options;
-  const agentMetrics = /* @__PURE__ */ new Map();
-  const agentMetricKeyByName = /* @__PURE__ */ new Map();
+function matchesScope(session, scope) {
+  if (scope.agent && getSessionAgentName(session) !== scope.agent) return false;
+  if (scope.projectKind == null && scope.projectKey == null) return true;
+  const identity = session.project_identity;
+  return identity != null && identity.kind === scope.projectKind && identity.key === scope.projectKey;
+}
+function scopedEntries(sessions, scope, from, to) {
+  const tree = buildSessionTree(filterSessionTreeByActivityWindow(sessions, from, to));
+  return tree.entries.filter((node) => matchesScope(node.session, scope));
+}
+function emptyDailyBucket(date) {
+  return {
+    date,
+    sessions: 0,
+    messages: 0,
+    cost: 0,
+    input: 0,
+    output: 0,
+    cache_read: 0,
+    cache_create: 0
+  };
+}
+function createAccumulator(byAgentNames, scope, to) {
+  const agents = /* @__PURE__ */ new Map();
   for (const name of byAgentNames) {
-    if (scope.agent && name.toLowerCase() !== scope.agent) continue;
-    agentMetrics.set(name, { sessions: 0, messages: 0, tokens: 0 });
-    agentMetricKeyByName.set(name.toLowerCase(), name);
+    const key = name.toLowerCase();
+    if (scope.agent && key !== scope.agent) continue;
+    agents.set(key, { name, sessions: 0, messages: 0, tokens: 0, cost: 0 });
   }
-  let totalSessions = 0;
-  let totalMessages = 0;
-  let totalTokens = 0;
-  let totalCost = 0;
-  let hasEstimatedCost = false;
-  let latestActivity = 0;
-  const recentCandidates = [];
-  const modelAgg = /* @__PURE__ */ new Map();
-  const dailyMap = /* @__PURE__ */ new Map();
-  const dailyTokenMap = /* @__PURE__ */ new Map();
+  const sparklineSlots = /* @__PURE__ */ new Map();
+  for (let slot = 0; slot < PROJECT_SPARKLINE_DAYS; slot += 1) {
+    const day = addCalendarDays(to, slot - (PROJECT_SPARKLINE_DAYS - 1));
+    sparklineSlots.set(toCalendarDayKey(day), slot);
+  }
+  return {
+    sessions: 0,
+    messages: 0,
+    tokens: 0,
+    cost: 0,
+    costRecorded: 0,
+    costEstimated: 0,
+    cacheReadTokens: 0,
+    hasEstimatedCost: false,
+    agents,
+    agentKeys: /* @__PURE__ */ new Set(),
+    daily: /* @__PURE__ */ new Map(),
+    models: /* @__PURE__ */ new Map(),
+    projects: /* @__PURE__ */ new Map(),
+    sparklineSlots,
+    recent: []
+  };
+}
+function foldModelUsage(node, into) {
+  if (node.session.model_usage) {
+    for (const [model, tokens] of Object.entries(node.session.model_usage)) {
+      into.set(model, (into.get(model) ?? 0) + tokens);
+    }
+  }
+  for (const child of node.children) foldModelUsage(child, into);
+}
+function trackProject(node, acc, dayKey, agentKey) {
+  const identity = node.session.project_identity;
+  if (!identity) return;
+  const key = getProjectIdentityKey(identity);
+  let project = acc.projects.get(key);
+  if (!project) {
+    project = {
+      identityKind: identity.kind,
+      identityKey: identity.key,
+      displayName: identity.displayName,
+      sessions: 0,
+      messages: 0,
+      tokens: 0,
+      cost: 0,
+      hasEstimatedCost: false,
+      agentSessions: /* @__PURE__ */ new Map(),
+      sparkline: Array.from({ length: PROJECT_SPARKLINE_DAYS }, () => 0)
+    };
+    acc.projects.set(key, project);
+  }
+  const stats = node.inclusiveStats;
+  project.sessions += 1;
+  project.messages += stats.messageCount;
+  project.tokens += stats.totalTokens;
+  project.cost += stats.cost;
+  if (stats.costSource === "estimated") project.hasEstimatedCost = true;
+  project.agentSessions.set(agentKey, (project.agentSessions.get(agentKey) ?? 0) + 1);
+  const slot = acc.sparklineSlots.get(dayKey);
+  if (slot != null) project.sparkline[slot] += stats.cost;
+}
+function accumulate(node, acc) {
+  const session = node.session;
+  const stats = node.inclusiveStats;
+  const activity = getSessionActivityTime(session);
+  const agentKey = getSessionAgentName(session);
+  acc.sessions += 1;
+  acc.messages += stats.messageCount;
+  acc.tokens += stats.totalTokens;
+  acc.cost += stats.cost;
+  acc.cacheReadTokens += stats.cacheReadTokens;
+  acc.agentKeys.add(agentKey);
+  if (stats.costSource === "recorded") acc.costRecorded += stats.cost;
+  else acc.costEstimated += stats.cost;
+  if (stats.costSource === "estimated") acc.hasEstimatedCost = true;
+  const metric = acc.agents.get(agentKey);
+  if (metric) {
+    metric.sessions += 1;
+    metric.messages += stats.messageCount;
+    metric.tokens += stats.totalTokens;
+    metric.cost += stats.cost;
+  }
+  const dayKey = toCalendarDayKey(activity);
+  let bucket = acc.daily.get(dayKey);
+  if (!bucket) {
+    bucket = emptyDailyBucket(dayKey);
+    acc.daily.set(dayKey, bucket);
+  }
+  bucket.sessions += 1;
+  bucket.messages += stats.messageCount;
+  bucket.cost += stats.cost;
+  bucket.input += Math.max(0, stats.inputTokens - stats.cacheReadTokens - stats.cacheCreateTokens);
+  bucket.output += stats.outputTokens;
+  bucket.cache_read += stats.cacheReadTokens;
+  bucket.cache_create += stats.cacheCreateTokens;
+  const usage = /* @__PURE__ */ new Map();
+  foldModelUsage(node, usage);
+  for (const [model, tokens] of usage) {
+    const entry = acc.models.get(model);
+    if (entry) {
+      entry.tokens += tokens;
+      entry.sessions += 1;
+    } else {
+      acc.models.set(model, { tokens, sessions: 1 });
+    }
+  }
+  trackProject(node, acc, dayKey, agentKey);
+  let recentIndex = acc.recent.length;
+  for (let i = 0; i < acc.recent.length; i += 1) {
+    if (activity > acc.recent[i].activity) {
+      recentIndex = i;
+      break;
+    }
+  }
+  if (recentIndex < DASHBOARD_RECENT_LIMIT) {
+    acc.recent.splice(recentIndex, 0, { session, activity });
+    if (acc.recent.length > DASHBOARD_RECENT_LIMIT) acc.recent.pop();
+  }
+}
+function toPreviousTotals(acc) {
+  return { sessions: acc.sessions, messages: acc.messages, tokens: acc.tokens, cost: acc.cost };
+}
+function toProjectStat(project) {
+  return {
+    identityKind: project.identityKind,
+    identityKey: project.identityKey,
+    displayName: project.displayName,
+    sessions: project.sessions,
+    messages: project.messages,
+    tokens: project.tokens,
+    cost: project.cost,
+    cost_source: project.cost > 0 ? project.hasEstimatedCost ? "estimated" : "recorded" : void 0,
+    agents: [...project.agentSessions.entries()].sort((a, b) => b[1] - a[1]).map(([agentKey]) => agentKey),
+    sparkline: project.sparkline
+  };
+}
+function buildDashboard(sessions, options) {
+  const { byAgentNames, scope, from, to, agentInfoMap, compare } = options;
+  const acc = createAccumulator(byAgentNames, scope, to);
   if (from != null) {
     const bucketDays = countCalendarDays(from, to);
     for (let i = 0; i < bucketDays; i += 1) {
       const key = toCalendarDayKey(addCalendarDays(from, i));
-      dailyMap.set(key, { date: key, sessions: 0, messages: 0 });
-      dailyTokenMap.set(key, { date: key, input: 0, output: 0, cache_read: 0, cache_create: 0 });
+      acc.daily.set(key, emptyDailyBucket(key));
     }
   }
-  for (const session of sessions) {
-    const agentName = getSessionAgentName(session);
-    if (scope.agent && agentName !== scope.agent) continue;
-    if (scope.projectKind || scope.projectKey) {
-      const identity = session.project_identity;
-      if (!identity || !scope.projectKind || !scope.projectKey || identity.kind !== scope.projectKind || identity.key !== scope.projectKey) {
-        continue;
-      }
-    }
-    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;
-    totalMessages += messageCount;
-    totalTokens += sessionTokens;
-    totalCost += session.stats.total_cost ?? 0;
-    if (session.stats.cost_source === "estimated") hasEstimatedCost = true;
-    if (activity > latestActivity) latestActivity = activity;
-    const metricKey = agentMetricKeyByName.get(agentName);
-    if (metricKey) {
-      const metric = agentMetrics.get(metricKey);
-      metric.sessions += 1;
-      metric.messages += messageCount;
-      metric.tokens += sessionTokens;
-    }
-    const key = toCalendarDayKey(activity);
-    let bucket = dailyMap.get(key);
-    if (!bucket) {
-      bucket = { date: key, sessions: 0, messages: 0 };
-      dailyMap.set(key, bucket);
-    }
-    bucket.sessions += 1;
-    bucket.messages += messageCount;
-    let tokenBucket = dailyTokenMap.get(key);
-    if (!tokenBucket) {
-      tokenBucket = { date: key, input: 0, output: 0, cache_read: 0, cache_create: 0 };
-      dailyTokenMap.set(key, tokenBucket);
-    }
-    const cacheRead = session.stats.total_cache_read_tokens ?? 0;
-    const cacheCreate = session.stats.total_cache_create_tokens ?? 0;
-    const pureInput = session.stats.total_input_tokens - cacheRead - cacheCreate;
-    tokenBucket.input += Math.max(0, pureInput);
-    tokenBucket.output += session.stats.total_output_tokens;
-    tokenBucket.cache_read += cacheRead;
-    tokenBucket.cache_create += cacheCreate;
-    if (session.model_usage) {
-      for (const [model, tokens] of Object.entries(session.model_usage)) {
-        const entry = modelAgg.get(model);
-        if (entry) {
-          entry.tokens += tokens;
-          entry.sessions += 1;
-        } else {
-          modelAgg.set(model, { tokens, sessions: 1 });
-        }
-      }
-    }
-    let recentIndex = recentCandidates.length;
-    for (let i = 0; i < recentCandidates.length; i += 1) {
-      if (activity > recentCandidates[i].activity) {
-        recentIndex = i;
-        break;
-      }
-    }
-    if (recentIndex < DASHBOARD_RECENT_LIMIT) {
-      recentCandidates.splice(recentIndex, 0, { session, activity });
-      if (recentCandidates.length > DASHBOARD_RECENT_LIMIT) recentCandidates.pop();
+  for (const node of scopedEntries(sessions, scope, from, to)) accumulate(node, acc);
+  let previous;
+  if (compare) {
+    const compareAcc = createAccumulator(byAgentNames, scope, compare.to);
+    for (const node of scopedEntries(sessions, scope, compare.from, compare.to)) {
+      accumulate(node, compareAcc);
     }
+    previous = toPreviousTotals(compareAcc);
   }
-  const perAgent = [...agentMetrics.entries()].map(([name, metrics]) => {
-    const info = agentInfoMap?.get(name);
+  const perAgent = [...acc.agents.values()].map((metrics) => {
+    const info = agentInfoMap?.get(metrics.name);
     return {
-      name,
-      displayName: info?.displayName ?? name,
+      name: metrics.name,
+      displayName: info?.displayName ?? metrics.name,
       icon: info?.icon ?? "",
       iconColored: info?.iconColored,
       sessions: metrics.sessions,
       messages: metrics.messages,
-      tokens: metrics.tokens
+      tokens: metrics.tokens,
+      cost: metrics.cost
     };
   }).filter((item) => item.sessions > 0).sort((a, b) => b.sessions - a.sessions);
-  const dailyActivity = [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date));
-  const dailyTokenActivity = [...dailyTokenMap.values()].sort(
-    (a, b) => a.date.localeCompare(b.date)
+  const dailyActivity = [...acc.daily.values()].sort((a, b) => a.date.localeCompare(b.date));
+  const modelDistribution = [...acc.models.entries()].map(([model, { tokens, sessions: count }]) => ({ model, tokens, sessions: count })).sort((a, b) => b.tokens - a.tokens);
+  const rankedProjects = [...acc.projects.values()].sort((a, b) => b.cost - a.cost);
+  const perProject = rankedProjects.slice(0, DASHBOARD_PROJECT_LIMIT).map(toProjectStat);
+  const projectRollup = rankedProjects.slice(DASHBOARD_PROJECT_LIMIT).reduce(
+    (rollup, project) => ({
+      projects: rollup.projects + 1,
+      sessions: rollup.sessions + project.sessions,
+      tokens: rollup.tokens + project.tokens,
+      cost: rollup.cost + project.cost
+    }),
+    { projects: 0, sessions: 0, tokens: 0, cost: 0 }
   );
-  const modelDistribution = [...modelAgg.entries()].map(([model, { tokens, sessions: count }]) => ({ model, tokens, sessions: count })).sort((a, b) => b.tokens - a.tokens);
-  const recentSessions = recentCandidates.map(({ session }) => {
-    const agentKey = getSessionAgentName(session);
-    return {
-      reference: { agentName: agentKey, sessionId: session.id },
-      session
-    };
-  });
+  const recentSessions = acc.recent.map(({ session }) => ({
+    reference: { agentName: getSessionAgentName(session), sessionId: session.id },
+    session
+  }));
+  const latest = acc.recent[0];
   return {
     totals: {
-      sessions: totalSessions,
-      messages: totalMessages,
-      tokens: totalTokens,
-      cost: totalCost,
-      cost_source: totalCost > 0 ? hasEstimatedCost ? "estimated" : "recorded" : void 0,
-      latestActivity: latestActivity || void 0
+      sessions: acc.sessions,
+      messages: acc.messages,
+      tokens: acc.tokens,
+      cost: acc.cost,
+      costRecorded: acc.costRecorded,
+      costEstimated: acc.costEstimated,
+      cacheReadTokens: acc.cacheReadTokens,
+      cost_source: acc.cost > 0 ? acc.hasEstimatedCost ? "estimated" : "recorded" : void 0,
+      latestActivity: latest?.activity || void 0,
+      latestActivityProject: latest?.session.project_identity?.displayName,
+      latestActivityAgent: latest ? getSessionAgentName(latest.session) : void 0,
+      previous
     },
+    scopeCounts: { projects: acc.projects.size, agents: acc.agentKeys.size },
     perAgent,
     dailyActivity,
-    dailyTokenActivity,
     modelDistribution,
+    perProject,
+    projectRollup,
     recentSessions
   };
 }
 function emptyMetrics() {
-  return { messages: 0, tokens: 0, cost: 0, hasEstimatedCost: false, agentStats: /* @__PURE__ */ new Map() };
+  return {
+    sessions: 0,
+    messages: 0,
+    tokens: 0,
+    cost: 0,
+    hasEstimatedCost: false,
+    agentStats: /* @__PURE__ */ new Map()
+  };
 }
 function attachProjectMetrics(projects, sessions) {
   const metrics = /* @__PURE__ */ new Map();
-  for (const session of sessions) {
-    const identity = session.project_identity;
+  for (const node of buildSessionTree(sessions).entries) {
+    const identity = node.session.project_identity;
     if (!identity) continue;
     const key = getProjectIdentityKey(identity);
     let current = metrics.get(key);
@@ -10327,26 +12827,26 @@ function attachProjectMetrics(projects, sessions) {
       current = emptyMetrics();
       metrics.set(key, current);
     }
-    const tokens = getTotalTokens(session.stats);
-    const cost = session.stats.total_cost ?? 0;
-    current.messages += session.stats.message_count;
-    current.tokens += tokens;
-    current.cost += cost;
-    if (session.stats.cost_source === "estimated") current.hasEstimatedCost = true;
-    const agentName = getSessionAgentName(session);
+    const stats = node.inclusiveStats;
+    current.sessions += 1;
+    current.messages += stats.messageCount;
+    current.tokens += stats.totalTokens;
+    current.cost += stats.cost;
+    if (stats.costSource === "estimated") current.hasEstimatedCost = true;
+    const agentName = getSessionAgentName(node.session);
     const agent = current.agentStats.get(agentName);
     if (agent) {
       agent.sessions += 1;
-      agent.messages += session.stats.message_count;
-      agent.tokens += tokens;
-      agent.cost += cost;
+      agent.messages += stats.messageCount;
+      agent.tokens += stats.totalTokens;
+      agent.cost += stats.cost;
     } else {
       current.agentStats.set(agentName, {
         name: agentName,
         sessions: 1,
-        messages: session.stats.message_count,
-        tokens,
-        cost
+        messages: stats.messageCount,
+        tokens: stats.totalTokens,
+        cost: stats.cost
       });
     }
   }
@@ -10356,6 +12856,7 @@ function attachProjectMetrics(projects, sessions) {
     );
     return {
       ...project,
+      sessionCount: metric?.sessions ?? 0,
       messages: metric?.messages ?? 0,
       tokens: metric?.tokens ?? 0,
       cost: metric?.cost ?? 0,
@@ -10501,6 +13002,10 @@ export {
   getSessionAgentKey,
   sessionRoutePath,
   mergeSortedSessions,
+  getSessionRouteKey,
+  isChildSession,
+  getRootSessions,
+  filterSessionTreeByActivityWindow,
   registerAgent,
   createRegisteredAgents,
   getRegisteredAgents,
@@ -10529,6 +13034,9 @@ export {
   loadCachedSessions,
   isAgentCacheInitialized,
   markAgentCacheInitialized,
+  markAgentFullSyncStarted,
+  getAgentFullSyncCursor,
+  markAgentFullSyncProgress,
   getAgentLastFullSyncAt,
   markAgentFullSyncCompleted,
   saveCachedSessions,
@@ -10543,6 +13051,7 @@ export {
   scanSessions,
   materializeSessionDetailResponse,
   listCachedProjectGroups,
+  listModelCostDistribution,
   StateStorageUnavailableError,
   listBookmarks,
   upsertBookmark,
@@ -10558,4 +13067,4 @@ export {
   executeSessionSearch,
   filterSessionSearchCandidates
 };
-//# sourceMappingURL=chunk-HIYT2ZJL.js.map
+//# sourceMappingURL=chunk-BEF6LLRG.js.map