@harness-engineering/cli 1.24.0 → 1.24.1

package/dist/{chunk-WPFFEDTO.js → chunk-PCWYYFBP.js}

@@ -5,8 +5,9 @@ import {
 } from "./chunk-5LMZA5LZ.js";
 import {
   GraphStore,
+  NODE_STABILITY,
   queryTraceability
-} from "./chunk-MY5DBCJZ.js";
+} from "./chunk-OZIHPMA7.js";
 
 // ../core/dist/chunk-4W4FRAA6.mjs
 import { z } from "zod";
@@ -139,17 +140,17 @@ function resolveFileToLayer(file, layers) {
 }
 var accessAsync = promisify(access);
 var readFileAsync = promisify(readFile);
-async function fileExists(path31) {
+async function fileExists(path34) {
   try {
-    await accessAsync(path31, constants.F_OK);
+    await accessAsync(path34, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path31) {
+async function readFileContent(path34) {
   try {
-    const content = await readFileAsync(path31, "utf-8");
+    const content = await readFileAsync(path34, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(error);
@@ -1952,6 +1953,13 @@ import * as path29 from "path";
 import * as fs31 from "fs";
 import * as path30 from "path";
 import * as os2 from "os";
+import * as fs32 from "fs";
+import * as path31 from "path";
+import * as fs34 from "fs";
+import * as path33 from "path";
+import * as fs33 from "fs";
+import * as path32 from "path";
+import * as crypto4 from "crypto";
 async function validateFileStructure(projectPath, conventions) {
   const missing = [];
   const unexpected = [];
@@ -1987,15 +1995,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path31 = firstError.path.join(".");
-    const pathDisplay = path31 ? ` at "${path31}"` : "";
+    const path34 = firstError.path.join(".");
+    const pathDisplay = path34 ? ` at "${path34}"` : "";
     if (firstError.code === "invalid_type") {
       const received = firstError.received;
       const expected = firstError.expected;
       if (received === "undefined") {
         code = "MISSING_FIELD";
         message = `Missing required field${pathDisplay}: ${firstError.message}`;
-        suggestions.push(`Field "${path31}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path34}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -2207,27 +2215,27 @@ function extractSections(content) {
   }
   return sections.map((section) => buildAgentMapSection(section, lines));
 }
-function isExternalLink(path31) {
-  return path31.startsWith("http://") || path31.startsWith("https://") || path31.startsWith("#") || path31.startsWith("mailto:");
+function isExternalLink(path34) {
+  return path34.startsWith("http://") || path34.startsWith("https://") || path34.startsWith("#") || path34.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? join4(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path31 = "./AGENTS.md") {
-  const contentResult = await readFileContent(path31);
+async function validateAgentsMap(path34 = "./AGENTS.md") {
+  const contentResult = await readFileContent(path34);
   if (!contentResult.ok) {
     return Err(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path31 },
+        { path: path34 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = dirname4(path31);
+  const baseDir = dirname4(path34);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -2361,8 +2369,8 @@ async function checkDocCoverage(domain, options = {}) {
     );
   }
 }
-function suggestFix(path31, existingFiles) {
-  const targetName = basename2(path31).toLowerCase();
+function suggestFix(path34, existingFiles) {
+  const targetName = basename2(path34).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = basename2(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -2370,7 +2378,7 @@ function suggestFix(path31, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path31}" or remove the link`;
+  return `Create the file "${path34}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
   const agentsPath = join22(rootDir, "AGENTS.md");
@@ -2711,8 +2719,8 @@ function createBoundaryValidator(schema, name) {
         return Ok(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path31 = issue.path.join(".");
-        return path31 ? `${path31}: ${issue.message}` : issue.message;
+        const path34 = issue.path.join(".");
+        return path34 ? `${path34}: ${issue.message}` : issue.message;
       });
       return Err(
         createError(
@@ -3322,11 +3330,11 @@ function processExportListSpecifiers(exportDecl, exports) {
 var TypeScriptParser = class {
   name = "typescript";
   extensions = [".ts", ".tsx", ".mts", ".cts"];
-  async parseFile(path31) {
-    const contentResult = await readFileContent(path31);
+  async parseFile(path34) {
+    const contentResult = await readFileContent(path34);
     if (!contentResult.ok) {
       return Err(
-        createParseError("NOT_FOUND", `File not found: ${path31}`, { path: path31 }, [
+        createParseError("NOT_FOUND", `File not found: ${path34}`, { path: path34 }, [
           "Check that the file exists",
           "Verify the path is correct"
         ])
@@ -3336,7 +3344,7 @@ var TypeScriptParser = class {
       const ast = parse(contentResult.value, {
         loc: true,
         range: true,
-        jsx: path31.endsWith(".tsx"),
+        jsx: path34.endsWith(".tsx"),
         errorOnUnknownASTType: false
       });
       return Ok({
@@ -3347,7 +3355,7 @@ var TypeScriptParser = class {
     } catch (e) {
       const error = e;
       return Err(
-        createParseError("SYNTAX_ERROR", `Failed to parse ${path31}: ${error.message}`, { path: path31 }, [
+        createParseError("SYNTAX_ERROR", `Failed to parse ${path34}: ${error.message}`, { path: path34 }, [
           "Check for syntax errors in the file",
           "Ensure valid TypeScript syntax"
         ])
@@ -3528,22 +3536,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path31) {
-  const contentResult = await readFileContent(path31);
+async function parseDocumentationFile(path34) {
+  const contentResult = await readFileContent(path34);
   if (!contentResult.ok) {
     return Err(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path31}`,
-        { file: path31 },
+        `Failed to read documentation file: ${path34}`,
+        { file: path34 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path31.endsWith(".md") ? "markdown" : "text";
+  const type = path34.endsWith(".md") ? "markdown" : "text";
   return Ok({
-    path: path31,
+    path: path34,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -5800,12 +5808,12 @@ function parseDiffHeader(part) {
   return headerMatch[2];
 }
 function parseDiffPart(part) {
-  const path31 = parseDiffHeader(part);
-  if (!path31) return null;
+  const path34 = parseDiffHeader(part);
+  if (!path34) return null;
   const additionRegex = /^\+(?!\+\+)/gm;
   const deletionRegex = /^-(?!--)/gm;
   return {
-    path: path31,
+    path: path34,
     status: detectFileStatus(part),
     additions: (part.match(additionRegex) || []).length,
     deletions: (part.match(deletionRegex) || []).length
@@ -8065,6 +8073,31 @@ async function saveState(projectPath, state, stream, session) {
     );
   }
 }
+function estimateTokens(content) {
+  return Math.ceil(content.length / 4);
+}
+function serializeEnvelope(envelope) {
+  const { meta, sections } = envelope;
+  const strategyLabel = meta.strategy.length > 0 ? meta.strategy.join("+") : "none";
+  let cacheLabel = "";
+  if (meta.cached) {
+    if (meta.cacheReadTokens != null && meta.cacheInputTokens != null && meta.cacheInputTokens > 0) {
+      const hitPct = Math.round(meta.cacheReadTokens / meta.cacheInputTokens * 100);
+      const readFormatted = meta.cacheReadTokens >= 1e3 ? (meta.cacheReadTokens / 1e3).toFixed(1) + "K" : String(meta.cacheReadTokens);
+      cacheLabel = ` [cached | cache: ${readFormatted} read, ${hitPct}% hit]`;
+    } else {
+      cacheLabel = " [cached]";
+    }
+  }
+  const header = `<!-- packed: ${strategyLabel} | ${meta.originalTokenEstimate}\u2192${meta.compactedTokenEstimate} tokens (-${meta.reductionPct}%)${cacheLabel} -->`;
+  if (sections.length === 0) {
+    return header;
+  }
+  const body = sections.map((section) => `### [${section.source}]
+${section.content}`).join("\n\n");
+  return `${header}
+${body}`;
+}
 function parseFrontmatter2(line) {
   const match = line.match(/^<!--\s+hash:([a-f0-9]+)(?:\s+tags:([^\s]+))?\s+-->/);
   if (!match) return null;
@@ -8168,9 +8201,6 @@ function analyzeLearningPatterns(entries) {
   }
   return patterns.sort((a, b) => b.count - a.count);
 }
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
 function scoreRelevance(entry, intent) {
   if (!intent || intent.trim() === "") return 0;
   const intentWords = intent.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
@@ -13926,9 +13956,9 @@ async function resolveWasmPath(grammarName) {
   const { createRequire } = await import("module");
   const require2 = createRequire(import.meta.url ?? __filename);
   const pkgPath = require2.resolve("tree-sitter-wasms/package.json");
-  const path31 = await import("path");
-  const pkgDir = path31.dirname(pkgPath);
-  return path31.join(pkgDir, "out", `${grammarName}.wasm`);
+  const path34 = await import("path");
+  const pkgDir = path34.dirname(pkgPath);
+  return path34.join(pkgDir, "out", `${grammarName}.wasm`);
 }
 async function loadLanguage(lang) {
   const grammarName = GRAMMAR_MAP[lang];
@@ -14778,7 +14808,414 @@ function parseCCRecords() {
   }
   return records;
 }
-var VERSION = "0.21.1";
+function parseLine2(line, lineNumber) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed.skill !== "string" || typeof parsed.startedAt !== "string" || typeof parsed.duration !== "number" || typeof parsed.outcome !== "string" || !Array.isArray(parsed.phasesReached)) {
+      process.stderr.write(
+        `[harness adoption] Skipping malformed JSONL line ${lineNumber}: missing required fields
+`
+      );
+      return null;
+    }
+    return parsed;
+  } catch {
+    process.stderr.write(`[harness adoption] Skipping malformed JSONL line ${lineNumber}
+`);
+    return null;
+  }
+}
+function readAdoptionRecords(projectRoot) {
+  const adoptionFile = path31.join(projectRoot, ".harness", "metrics", "adoption.jsonl");
+  let raw;
+  try {
+    raw = fs32.readFileSync(adoptionFile, "utf-8");
+  } catch {
+    return [];
+  }
+  const records = [];
+  const lines = raw.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]?.trim();
+    if (!line) continue;
+    const record = parseLine2(line, i + 1);
+    if (record) {
+      records.push(record);
+    }
+  }
+  return records;
+}
+function aggregateBySkill(records) {
+  if (records.length === 0) return [];
+  const skillMap = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!skillMap.has(record.skill)) {
+      const entry = { records: [] };
+      if (record.tier != null) entry.tier = record.tier;
+      skillMap.set(record.skill, entry);
+    }
+    skillMap.get(record.skill).records.push(record);
+  }
+  const results = [];
+  for (const [skill, bucket] of skillMap) {
+    const invocations = bucket.records.length;
+    const completedCount = bucket.records.filter((r) => r.outcome === "completed").length;
+    const totalDuration = bucket.records.reduce((sum, r) => sum + r.duration, 0);
+    const timestamps = bucket.records.map((r) => r.startedAt).sort();
+    const summary = {
+      skill,
+      invocations,
+      successRate: completedCount / invocations,
+      avgDuration: totalDuration / invocations,
+      lastUsed: timestamps[timestamps.length - 1]
+    };
+    if (bucket.tier != null) summary.tier = bucket.tier;
+    results.push(summary);
+  }
+  results.sort((a, b) => b.invocations - a.invocations);
+  return results;
+}
+function aggregateByDay2(records) {
+  if (records.length === 0) return [];
+  const dayMap = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const date = record.startedAt.slice(0, 10);
+    if (!dayMap.has(date)) {
+      dayMap.set(date, { invocations: 0, skills: /* @__PURE__ */ new Set() });
+    }
+    const bucket = dayMap.get(date);
+    bucket.invocations++;
+    bucket.skills.add(record.skill);
+  }
+  const results = [];
+  for (const [date, bucket] of dayMap) {
+    results.push({
+      date,
+      invocations: bucket.invocations,
+      uniqueSkills: bucket.skills.size
+    });
+  }
+  results.sort((a, b) => b.date.localeCompare(a.date));
+  return results;
+}
+function topSkills(records, n) {
+  return aggregateBySkill(records).slice(0, n);
+}
+function isEmptyObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && Object.keys(v).length === 0;
+}
+function isRetainable(v) {
+  return v !== void 0 && v !== "" && v !== null && !isEmptyObject(v);
+}
+function cleanArray(value) {
+  const cleaned = value.map(cleanValue).filter(isRetainable);
+  if (cleaned.length === 0) return void 0;
+  if (cleaned.length === 1) return cleaned[0];
+  return cleaned;
+}
+function cleanRecord(value) {
+  const cleaned = {};
+  for (const [k, v] of Object.entries(value)) {
+    const result = cleanValue(v);
+    if (isRetainable(result)) {
+      cleaned[k] = result;
+    }
+  }
+  if (Object.keys(cleaned).length === 0) return void 0;
+  return cleaned;
+}
+function cleanValue(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") return value.replace(/\s+/g, " ").trim();
+  if (Array.isArray(value)) return cleanArray(value);
+  if (typeof value === "object") return cleanRecord(value);
+  return value;
+}
+var StructuralStrategy = class {
+  name = "structural";
+  lossy = false;
+  apply(content, _budget) {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return content;
+    }
+    const cleaned = cleanValue(parsed);
+    return JSON.stringify(cleaned) ?? "";
+  }
+};
+var DEFAULT_TOKEN_BUDGET = 4e3;
+var CHARS_PER_TOKEN = 4;
+var TRUNCATION_MARKER = "\n[truncated \u2014 prioritized truncation applied]";
+function lineScore(line) {
+  let score = 0;
+  if (/\/[\w./-]/.test(line)) score += 40;
+  if (/error|Error|ERROR|fail|FAIL|status/i.test(line)) score += 35;
+  if (/\b[A-Z][a-z]+[A-Z]/.test(line) || /\b[a-z]+[A-Z]/.test(line)) score += 20;
+  if (line.trim().length < 40) score += 10;
+  return score;
+}
+function selectLines(lines, charBudget) {
+  const scored = lines.map((line, idx) => ({ line, idx, score: lineScore(line) }));
+  scored.sort((a, b) => b.score - a.score || a.idx - b.idx);
+  const kept = [];
+  let used = 0;
+  for (const item of scored) {
+    const lineLen = item.line.length + 1;
+    if (used + lineLen > charBudget) continue;
+    kept.push({ line: item.line, idx: item.idx });
+    used += lineLen;
+  }
+  kept.sort((a, b) => a.idx - b.idx);
+  return kept;
+}
+var TruncationStrategy = class {
+  name = "truncate";
+  lossy = false;
+  // deliberate: spec Decision 2 — truncation is classified lossless at the pipeline level
+  apply(content, budget = DEFAULT_TOKEN_BUDGET) {
+    if (!content) return content;
+    const charBudget = budget * CHARS_PER_TOKEN;
+    if (content.length <= charBudget) return content;
+    const lines = content.split("\n");
+    const available = charBudget - TRUNCATION_MARKER.length;
+    const kept = available > 0 ? selectLines(lines, available) : [{ line: (lines[0] ?? "").slice(0, charBudget), idx: 0 }];
+    return kept.map((k) => k.line).join("\n") + TRUNCATION_MARKER;
+  }
+};
+var CompactionPipeline = class {
+  strategies;
+  constructor(strategies) {
+    this.strategies = strategies;
+  }
+  /** The ordered list of strategy names in this pipeline. */
+  get strategyNames() {
+    return this.strategies.map((s) => s.name);
+  }
+  /**
+   * Apply all strategies in order.
+   * @param content — input string
+   * @param budget — optional token budget forwarded to each strategy
+   */
+  apply(content, budget) {
+    return this.strategies.reduce((current, strategy) => {
+      return strategy.apply(current, budget);
+    }, content);
+  }
+};
+var STABILITY_LOOKUP = {};
+for (const [key, tier] of Object.entries(NODE_STABILITY)) {
+  STABILITY_LOOKUP[key] = tier;
+  STABILITY_LOOKUP[key.toLowerCase()] = tier;
+}
+STABILITY_LOOKUP["packed_summary"] = "session";
+STABILITY_LOOKUP["skill"] = "static";
+function resolveStability(contentType) {
+  return STABILITY_LOOKUP[contentType] ?? "ephemeral";
+}
+var TIER_ORDER = {
+  static: 0,
+  session: 1,
+  ephemeral: 2
+};
+var AnthropicCacheAdapter = class {
+  provider = "claude";
+  wrapSystemBlock(content, stability) {
+    if (stability === "ephemeral") {
+      return { type: "text", text: content };
+    }
+    const ttl = stability === "static" ? "1h" : void 0;
+    return {
+      type: "text",
+      text: content,
+      cache_control: {
+        type: "ephemeral",
+        ...ttl !== void 0 && { ttl }
+      }
+    };
+  }
+  wrapTools(tools, stability) {
+    if (tools.length === 0 || stability === "ephemeral") {
+      return { tools: tools.map((t) => ({ ...t })) };
+    }
+    const wrapped = tools.map((t) => ({ ...t }));
+    const last = wrapped[wrapped.length - 1];
+    if (last) {
+      last.cache_control = { type: "ephemeral" };
+    }
+    return { tools: wrapped };
+  }
+  orderContent(blocks) {
+    return [...blocks].sort((a, b) => TIER_ORDER[a.stability] - TIER_ORDER[b.stability]);
+  }
+  parseCacheUsage(response) {
+    const resp = response;
+    const usage = resp?.usage;
+    return {
+      cacheCreationTokens: usage?.cache_creation_input_tokens ?? 0,
+      cacheReadTokens: usage?.cache_read_input_tokens ?? 0
+    };
+  }
+};
+var TIER_ORDER2 = {
+  static: 0,
+  session: 1,
+  ephemeral: 2
+};
+var OpenAICacheAdapter = class {
+  provider = "openai";
+  wrapSystemBlock(content, _stability) {
+    return { type: "text", text: content };
+  }
+  wrapTools(tools, _stability) {
+    return { tools: tools.map((t) => ({ ...t })) };
+  }
+  orderContent(blocks) {
+    return [...blocks].sort((a, b) => TIER_ORDER2[a.stability] - TIER_ORDER2[b.stability]);
+  }
+  parseCacheUsage(response) {
+    const resp = response;
+    const usage = resp?.usage;
+    const details = usage?.prompt_tokens_details;
+    return {
+      cacheCreationTokens: 0,
+      cacheReadTokens: details?.cached_tokens ?? 0
+    };
+  }
+};
+var TIER_ORDER3 = {
+  static: 0,
+  session: 1,
+  ephemeral: 2
+};
+var CACHED_CONTENT_MARKER = "cachedContents:pending";
+var GeminiCacheAdapter = class {
+  provider = "gemini";
+  wrapSystemBlock(content, stability) {
+    if (stability === "static") {
+      return {
+        type: "text",
+        text: content,
+        cachedContentRef: CACHED_CONTENT_MARKER
+      };
+    }
+    return { type: "text", text: content };
+  }
+  wrapTools(tools, _stability) {
+    return { tools: tools.map((t) => ({ ...t })) };
+  }
+  orderContent(blocks) {
+    return [...blocks].sort((a, b) => TIER_ORDER3[a.stability] - TIER_ORDER3[b.stability]);
+  }
+  parseCacheUsage(response) {
+    const resp = response;
+    const metadata = resp?.usageMetadata;
+    return {
+      cacheCreationTokens: 0,
+      cacheReadTokens: metadata?.cachedContentTokenCount ?? 0
+    };
+  }
+};
+function getOrCreateInstallId(projectRoot) {
+  const harnessDir = path32.join(projectRoot, ".harness");
+  const installIdFile = path32.join(harnessDir, ".install-id");
+  const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  try {
+    const existing = fs33.readFileSync(installIdFile, "utf-8").trim();
+    if (UUID_V4_RE.test(existing)) {
+      return existing;
+    }
+  } catch {
+  }
+  const id = crypto4.randomUUID();
+  fs33.mkdirSync(harnessDir, { recursive: true });
+  fs33.writeFileSync(installIdFile, id, { encoding: "utf-8", mode: 384 });
+  return id;
+}
+function readIdentity(projectRoot) {
+  const filePath = path33.join(projectRoot, ".harness", "telemetry.json");
+  try {
+    const raw = fs34.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.identity) {
+      const { project, team, alias } = parsed.identity;
+      const identity = {};
+      if (typeof project === "string") identity.project = project;
+      if (typeof team === "string") identity.team = team;
+      if (typeof alias === "string") identity.alias = alias;
+      return identity;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function resolveConsent(projectRoot, config) {
+  if (process.env.DO_NOT_TRACK === "1") return { allowed: false };
+  if (process.env.HARNESS_TELEMETRY_OPTOUT === "1") return { allowed: false };
+  const enabled = config?.enabled ?? true;
+  if (!enabled) return { allowed: false };
+  const installId = getOrCreateInstallId(projectRoot);
+  const identity = readIdentity(projectRoot);
+  return { allowed: true, installId, identity };
+}
+var VERSION = "0.21.3";
+function mapOutcome(outcome) {
+  return outcome === "completed" ? "success" : "failure";
+}
+function collectEvents(projectRoot, consent) {
+  const records = readAdoptionRecords(projectRoot);
+  if (records.length === 0) return [];
+  const { installId, identity } = consent;
+  const distinctId = identity.alias ?? installId;
+  return records.map(
+    (record) => ({
+      event: "skill_invocation",
+      distinctId,
+      timestamp: record.startedAt,
+      properties: {
+        installId,
+        os: process.platform,
+        nodeVersion: process.version,
+        harnessVersion: VERSION,
+        skillName: record.skill,
+        duration: record.duration,
+        outcome: mapOutcome(record.outcome),
+        phasesReached: record.phasesReached,
+        ...identity.project ? { project: identity.project } : {},
+        ...identity.team ? { team: identity.team } : {}
+      }
+    })
+  );
+}
+var POSTHOG_BATCH_URL = "https://app.posthog.com/batch";
+var MAX_ATTEMPTS = 3;
+var TIMEOUT_MS = 5e3;
+function sleep2(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function send(events, apiKey) {
+  if (events.length === 0) return;
+  const payload = { api_key: apiKey, batch: events };
+  const body = JSON.stringify(payload);
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    try {
+      const res = await fetch(POSTHOG_BATCH_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        signal: AbortSignal.timeout(TIMEOUT_MS)
+      });
+      if (res.ok) return;
+      if (res.status < 500) return;
+    } catch {
+    }
+    if (attempt < MAX_ATTEMPTS - 1) {
+      await sleep2(1e3 * (attempt + 1));
+    }
+  }
+}
 
 export {
   ArchMetricCategorySchema,
@@ -14947,6 +15384,8 @@ export {
   updateSessionIndex,
   loadState,
   saveState,
+  estimateTokens,
+  serializeEnvelope,
   parseFrontmatter2,
   parseDateFromEntry,
   extractIndexEntry,
@@ -15099,5 +15538,22 @@ export {
   aggregateByDay,
   readCostRecords,
   parseCCRecords,
-  VERSION
+  readAdoptionRecords,
+  aggregateBySkill,
+  aggregateByDay2,
+  topSkills,
+  StructuralStrategy,
+  DEFAULT_TOKEN_BUDGET,
+  TruncationStrategy,
+  CompactionPipeline,
+  resolveStability,
+  AnthropicCacheAdapter,
+  OpenAICacheAdapter,
+  GeminiCacheAdapter,
+  getOrCreateInstallId,
+  readIdentity,
+  resolveConsent,
+  VERSION,
+  collectEvents,
+  send
 };