@harness-engineering/core 0.21.2 → 0.21.3

package/dist/index.js

@@ -35,6 +35,7 @@ __export(index_exports, {
   ARCHITECTURE_DESCRIPTOR: () => ARCHITECTURE_DESCRIPTOR,
   AdjustedForecastSchema: () => AdjustedForecastSchema,
   AgentActionEmitter: () => AgentActionEmitter,
+  AnthropicCacheAdapter: () => AnthropicCacheAdapter,
   ArchBaselineManager: () => ArchBaselineManager,
   ArchBaselineSchema: () => ArchBaselineSchema,
   ArchConfigSchema: () => ArchConfigSchema,
@@ -54,6 +55,7 @@ __export(index_exports, {
   CategorySnapshotSchema: () => CategorySnapshotSchema,
   ChecklistBuilder: () => ChecklistBuilder,
   CircularDepsCollector: () => CircularDepsCollector,
+  CompactionPipeline: () => CompactionPipeline,
   ComplexityCollector: () => ComplexityCollector,
   ConfidenceTierSchema: () => ConfidenceTierSchema,
   ConfirmationSchema: () => ConfirmationSchema,
@@ -68,6 +70,7 @@ __export(index_exports, {
   DEFAULT_STABILITY_THRESHOLDS: () => DEFAULT_STABILITY_THRESHOLDS,
   DEFAULT_STATE: () => DEFAULT_STATE,
   DEFAULT_STREAM_INDEX: () => DEFAULT_STREAM_INDEX,
+  DEFAULT_TOKEN_BUDGET: () => DEFAULT_TOKEN_BUDGET,
   DESTRUCTIVE_BASH: () => DESTRUCTIVE_BASH,
   DepDepthCollector: () => DepDepthCollector,
   DirectionSchema: () => DirectionSchema,
@@ -81,6 +84,7 @@ __export(index_exports, {
   ForbiddenImportCollector: () => ForbiddenImportCollector,
   GateConfigSchema: () => GateConfigSchema,
   GateResultSchema: () => GateResultSchema,
+  GeminiCacheAdapter: () => GeminiCacheAdapter,
   GitHubIssuesSyncAdapter: () => GitHubIssuesSyncAdapter,
   HandoffSchema: () => HandoffSchema,
   HarnessStateSchema: () => HarnessStateSchema,
@@ -95,6 +99,7 @@ __export(index_exports, {
   NoOpExecutor: () => NoOpExecutor,
   NoOpSink: () => NoOpSink,
   NoOpTelemetryAdapter: () => NoOpTelemetryAdapter,
+  OpenAICacheAdapter: () => OpenAICacheAdapter,
   PatternConfigSchema: () => PatternConfigSchema,
   PredictionEngine: () => PredictionEngine,
   PredictionOptionsSchema: () => PredictionOptionsSchema,
@@ -122,6 +127,7 @@ __export(index_exports, {
   StabilityForecastSchema: () => StabilityForecastSchema,
   StreamIndexSchema: () => StreamIndexSchema,
   StreamInfoSchema: () => StreamInfoSchema,
+  StructuralStrategy: () => StructuralStrategy,
   ThresholdConfigSchema: () => ThresholdConfigSchema,
   TimelineFileSchema: () => TimelineFileSchema,
   TimelineManager: () => TimelineManager,
@@ -129,13 +135,16 @@ __export(index_exports, {
   TransitionSchema: () => TransitionSchema,
   TrendLineSchema: () => TrendLineSchema,
   TrendResultSchema: () => TrendResultSchema,
+  TruncationStrategy: () => TruncationStrategy,
   TypeScriptParser: () => TypeScriptParser,
   VERSION: () => VERSION,
   ViolationSchema: () => ViolationSchema,
   addProvenance: () => addProvenance,
   agentConfigRules: () => agentConfigRules,
+  aggregateAdoptionByDay: () => aggregateByDay2,
   aggregateByDay: () => aggregateByDay,
   aggregateBySession: () => aggregateBySession,
+  aggregateBySkill: () => aggregateBySkill,
   analyzeDiff: () => analyzeDiff,
   analyzeLearningPatterns: () => analyzeLearningPatterns,
   appendFailure: () => appendFailure,
@@ -167,6 +176,7 @@ __export(index_exports, {
   clearFailuresCache: () => clearFailuresCache,
   clearLearningsCache: () => clearLearningsCache,
   clearTaint: () => clearTaint,
+  collectEvents: () => collectEvents,
   computeContentHash: () => computeContentHash,
   computeOverallSeverity: () => computeOverallSeverity,
   computeScanExitCode: () => computeScanExitCode,
@@ -206,6 +216,7 @@ __export(index_exports, {
   determineAssessment: () => determineAssessment,
   diff: () => diff,
   emitEvent: () => emitEvent,
+  estimateTokens: () => estimateTokens,
   executeWorkflow: () => executeWorkflow,
   expressRules: () => expressRules,
   extractBundle: () => extractBundle,
@@ -227,6 +238,7 @@ __export(index_exports, {
   getFeedbackConfig: () => getFeedbackConfig,
   getInjectionPatterns: () => getInjectionPatterns,
   getModelPrice: () => getModelPrice,
+  getOrCreateInstallId: () => getOrCreateInstallId,
   getOutline: () => getOutline,
   getParser: () => getParser,
   getPhaseCategories: () => getPhaseCategories,
@@ -279,8 +291,10 @@ __export(index_exports, {
   promoteSessionLearnings: () => promoteSessionLearnings,
   pruneLearnings: () => pruneLearnings,
   reactRules: () => reactRules,
+  readAdoptionRecords: () => readAdoptionRecords,
   readCheckState: () => readCheckState,
   readCostRecords: () => readCostRecords,
+  readIdentity: () => readIdentity,
   readLockfile: () => readLockfile,
   readSessionSection: () => readSessionSection,
   readSessionSections: () => readSessionSections,
@@ -291,11 +305,13 @@ __export(index_exports, {
   requestPeerReview: () => requestPeerReview,
   resetFeedbackConfig: () => resetFeedbackConfig,
   resetParserCache: () => resetParserCache,
+  resolveConsent: () => resolveConsent,
   resolveFileToLayer: () => resolveFileToLayer,
   resolveModelTier: () => resolveModelTier,
   resolveReverseStatus: () => resolveReverseStatus,
   resolveRuleSeverity: () => resolveRuleSeverity,
   resolveSessionDir: () => resolveSessionDir,
+  resolveStability: () => resolveStability,
   resolveStreamPath: () => resolveStreamPath,
   resolveThresholds: () => resolveThresholds3,
   runAll: () => runAll,
@@ -317,6 +333,8 @@ __export(index_exports, {
   scoreRoadmapCandidates: () => scoreRoadmapCandidates,
   searchSymbols: () => searchSymbols,
   secretRules: () => secretRules,
+  send: () => send,
+  serializeEnvelope: () => serializeEnvelope,
   serializeRoadmap: () => serializeRoadmap,
   setActiveStream: () => setActiveStream,
   sharpEdgesRules: () => sharpEdgesRules,
@@ -327,6 +345,7 @@ __export(index_exports, {
   syncRoadmap: () => syncRoadmap,
   syncToExternal: () => syncToExternal,
   tagUncitedFindings: () => tagUncitedFindings,
+  topSkills: () => topSkills,
   touchStream: () => touchStream,
   trackAction: () => trackAction,
   unfoldRange: () => unfoldRange,
@@ -372,17 +391,17 @@ var import_node_path = require("path");
 var import_glob = require("glob");
 var accessAsync = (0, import_util.promisify)(import_fs.access);
 var readFileAsync = (0, import_util.promisify)(import_fs.readFile);
-async function fileExists(path31) {
+async function fileExists(path34) {
   try {
-    await accessAsync(path31, import_fs.constants.F_OK);
+    await accessAsync(path34, import_fs.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 (0, import_types.Ok)(content);
   } catch (error) {
     return (0, import_types.Err)(error);
@@ -433,15 +452,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}`;
@@ -660,27 +679,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(".") ? (0, import_path.join)(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 (0, import_types.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 = (0, import_path.dirname)(path31);
+  const baseDir = (0, import_path.dirname)(path34);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -821,8 +840,8 @@ async function checkDocCoverage(domain, options = {}) {
 
 // src/context/knowledge-map.ts
 var import_path3 = require("path");
-function suggestFix(path31, existingFiles) {
-  const targetName = (0, import_path3.basename)(path31).toLowerCase();
+function suggestFix(path34, existingFiles) {
+  const targetName = (0, import_path3.basename)(path34).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = (0, import_path3.basename)(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -830,7 +849,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 = (0, import_path3.join)(rootDir, "AGENTS.md");
@@ -1434,8 +1453,8 @@ function createBoundaryValidator(schema, name) {
         return (0, import_types.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 (0, import_types.Err)(
         createError(
@@ -2069,11 +2088,11 @@ function processExportListSpecifiers(exportDecl, exports2) {
 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 (0, import_types.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"
         ])
@@ -2083,7 +2102,7 @@ var TypeScriptParser = class {
       const ast = (0, import_typescript_estree.parse)(contentResult.value, {
         loc: true,
         range: true,
-        jsx: path31.endsWith(".tsx"),
+        jsx: path34.endsWith(".tsx"),
         errorOnUnknownASTType: false
       });
       return (0, import_types.Ok)({
@@ -2094,7 +2113,7 @@ var TypeScriptParser = class {
     } catch (e) {
       const error = e;
       return (0, import_types.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"
         ])
@@ -2279,22 +2298,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 (0, import_types.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 (0, import_types.Ok)({
-    path: path31,
+    path: path34,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -5074,12 +5093,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
@@ -8536,6 +8555,35 @@ async function saveState(projectPath, state, stream, session) {
 var fs11 = __toESM(require("fs"));
 var path8 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
+
+// src/compaction/envelope.ts
+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}`;
+}
+
+// src/state/learnings-content.ts
 function parseFrontmatter2(line) {
   const match = line.match(/^<!--\s+hash:([a-f0-9]+)(?:\s+tags:([^\s]+))?\s+-->/);
   if (!match) return null;
@@ -8639,9 +8687,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);
@@ -14602,9 +14647,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];
@@ -15484,14 +15529,458 @@ function parseCCRecords() {
   return records;
 }
 
-// src/index.ts
-var VERSION = "0.21.1";
+// src/adoption/reader.ts
+var fs32 = __toESM(require("fs"));
+var path31 = __toESM(require("path"));
+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;
+}
+
+// src/adoption/aggregator.ts
+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);
+}
+
+// src/compaction/strategies/structural.ts
+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) ?? "";
+  }
+};
+
+// src/compaction/strategies/truncation.ts
+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;
+  }
+};
+
+// src/compaction/pipeline.ts
+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);
+  }
+};
+
+// src/caching/stability.ts
+var import_graph2 = require("@harness-engineering/graph");
+var STABILITY_LOOKUP = {};
+for (const [key, tier] of Object.entries(import_graph2.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";
+}
+
+// src/caching/adapters/anthropic.ts
+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
+    };
+  }
+};
+
+// src/caching/adapters/openai.ts
+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
+    };
+  }
+};
+
+// src/caching/adapters/gemini.ts
+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
+    };
+  }
+};
+
+// src/telemetry/consent.ts
+var fs34 = __toESM(require("fs"));
+var path33 = __toESM(require("path"));
+
+// src/telemetry/install-id.ts
+var fs33 = __toESM(require("fs"));
+var path32 = __toESM(require("path"));
+var crypto4 = __toESM(require("crypto"));
+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;
+}
+
+// src/telemetry/consent.ts
+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 };
+}
+
+// src/version.ts
+var VERSION = "0.21.3";
+
+// src/telemetry/collector.ts
+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 } : {}
+      }
+    })
+  );
+}
+
+// src/telemetry/transport.ts
+var POSTHOG_BATCH_URL = "https://app.posthog.com/batch";
+var MAX_ATTEMPTS = 3;
+var TIMEOUT_MS = 5e3;
+function sleep2(ms) {
+  return new Promise((resolve7) => setTimeout(resolve7, 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));
+    }
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR,
   AdjustedForecastSchema,
   AgentActionEmitter,
+  AnthropicCacheAdapter,
   ArchBaselineManager,
   ArchBaselineSchema,
   ArchConfigSchema,
@@ -15511,6 +16000,7 @@ var VERSION = "0.21.1";
   CategorySnapshotSchema,
   ChecklistBuilder,
   CircularDepsCollector,
+  CompactionPipeline,
   ComplexityCollector,
   ConfidenceTierSchema,
   ConfirmationSchema,
@@ -15525,6 +16015,7 @@ var VERSION = "0.21.1";
   DEFAULT_STABILITY_THRESHOLDS,
   DEFAULT_STATE,
   DEFAULT_STREAM_INDEX,
+  DEFAULT_TOKEN_BUDGET,
   DESTRUCTIVE_BASH,
   DepDepthCollector,
   DirectionSchema,
@@ -15538,6 +16029,7 @@ var VERSION = "0.21.1";
   ForbiddenImportCollector,
   GateConfigSchema,
   GateResultSchema,
+  GeminiCacheAdapter,
   GitHubIssuesSyncAdapter,
   HandoffSchema,
   HarnessStateSchema,
@@ -15552,6 +16044,7 @@ var VERSION = "0.21.1";
   NoOpExecutor,
   NoOpSink,
   NoOpTelemetryAdapter,
+  OpenAICacheAdapter,
   PatternConfigSchema,
   PredictionEngine,
   PredictionOptionsSchema,
@@ -15579,6 +16072,7 @@ var VERSION = "0.21.1";
   StabilityForecastSchema,
   StreamIndexSchema,
   StreamInfoSchema,
+  StructuralStrategy,
   ThresholdConfigSchema,
   TimelineFileSchema,
   TimelineManager,
@@ -15586,13 +16080,16 @@ var VERSION = "0.21.1";
   TransitionSchema,
   TrendLineSchema,
   TrendResultSchema,
+  TruncationStrategy,
   TypeScriptParser,
   VERSION,
   ViolationSchema,
   addProvenance,
   agentConfigRules,
+  aggregateAdoptionByDay,
   aggregateByDay,
   aggregateBySession,
+  aggregateBySkill,
   analyzeDiff,
   analyzeLearningPatterns,
   appendFailure,
@@ -15624,6 +16121,7 @@ var VERSION = "0.21.1";
   clearFailuresCache,
   clearLearningsCache,
   clearTaint,
+  collectEvents,
   computeContentHash,
   computeOverallSeverity,
   computeScanExitCode,
@@ -15663,6 +16161,7 @@ var VERSION = "0.21.1";
   determineAssessment,
   diff,
   emitEvent,
+  estimateTokens,
   executeWorkflow,
   expressRules,
   extractBundle,
@@ -15684,6 +16183,7 @@ var VERSION = "0.21.1";
   getFeedbackConfig,
   getInjectionPatterns,
   getModelPrice,
+  getOrCreateInstallId,
   getOutline,
   getParser,
   getPhaseCategories,
@@ -15736,8 +16236,10 @@ var VERSION = "0.21.1";
   promoteSessionLearnings,
   pruneLearnings,
   reactRules,
+  readAdoptionRecords,
   readCheckState,
   readCostRecords,
+  readIdentity,
   readLockfile,
   readSessionSection,
   readSessionSections,
@@ -15748,11 +16250,13 @@ var VERSION = "0.21.1";
   requestPeerReview,
   resetFeedbackConfig,
   resetParserCache,
+  resolveConsent,
   resolveFileToLayer,
   resolveModelTier,
   resolveReverseStatus,
   resolveRuleSeverity,
   resolveSessionDir,
+  resolveStability,
   resolveStreamPath,
   resolveThresholds,
   runAll,
@@ -15774,6 +16278,8 @@ var VERSION = "0.21.1";
   scoreRoadmapCandidates,
   searchSymbols,
   secretRules,
+  send,
+  serializeEnvelope,
   serializeRoadmap,
   setActiveStream,
   sharpEdgesRules,
@@ -15784,6 +16290,7 @@ var VERSION = "0.21.1";
   syncRoadmap,
   syncToExternal,
   tagUncitedFindings,
+  topSkills,
   touchStream,
   trackAction,
   unfoldRange,