llm-usage-metrics 0.8.0 → 0.8.1

package/dist/index.js

@@ -6,11 +6,46 @@ import { isMainThread, workerData } from "worker_threads";
 // src/config/runtime-overrides.ts
 import { availableParallelism } from "os";
 
-// src/persistence/event-store.ts
-import { createHash } from "crypto";
+// src/persistence/event-store-administration.ts
 import { chmod, mkdir, open } from "fs/promises";
 import path2 from "path";
 
+// src/utils/as-record.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return value;
+}
+
+// src/cli/normalize-skipped-row-reasons.ts
+function toPositiveInteger(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return Math.trunc(value);
+}
+function normalizeSkippedRowReasons(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const record = asRecord(entry);
+    if (!record) {
+      return [];
+    }
+    const reason = typeof record.reason === "string" ? record.reason.trim() : "";
+    const count = toPositiveInteger(record.count);
+    if (!reason || count === void 0) {
+      return [];
+    }
+    return [{ reason, count }];
+  });
+}
+
 // src/utils/compare-by-code-point.ts
 function compareByCodePoint(left5, right4) {
   if (left5 === right4) {
@@ -273,42 +308,6 @@ function isPriceableEvent(event) {
   return hasBillableTokenBuckets(event);
 }
 
-// src/utils/as-record.ts
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function asRecord(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  return value;
-}
-
-// src/cli/normalize-skipped-row-reasons.ts
-function toPositiveInteger(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-    return void 0;
-  }
-  return Math.trunc(value);
-}
-function normalizeSkippedRowReasons(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.flatMap((entry) => {
-    const record = asRecord(entry);
-    if (!record) {
-      return [];
-    }
-    const reason = typeof record.reason === "string" ? record.reason.trim() : "";
-    const count = toPositiveInteger(record.count);
-    if (!reason || count === void 0) {
-      return [];
-    }
-    return [{ reason, count }];
-  });
-}
-
 // src/sources/opencode/node-sqlite-loader.ts
 import { createRequire } from "module";
 
@@ -379,83 +378,14 @@ function getUserCacheRootDir(env = process.env, platform = process.platform, hom
   return path.join(homedir, ".cache");
 }
 
-// src/persistence/event-store.ts
-var EVENT_STORE_SCHEMA_VERSION = "3";
-var MIGRATION_BATCH_SIZE = 5e3;
-var EVENT_STORE_OPEN_TIMEOUT_MS = 2e3;
-var CONTROL_CHARACTERS_PATTERN2 = new RegExp(String.raw`[\u0000-\u001F\u007F-\u009F]`, "u");
-var NORMALIZED_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
-var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-var FAST_PATH_REJECT = /* @__PURE__ */ Symbol("fast path reject");
-var loadEventStoreSqliteModule = () => loadNodeSqliteModule("Event store");
-var EventStoreSchemaVersionError = class extends Error {
-  schemaVersion;
-  constructor(schemaVersion) {
-    const versionLabel = schemaVersion ? `v${schemaVersion}` : "an unknown schema version";
-    super(
-      `Event store uses ${versionLabel}, which is not supported by this version of llm-usage-metrics (supports v${EVENT_STORE_SCHEMA_VERSION}); leaving store untouched`
-    );
-    this.name = "EventStoreSchemaVersionError";
-    this.schemaVersion = schemaVersion;
-  }
-};
-function createSchemaSql() {
-  return `
-CREATE TABLE IF NOT EXISTS meta (
-  key TEXT PRIMARY KEY,
-  value TEXT NOT NULL
-);
-CREATE TABLE IF NOT EXISTS files (
-  source TEXT NOT NULL,
-  file_path TEXT NOT NULL,
-  fingerprint TEXT NOT NULL,
-  skipped_rows INTEGER NOT NULL,
-  skipped_row_reasons TEXT,
-  ingested_at INTEGER NOT NULL,
-  PRIMARY KEY (source, file_path)
-);
-CREATE TABLE IF NOT EXISTS events (
-  id INTEGER PRIMARY KEY,
-  source TEXT NOT NULL,
-  file_path TEXT NOT NULL,
-  event_index INTEGER NOT NULL,
-  session_id TEXT NOT NULL,
-  timestamp TEXT NOT NULL,
-  model TEXT,
-  provider TEXT,
-  repo_root TEXT,
-  input_tokens INTEGER NOT NULL,
-  output_tokens INTEGER NOT NULL,
-  reasoning_tokens INTEGER NOT NULL,
-  cache_read_tokens INTEGER NOT NULL,
-  cache_write_tokens INTEGER NOT NULL,
-  total_tokens INTEGER NOT NULL,
-  content_hash TEXT,
-  cost_usd REAL,
-  cost_mode TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS events_file ON events(source, file_path, event_index);
-CREATE INDEX IF NOT EXISTS events_content_hash ON events(content_hash);
-`;
-}
+// src/persistence/event-store-codec.ts
+import { createHash } from "crypto";
+
+// src/persistence/event-store-database.ts
 function isEventStoreSqliteModule(value) {
   const moduleRecord = asRecord(value);
   return typeof moduleRecord?.DatabaseSync === "function";
 }
-function normalizeStoreSource(source) {
-  const normalizedSource = normalizeSourceId(source)?.toLowerCase();
-  if (!normalizedSource) {
-    throw new Error("Event store source must be a non-empty string");
-  }
-  return normalizedSource;
-}
-function normalizeStoreFilePath(filePath) {
-  const normalizedFilePath = filePath.trim();
-  if (!normalizedFilePath) {
-    throw new Error("Event store file path must be a non-empty string");
-  }
-  return normalizedFilePath;
-}
 function toNonNegativeInteger(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
     return void 0;
@@ -475,77 +405,22 @@ function toText(value) {
   const normalized = value.trim();
   return normalized || void 0;
 }
-function normalizeDependencyFingerprint(value) {
-  const dependencyPath = toText(value.path);
-  if (!dependencyPath) {
-    return void 0;
-  }
-  if (!value.exists) {
-    return {
-      path: dependencyPath,
-      exists: false
-    };
-  }
-  const size = toNonNegativeInteger(value.size);
-  const mtimeMs = toNonNegativeNumber(value.mtimeMs);
-  if (size === void 0 || mtimeMs === void 0) {
-    return void 0;
-  }
-  return {
-    path: dependencyPath,
-    exists: true,
-    size,
-    mtimeMs
-  };
-}
-function compareDependencyFingerprint(left5, right4) {
-  if (left5.path !== right4.path) {
-    return compareByCodePoint(left5.path, right4.path);
-  }
-  if (left5.exists !== right4.exists) {
-    return left5.exists ? 1 : -1;
-  }
-  if ((left5.size ?? -1) !== (right4.size ?? -1)) {
-    return (left5.size ?? -1) - (right4.size ?? -1);
-  }
-  return (left5.mtimeMs ?? -1) - (right4.mtimeMs ?? -1);
-}
-function normalizeEventStoreFingerprint(fingerprint) {
-  if (!Array.isArray(fingerprint.dependencies) || fingerprint.dependencies.length === 0) {
-    return void 0;
-  }
-  const dependencies = [];
-  for (const dependency of fingerprint.dependencies) {
-    const normalizedDependency = normalizeDependencyFingerprint(dependency);
-    if (!normalizedDependency) {
-      return void 0;
-    }
-    dependencies.push(normalizedDependency);
-  }
-  dependencies.sort(compareDependencyFingerprint);
-  return { dependencies };
-}
-function serializeEventStoreFingerprint(fingerprint) {
-  const normalizedFingerprint = normalizeEventStoreFingerprint(fingerprint);
-  if (!normalizedFingerprint) {
-    throw new Error("Event store fingerprint must include valid dependency fingerprints");
-  }
-  return JSON.stringify(normalizedFingerprint);
-}
-function parseSkippedRowReasons(value) {
-  if (typeof value !== "string") {
-    return [];
-  }
+function runTransaction(database, task) {
+  database.exec("BEGIN IMMEDIATE");
   try {
-    return normalizeSkippedRowReasons(JSON.parse(value));
-  } catch {
-    return [];
+    task();
+    database.exec("COMMIT");
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
   }
 }
-function stringifySkippedRowReasons(skippedRowReasons) {
-  const normalizedReasons = normalizeSkippedRowReasons(skippedRowReasons);
-  return normalizedReasons.length > 0 ? JSON.stringify(normalizedReasons) : null;
-}
+
+// src/persistence/event-store-codec.ts
+var CONTROL_CHARACTERS_PATTERN2 = new RegExp(String.raw`[\u0000-\u001F\u007F-\u009F]`, "u");
+var NORMALIZED_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var FAST_PATH_REJECT = /* @__PURE__ */ Symbol("fast path reject");
 function normalizeStoredEvent(row) {
   return fastMaterializeStoredEvent(row) ?? slowNormalizeStoredEvent(row);
 }
@@ -577,23 +452,63 @@ function slowNormalizeStoredEvent(row) {
   }
 }
 function fastMaterializeStoredEvent(row) {
-  const costMode = row.cost_mode === "explicit" || row.cost_mode === "estimated" ? row.cost_mode : void 0;
+  return materializeStoredEvent(
+    row.source,
+    row.session_id,
+    row.timestamp,
+    row.model,
+    row.provider,
+    row.repo_root,
+    row.input_tokens,
+    row.output_tokens,
+    row.reasoning_tokens,
+    row.cache_read_tokens,
+    row.cache_write_tokens,
+    row.total_tokens,
+    row.cost_usd,
+    row.cost_mode
+  );
+}
+function normalizeStoredEventTuple(row) {
+  const event = materializeStoredEvent(...row);
+  if (event) {
+    return event;
+  }
+  return slowNormalizeStoredEvent({
+    source: row[0],
+    session_id: row[1],
+    timestamp: row[2],
+    model: row[3],
+    provider: row[4],
+    repo_root: row[5],
+    input_tokens: row[6],
+    output_tokens: row[7],
+    reasoning_tokens: row[8],
+    cache_read_tokens: row[9],
+    cache_write_tokens: row[10],
+    total_tokens: row[11],
+    cost_usd: row[12],
+    cost_mode: row[13]
+  });
+}
+function materializeStoredEvent(sourceValue, sessionIdValue, timestampValue, modelValue, providerValue, repoRootValue, inputTokensValue, outputTokensValue, reasoningTokensValue, cacheReadTokensValue, cacheWriteTokensValue, totalTokensValue, costUsdValue, costModeValue) {
+  const costMode = costModeValue === "explicit" || costModeValue === "estimated" ? costModeValue : void 0;
   if (!costMode) {
     return void 0;
   }
-  const source = toStoredRequiredText(row.source);
-  const sessionId = toStoredRequiredText(row.session_id);
-  const timestamp = toStoredTimestamp(row.timestamp);
-  const repoRoot = toStoredOptionalText(row.repo_root);
-  const provider = toStoredOptionalText(row.provider);
-  const model = toStoredOptionalText(row.model);
-  const inputTokens = toStoredNonNegativeInteger(row.input_tokens);
-  const outputTokens = toStoredNonNegativeInteger(row.output_tokens);
-  const reasoningTokens = toStoredNonNegativeInteger(row.reasoning_tokens);
-  const cacheReadTokens = toStoredNonNegativeInteger(row.cache_read_tokens);
-  const cacheWriteTokens = toStoredNonNegativeInteger(row.cache_write_tokens);
-  const totalTokens = toStoredNonNegativeInteger(row.total_tokens);
-  const costUsd = toStoredCostUsd(row.cost_usd, costMode);
+  const source = toStoredRequiredText(sourceValue);
+  const sessionId = toStoredRequiredText(sessionIdValue);
+  const timestamp = toStoredTimestamp(timestampValue);
+  const repoRoot = toStoredOptionalText(repoRootValue);
+  const provider = toStoredOptionalText(providerValue);
+  const model = toStoredOptionalText(modelValue);
+  const inputTokens = toStoredNonNegativeInteger(inputTokensValue);
+  const outputTokens = toStoredNonNegativeInteger(outputTokensValue);
+  const reasoningTokens = toStoredNonNegativeInteger(reasoningTokensValue);
+  const cacheReadTokens = toStoredNonNegativeInteger(cacheReadTokensValue);
+  const cacheWriteTokens = toStoredNonNegativeInteger(cacheWriteTokensValue);
+  const totalTokens = toStoredNonNegativeInteger(totalTokensValue);
+  const costUsd = toStoredCostUsd(costUsdValue, costMode);
   if (!source || !sessionId || !timestamp || repoRoot === FAST_PATH_REJECT || provider === FAST_PATH_REJECT || model === FAST_PATH_REJECT || inputTokens === void 0 || outputTokens === void 0 || reasoningTokens === void 0 || cacheReadTokens === void 0 || cacheWriteTokens === void 0 || totalTokens === void 0 || costUsd === FAST_PATH_REJECT) {
     return void 0;
   }
@@ -675,6 +590,79 @@ function toStoredCostUsd(value, costMode) {
   }
   return value;
 }
+function computeEventContentHash(event) {
+  const fields = [
+    event.source.toLowerCase(),
+    event.sessionId,
+    event.timestamp,
+    event.model ?? "",
+    event.provider ?? "",
+    event.repoRoot ?? "",
+    event.inputTokens,
+    event.outputTokens,
+    event.reasoningTokens,
+    event.cacheReadTokens,
+    event.cacheWriteTokens,
+    event.totalTokens,
+    event.costMode,
+    event.costUsd ?? ""
+  ];
+  return createHash("sha256").update(fields.map(String).join("")).digest("hex").slice(0, 16);
+}
+
+// src/persistence/event-store-schema.ts
+var EVENT_STORE_SCHEMA_VERSION = "3";
+var MIGRATION_BATCH_SIZE = 5e3;
+var EventStoreSchemaVersionError = class extends Error {
+  schemaVersion;
+  constructor(schemaVersion) {
+    const versionLabel = schemaVersion ? `v${schemaVersion}` : "an unknown schema version";
+    super(
+      `Event store uses ${versionLabel}, which is not supported by this version of llm-usage-metrics (supports v${EVENT_STORE_SCHEMA_VERSION}); leaving store untouched`
+    );
+    this.name = "EventStoreSchemaVersionError";
+    this.schemaVersion = schemaVersion;
+  }
+};
+function createSchemaSql() {
+  return `
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS files (
+  source TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  fingerprint TEXT NOT NULL,
+  skipped_rows INTEGER NOT NULL,
+  skipped_row_reasons TEXT,
+  ingested_at INTEGER NOT NULL,
+  PRIMARY KEY (source, file_path)
+);
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY,
+  source TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  event_index INTEGER NOT NULL,
+  session_id TEXT NOT NULL,
+  timestamp TEXT NOT NULL,
+  model TEXT,
+  provider TEXT,
+  repo_root TEXT,
+  input_tokens INTEGER NOT NULL,
+  output_tokens INTEGER NOT NULL,
+  reasoning_tokens INTEGER NOT NULL,
+  cache_read_tokens INTEGER NOT NULL,
+  cache_write_tokens INTEGER NOT NULL,
+  total_tokens INTEGER NOT NULL,
+  content_hash TEXT,
+  cost_usd REAL,
+  cost_mode TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS events_file ON events(source, file_path, event_index);
+CREATE INDEX IF NOT EXISTS events_content_hash ON events(content_hash);
+`;
+}
 function listUserTableNames(database) {
   return database.prepare(
     [
@@ -697,25 +685,6 @@ function createFreshSchema(database) {
   database.exec(createSchemaSql());
   database.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('schemaVersion', ?)").run(EVENT_STORE_SCHEMA_VERSION);
 }
-function computeEventContentHash(event) {
-  const fields = [
-    event.source.toLowerCase(),
-    event.sessionId,
-    event.timestamp,
-    event.model ?? "",
-    event.provider ?? "",
-    event.repoRoot ?? "",
-    event.inputTokens,
-    event.outputTokens,
-    event.reasoningTokens,
-    event.cacheReadTokens,
-    event.cacheWriteTokens,
-    event.totalTokens,
-    event.costMode,
-    event.costUsd ?? ""
-  ];
-  return createHash("sha256").update(fields.map(String).join("")).digest("hex").slice(0, 16);
-}
 function migrateSchemaV1ToV2(database) {
   runTransaction(database, () => {
     if (readSchemaVersion(database) !== "1") {
@@ -809,29 +778,105 @@ function initializeSchema(database) {
   if (schemaVersion === EVENT_STORE_SCHEMA_VERSION) {
     return;
   }
-  if (schemaVersion === "1") {
-    migrateSchemaV1ToV2(database);
-    migrateSchemaV2ToV3(database);
-    return;
+  if (schemaVersion === "1") {
+    migrateSchemaV1ToV2(database);
+    migrateSchemaV2ToV3(database);
+    return;
+  }
+  if (schemaVersion === "2") {
+    migrateSchemaV2ToV3(database);
+    return;
+  }
+  throw new EventStoreSchemaVersionError(schemaVersion);
+}
+
+// src/persistence/event-store-administration.ts
+var EVENT_STORE_OPEN_TIMEOUT_MS = 2e3;
+var loadEventStoreSqliteModule = () => loadNodeSqliteModule("Event store");
+function normalizeStoreSource(source) {
+  const normalizedSource = normalizeSourceId(source)?.toLowerCase();
+  if (!normalizedSource) {
+    throw new Error("Event store source must be a non-empty string");
+  }
+  return normalizedSource;
+}
+function normalizeStoreFilePath(filePath) {
+  const normalizedFilePath = filePath.trim();
+  if (!normalizedFilePath) {
+    throw new Error("Event store file path must be a non-empty string");
+  }
+  return normalizedFilePath;
+}
+function normalizeDependencyFingerprint(value) {
+  const dependencyPath = toText(value.path);
+  if (!dependencyPath) {
+    return void 0;
+  }
+  if (!value.exists) {
+    return {
+      path: dependencyPath,
+      exists: false
+    };
+  }
+  const size = toNonNegativeInteger(value.size);
+  const mtimeMs = toNonNegativeNumber(value.mtimeMs);
+  if (size === void 0 || mtimeMs === void 0) {
+    return void 0;
+  }
+  return {
+    path: dependencyPath,
+    exists: true,
+    size,
+    mtimeMs
+  };
+}
+function compareDependencyFingerprint(left5, right4) {
+  if (left5.path !== right4.path) {
+    return compareByCodePoint(left5.path, right4.path);
+  }
+  if (left5.exists !== right4.exists) {
+    return left5.exists ? 1 : -1;
+  }
+  if ((left5.size ?? -1) !== (right4.size ?? -1)) {
+    return (left5.size ?? -1) - (right4.size ?? -1);
+  }
+  return (left5.mtimeMs ?? -1) - (right4.mtimeMs ?? -1);
+}
+function normalizeEventStoreFingerprint(fingerprint) {
+  if (!Array.isArray(fingerprint.dependencies) || fingerprint.dependencies.length === 0) {
+    return void 0;
+  }
+  const dependencies = [];
+  for (const dependency of fingerprint.dependencies) {
+    const normalizedDependency = normalizeDependencyFingerprint(dependency);
+    if (!normalizedDependency) {
+      return void 0;
+    }
+    dependencies.push(normalizedDependency);
   }
-  if (schemaVersion === "2") {
-    migrateSchemaV2ToV3(database);
-    return;
+  dependencies.sort(compareDependencyFingerprint);
+  return { dependencies };
+}
+function serializeEventStoreFingerprint(fingerprint) {
+  const normalizedFingerprint = normalizeEventStoreFingerprint(fingerprint);
+  if (!normalizedFingerprint) {
+    throw new Error("Event store fingerprint must include valid dependency fingerprints");
   }
-  throw new EventStoreSchemaVersionError(schemaVersion);
+  return JSON.stringify(normalizedFingerprint);
 }
-function runTransaction(database, task) {
-  database.exec("BEGIN IMMEDIATE");
+function parseSkippedRowReasons(value) {
+  if (typeof value !== "string") {
+    return [];
+  }
   try {
-    task();
-    database.exec("COMMIT");
-  } catch (error) {
-    database.exec("ROLLBACK");
-    throw error;
+    return normalizeSkippedRowReasons(JSON.parse(value));
+  } catch {
+    return [];
   }
 }
-function deleteFileEntry(store, source, filePath) {
-  deleteStoredFiles(store, [{ source, filePath }]);
+function stringifySkippedRowReasons(skippedRowReasons) {
+  const normalizedReasons = normalizeSkippedRowReasons(skippedRowReasons);
+  return normalizedReasons.length > 0 ? JSON.stringify(normalizedReasons) : null;
 }
 function getDefaultEventStorePath() {
   return path2.join(getUserCacheRootDir(), "llm-usage-metrics", "events.db");
@@ -933,6 +978,9 @@ async function readEventStoreStoredFiles(filePath = getDefaultEventStorePath(),
     database.close();
   }
 }
+function deleteFileEntry(store, source, filePath) {
+  deleteStoredFiles(store, [{ source, filePath }]);
+}
 function getFileEntry(store, source, filePath) {
   const normalizedSource = normalizeStoreSource(source);
   const normalizedFilePath = normalizeStoreFilePath(filePath);
@@ -960,16 +1008,21 @@ function getFileEntry(store, source, filePath) {
   };
 }
 function selectFileEventRows(store, source, filePath) {
-  const statement = store.statements.selectFileEvents ??= store.database.prepare(
-    [
-      "SELECT source, session_id, timestamp, model, provider, repo_root,",
-      "  input_tokens, output_tokens, reasoning_tokens, cache_read_tokens,",
-      "  cache_write_tokens, total_tokens, cost_usd, cost_mode",
-      "FROM events",
-      "WHERE source = ? AND file_path = ?",
-      "ORDER BY event_index ASC"
-    ].join("\n")
-  );
+  let statement = store.statements.selectFileEvents;
+  if (!statement) {
+    statement = store.database.prepare(
+      [
+        "SELECT source, session_id, timestamp, model, provider, repo_root,",
+        "  input_tokens, output_tokens, reasoning_tokens, cache_read_tokens,",
+        "  cache_write_tokens, total_tokens, cost_usd, cost_mode",
+        "FROM events",
+        "WHERE source = ? AND file_path = ?",
+        "ORDER BY event_index ASC"
+      ].join("\n")
+    );
+    statement.setReturnArrays(true);
+    store.statements.selectFileEvents = statement;
+  }
   return statement.all(source, filePath);
 }
 function readFileEvents(store, source, filePath) {
@@ -977,7 +1030,7 @@ function readFileEvents(store, source, filePath) {
   const normalizedFilePath = normalizeStoreFilePath(filePath);
   const events = [];
   for (const row of selectFileEventRows(store, normalizedSource, normalizedFilePath)) {
-    const event = normalizeStoredEvent(row);
+    const event = normalizeStoredEventTuple(row);
     if (!event) {
       deleteFileEntry(store, normalizedSource, normalizedFilePath);
       return void 0;
@@ -1214,105 +1267,13 @@ import { readFile as readFileFromFs } from "fs/promises";
 import os3 from "os";
 import path4 from "path";
 
-// node_modules/.pnpm/smol-toml@1.7.0/node_modules/smol-toml/dist/date.js
-var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
-var TomlDate = class _TomlDate extends Date {
-  #hasDate = false;
-  #hasTime = false;
-  #offset = null;
-  constructor(date) {
-    let hasDate = true;
-    let hasTime = true;
-    let offset = "Z";
-    if (typeof date === "string") {
-      let match = date.match(DATE_TIME_RE);
-      if (match) {
-        if (!match[1]) {
-          hasDate = false;
-          date = `0000-01-01T${date}`;
-        }
-        hasTime = !!match[2];
-        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
-        if (match[2] && +match[2] > 23) {
-          date = "";
-        } else {
-          offset = match[3] || null;
-          date = date.toUpperCase();
-          if (!offset && hasTime)
-            date += "Z";
-        }
-      } else {
-        date = "";
-      }
-    }
-    super(date);
-    if (!isNaN(this.getTime())) {
-      this.#hasDate = hasDate;
-      this.#hasTime = hasTime;
-      this.#offset = offset;
-    }
-  }
-  isDateTime() {
-    return this.#hasDate && this.#hasTime;
-  }
-  isLocal() {
-    return !this.#hasDate || !this.#hasTime || !this.#offset;
-  }
-  isDate() {
-    return this.#hasDate && !this.#hasTime;
-  }
-  isTime() {
-    return this.#hasTime && !this.#hasDate;
-  }
-  isValid() {
-    return this.#hasDate || this.#hasTime;
-  }
-  toISOString() {
-    let iso = super.toISOString();
-    if (this.isDate())
-      return iso.slice(0, 10);
-    if (this.isTime())
-      return iso.slice(11, 23);
-    if (this.#offset === null)
-      return iso.slice(0, -1);
-    if (this.#offset === "Z")
-      return iso;
-    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
-    offset = this.#offset[0] === "-" ? offset : -offset;
-    let offsetDate = new Date(this.getTime() - offset * 6e4);
-    return offsetDate.toISOString().slice(0, -1) + this.#offset;
-  }
-  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
-    let date = new _TomlDate(jsDate);
-    date.#offset = offset;
-    return date;
-  }
-  static wrapAsLocalDateTime(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#offset = null;
-    return date;
-  }
-  static wrapAsLocalDate(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#hasTime = false;
-    date.#offset = null;
-    return date;
-  }
-  static wrapAsLocalTime(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#hasDate = false;
-    date.#offset = null;
-    return date;
-  }
-};
-
-// node_modules/.pnpm/smol-toml@1.7.0/node_modules/smol-toml/dist/error.js
+// node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
-  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  let lines = string.slice(0, ptr).split(/\r?\n/);
   return [lines.length, lines.pop().length + 1];
 }
 function makeCodeBlock(string, line, column) {
-  let lines = string.split(/\r\n|\n|\r/g);
+  let lines = string.split(/\r?\n/);
   let codeblock = "";
   let numberLen = (Math.log10(line + 1) | 0) + 1;
   for (let i = line - 1; i <= line + 1; i++) {
@@ -1330,7 +1291,7 @@ function makeCodeBlock(string, line, column) {
   }
   return codeblock;
 }
-var TomlError = class extends Error {
+var TomlError = class _TomlError extends Error {
   line;
   column;
   codeblock;
@@ -1344,59 +1305,59 @@ ${codeblock}`, options);
     this.column = column;
     this.codeblock = codeblock;
   }
+  /** @internal */
+  static x(message, ctx, ptr) {
+    throw new _TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+  }
 };
 
-// node_modules/.pnpm/smol-toml@1.7.0/node_modules/smol-toml/dist/primitive.js
-var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
-var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
-var LEADING_ZERO = /^[+-]?0[0-9_]/;
-function parseString(str, ptr) {
-  let c = str[ptr++];
+// node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/primitive.js
+function parseString(ctx) {
+  let startPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
   let first = c;
-  let isLiteral = c === "'";
-  let isMultiline = c === str[ptr] && c === str[ptr + 1];
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
   if (isMultiline) {
-    if (str[ptr += 2] === "\n")
-      ptr++;
-    else if (str[ptr] === "\r" && str[ptr + 1] === "\n")
-      ptr += 2;
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
   }
   let parsed = "";
-  let sliceStart = ptr;
+  let sliceStart = ctx.p;
   let state = 0;
-  for (let i = ptr; i < str.length; i++) {
-    c = str[i];
-    if (isMultiline && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
       state = state && 3;
-    } else if (c < " " && c !== "	" || c === "\x7F") {
-      throw new TomlError("control characters are not allowed in strings", {
-        toml: str,
-        ptr: i
-      });
-    } else if ((!state || state === 3) && c === first && (!isMultiline || str[i + 1] === first && str[i + 2] === first)) {
+    } else if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in strings", ctx);
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
       if (isMultiline) {
-        if (str[i + 3] === first)
-          i++;
-        if (str[i + 3] === first)
-          i++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
       }
-      return [
-        // If we're in a newline escape still, then there's nothing to add.
-        // Also try to avoid concat if there's nothing to add to parsed, or nothing has been added to parsed.
-        state ? parsed : parsed + str.slice(sliceStart, i),
-        i + (isMultiline ? 3 : 1)
-      ];
+      if (!state) {
+        let s = ctx.s.slice(sliceStart, ctx.p);
+        parsed = parsed ? parsed + s : s;
+      }
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
     } else if (!state) {
-      if (!isLiteral && c === "\\") {
-        parsed += str.slice(sliceStart, sliceStart = i);
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
         state = 1;
       }
     } else if (state === 1) {
-      if (c === "x" || c === "u" || c === "U") {
+      if (c === 120 || c === 117 || c === 85) {
+        let errPtr = ctx.p++ - 1;
         let value = 0;
-        let len = c === "x" ? 2 : c === "u" ? 4 : 8;
-        for (let j = 0; j < len; j++, i++) {
-          let hex = str.charCodeAt(i + 1);
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p);
           let digit = (
             /* 0-9 */
             hex >= 48 && hex <= 57 ? hex - 48 : (
@@ -1408,369 +1369,517 @@ function parseString(str, ptr) {
             )
           );
           if (digit < 0)
-            throw new TomlError("invalid non-hex character in unicode escape", { toml: str, ptr: i + 1 });
+            TomlError.x("invalid non-hex character in unicode escape", ctx);
           value = value << 4 | digit;
         }
         if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
-          throw new TomlError("invalid unicode escape", { toml: str, ptr: i });
+          TomlError.x("invalid unicode escape", ctx, errPtr);
         }
         parsed += String.fromCodePoint(value);
-        sliceStart = i + 1;
+        sliceStart = ctx.p--;
         state = 0;
-      } else if (c === " " || c === "	") {
+      } else if (isMultiline && (c === 32 || c === 9)) {
         state = 2;
       } else {
-        if (c === "b")
+        if (c === 98)
           parsed += "\b";
-        else if (c === "t")
+        else if (c === 116)
           parsed += "	";
-        else if (c === "n")
+        else if (c === 110)
           parsed += "\n";
-        else if (c === "f")
+        else if (c === 102)
           parsed += "\f";
-        else if (c === "r")
+        else if (c === 114)
           parsed += "\r";
-        else if (c === "e")
+        else if (c === 101)
           parsed += "\x1B";
-        else if (c === '"')
+        else if (c === 34)
           parsed += '"';
-        else if (c === "\\")
+        else if (c === 92)
           parsed += "\\";
         else
-          throw new TomlError("unrecognized escape sequence", { toml: str, ptr: i });
-        sliceStart = i + 1;
+          TomlError.x("unrecognised escape sequence", ctx);
+        sliceStart = ctx.p + 1;
         state = 0;
       }
-    } else if (c !== " " && c !== "	") {
-      if (state === 2) {
-        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
-          toml: str,
-          ptr: sliceStart
-        });
-      }
-      state = !isLiteral && c === "\\" ? 1 : 0;
-      sliceStart = i;
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2)
+        TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
     }
   }
-  throw new TomlError("unfinished string", { toml: str, ptr });
+  TomlError.x("unfinished string", ctx, startPtr);
 }
-function parseValue(value, toml, ptr, integersAsBigInt) {
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
-  if (value === "-inf")
-    return -Infinity;
-  if (value === "inf" || value === "+inf")
-    return Infinity;
-  if (value === "nan" || value === "+nan" || value === "-nan")
-    return NaN;
-  if (value === "-0")
-    return integersAsBigInt ? 0n : 0;
-  let isInt = INT_REGEX.test(value);
-  if (isInt || FLOAT_REGEX.test(value)) {
-    if (LEADING_ZERO.test(value)) {
-      throw new TomlError("leading zeroes are not allowed", {
-        toml,
-        ptr
-      });
-    }
-    value = value.replace(/_/g, "");
-    let numeric = +value;
-    if (isNaN(numeric)) {
-      throw new TomlError("invalid number", {
-        toml,
-        ptr
-      });
-    }
-    if (isInt) {
-      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
-        throw new TomlError("integer value cannot be represented losslessly", {
-          toml,
-          ptr
-        });
+
+// node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date, fasttype, unsafeDelim) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    let c;
+    if (typeof date === "string") {
+      if (fasttype)
+        prep: {
+          if (fasttype < 3) {
+            if (+date.slice(11, 13) > 23) {
+              date = "";
+              break prep;
+            }
+            if (fasttype === 2) {
+              offset = null;
+              date += "Z";
+            } else if ((c = date.charCodeAt(date.length - 1)) !== 90 && c !== 122) {
+              offset = date.slice(date.length - 6);
+            }
+            if (unsafeDelim)
+              date = date.slice(0, 10) + "T" + date.slice(11);
+          } else if (fasttype === 4) {
+            date = +date.slice(0, 2) > 23 ? "" : `0000-01-01T${date}Z`;
+          }
+          hasDate = fasttype !== 4;
+          hasTime = fasttype !== 3;
+        }
+      else {
+        let match = date.match(DATE_TIME_RE);
+        if (match) {
+          if (!match[1]) {
+            hasDate = false;
+            date = `0000-01-01T${date}`;
+          }
+          hasTime = !!match[2];
+          hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+          if (match[2] && +match[2] > 23) {
+            date = "";
+          } else {
+            offset = match[3] || null;
+            if (!offset && hasTime)
+              date += "Z";
+          }
+        } else {
+          date = "";
+        }
       }
-      if (isInt || integersAsBigInt === true)
-        numeric = BigInt(value);
     }
-    return numeric;
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
   }
-  const date = new TomlDate(value);
-  if (!date.isValid()) {
-    throw new TomlError("invalid value", {
-      toml,
-      ptr
-    });
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
   }
-  return date;
-}
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z" || this.#offset === "z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
 
-// node_modules/.pnpm/smol-toml@1.7.0/node_modules/smol-toml/dist/util.js
-function indexOfNewline(str, start = 0, end = str.length) {
-  let idx = str.indexOf("\n", start);
-  if (str[idx - 1] === "\r")
-    idx--;
-  return idx <= end ? idx : -1;
-}
-function skipComment(str, ptr) {
-  for (let i = ptr; i < str.length; i++) {
-    let c = str[i];
-    if (c === "\n")
-      return i;
-    if (c === "\r" && str[i + 1] === "\n")
-      return i + 1;
-    if (c < " " && c !== "	" || c === "\x7F") {
-      throw new TomlError("control characters are not allowed in comments", {
-        toml: str,
-        ptr
-      });
-    }
+// node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/extract.js
+function isDigit(char, base = 10) {
+  return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
+}
+function isEndOfValue(char, delim) {
+  return char === 32 || char === 9 || char === 10 || char === 13 || // Structure end or next value delimiter
+  delim && (char === delim || char === 44) || // Comment
+  char === 35;
+}
+function extractValue(ctx, end) {
+  let errPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p);
+  if (c === 91 || c === 123) {
+    ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
+    let value = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
+    ctx.d++;
+    return value;
   }
-  return str.length;
-}
-function skipVoid(str, ptr, banNewLines, banComments) {
-  let c;
-  while (1) {
-    while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
-      ptr++;
-    if (banComments || c !== "#")
-      break;
-    ptr = skipComment(str, ptr);
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, false;
   }
-  return ptr;
+  if (c === 43 || c === 45) {
+    return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) {
+    return parseDate(ctx, c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 2) === 58) {
+    return parseTime(ctx, c, end);
+  }
+  return parseNumber(ctx, ctx.p, c, 0, end);
 }
-function skipUntil(str, ptr, sep, end, banNewLines = false) {
-  if (!end) {
-    ptr = indexOfNewline(str, ptr);
-    return ptr < 0 ? str.length : ptr;
+function parseNumber(ctx, startPtr, startChr, sign, endChr) {
+  let c = startChr;
+  let state = 0;
+  let hasUnderscores = false;
+  if (c === 105) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, (sign || 1) / 0;
+  }
+  if (c === 110) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, NaN;
+  }
+  if (c === 48) {
+    if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr))
+      return ctx.bi === true ? 0n : 0;
+    if (!sign) {
+      if (c === 120)
+        return parseIntegerBaseN(ctx, startPtr, 16, endChr);
+      else if (c === 98)
+        return parseIntegerBaseN(ctx, startPtr, 2, endChr);
+      else if (c === 111)
+        return parseIntegerBaseN(ctx, startPtr, 8, endChr);
+    }
+    if (c === 46)
+      state = 2;
+    else if (c === 101 || c === 69)
+      state = 4;
+    else
+      TomlError.x("illegal leading zero", ctx, startPtr);
+  } else if (!isDigit(c))
+    TomlError.x("invalid value", ctx, startPtr);
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (!state)
+      state = 1;
+    if (c === 95) {
+      if (!(state & 1))
+        TomlError.x("illegal underscore", ctx);
+      state += 11;
+      hasUnderscores = true;
+    } else if (state === 1 && c === 46)
+      state = 2;
+    else if ((state === 1 || state === 3) && (c === 101 || c === 69))
+      state = 4;
+    else if (state === 4 && (c === 43 || c === 45)) {
+    } else if (!isDigit(c))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (state > 9)
+      state -= 11;
+    else if (!(state & 1))
+      state++;
+  }
+  if (!state) {
+    let val = (startChr - 48) * (sign || 1);
+    return ctx.bi === true ? BigInt(val) : val;
+  }
+  if (!(state & 1))
+    TomlError.x("unfinished numeric value", ctx, startPtr);
+  let str = ctx.s.slice(startPtr, ctx.p);
+  if (hasUnderscores)
+    str = str.replaceAll("_", "");
+  return state > 1 ? parseFloat(str) : parseInteger(ctx, str, 10, startPtr);
+}
+function parseIntegerBaseN(ctx, startPtr, base, endChr) {
+  let c, underscore = 1;
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (c === 95) {
+      if (underscore & 1)
+        TomlError.x("illegal underscore", ctx);
+      underscore = 3;
+    } else if (!isDigit(c, base))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (underscore & 1)
+      underscore--;
+  }
+  if (underscore & 1)
+    TomlError.x("unfinished numeric value", ctx);
+  let str = ctx.s.slice(startPtr + 2, ctx.p);
+  if (underscore)
+    str = str.replaceAll("_", "");
+  return parseInteger(ctx, str, base, startPtr);
+}
+function parseInteger(ctx, str, base, startPtr) {
+  if (ctx.bi !== true)
+    int: {
+      let val = parseInt(str, base);
+      if (!Number.isSafeInteger(val)) {
+        if (ctx.bi)
+          break int;
+        TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
+      }
+      return val;
+    }
+  return base === 10 ? BigInt(str) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str);
+}
+function parseDate(ctx, c, endChr) {
+  let startPtr = ctx.p++, unsafeSeparator;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++))) {
+    return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
+  }
+  ctx.p += 5;
+  if (!isDigit(ctx.s.charCodeAt(ctx.p++)))
+    TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
+  if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) {
+    let t2 = ctx.s.slice(startPtr, ctx.p);
+    return readDate(ctx, t2, 3, false, startPtr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 3) !== 58)
+    TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
+  if (ctx.s.charCodeAt(ctx.p += 3) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  if (c = ctx.s.charCodeAt(ctx.p)) {
+    if (c === 90 || c === 122) {
+      let t2 = ctx.s.slice(startPtr, ++ctx.p);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, "[+00:00]");
+    }
+    if (c === 43 || c === 45) {
+      let t2 = ctx.s.slice(startPtr, ctx.p += 6);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
+    }
+  }
+  let t = ctx.s.slice(startPtr, ctx.p);
+  return readDate(ctx, t, 2, unsafeSeparator, startPtr);
+}
+function parseTime(ctx, c, endChr) {
+  let start = ctx.p;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(++ctx.p))) {
+    return parseNumber(ctx, --ctx.p, c, 0, endChr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 4) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  let t = ctx.s.slice(start, ctx.p);
+  return readDate(ctx, t, 4, false, start);
+}
+function readDate(ctx, str, type, unsafeDelim, errPtr, temporalSuffix) {
+  if (ctx.ld) {
+    let date = new TomlDate(str, type, unsafeDelim);
+    if (!date.isValid())
+      TomlError.x("invalid date", ctx, errPtr);
+    return date;
   }
-  for (let i = ptr; i < str.length; i++) {
-    let c = str[i];
-    if (c === "#") {
-      i = indexOfNewline(str, i);
-    } else if (c === sep) {
-      return i + 1;
-    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
-      return i;
+  try {
+    if (temporalSuffix)
+      str += temporalSuffix;
+    switch (type) {
+      case 1:
+        return Temporal.ZonedDateTime.from(str);
+      case 2:
+        return Temporal.PlainDateTime.from(str);
+      case 3:
+        return Temporal.PlainDate.from(str);
+      case 4:
+        return Temporal.PlainTime.from(str);
     }
+  } catch (e) {
+    TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
   }
-  throw new TomlError("cannot find end of structure", {
-    toml: str,
-    ptr
-  });
 }
 
-// node_modules/.pnpm/smol-toml@1.7.0/node_modules/smol-toml/dist/extract.js
-function sliceAndTrimEndOf(str, startPtr, endPtr) {
-  let value = str.slice(startPtr, endPtr);
-  let commentIdx = value.indexOf("#");
-  if (commentIdx > -1) {
-    skipComment(str, commentIdx);
-    value = value.slice(0, commentIdx);
-  }
-  return [value.trimEnd(), commentIdx];
-}
-function extractValue(str, ptr, end, depth, integersAsBigInt) {
-  if (depth === 0) {
-    throw new TomlError("document contains excessively nested structures. aborting.", {
-      toml: str,
-      ptr
-    });
-  }
-  let c = str[ptr];
-  if (c === "[" || c === "{") {
-    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
-    if (end) {
-      endPtr2 = skipVoid(str, endPtr2);
-      if (str[endPtr2] === ",")
-        endPtr2++;
-      else if (str[endPtr2] !== end) {
-        throw new TomlError("expected comma or end of structure", {
-          toml: str,
-          ptr: endPtr2
-        });
-      }
+// node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/util.js
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
     }
-    return [value, endPtr2];
-  }
-  if (c === '"' || c === "'") {
-    let [parsed, endPtr2] = parseString(str, ptr);
-    if (end) {
-      endPtr2 = skipVoid(str, endPtr2);
-      if (str[endPtr2] && str[endPtr2] !== "," && str[endPtr2] !== end && str[endPtr2] !== "\n" && str[endPtr2] !== "\r") {
-        throw new TomlError("unexpected character encountered", {
-          toml: str,
-          ptr: endPtr2
-        });
-      }
-      if (str[endPtr2] === ",")
-        endPtr2++;
+    if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in comments", ctx);
     }
-    return [parsed, endPtr2];
-  }
-  let endPtr = skipUntil(str, ptr, ",", end);
-  let slice = sliceAndTrimEndOf(str, ptr, endPtr - (str[endPtr - 1] === "," ? 1 : 0));
-  if (!slice[0]) {
-    throw new TomlError("incomplete key-value declaration: no value specified", {
-      toml: str,
-      ptr
-    });
   }
-  if (end && slice[1] > -1) {
-    endPtr = skipVoid(str, ptr + slice[1]);
-    if (str[endPtr] === ",")
-      endPtr++;
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (ctx.p < ctx.s.length) {
+    while (ctx.p < ctx.s.length && ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
   }
-  return [
-    parseValue(slice[0], str, ptr, integersAsBigInt),
-    endPtr
-  ];
 }
 
-// node_modules/.pnpm/smol-toml@1.7.0/node_modules/smol-toml/dist/struct.js
-var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
-function parseKey(str, ptr, end = "=") {
-  let dot = ptr - 1;
+// node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/struct.js
+function parseKey(ctx, end = 61) {
+  let startPtr;
+  let state = 0;
   let parsed = [];
-  let endPtr = str.indexOf(end, ptr);
-  if (endPtr < 0) {
-    throw new TomlError("incomplete key-value: cannot find end of key", {
-      toml: str,
-      ptr
-    });
-  }
+  let sliceStart;
+  let c = ctx.s.charCodeAt(startPtr = ctx.p);
   do {
-    let c = str[ptr = ++dot];
-    if (c !== " " && c !== "	") {
-      if (c === '"' || c === "'") {
-        if (c === str[ptr + 1] && c === str[ptr + 2]) {
-          throw new TomlError("multiline strings are not allowed in keys", {
-            toml: str,
-            ptr
-          });
-        }
-        let [part, eos] = parseString(str, ptr);
-        dot = str.indexOf(".", eos);
-        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
-        let newLine = indexOfNewline(strEnd);
-        if (newLine > -1) {
-          throw new TomlError("newlines are not allowed in keys", {
-            toml: str,
-            ptr: ptr + dot + newLine
-          });
-        }
-        if (strEnd.trimStart()) {
-          throw new TomlError("found extra tokens after the string part", {
-            toml: str,
-            ptr: eos
-          });
-        }
-        if (endPtr < eos) {
-          endPtr = str.indexOf(end, eos);
-          if (endPtr < 0) {
-            throw new TomlError("incomplete key-value: cannot find end of key", {
-              toml: str,
-              ptr
-            });
-          }
-        }
-        parsed.push(part);
-      } else {
-        dot = str.indexOf(".", ptr);
-        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
-        if (!KEY_PART_RE.test(part)) {
-          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
-            toml: str,
-            ptr
-          });
-        }
-        parsed.push(part.trimEnd());
+    if (c === end) {
+      if (!state)
+        TomlError.x("unexpected end of key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      return ctx.p++, parsed;
+    } else if (c === 46) {
+      if (!state)
+        TomlError.x("illegal empty bare key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      state = 0;
+    } else if (!state && (c === 34 || c === 39)) {
+      if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2))
+        TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
+      parsed.push(parseString(ctx));
+      state = 2;
+      ctx.p--;
+    } else if (c === 32 || c === 9) {
+      if (state === 1) {
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+        state = 2;
       }
+    } else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) {
+      TomlError.x("illegal character in key", ctx);
+    } else if (!state) {
+      state = 1;
+      sliceStart = ctx.p;
     }
-  } while (dot + 1 && dot < endPtr);
-  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+  } while (c = ctx.s.charCodeAt(++ctx.p));
+  TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
 }
-function parseInlineTable(str, ptr, depth, integersAsBigInt) {
-  let res = {};
+function parseInlineTable(ctx) {
+  let startPtr = ctx.p++;
+  let res = /* @__PURE__ */ Object.create(null);
   let seen = /* @__PURE__ */ new Set();
   let c;
-  ptr++;
-  while ((c = str[ptr++]) !== "}" && c) {
-    if (c === ",") {
-      throw new TomlError("expected value, found comma", {
-        toml: str,
-        ptr: ptr - 1
-      });
-    } else if (c === "#")
-      ptr = skipComment(str, ptr);
-    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
-      let k;
-      let t = res;
-      let hasOwn = false;
-      let [key, keyEndPtr] = parseKey(str, ptr - 1);
-      for (let i = 0; i < key.length; i++) {
-        if (i)
-          t = hasOwn ? t[k] : t[k] = {};
-        k = key[i];
-        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
-          throw new TomlError("trying to redefine an already defined value", {
-            toml: str,
-            ptr
-          });
-        }
-        if (!hasOwn && k === "__proto__") {
-          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
-        }
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let errPtr = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        TomlError.x("trying to redefine an already defined value", ctx, errPtr);
       }
-      if (hasOwn) {
-        throw new TomlError("trying to redefine an already defined value", {
-          toml: str,
-          ptr
-        });
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor")) {
+        t = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
+        break;
+      }
+      if (!hasOwn && unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
       }
-      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+    }
+    if (hasOwn) {
+      TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+    }
+    skipVoid(ctx, true, true);
+    let value = extractValue(
+      ctx,
+      125
+      /* } */
+    );
+    if (t && typeof (t[k] = value) === "object")
       seen.add(value);
-      t[k] = value;
-      ptr = valueEndPtr;
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
     }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
   }
-  if (!c) {
-    throw new TomlError("unfinished table encountered", {
-      toml: str,
-      ptr
-    });
-  }
-  return [res, ptr];
+  TomlError.x("unfinished table", ctx, startPtr);
 }
-function parseArray(str, ptr, depth, integersAsBigInt) {
+function parseArray(ctx) {
+  let startPtr = ctx.p++;
   let res = [];
   let c;
-  ptr++;
-  while ((c = str[ptr++]) !== "]" && c) {
-    if (c === ",") {
-      throw new TomlError("expected value, found comma", {
-        toml: str,
-        ptr: ptr - 1
-      });
-    } else if (c === "#")
-      ptr = skipComment(str, ptr);
-    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
-      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
-      res.push(e[0]);
-      ptr = e[1];
-    }
-  }
-  if (!c) {
-    throw new TomlError("unfinished array encountered", {
-      toml: str,
-      ptr
-    });
-  }
-  return [res, ptr];
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(
+      ctx,
+      93
+      /* ] */
+    ));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished array", ctx, startPtr);
 }
 
-// node_modules/.pnpm/smol-toml@1.7.0/node_modules/smol-toml/dist/parse.js
-function peekTable(key, table, meta, type) {
+// node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/parse.js
+function peekTable(ctx, key, table, meta, type) {
   let t = table;
   let m = meta;
   let k;
@@ -1778,7 +1887,7 @@ function peekTable(key, table, meta, type) {
   let state;
   for (let i = 0; i < key.length; i++) {
     if (i) {
-      t = hasOwn ? t[k] : t[k] = {};
+      t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
       m = (state = m[k]).c;
       if (type === 0 && (state.t === 1 || state.t === 2)) {
         return null;
@@ -1794,7 +1903,10 @@ function peekTable(key, table, meta, type) {
       return null;
     }
     if (!hasOwn) {
-      if (k === "__proto__") {
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor"))
+        return false;
+      if (unsafe) {
         Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
         Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
       }
@@ -1802,7 +1914,7 @@ function peekTable(key, table, meta, type) {
         t: i < key.length - 1 && type === 2 ? 3 : type,
         d: false,
         i: 0,
-        c: {}
+        c: /* @__PURE__ */ Object.create(null)
       };
     }
   }
@@ -1815,85 +1927,103 @@ function peekTable(key, table, meta, type) {
       state.d = true;
       t[k] = [];
     }
-    t[k].push(t = {});
-    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+    t[k].push(t = /* @__PURE__ */ Object.create(null));
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: /* @__PURE__ */ Object.create(null) };
   }
   if (state.d) {
     return null;
   }
   state.d = true;
   if (type === 1) {
-    t = hasOwn ? t[k] : t[k] = {};
+    t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
   } else if (type === 0 && hasOwn) {
     return null;
   }
   return [k, t, state.c];
 }
-function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
-  let res = {};
-  let meta = {};
+function validateTablePeek(ctx, peek, ptr) {
+  if (peek === null || ctx.uk === 2)
+    TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
+}
+function parse(toml, options = {}) {
+  let ctx = {
+    s: toml,
+    p: 0,
+    d: options.maxDepth ?? 1e3,
+    bi: options.integersAsBigInt ?? false,
+    ld: options.useLegacyDate ?? true,
+    uk: options.unsafeKeyBehaviour === "throw" ? 2 : options.unsafeKeyBehaviour === "drop" ? 1 : 0
+  };
+  let res = /* @__PURE__ */ Object.create(null);
+  let meta = /* @__PURE__ */ Object.create(null);
+  let tmp;
+  let skipping = false;
   let tbl = res;
   let m = meta;
-  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
-    if (toml[ptr] === "[") {
-      let isTableArray = toml[++ptr] === "[";
-      let k = parseKey(toml, ptr += +isTableArray, "]");
+  if (toml.charCodeAt(0) === 65279)
+    ctx.p++;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      skipping = false;
+      let k = parseKey(
+        ctx,
+        93
+        /* ] */
+      );
       if (isTableArray) {
-        if (toml[k[1] - 1] !== "]") {
-          throw new TomlError("expected end of table declaration", {
-            toml,
-            ptr: k[1] - 1
-          });
+        if (toml.charCodeAt(ctx.p) !== 93) {
+          TomlError.x("expected end of table array declaration", ctx);
         }
-        k[1]++;
+        ctx.p++;
       }
       let p = peekTable(
-        k[0],
+        ctx,
+        k,
         res,
         meta,
         isTableArray ? 2 : 1
         /* Type.EXPLICIT */
       );
       if (!p) {
-        throw new TomlError("trying to redefine an already defined table or value", {
-          toml,
-          ptr
-        });
+        validateTablePeek(ctx, p, tmp);
+        skipping = true;
+      } else {
+        m = p[2];
+        tbl = p[1];
       }
-      m = p[2];
-      tbl = p[1];
-      ptr = k[1];
     } else {
-      let k = parseKey(toml, ptr);
+      tmp = ctx.p;
+      let k = parseKey(ctx);
       let p = peekTable(
-        k[0],
+        ctx,
+        k,
         tbl,
         m,
         0
         /* Type.DOTTED */
       );
-      if (!p) {
-        throw new TomlError("trying to redefine an already defined table or value", {
-          toml,
-          ptr
-        });
-      }
-      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
-      p[1][p[0]] = v[0];
-      ptr = v[1];
-    }
-    ptr = skipVoid(toml, ptr, true);
-    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
-      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
-        toml,
-        ptr
-      });
+      if (!p && !skipping)
+        validateTablePeek(ctx, p, tmp);
+      skipVoid(ctx, true, true);
+      let v = extractValue(ctx, void 0);
+      if (p && !skipping)
+        p[1][p[0]] = v;
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) {
+      TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
     }
-    ptr = skipVoid(toml, ptr);
+    skipVoid(ctx);
   }
   return res;
 }
 
+// node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/stringify.js
+var HAS_WELLFORMED = !!"".isWellFormed;
+
 // src/utils/config-root-dir.ts
 import os2 from "os";
 import path3 from "path";
@@ -1944,7 +2074,8 @@ var USER_CONFIG_SOURCE_DIR_KEYS = [
   "cline",
   "roocode",
   "kilocode",
-  "antigravity"
+  "antigravity",
+  "dsh"
 ];
 var knownTopLevelKeys = [
   "eventStore",
@@ -2003,10 +2134,10 @@ function hasConfigPathOverride(env) {
 function getLegacyJsonConfigPath(configPath) {
   return path4.join(path4.dirname(configPath), "config.json");
 }
-async function throwIfLegacyJsonConfigExists(tomlPath, readFile8) {
+async function throwIfLegacyJsonConfigExists(tomlPath, readFile9) {
   const jsonPath = getLegacyJsonConfigPath(tomlPath);
   try {
-    await readFile8(jsonPath);
+    await readFile9(jsonPath);
   } catch (error) {
     if (isMissingFileError(error)) {
       return;
@@ -2254,15 +2385,15 @@ function parseUserConfigRoot(filePath, content) {
   }
   return root;
 }
-async function loadUserConfig(env = process.env, readFile8 = (filePath) => readFileFromFs(filePath, "utf8")) {
+async function loadUserConfig(env = process.env, readFile9 = (filePath) => readFileFromFs(filePath, "utf8")) {
   const configPath = resolveUserConfigPath(env);
   let content;
   try {
-    content = await readFile8(configPath);
+    content = await readFile9(configPath);
   } catch (error) {
     if (isMissingFileError(error)) {
       if (!hasConfigPathOverride(env)) {
-        await throwIfLegacyJsonConfigExists(configPath, readFile8);
+        await throwIfLegacyJsonConfigExists(configPath, readFile9);
       }
       return {
         config: {},
@@ -6781,16 +6912,310 @@ var DroidSourceAdapter = class {
   }
 };
 
-// src/sources/gemini/gemini-source-adapter.ts
-import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+// src/sources/dsh/dsh-source-adapter.ts
+import path17 from "path";
+
+// src/sources/dsh/dsh-session-log-reader.ts
+import { readFile as readFile4 } from "fs/promises";
+import { Readable, Writable } from "stream";
+import { pipeline } from "stream/promises";
+import { createZstdDecompress } from "zlib";
+var DshSessionLogUnreadableError = class extends Error {
+  constructor(message = "DSH session log could not be decompressed") {
+    super(message);
+    this.name = "DshSessionLogUnreadableError";
+  }
+};
+var ZSTD_FRAME_MAGIC = Buffer.from([40, 181, 47, 253]);
+var UNDECODABLE_FRAME_REASON = "undecodable_jsonl_frame";
+function collectFrameSlices(compressed) {
+  const frames = [];
+  let damagedSlices = 0;
+  let offset = 0;
+  while (offset < compressed.length) {
+    const nextOffset = compressed.indexOf(ZSTD_FRAME_MAGIC, offset + ZSTD_FRAME_MAGIC.length);
+    const slice = nextOffset === -1 ? compressed.subarray(offset) : compressed.subarray(offset, nextOffset);
+    if (slice.subarray(0, ZSTD_FRAME_MAGIC.length).equals(ZSTD_FRAME_MAGIC)) {
+      frames.push(slice);
+    } else {
+      damagedSlices += 1;
+    }
+    if (nextOffset === -1) {
+      break;
+    }
+    offset = nextOffset;
+  }
+  return { frames, damagedSlices };
+}
+async function decodeFrame(frameBytes) {
+  const engine = createZstdDecompress();
+  const chunks = [];
+  await pipeline(
+    Readable.from([frameBytes]),
+    engine,
+    new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    })
+  );
+  const decoded = Buffer.concat(chunks);
+  const frameConsumed = engine.bytesWritten === frameBytes.length;
+  if (decoded.length === 0 || !frameConsumed) {
+    throw new DshSessionLogUnreadableError("DSH session log frame is incomplete");
+  }
+  return decoded;
+}
+function splitJsonlLines(text) {
+  const lines = [];
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (line.length > 0) {
+      lines.push(line);
+    }
+  }
+  return lines;
+}
+async function readDshSessionLog(filePath) {
+  const contents = await readFile4(filePath);
+  if (!filePath.toLowerCase().endsWith(".zstd")) {
+    return {
+      lines: splitJsonlLines(contents.toString("utf8")),
+      skippedRowReasons: []
+    };
+  }
+  const lines = [];
+  let decodedFrames = 0;
+  const { frames, damagedSlices } = collectFrameSlices(contents);
+  let undecodableFrames = damagedSlices;
+  for (const frameBytes of frames) {
+    try {
+      const decoded = await decodeFrame(frameBytes);
+      decodedFrames += 1;
+      lines.push(...splitJsonlLines(decoded.toString("utf8")));
+    } catch {
+      undecodableFrames += 1;
+    }
+  }
+  if (decodedFrames === 0) {
+    throw new DshSessionLogUnreadableError();
+  }
+  return {
+    lines,
+    skippedRowReasons: undecodableFrames > 0 ? [{ reason: UNDECODABLE_FRAME_REASON, count: undecodableFrames }] : []
+  };
+}
+
+// src/sources/dsh/dsh-path-resolver.ts
 import os11 from "os";
 import path16 from "path";
-var defaultGeminiDir = path16.join(os11.homedir(), ".gemini");
+function resolveDshHome(options) {
+  const configuredHome = asTrimmedText(options.env.DSH_HOME);
+  if (!configuredHome) {
+    return path16.join(options.homeDir, ".dsh");
+  }
+  if (configuredHome === "~") {
+    return options.homeDir;
+  }
+  if (configuredHome.startsWith("~/") || configuredHome.startsWith("~\\")) {
+    return path16.join(options.homeDir, configuredHome.slice(2));
+  }
+  return configuredHome;
+}
+function getDefaultDshSessionsDir(options = {}) {
+  const resolvedOptions = {
+    env: options.env ?? process.env,
+    homeDir: options.homeDir ?? os11.homedir()
+  };
+  return path16.join(resolveDshHome(resolvedOptions), "sessions");
+}
+
+// src/sources/dsh/dsh-source-adapter.ts
+var DSH_SESSION_LOG_FILENAME_PATTERN = /^session(?:\.v[1-9][0-9]*)?\.jsonl(?:\.zstd)?$/u;
+var DSH_ASSISTANT_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"assistant\/message"/u;
+var DSH_SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
+var DSH_TITLE_REQUEST_LINE_PATTERN = /"type"\s*:\s*"session\/title-llm-request"/u;
+function shouldParseDshJsonlLine(lineText) {
+  return DSH_ASSISTANT_MESSAGE_LINE_PATTERN.test(lineText) || DSH_SESSION_LINE_PATTERN.test(lineText) || DSH_TITLE_REQUEST_LINE_PATTERN.test(lineText);
+}
+function isDshSessionLogFile(fileName) {
+  return DSH_SESSION_LOG_FILENAME_PATTERN.test(fileName);
+}
+function getFallbackSessionId4(filePath) {
+  const parentDirName = path17.basename(path17.dirname(filePath));
+  if (parentDirName.startsWith("session-")) {
+    return parentDirName;
+  }
+  return path17.basename(filePath).replace(/\.zstd$/u, "");
+}
+function resolveRoute(record) {
+  const route = asRecord(record?.route) ?? record;
+  return {
+    provider: asTrimmedText(route?.provider),
+    model: asTrimmedText(route?.model)
+  };
+}
+function extractUsage2(usage) {
+  const extracted = {
+    inputTokens: toNumberLike(usage.inputTokens),
+    outputTokens: toNumberLike(usage.outputTokens),
+    reasoningTokens: toNumberLike(usage.reasoningTokens),
+    cacheReadTokens: toNumberLike(usage.cacheReadTokens),
+    cacheWriteTokens: toNumberLike(usage.cacheWriteTokens),
+    totalTokens: toNumberLike(usage.totalTokens)
+  };
+  const usageCandidates = [
+    extracted.inputTokens,
+    extracted.outputTokens,
+    extracted.reasoningTokens,
+    extracted.cacheReadTokens,
+    extracted.cacheWriteTokens,
+    extracted.totalTokens
+  ];
+  return hasPositiveUsageOrCostSignal(usageCandidates, void 0) ? extracted : void 0;
+}
+function resolveTimestamp3(line) {
+  const time = line.time;
+  if (typeof time !== "number" || !Number.isFinite(time)) {
+    return void 0;
+  }
+  const date = new Date(time);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+var DshSourceAdapter = class {
+  id = "dsh";
+  rootDirs;
+  requireDir;
+  constructor(options = {}) {
+    this.rootDirs = resolveRootDirs(
+      options.dir,
+      options.defaultRootDirs ?? [
+        getDefaultDshSessionsDir({ env: options.env, homeDir: options.homeDir })
+      ]
+    );
+    this.requireDir = options.requireDir ?? false;
+  }
+  async discoverFiles() {
+    return discoverFilesAcrossRoots({
+      rootDirs: this.rootDirs,
+      requireDir: this.requireDir,
+      directoryLabel: "DSH sessions directory",
+      sortAcrossRoots: true,
+      discoverInRoot: async (rootDir) => {
+        const discovered = [
+          ...await discoverFiles(rootDir, { extension: ".jsonl" }),
+          ...await discoverFiles(rootDir, { extension: ".jsonl.zstd" })
+        ];
+        return discovered.filter((filePath) => isDshSessionLogFile(path17.basename(filePath)));
+      }
+    });
+  }
+  async parseFile(filePath) {
+    const { events } = await this.parseFileWithDiagnostics(filePath);
+    return events;
+  }
+  async parseFileWithDiagnostics(filePath) {
+    const events = [];
+    const skippedRowReasons = /* @__PURE__ */ new Map();
+    const state = { sessionId: getFallbackSessionId4(filePath) };
+    let skippedRows = 0;
+    let log;
+    try {
+      log = await readDshSessionLog(filePath);
+    } catch (error) {
+      if (error instanceof DshSessionLogUnreadableError) {
+        return toParseDiagnostics(events, 1, /* @__PURE__ */ new Map([["file_parse_failed", 1]]));
+      }
+      throw error;
+    }
+    for (const reasonStat of log.skippedRowReasons) {
+      incrementSkippedReason(skippedRowReasons, reasonStat.reason);
+      skippedRows += reasonStat.count;
+    }
+    for (const lineText of log.lines) {
+      if (!shouldParseDshJsonlLine(lineText)) {
+        continue;
+      }
+      let line;
+      try {
+        const parsedLine = asRecord(JSON.parse(lineText));
+        if (!parsedLine) {
+          continue;
+        }
+        line = parsedLine;
+      } catch {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "json_parse_error");
+        continue;
+      }
+      if (line.type === "session") {
+        state.sessionId = asTrimmedText(line.id) ?? state.sessionId;
+        state.repoRoot = asTrimmedText(line.cwd) ?? state.repoRoot;
+        continue;
+      }
+      if (line.type === "session/title-llm-request") {
+        const route = resolveRoute(asRecord(line.data));
+        state.provider = route.provider ?? state.provider;
+        state.model = route.model ?? state.model;
+        continue;
+      }
+      if (line.type !== "assistant/message") {
+        continue;
+      }
+      const data = asRecord(line.data);
+      const message = asRecord(data?.message);
+      const usage = asRecord(data?.usage);
+      if (!usage) {
+        continue;
+      }
+      const extractedUsage = extractUsage2(usage);
+      if (!extractedUsage) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "no_token_usage");
+        continue;
+      }
+      const timestamp = resolveTimestamp3(line);
+      if (!timestamp || !state.sessionId) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
+        continue;
+      }
+      const source = asRecord(message?.source);
+      const provider = asTrimmedText(source?.provider) ?? state.provider;
+      const model = asTrimmedText(source?.model) ?? state.model;
+      try {
+        events.push(
+          createUsageEvent({
+            source: this.id,
+            sessionId: state.sessionId,
+            timestamp,
+            repoRoot: state.repoRoot,
+            provider,
+            model,
+            ...extractedUsage
+          })
+        );
+      } catch {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "event_creation_failed");
+        continue;
+      }
+    }
+    return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+  }
+};
+
+// src/sources/gemini/gemini-source-adapter.ts
+import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import os12 from "os";
+import path18 from "path";
+var defaultGeminiDir = path18.join(os12.homedir(), ".gemini");
 function resolveDefaultGeminiDir(env) {
   return asTrimmedText(env.GEMINI_CLI_HOME) ?? defaultGeminiDir;
 }
 function getProjectsJsonPath(geminiDir) {
-  return path16.join(geminiDir, "projects.json");
+  return path18.join(geminiDir, "projects.json");
 }
 function parseProjectsJson(data) {
   const mapping = /* @__PURE__ */ new Map();
@@ -6814,7 +7239,7 @@ function parseProjectsJson(data) {
 async function loadProjectsJson(geminiDir) {
   const projectsPath = getProjectsJsonPath(geminiDir);
   try {
-    const content = await readFile4(projectsPath, "utf8");
+    const content = await readFile5(projectsPath, "utf8");
     const parsed = JSON.parse(content);
     return parseProjectsJson(parsed);
   } catch (error) {
@@ -6825,7 +7250,7 @@ async function loadProjectsJson(geminiDir) {
   }
 }
 async function discoverSessionFiles(geminiDir) {
-  const tmpDir = path16.join(geminiDir, "tmp");
+  const tmpDir = path18.join(geminiDir, "tmp");
   let projectEntries;
   try {
     projectEntries = await readdir2(tmpDir, { withFileTypes: true, encoding: "utf8" });
@@ -6842,7 +7267,7 @@ async function discoverSessionFiles(geminiDir) {
     if (!projectEntry.isDirectory() && !projectEntry.isSymbolicLink()) {
       continue;
     }
-    const chatsDir = path16.join(tmpDir, projectEntry.name, "chats");
+    const chatsDir = path18.join(tmpDir, projectEntry.name, "chats");
     const discoveredChatFiles = await discoverFiles(chatsDir, { extension: ".json" });
     allSessionFiles.push(...discoveredChatFiles);
   }
@@ -6856,9 +7281,9 @@ function resolveRepoRoot(filePath, sessionData, projectMapping) {
       return mappedRoot;
     }
   }
-  const chatsDir = path16.dirname(filePath);
-  const projectDir = path16.dirname(chatsDir);
-  const projectIdentifier = path16.basename(projectDir);
+  const chatsDir = path18.dirname(filePath);
+  const projectDir = path18.dirname(chatsDir);
+  const projectIdentifier = path18.basename(projectDir);
   return projectMapping.get(projectIdentifier);
 }
 function toFiniteNumber3(value) {
@@ -6967,7 +7392,7 @@ var GeminiSourceAdapter = class {
       incrementSkippedReason(skippedRowReasons, "invalid_session_data");
       return toParseDiagnostics(events, skippedRows, skippedRowReasons);
     }
-    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path16.basename(filePath, ".json");
+    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path18.basename(filePath, ".json");
     const projectMapping = await this.getProjectMappingForParse();
     const repoRoot = resolveRepoRoot(filePath, sessionDataRecord, projectMapping);
     if (!Array.isArray(sessionDataRecord.messages)) {
@@ -7024,8 +7449,8 @@ var GeminiSourceAdapter = class {
 };
 
 // src/sources/goose/goose-db-path-resolver.ts
-import os12 from "os";
-import path17 from "path";
+import os13 from "os";
+import path19 from "path";
 function deduplicate(paths) {
   return [...new Set(paths)];
 }
@@ -7037,36 +7462,36 @@ function normalizeEnvPath3(value) {
   return normalized || void 0;
 }
 function getGooseDbPath(rootDir) {
-  return path17.join(rootDir, "goose", "sessions", "sessions.db");
+  return path19.join(rootDir, "goose", "sessions", "sessions.db");
 }
 function getLinuxLikeCandidates(homeDir, env) {
-  const xdgDataHome = normalizeEnvPath3(env.XDG_DATA_HOME) ?? path17.join(homeDir, ".local", "share");
+  const xdgDataHome = normalizeEnvPath3(env.XDG_DATA_HOME) ?? path19.join(homeDir, ".local", "share");
   return [
     getGooseDbPath(xdgDataHome),
-    path17.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
+    path19.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
   ];
 }
 function getMacOsCandidates(homeDir) {
   return [
-    path17.join(homeDir, "Library", "Application Support", "goose", "sessions", "sessions.db"),
-    path17.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
+    path19.join(homeDir, "Library", "Application Support", "goose", "sessions", "sessions.db"),
+    path19.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
   ];
 }
 function getWindowsCandidates(homeDir, env) {
   const userProfile = normalizeEnvPath3(env.USERPROFILE);
-  const roamingBase = normalizeEnvPath3(env.APPDATA) ?? normalizeEnvPath3(env.LOCALAPPDATA) ?? (userProfile ? path17.join(userProfile, "AppData", "Roaming") : void 0);
+  const roamingBase = normalizeEnvPath3(env.APPDATA) ?? normalizeEnvPath3(env.LOCALAPPDATA) ?? (userProfile ? path19.join(userProfile, "AppData", "Roaming") : void 0);
   const roamingCandidates = roamingBase ? [getGooseDbPath(roamingBase)] : [];
   return [
     ...roamingCandidates,
-    path17.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
+    path19.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
   ];
 }
 function getDefaultGooseDbPathCandidates(options = {}) {
   const platform = options.platform ?? process.platform;
-  const homeDir = options.homeDir ?? os12.homedir();
+  const homeDir = options.homeDir ?? os13.homedir();
   const env = options.env ?? process.env;
   const goosePathRoot = normalizeEnvPath3(env.GOOSE_PATH_ROOT);
-  const envCandidates = goosePathRoot ? [path17.join(goosePathRoot, "data", "sessions", "sessions.db")] : [];
+  const envCandidates = goosePathRoot ? [path19.join(goosePathRoot, "data", "sessions", "sessions.db")] : [];
   switch (platform) {
     case "win32":
       return deduplicate([...envCandidates, ...getWindowsCandidates(homeDir, env)]);
@@ -7255,11 +7680,11 @@ var GooseSourceAdapter = class {
 };
 
 // src/sources/kimi/kimi-source-adapter.ts
-import { readFile as readFile5 } from "fs/promises";
-import os13 from "os";
-import path18 from "path";
-var defaultKimiCliSessionsDir = path18.join(os13.homedir(), ".kimi", "sessions");
-var defaultKimiCodeSessionsDir = path18.join(os13.homedir(), ".kimi-code", "sessions");
+import { readFile as readFile6 } from "fs/promises";
+import os14 from "os";
+import path20 from "path";
+var defaultKimiCliSessionsDir = path20.join(os14.homedir(), ".kimi", "sessions");
+var defaultKimiCodeSessionsDir = path20.join(os14.homedir(), ".kimi-code", "sessions");
 var defaultRootDirs = [defaultKimiCliSessionsDir, defaultKimiCodeSessionsDir];
 var KIMI_STATUS_UPDATE_LINE_TEXT = '"StatusUpdate"';
 var KIMI_USAGE_RECORD_LINE_TEXT = '"usage.record"';
@@ -7306,18 +7731,18 @@ function incrementContextSkippedReason3(context, reason) {
   incrementSkippedReason(context.skippedRowReasons, reason);
 }
 function getCliSessionId(filePath) {
-  return path18.basename(path18.dirname(filePath));
+  return path20.basename(path20.dirname(filePath));
 }
 function getCliConfigPath(filePath) {
-  const sessionsDir = path18.dirname(path18.dirname(path18.dirname(filePath)));
-  return path18.join(path18.dirname(sessionsDir), "config.json");
+  const sessionsDir = path20.dirname(path20.dirname(path20.dirname(filePath)));
+  return path20.join(path20.dirname(sessionsDir), "config.json");
 }
 function isCodeWireFile(filePath) {
-  return path18.basename(path18.dirname(path18.dirname(filePath))) === "agents";
+  return path20.basename(path20.dirname(path20.dirname(filePath))) === "agents";
 }
 async function readCliConfigModel(filePath) {
   try {
-    const content = await readFile5(getCliConfigPath(filePath), "utf8");
+    const content = await readFile6(getCliConfigPath(filePath), "utf8");
     return asTrimmedText(asRecord(JSON.parse(content))?.model);
   } catch {
     return void 0;
@@ -7327,10 +7752,10 @@ function getCliFallbackModel(timestamp) {
   return Date.parse(timestamp) < KIMI_K2_6_CUTOFF_MS ? KIMI_K2_5_MODEL : KIMI_K2_6_MODEL;
 }
 function getCodeSessionId(filePath) {
-  const agentDir = path18.dirname(filePath);
-  const agentsDir = path18.dirname(agentDir);
-  const sessionDir = path18.dirname(agentsDir);
-  return path18.basename(sessionDir);
+  const agentDir = path20.dirname(filePath);
+  const agentsDir = path20.dirname(agentDir);
+  const sessionDir = path20.dirname(agentsDir);
+  return path20.basename(sessionDir);
 }
 function normalizeKimiCodeModel(model) {
   const normalizedModel = asTrimmedText(model);
@@ -7431,7 +7856,7 @@ function parseUsageRecordLine(context, filePath, line) {
 }
 async function discoverWireFiles(rootDir) {
   const jsonlFiles = await discoverFiles(rootDir, { extension: ".jsonl" });
-  return jsonlFiles.filter((filePath) => path18.basename(filePath) === "wire.jsonl");
+  return jsonlFiles.filter((filePath) => path20.basename(filePath) === "wire.jsonl");
 }
 var KimiSourceAdapter = class {
   id = "kimi";
@@ -7492,8 +7917,8 @@ var KimiSourceAdapter = class {
 
 // src/sources/opencode/opencode-db-path-resolver.ts
 import { readdirSync } from "fs";
-import os14 from "os";
-import path19 from "path";
+import os15 from "os";
+import path21 from "path";
 var CHANNEL_DB_FILE_PATTERN = /^opencode-.+\.db$/u;
 function deduplicate2(paths) {
   return [...new Set(paths)];
@@ -7516,34 +7941,34 @@ function listChannelDbFileNames(directory) {
 }
 function getDirectoryCandidates(directory) {
   return [
-    path19.join(directory, "opencode.db"),
-    ...listChannelDbFileNames(directory).map((fileName) => path19.join(directory, fileName)),
-    path19.join(directory, "db.sqlite")
+    path21.join(directory, "opencode.db"),
+    ...listChannelDbFileNames(directory).map((fileName) => path21.join(directory, fileName)),
+    path21.join(directory, "db.sqlite")
   ];
 }
 function getLinuxLikeCandidates2(homeDir, env) {
-  const xdgDataHome = normalizeEnvPath4(env.XDG_DATA_HOME) ?? path19.join(homeDir, ".local", "share");
+  const xdgDataHome = normalizeEnvPath4(env.XDG_DATA_HOME) ?? path21.join(homeDir, ".local", "share");
   return [
-    ...getDirectoryCandidates(path19.join(xdgDataHome, "opencode")),
-    ...getDirectoryCandidates(path19.join(homeDir, ".opencode"))
+    ...getDirectoryCandidates(path21.join(xdgDataHome, "opencode")),
+    ...getDirectoryCandidates(path21.join(homeDir, ".opencode"))
   ];
 }
 function getMacOsCandidates2(homeDir) {
-  const appSupportDir = path19.join(homeDir, "Library", "Application Support");
+  const appSupportDir = path21.join(homeDir, "Library", "Application Support");
   return [
-    ...getDirectoryCandidates(path19.join(appSupportDir, "opencode")),
-    ...getDirectoryCandidates(path19.join(homeDir, ".opencode"))
+    ...getDirectoryCandidates(path21.join(appSupportDir, "opencode")),
+    ...getDirectoryCandidates(path21.join(homeDir, ".opencode"))
   ];
 }
 function getWindowsCandidates2(homeDir, env) {
   const userProfile = normalizeEnvPath4(env.USERPROFILE);
-  const roamingBase = normalizeEnvPath4(env.APPDATA) ?? normalizeEnvPath4(env.LOCALAPPDATA) ?? (userProfile ? path19.join(userProfile, "AppData", "Roaming") : void 0);
-  const roamingCandidates = roamingBase ? getDirectoryCandidates(path19.join(roamingBase, "opencode")) : [];
-  return [...roamingCandidates, ...getDirectoryCandidates(path19.join(homeDir, ".opencode"))];
+  const roamingBase = normalizeEnvPath4(env.APPDATA) ?? normalizeEnvPath4(env.LOCALAPPDATA) ?? (userProfile ? path21.join(userProfile, "AppData", "Roaming") : void 0);
+  const roamingCandidates = roamingBase ? getDirectoryCandidates(path21.join(roamingBase, "opencode")) : [];
+  return [...roamingCandidates, ...getDirectoryCandidates(path21.join(homeDir, ".opencode"))];
 }
 function getDefaultOpenCodeDbPathCandidates(options = {}) {
   const platform = options.platform ?? process.platform;
-  const homeDir = options.homeDir ?? os14.homedir();
+  const homeDir = options.homeDir ?? os15.homedir();
   const env = options.env ?? process.env;
   switch (platform) {
     case "win32":
@@ -7556,7 +7981,7 @@ function getDefaultOpenCodeDbPathCandidates(options = {}) {
 }
 
 // src/sources/opencode/opencode-row-parser.ts
-function resolveTimestamp3(rowTimestamp, messagePayload) {
+function resolveTimestamp4(rowTimestamp, messagePayload) {
   const timestampCandidates = [
     rowTimestamp,
     messagePayload.timestamp,
@@ -7634,7 +8059,7 @@ function parseOpenCodeMessageRows(rows, sourceId) {
     if (role?.toLowerCase() !== "assistant") {
       continue;
     }
-    const timestamp = resolveTimestamp3(row.row_time, payload);
+    const timestamp = resolveTimestamp4(row.row_time, payload);
     if (!timestamp) {
       recordSkippedRow("missing_timestamp");
       continue;
@@ -7979,11 +8404,11 @@ var OpenCodeSourceAdapter = class {
 };
 
 // src/sources/openclaw/openclaw-source-adapter.ts
-import os15 from "os";
-import path21 from "path";
+import os16 from "os";
+import path23 from "path";
 
 // src/sources/openclaw/openclaw-session-parser.ts
-import path20 from "path";
+import path22 from "path";
 var SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
 var MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 var MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
@@ -7993,8 +8418,8 @@ var PROVIDER_LINE_PATTERN = /"provider"\s*:/u;
 function shouldParseOpenClawJsonlLine(lineText) {
   return SESSION_LINE_PATTERN.test(lineText) || MESSAGE_LINE_PATTERN.test(lineText) || MODEL_CHANGE_LINE_PATTERN.test(lineText) || USAGE_LINE_PATTERN.test(lineText) || MODEL_LINE_PATTERN.test(lineText) || PROVIDER_LINE_PATTERN.test(lineText);
 }
-function getFallbackSessionId4(filePath) {
-  return path20.basename(filePath, ".jsonl");
+function getFallbackSessionId5(filePath) {
+  return path22.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord(record) {
   if (!record) {
@@ -8060,14 +8485,14 @@ function mergeUsageExtracts(primary, fallback) {
     costUsd: primary.costUsd ?? fallback.costUsd
   };
 }
-function extractUsage2(line, message) {
+function extractUsage3(line, message) {
   const lineUsage = asRecord(line.usage);
   const messageUsage = asRecord(message.usage);
   const extractedLineUsage = lineUsage ? extractUsageFromRecord(lineUsage) : void 0;
   const extractedMessageUsage = messageUsage ? extractUsageFromRecord(messageUsage) : void 0;
   return mergeUsageExtracts(extractedLineUsage, extractedMessageUsage);
 }
-function resolveTimestamp4(line, message, state, fallbackTimestamp) {
+function resolveTimestamp5(line, message, state, fallbackTimestamp) {
   const candidates = [line.timestamp, message.timestamp, fallbackTimestamp, state.sessionTimestamp];
   for (const candidate of candidates) {
     const normalizedTimestamp = normalizeTimestampCandidate(candidate);
@@ -8103,7 +8528,7 @@ async function parseOpenClawSessionFile(sourceId, filePath) {
   const fileStats = await pathStat(filePath);
   const fallbackTimestamp = fileStats?.mtime.toISOString();
   const state = {
-    sessionId: getFallbackSessionId4(filePath)
+    sessionId: getFallbackSessionId5(filePath)
   };
   for await (const line of readJsonlObjects(filePath, {
     shouldParseLine: shouldParseOpenClawJsonlLine,
@@ -8149,11 +8574,11 @@ async function parseOpenClawSessionFile(sourceId, filePath) {
     updateRuntimeStateFromRecord(state, line, message);
     const provider = rowProvider ?? state.provider;
     const model = rowModel ?? state.model;
-    const usage = extractUsage2(line, message);
+    const usage = extractUsage3(line, message);
     if (!usage) {
       continue;
     }
-    const timestamp = resolveTimestamp4(line, message, state, fallbackTimestamp);
+    const timestamp = resolveTimestamp5(line, message, state, fallbackTimestamp);
     if (!timestamp) {
       continue;
     }
@@ -8179,12 +8604,12 @@ async function parseOpenClawSessionFile(sourceId, filePath) {
 }
 
 // src/sources/openclaw/openclaw-source-adapter.ts
-var defaultAgentsDir = path21.join(os15.homedir(), ".openclaw", "agents");
+var defaultAgentsDir = path23.join(os16.homedir(), ".openclaw", "agents");
 var defaultOpenClawRootDirs = [
   defaultAgentsDir,
-  path21.join(os15.homedir(), ".clawdbot", "agents"),
-  path21.join(os15.homedir(), ".moltbot", "agents"),
-  path21.join(os15.homedir(), ".moldbot", "agents")
+  path23.join(os16.homedir(), ".clawdbot", "agents"),
+  path23.join(os16.homedir(), ".moltbot", "agents"),
+  path23.join(os16.homedir(), ".moldbot", "agents")
 ];
 var OpenClawSourceAdapter = class {
   id = "openclaw";
@@ -8214,12 +8639,12 @@ var OpenClawSourceAdapter = class {
 };
 
 // src/sources/pi/pi-source-adapter.ts
-import os16 from "os";
-import path22 from "path";
-var defaultSessionsDir3 = path22.join(os16.homedir(), ".pi", "agent", "sessions");
+import os17 from "os";
+import path24 from "path";
+var defaultSessionsDir3 = path24.join(os17.homedir(), ".pi", "agent", "sessions");
 var defaultPiRootDirs = [
   defaultSessionsDir3,
-  path22.join(os16.homedir(), ".omp", "agent", "sessions")
+  path24.join(os17.homedir(), ".omp", "agent", "sessions")
 ];
 var PI_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 var PI_SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
@@ -8227,7 +8652,7 @@ var PI_MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
 function shouldParsePiJsonlLine(lineText) {
   return PI_MESSAGE_LINE_PATTERN.test(lineText) || PI_SESSION_LINE_PATTERN.test(lineText) || PI_MODEL_CHANGE_LINE_PATTERN.test(lineText);
 }
-function resolveTimestamp5(line, message, state) {
+function resolveTimestamp6(line, message, state) {
   const candidates = [line.timestamp, message?.timestamp, state.sessionTimestamp];
   for (const candidate of candidates) {
     const normalizedTimestamp = normalizeTimestampCandidate(candidate);
@@ -8260,7 +8685,7 @@ function extractUsageFromRecord2(usage) {
   ];
   return hasPositiveUsageOrCostSignal(usageCandidates, extracted.costUsd) ? extracted : void 0;
 }
-function extractUsage3(line, message) {
+function extractUsage4(line, message) {
   const lineUsage = asRecord(line.usage);
   const messageUsage = asRecord(message?.usage);
   if (lineUsage) {
@@ -8274,8 +8699,8 @@ function extractUsage3(line, message) {
   }
   return extractUsageFromRecord2(messageUsage);
 }
-function getFallbackSessionId5(filePath) {
-  return path22.basename(filePath, ".jsonl");
+function getFallbackSessionId6(filePath) {
+  return path24.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord2(record) {
   if (!record) {
@@ -8308,7 +8733,7 @@ var PiSourceAdapter = class {
     const events = [];
     let skippedRows = 0;
     const skippedRowReasons = /* @__PURE__ */ new Map();
-    const state = { sessionId: getFallbackSessionId5(filePath) };
+    const state = { sessionId: getFallbackSessionId6(filePath) };
     for await (const line of readJsonlObjects(filePath, {
       shouldParseLine: shouldParsePiJsonlLine,
       onMalformedLine: () => {
@@ -8332,7 +8757,7 @@ var PiSourceAdapter = class {
         continue;
       }
       const message = asRecord(line.message);
-      const usage = extractUsage3(line, message);
+      const usage = extractUsage4(line, message);
       if (!usage) {
         const hasUsageRecord = Boolean(asRecord(line.usage) ?? asRecord(message?.usage));
         if (hasUsageRecord) {
@@ -8342,7 +8767,7 @@ var PiSourceAdapter = class {
         continue;
       }
       const provider = asTrimmedText(line.provider) ?? asTrimmedText(message?.provider) ?? state.provider;
-      const timestamp = resolveTimestamp5(line, message, state);
+      const timestamp = resolveTimestamp6(line, message, state);
       if (!timestamp || !state.sessionId) {
         skippedRows++;
         incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
@@ -8373,9 +8798,9 @@ var PiSourceAdapter = class {
 };
 
 // src/sources/qwen/qwen-source-adapter.ts
-import os17 from "os";
-import path23 from "path";
-var defaultProjectsDir = path23.join(os17.homedir(), ".qwen", "projects");
+import os18 from "os";
+import path25 from "path";
+var defaultProjectsDir = path25.join(os18.homedir(), ".qwen", "projects");
 var QWEN_USAGE_LINE_TEXT = '"usageMetadata"';
 function shouldParseQwenJsonlLine(lineText) {
   return lineText.includes(QWEN_USAGE_LINE_TEXT);
@@ -8409,11 +8834,11 @@ function extractTokenUsage2(usageMetadata) {
   }
   return extractedUsage;
 }
-function getFallbackSessionId6(filePath) {
-  const chatsDir = path23.dirname(filePath);
-  const projectDir = path23.dirname(chatsDir);
-  const projectName = path23.basename(projectDir);
-  const fileStem = path23.basename(filePath, ".jsonl");
+function getFallbackSessionId7(filePath) {
+  const chatsDir = path25.dirname(filePath);
+  const projectDir = path25.dirname(chatsDir);
+  const projectName = path25.basename(projectDir);
+  const fileStem = path25.basename(filePath, ".jsonl");
   return `${projectName}-${fileStem}`;
 }
 var QwenSourceAdapter = class {
@@ -8448,7 +8873,7 @@ var QwenSourceAdapter = class {
     const events = [];
     let skippedRows = 0;
     const skippedRowReasons = /* @__PURE__ */ new Map();
-    const fallbackSessionId = getFallbackSessionId6(filePath);
+    const fallbackSessionId = getFallbackSessionId7(filePath);
     for await (const line of readJsonlObjects(filePath, {
       shouldParseLine: shouldParseQwenJsonlLine,
       onMalformedLine: () => {
@@ -8517,8 +8942,8 @@ function parseSourceDirectoryOverrides(entries) {
 }
 
 // src/sources/create-default-adapters.ts
-var dirOptions = ({ path: path30, requireExistingPath }) => ({
-  dir: path30,
+var dirOptions = ({ path: path32, requireExistingPath }) => ({
+  dir: path32,
   requireDir: requireExistingPath
 });
 var sourceRegistrations = [
@@ -8567,7 +8992,7 @@ var sourceRegistrations = [
       flag: "--opencode-db <path>",
       help: "Path to OpenCode SQLite DB"
     },
-    create: ({ path: path30 }) => new OpenCodeSourceAdapter({ dbPath: path30 })
+    create: ({ path: path32 }) => new OpenCodeSourceAdapter({ dbPath: path32 })
   },
   {
     id: "openclaw",
@@ -8607,7 +9032,7 @@ var sourceRegistrations = [
     format: "sqlite",
     supportsSourceDir: false,
     option: { key: "gooseDb", flag: "--goose-db <path>", help: "Path to Goose SQLite DB" },
-    create: ({ path: path30 }) => new GooseSourceAdapter({ dbPath: path30 })
+    create: ({ path: path32 }) => new GooseSourceAdapter({ dbPath: path32 })
   },
   {
     id: "amp",
@@ -8681,6 +9106,17 @@ var sourceRegistrations = [
       help: "Path to Antigravity conversations directory"
     },
     create: (resolved) => new AntigravitySourceAdapter(dirOptions(resolved))
+  },
+  {
+    id: "dsh",
+    format: "jsonl",
+    supportsSourceDir: true,
+    option: {
+      key: "dshDir",
+      flag: "--dsh-dir <path>",
+      help: "Path to DeepSeek Harness sessions directory"
+    },
+    create: (resolved) => new DshSourceAdapter(dirOptions(resolved))
   }
 ];
 var dedicatedOptionOrderIds = [
@@ -8699,7 +9135,8 @@ var dedicatedOptionOrderIds = [
   "cline",
   "roocode",
   "kilocode",
-  "antigravity"
+  "antigravity",
+  "dsh"
 ];
 function dedicatedFlagName(flag) {
   return flag.split(" ")[0];
@@ -9009,7 +9446,8 @@ var sourceDirOptionByConfigKey = {
   cline: "clineDir",
   roocode: "roocodeDir",
   kilocode: "kilocodeDir",
-  antigravity: "antigravityDir"
+  antigravity: "antigravityDir",
+  dsh: "dshDir"
 };
 var sourceDirConfigKeys = [
   "pi",
@@ -9027,7 +9465,8 @@ var sourceDirConfigKeys = [
   "cline",
   "roocode",
   "kilocode",
-  "antigravity"
+  "antigravity",
+  "dsh"
 ];
 function formatConfigValue(value) {
   if (Array.isArray(value)) {
@@ -9309,13 +9748,13 @@ function readLiveHashCounts(store) {
   const rows = store.database.prepare(
     [
       "SELECT events.content_hash AS content_hash, COUNT(*) AS count",
-      "FROM events",
-      "JOIN history_discovered_files AS discovered",
-      "  ON events.source = discovered.source",
-      "  AND events.file_path = discovered.file_path",
+      "FROM history_discovered_files AS discovered",
       "JOIN history_selected_sources AS selected",
-      "  ON events.source = selected.source",
-      "WHERE events.content_hash IS NOT NULL",
+      "  ON discovered.source = selected.source",
+      "CROSS JOIN events",
+      "WHERE events.source = discovered.source",
+      "  AND events.file_path = discovered.file_path",
+      "  AND events.content_hash IS NOT NULL",
       "GROUP BY events.content_hash"
     ].join("\n")
   ).all();
@@ -9391,9 +9830,9 @@ function readDepartedHashMultisets(store) {
     [
       "SELECT events.source AS source, events.file_path AS file_path,",
       "  events.content_hash AS content_hash, COUNT(*) AS count",
-      "FROM events",
-      "JOIN history_departed_files AS departed",
-      "  ON events.source = departed.source",
+      "FROM history_departed_files AS departed",
+      "CROSS JOIN events",
+      "WHERE events.source = departed.source",
       "  AND events.file_path = departed.file_path",
       "GROUP BY events.source, events.file_path, events.content_hash"
     ].join("\n")
@@ -9458,9 +9897,9 @@ function loadServedEvents(store, servedFiles) {
       "  events.provider, events.repo_root, events.input_tokens, events.output_tokens,",
       "  events.reasoning_tokens, events.cache_read_tokens, events.cache_write_tokens,",
       "  events.total_tokens, events.cost_usd, events.cost_mode",
-      "FROM events",
-      "JOIN history_served_files AS served",
-      "  ON events.source = served.source",
+      "FROM history_served_files AS served",
+      "CROSS JOIN events",
+      "WHERE events.source = served.source",
       "  AND events.file_path = served.file_path",
       "ORDER BY served.ordinal ASC, events.event_index ASC"
     ].join("\n")
@@ -10133,7 +10572,12 @@ async function parseAdapterEvents(adapter, maxParallelFileParsing, runWithParseB
       fileIndices2,
       (fileIndex) => resolveStoreHitOrWorkerMiss(fileIndex, missedFiles)
     );
-    missedFiles.sort((left5, right4) => left5.fileIndex - right4.fileIndex);
+    missedFiles.sort((left5, right4) => {
+      if (left5.byteSize !== right4.byteSize) {
+        return right4.byteSize - left5.byteSize;
+      }
+      return left5.fileIndex - right4.fileIndex;
+    });
     const missedBytes = missedFiles.reduce(
       (sum, missedFile) => sum + Math.max(0, missedFile.byteSize),
       0
@@ -10452,7 +10896,7 @@ function applyPricingToEvents(events, pricingSource) {
 }
 
 // src/pricing/pricing-override-source.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 function toFiniteUsdRate(value) {
   if (value === null || value === void 0) {
     return void 0;
@@ -10508,7 +10952,7 @@ function normalizeOverrideFile(payload) {
   return overrides;
 }
 async function loadPricingOverrides(filePath) {
-  const fileContents = await readFile6(filePath, "utf8");
+  const fileContents = await readFile7(filePath, "utf8");
   const parsed = JSON.parse(fileContents);
   return normalizeOverrideFile(parsed);
 }
@@ -10535,8 +10979,8 @@ var PricingOverrideSource = class {
 };
 
 // src/pricing/litellm-pricing-fetcher.ts
-import { mkdir as mkdir3, readFile as readFile7, writeFile as writeFile2 } from "fs/promises";
-import path24 from "path";
+import { mkdir as mkdir3, readFile as readFile8, writeFile as writeFile2 } from "fs/promises";
+import path26 from "path";
 
 // src/pricing/litellm-model-map.json
 var litellm_model_map_default = {
@@ -10571,10 +11015,11 @@ var litellm_model_map_default = {
     "anthropic/claude-sonnet-4.6": "claude-sonnet-4.6",
     "anthropic.claude-sonnet-4-6": "claude-sonnet-4.6"
   },
-  neverFuzzyMatch: ["kimi-for-coding"],
+  neverFuzzyMatch: ["deepseek-flash", "deepseek-v4.1-flash", "kimi-for-coding"],
   notes: {
     "gpt-5.3-codex-spark": "Alias to gpt-5.3-codex because upstream publishes token pricing on the gpt-5.3-codex key",
     "gemini-3-flash-a": "Antigravity session data records gemini-3 models with an '-a' suffix (gemini-3-flash-a, gemini-3-pro-a); alias them to the canonical gemini-3 models",
+    "deepseek-flash": "Deliberately NOT aliased: DeepSeek Harness reports its default route as deepseek-flash, which its catalog names DeepSeek-V41-Flash. LiteLLM publishes no v4.1 key (bundled snapshot or upstream main), and deepseek-v4-flash is the earlier V4 model at its own much lower rates, so any alias would silently bill V4.1 traffic at another model's prices. Fuzzy matching is blocked so the row stays visibly unpriced until a real key exists; the published V4.1 rate card is listed in site/src/content/docs/sources/dsh.mdx for use with --pricing-overrides",
     "kimi-for-coding": "Deliberately NOT aliased: the managed kimi-for-coding endpoint maps to kimi-k2.5 or kimi-k2.6 depending on the event timestamp. The kimi adapter resolves that fallback itself; a config-provided kimi-for-coding model stays unpriced rather than mispriced"
   },
   preferredPricingKeyByCanonicalModel: {
@@ -21817,7 +22262,7 @@ function formatBundledSnapshotWarning(fetchedAt) {
   return `Pricing: using the bundled LiteLLM snapshot from ${fetchedDate} (run online to refresh).`;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path24.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
+  return path26.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
 }
 var LiteLLMPricingFetcher = class {
   sourceUrl;
@@ -22027,7 +22472,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile7(this.cacheFilePath, "utf8");
+      content = await readFile8(this.cacheFilePath, "utf8");
     } catch {
       return void 0;
     }
@@ -22040,7 +22485,7 @@ var LiteLLMPricingFetcher = class {
     return normalizeLiteLLMCachePayload(parsedPayload);
   }
   async writeCache() {
-    const directoryPath = path24.dirname(this.cacheFilePath);
+    const directoryPath = path26.dirname(this.cacheFilePath);
     await mkdir3(directoryPath, { recursive: true });
     const payload = {
       fetchedAt: this.now(),
@@ -23039,9 +23484,9 @@ function emitEnvVarOverrides(activeEnvOverrides, diagnosticsLogger) {
 import { spawn } from "child_process";
 import { constants as constants2 } from "fs";
 import { access as access2, writeFile as writeFile3 } from "fs/promises";
-import path25 from "path";
+import path27 from "path";
 async function writeShareSvgFile(fileName, svgContent) {
-  const outputPath = path25.resolve(process.cwd(), fileName);
+  const outputPath = path27.resolve(process.cwd(), fileName);
   await writeFile3(outputPath, svgContent, "utf8");
   return outputPath;
 }
@@ -23069,10 +23514,10 @@ async function resolveBinaryPath(primaryPath, fallbackNames) {
   if (await fileExists(primaryPath)) {
     return primaryPath;
   }
-  const pathDirs = (process.env.PATH ?? "").split(path25.delimiter).filter(Boolean);
+  const pathDirs = (process.env.PATH ?? "").split(path27.delimiter).filter(Boolean);
   for (const fallbackName of fallbackNames) {
     for (const dir of pathDirs) {
-      const candidate = path25.join(dir, fallbackName);
+      const candidate = path27.join(dir, fallbackName);
       if (await fileExists(candidate)) {
         return candidate;
       }
@@ -23943,7 +24388,7 @@ function aggregateEfficiency(options) {
 // src/efficiency/git-outcome-collector.ts
 import { spawn as spawn2 } from "child_process";
 import { createInterface } from "readline";
-import path26 from "path";
+import path28 from "path";
 import { stat as stat5 } from "fs/promises";
 var GIT_COMMIT_MARKER = "";
 var SHORTSTAT_PATTERN = /(\d+)\s+files?\s+changed(?:,\s+(\d+)\s+insertions?\(\+\))?(?:,\s+(\d+)\s+deletions?\(-\))?/u;
@@ -23963,13 +24408,13 @@ function resolveGitCommandFailureReason(result) {
 }
 function resolveRepoDir(repoDir) {
   if (repoDir === void 0) {
-    return path26.resolve(process.cwd());
+    return path28.resolve(process.cwd());
   }
   const normalizedRepoDir = repoDir.trim();
   if (!normalizedRepoDir) {
     throw new Error("--repo-dir must be a non-empty path");
   }
-  return path26.resolve(normalizedRepoDir);
+  return path28.resolve(normalizedRepoDir);
 }
 function getNodeErrorCode2(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) {
@@ -24350,21 +24795,21 @@ async function collectGitOutcomes(options, deps = {}) {
 
 // src/efficiency/repo-attribution.ts
 import { access as access3, constants as constants3, realpath as realpath3 } from "fs/promises";
-import path27 from "path";
+import path29 from "path";
 async function hasGitMarker(directoryPath) {
   try {
-    await access3(path27.join(directoryPath, ".git"), constants3.F_OK);
+    await access3(path29.join(directoryPath, ".git"), constants3.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 function normalizeComparablePath(value) {
-  const normalizedPath = path27.normalize(path27.resolve(value));
+  const normalizedPath = path29.normalize(path29.resolve(value));
   return process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
 }
 async function resolveComparablePath(value) {
-  const resolvedPath = path27.resolve(value);
+  const resolvedPath = path29.resolve(value);
   try {
     return normalizeComparablePath(await realpath3(resolvedPath));
   } catch {
@@ -24376,12 +24821,12 @@ async function resolveRepoRootFromPathHint(pathHint) {
   if (!trimmedPath) {
     return void 0;
   }
-  let currentPath = path27.resolve(trimmedPath);
+  let currentPath = path29.resolve(trimmedPath);
   for (; ; ) {
     if (await hasGitMarker(currentPath)) {
       return currentPath;
     }
-    const parentPath = path27.dirname(currentPath);
+    const parentPath = path29.dirname(currentPath);
     if (parentPath === currentPath) {
       return void 0;
     }
@@ -24500,6 +24945,9 @@ function resolveScopeNote(options) {
   if (hasActiveTextOption(options.antigravityDir)) {
     activeFilters.push("--antigravity-dir");
   }
+  if (hasActiveTextOption(options.dshDir)) {
+    activeFilters.push("--dsh-dir");
+  }
   if (hasActiveRepeatedFilter(options.sourceDir)) {
     activeFilters.push("--source-dir");
   }
@@ -25441,7 +25889,7 @@ async function runOptimizeReport(granularity, options) {
 }
 
 // src/render/render-session-report.ts
-import path28 from "path";
+import path30 from "path";
 import { markdownTable as markdownTable4 } from "markdown-table";
 
 // src/render/format-duration.ts
@@ -25509,7 +25957,7 @@ function toSessionTableCells(row, options) {
   return [
     options.truncateSessionIds ? truncateSessionId(row.sessionId) : row.sessionId,
     row.source,
-    row.repoRoot ? path28.basename(row.repoRoot) : "-",
+    row.repoRoot ? path30.basename(row.repoRoot) : "-",
     getPeriodKey(row.lastActivity, "daily", options.timezone),
     formatDuration(row.durationMs),
     formatInteger4(row.totalTokens),
@@ -25519,7 +25967,7 @@ function toSessionTableCells(row, options) {
 }
 function toRepoTableCells(row, timezone) {
   return [
-    row.repoRoot ? path28.basename(row.repoRoot) : "(no repo)",
+    row.repoRoot ? path30.basename(row.repoRoot) : "(no repo)",
     formatInteger4(row.sessionCount),
     getPeriodKey(row.lastActivity, "daily", timezone),
     formatInteger4(row.totalTokens),
@@ -29144,7 +29592,7 @@ function createRootDescription() {
 
 // src/cli/create-config-command.ts
 import { access as access4, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path29 from "path";
+import path31 from "path";
 import { Command as Command2 } from "commander";
 var CONFIG_TEMPLATE_HEADER = `#:schema https://ayagmar.github.io/llm-usage-metrics/config-schema.json
 # llm-usage-metrics configuration. Uncomment a key to override its default.
@@ -29195,7 +29643,7 @@ function isExistingFileError(error) {
   return asRecord(error)?.code === "EEXIST";
 }
 async function writeConfigTemplate(configPath, options) {
-  await mkdir4(path29.dirname(configPath), { recursive: true });
+  await mkdir4(path31.dirname(configPath), { recursive: true });
   try {
     await writeFile4(configPath, USER_CONFIG_TEMPLATE, {
       encoding: "utf8",
@@ -29347,6 +29795,10 @@ var config_schema_default = {
         antigravity: {
           description: "Default path for Antigravity conversations; maps to --antigravity-dir.",
           type: "string"
+        },
+        dsh: {
+          description: "Default path for DeepSeek Harness sessions; maps to --dsh-dir.",
+          type: "string"
         }
       }
     },
@@ -30827,11 +31279,11 @@ mainPromise.catch((error) => {
 });
 /*! Bundled license information:
 
-smol-toml/dist/date.js:
 smol-toml/dist/error.js:
 smol-toml/dist/primitive.js:
-smol-toml/dist/util.js:
+smol-toml/dist/date.js:
 smol-toml/dist/extract.js:
+smol-toml/dist/util.js:
 smol-toml/dist/struct.js:
 smol-toml/dist/parse.js:
 smol-toml/dist/stringify.js: