codesesh 0.12.0 → 0.14.0

package/dist/{chunk-GCOAE7KI.js → chunk-VRVZJDNL.js}

@@ -1,15 +1,29 @@
 #!/usr/bin/env node
 
+// ../core/dist/chunk-M5ISIPFR.mjs
+function compareSessionActivityDesc(a, b) {
+  return (b.time_updated ?? b.time_created) - (a.time_updated ?? a.time_created);
+}
+function sortSessionsByActivity(sessions) {
+  for (let index = 1; index < sessions.length; index += 1) {
+    if (compareSessionActivityDesc(sessions[index - 1], sessions[index]) > 0) {
+      return [...sessions].sort(compareSessionActivityDesc);
+    }
+  }
+  return [...sessions];
+}
+
 // ../core/dist/index.mjs
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
 import { join as join3, basename as basename2, dirname } from "path";
 import { existsSync, statSync } from "fs";
 import { existsSync as existsSync2 } from "fs";
 import { homedir, platform } from "os";
 import { join } from "path";
-import { readFileSync } from "fs";
+import { closeSync, openSync, readSync } from "fs";
+import { StringDecoder } from "string_decoder";
 import { basename } from "path";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 import { join as join5 } from "path";
@@ -17,26 +31,26 @@ import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
 import { basename as basename3, dirname as dirname2, join as join4 } from "path";
 import { createRequire } from "module";
 import { createHash } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
 import { join as join6, basename as basename4, dirname as dirname3 } from "path";
 import {
-  closeSync,
+  closeSync as closeSync2,
   existsSync as existsSync7,
-  openSync,
-  readFileSync as readFileSync5,
-  readSync,
+  openSync as openSync2,
+  readFileSync as readFileSync4,
+  readSync as readSync2,
   readdirSync as readdirSync3,
   statSync as statSync4
 } from "fs";
 import { join as join7, basename as basename5 } from "path";
-import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
 import { join as join8, normalize } from "path";
-import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
 import { basename as basename6, join as join9 } from "path";
 import { join as join10 } from "path";
 import { availableParallelism } from "os";
 import { Worker } from "worker_threads";
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
 import { spawnSync } from "child_process";
 import * as os from "os";
 import * as path from "path";
@@ -58,15 +72,18 @@ function getRegisteredAgents() {
   return registrations;
 }
 function getAgentInfoMap(sessionsByAgent) {
-  return registrations.map((r) => ({
-    name: r.name,
-    displayName: r.displayName,
-    icon: r.icon,
-    count: sessionsByAgent[r.name] ?? 0
-  }));
+  return registrations.map((registration) => {
+    const agent = registration.create();
+    return {
+      name: agent.name,
+      displayName: agent.displayName,
+      icon: registration.icon,
+      count: sessionsByAgent[agent.name] ?? 0
+    };
+  });
 }
 function getAgentByName(name) {
-  return registrations.find((r) => r.name === name);
+  return registrations.find((registration) => registration.create().name === name);
 }
 function parsedSession(session) {
   return { status: "parsed", data: session };
@@ -92,6 +109,26 @@ var BaseAgent = class {
 };
 var FileSystemSessionSource = class extends BaseAgent {
   sessionMetaMap = /* @__PURE__ */ new Map();
+  scan(options) {
+    const sources = this.listSessionSources(options);
+    const sessions = [];
+    options?.onProgress?.({ total: sources.length, processed: 0, sessions: 0 });
+    for (const [index, source] of sources.entries()) {
+      try {
+        const session = this.scanSessionSource(source.sourcePath, options);
+        if (session) sessions.push(session);
+      } catch {
+        continue;
+      } finally {
+        options?.onProgress?.({
+          total: sources.length,
+          processed: index + 1,
+          sessions: sessions.length
+        });
+      }
+    }
+    return sessions;
+  }
   getSessionMetaMap() {
     return this.sessionMetaMap;
   }
@@ -244,6 +281,7 @@ function getZCodeDataPath() {
   }
   return null;
 }
+var READ_CHUNK_BYTES = 1 << 20;
 function* parseJsonlLines(content) {
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
@@ -254,9 +292,35 @@ function* parseJsonlLines(content) {
     }
   }
 }
-function readJsonlFile(filePath) {
-  const content = readFileSync(filePath, "utf-8");
-  return parseJsonlLines(content);
+function* readJsonlFileLines(filePath, chunkBytes = READ_CHUNK_BYTES) {
+  const fd = openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(chunkBytes);
+    const decoder = new StringDecoder("utf8");
+    let remainder = "";
+    let bytesRead = readSync(fd, buffer, 0, chunkBytes, -1);
+    while (bytesRead > 0) {
+      const lines = (remainder + decoder.write(buffer.subarray(0, bytesRead))).split("\n");
+      remainder = lines.pop();
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) yield trimmed;
+      }
+      bytesRead = readSync(fd, buffer, 0, chunkBytes, -1);
+    }
+    const tail = (remainder + decoder.end()).trim();
+    if (tail) yield tail;
+  } finally {
+    closeSync(fd);
+  }
+}
+function* readJsonlFile(filePath) {
+  for (const line of readJsonlFileLines(filePath)) {
+    try {
+      yield JSON.parse(line);
+    } catch {
+    }
+  }
 }
 var INTERNAL_TAGS = [
   "command-message",
@@ -339,15 +403,6 @@ function resolveSessionTitle(explicit, message, directory) {
   }
   return UNTITLED_SESSION;
 }
-function parsed(data) {
-  return { status: "parsed", data };
-}
-function skipped(reason) {
-  return reason ? { status: "skipped", reason } : { status: "skipped" };
-}
-function filtered(reason) {
-  return reason ? { status: "filtered", reason } : { status: "filtered" };
-}
 function isInternalEventType2(value) {
   return isInternalEventType(value);
 }
@@ -416,80 +471,6 @@ function firstUserMessageTitle(messages) {
   }
   return null;
 }
-var PerfTracer = class {
-  rootMarkers = [];
-  activeStack = [];
-  enabled = false;
-  enable() {
-    this.enabled = true;
-  }
-  start(name) {
-    const marker = {
-      name,
-      startTime: performance.now(),
-      children: []
-    };
-    if (!this.enabled) return marker;
-    const parent = this.activeStack[this.activeStack.length - 1];
-    if (parent) {
-      marker.parent = parent;
-      parent.children.push(marker);
-    } else {
-      this.rootMarkers.push(marker);
-    }
-    this.activeStack.push(marker);
-    return marker;
-  }
-  end(marker) {
-    if (!this.enabled) return;
-    const target = marker ?? this.activeStack[this.activeStack.length - 1];
-    if (!target) return;
-    target.endTime = performance.now();
-    target.duration = target.endTime - target.startTime;
-    while (this.activeStack.length > 0) {
-      const popped = this.activeStack.pop();
-      if (popped === target) break;
-    }
-  }
-  measure(name, fn) {
-    const marker = this.start(name);
-    try {
-      return fn();
-    } finally {
-      this.end(marker);
-    }
-  }
-  async measureAsync(name, fn) {
-    const marker = this.start(name);
-    try {
-      return await fn();
-    } finally {
-      this.end(marker);
-    }
-  }
-  getReport() {
-    if (!this.enabled) return "Performance tracing disabled";
-    const lines = [];
-    lines.push("\n=== Performance Report ===\n");
-    for (const marker of this.rootMarkers) {
-      this.formatMarker(marker, 0, lines);
-    }
-    return lines.join("\n");
-  }
-  formatMarker(marker, depth, lines) {
-    const indent = "  ".repeat(depth);
-    const duration = marker.duration?.toFixed(2) ?? "?";
-    lines.push(`${indent}${marker.name}: ${duration}ms`);
-    for (const child of marker.children) {
-      this.formatMarker(child, depth + 1, lines);
-    }
-  }
-  reset() {
-    this.rootMarkers = [];
-    this.activeStack = [];
-  }
-};
-var perf = new PerfTracer();
 var aliases_default = {
   "anthropic--claude-4.6-opus": "claude-opus-4-6",
   "anthropic--claude-4.6-sonnet": "claude-sonnet-4-6",
@@ -638,7 +619,7 @@ function loadDiskCache() {
   const path2 = getCachePath();
   if (!existsSync3(path2)) return;
   try {
-    const cached = JSON.parse(readFileSync2(path2, "utf-8"));
+    const cached = JSON.parse(readFileSync(path2, "utf-8"));
     if (Date.now() - cached.timestamp <= CACHE_TTL_MS) {
       const next = loadSnapshot();
       for (const [name, rawPricing] of Object.entries(cached.data)) {
@@ -661,7 +642,7 @@ async function refreshPricingCache() {
   const path2 = getCachePath();
   if (existsSync3(path2)) {
     try {
-      const cached = JSON.parse(readFileSync2(path2, "utf-8"));
+      const cached = JSON.parse(readFileSync(path2, "utf-8"));
       if (typeof cached.timestamp === "number" && Date.now() - cached.timestamp <= CACHE_TTL_MS) {
         return false;
       }
@@ -813,6 +794,179 @@ function withEstimatedSessionCost(stats, model) {
 function estimateTokenCost(model, tokens) {
   return estimateCostForTokens(model, tokens)?.cost ?? null;
 }
+var TranscriptBuilder = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  messages = [];
+  pendingToolCalls = /* @__PURE__ */ new Map();
+  currentAssistant = null;
+  latestTextAssistant = null;
+  beginTurn() {
+    this.currentAssistant = null;
+    this.latestTextAssistant = null;
+  }
+  appendMessage(input) {
+    const message = this.createMessage(input);
+    this.messages.push(message);
+    this.registerToolCalls(message.parts);
+    if (message.role === "assistant") {
+      this.currentAssistant = message;
+      if (message.parts.some((part) => part.type === "text")) {
+        this.latestTextAssistant = message;
+      }
+    } else if (message.role === "user") {
+      this.beginTurn();
+    }
+    return message;
+  }
+  appendAssistantPart(part, input, options = {}) {
+    const current = this.currentAssistant;
+    const canReuse = current !== null && (options.grouping === "current" || (part.type === "text" ? !current.parts.some((item) => item.type === "tool") : part.type === "reasoning" ? !current.parts.some((item) => item.type === "text" || item.type === "tool") : false));
+    const message = canReuse ? current : this.appendMessage({ ...input, role: "assistant", parts: [part] });
+    if (canReuse) {
+      if (options.deduplicateTail) this.appendPartIfNew(message, part);
+      else message.parts.push(part);
+      this.applyMissingMetadata(message, input);
+    }
+    if (part.type === "text") {
+      this.latestTextAssistant = message;
+    } else if (options.resetLatestText) {
+      this.latestTextAssistant = null;
+    }
+    return message;
+  }
+  appendToolCall(part, input, options = {}) {
+    const target = options.target === "current" ? this.currentAssistant : this.latestTextAssistant ?? this.currentAssistant;
+    const message = target ? target : this.appendMessage({
+      ...input,
+      role: "assistant",
+      mode: options.modeOnCreate ?? (options.markModeAsTool ? "tool" : input.mode),
+      parts: [part]
+    });
+    if (target) {
+      message.parts.push(part);
+      this.applyMissingMetadata(message, input);
+      if (options.markModeAsTool) message.mode = "tool";
+      this.registerToolCall(part);
+    }
+    this.currentAssistant = message;
+    return message;
+  }
+  appendToCurrentAssistant(part) {
+    if (!this.currentAssistant) return false;
+    this.currentAssistant.parts.push(part);
+    return true;
+  }
+  updateToolCall(callId, update) {
+    const part = this.pendingToolCalls.get(callId);
+    if (!part) return false;
+    update(part);
+    return true;
+  }
+  resolveToolCall(callId, resolution) {
+    return this.updateToolCall(callId, (part) => {
+      const state = part.state ?? (part.state = {});
+      if (resolution.output !== void 0) state.output = resolution.output;
+      if (resolution.status !== void 0) state.status = resolution.status;
+      if (resolution.metadata !== void 0) state.metadata = resolution.metadata;
+      if (resolution.consume) this.pendingToolCalls.delete(callId);
+    });
+  }
+  attachUsageToLatestAssistant(tokens, options = {}) {
+    for (let index = this.messages.length - 1; index >= 0; index -= 1) {
+      const message = this.messages[index];
+      if (message.role !== "assistant" || message.tokens) continue;
+      message.tokens = tokens;
+      if (options.model !== void 0) message.model ??= options.model;
+      if (options.cost !== void 0) message.cost = options.cost;
+      if (options.costSource !== void 0) message.cost_source = options.costSource;
+      return true;
+    }
+    return false;
+  }
+  finish(baseStats) {
+    const messages = cleanParsedMessages(this.messages);
+    const derived = this.deriveStats(messages);
+    if (!baseStats) return { messages, stats: derived };
+    return {
+      messages,
+      stats: {
+        ...derived,
+        ...baseStats,
+        message_count: messages.length,
+        cost_source: baseStats.cost_source
+      }
+    };
+  }
+  createMessage(input) {
+    const sparse = this.options.messageDefaults === "sparse";
+    return {
+      id: input.id,
+      role: input.role,
+      agent: sparse ? input.agent : input.agent ?? null,
+      time_created: input.timestampMs,
+      mode: sparse ? input.mode : input.mode ?? null,
+      model: sparse ? input.model : input.model ?? null,
+      provider: sparse ? input.provider : input.provider ?? null,
+      tokens: input.tokens,
+      cost: sparse ? input.cost : input.cost ?? 0,
+      cost_source: input.costSource,
+      parts: input.parts ?? [],
+      subagent_id: input.subagentId,
+      nickname: input.nickname
+    };
+  }
+  registerToolCalls(parts) {
+    for (const part of parts) this.registerToolCall(part);
+  }
+  registerToolCall(part) {
+    if (part.type === "tool" && part.callID) {
+      this.pendingToolCalls.set(part.callID, part);
+    }
+  }
+  appendPartIfNew(message, part) {
+    const tail = message.parts.at(-1);
+    if (tail?.type === part.type && tail.text === part.text) return;
+    message.parts.push(part);
+  }
+  applyMissingMetadata(message, input) {
+    if (!message.id && input.id) message.id = input.id;
+    if (message.agent == null && input.agent !== void 0) message.agent = input.agent;
+    if (message.mode == null && input.mode !== void 0) message.mode = input.mode;
+    if (message.model == null && input.model !== void 0) message.model = input.model;
+    if (message.provider == null && input.provider !== void 0) message.provider = input.provider;
+    if (!message.tokens && input.tokens) message.tokens = input.tokens;
+    if ((message.cost ?? 0) === 0 && input.cost !== void 0) message.cost = input.cost;
+    if (!message.cost_source && input.costSource) message.cost_source = input.costSource;
+  }
+  deriveStats(messages) {
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCacheCreateTokens = 0;
+    let totalCost = 0;
+    let hasEstimatedCost = false;
+    for (const message of messages) {
+      totalInputTokens += message.tokens?.input ?? 0;
+      totalOutputTokens += message.tokens?.output ?? 0;
+      totalCacheReadTokens += message.tokens?.cache_read ?? 0;
+      totalCacheCreateTokens += message.tokens?.cache_create ?? 0;
+      totalCost += message.cost ?? 0;
+      if (message.cost_source === "estimated") hasEstimatedCost = true;
+    }
+    return {
+      message_count: messages.length,
+      total_input_tokens: totalInputTokens,
+      total_output_tokens: totalOutputTokens,
+      total_cache_read_tokens: totalCacheReadTokens || void 0,
+      total_cache_create_tokens: totalCacheCreateTokens || void 0,
+      total_cost: totalCost,
+      cost_source: totalCost > 0 ? hasEstimatedCost ? "estimated" : "recorded" : void 0
+    };
+  }
+};
 var HEAD_INDEX_VERSION = "claudecode-head-v2";
 function parseTimestampMs(data) {
   const raw = String(data["timestamp"] ?? "").trim();
@@ -867,48 +1021,6 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
     }
     return false;
   }
-  scan(options) {
-    if (!this.basePath) return [];
-    const scanMarker = perf.start("claudecode:scan");
-    const heads = [];
-    const listMarker = perf.start("listProjectDirs");
-    const projectDirs = this.listProjectDirs();
-    perf.end(listMarker);
-    const filesByProject = projectDirs.map((projectDir) => {
-      const fileMarker = perf.start(`listJsonlFiles:${basename2(projectDir)}`);
-      const files = this.listJsonlFiles(projectDir).filter((file) => {
-        try {
-          return matchesScanWindow(statSync2(file).mtimeMs, options);
-        } catch {
-          return false;
-        }
-      });
-      perf.end(fileMarker);
-      return { projectDir, files };
-    });
-    const totalFiles = filesByProject.reduce((total, item) => total + item.files.length, 0);
-    options?.onProgress?.({ total: totalFiles, processed: 0, sessions: 0 });
-    let processed = 0;
-    for (const { projectDir, files } of filesByProject) {
-      for (const file of files) {
-        try {
-          const parseMarker = perf.start(`parseSessionHead:${basename2(file)}`);
-          const head = getParsedSession(this.parseSessionHeadResult(file, projectDir));
-          perf.end(parseMarker);
-          if (head) {
-            heads.push(head);
-            this.sessionMetaMap.set(head.id, this.buildSessionMeta(head, file, projectDir));
-          }
-        } catch {
-        } finally {
-          processed += 1;
-          options?.onProgress?.({ total: totalFiles, processed, sessions: heads.length });
-        }
-      }
-    }
-    perf.end(scanMarker);
-    return heads;
-  }
   listSessionSources(options) {
     if (!this.basePath) return [];
     const refs = [];
@@ -945,43 +1057,24 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
     if (!existsSync4(meta.sourcePath)) {
       throw new Error(`Session file missing: ${meta.sourcePath}`);
     }
-    const content = readFileSync3(meta.sourcePath, "utf-8");
-    const messages = [];
-    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const content = readFileSync2(meta.sourcePath, "utf-8");
+    const builder = new TranscriptBuilder();
     const ignoredToolCallIds = /* @__PURE__ */ new Set();
     const assistantUuidToToolCalls = /* @__PURE__ */ new Map();
     const countedUsageKeys = /* @__PURE__ */ new Set();
-    const assistantState = {
-      currentIndex: null,
-      latestTextIndex: null
-    };
-    let totalCost = 0;
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCacheRead = 0;
-    let totalCacheCreate = 0;
     for (const record of parseJsonlLines(content)) {
       try {
         this.convertRecord(
           record,
-          messages,
-          pendingToolCalls,
+          builder,
           ignoredToolCallIds,
           assistantUuidToToolCalls,
-          countedUsageKeys,
-          assistantState
+          countedUsageKeys
         );
       } catch {
       }
     }
-    const cleanedMessages = cleanParsedMessages(messages);
-    for (const msg of cleanedMessages) {
-      totalCost += msg.cost ?? 0;
-      totalInputTokens += msg.tokens?.input ?? 0;
-      totalOutputTokens += msg.tokens?.output ?? 0;
-      totalCacheRead += msg.tokens?.cache_read ?? 0;
-      totalCacheCreate += msg.tokens?.cache_create ?? 0;
-    }
+    const transcript = builder.finish();
     return {
       id: meta.id,
       title: meta.title,
@@ -990,16 +1083,8 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
       version: void 0,
       time_created: meta.createdAt,
       time_updated: meta.updatedAt,
-      stats: {
-        message_count: cleanedMessages.length,
-        total_input_tokens: totalInputTokens,
-        total_output_tokens: totalOutputTokens,
-        total_cost: totalCost,
-        cost_source: totalCost > 0 ? "estimated" : void 0,
-        total_cache_read_tokens: totalCacheRead,
-        total_cache_create_tokens: totalCacheCreate
-      },
-      messages: cleanedMessages
+      stats: transcript.stats,
+      messages: transcript.messages
     };
   }
   // --- Private helpers ---
@@ -1066,7 +1151,7 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
     const map = /* @__PURE__ */ new Map();
     if (existsSync4(indexPath)) {
       try {
-        const data = JSON.parse(readFileSync3(indexPath, "utf-8"));
+        const data = JSON.parse(readFileSync2(indexPath, "utf-8"));
         const entries = data?.entries ?? [];
         for (const entry of entries) {
           const sid = entry?.sessionId;
@@ -1085,7 +1170,7 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
     return getParsedSession(this.parseSessionHeadResult(filePath, projectDir));
   }
   parseSessionHeadResult(filePath, projectDir) {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync2(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     if (lines.length === 0) return skippedSession("empty file");
     const sessionId = basename2(filePath, ".jsonl");
@@ -1210,41 +1295,30 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
     return null;
   }
   // --- Record conversion ---
-  convertRecord(data, messages, pendingToolCalls, ignoredToolCallIds, assistantUuidToToolCalls, countedUsageKeys, assistantState) {
+  convertRecord(data, builder, ignoredToolCallIds, assistantUuidToToolCalls, countedUsageKeys) {
     if (data["isMeta"] === true) return;
     const msgType = String(data["type"] ?? "");
     if (isInternalEventType(msgType)) return;
     if (msgType === "assistant") {
       this.convertAssistantRecord(
         data,
-        messages,
-        pendingToolCalls,
+        builder,
         ignoredToolCallIds,
         assistantUuidToToolCalls,
-        countedUsageKeys,
-        assistantState
+        countedUsageKeys
       );
     } else if (msgType === "user") {
-      this.convertUserRecord(
-        data,
-        messages,
-        pendingToolCalls,
-        ignoredToolCallIds,
-        assistantUuidToToolCalls,
-        assistantState
-      );
+      this.convertUserRecord(data, builder, ignoredToolCallIds, assistantUuidToToolCalls);
     } else if (msgType === "tool_result") {
-      this.convertToolResultRecord(data, messages, assistantState);
+      this.convertToolResultRecord(data, builder);
     }
   }
-  convertAssistantRecord(data, messages, pendingToolCalls, ignoredToolCallIds, assistantUuidToToolCalls, countedUsageKeys, assistantState) {
+  convertAssistantRecord(data, builder, ignoredToolCallIds, assistantUuidToToolCalls, countedUsageKeys) {
     const msg = data["message"] ?? {};
     const timestampMs = parseTimestampMs(data);
     const rawContent = msg["content"] ?? [];
     const uuid = String(data["uuid"] ?? "");
     const toolCallIds = [];
-    let currentAssistantIndex = assistantState.currentIndex;
-    let latestAssistantTextIndex = assistantState.latestTextIndex;
     if (Array.isArray(rawContent)) {
       for (const item of rawContent) {
         if (!item || typeof item !== "object") continue;
@@ -1253,23 +1327,28 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
         if (partType === "thinking") {
           const text = cleanInternalText(String(part["thinking"] ?? ""));
           if (text) {
-            currentAssistantIndex = this.appendAssistantReasoning(
-              messages,
-              { messageId: uuid, data, msg, timestampMs, text, countedUsageKeys },
-              currentAssistantIndex
+            const message2 = builder.appendAssistantPart(
+              this.buildReasoningPart(text, timestampMs),
+              { id: uuid, timestampMs, agent: "claude" },
+              { deduplicateTail: true }
             );
+            this.applyAssistantMetadata(message2, data, msg, countedUsageKeys);
           }
           continue;
         }
         if (partType === "text") {
           const text = cleanInternalText(String(part["text"] ?? ""));
           if (text) {
-            currentAssistantIndex = this.appendAssistantText(
-              messages,
-              { messageId: uuid, data, msg, timestampMs, text, countedUsageKeys },
-              currentAssistantIndex
+            const message2 = builder.appendAssistantPart(
+              this.buildTextPart(text, timestampMs),
+              {
+                id: uuid,
+                timestampMs,
+                agent: "claude"
+              },
+              { deduplicateTail: true }
             );
-            latestAssistantTextIndex = currentAssistantIndex;
+            this.applyAssistantMetadata(message2, data, msg, countedUsageKeys);
           }
           continue;
         }
@@ -1281,18 +1360,13 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
           continue;
         }
         const toolPart = this.buildToolPart(part, timestampMs);
-        const [msgIndex, partIndex] = this.attachToolCallToLatestAssistant(messages, {
-          messageId: uuid,
-          data,
-          msg,
-          timestampMs,
+        const message = builder.appendToolCall(
           toolPart,
-          latestTextIndex: latestAssistantTextIndex,
-          countedUsageKeys
-        });
-        currentAssistantIndex = msgIndex;
+          { id: uuid, timestampMs, agent: "claude" },
+          { modeOnCreate: "tool" }
+        );
+        this.applyAssistantMetadata(message, data, msg, countedUsageKeys);
         if (toolCallId) {
-          pendingToolCalls.set(toolCallId, [msgIndex, partIndex]);
           toolCallIds.push(toolCallId);
         }
       }
@@ -1300,10 +1374,8 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
     if (toolCallIds.length > 0) {
       assistantUuidToToolCalls.set(uuid, toolCallIds);
     }
-    assistantState.currentIndex = currentAssistantIndex;
-    assistantState.latestTextIndex = latestAssistantTextIndex;
   }
-  convertUserRecord(data, messages, pendingToolCalls, ignoredToolCallIds, assistantUuidToToolCalls, assistantState) {
+  convertUserRecord(data, builder, ignoredToolCallIds, assistantUuidToToolCalls) {
     const msg = data["message"] ?? {};
     const timestampMs = parseTimestampMs(data);
     const content = msg["content"] ?? "";
@@ -1311,18 +1383,14 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
     if (typeof content === "string") {
       const parts = this.normalizeUserTextParts(content, timestampMs);
       if (parts.length === 0) {
-        assistantState.currentIndex = null;
-        assistantState.latestTextIndex = null;
+        builder.beginTurn();
         return;
       }
-      messages.push(this.buildMessage({ messageId: uuid, role: "user", timestampMs, parts }));
-      assistantState.currentIndex = null;
-      assistantState.latestTextIndex = null;
+      builder.appendMessage({ id: uuid, role: "user", timestampMs, parts });
       return;
     }
     if (!Array.isArray(content)) {
-      assistantState.currentIndex = null;
-      assistantState.latestTextIndex = null;
+      builder.beginTurn();
       return;
     }
     const visibleParts = this.normalizeUserTextParts(content, timestampMs);
@@ -1334,13 +1402,7 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
       const toolCallId = this.resolveToolCallId(data, ci, assistantUuidToToolCalls);
       if (toolCallId && ignoredToolCallIds.has(toolCallId)) continue;
       const outputParts = this.normalizeClaudeToolOutput(ci["content"], timestampMs);
-      if (this.backfillToolOutput(
-        messages,
-        pendingToolCalls,
-        toolCallId,
-        outputParts,
-        toolStateUpdates
-      )) {
+      if (this.backfillToolOutput(builder, toolCallId, outputParts, toolStateUpdates)) {
         continue;
       }
       const fallback = this.buildFallbackToolMessage({
@@ -1349,17 +1411,14 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
         toolCallId,
         outputParts
       });
-      if (fallback) messages.push(fallback);
+      if (fallback) builder.appendMessage(fallback);
     }
     if (visibleParts.length > 0) {
-      messages.push(
-        this.buildMessage({ messageId: uuid, role: "user", timestampMs, parts: visibleParts })
-      );
+      builder.appendMessage({ id: uuid, role: "user", timestampMs, parts: visibleParts });
     }
-    assistantState.currentIndex = null;
-    assistantState.latestTextIndex = null;
+    builder.beginTurn();
   }
-  convertToolResultRecord(data, messages, assistantState) {
+  convertToolResultRecord(data, builder) {
     const timestampMs = parseTimestampMs(data);
     const msg = data["message"] ?? {};
     const outputParts = this.normalizeClaudeToolOutput(msg["content"], timestampMs);
@@ -1370,25 +1429,8 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
       toolCallId: null,
       outputParts
     });
-    if (fallback) messages.push(fallback);
-    assistantState.currentIndex = null;
-    assistantState.latestTextIndex = null;
-  }
-  // --- Message building ---
-  buildMessage(opts) {
-    return {
-      id: opts.messageId,
-      role: opts.role,
-      agent: opts.agent ?? null,
-      time_created: opts.timestampMs,
-      mode: opts.mode ?? null,
-      model: opts.model ?? null,
-      provider: opts.provider ?? null,
-      tokens: opts.tokens ? opts.tokens : void 0,
-      cost: opts.cost ?? 0,
-      cost_source: opts.cost_source,
-      parts: opts.parts
-    };
+    if (fallback) builder.appendMessage(fallback);
+    builder.beginTurn();
   }
   buildTextPart(text, timestampMs) {
     return { type: "text", text, time_created: timestampMs };
@@ -1431,71 +1473,6 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
       }
     }
   }
-  // --- Assistant message grouping ---
-  appendAssistantReasoning(messages, opts, currentIndex) {
-    const part = this.buildReasoningPart(opts.text, opts.timestampMs);
-    if (currentIndex !== null) {
-      const message2 = messages[currentIndex];
-      const hasText = message2.parts.some((p) => p.type === "text");
-      const hasTool = message2.parts.some((p) => p.type === "tool");
-      if (!hasText && !hasTool) {
-        this.appendPartIfNew(message2, part);
-        this.applyAssistantMetadata(message2, opts.data, opts.msg, opts.countedUsageKeys);
-        return currentIndex;
-      }
-    }
-    const message = this.buildMessage({
-      messageId: opts.messageId,
-      role: "assistant",
-      timestampMs: opts.timestampMs,
-      parts: [part],
-      agent: "claude"
-    });
-    this.applyAssistantMetadata(message, opts.data, opts.msg, opts.countedUsageKeys);
-    messages.push(message);
-    return messages.length - 1;
-  }
-  appendAssistantText(messages, opts, currentIndex) {
-    const part = this.buildTextPart(opts.text, opts.timestampMs);
-    if (currentIndex !== null) {
-      const message2 = messages[currentIndex];
-      const hasTool = message2.parts.some((p) => p.type === "tool");
-      if (!hasTool) {
-        this.appendPartIfNew(message2, part);
-        this.applyAssistantMetadata(message2, opts.data, opts.msg, opts.countedUsageKeys);
-        return currentIndex;
-      }
-    }
-    const message = this.buildMessage({
-      messageId: opts.messageId,
-      role: "assistant",
-      timestampMs: opts.timestampMs,
-      parts: [part],
-      agent: "claude"
-    });
-    this.applyAssistantMetadata(message, opts.data, opts.msg, opts.countedUsageKeys);
-    messages.push(message);
-    return messages.length - 1;
-  }
-  attachToolCallToLatestAssistant(messages, opts) {
-    if (opts.latestTextIndex !== null) {
-      const message2 = messages[opts.latestTextIndex];
-      message2.parts.push(opts.toolPart);
-      this.applyAssistantMetadata(message2, opts.data, opts.msg, opts.countedUsageKeys);
-      return [opts.latestTextIndex, message2.parts.length - 1];
-    }
-    const message = this.buildMessage({
-      messageId: opts.messageId,
-      role: "assistant",
-      timestampMs: opts.timestampMs,
-      parts: [opts.toolPart],
-      agent: "claude",
-      mode: "tool"
-    });
-    this.applyAssistantMetadata(message, opts.data, opts.msg, opts.countedUsageKeys);
-    messages.push(message);
-    return [messages.length - 1, 0];
-  }
   // --- User content normalization ---
   normalizeUserTextParts(content, timestampMs) {
     if (typeof content === "string") {
@@ -1543,29 +1520,19 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
     return text ? [this.buildTextPart(text, timestampMs)] : [];
   }
   // --- Tool backfill ---
-  backfillToolOutput(messages, pendingToolCalls, callId, outputParts, stateUpdates) {
+  backfillToolOutput(builder, callId, outputParts, stateUpdates) {
     if (!callId) return false;
-    const location = pendingToolCalls.get(callId);
-    if (location === void 0) return false;
-    const [msgIndex, partIndex] = location;
-    const state = messages[msgIndex].parts[partIndex].state ?? (messages[msgIndex].parts[partIndex].state = {});
-    if (outputParts.length > 0) {
-      const existing = state.output;
-      if (Array.isArray(existing)) {
-        existing.push(...outputParts);
-      } else if (existing === null || existing === void 0) {
-        state.output = [...outputParts];
-      } else {
-        state.output = [existing, ...outputParts];
+    return builder.updateToolCall(callId, (part) => {
+      const state = part.state ?? (part.state = {});
+      if (outputParts.length > 0) {
+        const existing = state.output;
+        if (Array.isArray(existing)) existing.push(...outputParts);
+        else if (existing == null) state.output = [...outputParts];
+        else state.output = [existing, ...outputParts];
       }
-    }
-    if (stateUpdates) {
-      Object.assign(state, stateUpdates);
-    }
-    if (outputParts.length > 0 && !state.status) {
-      state.status = "completed";
-    }
-    return outputParts.length > 0 || !!stateUpdates;
+      if (stateUpdates) Object.assign(state, stateUpdates);
+      if (outputParts.length > 0 && !state.status) state.status = "completed";
+    });
   }
   resolveToolCallId(data, item, assistantUuidToToolCalls) {
     const directId = String(item["tool_use_id"] ?? "").trim();
@@ -1593,25 +1560,17 @@ var ClaudeCodeAgent = class extends FileSystemSessionSource {
   // --- Fallback ---
   buildFallbackToolMessage(opts) {
     if (opts.outputParts.length === 0) return null;
-    return this.buildMessage({
-      messageId: opts.messageId,
+    return {
+      id: opts.messageId,
       role: "tool",
       timestampMs: opts.timestampMs,
       parts: opts.outputParts
-    });
+    };
   }
   // --- Utilities ---
   shouldIgnoreTool(toolName) {
     return toolName === "TodoWrite";
   }
-  appendPartIfNew(message, part) {
-    const parts = message.parts;
-    if (parts.length > 0 && parts[parts.length - 1].type === part.type) {
-      const tail = parts[parts.length - 1];
-      if (tail.text === part.text) return;
-    }
-    parts.push(part);
-  }
 };
 var DatabaseConstructor = null;
 try {
@@ -2142,7 +2101,7 @@ function kimiContentText(content) {
 }
 function extractFirstUserTitle(contextFile, wireFile) {
   if (contextFile && existsSync6(contextFile)) {
-    const content = readFileSync4(contextFile, "utf-8");
+    const content = readFileSync3(contextFile, "utf-8");
     for (const record of parseJsonlLines(content)) {
       if (record.role !== "user") continue;
       const title = normalizeTitleText(kimiContentText(record.content));
@@ -2150,7 +2109,7 @@ function extractFirstUserTitle(contextFile, wireFile) {
     }
   }
   if (wireFile && existsSync6(wireFile)) {
-    const content = readFileSync4(wireFile, "utf-8");
+    const content = readFileSync3(wireFile, "utf-8");
     for (const record of parseJsonlLines(content)) {
       const message = record.message ?? {};
       if (message.type !== "TurnBegin") continue;
@@ -2179,12 +2138,12 @@ var KimiAgent = class extends FileSystemSessionSource {
     const configPath = join6(roots.kimiRoot, "kimi.json");
     const tomlPath = join6(roots.kimiRoot, "config.toml");
     if (existsSync6(tomlPath)) {
-      const configText = readFileSync4(tomlPath, "utf-8");
+      const configText = readFileSync3(tomlPath, "utf-8");
       this.defaultModel = configText.match(/^default_model\s*=\s*"([^"]+)"/m)?.[1] ?? null;
     }
     if (!existsSync6(configPath)) return;
     try {
-      const raw = JSON.parse(readFileSync4(configPath, "utf-8"));
+      const raw = JSON.parse(readFileSync3(configPath, "utf-8"));
       const workDirs = raw?.work_dirs;
       if (!Array.isArray(workDirs)) return;
       for (const wd of workDirs) {
@@ -2248,12 +2207,12 @@ var KimiAgent = class extends FileSystemSessionSource {
       let wireMtime = null;
       let metaFile = "";
       if (existsSync6(statePath)) {
-        const state = JSON.parse(readFileSync4(statePath, "utf-8"));
+        const state = JSON.parse(readFileSync3(statePath, "utf-8"));
         title = String(state.custom_title ?? "");
         wireMtime = typeof state.wire_mtime === "number" ? state.wire_mtime : null;
         metaFile = statePath;
       } else if (existsSync6(metaPath)) {
-        const meta = JSON.parse(readFileSync4(metaPath, "utf-8"));
+        const meta = JSON.parse(readFileSync3(metaPath, "utf-8"));
         title = String(meta.title ?? "");
         wireMtime = typeof meta.wire_mtime === "number" ? meta.wire_mtime : null;
         metaFile = metaPath;
@@ -2277,50 +2236,6 @@ var KimiAgent = class extends FileSystemSessionSource {
       return skippedSession("malformed metadata");
     }
   }
-  scan(options) {
-    if (!this.basePath) return [];
-    const scanMarker = perf.start("kimi:scan");
-    const listMarker = perf.start("listSessionDirs");
-    const sessionDirs = this.listSessionDirs();
-    perf.end(listMarker);
-    const metas = [];
-    for (const dir of sessionDirs) {
-      try {
-        const parseMarker = perf.start(`parseSessionDir:${basename4(dir)}`);
-        const meta = getParsedSession(this.parseSessionDirResult(dir));
-        perf.end(parseMarker);
-        if (meta && matchesScanWindow(meta.createdAt, options)) {
-          metas.push(meta);
-        }
-      } catch {
-      }
-    }
-    options?.onProgress?.({ total: metas.length, processed: 0, sessions: 0 });
-    const heads = [];
-    let processed = 0;
-    for (const meta of metas) {
-      try {
-        meta.sourceFingerprint = this.sourceFingerprint(meta);
-        this.sessionMetaMap.set(meta.id, meta);
-        const stats = this.extractStats(meta.sourcePath);
-        heads.push({
-          id: meta.id,
-          slug: `kimi/${meta.id}`,
-          title: meta.title,
-          directory: meta.cwd,
-          time_created: meta.createdAt,
-          time_updated: meta.createdAt,
-          stats
-        });
-      } catch {
-      } finally {
-        processed += 1;
-        options?.onProgress?.({ total: metas.length, processed, sessions: heads.length });
-      }
-    }
-    perf.end(scanMarker);
-    return heads;
-  }
   listSessionSources(options) {
     if (!this.basePath) return [];
     const refs = [];
@@ -2361,9 +2276,8 @@ var KimiAgent = class extends FileSystemSessionSource {
   }
   getSessionDataFromContext(meta) {
     if (!meta.contextFile) throw new Error("context.jsonl is missing");
-    const content = readFileSync4(meta.contextFile, "utf-8");
-    const messages = [];
-    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const content = readFileSync3(meta.contextFile, "utf-8");
+    const builder = new TranscriptBuilder();
     const ignoredToolCallIds = /* @__PURE__ */ new Set();
     let seq = 0;
     const fallbackTs = meta.createdAt;
@@ -2375,65 +2289,55 @@ var KimiAgent = class extends FileSystemSessionSource {
         if (role === "user") {
           const text = cleanInternalText(kimiContentText(record.content));
           if (text) {
-            messages.push(
-              this.buildMessage({
-                messageId: `context-${seq}`,
-                role: "user",
-                timestampMs: fallbackTs,
-                parts: [{ type: "text", text, time_created: fallbackTs }]
-              })
-            );
+            builder.appendMessage({
+              id: `context-${seq}`,
+              role: "user",
+              timestampMs: fallbackTs,
+              parts: [{ type: "text", text, time_created: fallbackTs }]
+            });
           }
           continue;
         }
         if (role === "assistant") {
-          const { message, toolIndexes } = this.buildContextAssistantMessage(
+          const message = this.buildContextAssistantMessage(
             record,
             seq,
             ignoredToolCallIds,
             fallbackTs
           );
           if (!message) continue;
-          const msgIndex = messages.length;
-          messages.push(message);
-          for (const [callId, partIndex] of toolIndexes) {
-            pendingToolCalls.set(callId, [msgIndex, partIndex]);
-          }
+          builder.appendMessage(message);
           continue;
         }
         if (role === "tool") {
           const callId = String(record.tool_call_id ?? "").trim();
           if (callId && ignoredToolCallIds.has(callId)) continue;
           const outputParts = normalizeToolOutputParts(record.content, fallbackTs);
-          if (callId && this.backfillToolOutput(messages, pendingToolCalls, callId, outputParts)) {
+          if (callId && this.backfillToolOutput(builder, callId, outputParts)) {
             continue;
           }
           if (outputParts.length > 0) {
-            messages.push(
-              this.buildMessage({
-                messageId: `context-${seq}`,
-                role: "tool",
-                timestampMs: fallbackTs,
-                parts: outputParts
-              })
-            );
+            builder.appendMessage({
+              id: `context-${seq}`,
+              role: "tool",
+              timestampMs: fallbackTs,
+              parts: outputParts
+            });
           }
         }
       } catch {
       }
     }
     const stats = this.extractStats(meta.sourcePath);
-    return this.buildSessionData(meta, messages, stats);
+    return this.buildSessionData(meta, builder, stats);
   }
   getSessionDataFromWire(meta) {
     const wirePath = meta.wireFile ?? join6(meta.sourcePath, "wire.jsonl");
     if (!existsSync6(wirePath)) throw new Error("wire.jsonl is missing");
-    const content = readFileSync4(wirePath, "utf-8");
-    const messages = [];
-    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const content = readFileSync3(wirePath, "utf-8");
+    const builder = new TranscriptBuilder();
     const ignoredToolCallIds = /* @__PURE__ */ new Set();
     const openToolArgumentBuffer = /* @__PURE__ */ new Map();
-    let currentAssistantIndex = null;
     let openToolCallId = null;
     let seq = 0;
     for (const record of parseJsonlLines(content)) {
@@ -2450,19 +2354,13 @@ var KimiAgent = class extends FileSystemSessionSource {
           const inputTokens = Number(usage["input_tokens"] ?? 0);
           const outputTokens = Number(usage["output_tokens"] ?? 0);
           if (inputTokens || outputTokens) {
-            for (let i = messages.length - 1; i >= 0; i--) {
-              const msg = messages[i];
-              if (msg.role === "assistant" && !msg.tokens) {
-                msg.tokens = { input: inputTokens, output: outputTokens };
-                msg.model ??= this.defaultModel;
-                const cost = estimateTokenCost(msg.model, msg.tokens);
-                if (cost !== null) {
-                  msg.cost = cost;
-                  msg.cost_source = "estimated";
-                }
-                break;
-              }
-            }
+            const tokens = { input: inputTokens, output: outputTokens };
+            const cost = estimateTokenCost(this.defaultModel, tokens);
+            builder.attachUsageToLatestAssistant(tokens, {
+              model: this.defaultModel,
+              cost: cost ?? void 0,
+              costSource: cost === null ? void 0 : "estimated"
+            });
           }
         }
         if (msgType === "TurnBegin") {
@@ -2470,37 +2368,37 @@ var KimiAgent = class extends FileSystemSessionSource {
           if (Array.isArray(userInput) && userInput.length > 0) {
             const text = cleanInternalText(kimiContentText(userInput));
             if (text) {
-              messages.push(
-                this.buildMessage({
-                  messageId: `wire-${seq}`,
-                  role: "user",
-                  timestampMs,
-                  parts: [{ type: "text", text, time_created: timestampMs }]
-                })
-              );
+              builder.appendMessage({
+                id: `wire-${seq}`,
+                role: "user",
+                timestampMs,
+                parts: [{ type: "text", text, time_created: timestampMs }]
+              });
             }
           }
-          currentAssistantIndex = null;
+          builder.beginTurn();
           openToolCallId = null;
           continue;
         }
         if (msgType === "ContentPart") {
-          currentAssistantIndex = this.getOrCreateWireAssistant(
-            messages,
-            currentAssistantIndex,
-            `wire-${seq}`
-          );
-          const assistant = messages[currentAssistantIndex];
           const partType = String(payload.type ?? "");
           if (partType === "think") {
             const text = cleanInternalText(String(payload.think ?? ""));
             if (text) {
-              assistant.parts.push({ type: "reasoning", text, time_created: timestampMs });
+              builder.appendAssistantPart(
+                { type: "reasoning", text, time_created: timestampMs },
+                { id: `wire-${seq}`, timestampMs: 0, agent: "kimi" },
+                { grouping: "current" }
+              );
             }
           } else if (partType === "text") {
             const text = cleanInternalText(String(payload.text ?? ""));
             if (text) {
-              assistant.parts.push({ type: "text", text, time_created: timestampMs });
+              builder.appendAssistantPart(
+                { type: "text", text, time_created: timestampMs },
+                { id: `wire-${seq}`, timestampMs: 0, agent: "kimi" },
+                { grouping: "current" }
+              );
             }
           }
           continue;
@@ -2515,12 +2413,6 @@ var KimiAgent = class extends FileSystemSessionSource {
             continue;
           }
           if (!function_ || !callId || !toolName) continue;
-          currentAssistantIndex = this.getOrCreateWireAssistant(
-            messages,
-            currentAssistantIndex,
-            `wire-${seq}`
-          );
-          const assistant = messages[currentAssistantIndex];
           const rawArgs = function_.arguments;
           const normalizedArgs = normalizeToolArguments(rawArgs);
           const buffer = typeof rawArgs === "string" && typeof normalizedArgs !== "string" ? rawArgs : null;
@@ -2532,10 +2424,11 @@ var KimiAgent = class extends FileSystemSessionSource {
             state: { arguments: normalizedArgs, output: null },
             time_created: timestampMs
           };
-          const partIndex = assistant.parts.length;
-          assistant.parts.push(toolPart);
-          assistant.mode = "tool";
-          pendingToolCalls.set(callId, [currentAssistantIndex, partIndex]);
+          builder.appendToolCall(
+            toolPart,
+            { id: `wire-${seq}`, timestampMs: 0, agent: "kimi" },
+            { markModeAsTool: true, target: "current" }
+          );
           openToolCallId = callId;
           if (buffer !== null) {
             openToolArgumentBuffer.set(callId, buffer);
@@ -2549,8 +2442,7 @@ var KimiAgent = class extends FileSystemSessionSource {
             argumentsPart,
             openToolCallId,
             openToolArgumentBuffer,
-            messages,
-            pendingToolCalls
+            builder
           );
           continue;
         }
@@ -2558,27 +2450,24 @@ var KimiAgent = class extends FileSystemSessionSource {
           const callId = String(payload.tool_call_id ?? "").trim();
           if (callId && ignoredToolCallIds.has(callId)) continue;
           const outputParts = normalizeWireToolOutputParts(payload.return_value, timestampMs);
-          if (callId && this.backfillToolOutput(messages, pendingToolCalls, callId, outputParts)) {
+          if (callId && this.backfillToolOutput(builder, callId, outputParts)) {
             continue;
           }
           if (outputParts.length > 0) {
-            messages.push(
-              this.buildMessage({
-                messageId: `wire-${seq}`,
-                role: "tool",
-                timestampMs,
-                parts: outputParts
-              })
-            );
+            builder.appendMessage({
+              id: `wire-${seq}`,
+              role: "tool",
+              timestampMs,
+              parts: outputParts
+            });
           }
           continue;
         }
       } catch {
       }
     }
-    const filteredMessages = messages.filter((m) => m.parts.length > 0);
     const stats = this.extractStats(meta.sourcePath);
-    return this.buildSessionData(meta, filteredMessages, stats);
+    return this.buildSessionData(meta, builder, stats);
   }
   // --- Helpers ---
   sourceFingerprint(meta) {
@@ -2596,23 +2485,8 @@ var KimiAgent = class extends FileSystemSessionSource {
       fileMtime(meta.wireFile)
     ]);
   }
-  buildMessage(opts) {
-    return {
-      id: opts.messageId,
-      role: opts.role,
-      agent: opts.agent ?? null,
-      time_created: opts.timestampMs,
-      mode: opts.mode ?? null,
-      model: opts.model ?? null,
-      provider: opts.provider ?? null,
-      tokens: opts.tokens ? opts.tokens : void 0,
-      cost: opts.cost ?? 0,
-      parts: opts.parts
-    };
-  }
   buildContextAssistantMessage(record, seq, ignoredToolCallIds, fallbackTs) {
     const parts = [];
-    const toolIndexes = /* @__PURE__ */ new Map();
     const content = record.content;
     if (Array.isArray(content)) {
       for (const item of content) {
@@ -2650,71 +2524,41 @@ var KimiAgent = class extends FileSystemSessionSource {
           state: { arguments: normalizeToolArguments(function_.arguments), output: null },
           time_created: fallbackTs
         };
-        toolIndexes.set(callId, parts.length);
         parts.push(part);
       }
     }
     if (parts.length === 0) {
-      return {
-        message: this.buildMessage({
-          messageId: `context-${seq}`,
-          role: "assistant",
-          timestampMs: fallbackTs,
-          parts: []
-        }),
-        toolIndexes
-      };
+      return null;
     }
     const allTools = parts.every((p) => p.type === "tool");
-    const message = this.buildMessage({
-      messageId: `context-${seq}`,
+    return {
+      id: `context-${seq}`,
       role: "assistant",
       timestampMs: fallbackTs,
       parts,
       agent: "kimi",
       mode: allTools ? "tool" : void 0
-    });
-    return { message, toolIndexes };
-  }
-  getOrCreateWireAssistant(messages, currentIndex, messageId) {
-    if (currentIndex !== null) return currentIndex;
-    messages.push(
-      this.buildMessage({
-        messageId,
-        role: "assistant",
-        timestampMs: 0,
-        parts: [],
-        agent: "kimi"
-      })
-    );
-    return messages.length - 1;
+    };
   }
-  appendWireToolCallPart(argumentsPart, openCallId, buffer, messages, pendingToolCalls) {
-    if (!openCallId || !pendingToolCalls.has(openCallId)) return;
+  appendWireToolCallPart(argumentsPart, openCallId, buffer, builder) {
+    if (!openCallId) return;
     const existing = buffer.get(openCallId) ?? "";
     const combined = existing + argumentsPart;
     try {
-      const parsed2 = JSON.parse(combined);
-      const location = pendingToolCalls.get(openCallId);
-      if (!location) return;
-      const msgPart = messages[location[0]]?.parts[location[1]];
-      if (msgPart?.state) {
-        msgPart.state.arguments = parsed2;
+      const parsed = JSON.parse(combined);
+      if (builder.updateToolCall(openCallId, (part) => {
+        const state = part.state ?? (part.state = {});
+        state.arguments = parsed;
+      })) {
+        buffer.delete(openCallId);
       }
-      buffer.delete(openCallId);
     } catch {
       buffer.set(openCallId, combined);
     }
   }
-  backfillToolOutput(messages, pendingToolCalls, callId, outputParts) {
+  backfillToolOutput(builder, callId, outputParts) {
     if (!outputParts.length || !callId) return false;
-    const location = pendingToolCalls.get(callId);
-    if (!location) return false;
-    const part = messages[location[0]]?.parts[location[1]];
-    if (!part) return false;
-    if (!part.state) part.state = {};
-    part.state.output = [...outputParts];
-    return true;
+    return builder.resolveToolCall(callId, { output: [...outputParts] });
   }
   extractStats(sessionDir) {
     let totalCost = 0;
@@ -2728,7 +2572,7 @@ var KimiAgent = class extends FileSystemSessionSource {
     const wirePath = join6(sessionDir, "wire.jsonl");
     if (!existsSync6(wirePath)) return stats;
     try {
-      const content = readFileSync4(wirePath, "utf-8");
+      const content = readFileSync3(wirePath, "utf-8");
       for (const line of content.split("\n").filter((l) => l.trim())) {
         try {
           const data = JSON.parse(line);
@@ -2752,7 +2596,7 @@ var KimiAgent = class extends FileSystemSessionSource {
     const rawPath = existsSync6(contextPath) ? contextPath : wirePath;
     if (!existsSync6(rawPath)) return stats;
     try {
-      const rawContent = readFileSync4(rawPath, "utf-8");
+      const rawContent = readFileSync3(rawPath, "utf-8");
       for (const line of rawContent.split("\n").filter((l) => l.trim())) {
         try {
           const data = JSON.parse(line);
@@ -2770,14 +2614,8 @@ var KimiAgent = class extends FileSystemSessionSource {
     }
     return stats;
   }
-  buildSessionData(meta, messages, stats) {
-    const cleanedMessages = cleanParsedMessages(messages);
-    stats.message_count = cleanedMessages.length;
-    const totalCost = cleanedMessages.reduce((sum, message) => sum + (message.cost ?? 0), 0);
-    if (totalCost > 0) {
-      stats.total_cost = Number(totalCost.toFixed(8));
-      stats.cost_source = "estimated";
-    }
+  buildSessionData(meta, builder, stats) {
+    const transcript = builder.finish(stats);
     return {
       id: meta.id,
       title: meta.title,
@@ -2785,8 +2623,8 @@ var KimiAgent = class extends FileSystemSessionSource {
       directory: meta.cwd,
       time_created: meta.createdAt,
       time_updated: meta.createdAt,
-      stats,
-      messages: cleanedMessages
+      stats: transcript.stats,
+      messages: transcript.messages
     };
   }
 };
@@ -2974,36 +2812,6 @@ var CodexAgent = class extends FileSystemSessionSource {
       return false;
     }
   }
-  scan(options) {
-    if (!this.basePath) return [];
-    const scanMarker = perf.start("codex:scan");
-    const indexMarker = perf.start("loadSessionIndex");
-    this.loadSessionIndex();
-    perf.end(indexMarker);
-    const heads = [];
-    const listMarker = perf.start("listRolloutFiles");
-    const files = this.listRolloutFiles(options);
-    perf.end(listMarker);
-    options?.onProgress?.({ total: files.length, processed: 0, sessions: 0 });
-    let processed = 0;
-    for (const file of files) {
-      try {
-        const parseMarker = perf.start(`parseSessionHead:${basename5(file)}`);
-        const head = getParsedSession(this.parseSessionHeadResult(file, options));
-        perf.end(parseMarker);
-        if (head) {
-          heads.push(head);
-          this.sessionMetaMap.set(head.id, this.buildSessionMeta(head, file));
-        }
-      } catch {
-      } finally {
-        processed += 1;
-        options?.onProgress?.({ total: files.length, processed, sessions: heads.length });
-      }
-    }
-    perf.end(scanMarker);
-    return heads;
-  }
   listSessionSources(options) {
     if (!this.basePath) return [];
     this.loadSessionIndex();
@@ -3013,9 +2821,9 @@ var CodexAgent = class extends FileSystemSessionSource {
       fingerprint: this.sourceFingerprint(file)
     }));
   }
-  scanSessionSource(sourcePath) {
+  scanSessionSource(sourcePath, options) {
     this.loadSessionIndex();
-    const head = getParsedSession(this.parseSessionHeadResult(sourcePath));
+    const head = getParsedSession(this.parseSessionHeadResult(sourcePath, options));
     if (head) {
       this.sessionMetaMap.set(head.id, this.buildSessionMeta(head, sourcePath));
     }
@@ -3025,15 +2833,11 @@ var CodexAgent = class extends FileSystemSessionSource {
     const meta = this.sessionMetaMap.get(sessionId);
     if (!meta) throw new Error(`Session not found: ${sessionId}`);
     if (!existsSync7(meta.sourcePath)) throw new Error(`Session file missing: ${meta.sourcePath}`);
-    const content = readFileSync5(meta.sourcePath, "utf-8");
-    const messages = [];
-    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const transcript = new TranscriptBuilder();
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
     let totalCacheReadTokens = 0;
     let totalCost = 0;
-    let currentAssistantIndex = null;
-    let latestAssistantTextIndex = null;
     let pendingPlan = null;
     let activeModel = meta.model;
     let prevCumulativeTotal = 0;
@@ -3041,31 +2845,14 @@ var CodexAgent = class extends FileSystemSessionSource {
     let prevOutput = 0;
     let prevReasoning = 0;
     let prevCachedInput = 0;
-    for (const record of parseJsonlLines(content)) {
+    for (const record of readJsonlFile(meta.sourcePath)) {
       try {
         const recordType = String(record["type"] ?? "");
         if (recordType === "turn_context") {
           const payload = record["payload"] ?? {};
           activeModel = extractModelName(payload["model"]) ?? activeModel;
         }
-        const result = this.convertRecord(
-          record,
-          messages,
-          pendingToolCalls,
-          meta.id,
-          currentAssistantIndex,
-          latestAssistantTextIndex,
-          pendingPlan
-        );
-        currentAssistantIndex = result.currentAssistantIndex;
-        latestAssistantTextIndex = result.latestAssistantTextIndex;
-        pendingPlan = result.pendingPlan;
-        if (currentAssistantIndex !== null && activeModel) {
-          const message = messages[currentAssistantIndex];
-          if (message?.role === "assistant" && !message.model) {
-            message.model = activeModel;
-          }
-        }
+        pendingPlan = this.convertRecord(record, transcript, pendingPlan, activeModel);
         if (recordType === "event_msg") {
           const payload = record["payload"] ?? {};
           if (String(payload["type"] ?? "") === "token_count") {
@@ -3101,24 +2888,19 @@ var CodexAgent = class extends FileSystemSessionSource {
                 totalInputTokens += totalInput;
                 totalOutputTokens += outputTokens + reasoningTokens;
                 totalCacheReadTokens += totalCacheRead;
-                for (let i = messages.length - 1; i >= 0; i--) {
-                  const msg = messages[i];
-                  if (msg.role === "assistant" && !msg.tokens) {
-                    msg.tokens = {
-                      input: totalInput,
-                      output: outputTokens,
-                      reasoning: reasoningTokens || void 0,
-                      cache_read: totalCacheRead || void 0
-                    };
-                    const cost = estimateTokenCost(msg.model ?? activeModel, msg.tokens);
-                    if (cost !== null) {
-                      msg.cost = cost;
-                      msg.cost_source = "estimated";
-                      totalCost += cost;
-                    }
-                    break;
-                  }
-                }
+                const tokens = {
+                  input: totalInput,
+                  output: outputTokens,
+                  reasoning: reasoningTokens || void 0,
+                  cache_read: totalCacheRead || void 0
+                };
+                const cost = estimateTokenCost(activeModel, tokens);
+                transcript.attachUsageToLatestAssistant(tokens, {
+                  model: activeModel,
+                  cost: cost ?? void 0,
+                  costSource: cost === null ? void 0 : "estimated"
+                });
+                totalCost += cost ?? 0;
               }
             }
           }
@@ -3126,10 +2908,15 @@ var CodexAgent = class extends FileSystemSessionSource {
       } catch {
       }
     }
-    if (pendingPlan && currentAssistantIndex !== null) {
-      messages[currentAssistantIndex].parts.push(pendingPlan);
-    }
-    const cleanedMessages = cleanParsedMessages(messages);
+    if (pendingPlan) transcript.appendToCurrentAssistant(pendingPlan);
+    const result = transcript.finish({
+      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
+    });
     return {
       id: meta.id,
       title: meta.title,
@@ -3137,15 +2924,8 @@ var CodexAgent = class extends FileSystemSessionSource {
       directory: meta.directory,
       time_created: meta.createdAt,
       time_updated: meta.updatedAt,
-      stats: {
-        message_count: cleanedMessages.length,
-        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
-      },
-      messages: cleanedMessages
+      stats: result.stats,
+      messages: result.messages
     };
   }
   // ---- File listing ----
@@ -3229,7 +3009,7 @@ var CodexAgent = class extends FileSystemSessionSource {
     this.sessionIndexMtime = mtime;
     if (mtime === null) return;
     try {
-      const content = readFileSync5(indexPath, "utf-8");
+      const content = readFileSync4(indexPath, "utf-8");
       for (const record of parseJsonlLines(content)) {
         const sid = String(record["id"] ?? "").trim();
         const threadName = String(record["thread_name"] ?? "").trim();
@@ -3246,13 +3026,13 @@ var CodexAgent = class extends FileSystemSessionSource {
   }
   // ---- Session head parsing ----
   readFilePrefix(filePath, bytes = 64 * 1024) {
-    const fd = openSync(filePath, "r");
+    const fd = openSync2(filePath, "r");
     try {
       const buffer = Buffer.alloc(bytes);
-      const bytesRead = readSync(fd, buffer, 0, bytes, 0);
+      const bytesRead = readSync2(fd, buffer, 0, bytes, 0);
       return buffer.subarray(0, bytesRead).toString("utf-8");
     } finally {
-      closeSync(fd);
+      closeSync2(fd);
     }
   }
   parseSessionHead(filePath, options) {
@@ -3262,23 +3042,12 @@ var CodexAgent = class extends FileSystemSessionSource {
     if (options?.fast) {
       return this.parseFastSessionHeadResult(filePath);
     }
-    const content = readFileSync5(filePath, "utf-8");
-    const lines = content.split("\n").filter((l) => l.trim());
-    if (lines.length === 0) return skippedSession("empty file");
     const sessionId = extractSessionId(filePath);
-    let firstRecord;
-    try {
-      firstRecord = JSON.parse(lines[0]);
-    } catch {
-      return skippedSession("malformed first record");
-    }
-    const payload = firstRecord["payload"] ?? {};
-    const createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(payload) || statSync4(filePath).mtimeMs;
-    const indexTitle = this.getTitleForSession(sessionId);
-    const messageTitle = this.extractTitleFromLines(lines);
-    const directoryTitle = basenameTitle(payload["cwd"] ? String(payload["cwd"]) : null);
-    const title = resolveSessionTitle(indexTitle, messageTitle, directoryTitle);
-    let updatedAt = createdAt;
+    let firstPayload = {};
+    let createdAt = 0;
+    let lineCount = 0;
+    const titleLines = [];
+    let updatedAt = 0;
     let messageCount = 0;
     let model = null;
     let activeModel = null;
@@ -3294,18 +3063,31 @@ var CodexAgent = class extends FileSystemSessionSource {
     let scanPrevCachedInput = 0;
     const COUNTED_TYPES = /* @__PURE__ */ new Set(["message", "function_call", "function_call_output"]);
     let hasNonInternalRecord = false;
-    for (const line of lines) {
+    for (const line of readJsonlFileLines(filePath)) {
+      lineCount += 1;
+      if (lineCount === 1) {
+        let firstRecord;
+        try {
+          firstRecord = JSON.parse(line);
+        } catch {
+          return skippedSession("malformed first record");
+        }
+        firstPayload = firstRecord["payload"] ?? {};
+        createdAt = parseTimestampMs2(firstRecord) || parseTimestampMs2(firstPayload) || statSync4(filePath).mtimeMs;
+        updatedAt = createdAt;
+      }
+      if (titleLines.length < 20) titleLines.push(line);
       try {
         const data = JSON.parse(line);
         const recordType = String(data["type"] ?? "");
-        const payload2 = data["payload"] ?? {};
-        const payloadType = String(payload2["type"] ?? "");
+        const payload = data["payload"] ?? {};
+        const payloadType = String(payload["type"] ?? "");
         if (isInternalEventType2(recordType) || isInternalEventType2(payloadType)) continue;
         hasNonInternalRecord = true;
         const recordTs = parseTimestampMs2(data) || parseTimestampMs2(data["payload"] ?? {});
         if (recordTs > updatedAt) updatedAt = recordTs;
         if (recordType === "session_meta" || recordType === "turn_context") {
-          const nextModel = extractModelName(payload2["model"]);
+          const nextModel = extractModelName(payload["model"]);
           if (nextModel) {
             activeModel = nextModel;
             model ??= nextModel;
@@ -3313,7 +3095,7 @@ var CodexAgent = class extends FileSystemSessionSource {
           continue;
         }
         if (recordType === "response_item") {
-          const p = payload2;
+          const p = payload;
           const pType = String(p["type"] ?? "");
           if (COUNTED_TYPES.has(pType)) {
             messageCount++;
@@ -3375,8 +3157,12 @@ var CodexAgent = class extends FileSystemSessionSource {
       } catch {
       }
     }
+    if (lineCount === 0) return skippedSession("empty file");
     if (!hasNonInternalRecord) return filteredSession("internal events only");
-    const directory = payload["cwd"] ? String(payload["cwd"]) : "";
+    const indexTitle = this.getTitleForSession(sessionId);
+    const messageTitle = this.extractTitleFromLines(titleLines);
+    const directory = firstPayload["cwd"] ? String(firstPayload["cwd"]) : "";
+    const title = resolveSessionTitle(indexTitle, messageTitle, basenameTitle(directory || null));
     return parsedSession({
       id: sessionId,
       slug: `codex/${sessionId}`,
@@ -3458,22 +3244,16 @@ var CodexAgent = class extends FileSystemSessionSource {
     return null;
   }
   // ---- Record conversion ----
-  convertRecord(data, messages, pendingToolCalls, sessionId, currentAssistantIndex, latestAssistantTextIndex, pendingPlan) {
+  convertRecord(data, transcript, pendingPlan, activeModel) {
     const recordType = String(data["type"] ?? "");
-    if (isInternalEventType2(recordType)) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-    }
+    if (isInternalEventType2(recordType)) return pendingPlan;
     if (recordType === "session_meta" || recordType === "event_msg") {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-    }
-    if (recordType !== "response_item") {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+      return pendingPlan;
     }
+    if (recordType !== "response_item") return pendingPlan;
     const payload = data["payload"] ?? {};
     const payloadType = String(payload["type"] ?? "");
-    if (isInternalEventType2(payloadType)) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-    }
+    if (isInternalEventType2(payloadType)) return pendingPlan;
     const timestampMs = parseTimestampMs2(data) || parseTimestampMs2(payload);
     switch (payloadType) {
       case "message": {
@@ -3481,60 +3261,39 @@ var CodexAgent = class extends FileSystemSessionSource {
         if (role === "assistant") {
           return this.convertAssistantMessage(
             payload,
-            messages,
+            transcript,
             timestampMs,
-            currentAssistantIndex,
-            latestAssistantTextIndex,
-            pendingPlan
+            pendingPlan,
+            activeModel
           );
         }
         if (role === "user") {
-          return this.convertUserMessage(
-            payload,
-            messages,
-            timestampMs,
-            currentAssistantIndex,
-            latestAssistantTextIndex,
-            pendingPlan
-          );
+          return this.convertUserMessage(payload, transcript, timestampMs, pendingPlan);
         }
         break;
       }
       case "reasoning":
-        return this.convertReasoning(payload, messages, timestampMs, currentAssistantIndex);
+        this.convertReasoning(payload, transcript, timestampMs, activeModel);
+        return null;
       case "function_call":
-        return this.convertFunctionCall(
-          payload,
-          messages,
-          pendingToolCalls,
-          timestampMs,
-          currentAssistantIndex,
-          latestAssistantTextIndex
-        );
+        this.convertFunctionCall(payload, transcript, timestampMs, activeModel);
+        return null;
       case "function_call_output":
-        this.convertFunctionCallOutput(payload, messages, pendingToolCalls, timestampMs);
-        return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+        this.convertToolCallOutput(payload, transcript, timestampMs);
+        return pendingPlan;
       case "custom_tool_call":
-        return this.convertCustomToolCall(
-          payload,
-          messages,
-          pendingToolCalls,
-          timestampMs,
-          currentAssistantIndex,
-          latestAssistantTextIndex
-        );
+        this.convertCustomToolCall(payload, transcript, timestampMs, activeModel);
+        return null;
       case "custom_tool_call_output":
-        this.convertCustomToolCallOutput(payload, messages, pendingToolCalls, timestampMs);
-        return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+        this.convertToolCallOutput(payload, transcript, timestampMs);
+        return pendingPlan;
     }
-    return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    return pendingPlan;
   }
   // ---- Assistant message ----
-  convertAssistantMessage(payload, messages, timestampMs, currentAssistantIndex, latestAssistantTextIndex, pendingPlan) {
+  convertAssistantMessage(payload, transcript, timestampMs, pendingPlan, activeModel) {
     const content = payload["content"];
-    if (!Array.isArray(content)) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-    }
+    if (!Array.isArray(content)) return pendingPlan;
     const textParts = [];
     for (const item of content) {
       if (typeof item !== "object" || item === null) continue;
@@ -3544,9 +3303,7 @@ var CodexAgent = class extends FileSystemSessionSource {
         if (text.trim()) textParts.push(text);
       }
     }
-    if (textParts.length === 0) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-    }
+    if (textParts.length === 0) return pendingPlan;
     const fullText = textParts.join("\n");
     const planMatch = fullText.match(PROPOSED_PLAN_PATTERN);
     if (planMatch) {
@@ -3560,61 +3317,34 @@ var CodexAgent = class extends FileSystemSessionSource {
       pendingPlan = planPart;
     }
     const displayText = cleanInternalText(fullText.replace(PROPOSED_PLAN_PATTERN, ""));
-    if (!displayText) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-    }
+    if (!displayText) return pendingPlan;
     const textPart = { type: "text", text: displayText, time_created: timestampMs };
-    if (currentAssistantIndex !== null) {
-      const message = messages[currentAssistantIndex];
-      const hasTool = message.parts.some((p) => p.type === "tool");
-      if (!hasTool) {
-        message.parts.push(textPart);
-        latestAssistantTextIndex = currentAssistantIndex;
-        return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-      }
-    }
-    messages.push(
-      this.buildMessage({
-        messageId: "",
-        role: "assistant",
-        timestampMs,
-        parts: [textPart],
-        agent: "codex"
-      })
-    );
-    currentAssistantIndex = messages.length - 1;
-    latestAssistantTextIndex = currentAssistantIndex;
-    return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    transcript.appendAssistantPart(textPart, {
+      id: "",
+      timestampMs,
+      agent: "codex",
+      model: activeModel
+    });
+    return pendingPlan;
   }
   // ---- User message ----
-  convertUserMessage(payload, messages, timestampMs, currentAssistantIndex, latestAssistantTextIndex, pendingPlan) {
+  convertUserMessage(payload, transcript, timestampMs, pendingPlan) {
     const content = payload["content"];
     const text = Array.isArray(content) ? content.map(
       (c) => typeof c === "object" && c !== null ? String(c["text"] ?? "") : String(c ?? "")
     ).join(" ") : String(content ?? "");
     const visibleText = cleanInternalText(text);
-    if (!visibleText) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-    }
-    if (isDeveloperLikeUserMessage(visibleText)) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
-    }
+    if (!visibleText) return pendingPlan;
+    if (isDeveloperLikeUserMessage(visibleText)) return pendingPlan;
     if (visibleText.trimStart().startsWith(PLAN_APPROVAL_PREFIX)) {
-      if (pendingPlan && currentAssistantIndex !== null) {
-        messages[currentAssistantIndex].parts.push(pendingPlan);
-      }
-      pendingPlan = null;
-      messages.push(
-        this.buildMessage({
-          messageId: "",
-          role: "user",
-          timestampMs,
-          parts: [{ type: "text", text: visibleText, time_created: timestampMs }]
-        })
-      );
-      currentAssistantIndex = null;
-      latestAssistantTextIndex = null;
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+      if (pendingPlan) transcript.appendToCurrentAssistant(pendingPlan);
+      transcript.appendMessage({
+        id: "",
+        role: "user",
+        timestampMs,
+        parts: [{ type: "text", text: visibleText, time_created: timestampMs }]
+      });
+      return null;
     }
     const subagentMatch = visibleText.match(SUBAGENT_NOTIFICATION_PATTERN);
     if (subagentMatch) {
@@ -3628,41 +3358,32 @@ var CodexAgent = class extends FileSystemSessionSource {
           text: completedText || `Subagent ${nickname} completed`,
           time_created: timestampMs
         };
-        messages.push(
-          this.buildMessage({
-            messageId: "",
-            role: "assistant",
-            timestampMs,
-            parts: [textPart],
-            agent: "codex",
-            subagent_id: agentId || void 0,
-            nickname: nickname || void 0
-          })
-        );
-        currentAssistantIndex = null;
-        latestAssistantTextIndex = null;
-        return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+        transcript.appendMessage({
+          id: "",
+          role: "assistant",
+          timestampMs,
+          parts: [textPart],
+          agent: "codex",
+          subagentId: agentId || void 0,
+          nickname: nickname || void 0
+        });
+        transcript.beginTurn();
+        return pendingPlan;
       } catch {
       }
     }
-    messages.push(
-      this.buildMessage({
-        messageId: "",
-        role: "user",
-        timestampMs,
-        parts: [{ type: "text", text: visibleText, time_created: timestampMs }]
-      })
-    );
-    currentAssistantIndex = null;
-    latestAssistantTextIndex = null;
-    return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan };
+    transcript.appendMessage({
+      id: "",
+      role: "user",
+      timestampMs,
+      parts: [{ type: "text", text: visibleText, time_created: timestampMs }]
+    });
+    return pendingPlan;
   }
   // ---- Reasoning ----
-  convertReasoning(payload, messages, timestampMs, currentAssistantIndex) {
+  convertReasoning(payload, transcript, timestampMs, activeModel) {
     const summary = payload["summary"];
-    if (!Array.isArray(summary)) {
-      return { currentAssistantIndex, latestAssistantTextIndex: null, pendingPlan: null };
-    }
+    if (!Array.isArray(summary)) return;
     const texts = [];
     for (const item of summary) {
       if (typeof item === "object" && item !== null) {
@@ -3673,42 +3394,25 @@ var CodexAgent = class extends FileSystemSessionSource {
         }
       }
     }
-    if (texts.length === 0) {
-      return { currentAssistantIndex, latestAssistantTextIndex: null, pendingPlan: null };
-    }
+    if (texts.length === 0) return;
     const reasoningText = texts.join("\n");
     const part = { type: "reasoning", text: reasoningText, time_created: timestampMs };
-    if (currentAssistantIndex !== null) {
-      const message = messages[currentAssistantIndex];
-      const hasText = message.parts.some((p) => p.type === "text");
-      const hasTool = message.parts.some((p) => p.type === "tool");
-      if (!hasText && !hasTool) {
-        message.parts.push(part);
-        return { currentAssistantIndex, latestAssistantTextIndex: null, pendingPlan: null };
-      }
-    }
-    messages.push(
-      this.buildMessage({
-        messageId: "",
-        role: "assistant",
+    transcript.appendAssistantPart(
+      part,
+      {
+        id: "",
         timestampMs,
-        parts: [part],
-        agent: "codex"
-      })
+        agent: "codex",
+        model: activeModel
+      },
+      { resetLatestText: true }
     );
-    return {
-      currentAssistantIndex: messages.length - 1,
-      latestAssistantTextIndex: null,
-      pendingPlan: null
-    };
   }
   // ---- Function call ----
-  convertFunctionCall(payload, messages, pendingToolCalls, timestampMs, currentAssistantIndex, latestAssistantTextIndex) {
+  convertFunctionCall(payload, transcript, timestampMs, activeModel) {
     const callId = String(payload["call_id"] ?? "").trim();
     const name = String(payload["name"] ?? "").trim();
-    if (!name) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan: null };
-    }
+    if (!name) return;
     const toolIdentity = resolveToolIdentity(name, payload["namespace"]);
     const arguments_ = normalizeToolArguments2(payload["arguments"]);
     const toolPart = {
@@ -3723,59 +3427,27 @@ var CodexAgent = class extends FileSystemSessionSource {
       },
       time_created: timestampMs
     };
-    const targetIndex = latestAssistantTextIndex ?? currentAssistantIndex;
-    if (targetIndex !== null) {
-      const message = messages[targetIndex];
-      const partIndex = message.parts.length;
-      message.parts.push(toolPart);
-      message.mode = "tool";
-      if (callId) {
-        pendingToolCalls.set(callId, [targetIndex, partIndex]);
-      }
-      return {
-        currentAssistantIndex: targetIndex,
-        latestAssistantTextIndex: targetIndex,
-        pendingPlan: null
-      };
-    }
-    messages.push(
-      this.buildMessage({
-        messageId: "",
-        role: "assistant",
-        timestampMs,
-        parts: [toolPart],
-        agent: "codex",
-        mode: "tool"
-      })
+    transcript.appendToolCall(
+      toolPart,
+      { id: "", timestampMs, agent: "codex", model: activeModel },
+      { markModeAsTool: true }
     );
-    const newIndex = messages.length - 1;
-    if (callId) {
-      pendingToolCalls.set(callId, [newIndex, 0]);
-    }
-    return { currentAssistantIndex: newIndex, latestAssistantTextIndex: null, pendingPlan: null };
   }
   // ---- Function call output ----
-  convertFunctionCallOutput(payload, messages, pendingToolCalls, timestampMs) {
+  convertToolCallOutput(payload, transcript, timestampMs) {
     const callId = String(payload["call_id"] ?? "").trim();
     if (!callId) return;
-    const location = pendingToolCalls.get(callId);
-    if (!location) return;
     const outputText = cleanInternalText(String(payload["output"] ?? ""));
     const outputParts = outputText ? [{ type: "text", text: outputText, time_created: timestampMs }] : [];
-    const [msgIndex, partIndex] = location;
-    const state = messages[msgIndex].parts[partIndex].state ?? (messages[msgIndex].parts[partIndex].state = {});
     if (outputParts.length > 0) {
-      state.output = [...outputParts];
-      state.status = "completed";
+      transcript.resolveToolCall(callId, { output: outputParts, status: "completed" });
     }
   }
   // ---- Custom tool call ----
-  convertCustomToolCall(payload, messages, pendingToolCalls, timestampMs, currentAssistantIndex, latestAssistantTextIndex) {
+  convertCustomToolCall(payload, transcript, timestampMs, activeModel) {
     const callId = String(payload["call_id"] ?? "").trim();
     const name = String(payload["name"] ?? "").trim();
-    if (!name) {
-      return { currentAssistantIndex, latestAssistantTextIndex, pendingPlan: null };
-    }
+    if (!name) return;
     const toolIdentity = resolveToolIdentity(name, payload["namespace"]);
     const rawInput = payload["input"];
     const normalizedInput = normalizeCustomToolArguments(name, rawInput);
@@ -3791,70 +3463,87 @@ var CodexAgent = class extends FileSystemSessionSource {
       },
       time_created: timestampMs
     };
-    const targetIndex = latestAssistantTextIndex ?? currentAssistantIndex;
-    if (targetIndex !== null) {
-      const message = messages[targetIndex];
-      const partIndex = message.parts.length;
-      message.parts.push(toolPart);
-      message.mode = "tool";
-      if (callId) {
-        pendingToolCalls.set(callId, [targetIndex, partIndex]);
-      }
-      return {
-        currentAssistantIndex: targetIndex,
-        latestAssistantTextIndex: targetIndex,
-        pendingPlan: null
-      };
-    }
-    messages.push(
-      this.buildMessage({
-        messageId: "",
-        role: "assistant",
-        timestampMs,
-        parts: [toolPart],
-        agent: "codex",
-        mode: "tool"
-      })
+    transcript.appendToolCall(
+      toolPart,
+      { id: "", timestampMs, agent: "codex", model: activeModel },
+      { markModeAsTool: true }
     );
-    const newIndex = messages.length - 1;
-    if (callId) {
-      pendingToolCalls.set(callId, [newIndex, 0]);
+  }
+};
+var PerfTracer = class {
+  rootMarkers = [];
+  activeStack = [];
+  enabled = false;
+  enable() {
+    this.enabled = true;
+  }
+  start(name) {
+    const marker = {
+      name,
+      startTime: performance.now(),
+      children: []
+    };
+    if (!this.enabled) return marker;
+    const parent = this.activeStack[this.activeStack.length - 1];
+    if (parent) {
+      marker.parent = parent;
+      parent.children.push(marker);
+    } else {
+      this.rootMarkers.push(marker);
     }
-    return { currentAssistantIndex: newIndex, latestAssistantTextIndex: null, pendingPlan: null };
+    this.activeStack.push(marker);
+    return marker;
   }
-  // ---- Custom tool call output ----
-  convertCustomToolCallOutput(payload, messages, pendingToolCalls, timestampMs) {
-    const callId = String(payload["call_id"] ?? "").trim();
-    if (!callId) return;
-    const location = pendingToolCalls.get(callId);
-    if (!location) return;
-    const outputText = cleanInternalText(String(payload["output"] ?? ""));
-    const outputParts = outputText ? [{ type: "text", text: outputText, time_created: timestampMs }] : [];
-    const [msgIndex, partIndex] = location;
-    const state = messages[msgIndex].parts[partIndex].state ?? (messages[msgIndex].parts[partIndex].state = {});
-    if (outputParts.length > 0) {
-      state.output = [...outputParts];
-      state.status = "completed";
+  end(marker) {
+    if (!this.enabled) return;
+    const target = marker ?? this.activeStack[this.activeStack.length - 1];
+    if (!target) return;
+    target.endTime = performance.now();
+    target.duration = target.endTime - target.startTime;
+    while (this.activeStack.length > 0) {
+      const popped = this.activeStack.pop();
+      if (popped === target) break;
     }
   }
-  // ---- Message builder ----
-  buildMessage(opts) {
-    return {
-      id: opts.messageId,
-      role: opts.role,
-      agent: opts.agent ?? null,
-      time_created: opts.timestampMs,
-      mode: opts.mode ?? null,
-      model: opts.model ?? null,
-      provider: opts.provider ?? null,
-      tokens: opts.tokens ? opts.tokens : void 0,
-      cost: opts.cost ?? 0,
-      parts: opts.parts,
-      subagent_id: opts.subagent_id,
-      nickname: opts.nickname
-    };
+  measure(name, fn) {
+    const marker = this.start(name);
+    try {
+      return fn();
+    } finally {
+      this.end(marker);
+    }
+  }
+  async measureAsync(name, fn) {
+    const marker = this.start(name);
+    try {
+      return await fn();
+    } finally {
+      this.end(marker);
+    }
+  }
+  getReport() {
+    if (!this.enabled) return "Performance tracing disabled";
+    const lines = [];
+    lines.push("\n=== Performance Report ===\n");
+    for (const marker of this.rootMarkers) {
+      this.formatMarker(marker, 0, lines);
+    }
+    return lines.join("\n");
+  }
+  formatMarker(marker, depth, lines) {
+    const indent = "  ".repeat(depth);
+    const duration = marker.duration?.toFixed(2) ?? "?";
+    lines.push(`${indent}${marker.name}: ${duration}ms`);
+    for (const child of marker.children) {
+      this.formatMarker(child, depth + 1, lines);
+    }
+  }
+  reset() {
+    this.rootMarkers = [];
+    this.activeStack = [];
   }
 };
+var perf = new PerfTracer();
 var CURSOR_TOOL_TITLE_MAP = {
   read_file_v2: "read",
   edit_file_v2: "edit",
@@ -4008,7 +3697,7 @@ var CursorAgent = class extends DatabaseSessionSource {
       if (!existsSync8(wsJsonPath)) continue;
       let workspacePath;
       try {
-        const data = JSON.parse(readFileSync6(wsJsonPath, "utf-8"));
+        const data = JSON.parse(readFileSync5(wsJsonPath, "utf-8"));
         const uri = data.folder ?? data.workspace ?? "";
         if (!uri) continue;
         workspacePath = normalize(decodeURIComponent(uri.replace(/^file:\/\//, "")));
@@ -4022,12 +3711,12 @@ var CursorAgent = class extends DatabaseSessionSource {
       try {
         const row = wsDb.prepare("SELECT value FROM ItemTable WHERE key = 'composer.composerData'").get();
         if (!row?.value) continue;
-        const parsed2 = JSON.parse(row.value);
+        const parsed = JSON.parse(row.value);
         let composers;
-        if (parsed2 !== null && typeof parsed2 === "object" && "allComposers" in parsed2 && Array.isArray(parsed2["allComposers"])) {
-          composers = parsed2.allComposers;
-        } else if (Array.isArray(parsed2)) {
-          composers = parsed2;
+        if (parsed !== null && typeof parsed === "object" && "allComposers" in parsed && Array.isArray(parsed["allComposers"])) {
+          composers = parsed.allComposers;
+        } else if (Array.isArray(parsed)) {
+          composers = parsed;
         } else {
           continue;
         }
@@ -4406,10 +4095,10 @@ var CursorAgent = class extends DatabaseSessionSource {
     if (toolData.result !== void 0) {
       if (typeof toolData.result === "string") {
         try {
-          const parsed2 = JSON.parse(toolData.result);
-          state.output = parsed2;
-          if (parsed2.error || parsed2.message || parsed2.stderr) {
-            state.error = parsed2.error || parsed2.message || parsed2.stderr;
+          const parsed = JSON.parse(toolData.result);
+          state.output = parsed;
+          if (parsed.error || parsed.message || parsed.stderr) {
+            state.error = parsed.error || parsed.message || parsed.stderr;
             state.status = "error";
           }
         } catch {
@@ -4531,20 +4220,6 @@ function normalizeTextParts(content, timestampMs) {
   const text = cleanInternalText(contentToText(content));
   return text ? [{ type: "text", text, time_created: timestampMs }] : [];
 }
-function buildMessage(params) {
-  return {
-    id: params.id,
-    role: params.role,
-    agent: params.agent,
-    time_created: params.timestampMs,
-    provider: params.provider,
-    model: params.model,
-    tokens: params.tokens,
-    cost: params.cost,
-    cost_source: params.costSource,
-    parts: params.parts
-  };
-}
 function getEntryTimestamp(entry) {
   return parseTimestampMs3(entry["timestamp"]);
 }
@@ -4588,29 +4263,6 @@ var PiAgent = class extends FileSystemSessionSource {
     if (!this.basePath) return false;
     return this.listSessionFiles().length > 0;
   }
-  scan(options) {
-    if (!this.basePath) return [];
-    const scanMarker = perf.start("pi:scan");
-    const files = this.listSessionFiles(options);
-    options?.onProgress?.({ total: files.length, processed: 0, sessions: 0 });
-    const heads = [];
-    let processed = 0;
-    for (const file of files) {
-      try {
-        const head = getParsedSession(this.parseSessionHeadResult(file));
-        if (head) {
-          heads.push(head);
-          this.sessionMetaMap.set(head.id, this.buildSessionMeta(head, file));
-        }
-      } catch {
-      } finally {
-        processed += 1;
-        options?.onProgress?.({ total: files.length, processed, sessions: heads.length });
-      }
-    }
-    perf.end(scanMarker);
-    return heads;
-  }
   listSessionSources(options) {
     if (!this.basePath) return [];
     return this.listSessionFiles(options).map((file) => ({
@@ -4630,9 +4282,8 @@ var PiAgent = class extends FileSystemSessionSource {
     const meta = this.sessionMetaMap.get(sessionId);
     if (!meta) throw new Error(`Session not found: ${sessionId}`);
     if (!existsSync9(meta.sourcePath)) throw new Error(`Session file missing: ${meta.sourcePath}`);
-    const parsed2 = this.parsePiFile(meta.sourcePath);
-    const state = this.convertEntries(parsed2.pathEntries);
-    const cleanedMessages = cleanParsedMessages(state.messages);
+    const parsed = this.parsePiFile(meta.sourcePath);
+    const state = this.convertEntries(parsed.pathEntries);
     return {
       id: meta.id,
       title: meta.title,
@@ -4641,7 +4292,7 @@ var PiAgent = class extends FileSystemSessionSource {
       time_created: meta.createdAt,
       time_updated: meta.updatedAt,
       stats: {
-        message_count: cleanedMessages.length,
+        message_count: state.messages.length,
         total_input_tokens: state.totalInputTokens,
         total_output_tokens: state.totalOutputTokens,
         total_cache_read_tokens: state.totalCacheReadTokens || void 0,
@@ -4649,7 +4300,7 @@ var PiAgent = class extends FileSystemSessionSource {
         total_cost: state.totalCost,
         cost_source: state.totalCost > 0 ? "recorded" : void 0
       },
-      messages: cleanedMessages
+      messages: state.messages
     };
   }
   listSessionFiles(options) {
@@ -4693,18 +4344,18 @@ var PiAgent = class extends FileSystemSessionSource {
     return JSON.stringify([HEAD_INDEX_VERSION3, PARSER_VERSION2, stat.mtimeMs, stat.size]);
   }
   parseSessionHeadResult(filePath) {
-    const parsed2 = this.parsePiFile(filePath);
-    const state = this.convertEntries(parsed2.pathEntries);
+    const parsed = this.parsePiFile(filePath);
+    const state = this.convertEntries(parsed.pathEntries);
     const messageCount = state.messages.length;
     if (messageCount === 0) return filteredSession("no visible messages");
     const modelUsage = Object.keys(state.modelUsage).length > 0 ? state.modelUsage : void 0;
     return parsedSession({
-      id: parsed2.sessionId,
-      slug: `pi/${parsed2.sessionId}`,
-      title: parsed2.title,
-      directory: parsed2.directory,
-      time_created: parsed2.createdAt,
-      time_updated: parsed2.updatedAt,
+      id: parsed.sessionId,
+      slug: `pi/${parsed.sessionId}`,
+      title: parsed.title,
+      directory: parsed.directory,
+      time_created: parsed.createdAt,
+      time_updated: parsed.updatedAt,
       stats: {
         message_count: messageCount,
         total_input_tokens: state.totalInputTokens,
@@ -4718,7 +4369,7 @@ var PiAgent = class extends FileSystemSessionSource {
     });
   }
   parsePiFile(filePath) {
-    const records = Array.from(parseJsonlLines(readFileSync7(filePath, "utf-8")));
+    const records = Array.from(parseJsonlLines(readFileSync6(filePath, "utf-8")));
     if (records.length === 0) throw new Error("empty file");
     const header = records.find((record) => record["type"] === "session");
     if (!header) throw new Error("missing session header");
@@ -4766,74 +4417,52 @@ var PiAgent = class extends FileSystemSessionSource {
     return null;
   }
   convertEntries(entries) {
-    const messages = [];
-    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const builder = new TranscriptBuilder({ messageDefaults: "sparse" });
     const modelUsage = {};
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCacheReadTokens = 0;
-    let totalCacheCreateTokens = 0;
-    let totalCost = 0;
     for (const entry of entries) {
       const timestampMs = getEntryTimestamp(entry);
       const type = String(entry["type"] ?? "");
       if (type === "message") {
         const message = entry["message"];
         if (!isObject(message)) continue;
-        const result = this.convertAgentMessage(
-          entry,
-          message,
-          timestampMs,
-          pendingToolCalls,
-          messages.length,
-          messages
-        );
-        if (!result) continue;
-        if (result.message) messages.push(result.message);
-        totalInputTokens += result.inputTokens;
-        totalOutputTokens += result.outputTokens;
-        totalCacheReadTokens += result.cacheReadTokens;
-        totalCacheCreateTokens += result.cacheCreateTokens;
-        totalCost += result.cost;
-        if (result.model && result.totalTokens > 0) {
-          modelUsage[result.model] = (modelUsage[result.model] ?? 0) + result.totalTokens;
+        const result2 = this.convertAgentMessage(entry, message, timestampMs, builder);
+        if (!result2) continue;
+        if (result2.message) builder.appendMessage(result2.message);
+        if (result2.model && result2.totalTokens > 0) {
+          modelUsage[result2.model] = (modelUsage[result2.model] ?? 0) + result2.totalTokens;
         }
         continue;
       }
       const summary = this.convertSummaryEntry(entry, timestampMs);
-      if (summary) messages.push(summary);
+      if (summary) builder.appendMessage(summary);
     }
+    const result = builder.finish();
     return {
-      messages,
-      totalInputTokens,
-      totalOutputTokens,
-      totalCacheReadTokens,
-      totalCacheCreateTokens,
-      totalCost,
+      messages: result.messages,
+      totalInputTokens: result.stats.total_input_tokens,
+      totalOutputTokens: result.stats.total_output_tokens,
+      totalCacheReadTokens: result.stats.total_cache_read_tokens ?? 0,
+      totalCacheCreateTokens: result.stats.total_cache_create_tokens ?? 0,
+      totalCost: result.stats.total_cost,
       modelUsage
     };
   }
-  convertAgentMessage(entry, message, timestampMs, pendingToolCalls, nextMessageIndex, messages) {
+  convertAgentMessage(entry, message, timestampMs, builder) {
     const id = String(entry["id"] ?? "");
     const role = String(message["role"] ?? "");
     if (role === "user") {
       const parts = normalizeTextParts(message["content"], timestampMs);
       if (parts.length === 0) return null;
-      return this.emptyUsageResult(buildMessage({ id, role: "user", timestampMs, parts }));
+      return this.emptyUsageResult({ id, role: "user", timestampMs, parts });
     }
     if (role === "assistant") {
-      const parts = this.normalizeAssistantParts(
-        message["content"],
-        timestampMs,
-        pendingToolCalls,
-        nextMessageIndex
-      );
+      const parts = this.normalizeAssistantParts(message["content"], timestampMs);
       if (parts.length === 0) return null;
       const usage = this.normalizeUsage(message["usage"]);
       const model = typeof message["model"] === "string" ? message["model"].trim() : null;
       const cost = usage.cost ?? estimateTokenCost(model, usage.tokens) ?? 0;
       return {
-        message: buildMessage({
+        message: {
           id,
           role: "assistant",
           agent: "pi",
@@ -4844,18 +4473,13 @@ var PiAgent = class extends FileSystemSessionSource {
           tokens: usage.tokens,
           cost: cost || void 0,
           costSource: cost > 0 ? "recorded" : void 0
-        }),
-        inputTokens: usage.inputTokens,
-        outputTokens: usage.outputTokens,
-        cacheReadTokens: usage.cacheReadTokens,
-        cacheCreateTokens: usage.cacheCreateTokens,
+        },
         totalTokens: usage.totalTokens,
-        cost,
         model
       };
     }
     if (role === "toolResult") {
-      this.attachToolResult(message, timestampMs, pendingToolCalls, messages);
+      this.attachToolResult(message, timestampMs, builder);
       return this.emptyUsageResult();
     }
     if (role === "bashExecution") {
@@ -4864,24 +4488,22 @@ var PiAgent = class extends FileSystemSessionSource {
     if (role === "custom" && message["display"] === true) {
       const parts = normalizeTextParts(message["content"], timestampMs);
       if (parts.length === 0) return null;
-      return this.emptyUsageResult(buildMessage({ id, role: "user", timestampMs, parts }));
+      return this.emptyUsageResult({ id, role: "user", timestampMs, parts });
     }
     if (role === "branchSummary" || role === "compactionSummary") {
       const summary = String(message["summary"] ?? "").trim();
       if (!summary) return null;
-      return this.emptyUsageResult(
-        buildMessage({
-          id,
-          role: "assistant",
-          agent: "pi",
-          timestampMs,
-          parts: [{ type: "text", text: summary, time_created: timestampMs }]
-        })
-      );
+      return this.emptyUsageResult({
+        id,
+        role: "assistant",
+        agent: "pi",
+        timestampMs,
+        parts: [{ type: "text", text: summary, time_created: timestampMs }]
+      });
     }
     return null;
   }
-  normalizeAssistantParts(content, timestampMs, pendingToolCalls, messageIndex) {
+  normalizeAssistantParts(content, timestampMs) {
     if (!Array.isArray(content)) return [];
     const parts = [];
     for (const item of content) {
@@ -4912,29 +4534,26 @@ var PiAgent = class extends FileSystemSessionSource {
           }
         };
         parts.push(toolPart);
-        if (callId) pendingToolCalls.set(callId, [messageIndex, parts.length - 1]);
       }
     }
     return parts;
   }
-  attachToolResult(message, timestampMs, pendingToolCalls, messages) {
+  attachToolResult(message, timestampMs, builder) {
     const callId = String(message["toolCallId"] ?? "").trim();
     const output = normalizeTextParts(message["content"], timestampMs);
-    const location = callId ? pendingToolCalls.get(callId) : void 0;
-    if (!location) return;
-    const [messageIndex, partIndex] = location;
-    const target = messages[messageIndex]?.parts[partIndex];
-    if (!target?.state) return;
-    target.state.output = output;
-    target.state.status = message["isError"] === true ? "error" : "completed";
-    target.state.metadata = message["details"];
-    pendingToolCalls.delete(callId);
+    if (!callId) return;
+    builder.resolveToolCall(callId, {
+      output,
+      status: message["isError"] === true ? "error" : "completed",
+      metadata: message["details"],
+      consume: true
+    });
   }
   convertBashExecution(id, message, timestampMs) {
     const command = String(message["command"] ?? "");
     const output = String(message["output"] ?? "");
     const isError = Number(message["exitCode"] ?? 0) !== 0 || message["cancelled"] === true;
-    return buildMessage({
+    return {
       id,
       role: "tool",
       timestampMs,
@@ -4957,7 +4576,7 @@ var PiAgent = class extends FileSystemSessionSource {
           }
         }
       ]
-    });
+    };
   }
   convertSummaryEntry(entry, timestampMs) {
     const type = entry["type"];
@@ -4968,13 +4587,13 @@ var PiAgent = class extends FileSystemSessionSource {
     const rawText = type === "custom_message" ? contentToText(entry["content"]) : String(entry["summary"] ?? "");
     const text = cleanInternalText(rawText);
     if (!text) return null;
-    return buildMessage({
+    return {
       id: String(entry["id"] ?? ""),
       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 = isObject(raw) ? raw : {};
@@ -5004,12 +4623,7 @@ var PiAgent = class extends FileSystemSessionSource {
   emptyUsageResult(message) {
     return {
       message,
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheReadTokens: 0,
-      cacheCreateTokens: 0,
       totalTokens: 0,
-      cost: 0,
       model: null
     };
   }
@@ -5030,44 +4644,30 @@ var ZCodeAgent = class extends OpenCodeSqliteAgent {
   }
 };
 registerAgent({
-  name: "claudecode",
-  displayName: "Claude Code",
   icon: "/icon/agent/claudecode.svg",
   create: () => new ClaudeCodeAgent()
 });
 registerAgent({
-  name: "opencode",
-  displayName: "OpenCode",
   icon: "/icon/agent/opencode.svg",
   create: () => new OpenCodeAgent()
 });
 registerAgent({
-  name: "zcode",
-  displayName: "ZCode",
   icon: "/icon/agent/zcode.svg",
   create: () => new ZCodeAgent()
 });
 registerAgent({
-  name: "kimi",
-  displayName: "Kimi-Cli",
   icon: "/icon/agent/kimi.svg",
   create: () => new KimiAgent()
 });
 registerAgent({
-  name: "codex",
-  displayName: "Codex",
   icon: "/icon/agent/codex.svg",
   create: () => new CodexAgent()
 });
 registerAgent({
-  name: "pi",
-  displayName: "Pi",
   icon: "/icon/agent/pi.svg",
   create: () => new PiAgent()
 });
 registerAgent({
-  name: "cursor",
-  displayName: "Cursor",
   icon: "/icon/agent/cursor.svg",
   create: () => new CursorAgent()
 });
@@ -5083,7 +4683,7 @@ var realFs = {
   },
   readText(path2) {
     try {
-      return readFileSync8(path2, "utf8");
+      return readFileSync7(path2, "utf8");
     } catch {
       return null;
     }
@@ -5096,43 +4696,6 @@ var realFs = {
     };
   }
 };
-function getAgentName(session) {
-  return session.slug.split("/")[0]?.toLowerCase() || "unknown";
-}
-function buildProjectGroups(sessions) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const session of sessions) {
-    const identity = session.project_identity;
-    if (!identity) continue;
-    const activity = session.time_updated ?? session.time_created;
-    const groupKey = `${identity.kind}:${identity.key}`;
-    const current = groups.get(groupKey);
-    if (current) {
-      current.sources.add(getAgentName(session));
-      current.sessionCount += 1;
-      current.lastActivity = Math.max(current.lastActivity, activity);
-    } else {
-      groups.set(groupKey, {
-        identity,
-        sources: /* @__PURE__ */ new Set([getAgentName(session)]),
-        sessionCount: 1,
-        lastActivity: activity
-      });
-    }
-  }
-  return [...groups.values()].map((group) => ({
-    identityKind: group.identity.kind,
-    identityKey: group.identity.key,
-    displayName: group.identity.displayName,
-    sources: [...group.sources].sort(),
-    sessionCount: group.sessionCount,
-    lastActivity: group.lastActivity || null
-  })).sort((a, b) => {
-    if (a.identityKind === "loose" && b.identityKind !== "loose") return 1;
-    if (b.identityKind === "loose" && a.identityKind !== "loose") return -1;
-    return (b.lastActivity ?? 0) - (a.lastActivity ?? 0);
-  });
-}
 var MANIFESTS = [
   "package.json",
   "Cargo.toml",
@@ -5145,6 +4708,23 @@ var MANIFESTS = [
 var PARSEABLE_MANIFESTS = ["package.json", "Cargo.toml", "pyproject.toml"];
 var LOOSE_DIRS = /* @__PURE__ */ new Set(["/tmp", "/private/tmp"]);
 var LOOSE_HOME_DIRS = ["Desktop", "Downloads", "Documents"];
+var PROJECT_IDENTITY_KINDS = /* @__PURE__ */ new Set([
+  "git_remote",
+  "git_common_dir",
+  "manifest_path",
+  "synthetic",
+  "path",
+  "loose"
+]);
+function isProjectIdentityKind(value) {
+  return PROJECT_IDENTITY_KINDS.has(value);
+}
+function getProjectIdentityKey(identity) {
+  return `${identity.kind}:${identity.key}`;
+}
+function matchesProjectIdentity(identity, expected) {
+  return identity?.kind === expected.kind && identity.key === expected.key;
+}
 function normalizeGitRemote(url) {
   if (!url) return null;
   let value = url.trim().replace(/\.git$/, "");
@@ -5275,15 +4855,53 @@ function parseManifestName(file, text) {
   }
   return null;
 }
+function getAgentName(session) {
+  return session.slug.split("/")[0]?.toLowerCase() || "unknown";
+}
+function buildProjectGroups(sessions) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const identity = session.project_identity;
+    if (!identity) continue;
+    const activity = session.time_updated ?? session.time_created;
+    const groupKey = getProjectIdentityKey(identity);
+    const current = groups.get(groupKey);
+    if (current) {
+      current.sources.add(getAgentName(session));
+      current.sessionCount += 1;
+      current.lastActivity = Math.max(current.lastActivity, activity);
+    } else {
+      groups.set(groupKey, {
+        identity,
+        sources: /* @__PURE__ */ new Set([getAgentName(session)]),
+        sessionCount: 1,
+        lastActivity: activity
+      });
+    }
+  }
+  return [...groups.values()].map((group) => ({
+    identityKind: group.identity.kind,
+    identityKey: group.identity.key,
+    displayName: group.identity.displayName,
+    sources: [...group.sources].sort(),
+    sessionCount: group.sessionCount,
+    lastActivity: group.lastActivity || null
+  })).sort((a, b) => {
+    if (a.identityKind === "loose" && b.identityKind !== "loose") return 1;
+    if (b.identityKind === "loose" && a.identityKind !== "loose") return -1;
+    return (b.lastActivity ?? 0) - (a.lastActivity ?? 0);
+  });
+}
 function createProjectScopeMatcher(queryPath, fs = realFs) {
+  const identity = computeIdentity(queryPath, fs);
   return {
-    identityKey: computeIdentity(queryPath, fs).key,
+    identity: { kind: identity.kind, key: identity.key },
     path: normalizeScopePath(queryPath)
   };
 }
 function matchesProjectScope(session, scope) {
   if (!session.directory) return false;
-  if (session.project_identity?.key === scope.identityKey) return true;
+  if (matchesProjectIdentity(session.project_identity, scope.identity)) return true;
   return isPathScopeMatch(scope.path, session.directory);
 }
 function filterSessionsByProjectScope(sessions, queryPath, fs) {
@@ -6039,7 +5657,7 @@ function buildSessionContentFromMessages(title, messages) {
   }
   return chunks.join("\n");
 }
-var CACHE_SCHEMA_VERSION = 13;
+var CACHE_SCHEMA_VERSION = 14;
 function withCacheDb(fn) {
   const cachePath = getCachePath2();
   const db = openDb(cachePath);
@@ -6312,6 +5930,7 @@ function createSearchTables(db) {
       activity_time INTEGER NOT NULL,
       content_text TEXT NOT NULL,
       content_hash TEXT NOT NULL,
+      indexed_message_count INTEGER NOT NULL,
       indexed_at INTEGER NOT NULL,
       UNIQUE(agent_name, session_id)
     );
@@ -6345,6 +5964,24 @@ function createSearchTriggers(db) {
     END;
   `);
 }
+function addIndexedMessageCount(db) {
+  if (!tableExists(db, "session_documents")) return;
+  if (!columnExists(db, "session_documents", "indexed_message_count")) {
+    db.exec(
+      "ALTER TABLE session_documents ADD COLUMN indexed_message_count INTEGER NOT NULL DEFAULT 0"
+    );
+  }
+  if (!tableExists(db, "messages")) return;
+  db.exec(`
+    UPDATE session_documents
+    SET indexed_message_count = (
+      SELECT COUNT(*)
+      FROM messages
+      WHERE messages.agent_name = session_documents.agent_name
+        AND messages.session_id = session_documents.session_id
+    )
+  `);
+}
 function dropSearchTriggers(db) {
   db.exec(`
     DROP TRIGGER IF EXISTS session_documents_ai;
@@ -6450,6 +6087,9 @@ function readLegacyCacheVersion(db) {
   return Number(versionRow?.value ?? 0);
 }
 function inferCacheSchemaVersion(db) {
+  if (columnExists(db, "session_documents", "indexed_message_count")) {
+    return 14;
+  }
   if (tableExists(db, "message_tools")) {
     return 11;
   }
@@ -6882,39 +6522,16 @@ function ensureSchema(db, dbPath) {
         version: 12,
         migrate(db2) {
           refreshProjectIdentities(db2);
-        }
-      },
-      { version: 13, migrate: createCacheTables }
-    ]
-  });
-  createLatestCacheSchema(db);
-  if (getUserVersion(db) <= CACHE_SCHEMA_VERSION) {
-    setCacheSchemaVersion(db);
-  }
-}
-function shouldBulkSyncSearchIndex(options, changedCount) {
-  if (options.isBulk != null) {
-    return options.isBulk;
-  }
-  const threshold = options.bulkThreshold ?? SEARCH_INDEX_BULK_SYNC_THRESHOLD;
-  return threshold > 0 && changedCount >= threshold;
-}
-function sessionContentHash(session) {
-  return JSON.stringify([
-    session.slug,
-    session.title,
-    session.directory,
-    session.time_created,
-    session.time_updated ?? session.time_created,
-    session.stats.message_count,
-    session.stats.total_input_tokens,
-    session.stats.total_output_tokens,
-    session.stats.total_cache_read_tokens ?? 0,
-    session.stats.total_cache_create_tokens ?? 0,
-    session.stats.total_cost,
-    session.stats.cost_source ?? "",
-    session.stats.total_tokens ?? 0
-  ]);
+        }
+      },
+      { version: 13, migrate: createCacheTables },
+      { version: 14, migrate: addIndexedMessageCount }
+    ]
+  });
+  createLatestCacheSchema(db);
+  if (getUserVersion(db) <= CACHE_SCHEMA_VERSION) {
+    setCacheSchemaVersion(db);
+  }
 }
 function escapeFtsTerm(value) {
   return value.replaceAll('"', '""');
@@ -6938,9 +6555,7 @@ function splitSearchTokens(input) {
     }
     token += char;
   }
-  if (token) {
-    tokens.push(token);
-  }
+  if (token) tokens.push(token);
   return tokens;
 }
 function unwrapSearchValue(value) {
@@ -7000,7 +6615,10 @@ function parseSearchQuery(input) {
     if (key === "agent") filters.agent = value.toLowerCase();
     else if (key === "project") filters.project = value;
     else if (key === "projectkey" || key === "project-key") filters.projectKey = value;
-    else if (key === "cwd") filters.cwd = value;
+    else if (key === "projectkind" || key === "project-kind") {
+      if (isProjectIdentityKind(value)) filters.projectKind = value;
+      else consumed = false;
+    } else if (key === "cwd") filters.cwd = value;
     else if (key === "tool") filters.tools = appendUnique(filters.tools, value.toLowerCase());
     else if (key === "file" || key === "path") filters.file = value;
     else if (key === "kind" || key === "filekind" || key === "file-kind") {
@@ -7011,21 +6629,15 @@ function parseSearchQuery(input) {
       }
     } else if (key === "tag" || key === "signal") {
       const tag = value.toLowerCase();
-      if (isSmartTag(tag)) {
-        filters.tags = appendUnique(filters.tags, tag);
-      } else {
-        consumed = false;
-      }
+      if (isSmartTag(tag)) filters.tags = appendUnique(filters.tags, tag);
+      else consumed = false;
     } else if (key === "cost") {
       parseCostQualifier(value, filters);
     } else {
       consumed = false;
     }
-    if (consumed) {
-      hasQualifiers = true;
-    } else {
-      textTokens.push(token);
-    }
+    if (consumed) hasQualifiers = true;
+    else textTokens.push(token);
   }
   return {
     text: textTokens.join(" ").trim(),
@@ -7035,18 +6647,86 @@ function parseSearchQuery(input) {
 }
 function toFtsQuery(input) {
   const tokens = splitSearchTokens(input);
-  const mapped = tokens.map((token) => {
-    if (/^OR$/i.test(token)) {
-      return "OR";
-    }
+  return tokens.map((token) => {
+    if (/^OR$/i.test(token)) return "OR";
     if (token.startsWith('"') && token.endsWith('"')) {
       return `"${escapeFtsTerm(token.slice(1, -1))}"`;
     }
     return `"${escapeFtsTerm(token)}"`;
   }).filter(
     (token, index, values) => token !== "OR" || index > 0 && index < values.length - 1 && values[index - 1] !== "OR" && values[index + 1] !== "OR"
-  );
-  return mapped.join(" ");
+  ).join(" ");
+}
+var SEARCH_INDEX_STATE_BATCH_SIZE = 900;
+function shouldBulkSyncSearchIndex(options, changedCount) {
+  if (options.isBulk != null) {
+    return options.isBulk;
+  }
+  const threshold = options.bulkThreshold ?? SEARCH_INDEX_BULK_SYNC_THRESHOLD;
+  return threshold > 0 && changedCount >= threshold;
+}
+function sessionContentHash(session) {
+  return JSON.stringify([
+    session.slug,
+    session.title,
+    session.directory,
+    session.time_created,
+    session.time_updated ?? session.time_created,
+    session.stats.message_count,
+    session.stats.total_input_tokens,
+    session.stats.total_output_tokens,
+    session.stats.total_cache_read_tokens ?? 0,
+    session.stats.total_cache_create_tokens ?? 0,
+    session.stats.total_cost,
+    session.stats.cost_source ?? "",
+    session.stats.total_tokens ?? 0
+  ]);
+}
+function searchIndexStateFromRows(indexedRows, messageCountRows) {
+  return {
+    contentHashBySessionId: new Map(
+      indexedRows.map((row) => [String(row.session_id), String(row.content_hash ?? "")])
+    ),
+    indexedMessageCountBySessionId: new Map(
+      indexedRows.map((row) => [String(row.session_id), Number(row.indexed_message_count ?? 0)])
+    ),
+    messageCountBySessionId: new Map(
+      messageCountRows.map((row) => [String(row.session_id), Number(row.value ?? 0)])
+    )
+  };
+}
+function readSearchIndexState(db, agentName, sessionIds) {
+  const rows = [];
+  const uniqueSessionIds = [...new Set(sessionIds)];
+  for (let offset = 0; offset < uniqueSessionIds.length; offset += SEARCH_INDEX_STATE_BATCH_SIZE) {
+    const batch = uniqueSessionIds.slice(offset, offset + SEARCH_INDEX_STATE_BATCH_SIZE);
+    const requestedRows = batch.map(() => "(?)").join(", ");
+    const batchRows = db.prepare(
+      `
+          WITH requested_session_ids(session_id) AS (VALUES ${requestedRows})
+          SELECT
+            requested.session_id,
+            documents.content_hash,
+            documents.indexed_message_count,
+            COUNT(messages.message_index) AS value
+          FROM requested_session_ids AS requested
+          LEFT JOIN session_documents AS documents
+            ON documents.agent_name = ? AND documents.session_id = requested.session_id
+          LEFT JOIN messages
+            ON messages.agent_name = ? AND messages.session_id = requested.session_id
+          GROUP BY
+            requested.session_id,
+            documents.content_hash,
+            documents.indexed_message_count
+        `
+    ).all(...batch, agentName, agentName);
+    rows.push(...batchRows);
+  }
+  return searchIndexStateFromRows(rows, rows);
+}
+function searchIndexEntryNeedsUpdate(state, session) {
+  const sessionId = session.id;
+  return state.contentHashBySessionId.get(sessionId) !== sessionContentHash(session) || state.indexedMessageCountBySessionId.get(sessionId) !== (state.messageCountBySessionId.get(sessionId) ?? 0);
 }
 function loadSearchIndexEntry(agentName, change, loadSessionData) {
   try {
@@ -7071,6 +6751,12 @@ function loadSearchIndexEntry(agentName, change, loadSessionData) {
     return null;
   }
 }
+function* loadSearchIndexEntries(agentName, changes, loadSessionData) {
+  for (const change of changes) {
+    const entry = loadSearchIndexEntry(agentName, change, loadSessionData);
+    if (entry) yield entry;
+  }
+}
 function writeSearchIndexRows(db, agentName, removedSessionIds, entries) {
   const deleteRow = db.prepare(
     "DELETE FROM session_documents WHERE agent_name = ? AND session_id = ?"
@@ -7142,8 +6828,9 @@ function writeSearchIndexRows(db, agentName, removedSessionIds, entries) {
       activity_time,
       content_text,
       content_hash,
+      indexed_message_count,
       indexed_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(agent_name, session_id) DO UPDATE SET
       slug = excluded.slug,
       title = excluded.title,
@@ -7156,6 +6843,7 @@ function writeSearchIndexRows(db, agentName, removedSessionIds, entries) {
       activity_time = excluded.activity_time,
       content_text = excluded.content_text,
       content_hash = excluded.content_hash,
+      indexed_message_count = excluded.indexed_message_count,
       indexed_at = excluded.indexed_at
   `);
   for (const sessionId of new Set(removedSessionIds)) {
@@ -7164,6 +6852,7 @@ function writeSearchIndexRows(db, agentName, removedSessionIds, entries) {
     deleteMessageTools.run(agentName, sessionId, 0);
     deleteMessages.run(agentName, sessionId, 0);
   }
+  let indexed = 0;
   for (const entry of entries) {
     const activityTime = entry.session.time_updated ?? entry.session.time_created;
     upsertSessionRow(upsertIndexedSession, agentName, entry.session, null, entry.sortIndex, null);
@@ -7211,44 +6900,47 @@ function writeSearchIndexRows(db, agentName, removedSessionIds, entries) {
       activityTime,
       entry.contentText,
       entry.contentHash,
+      entry.messages.length,
       Date.now()
     );
+    indexed += 1;
   }
+  return indexed;
 }
 function syncSessionSearchIndex(agentName, sessions, loadSessionData, options = {}) {
   return withCacheDb((db) => {
     ensureFtsConsistency(db);
     const startedAt = performance.now();
     const existingRows = db.prepare(
-      "SELECT session_id, content_hash FROM session_documents WHERE agent_name = ? ORDER BY id"
+      "SELECT session_id, content_hash, indexed_message_count FROM session_documents WHERE agent_name = ? ORDER BY id"
     ).all(agentName);
-    const existingMap = new Map(
-      existingRows.map((row) => [String(row.session_id), String(row.content_hash ?? "")])
-    );
     const sessionSortIndexMap = new Map(sessions.map((session, index) => [session.id, index]));
     const messageCountRows = db.prepare(
       "SELECT session_id, COUNT(*) AS value FROM messages WHERE agent_name = ? GROUP BY session_id"
     ).all(agentName);
-    const messageCountMap = new Map(
-      messageCountRows.map((row) => [String(row.session_id), Number(row.value ?? 0)])
-    );
+    const searchIndexState = searchIndexStateFromRows(existingRows, messageCountRows);
     const sessionMap = new Map(sessions.map((session) => [session.id, session]));
     const toDelete = existingRows.map((row) => String(row.session_id)).filter((sessionId) => !sessionMap.has(sessionId));
     const toUpsert = sessions.filter(
-      (session) => existingMap.get(session.id) !== sessionContentHash(session) || messageCountMap.get(session.id) !== session.stats.message_count
+      (session) => searchIndexEntryNeedsUpdate(searchIndexState, session)
     );
     const changedCount = toDelete.length + toUpsert.length;
     const isBulk = shouldBulkSyncSearchIndex(options, changedCount);
-    const loaded = toUpsert.map(
-      (session) => loadSearchIndexEntry(
+    const changes = toUpsert.map((session) => ({
+      session,
+      sortIndex: sessionSortIndexMap.get(session.id) ?? 0
+    }));
+    let indexed = 0;
+    const writeRows = () => {
+      indexed = writeSearchIndexRows(
+        db,
         agentName,
-        { session, sortIndex: sessionSortIndexMap.get(session.id) ?? 0 },
-        loadSessionData
-      )
-    ).filter((entry) => entry !== null);
-    const writeRows = () => writeSearchIndexRows(db, agentName, toDelete, loaded);
+        toDelete,
+        loadSearchIndexEntries(agentName, changes, loadSessionData)
+      );
+    };
     let rebuildDurationMs;
-    const needsRebuild = isBulk && (toDelete.length > 0 || loaded.length > 0);
+    const needsRebuild = isBulk && changedCount > 0;
     if (needsRebuild) {
       db.transaction(() => {
         dropSearchTriggers(db);
@@ -7270,8 +6962,8 @@ function syncSessionSearchIndex(agentName, sessions, loadSessionData, options =
       sessions: sessions.length,
       changed: toUpsert.length,
       deleted: toDelete.length,
-      indexed: loaded.length,
-      skipped: toUpsert.length - loaded.length,
+      indexed,
+      skipped: toUpsert.length - indexed,
       durationMs: performance.now() - startedAt,
       rebuildDurationMs
     };
@@ -7293,24 +6985,28 @@ function syncSessionSearchIndexChanges(agentName, changes, removedSessionIds, lo
   return withCacheDb((db) => {
     ensureFtsConsistency(db);
     const startedAt = performance.now();
-    const getIndexedRow = db.prepare(
-      "SELECT content_hash FROM session_documents WHERE agent_name = ? AND session_id = ?"
+    const searchIndexState = readSearchIndexState(
+      db,
+      agentName,
+      changes.map(({ session }) => session.id)
     );
-    const getMessageCount = db.prepare(
-      "SELECT COUNT(*) AS value FROM messages WHERE agent_name = ? AND session_id = ?"
+    const toUpsert = changes.filter(
+      ({ session }) => searchIndexEntryNeedsUpdate(searchIndexState, session)
     );
-    const toUpsert = changes.filter(({ session }) => {
-      const indexed = getIndexedRow.get(agentName, session.id);
-      const messageCount = getMessageCount.get(agentName, session.id);
-      return String(indexed?.content_hash ?? "") !== sessionContentHash(session) || Number(messageCount?.value ?? 0) !== session.stats.message_count;
-    });
     const uniqueRemovedSessionIds = Array.from(new Set(removedSessionIds));
     const changedCount = uniqueRemovedSessionIds.length + toUpsert.length;
     const isBulk = shouldBulkSyncSearchIndex(options, changedCount);
-    const loaded = toUpsert.map((change) => loadSearchIndexEntry(agentName, change, loadSessionData)).filter((entry) => entry !== null);
-    const writeRows = () => writeSearchIndexRows(db, agentName, uniqueRemovedSessionIds, loaded);
+    let indexed = 0;
+    const writeRows = () => {
+      indexed = writeSearchIndexRows(
+        db,
+        agentName,
+        uniqueRemovedSessionIds,
+        loadSearchIndexEntries(agentName, toUpsert, loadSessionData)
+      );
+    };
     let rebuildDurationMs;
-    const needsRebuild = isBulk && (uniqueRemovedSessionIds.length > 0 || loaded.length > 0);
+    const needsRebuild = isBulk && changedCount > 0;
     if (needsRebuild) {
       db.transaction(() => {
         dropSearchTriggers(db);
@@ -7332,8 +7028,8 @@ function syncSessionSearchIndexChanges(agentName, changes, removedSessionIds, lo
       sessions: changes.length,
       changed: toUpsert.length,
       deleted: uniqueRemovedSessionIds.length,
-      indexed: loaded.length,
-      skipped: toUpsert.length - loaded.length,
+      indexed,
+      skipped: toUpsert.length - indexed,
       durationMs: performance.now() - startedAt,
       rebuildDurationMs
     };
@@ -7347,25 +7043,26 @@ function mergeSearchLists(left, right) {
   return values.length > 0 ? [...new Set(values)] : void 0;
 }
 function mergeSearchQueryOptions(query, options) {
-  const parsed2 = parseSearchQuery(query);
+  const parsed = parseSearchQuery(query);
   return {
-    text: parsed2.text || (parsed2.hasQualifiers ? "" : query.trim()),
+    text: parsed.text || (parsed.hasQualifiers ? "" : query.trim()),
     options: {
       ...options,
-      agent: options.agent ?? parsed2.filters.agent,
-      project: options.project ?? parsed2.filters.project,
-      projectKey: options.projectKey ?? parsed2.filters.projectKey,
-      cwd: options.cwd ?? parsed2.filters.cwd,
-      tags: mergeSearchLists(options.tags, parsed2.filters.tags),
-      tools: mergeSearchLists(options.tools, parsed2.filters.tools),
-      file: options.file ?? parsed2.filters.file,
-      fileKind: options.fileKind ?? parsed2.filters.fileKind,
-      costMin: options.costMin ?? parsed2.filters.costMin,
-      costMax: options.costMax ?? parsed2.filters.costMax,
-      costMinExclusive: options.costMinExclusive ?? parsed2.filters.costMinExclusive,
-      costMaxExclusive: options.costMaxExclusive ?? parsed2.filters.costMaxExclusive
+      agent: options.agent ?? parsed.filters.agent,
+      project: options.project ?? parsed.filters.project,
+      projectKind: options.projectKind ?? parsed.filters.projectKind,
+      projectKey: options.projectKey ?? parsed.filters.projectKey,
+      cwd: options.cwd ?? parsed.filters.cwd,
+      tags: mergeSearchLists(options.tags, parsed.filters.tags),
+      tools: mergeSearchLists(options.tools, parsed.filters.tools),
+      file: options.file ?? parsed.filters.file,
+      fileKind: options.fileKind ?? parsed.filters.fileKind,
+      costMin: options.costMin ?? parsed.filters.costMin,
+      costMax: options.costMax ?? parsed.filters.costMax,
+      costMinExclusive: options.costMinExclusive ?? parsed.filters.costMinExclusive,
+      costMaxExclusive: options.costMaxExclusive ?? parsed.filters.costMaxExclusive
     },
-    parsed: parsed2
+    parsed
   };
 }
 function sessionMatchesSearchCost(session, options) {
@@ -7389,13 +7086,20 @@ function buildSessionSearchFilters(options) {
     clauses.push("s.agent_name = ?");
     params.push(options.agent);
   }
-  if (options.projectKey) {
-    clauses.push("s.project_identity_key = ?");
-    params.push(options.projectKey);
+  if (options.projectKind || options.projectKey) {
+    if (options.projectKind && options.projectKey) {
+      clauses.push("s.project_identity_kind = ? AND s.project_identity_key = ?");
+      params.push(options.projectKind, options.projectKey);
+    } else {
+      clauses.push("0");
+    }
   }
   if (options.cwd) {
-    clauses.push("(s.project_identity_key = ? OR LOWER(s.directory) LIKE ? ESCAPE '\\')");
-    params.push(computeIdentity(options.cwd, realFs).key, likePattern(options.cwd));
+    const identity = computeIdentity(options.cwd, realFs);
+    clauses.push(
+      "((s.project_identity_kind = ? AND s.project_identity_key = ?) OR LOWER(s.directory) LIKE ? ESCAPE '\\')"
+    );
+    params.push(identity.kind, identity.key, likePattern(options.cwd));
   }
   if (options.project) {
     clauses.push(
@@ -7640,10 +7344,13 @@ function searchSessions(query, options = {}) {
 }
 function fileActivityFilters(options) {
   const path2 = options.path ? normalizeFilePathSearch(options.path) : "";
+  const cwdIdentity = options.cwd ? computeIdentity(options.cwd, realFs) : null;
   return {
+    projectKind: options.projectKind ?? null,
     projectKey: options.projectKey ?? null,
     projectLike: options.project ? likePattern(options.project) : null,
-    cwdKey: options.cwd ? computeIdentity(options.cwd, realFs).key : null,
+    cwdKind: cwdIdentity?.kind ?? null,
+    cwdKey: cwdIdentity?.key ?? null,
     cwdLike: options.cwd ? likePattern(options.cwd) : null,
     path: path2,
     pathLike: path2 ? likePattern(path2) : null
@@ -7672,9 +7379,13 @@ function buildFileActivityWhere(options) {
     clauses.push("fa.session_id = ?");
     params.push(options.sessionId);
   }
-  if (filters.projectKey != null) {
-    clauses.push("fa.project_identity_key = ?");
-    params.push(filters.projectKey);
+  if (filters.projectKind != null || filters.projectKey != null) {
+    if (filters.projectKind != null && filters.projectKey != null) {
+      clauses.push("s.project_identity_kind = ? AND fa.project_identity_key = ?");
+      params.push(filters.projectKind, filters.projectKey);
+    } else {
+      clauses.push("0");
+    }
   }
   if (filters.projectLike != null) {
     clauses.push(
@@ -7683,8 +7394,10 @@ function buildFileActivityWhere(options) {
     params.push(filters.projectLike, filters.projectLike, filters.projectLike);
   }
   if (filters.cwdKey != null) {
-    clauses.push("(s.project_identity_key = ? OR LOWER(s.directory) LIKE ? ESCAPE '\\')");
-    params.push(filters.cwdKey, filters.cwdLike);
+    clauses.push(
+      "((s.project_identity_kind = ? AND s.project_identity_key = ?) OR LOWER(s.directory) LIKE ? ESCAPE '\\')"
+    );
+    params.push(filters.cwdKind, filters.cwdKey, filters.cwdLike);
   }
   if (filters.pathLike != null) {
     const pathQuery = filePathFtsQuery(filters.path);
@@ -7782,6 +7495,7 @@ function searchFileActivitySessions(query, options = {}) {
   if (!path2) return [];
   const rows = listFileActivity({
     agent: search.options.agent,
+    projectKind: search.options.projectKind,
     projectKey: search.options.projectKey,
     project: search.options.project,
     cwd: search.options.cwd,
@@ -8258,9 +7972,7 @@ function sessionSignature(session) {
   ]);
 }
 function sortSessions(sessions) {
-  return [...sessions].sort(
-    (a, b) => (b.time_updated ?? b.time_created) - (a.time_updated ?? a.time_created)
-  );
+  return sortSessionsByActivity(sessions);
 }
 function computeSessionDiff(cachedSessions, updatedSessions, changedIds = [], signature = sessionSignature) {
   const cachedMap = new Map(cachedSessions.map((session) => [session.id, session]));
@@ -8404,6 +8116,47 @@ async function ensureSessionTags(agent, sessions, workerUrl) {
     return ensureSessionTagsSync(agent, sessions);
   }
 }
+async function finalizeAgentScan(agent, sessions, context) {
+  const { finalization, options, timing, agentStart, onProgress } = context;
+  const isIncremental = finalization.kind === "incremental";
+  if (!isIncremental) {
+    onProgress?.({ agent: agent.name, phase: "complete", newCount: sessions.length });
+  }
+  const identityStart = performance.now();
+  const sessionsWithIdentity = attachMissingProjectIdentities(sessions);
+  timing.identity = performance.now() - identityStart;
+  let tagged = { sessions: sessionsWithIdentity, changed: false };
+  if (finalization.kind !== "cache-only") {
+    const tagsStart = performance.now();
+    tagged = options.includeSmartTags === false ? tagged : await ensureSessionTags(agent, sessionsWithIdentity, options.smartTagWorkerUrl);
+    timing.tags = performance.now() - tagsStart;
+  }
+  if (options.writeCache !== false) {
+    if (finalization.kind === "incremental") {
+      saveCachedSessionDiff(
+        agent,
+        finalization.cached.sessions,
+        tagged.sessions,
+        finalization.changedIds
+      );
+    } else if (finalization.kind === "unchanged" && tagged.changed) {
+      saveCachedSessionDiff(agent, finalization.cached.sessions, tagged.sessions);
+    }
+  }
+  if (isIncremental) {
+    onProgress?.({ agent: agent.name, phase: "complete", newCount: tagged.sessions.length });
+  }
+  const heads = filterSessions(tagged.sessions, options);
+  timing.total = performance.now() - agentStart;
+  return {
+    agent,
+    heads,
+    fromCache: true,
+    ...isIncremental ? { refreshed: true } : {},
+    timing,
+    cacheTimestamp: isIncremental ? finalization.cacheTimestamp : finalization.cached.timestamp
+  };
+}
 async function scanAgentSmart(agent, options, onProgress) {
   const agentStart = performance.now();
   const timing = { total: 0 };
@@ -8424,19 +8177,13 @@ async function scanAgentSmart(agent, options, onProgress) {
           phase: "cache",
           cachedCount: cached.sessions.length
         });
-        onProgress?.({ agent: agent.name, phase: "complete", newCount: cached.sessions.length });
-        const t32 = performance.now();
-        const cachedWithIdentity2 = attachMissingProjectIdentities(cached.sessions);
-        timing.identity = performance.now() - t32;
-        const filtered3 = filterSessions(cachedWithIdentity2, options);
-        timing.total = performance.now() - agentStart;
-        return {
-          agent,
-          heads: filtered3,
-          fromCache: true,
+        return finalizeAgentScan(agent, cached.sessions, {
+          finalization: { kind: "cache-only", cached },
+          options,
           timing,
-          cacheTimestamp: cached.timestamp
-        };
+          agentStart,
+          onProgress
+        });
       }
       const isAvail = agent.isAvailable();
       if (!isAvail) {
@@ -8464,55 +8211,26 @@ async function scanAgentSmart(agent, options, onProgress) {
           agent.incrementalScan(cached.sessions, checkResult.changedIds || [])
         );
         timing.scan = performance.now() - t2;
-        const t32 = performance.now();
-        const sessionsWithIdentity = attachMissingProjectIdentities(updatedSessions);
-        timing.identity = performance.now() - t32;
-        const t42 = performance.now();
-        const tagged2 = options.includeSmartTags === false ? { sessions: sessionsWithIdentity, changed: false } : await ensureSessionTags(agent, sessionsWithIdentity, options.smartTagWorkerUrl);
-        timing.tags = performance.now() - t42;
-        if (options.writeCache !== false) {
-          saveCachedSessionDiff(
-            agent,
-            cached.sessions,
-            tagged2.sessions,
-            checkResult.changedIds ?? []
-          );
-        }
-        onProgress?.({
-          agent: agent.name,
-          phase: "complete",
-          newCount: tagged2.sessions.length
-        });
-        const filtered3 = filterSessions(tagged2.sessions, options);
-        timing.total = performance.now() - agentStart;
-        return {
-          agent,
-          heads: filtered3,
-          fromCache: true,
-          refreshed: true,
+        return finalizeAgentScan(agent, updatedSessions, {
+          finalization: {
+            kind: "incremental",
+            cached,
+            changedIds: checkResult.changedIds ?? [],
+            cacheTimestamp: checkResult.timestamp
+          },
+          options,
           timing,
-          cacheTimestamp: checkResult.timestamp
-        };
-      }
-      onProgress?.({ agent: agent.name, phase: "complete", newCount: cached.sessions.length });
-      const t3 = performance.now();
-      const cachedWithIdentity = attachMissingProjectIdentities(cached.sessions);
-      timing.identity = performance.now() - t3;
-      const t4 = performance.now();
-      const tagged = options.includeSmartTags === false ? { sessions: cachedWithIdentity, changed: false } : await ensureSessionTags(agent, cachedWithIdentity, options.smartTagWorkerUrl);
-      timing.tags = performance.now() - t4;
-      if (tagged.changed && options.writeCache !== false) {
-        saveCachedSessionDiff(agent, cached.sessions, tagged.sessions);
+          agentStart,
+          onProgress
+        });
       }
-      const filtered2 = filterSessions(tagged.sessions, options);
-      timing.total = performance.now() - agentStart;
-      return {
-        agent,
-        heads: filtered2,
-        fromCache: true,
+      return finalizeAgentScan(agent, cached.sessions, {
+        finalization: { kind: "unchanged", cached },
+        options,
         timing,
-        cacheTimestamp: cached.timestamp
-      };
+        agentStart,
+        onProgress
+      });
     }
   }
   if (options.cacheOnly) {
@@ -8560,9 +8278,9 @@ async function scanAgentFull(agent, options, onProgress, timing = { total: 0 },
       markAgentFullSyncCompleted(agent.name);
     }
     onProgress?.({ agent: agent.name, phase: "complete", newCount: tagged.sessions.length });
-    const filtered2 = filterSessions(tagged.sessions, options);
+    const filtered = filterSessions(tagged.sessions, options);
     timing.total = performance.now() - agentStart;
-    return { agent, heads: filtered2, fromCache: false, timing };
+    return { agent, heads: filtered, fromCache: false, timing };
   } catch (err) {
     console.error(`Error scanning ${agent.name}:`, err);
     return { agent, heads: [], fromCache: false };
@@ -8610,67 +8328,35 @@ async function scanSessions(options = {}, onProgress) {
 async function scanSessionsAsync(options = {}, onProgress) {
   return scanSessions(options, onProgress);
 }
-var BOOKMARK_DB_FILENAME = "state.db";
-var BOOKMARK_SCHEMA_VERSION = 1;
+var STATE_DB_FILENAME = "state.db";
+var STATE_SCHEMA_VERSION = 2;
 var MEMORY_STATE_STORE = "memory";
-var memoryBookmarks = /* @__PURE__ */ new Map();
-var BookmarkStorageUnavailableError = class extends Error {
+var StateStorageUnavailableError = class extends Error {
   constructor() {
     super("SQLite state database is unavailable");
-    this.name = "BookmarkStorageUnavailableError";
+    this.name = "StateStorageUnavailableError";
   }
 };
 function getStateDir() {
-  if (process.env.CODESESH_STATE_DIR) {
-    return process.env.CODESESH_STATE_DIR;
-  }
-  const p = platform2();
-  if (p === "darwin") {
+  if (process.env.CODESESH_STATE_DIR) return process.env.CODESESH_STATE_DIR;
+  const currentPlatform = platform2();
+  if (currentPlatform === "darwin") {
     return join12(homedir5(), "Library", "Application Support", "codesesh");
   }
-  if (p === "win32") {
+  if (currentPlatform === "win32") {
     const appData = process.env.APPDATA ?? process.env.LOCALAPPDATA;
     return join12(appData ?? join12(homedir5(), "AppData", "Roaming"), "codesesh");
   }
   return join12(process.env.XDG_DATA_HOME ?? join12(homedir5(), ".local", "share"), "codesesh");
 }
 function getStateDbPath() {
-  return join12(getStateDir(), BOOKMARK_DB_FILENAME);
+  return join12(getStateDir(), STATE_DB_FILENAME);
 }
 function useMemoryStateStore() {
   return process.env.CODESESH_STATE_STORE === MEMORY_STATE_STORE;
 }
-function getBookmarkKey(agentKey, sessionId) {
-  return JSON.stringify([agentKey, sessionId]);
-}
-function getActivityTime(bookmark) {
-  return bookmark.time_updated ?? bookmark.time_created;
-}
-function sortBookmarks(bookmarks) {
-  return bookmarks.sort((a, b) => {
-    const activityDelta = getActivityTime(b) - getActivityTime(a);
-    return activityDelta || b.bookmarked_at - a.bookmarked_at;
-  });
-}
-function listMemoryBookmarks() {
-  return sortBookmarks(Array.from(memoryBookmarks.values()));
-}
-function upsertMemoryBookmark(bookmark) {
-  const key = getBookmarkKey(bookmark.agentKey, bookmark.sessionId);
-  const saved = {
-    ...bookmark,
-    bookmarked_at: memoryBookmarks.get(key)?.bookmarked_at ?? Date.now()
-  };
-  memoryBookmarks.set(key, saved);
-  return saved;
-}
-function createStateSchema(db) {
+function createBookmarksTable(db) {
   db.exec(`
-    CREATE TABLE IF NOT EXISTS state_meta (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-
     CREATE TABLE IF NOT EXISTS bookmarks (
       agent_name TEXT NOT NULL,
       session_id TEXT NOT NULL,
@@ -8685,6 +8371,27 @@ function createStateSchema(db) {
     );
   `);
 }
+function createSessionAliasesTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_aliases (
+      agent_name TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      alias TEXT NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (agent_name, session_id)
+    );
+  `);
+}
+function createStateSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS state_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  createBookmarksTable(db);
+  createSessionAliasesTable(db);
+}
 function readLegacyStateVersion(db) {
   if (!tableExists(db, "state_meta") || !columnExists(db, "state_meta", "key") || !columnExists(db, "state_meta", "value")) {
     return 0;
@@ -8694,13 +8401,9 @@ function readLegacyStateVersion(db) {
 }
 function getCurrentStateSchemaVersion(db) {
   const userVersion = getUserVersion(db);
-  if (userVersion > 0) {
-    return userVersion;
-  }
+  if (userVersion > 0) return userVersion;
   const legacyVersion = readLegacyStateVersion(db);
-  if (legacyVersion > 0) {
-    return legacyVersion;
-  }
+  if (legacyVersion > 0) return legacyVersion;
   return tableExists(db, "bookmarks") ? 1 : 0;
 }
 function hasAnyStateSchema(db) {
@@ -8708,14 +8411,14 @@ function hasAnyStateSchema(db) {
 }
 function setStateSchemaVersion(db) {
   createStateSchema(db);
-  setUserVersion(db, BOOKMARK_SCHEMA_VERSION);
+  setUserVersion(db, STATE_SCHEMA_VERSION);
   db.prepare(
     `
       INSERT INTO state_meta(key, value)
       VALUES ('version', ?)
       ON CONFLICT(key) DO UPDATE SET value = excluded.value
     `
-  ).run(String(BOOKMARK_SCHEMA_VERSION));
+  ).run(String(STATE_SCHEMA_VERSION));
 }
 function ensureSchema2(db, dbPath) {
   const currentVersion = getCurrentStateSchemaVersion(db);
@@ -8726,22 +8429,22 @@ function ensureSchema2(db, dbPath) {
   runSchemaMigrations(db, {
     dbPath,
     currentVersion,
-    targetVersion: BOOKMARK_SCHEMA_VERSION,
+    targetVersion: STATE_SCHEMA_VERSION,
     backupLabel: "state-migration",
-    backupTables: ["bookmarks"],
-    migrations: [{ version: 1, migrate: createStateSchema }]
+    backupTables: ["bookmarks", "session_aliases"],
+    migrations: [
+      { version: 1, migrate: createBookmarksTable },
+      { version: 2, migrate: createSessionAliasesTable }
+    ]
   });
-  createStateSchema(db);
-  if (getUserVersion(db) <= BOOKMARK_SCHEMA_VERSION) {
+  if (currentVersion <= STATE_SCHEMA_VERSION) {
     setStateSchemaVersion(db);
   }
 }
 function withStateDb(fn) {
   const statePath = getStateDbPath();
   const db = openDb(statePath);
-  if (!db) {
-    throw new BookmarkStorageUnavailableError();
-  }
+  if (!db) throw new StateStorageUnavailableError();
   try {
     ensureSchema2(db, statePath);
     return fn(db);
@@ -8749,6 +8452,31 @@ function withStateDb(fn) {
     db.close();
   }
 }
+var memoryBookmarks = /* @__PURE__ */ new Map();
+function getBookmarkKey(agentKey, sessionId) {
+  return JSON.stringify([agentKey, sessionId]);
+}
+function getActivityTime(bookmark) {
+  return bookmark.time_updated ?? bookmark.time_created;
+}
+function sortBookmarks(bookmarks) {
+  return bookmarks.sort((a, b) => {
+    const activityDelta = getActivityTime(b) - getActivityTime(a);
+    return activityDelta || b.bookmarked_at - a.bookmarked_at;
+  });
+}
+function listMemoryBookmarks() {
+  return sortBookmarks(Array.from(memoryBookmarks.values()));
+}
+function upsertMemoryBookmark(bookmark) {
+  const key = getBookmarkKey(bookmark.agentKey, bookmark.sessionId);
+  const saved = {
+    ...bookmark,
+    bookmarked_at: memoryBookmarks.get(key)?.bookmarked_at ?? Date.now()
+  };
+  memoryBookmarks.set(key, saved);
+  return saved;
+}
 function toBookmarkRecord(row) {
   return {
     agentKey: String(row.agent_name ?? ""),
@@ -8921,6 +8649,78 @@ function deleteBookmark(agentKey, sessionId) {
     ).run(agentKey, sessionId);
   });
 }
+var SESSION_ALIAS_MAX_LENGTH = 160;
+var memoryAliases = /* @__PURE__ */ new Map();
+function getAliasKey(agentKey, sessionId) {
+  return JSON.stringify([agentKey, sessionId]);
+}
+function toSessionAlias(row) {
+  return {
+    agentKey: String(row.agent_name ?? ""),
+    sessionId: String(row.session_id ?? ""),
+    alias: String(row.alias ?? ""),
+    updated_at: Number(row.updated_at ?? 0)
+  };
+}
+function normalizeSessionAlias(value) {
+  const alias = value.trim();
+  if (!alias || alias.length > SESSION_ALIAS_MAX_LENGTH) return null;
+  return alias;
+}
+function listSessionAliases() {
+  if (useMemoryStateStore()) return [...memoryAliases.values()];
+  return withStateDb(
+    (db) => db.prepare(
+      `
+          SELECT agent_name, session_id, alias, updated_at
+          FROM session_aliases
+          ORDER BY updated_at DESC
+        `
+    ).all().map(toSessionAlias)
+  );
+}
+function upsertSessionAlias(agentKey, sessionId, alias) {
+  const normalizedAlias = normalizeSessionAlias(alias);
+  if (!normalizedAlias) {
+    throw new TypeError("Invalid session alias");
+  }
+  const saved = {
+    agentKey,
+    sessionId,
+    alias: normalizedAlias,
+    updated_at: Date.now()
+  };
+  if (useMemoryStateStore()) {
+    memoryAliases.set(getAliasKey(agentKey, sessionId), saved);
+    return saved;
+  }
+  return withStateDb((db) => {
+    db.prepare(
+      `
+        INSERT INTO session_aliases(agent_name, session_id, alias, updated_at)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(agent_name, session_id) DO UPDATE SET
+          alias = excluded.alias,
+          updated_at = excluded.updated_at
+      `
+    ).run(saved.agentKey, saved.sessionId, saved.alias, saved.updated_at);
+    return saved;
+  });
+}
+function deleteSessionAlias(agentKey, sessionId) {
+  if (useMemoryStateStore()) {
+    memoryAliases.delete(getAliasKey(agentKey, sessionId));
+    return;
+  }
+  withStateDb((db) => {
+    db.prepare(
+      `
+        DELETE FROM session_aliases
+        WHERE agent_name = ? AND session_id = ?
+      `
+    ).run(agentKey, sessionId);
+  });
+}
 var DASHBOARD_RECENT_LIMIT = 10;
 function getTotalTokens(stats) {
   return stats.total_tokens ?? stats.total_input_tokens + stats.total_output_tokens;
@@ -8974,10 +8774,11 @@ function buildDashboard(sessions, options) {
   for (const session of sessions) {
     const agentName = getSessionAgentName(session);
     if (scope.agent && agentName !== scope.agent) continue;
-    if (scope.projectKey) {
+    if (scope.projectKind || scope.projectKey) {
       const identity = session.project_identity;
-      if (!identity || identity.key !== scope.projectKey) continue;
-      if (scope.projectKind && identity.kind !== scope.projectKind) continue;
+      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;
@@ -9076,6 +8877,90 @@ function buildDashboard(sessions, options) {
     recentSessions
   };
 }
+function executeSessionSearch(query, options, snapshot) {
+  const merged = mergeSearchQueryOptions(query, options);
+  if (!needsIndexedSearch(merged.text, merged.options)) {
+    return searchRecentSessions(snapshot, merged.options);
+  }
+  return searchIndexedSessions(query, merged.text, merged.parsed, merged.options);
+}
+function needsIndexedSearch(textQuery, options) {
+  return Boolean(textQuery || options.file || options.fileKind || options.tools?.length);
+}
+function filterSessionsByActivityWindow(sessions, from, to) {
+  if (from == null && to == null) return sessions;
+  return sessions.filter((session) => {
+    const activity = getSessionActivityTime(session);
+    if (from != null && activity < from) return false;
+    if (to != null && activity > to) return false;
+    return true;
+  });
+}
+function matchesRecentSearchFilters(session, options, projectScope) {
+  if (options.projectKind || options.projectKey) {
+    if (!options.projectKind || !options.projectKey || !matchesProjectIdentity(session.project_identity, {
+      kind: options.projectKind,
+      key: options.projectKey
+    })) {
+      return false;
+    }
+  }
+  if (projectScope && !matchesProjectScope(session, projectScope)) return false;
+  if (options.project) {
+    const projectNeedle = options.project.toLowerCase();
+    const projectText = [
+      session.project_identity?.key,
+      session.project_identity?.displayName,
+      session.directory
+    ].filter(Boolean).join("\n").toLowerCase();
+    if (!projectText.includes(projectNeedle)) return false;
+  }
+  if (options.tags?.length && !options.tags.every((tag) => session.smart_tags?.includes(tag))) {
+    return false;
+  }
+  if (!sessionMatchesSearchCost(session, options)) return false;
+  return true;
+}
+function searchRecentSessions(snapshot, options) {
+  const projectScope = options.cwd ? createProjectScopeMatcher(options.cwd) : null;
+  const entries = options.agent ? [[options.agent, snapshot.byAgent[options.agent] ?? []]] : Object.entries(snapshot.byAgent);
+  return entries.flatMap(
+    ([agentName, sessions]) => filterSessionsByActivityWindow(sessions, options.from, options.to).filter((session) => matchesRecentSearchFilters(session, options, projectScope)).map((session) => ({ agentName, session }))
+  ).sort(
+    (a, b) => (b.session.time_updated ?? b.session.time_created) - (a.session.time_updated ?? a.session.time_created)
+  ).slice(0, options.limit ?? 50).map(({ agentName, session }) => ({
+    agentName,
+    session,
+    snippet: `Recent session \xB7 ${session.directory}`,
+    matchType: "recent"
+  }));
+}
+function deriveFileQuery(query, parsed, options) {
+  return options.file ?? (!parsed.text ? parsed.filters.file : void 0) ?? (!parsed.hasQualifiers && query ? parsed.text || query : "");
+}
+function mergeSearchResultSources(results, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const result of results) {
+    const key = `${result.agentName}/${result.session.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(result);
+    if (merged.length >= limit) break;
+  }
+  return merged;
+}
+function canSkipSessionsSearch(fileQuery, textQuery, options) {
+  return Boolean(
+    fileQuery && !textQuery && !options.tools?.length && !options.tags?.length && options.from == null && options.to == null
+  );
+}
+function searchIndexedSessions(query, textQuery, parsed, options) {
+  const fileQuery = deriveFileQuery(query, parsed, options);
+  const fileResults = fileQuery ? searchFileActivitySessions(fileQuery, options) : [];
+  const sessionResults = canSkipSessionsSearch(fileQuery, textQuery, options) ? [] : searchSessions(query, options);
+  return mergeSearchResultSources([...fileResults, ...sessionResults], options.limit ?? 50);
+}
 
 export {
   registerAgent,
@@ -9101,16 +8986,12 @@ export {
   normalizeTitleText,
   basenameTitle,
   resolveSessionTitle,
-  parsed,
-  skipped,
-  filtered,
   cleanInternalText,
   cleanMessagePart,
   cleanMessageParts,
   cleanParsedMessage,
   cleanParsedMessages,
   firstUserMessageTitle,
-  perf,
   getPricingRegistry,
   hasBillablePricing,
   refreshPricingCache,
@@ -9123,11 +9004,15 @@ export {
   openDbReadOnly,
   openDb,
   isSqliteAvailable,
+  perf,
   fallbackDisplayName,
   realFs,
-  buildProjectGroups,
+  isProjectIdentityKind,
+  getProjectIdentityKey,
+  matchesProjectIdentity,
   normalizeGitRemote,
   computeIdentity,
+  buildProjectGroups,
   createProjectScopeMatcher,
   matchesProjectScope,
   filterSessionsByProjectScope,
@@ -9141,6 +9026,7 @@ export {
   parseSearchQuery,
   syncSessionSearchIndex,
   syncSessionSearchIndexChanges,
+  mergeSearchQueryOptions,
   searchSessions,
   listFileActivity,
   listSessionFileActivity,
@@ -9165,17 +9051,23 @@ export {
   ensureSessionTagsSync,
   scanSessions,
   scanSessionsAsync,
-  BookmarkStorageUnavailableError,
+  StateStorageUnavailableError,
   listBookmarks,
   upsertBookmark,
   importBookmarks,
   deleteBookmark,
+  SESSION_ALIAS_MAX_LENGTH,
+  normalizeSessionAlias,
+  listSessionAliases,
+  upsertSessionAlias,
+  deleteSessionAlias,
   DASHBOARD_RECENT_LIMIT,
   getTotalTokens,
   getSessionAgentName,
   getSessionActivityTime,
   toLocalDateKey,
   startOfLocalDay,
-  buildDashboard
+  buildDashboard,
+  executeSessionSearch
 };
-//# sourceMappingURL=chunk-GCOAE7KI.js.map
+//# sourceMappingURL=chunk-VRVZJDNL.js.map