codesesh 1.0.2 → 1.0.4

package/dist/chunk-W4PZHL2C.js

@@ -0,0 +1,2035 @@
+#!/usr/bin/env node
+
+// ../core/dist/chunk-AXHUQ6MM.mjs
+var SMART_TAGS = [
+  "bugfix",
+  "refactoring",
+  "feature-dev",
+  "testing",
+  "docs",
+  "git-ops",
+  "build-deploy",
+  "exploration",
+  "planning"
+];
+function isSmartTag(value) {
+  return SMART_TAGS.some((tag) => tag === value);
+}
+function assertIdentifiedSessionHead(session) {
+  if (session.project_identity) return;
+  throw new Error(
+    `Session ${session.reference.agentName}/${session.reference.sessionId} is missing project_identity`
+  );
+}
+function toPublicSessionHead(session) {
+  const {
+    model_usage: _modelUsage,
+    project_identity_resolver_revision: _resolverRevision,
+    project_identity_input_signature: _identityInputSignature,
+    smart_tags_source_updated_at: _smartTagsSourceUpdatedAt,
+    smart_tags_classifier_revision: _classifierRevision,
+    ...publicSession
+  } = session;
+  return publicSession;
+}
+function toPublicReferencedSessionHead(item) {
+  return { ...item, session: toPublicSessionHead(item.session) };
+}
+
+// ../core/dist/chunk-EY7UDYHJ.mjs
+var SMART_TAG_CLASSIFIER_REVISION = "smart-tags-v1";
+var USER_RULES = [
+  ["bugfix", /\b(fix|bug|error|crash|exception|fail(?:ed|ure)?)\b|修复|错误|报错|崩溃|异常/i],
+  ["refactoring", /\b(refactor|rename|simplify|clean up|cleanup)\b|重构|重命名|简化|清理/i],
+  ["feature-dev", /\b(add|create|implement|new|support|build)\b|新增|创建|实现|增加|开发|支持/i],
+  ["docs", /\b(document|documentation|readme|docs?)\b|文档|说明/i]
+];
+var TESTING_COMMAND_RE = /\b(pytest|vitest|jest|mocha|pnpm\s+test|npm\s+test|yarn\s+test)\b/i;
+var GIT_COMMAND_RE = /\bgit\s+(push|commit|merge|branch|checkout|switch|rebase|tag)\b/i;
+var BUILD_DEPLOY_COMMAND_RE = /\b((npm|pnpm|yarn|bun)\s+(run\s+)?build|docker|pm2|deploy|vercel|netlify)\b/i;
+var DOC_PATH_RE = /\.(md|mdx|txt|rst|adoc)$/i;
+var READ_TOOL_RE = /\b(read|grep|glob|websearch|web_search|search|find|rg)\b/i;
+var EDIT_TOOL_RE = /\b(edit|write|apply_patch|patch|multiedit|notebookedit)\b/i;
+var PLAN_TOOL_RE = /\b(enterplanmode|taskcreate|update_plan|plan)\b/i;
+function getSmartTagSourceTimestamp(session) {
+  return session.time_updated ?? session.time_created;
+}
+function classifySessionTags(session) {
+  const tags = /* @__PURE__ */ new Set();
+  let readToolCount = 0;
+  let editToolCount = 0;
+  for (const message of session.messages) {
+    if (message.role === "user") {
+      const text = message.parts.map(partText).join("\n");
+      for (const [tag, pattern] of USER_RULES) {
+        if (pattern.test(text)) tags.add(tag);
+      }
+    }
+    for (const part of message.parts) {
+      if (part.type === "plan") tags.add("planning");
+      if (part.type !== "tool") continue;
+      const toolName = `${part.tool} ${part.title ?? ""}`;
+      const toolPayload = stringifyToolPayload(part);
+      if (PLAN_TOOL_RE.test(toolName)) tags.add("planning");
+      if (READ_TOOL_RE.test(toolName)) readToolCount += 1;
+      if (EDIT_TOOL_RE.test(toolName)) editToolCount += 1;
+      if (TESTING_COMMAND_RE.test(toolPayload)) tags.add("testing");
+      if (GIT_COMMAND_RE.test(toolPayload)) tags.add("git-ops");
+      if (BUILD_DEPLOY_COMMAND_RE.test(toolPayload)) tags.add("build-deploy");
+      if (hasEditedDocPath(part.state.input)) {
+        tags.add("docs");
+      }
+    }
+  }
+  if (readToolCount >= 3 && editToolCount <= 1) {
+    tags.add("exploration");
+  }
+  return SMART_TAGS.filter((tag) => tags.has(tag));
+}
+function partText(part) {
+  return part.type === "text" || part.type === "reasoning" || part.type === "plan" ? part.text : "";
+}
+function stringifyToolPayload(part) {
+  return [part.tool, part.title, valueToText(part.state)].filter(Boolean).join("\n");
+}
+function valueToText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function hasEditedDocPath(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return DOC_PATH_RE.test(value);
+  if (Array.isArray(value)) return value.some(hasEditedDocPath);
+  if (typeof value !== "object") return false;
+  const record = value;
+  for (const key of ["path", "file", "filePath", "file_path", "targetPath", "target_path"]) {
+    const raw = record[key];
+    if (typeof raw === "string" && DOC_PATH_RE.test(raw)) return true;
+  }
+  return Object.values(record).some(hasEditedDocPath);
+}
+var WORKER_LOG_MESSAGE_TYPE = "codesesh.worker-log";
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isWorkerLogMessage(value) {
+  if (!isRecord(value) || value.type !== WORKER_LOG_MESSAGE_TYPE) return false;
+  return typeof value.ts === "string" && value.ts.length > 0 && (value.level === "debug" || value.level === "info" || value.level === "warn" || value.level === "error") && typeof value.event === "string" && value.event.length > 0 && Number.isSafeInteger(value.pid) && Number(value.pid) > 0 && Number.isSafeInteger(value.threadId) && Number(value.threadId) >= 0 && isRecord(value.data);
+}
+
+// ../core/dist/chunk-FDGCEOYE.mjs
+function normalizeSessionReference(reference) {
+  return {
+    agentName: reference.agentName.trim().toLowerCase(),
+    sessionId: reference.sessionId
+  };
+}
+function formatSessionReference(reference) {
+  const normalized = normalizeSessionReference(reference);
+  return `${normalized.agentName}/${normalized.sessionId}`;
+}
+function getSessionReferenceKey(reference) {
+  return formatSessionReference(reference);
+}
+function createSessionIdentity(reference) {
+  return {
+    reference: normalizeSessionReference(reference)
+  };
+}
+function assertSessionIdentity(identity, agentName) {
+  const normalized = normalizeSessionReference(identity.reference);
+  const expectedAgentName = agentName?.trim().toLowerCase();
+  if (identity.reference.agentName !== normalized.agentName) {
+    throw new Error("Session reference is not normalized");
+  }
+  if (expectedAgentName != null && normalized.agentName !== expectedAgentName) {
+    throw new Error(
+      `Session reference agent "${normalized.agentName}" does not match "${expectedAgentName}"`
+    );
+  }
+}
+function getSessionAgentKey(session) {
+  return normalizeSessionReference(session.reference).agentName;
+}
+function agentRoutePath(agentName) {
+  return `/${encodeURIComponent(agentName.trim().toLowerCase())}`;
+}
+function sessionRoutePath(reference) {
+  const normalized = normalizeSessionReference(reference);
+  return `${agentRoutePath(normalized.agentName)}/${encodeURIComponent(normalized.sessionId)}`;
+}
+
+// ../core/dist/chunk-GHNYETRY.mjs
+var FILE_TOOL_KINDS = {
+  read: "read",
+  read_file: "read",
+  read_file_v2: "read",
+  read_text_file: "read",
+  readfile: "read",
+  view_image: "read",
+  apply_patch: "edit",
+  edit: "edit",
+  edit_file: "edit",
+  edit_file_v2: "edit",
+  editfile: "edit",
+  multiedit: "edit",
+  notebookedit: "edit",
+  patch: "edit",
+  search_replace: "edit",
+  str_replace: "edit",
+  create_file: "write",
+  write: "write",
+  write_file: "write",
+  writefile: "write",
+  delete: "delete",
+  delete_file: "delete"
+};
+var PATCH_KINDS = {
+  edit_file: "edit",
+  update_file: "edit",
+  write_file: "write",
+  delete_file: "delete",
+  move_file: "edit"
+};
+function toRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function looksLikeFilePath(value) {
+  const text = value.trim();
+  if (!text || text.length > 300 || text.includes("\n")) return false;
+  if (/^[a-z]+:\/\//i.test(text) || /[<>{}]/.test(text)) return false;
+  if (text.startsWith("/") || text.startsWith("./") || text.startsWith("../")) return true;
+  if (text.startsWith("~/") || text.includes("/") || text.includes("\\")) return true;
+  return /^[A-Za-z0-9_.@-]+\.[A-Za-z0-9_-]+$/.test(text);
+}
+function isPathKey(key) {
+  const normalized = key.trim().toLowerCase();
+  if (!normalized) return false;
+  if (normalized.includes("command") || normalized.includes("content") || normalized.includes("text") || normalized.includes("prompt") || normalized.includes("url") || normalized.includes("body") || normalized.includes("title") || normalized.includes("description") || normalized === "cwd" || normalized === "workdir" || normalized === "directory") {
+    return false;
+  }
+  return normalized.includes("file") || normalized.includes("path");
+}
+function collectPaths(value, key, paths, depth = 0) {
+  if (value == null || depth > 4) return;
+  if (typeof value === "string") {
+    if (isPathKey(key) && looksLikeFilePath(value)) paths.add(value.trim());
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectPaths(item, key, paths, depth + 1);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [nestedKey, nested] of Object.entries(value)) {
+      collectPaths(nested, nestedKey, paths, depth + 1);
+    }
+  }
+}
+function extractPatchOperations(input) {
+  const record = toRecord(input);
+  const content = Array.isArray(input) ? input : Array.isArray(record.content) ? record.content : [];
+  return content.flatMap((entry) => {
+    const patch = toRecord(entry);
+    const kind = typeof patch.type === "string" ? PATCH_KINDS[patch.type] : void 0;
+    const pathValue = patch.path || patch.old_path;
+    const path = typeof pathValue === "string" ? pathValue.trim() : "";
+    return kind && path ? [{ kind, path }] : [];
+  });
+}
+function classifyFileTool(part) {
+  return FILE_TOOL_KINDS[part.tool.trim().toLowerCase()] ?? null;
+}
+function extractFileToolOperations(part) {
+  const patchOperations = extractPatchOperations(part.state.input);
+  if (patchOperations.length > 0) return patchOperations;
+  const kind = classifyFileTool(part);
+  if (!kind) return [];
+  const paths = /* @__PURE__ */ new Set();
+  collectPaths(part.state.input, "", paths);
+  return [...paths].map((path) => ({ kind, path }));
+}
+function mergeSessionsUpdatedEvents(previous, next) {
+  const changedSessionHeads = /* @__PURE__ */ new Map();
+  const projectionRelatedSessionHeads = /* @__PURE__ */ new Map();
+  const projectionSessionOrder = /* @__PURE__ */ new Map();
+  const newSessionRefs = /* @__PURE__ */ new Map();
+  const removedSessionRefs = /* @__PURE__ */ new Map();
+  const sessionKey2 = (agentName, sessionId) => `${agentName}\0${sessionId}`;
+  const addChanged = (item) => {
+    const key = sessionKey2(item.reference.agentName, item.reference.sessionId);
+    removedSessionRefs.delete(key);
+    projectionRelatedSessionHeads.delete(key);
+    changedSessionHeads.set(key, item);
+  };
+  const addProjectionRelated = (item) => {
+    const key = sessionKey2(item.reference.agentName, item.reference.sessionId);
+    if (changedSessionHeads.has(key) || removedSessionRefs.has(key)) return;
+    projectionRelatedSessionHeads.set(key, item);
+  };
+  const addNew = (item) => {
+    const key = sessionKey2(item.agentName, item.sessionId);
+    removedSessionRefs.delete(key);
+    newSessionRefs.set(key, item);
+  };
+  const addProjectionOrder = (item) => {
+    const key = sessionKey2(item.agentName, item.sessionId);
+    projectionSessionOrder.delete(key);
+    projectionSessionOrder.set(key, item);
+  };
+  const addRemoved = (item) => {
+    const key = sessionKey2(item.agentName, item.sessionId);
+    changedSessionHeads.delete(key);
+    projectionRelatedSessionHeads.delete(key);
+    projectionSessionOrder.delete(key);
+    newSessionRefs.delete(key);
+    removedSessionRefs.set(key, item);
+  };
+  for (const item of previous.newSessionRefs) addNew(item);
+  for (const item of previous.projectionRelatedSessionHeads ?? []) addProjectionRelated(item);
+  for (const item of previous.projectionSessionOrder ?? []) addProjectionOrder(item);
+  for (const item of previous.changedSessionHeads) addChanged(item);
+  for (const item of previous.removedSessionRefs) addRemoved(item);
+  for (const item of next.newSessionRefs) addNew(item);
+  for (const item of next.projectionRelatedSessionHeads ?? []) addProjectionRelated(item);
+  for (const item of next.projectionSessionOrder ?? []) addProjectionOrder(item);
+  for (const item of next.changedSessionHeads) addChanged(item);
+  for (const item of next.removedSessionRefs) addRemoved(item);
+  return {
+    type: "sessions-updated",
+    changedAgents: Array.from(/* @__PURE__ */ new Set([...previous.changedAgents, ...next.changedAgents])),
+    newSessionRefs: [...newSessionRefs.values()],
+    totalSessions: next.totalSessions,
+    timestamp: next.timestamp,
+    changedSessionHeads: [...changedSessionHeads.values()],
+    projectionRelatedSessionHeads: [...projectionRelatedSessionHeads.values()],
+    projectionSessionOrder: [...projectionSessionOrder.values()],
+    removedSessionRefs: [...removedSessionRefs.values()]
+  };
+}
+function startOfCalendarDay(timestamp) {
+  const date = new Date(timestamp);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function addCalendarDays(timestamp, days) {
+  const date = new Date(timestamp);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days).getTime();
+}
+function toCalendarDayNumber(timestamp) {
+  const date = new Date(timestamp);
+  return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) / 864e5;
+}
+function countCalendarDays(from, to) {
+  return Math.max(1, toCalendarDayNumber(to) - toCalendarDayNumber(from) + 1);
+}
+function toCalendarDayKey(timestamp) {
+  const date = new Date(timestamp);
+  return `${String(date.getFullYear()).padStart(4, "0")}-${String(date.getMonth() + 1).padStart(
+    2,
+    "0"
+  )}-${String(date.getDate()).padStart(2, "0")}`;
+}
+var PROJECT_IDENTITY_KINDS = [
+  "git_remote",
+  "git_common_dir",
+  "manifest_path",
+  "synthetic",
+  "path",
+  "loose"
+];
+var KIND_LOOKUP = new Set(PROJECT_IDENTITY_KINDS);
+function isProjectIdentityKind(value) {
+  return KIND_LOOKUP.has(value);
+}
+function getProjectIdentityKey(identity) {
+  return `${identity.kind}:${identity.key}`;
+}
+function matchesProjectIdentity(identity, expected) {
+  return identity?.kind === expected.kind && identity.key === expected.key;
+}
+function getProjectAgentKey(projectIdentityKey, agentName) {
+  return `${projectIdentityKey}\0${agentName.toLowerCase()}`;
+}
+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];
+}
+function mergeSortedSessions(shards) {
+  const active = shards.filter((shard) => shard.length > 0);
+  if (active.length === 0) return [];
+  if (active.length === 1) return [...active[0]];
+  const total = active.reduce((sum, shard) => sum + shard.length, 0);
+  const merged = [];
+  const cursors = Array.from({ length: active.length }, () => 0);
+  for (let position = 0; position < total; position += 1) {
+    let pick = -1;
+    for (let shard = 0; shard < active.length; shard += 1) {
+      const cursor = cursors[shard];
+      if (cursor >= active[shard].length) continue;
+      if (pick === -1 || compareSessionActivityDesc(active[shard][cursor], active[pick][cursors[pick]]) < 0) {
+        pick = shard;
+      }
+    }
+    merged.push(active[pick][cursors[pick]]);
+    cursors[pick] += 1;
+  }
+  return merged;
+}
+function pushMapValue(map, key, value) {
+  const current = map.get(key);
+  if (current) {
+    current.push(value);
+  } else {
+    map.set(key, [value]);
+  }
+}
+function createSessionIndex(sourceSessions) {
+  const byRouteKey = /* @__PURE__ */ new Map();
+  const childrenByParentRouteKey = /* @__PURE__ */ new Map();
+  const byAgent = /* @__PURE__ */ new Map();
+  const byProjectIdentityKey = /* @__PURE__ */ new Map();
+  const byProjectAgentKey = /* @__PURE__ */ new Map();
+  for (const session of sourceSessions) {
+    const routeKey = getSessionReferenceKey(session.reference);
+    if (!byRouteKey.has(routeKey)) byRouteKey.set(routeKey, session);
+    if (session.parent_reference) {
+      pushMapValue(
+        childrenByParentRouteKey,
+        getSessionReferenceKey(session.parent_reference),
+        session
+      );
+    }
+  }
+  const sessionsByActivity = sortSessionsByActivity(sourceSessions);
+  for (const session of sessionsByActivity) {
+    const { agentName } = session.reference;
+    pushMapValue(byAgent, agentName, session);
+    const identity = session.project_identity;
+    if (!identity?.key) continue;
+    const projectIdentityKey = getProjectIdentityKey(identity);
+    pushMapValue(byProjectIdentityKey, projectIdentityKey, session);
+    pushMapValue(byProjectAgentKey, getProjectAgentKey(projectIdentityKey, agentName), session);
+  }
+  return {
+    sourceSessions,
+    sessionsByActivity,
+    byRouteKey,
+    childrenByParentRouteKey,
+    byAgent,
+    byProjectIdentityKey,
+    byProjectAgentKey
+  };
+}
+function sessionKey(session) {
+  return getSessionReferenceKey(session.reference);
+}
+function parentKey(session) {
+  return session.parent_reference ? getSessionReferenceKey(session.parent_reference) : null;
+}
+function activityTime(session) {
+  return session.time_updated ?? session.time_created;
+}
+function hasActivityInWindow(session, from, to) {
+  const activity = activityTime(session);
+  return (from == null || activity >= from) && (to == null || activity <= to);
+}
+function ownStats(session) {
+  const stats = session.stats;
+  const cost = stats.total_cost ?? 0;
+  return {
+    messageCount: stats.message_count,
+    inputTokens: stats.total_input_tokens,
+    outputTokens: stats.total_output_tokens,
+    cacheReadTokens: stats.total_cache_read_tokens ?? 0,
+    cacheCreateTokens: stats.total_cache_create_tokens ?? 0,
+    totalTokens: stats.total_tokens ?? stats.total_input_tokens + stats.total_output_tokens,
+    cost,
+    costSource: cost > 0 ? stats.cost_source ?? "recorded" : void 0
+  };
+}
+function addStats(target, source) {
+  target.messageCount += source.messageCount;
+  target.inputTokens += source.inputTokens;
+  target.outputTokens += source.outputTokens;
+  target.cacheReadTokens += source.cacheReadTokens;
+  target.cacheCreateTokens += source.cacheCreateTokens;
+  target.totalTokens += source.totalTokens;
+  target.cost += source.cost;
+  if (source.costSource === "estimated") target.costSource = "estimated";
+}
+function rollUpSubtree(entry) {
+  const order = [];
+  const pending2 = [entry];
+  while (pending2.length > 0) {
+    const node = pending2.pop();
+    order.push(node);
+    for (const child of node.children) pending2.push(child);
+  }
+  for (let index = order.length - 1; index >= 0; index -= 1) {
+    const node = order[index];
+    const stats = node.inclusiveStats;
+    let descendants = 0;
+    for (const child of node.children) {
+      descendants += 1 + child.descendantCount;
+      addStats(stats, child.inclusiveStats);
+    }
+    if (stats.cost > 0 && stats.costSource == null) stats.costSource = "recorded";
+    node.descendantCount = descendants;
+  }
+}
+function buildSessionTree(sessions) {
+  const byRouteKey = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const key = sessionKey(session);
+    if (byRouteKey.has(key)) continue;
+    byRouteKey.set(key, {
+      session,
+      children: [],
+      descendantCount: 0,
+      inclusiveStats: ownStats(session)
+    });
+  }
+  const nodes = [...byRouteKey.values()];
+  const chainTerminates = /* @__PURE__ */ new Map();
+  function reachesRoot(startKey) {
+    const path = [];
+    const onPath = /* @__PURE__ */ new Set();
+    let key = startKey;
+    let terminates = true;
+    while (key != null) {
+      const memo = chainTerminates.get(key);
+      if (memo != null) {
+        terminates = memo;
+        break;
+      }
+      if (onPath.has(key)) {
+        terminates = false;
+        break;
+      }
+      onPath.add(key);
+      path.push(key);
+      const parent = parentKey(byRouteKey.get(key).session);
+      key = parent != null && byRouteKey.has(parent) ? parent : null;
+    }
+    for (const visited of path) chainTerminates.set(visited, terminates);
+    return terminates;
+  }
+  const mountStates = /* @__PURE__ */ new Map();
+  const roots = [];
+  const orphans = [];
+  const entries = [];
+  for (const node of nodes) {
+    const key = sessionKey(node.session);
+    const parent = parentKey(node.session);
+    const state = parent == null ? "root" : byRouteKey.has(parent) && reachesRoot(key) ? "mounted-child" : "orphan";
+    mountStates.set(key, state);
+    if (state === "mounted-child") {
+      byRouteKey.get(parent).children.push(node);
+      continue;
+    }
+    (state === "root" ? roots : orphans).push(node);
+    entries.push(node);
+  }
+  for (const entry of entries) rollUpSubtree(entry);
+  return {
+    roots,
+    orphans,
+    entries,
+    byRouteKey,
+    mountStateOf(session) {
+      return mountStates.get(sessionKey(session)) ?? (session.parent_reference ? "orphan" : "root");
+    }
+  };
+}
+function filterSessionTreeByActivityWindow(sessions, from, to, tree = buildSessionTree(sessions)) {
+  if (from == null && to == null) return sessions;
+  const pending2 = filterSessionTreeEntriesByActivityWindow(tree, from, to);
+  const visible = /* @__PURE__ */ new Set();
+  while (pending2.length > 0) {
+    const node = pending2.pop();
+    const key = sessionKey(node.session);
+    if (visible.has(key)) continue;
+    visible.add(key);
+    for (const child of node.children) pending2.push(child);
+  }
+  return sessions.filter((session) => visible.has(sessionKey(session)));
+}
+function filterSessionTreeEntriesByActivityWindow(tree, from, to) {
+  if (from == null && to == null) return tree.entries;
+  return tree.entries.filter((node) => hasActivityInWindow(node.session, from, to));
+}
+function createSessionHierarchyGraph(sessions) {
+  const sessionsByKey = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const key = sessionKey(session);
+    if (!sessionsByKey.has(key)) sessionsByKey.set(key, session);
+  }
+  const parentByKey = /* @__PURE__ */ new Map();
+  const childrenByKey = /* @__PURE__ */ new Map();
+  for (const [key, session] of sessionsByKey) {
+    const parent = parentKey(session);
+    if (!parent || !sessionsByKey.has(parent)) continue;
+    parentByKey.set(key, parent);
+    const children = childrenByKey.get(parent);
+    if (children) children.push(key);
+    else childrenByKey.set(parent, [key]);
+  }
+  return { sessionsByKey, parentByKey, childrenByKey };
+}
+function collectAffectedHierarchyKeys(graph, seedKeys, includeAncestors, collected) {
+  const visited = /* @__PURE__ */ new Set();
+  const pending2 = [...seedKeys].filter((key) => graph.sessionsByKey.has(key));
+  while (pending2.length > 0) {
+    const key = pending2.pop();
+    if (visited.has(key)) continue;
+    visited.add(key);
+    collected.add(key);
+    for (const child of graph.childrenByKey.get(key) ?? []) pending2.push(child);
+  }
+  if (!includeAncestors) return;
+  for (const seed of seedKeys) {
+    let key = graph.sessionsByKey.has(seed) ? seed : void 0;
+    const onPath = /* @__PURE__ */ new Set();
+    while (key && !onPath.has(key)) {
+      onPath.add(key);
+      collected.add(key);
+      key = graph.parentByKey.get(key);
+    }
+  }
+}
+function createSessionProjectionContext(previousSessions, nextSessions, changedSessionHeads, removedSessionRefs) {
+  const changedKeys = new Set(
+    changedSessionHeads.map(({ reference }) => getSessionReferenceKey(reference))
+  );
+  const removedKeys = removedSessionRefs.map(getSessionReferenceKey);
+  const affectedKeys = /* @__PURE__ */ new Set();
+  const previousGraph = createSessionHierarchyGraph(previousSessions);
+  const nextGraph = createSessionHierarchyGraph(nextSessions);
+  collectAffectedHierarchyKeys(previousGraph, changedKeys, true, affectedKeys);
+  collectAffectedHierarchyKeys(nextGraph, changedKeys, true, affectedKeys);
+  collectAffectedHierarchyKeys(previousGraph, removedKeys, false, affectedKeys);
+  const emitted = /* @__PURE__ */ new Set();
+  const relatedSessionHeads = nextSessions.flatMap((session) => {
+    const key = sessionKey(session);
+    if (!affectedKeys.has(key) || changedKeys.has(key) || emitted.has(key)) return [];
+    emitted.add(key);
+    return [
+      {
+        reference: session.reference,
+        session
+      }
+    ];
+  });
+  const affectedActivityTimes = new Set(
+    [...changedSessionHeads, ...relatedSessionHeads].map(({ session }) => activityTime(session))
+  );
+  const sessionOrder = nextSessions.flatMap(
+    (session) => affectedActivityTimes.has(activityTime(session)) ? [session.reference] : []
+  );
+  return { relatedSessionHeads, sessionOrder };
+}
+
+// ../core/dist/chunk-3ENBOS4I.mjs
+function normalizeToolLabel(part) {
+  if (part.title?.trim()) {
+    return part.title.trim().replace(/^tool:\s*/i, "");
+  }
+  if (part.tool.trim()) return part.tool.trim();
+  return "tool";
+}
+function extractFileActivityOccurrences(messages) {
+  const occurrences = [];
+  messages.forEach((message, messageIndex) => {
+    let toolIndex = 0;
+    for (const part of message.parts) {
+      if (part.type !== "tool") continue;
+      const toolLabel = normalizeToolLabel(part);
+      const time = part.time_created ?? message.time_created;
+      const currentToolIndex = toolIndex;
+      toolIndex += 1;
+      for (const { kind, path } of extractFileToolOperations(part)) {
+        occurrences.push({
+          path,
+          kind,
+          time,
+          tool_label: toolLabel,
+          message_index: messageIndex,
+          tool_index: currentToolIndex
+        });
+      }
+    }
+  });
+  return occurrences;
+}
+function summarizeFileActivity(agentName, sessionId, projectIdentityKey, occurrences) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const occurrence of occurrences) {
+    const key = `${occurrence.kind}\0${occurrence.path}`;
+    const current = grouped.get(key);
+    if (current) {
+      current.count += 1;
+      current.latestTime = Math.max(current.latestTime, occurrence.time);
+      continue;
+    }
+    grouped.set(key, {
+      reference: { agentName, sessionId },
+      projectIdentityKey,
+      path: occurrence.path,
+      kind: occurrence.kind,
+      count: 1,
+      latestTime: occurrence.time
+    });
+  }
+  return [...grouped.values()].sort((a, b) => {
+    if (b.latestTime !== a.latestTime) return b.latestTime - a.latestTime;
+    return a.path.localeCompare(b.path);
+  });
+}
+function extractSessionFileActivity(agentName, sessionId, projectIdentityKey, messages) {
+  return summarizeFileActivity(
+    agentName,
+    sessionId,
+    projectIdentityKey,
+    extractFileActivityOccurrences(messages)
+  );
+}
+
+// ../core/dist/chunk-WABZHIV5.mjs
+import { chmodSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { basename, dirname, join } from "path";
+var diagnostics = null;
+function toSafeSink(sink) {
+  return {
+    info(event, detail) {
+      try {
+        sink.info?.(event, detail);
+      } catch {
+      }
+    },
+    warn(event, detail) {
+      try {
+        sink.warn(event, detail);
+      } catch {
+      }
+    }
+  };
+}
+function setCoreDiagnostics(next) {
+  diagnostics = next ? toSafeSink(next) : null;
+}
+function getCoreDiagnostics() {
+  return diagnostics;
+}
+var PRIVATE_DIR_MODE = 448;
+var PRIVATE_FILE_MODE = 384;
+var SQLITE_SIDECAR_SUFFIXES = ["-wal", "-shm", "-journal"];
+var isPosix = process.platform !== "win32";
+function reportChmodFailure(path, error) {
+  getCoreDiagnostics()?.warn("storage.permissions_failed", {
+    path,
+    message: error instanceof Error ? error.message : String(error)
+  });
+}
+function restrict(path, mode) {
+  if (!isPosix || !existsSync(path)) return;
+  try {
+    if ((statSync(path).mode & 511) === mode) return;
+    chmodSync(path, mode);
+  } catch (error) {
+    reportChmodFailure(path, error);
+  }
+}
+function ensurePrivateDirectory(path) {
+  mkdirSync(path, { recursive: true, mode: PRIVATE_DIR_MODE });
+  restrict(path, PRIVATE_DIR_MODE);
+}
+function restrictPrivateFile(path) {
+  restrict(path, PRIVATE_FILE_MODE);
+}
+function restrictExistingPrivateFiles(directory, owns) {
+  try {
+    for (const entry of readdirSync(directory)) {
+      if (owns(entry)) restrictPrivateFile(join(directory, entry));
+    }
+  } catch (error) {
+    reportChmodFailure(directory, error);
+  }
+}
+var sweptBackupsFor = /* @__PURE__ */ new Set();
+function restrictExistingBackups(dbPath) {
+  if (sweptBackupsFor.has(dbPath)) return;
+  sweptBackupsFor.add(dbPath);
+  const prefix = `${basename(dbPath)}.`;
+  restrictExistingPrivateFiles(
+    dirname(dbPath),
+    (name) => name.startsWith(prefix) && name.endsWith(".bak")
+  );
+}
+function restrictPrivateDatabase(dbPath) {
+  restrictPrivateFile(dbPath);
+  for (const suffix of SQLITE_SIDECAR_SUFFIXES) restrictPrivateFile(`${dbPath}${suffix}`);
+  restrictExistingBackups(dbPath);
+}
+
+// ../core/dist/chunk-3JGIS7MJ.mjs
+import { createHash } from "crypto";
+import { existsSync as existsSync2, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { AsyncLocalStorage } from "async_hooks";
+var snapshot_default = {
+  "claude-3-5-haiku": [8e-7, 4e-6, 1e-6, 8e-8],
+  "claude-3-5-sonnet": [3e-6, 15e-6, 375e-8, 3e-7],
+  "claude-3-7-sonnet": [3e-6, 15e-6, 375e-8, 3e-7],
+  "claude-haiku-4-5": [1e-6, 5e-6, 125e-8, 1e-7],
+  "claude-sonnet-4": [3e-6, 15e-6, 375e-8, 3e-7],
+  "claude-sonnet-4-5": [3e-6, 15e-6, 375e-8, 3e-7],
+  "claude-sonnet-4-6": [3e-6, 15e-6, 375e-8, 3e-7],
+  "claude-opus-4": [15e-6, 75e-6, 1875e-8, 15e-7],
+  "claude-opus-4-1": [15e-6, 75e-6, 1875e-8, 15e-7],
+  "claude-opus-4-5": [5e-6, 25e-6, 625e-8, 5e-7],
+  "claude-opus-4-6": [5e-6, 25e-6, 625e-8, 5e-7],
+  "claude-opus-4-7": [5e-6, 25e-6, 625e-8, 5e-7],
+  "anthropic/claude-sonnet-4-5": [3e-6, 15e-6, 375e-8, 3e-7],
+  "anthropic/claude-sonnet-4-6": [3e-6, 15e-6, 375e-8, 3e-7],
+  "anthropic/claude-opus-4-6": [5e-6, 25e-6, 625e-8, 5e-7],
+  "gpt-4.1": [2e-6, 8e-6, null, 5e-7],
+  "gpt-4.1-mini": [4e-7, 16e-7, null, 1e-7],
+  "gpt-4.1-nano": [1e-7, 4e-7, null, 25e-9],
+  "gpt-4o": [25e-7, 1e-5, null, 125e-8],
+  "gpt-4o-mini": [15e-8, 6e-7, null, 75e-9],
+  "gpt-5": [125e-8, 1e-5, null, 125e-9],
+  "gpt-5.1": [125e-8, 1e-5, null, 125e-9],
+  "gpt-5.1-codex": [125e-8, 1e-5, null, 125e-9],
+  "gpt-5.1-codex-mini": [25e-8, 2e-6, null, 25e-9],
+  "gpt-5.2": [175e-8, 14e-6, null, 175e-9],
+  "gpt-5.2-codex": [175e-8, 14e-6, null, 175e-9],
+  "gpt-5.3-codex": [175e-8, 14e-6, null, 175e-9],
+  "gpt-5.4": [25e-7, 15e-6, null, 25e-8],
+  "gpt-5.4-mini": [75e-8, 45e-7, null, 75e-9],
+  "gpt-5.4-nano": [2e-7, 125e-8, null, 2e-8],
+  "gpt-5.5": [5e-6, 3e-5, null, 5e-7],
+  "gpt-5-mini": [25e-8, 2e-6, null, 25e-9],
+  "gpt-5-nano": [5e-8, 4e-7, null, 5e-9],
+  "moonshotai/kimi-k2-0905": [6e-7, 25e-7, null, null],
+  "moonshotai/kimi-k2-instruct": [57e-8, 23e-7, null, null],
+  "moonshotai/kimi-k2-thinking": [6e-7, 25e-7, null, null],
+  "deepseek-chat": [28e-8, 42e-8, null, 28e-9],
+  "deepseek-reasoner": [28e-8, 42e-8, null, 28e-9],
+  "qwen3-coder-480b-a35b-instruct": [3e-7, 13e-7, null, null],
+  "gemini-2.5-pro": [125e-8, 1e-5, null, 125e-9],
+  "gemini-2.5-flash": [3e-7, 25e-7, null, 3e-8]
+};
+var LITELLM_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var WEB_SEARCH_COST = 0.01;
+var REFRESH_TIMEOUT_MS = 1e4;
+var published = createPricingGeneration(loadSnapshot());
+var pending = null;
+published = readDiskCache() ?? published;
+function normalizeModelKey(key) {
+  return key.trim().toLowerCase().replaceAll("_", "-");
+}
+function createPricingGeneration(pricing) {
+  const hash = createHash("sha256");
+  const entries = [...pricing.entries()].sort(
+    ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
+  );
+  for (const [name, modelPricing] of entries) {
+    hash.update(name);
+    hash.update("\0");
+    hash.update(JSON.stringify(modelPricing));
+    hash.update("\n");
+  }
+  return {
+    id: Number.parseInt(hash.digest("hex").slice(0, 13), 16) || 1,
+    pricing
+  };
+}
+function costNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function getCacheDir() {
+  return join2(homedir(), ".cache", "codesesh");
+}
+function getCachePath() {
+  return join2(getCacheDir(), "litellm-pricing.json");
+}
+function loadSnapshot() {
+  const map = /* @__PURE__ */ new Map();
+  const snapshot = snapshot_default;
+  for (const [name, entry] of Object.entries(snapshot)) {
+    const [input, output, cacheCreate, cacheRead, reasoning, webSearch] = entry;
+    indexPricing(map, name, {
+      inputCostPerToken: input,
+      outputCostPerToken: output,
+      cacheCreateCostPerToken: cacheCreate ?? input * 1.25,
+      cacheReadCostPerToken: cacheRead ?? input * 0.1,
+      reasoningCostPerToken: reasoning ?? output,
+      webSearchCostPerRequest: webSearch ?? WEB_SEARCH_COST
+    });
+  }
+  return map;
+}
+function parseLiteLLMEntry(entry) {
+  const input = entry.input_cost_per_token;
+  const output = entry.output_cost_per_token;
+  if (typeof input !== "number" || typeof output !== "number") return null;
+  return {
+    inputCostPerToken: input,
+    outputCostPerToken: output,
+    cacheCreateCostPerToken: entry.cache_creation_input_token_cost ?? input * 1.25,
+    cacheReadCostPerToken: entry.cache_read_input_token_cost ?? input * 0.1,
+    reasoningCostPerToken: entry.output_reasoning_cost_per_token ?? output,
+    webSearchCostPerRequest: costNumber(
+      entry.web_search_cost_per_request ?? entry.search_context_cost_per_query,
+      WEB_SEARCH_COST
+    )
+  };
+}
+function normalizeCachedPricing(raw) {
+  const input = costNumber(raw["inputCostPerToken"], 0);
+  const output = costNumber(raw["outputCostPerToken"], 0);
+  if (input <= 0 || output <= 0) return null;
+  return {
+    inputCostPerToken: input,
+    outputCostPerToken: output,
+    cacheCreateCostPerToken: costNumber(raw["cacheCreateCostPerToken"], input * 1.25),
+    cacheReadCostPerToken: costNumber(raw["cacheReadCostPerToken"], input * 0.1),
+    reasoningCostPerToken: costNumber(raw["reasoningCostPerToken"], output),
+    webSearchCostPerRequest: costNumber(raw["webSearchCostPerRequest"], WEB_SEARCH_COST)
+  };
+}
+function indexPricing(map, name, pricing) {
+  const normalized = normalizeModelKey(name);
+  map.set(normalized, pricing);
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex >= 0) {
+    const stripped = normalized.slice(slashIndex + 1);
+    if (!map.has(stripped)) map.set(stripped, pricing);
+  }
+}
+function parseLiteLLMData(data) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [name, entry] of Object.entries(data)) {
+    const pricing = parseLiteLLMEntry(entry);
+    if (pricing) indexPricing(map, name, pricing);
+  }
+  return map;
+}
+function readDiskCache() {
+  const path = getCachePath();
+  if (!existsSync2(path)) return null;
+  try {
+    const cached = JSON.parse(readFileSync(path, "utf-8"));
+    if (!Number.isFinite(cached.timestamp)) return null;
+    if (cached.data == null || typeof cached.data !== "object" || Array.isArray(cached.data)) {
+      return null;
+    }
+    const next = loadSnapshot();
+    for (const [name, rawPricing] of Object.entries(cached.data)) {
+      const pricing = normalizeCachedPricing(rawPricing);
+      if (!pricing) continue;
+      indexPricing(next, name, pricing);
+    }
+    return createPricingGeneration(next);
+  } catch {
+    return null;
+  }
+}
+function getPricingRegistry() {
+  return published.pricing;
+}
+function getPricingGeneration() {
+  return published;
+}
+function synchronizePricingGeneration(expectedId) {
+  if (!Number.isSafeInteger(expectedId) || expectedId < 1) {
+    throw new Error(`Invalid pricing generation: ${expectedId}`);
+  }
+  if (published.id === expectedId) return;
+  const cached = readDiskCache();
+  if (cached?.id !== expectedId) {
+    throw new Error(
+      `Pricing generation ${expectedId} is unavailable (current ${published.id}, cached ${cached?.id ?? "none"})`
+    );
+  }
+  published = cached;
+  getCoreDiagnostics()?.info?.("pricing.generation.synchronized", {
+    generation: published.id,
+    models: published.pricing.size
+  });
+}
+function publishPendingPricing() {
+  if (!pending) return false;
+  const next = createPricingGeneration(pending);
+  if (!writeDiskCacheAtomically(getCachePath(), next)) return false;
+  published = next;
+  pending = null;
+  getCoreDiagnostics()?.info?.("pricing.generation.published", {
+    generation: published.id,
+    models: published.pricing.size
+  });
+  return true;
+}
+function hasBillablePricing(pricing) {
+  return pricing.inputCostPerToken > 0 || pricing.outputCostPerToken > 0 || pricing.cacheReadCostPerToken > 0 || pricing.cacheCreateCostPerToken > 0;
+}
+function writeDiskCacheAtomically(path, generation) {
+  const temporaryPath = `${path}.${process.pid}.tmp`;
+  const payload = JSON.stringify({
+    timestamp: Date.now(),
+    data: Object.fromEntries(generation.pricing)
+  });
+  try {
+    ensurePrivateDirectory(getCacheDir());
+    writeFileSync(temporaryPath, payload);
+    restrictPrivateFile(temporaryPath);
+    renameSync(temporaryPath, path);
+    return true;
+  } catch (error) {
+    rmSync(temporaryPath, { force: true });
+    getCoreDiagnostics()?.warn("pricing.cache_write_failed", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+async function refreshPricingCache(options = {}) {
+  const path = getCachePath();
+  if (existsSync2(path)) {
+    try {
+      const cached = JSON.parse(readFileSync(path, "utf-8"));
+      if (typeof cached.timestamp === "number" && Date.now() - cached.timestamp <= CACHE_TTL_MS) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  const timeout = AbortSignal.timeout(options.timeoutMs ?? REFRESH_TIMEOUT_MS);
+  const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+  getCoreDiagnostics()?.info?.("pricing.refresh.started", { generation: published.id });
+  try {
+    const response = await fetch(LITELLM_URL, { signal });
+    if (!response.ok) return false;
+    const data = await response.json();
+    const remote = parseLiteLLMData(data);
+    if (remote.size === 0) return false;
+    const next = loadSnapshot();
+    for (const [name, pricing] of remote.entries()) {
+      next.set(name, pricing);
+    }
+    pending = next;
+    getCoreDiagnostics()?.info?.("pricing.refresh.completed", {
+      generation: published.id,
+      models: next.size
+    });
+    return true;
+  } catch (error) {
+    getCoreDiagnostics()?.warn("pricing.refresh.failed", {
+      generation: published.id,
+      aborted: signal.aborted,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+var aliases_default = {
+  "anthropic--claude-4.6-opus": "claude-opus-4-6",
+  "anthropic--claude-4.6-sonnet": "claude-sonnet-4-6",
+  "claude-4.6-sonnet": "claude-sonnet-4-6",
+  "anthropic--claude-4.5-opus": "claude-opus-4-5",
+  "anthropic--claude-4.5-sonnet": "claude-sonnet-4-5",
+  "anthropic--claude-4.5-haiku": "claude-haiku-4-5",
+  "claude-4.5-sonnet-thinking": "claude-sonnet-4-5",
+  "claude-4-sonnet-thinking": "claude-sonnet-4-5",
+  "claude-4-opus": "claude-opus-4-5",
+  "cursor-auto": "claude-sonnet-4-5",
+  "cursor-agent-auto": "claude-sonnet-4-5",
+  "copilot-auto": "claude-sonnet-4-5",
+  "copilot-openai-auto": "gpt-5.3-codex",
+  "copilot-anthropic-auto": "claude-sonnet-4-5",
+  "kimi-for-coding": "moonshotai/kimi-k2-0905",
+  "kimi-k2.5": "moonshotai/kimi-k2-0905",
+  "moonshot-cn/kimi-k2.5": "moonshotai/kimi-k2-0905",
+  "gpt-5-codex": "gpt-5",
+  "gpt-5.1-codex-high": "gpt-5.3-codex",
+  "gpt-5.2-low": "gpt-5.2"
+};
+var BUILTIN_ALIASES = Object.fromEntries(
+  Object.entries(aliases_default).map(([key, value]) => [
+    normalizeModelKey(key),
+    normalizeModelKey(value)
+  ])
+);
+function stripVersion(model) {
+  return model.replace(/@.*$/, "").replace(/-\d{8}$/, "");
+}
+function stripProviderPrefix(model) {
+  const parts = model.split("/");
+  return parts[parts.length - 1] ?? model;
+}
+function resolveAlias(model) {
+  return BUILTIN_ALIASES[model] ?? model;
+}
+function getCandidates(rawModel) {
+  const withPrefix = stripVersion(normalizeModelKey(rawModel));
+  const stripped = stripProviderPrefix(withPrefix);
+  const aliased = resolveAlias(stripped);
+  const candidates = [
+    withPrefix,
+    resolveAlias(withPrefix),
+    stripped,
+    aliased,
+    `anthropic/${stripped}`,
+    `openai/${stripped}`,
+    `openrouter/openai/${stripped}`,
+    `openrouter/anthropic/${stripped}`,
+    `moonshotai/${stripped}`,
+    `novita/moonshotai/${stripped}`
+  ];
+  return [...new Set(candidates.filter(Boolean))];
+}
+function lookupCandidate(model, registry) {
+  const direct = registry.get(model);
+  if (direct && hasBillablePricing(direct)) return direct;
+  const alias = resolveAlias(model);
+  if (alias !== model) {
+    const aliased = registry.get(alias);
+    if (aliased && hasBillablePricing(aliased)) return aliased;
+  }
+  return null;
+}
+function fuzzyLookup(model, registry) {
+  let best = null;
+  for (const [key, pricing] of registry.entries()) {
+    if (!hasBillablePricing(pricing)) continue;
+    if (model.startsWith(`${key}-`) || model.startsWith(`${key}@`) || model === key) {
+      if (!best || key.length > best[0].length) best = [key, pricing];
+    }
+  }
+  return best?.[1] ?? null;
+}
+var pricingResolver = {
+  resolve(rawModelName) {
+    const registry = getPricingRegistry();
+    const candidates = getCandidates(rawModelName);
+    for (const candidate of candidates) {
+      const pricing = lookupCandidate(candidate, registry);
+      if (pricing) return pricing;
+    }
+    for (const candidate of candidates) {
+      const pricing = fuzzyLookup(candidate, registry);
+      if (pricing) return pricing;
+    }
+    return null;
+  }
+};
+function positive(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+var pricingMissCapture = new AsyncLocalStorage();
+var PRICING_CAPTURE_EPOCH = "pricing-capture-v1";
+function pricingBecameAvailable(unpricedModels) {
+  if (!Array.isArray(unpricedModels)) return false;
+  return unpricedModels.some(
+    (model) => typeof model === "string" && pricingResolver.resolve(model) !== null
+  );
+}
+function capturePricingMisses(run) {
+  const capture = /* @__PURE__ */ new Set();
+  const result = pricingMissCapture.run(capture, run);
+  if (result instanceof Promise) {
+    return result.then((resolved) => ({ result: resolved, unpricedModels: [...capture] }));
+  }
+  return { result, unpricedModels: [...capture] };
+}
+function estimateCostForTokens(model, usage) {
+  if (!model || !usage) return null;
+  const pricing = pricingResolver.resolve(model);
+  if (!pricing) {
+    pricingMissCapture.getStore()?.add(model);
+    return null;
+  }
+  const cacheRead = positive(usage.cache_read);
+  const cacheCreate = positive(usage.cache_create);
+  const input = Math.max(0, positive(usage.input) - cacheRead - cacheCreate);
+  const output = positive(usage.output);
+  const reasoning = positive(usage.reasoning);
+  const webSearchRequests = positive(usage.web_search_requests);
+  const cost = input * pricing.inputCostPerToken + output * pricing.outputCostPerToken + reasoning * pricing.reasoningCostPerToken + cacheRead * pricing.cacheReadCostPerToken + cacheCreate * pricing.cacheCreateCostPerToken + webSearchRequests * pricing.webSearchCostPerRequest;
+  return cost > 0 ? { cost: Number(cost.toFixed(8)), source: "estimated" } : null;
+}
+
+// ../core/dist/chunk-326ZXYCY.mjs
+import { closeSync, openSync, readSync } from "fs";
+import { StringDecoder } from "string_decoder";
+import { basename as basename2 } from "path";
+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 READ_CHUNK_BYTES = 1 << 20;
+function* parseJsonlLines(content) {
+  let total = 0;
+  let skipped = 0;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    total += 1;
+    try {
+      yield JSON.parse(trimmed);
+    } catch {
+      skipped += 1;
+    }
+  }
+  if (skipped > 0) {
+    getCoreDiagnostics()?.warn("agent.jsonl_lines_skipped", { skipped, total });
+  }
+}
+function* readJsonlFileLines(filePath, chunkBytes = READ_CHUNK_BYTES) {
+  const fd = openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(chunkBytes);
+    const decoder = new StringDecoder("utf8");
+    let pending2 = [];
+    let bytesRead = readSync(fd, buffer, 0, chunkBytes, -1);
+    while (bytesRead > 0) {
+      const decoded = decoder.write(buffer.subarray(0, bytesRead));
+      const lastBreak = decoded.lastIndexOf("\n");
+      if (lastBreak === -1) {
+        if (decoded) pending2.push(decoded);
+      } else {
+        pending2.push(decoded.slice(0, lastBreak));
+        const complete = pending2.join("");
+        pending2 = [decoded.slice(lastBreak + 1)];
+        for (const line of complete.split("\n")) {
+          const trimmed = line.trim();
+          if (trimmed) yield trimmed;
+        }
+      }
+      bytesRead = readSync(fd, buffer, 0, chunkBytes, -1);
+    }
+    pending2.push(decoder.end());
+    const tail = pending2.join("").trim();
+    if (tail) yield tail;
+  } finally {
+    closeSync(fd);
+  }
+}
+function* readJsonlFile(filePath) {
+  let total = 0;
+  let skipped = 0;
+  for (const line of readJsonlFileLines(filePath)) {
+    total += 1;
+    try {
+      yield JSON.parse(line);
+    } catch {
+      skipped += 1;
+    }
+  }
+  if (skipped > 0) {
+    getCoreDiagnostics()?.warn("agent.jsonl_lines_skipped", { skipped, total, filePath });
+  }
+}
+var INTERNAL_BLOCK_TAGS = [
+  "command-message",
+  "command-name",
+  "local-command-caveat",
+  "local-command-stdout",
+  "system-reminder"
+];
+var TRANSPARENT_TAGS = ["command-args"];
+var INTERNAL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "progress",
+  "file history snapshot",
+  "file-history snapshot",
+  "file_history snapshot",
+  "queue operation",
+  "queue-operation",
+  "queue_operation",
+  "last prompt",
+  "last-prompt",
+  "last_prompt"
+]);
+function blockTagPattern(tag) {
+  return new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, "gi");
+}
+function blockTagLinePattern(tag) {
+  return new RegExp(
+    `(^|\\r?\\n)[ \\t]*<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>[ \\t]*(?:\\r?\\n|$)`,
+    "gi"
+  );
+}
+function openBlockTagPattern(tag) {
+  return new RegExp(`\\n*<${tag}\\b[^>]*>[\\s\\S]*$`, "gi");
+}
+function looseTagPattern(tag) {
+  return new RegExp(`<\\/?${tag}\\b[^>]*>`, "gi");
+}
+function isInternalEventType(value) {
+  if (typeof value !== "string") return false;
+  const normalized = value.trim().toLowerCase().replace(/[_-]+/g, " ");
+  return INTERNAL_EVENT_TYPES.has(normalized);
+}
+function cleanDisplayText(text) {
+  let cleaned = text;
+  for (const tag of INTERNAL_BLOCK_TAGS) {
+    cleaned = cleaned.replace(blockTagLinePattern(tag), "$1");
+    cleaned = cleaned.replace(blockTagPattern(tag), "");
+    cleaned = cleaned.replace(openBlockTagPattern(tag), "");
+  }
+  for (const tag of INTERNAL_BLOCK_TAGS) {
+    cleaned = cleaned.replace(looseTagPattern(tag), "");
+  }
+  for (const tag of TRANSPARENT_TAGS) {
+    cleaned = cleaned.replace(looseTagPattern(tag), "");
+  }
+  cleaned = cleaned.replace(/[ \t]+(?=\r?\n|$)/g, "").replace(/(?:\r?\n)+$/g, "");
+  return cleaned.trim() ? cleaned : null;
+}
+var TITLE_MAX_LENGTH = 100;
+var UNTITLED_SESSION = "Untitled Session";
+function normalizeTitleText(text) {
+  const visible = cleanDisplayText(text)?.split("\n").find((line) => line.trim())?.trim() ?? null;
+  if (!visible) return null;
+  const cleaned = visible.replace(/\s+/g, " ").trim();
+  if (!cleaned) return null;
+  return cleaned.slice(0, TITLE_MAX_LENGTH);
+}
+function basenameTitle(path) {
+  if (!path) return null;
+  const normalized = path.trim().replace(/[/\\]+$/, "");
+  if (!normalized) return null;
+  const name = basename2(normalized).trim();
+  return name || null;
+}
+function resolveSessionTitle(explicit, message, directory) {
+  for (const candidate of [explicit, message, directory]) {
+    if (candidate) {
+      const normalized = normalizeTitleText(candidate);
+      if (normalized) return normalized;
+    }
+  }
+  return UNTITLED_SESSION;
+}
+function estimateTokenCost(model, tokens) {
+  return estimateCostForTokens(model, tokens)?.cost ?? null;
+}
+function asRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return void 0;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function safeParseJsonRecord(json) {
+  let raw;
+  try {
+    raw = JSON.parse(json);
+  } catch {
+    return void 0;
+  }
+  return asRecord(raw);
+}
+var reportedFieldMismatches = /* @__PURE__ */ new Set();
+function reportFieldMismatch(agentName, field) {
+  const key = `${agentName}\0${field}`;
+  if (reportedFieldMismatches.has(key)) return;
+  reportedFieldMismatches.add(key);
+  getCoreDiagnostics()?.warn("agent.field_shape_mismatch", { agentName, field });
+}
+function narrowField(agent, field, value, narrow) {
+  if (value === void 0 || value === null) return void 0;
+  const result = narrow(value);
+  if (result === void 0) reportFieldMismatch(agent, field);
+  return result;
+}
+function isInternalEventType2(value) {
+  return isInternalEventType(value);
+}
+function cleanInternalText(text) {
+  return cleanDisplayText(text) ?? "";
+}
+function cleanUnknown(value) {
+  if (typeof value === "string") return cleanInternalText(value);
+  if (Array.isArray(value)) return value.map(cleanUnknown);
+  if (!value || typeof value !== "object") return value;
+  const cleaned = {};
+  for (const [key, child] of Object.entries(value)) {
+    cleaned[key] = cleanUnknown(child);
+  }
+  return cleaned;
+}
+function cleanMessagePart(part) {
+  if (part.type === "text" || part.type === "reasoning" || part.type === "plan") {
+    const text = cleanInternalText(part.text);
+    return text ? { ...part, text } : null;
+  }
+  if (part.type !== "tool") return part;
+  const title = part.title ? cleanInternalText(part.title) : "";
+  const state = {
+    ...part.state,
+    ...part.state.input !== void 0 ? { input: cleanUnknown(part.state.input) } : {},
+    ...part.state.output !== void 0 ? { output: cleanUnknown(part.state.output) } : {},
+    ...part.state.error !== void 0 ? { error: cleanUnknown(part.state.error) } : {},
+    ...part.state.metadata !== void 0 ? { metadata: cleanUnknown(part.state.metadata) } : {}
+  };
+  const { title: _title, ...withoutTitle } = part;
+  return {
+    ...withoutTitle,
+    ...title ? { title } : {},
+    state
+  };
+}
+function cleanMessageParts(parts) {
+  return parts.flatMap((part) => {
+    const cleaned = cleanMessagePart(part);
+    return cleaned ? [cleaned] : [];
+  });
+}
+function cleanParsedMessage(message) {
+  const parts = cleanMessageParts(message.parts);
+  if (parts.length === 0) return null;
+  return { ...message, parts };
+}
+function cleanParsedMessages(messages) {
+  return messages.flatMap((message) => {
+    const cleaned = cleanParsedMessage(message);
+    return cleaned ? [cleaned] : [];
+  });
+}
+function firstUserMessageTitle(messages) {
+  for (const message of messages) {
+    if (message.role !== "user") continue;
+    for (const part of message.parts) {
+      if (part.type !== "text") continue;
+      const title = normalizeTitleText(cleanInternalText(part.text));
+      if (title) return title;
+    }
+  }
+  return null;
+}
+
+// ../core/dist/chunk-BAU7ZBXA.mjs
+import { existsSync as existsSync3 } from "fs";
+import { basename as basename3, dirname as dirname2, join as join3 } from "path";
+import { createRequire } from "module";
+var SQLITE_BUSY_TIMEOUT_MS = 5e3;
+var DatabaseConstructor = null;
+var loadErrorMessage = null;
+try {
+  const require2 = createRequire(import.meta.url);
+  const mod = require2("better-sqlite3");
+  DatabaseConstructor = typeof mod === "function" ? mod : mod.default;
+} catch (error) {
+  loadErrorMessage = error instanceof Error ? error.message : String(error);
+}
+var unavailableReported = false;
+function reportUnavailableOnce() {
+  if (unavailableReported) return;
+  unavailableReported = true;
+  getCoreDiagnostics()?.warn("sqlite.unavailable", { message: loadErrorMessage });
+}
+var SchemaMigrationPlanError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SchemaMigrationPlanError";
+  }
+};
+function validateSchemaVersion(value, label) {
+  if (Number.isSafeInteger(value) && value >= 0) return;
+  throw new SchemaMigrationPlanError(`${label} must be a non-negative safe integer`);
+}
+function validateMigrationPlan(options) {
+  let previousVersion = -1;
+  let reachesTarget = false;
+  for (const migration of options.migrations) {
+    if (!Number.isSafeInteger(migration.version) || migration.version < 0) {
+      throw new SchemaMigrationPlanError(
+        `${options.backupLabel} migration version must be a non-negative safe integer`
+      );
+    }
+    if (migration.version <= previousVersion) {
+      throw new SchemaMigrationPlanError(
+        `${options.backupLabel} migrations must be ordered by strictly increasing version`
+      );
+    }
+    previousVersion = migration.version;
+    reachesTarget ||= migration.version === options.targetVersion;
+  }
+  if (!reachesTarget) {
+    throw new SchemaMigrationPlanError(
+      `${options.backupLabel} has no migration for target version ${options.targetVersion}`
+    );
+  }
+}
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function quoteSqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function isInMemoryPath(dbPath) {
+  return dbPath === ":memory:" || dbPath.startsWith("file::memory:") || dbPath.includes("mode=memory");
+}
+function getUserVersion(db) {
+  const row = db.prepare("PRAGMA user_version").get();
+  return Number(row?.user_version ?? 0);
+}
+function setUserVersion(db, version) {
+  db.exec(`PRAGMA user_version = ${Math.trunc(version)}`);
+}
+function tableExists(db, tableName) {
+  const row = db.prepare(
+    `
+        SELECT 1 AS value
+        FROM sqlite_master
+        WHERE name = ? AND type IN ('table', 'view')
+        LIMIT 1
+      `
+  ).get(tableName);
+  return row !== void 0;
+}
+function columnExists(db, tableName, columnName) {
+  if (!tableExists(db, tableName)) {
+    return false;
+  }
+  const rows = db.prepare(`PRAGMA table_info(${quoteIdentifier(tableName)})`).all();
+  return rows.some((row) => String(row.name) === columnName);
+}
+function tableHasRows(db, tableName) {
+  if (!tableExists(db, tableName)) {
+    return false;
+  }
+  const row = db.prepare(`SELECT 1 AS value FROM ${quoteIdentifier(tableName)} LIMIT 1`).get();
+  return row !== void 0;
+}
+function backupDatabase(db, dbPath, label) {
+  if (isInMemoryPath(dbPath)) {
+    return null;
+  }
+  const timestamp = new Date(Date.now()).toISOString().replaceAll(":", "").replaceAll(".", "-");
+  let backupPath = join3(dirname2(dbPath), `${basename3(dbPath)}.${timestamp}.${label}.bak`);
+  for (let counter = 1; existsSync3(backupPath); counter += 1) {
+    backupPath = join3(dirname2(dbPath), `${basename3(dbPath)}.${timestamp}.${label}.${counter}.bak`);
+  }
+  db.exec(`VACUUM INTO ${quoteSqlString(backupPath)}`);
+  restrictPrivateFile(backupPath);
+  return backupPath;
+}
+function backupDatabaseIfPopulated(db, dbPath, label, tables) {
+  if (!tables.some((table) => tableHasRows(db, table))) {
+    return null;
+  }
+  return backupDatabase(db, dbPath, label);
+}
+function runSchemaMigrations(db, options) {
+  const backups = [];
+  let currentVersion = options.currentVersion;
+  validateSchemaVersion(currentVersion, `${options.backupLabel} current version`);
+  validateSchemaVersion(options.targetVersion, `${options.backupLabel} target version`);
+  if (currentVersion >= options.targetVersion) return backups;
+  validateMigrationPlan(options);
+  for (const migration of options.migrations) {
+    if (migration.version <= currentVersion) {
+      continue;
+    }
+    if (migration.version > options.targetVersion) {
+      break;
+    }
+    const fromVersion = currentVersion;
+    const startedAt = performance.now();
+    getCoreDiagnostics()?.info?.("sqlite.migration.started", {
+      label: options.backupLabel,
+      from_version: fromVersion,
+      to_version: migration.version,
+      destructive: migration.destructive ?? false
+    });
+    try {
+      let backupCreated = false;
+      if (migration.destructive) {
+        const backupPath = backupDatabaseIfPopulated(
+          db,
+          options.dbPath,
+          options.backupLabel,
+          options.backupTables
+        );
+        if (backupPath) {
+          backups.push(backupPath);
+          backupCreated = true;
+        }
+      }
+      const apply = db.transaction(() => {
+        migration.migrate(db);
+        setUserVersion(db, migration.version);
+      });
+      apply.immediate();
+      currentVersion = migration.version;
+      getCoreDiagnostics()?.info?.("sqlite.migration.completed", {
+        label: options.backupLabel,
+        from_version: fromVersion,
+        to_version: migration.version,
+        destructive: migration.destructive ?? false,
+        backup_created: backupCreated,
+        duration_ms: Math.round(performance.now() - startedAt)
+      });
+    } catch (error) {
+      getCoreDiagnostics()?.warn("sqlite.migration.failed", {
+        label: options.backupLabel,
+        from_version: fromVersion,
+        to_version: migration.version,
+        destructive: migration.destructive ?? false,
+        duration_ms: Math.round(performance.now() - startedAt),
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  if (currentVersion !== options.targetVersion) {
+    throw new SchemaMigrationPlanError(
+      `${options.backupLabel} stopped at version ${currentVersion}, expected ${options.targetVersion}`
+    );
+  }
+  return backups;
+}
+function openDbReadOnly(dbPath) {
+  if (!DatabaseConstructor) {
+    reportUnavailableOnce();
+    return null;
+  }
+  try {
+    const db = DatabaseConstructor(dbPath, { readonly: true });
+    try {
+      db.pragma(`busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS}`);
+    } catch {
+    }
+    return db;
+  } catch (error) {
+    getCoreDiagnostics()?.warn("sqlite.open_failed", {
+      dbPath,
+      readonly: true,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function openDb(dbPath) {
+  if (!DatabaseConstructor) {
+    reportUnavailableOnce();
+    return null;
+  }
+  try {
+    ensurePrivateDirectory(dirname2(dbPath));
+    if (!isInMemoryPath(dbPath)) process.env.SQLITE_TMPDIR ||= dirname2(dbPath);
+    const db = DatabaseConstructor(dbPath);
+    restrictPrivateDatabase(dbPath);
+    try {
+      db.pragma(`busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS}`);
+      db.pragma("journal_mode = WAL");
+      db.pragma("synchronous = NORMAL");
+      db.pragma("foreign_keys = ON");
+      db.pragma("temp_store = FILE");
+    } catch {
+    }
+    return db;
+  } catch (error) {
+    getCoreDiagnostics()?.warn("sqlite.open_failed", {
+      dbPath,
+      readonly: false,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function isSqliteAvailable() {
+  return DatabaseConstructor !== null;
+}
+
+// ../core/dist/chunk-PIUQAREY.mjs
+function toRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function optionalTime(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function timeField(time_created) {
+  return time_created === void 0 ? {} : { time_created };
+}
+function firstDefined(...values) {
+  return values.find((value) => value !== void 0);
+}
+function normalizeStatus(state, output, error) {
+  const status = state.status;
+  if (status === "running" || status === "completed" || status === "error") return status;
+  if (status === "success") return "completed";
+  if (error != null) return "error";
+  if (output !== void 0) return "completed";
+  return "running";
+}
+function normalizeMetadata(state) {
+  const rawMetadata = state.metadata ?? state.meta;
+  const extras = Object.fromEntries(
+    Object.entries(state).filter(
+      ([key]) => !["status", "input", "arguments", "output", "result", "error", "metadata", "meta"].includes(
+        key
+      )
+    )
+  );
+  if (Object.keys(extras).length === 0) return rawMetadata;
+  const metadata = toRecord2(rawMetadata);
+  return metadata ? { ...metadata, ...extras } : extras;
+}
+function normalizeToolState(value, legacyPart) {
+  const state = toRecord2(value) ?? {};
+  const input = firstDefined(state.input, state.arguments, legacyPart.input);
+  const output = firstDefined(state.output, state.result, legacyPart.output);
+  const error = state.error;
+  const metadata = normalizeMetadata(state);
+  return {
+    status: normalizeStatus(state, output, error),
+    ...input !== void 0 ? { input } : {},
+    ...output !== void 0 ? { output } : {},
+    ...error !== void 0 ? { error } : {},
+    ...metadata !== void 0 ? { metadata } : {}
+  };
+}
+function planText(value) {
+  if (typeof value === "string") return value;
+  const record = toRecord2(value);
+  if (!record) return "";
+  return planText(record.text ?? record.plan ?? record.content);
+}
+function normalizePlanPart(value, time_created) {
+  const approval_status = value.approval_status === "fail" ? "fail" : "success";
+  const text = planText(value.text ?? (approval_status === "fail" ? value.output : value.input));
+  return text ? { type: "plan", text, approval_status, ...timeField(time_created) } : null;
+}
+function normalizeImagePart(value, time_created) {
+  const data = optionalString(value.data);
+  const url = optionalString(value.url);
+  const mime_type = optionalString(value.mime_type);
+  if (data && mime_type) {
+    return {
+      type: "image",
+      data,
+      mime_type,
+      ...url ? { url } : {},
+      ...timeField(time_created)
+    };
+  }
+  if (url) {
+    return {
+      type: "image",
+      url,
+      ...data ? { data } : {},
+      ...mime_type ? { mime_type } : {},
+      ...timeField(time_created)
+    };
+  }
+  return null;
+}
+function normalizeToolPart(value, time_created) {
+  const title = optionalString(value.title);
+  const callID = optionalString(value.callID);
+  const tool = optionalString(value.tool)?.trim() || title?.replace(/^tool:\s*/i, "").trim();
+  if (!tool) return null;
+  return {
+    type: "tool",
+    tool,
+    ...title ? { title } : {},
+    ...callID ? { callID } : {},
+    state: normalizeToolState(value.state, value),
+    ...timeField(time_created)
+  };
+}
+function normalizeMessagePart(value) {
+  const part = toRecord2(value);
+  if (!part) return null;
+  const time_created = optionalTime(part.time_created);
+  if (part.type === "text" || part.type === "reasoning") {
+    if (typeof part.text !== "string") return null;
+    return { type: part.type, text: part.text, ...timeField(time_created) };
+  }
+  if (part.type === "plan") return normalizePlanPart(part, time_created);
+  if (part.type === "image") return normalizeImagePart(part, time_created);
+  if (part.type === "tool") return normalizeToolPart(part, time_created);
+  return null;
+}
+function normalizeMessageParts(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((part) => {
+    const normalized = normalizeMessagePart(part);
+    return normalized ? [normalized] : [];
+  });
+}
+
+// ../core/dist/chunk-IKDMAP3N.mjs
+var AGENT_CATALOG = [
+  {
+    name: "claudecode",
+    displayName: "Claude Code",
+    icon: "/icon/agent/claudecode.svg",
+    iconColored: true,
+    sourceKind: "filesystem",
+    resumeCommandPrefix: "claude --resume",
+    toolStrategy: "custom"
+  },
+  {
+    name: "cursor",
+    displayName: "Cursor",
+    icon: "/icon/agent/cursor.svg",
+    sourceKind: "sqlite",
+    resumeCommandPrefix: null,
+    toolStrategy: "custom"
+  },
+  {
+    name: "kimi",
+    displayName: "Kimi-Cli",
+    icon: "/icon/agent/kimi.svg",
+    sourceKind: "filesystem",
+    resumeCommandPrefix: "kimi -r",
+    toolStrategy: "custom"
+  },
+  {
+    name: "kimi-code",
+    displayName: "Kimi-Code",
+    icon: "/icon/agent/kimi.svg",
+    sourceKind: "filesystem",
+    resumeCommandPrefix: "kimi -r",
+    toolStrategy: "custom"
+  },
+  {
+    name: "codex",
+    displayName: "Codex",
+    icon: "/icon/agent/codex.svg",
+    sourceKind: "filesystem",
+    resumeCommandPrefix: "codex resume",
+    toolStrategy: "custom"
+  },
+  {
+    name: "grok",
+    displayName: "Grok",
+    icon: "/icon/agent/grok.svg",
+    sourceKind: "filesystem",
+    resumeCommandPrefix: "grok --resume",
+    toolStrategy: "custom"
+  },
+  {
+    name: "pi",
+    displayName: "Pi",
+    icon: "/icon/agent/pi.svg",
+    sourceKind: "filesystem",
+    resumeCommandPrefix: "pi --session",
+    toolStrategy: "custom"
+  },
+  {
+    name: "opencode",
+    displayName: "OpenCode",
+    icon: "/icon/agent/opencode.svg",
+    sourceKind: "sqlite",
+    resumeCommandPrefix: "opencode -s",
+    toolStrategy: "custom"
+  },
+  {
+    name: "zcode",
+    displayName: "ZCode",
+    icon: "/icon/agent/zcode.svg",
+    sourceKind: "sqlite",
+    resumeCommandPrefix: null,
+    toolStrategy: "custom"
+  },
+  {
+    name: "dsh",
+    displayName: "DSH",
+    icon: "/icon/agent/dsh.svg",
+    iconColored: true,
+    sourceKind: "filesystem",
+    // DSH delegates launch arguments to installation-specific profiles.
+    resumeCommandPrefix: null,
+    toolStrategy: "custom"
+  }
+];
+function getAgentCatalogEntry(name) {
+  const entry = AGENT_CATALOG.find((candidate) => candidate.name === name);
+  if (!entry) throw new Error(`Unknown agent catalog entry: ${name}`);
+  return entry;
+}
+
+export {
+  SMART_TAGS,
+  isSmartTag,
+  assertIdentifiedSessionHead,
+  toPublicSessionHead,
+  toPublicReferencedSessionHead,
+  SMART_TAG_CLASSIFIER_REVISION,
+  getSmartTagSourceTimestamp,
+  classifySessionTags,
+  WORKER_LOG_MESSAGE_TYPE,
+  isWorkerLogMessage,
+  normalizeSessionReference,
+  formatSessionReference,
+  getSessionReferenceKey,
+  createSessionIdentity,
+  assertSessionIdentity,
+  getSessionAgentKey,
+  sessionRoutePath,
+  mergeSessionsUpdatedEvents,
+  startOfCalendarDay,
+  addCalendarDays,
+  countCalendarDays,
+  toCalendarDayKey,
+  isProjectIdentityKind,
+  getProjectIdentityKey,
+  matchesProjectIdentity,
+  sortSessionsByActivity,
+  mergeSortedSessions,
+  createSessionIndex,
+  buildSessionTree,
+  filterSessionTreeByActivityWindow,
+  filterSessionTreeEntriesByActivityWindow,
+  createSessionProjectionContext,
+  extractSessionFileActivity,
+  setCoreDiagnostics,
+  getCoreDiagnostics,
+  ensurePrivateDirectory,
+  restrictPrivateFile,
+  restrictExistingPrivateFiles,
+  getPricingGeneration,
+  synchronizePricingGeneration,
+  publishPendingPricing,
+  refreshPricingCache,
+  PRICING_CAPTURE_EPOCH,
+  pricingBecameAvailable,
+  capturePricingMisses,
+  perf,
+  parseJsonlLines,
+  readJsonlFileLines,
+  readJsonlFile,
+  isInternalEventType,
+  normalizeTitleText,
+  basenameTitle,
+  resolveSessionTitle,
+  estimateTokenCost,
+  asRecord,
+  asString,
+  asNumber,
+  asArray,
+  safeParseJsonRecord,
+  reportFieldMismatch,
+  narrowField,
+  isInternalEventType2,
+  cleanInternalText,
+  cleanMessagePart,
+  cleanParsedMessages,
+  firstUserMessageTitle,
+  getUserVersion,
+  setUserVersion,
+  tableExists,
+  columnExists,
+  runSchemaMigrations,
+  openDbReadOnly,
+  openDb,
+  isSqliteAvailable,
+  normalizeMessageParts,
+  AGENT_CATALOG,
+  getAgentCatalogEntry
+};
+//# sourceMappingURL=chunk-W4PZHL2C.js.map