@hivelore/core 0.53.2 → 0.54.0

package/dist/index.js

@@ -1394,10 +1394,10 @@ function sensorPatternBrittleness(pattern) {
 function normalizeProjectPath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^[ab]\//, "").replace(/\/+$/g, "");
 }
-function sensorAppliesToPath(sensor, anchorPaths, path20) {
+function sensorAppliesToPath(sensor, anchorPaths, path21) {
   const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
   if (scopes.length === 0) return true;
-  const target = normalizeProjectPath(path20);
+  const target = normalizeProjectPath(path21);
   return scopes.some((rawScope) => {
     const scope = normalizeProjectPath(rawScope);
     if (!scope) return false;
@@ -4241,6 +4241,178 @@ async function usageLogSize(paths) {
   return { exists: true, size_bytes: st.size, lines: raw.split("\n").filter((l) => l).length };
 }
 
+// src/friction.ts
+import { appendFile as appendFile3, mkdir as mkdir9, readFile as readFile12, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import { createHash as createHash2 } from "crypto";
+import path14 from "path";
+var FRICTION_LOG_FILE = "friction.jsonl";
+var FRICTION_STATE_FILE = "friction-state.json";
+var FRICTION_FIELD_MAX = 2e3;
+function frictionLogPath(paths) {
+  return path14.join(paths.runtimeDir, FRICTION_LOG_FILE);
+}
+function frictionStatePath(paths) {
+  return path14.join(paths.runtimeDir, FRICTION_STATE_FILE);
+}
+function normalizeFrictionSummary(value) {
+  return value.toLowerCase().replace(/[a-z]?:?[\\/](?:[\w.-]+[\\/])+/g, "/").replace(/\d{3,}/g, "N").replace(/\s+/g, " ").trim();
+}
+function frictionFingerprint(input) {
+  const basis = [
+    input.kind,
+    input.surface.trim().toLowerCase(),
+    normalizeFrictionSummary(input.summary)
+  ].join("|");
+  return createHash2("sha256").update(basis).digest("hex").slice(0, 16);
+}
+function truncate(value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length > FRICTION_FIELD_MAX ? `${trimmed.slice(0, FRICTION_FIELD_MAX)}
+\u2026[truncated]` : trimmed;
+}
+function normalizeKind(kind, repro) {
+  if (kind === "bug" && !truncate(repro)) {
+    return { kind: "suggestion", downgraded_from: "bug" };
+  }
+  return { kind };
+}
+async function appendFrictionReport(paths, input) {
+  const { kind, downgraded_from } = normalizeKind(input.kind, input.repro);
+  const summary = truncate(input.summary) ?? "(no summary)";
+  const surface = truncate(input.surface) ?? "(unknown)";
+  const fingerprint = frictionFingerprint({ kind, surface, summary });
+  const report = {
+    at: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    kind,
+    surface,
+    summary,
+    ...truncate(input.expected) ? { expected: truncate(input.expected) } : {},
+    ...truncate(input.observed) ? { observed: truncate(input.observed) } : {},
+    ...truncate(input.repro) ? { repro: truncate(input.repro) } : {},
+    ...input.version ? { version: input.version } : {},
+    ...downgraded_from ? { downgraded_from } : {},
+    fingerprint
+  };
+  const prior = (await readFrictionReports(paths)).filter((r) => r.fingerprint === fingerprint);
+  try {
+    if (!existsSync12(paths.runtimeDir)) await mkdir9(paths.runtimeDir, { recursive: true });
+    await appendFile3(frictionLogPath(paths), JSON.stringify(report) + "\n", "utf8");
+  } catch {
+  }
+  const state = await loadFrictionState(paths);
+  return {
+    report,
+    occurrences: prior.length + 1,
+    already_reported: prior.length > 0,
+    ...state[fingerprint] ? { resolved_as: state[fingerprint] } : {}
+  };
+}
+async function readFrictionReports(paths) {
+  const file = frictionLogPath(paths);
+  if (!existsSync12(file)) return [];
+  let raw;
+  try {
+    raw = await readFile12(file, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed.fingerprint && parsed.at && parsed.summary) out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+async function loadFrictionState(paths) {
+  const file = frictionStatePath(paths);
+  if (!existsSync12(file)) return {};
+  try {
+    const parsed = JSON.parse(await readFile12(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function saveFrictionState(paths, state) {
+  if (!existsSync12(paths.runtimeDir)) await mkdir9(paths.runtimeDir, { recursive: true });
+  await writeFile8(frictionStatePath(paths), JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+async function setFrictionStatus(paths, fingerprint, status, url) {
+  const state = await loadFrictionState(paths);
+  const entry = {
+    status,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...url ? { url } : {}
+  };
+  state[fingerprint] = entry;
+  await saveFrictionState(paths, state);
+  return entry;
+}
+function groupFriction(reports, state = {}) {
+  const byFingerprint = /* @__PURE__ */ new Map();
+  for (const report of reports) {
+    const bucket = byFingerprint.get(report.fingerprint);
+    if (bucket) bucket.push(report);
+    else byFingerprint.set(report.fingerprint, [report]);
+  }
+  const groups = [];
+  for (const [fingerprint, bucket] of byFingerprint) {
+    const sorted = [...bucket].sort((a, b) => a.at.localeCompare(b.at));
+    const latest = sorted[sorted.length - 1];
+    const resolution = state[fingerprint];
+    groups.push({
+      fingerprint,
+      kind: latest.kind,
+      surface: latest.surface,
+      summary: latest.summary,
+      count: sorted.length,
+      first_seen: sorted[0].at,
+      last_seen: latest.at,
+      latest,
+      status: resolution?.status ?? "open",
+      ...resolution?.at ? { submitted_at: resolution.at } : {},
+      ...resolution?.url ? { url: resolution.url } : {}
+    });
+  }
+  return groups.sort(
+    (a, b) => b.count - a.count || b.last_seen.localeCompare(a.last_seen)
+  );
+}
+function formatFrictionIssue(group) {
+  const title = `[${group.kind}] ${group.surface}: ${group.summary}`.slice(0, 120);
+  const r = group.latest;
+  const lines = [
+    `**Surface:** \`${group.surface}\``,
+    `**Reported:** ${group.count}\xD7 (first ${group.first_seen.slice(0, 10)}, last ${group.last_seen.slice(0, 10)})`,
+    ...r.version ? [`**Version:** ${r.version}`] : [],
+    "",
+    "### What happened",
+    group.summary
+  ];
+  if (r.expected) lines.push("", "### Expected", r.expected);
+  if (r.observed) lines.push("", "### Observed", r.observed);
+  if (r.repro) lines.push("", "### Reproduction", "```sh", r.repro, "```");
+  if (r.downgraded_from === "bug") {
+    lines.push(
+      "",
+      "> Reported as a bug but filed as a suggestion: no reproduction was supplied."
+    );
+  }
+  lines.push(
+    "",
+    "---",
+    "<sub>Captured by an AI agent session via `report_friction` and reviewed by a human before submission.</sub>"
+  );
+  return { title, body: lines.join("\n") };
+}
+
 // src/briefing-preset.ts
 var BRIEFING_PRESET_DEFAULTS = {
   /** Fast session start — minimal tokens, skip module CONTEXT.md slices */
@@ -4307,21 +4479,21 @@ function extractActionsBriefBody(markdown, maxChars = MAX_DEFAULT_CHARS) {
 }
 
 // src/resolve-project.ts
-import { existsSync as existsSync12 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync13 } from "fs";
+import path15 from "path";
 var ROOT_MARKERS2 = [".ai", ".git", "package.json"];
 function markersAtRoot(root) {
   const found = [];
   for (const m of ROOT_MARKERS2) {
-    if (existsSync12(path14.join(root, m))) found.push(m);
+    if (existsSync13(path15.join(root, m))) found.push(m);
   }
   return found;
 }
 function resolveProjectInfo(opts = {}) {
   const env = opts.env ?? process.env;
-  const cwd = path14.resolve(opts.cwd ?? process.cwd());
+  const cwd = path15.resolve(opts.cwd ?? process.cwd());
   const raw = env.HAIVE_PROJECT_ROOT;
-  const explicit = raw !== void 0 && raw !== "" ? path14.resolve(raw) : null;
+  const explicit = raw !== void 0 && raw !== "" ? path15.resolve(raw) : null;
   const resolvedRoot = explicit ?? findProjectRoot(cwd);
   const paths = resolveHaivePaths(resolvedRoot);
   return {
@@ -4329,8 +4501,8 @@ function resolveProjectInfo(opts = {}) {
     resolved_root: resolvedRoot,
     haive_project_root_env: explicit,
     explicit_root: explicit != null,
-    haive_dir_exists: existsSync12(paths.haiveDir),
-    memories_dir_exists: existsSync12(paths.memoriesDir),
+    haive_dir_exists: existsSync13(paths.haiveDir),
+    memories_dir_exists: existsSync13(paths.memoriesDir),
     runtime_dir: paths.runtimeDir,
     markers_found: markersAtRoot(resolvedRoot)
   };
@@ -4585,16 +4757,16 @@ function findLexicalConflictPairs(memories, opts) {
 }
 
 // src/runtime-journal.ts
-import { mkdir as mkdir9, readFile as readFile12, appendFile as appendFile3 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
-import path15 from "path";
+import { mkdir as mkdir10, readFile as readFile13, appendFile as appendFile4 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import path16 from "path";
 var RUNTIME_JOURNAL_FILENAME = "session-journal.ndjson";
 function runtimeJournalPath(paths) {
-  return path15.join(paths.runtimeDir, RUNTIME_JOURNAL_FILENAME);
+  return path16.join(paths.runtimeDir, RUNTIME_JOURNAL_FILENAME);
 }
 async function appendRuntimeJournalEntry(paths, entry) {
   try {
-    await mkdir9(paths.runtimeDir, { recursive: true });
+    await mkdir10(paths.runtimeDir, { recursive: true });
     const line = {
       ts: entry.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
       kind: entry.kind,
@@ -4602,7 +4774,7 @@ async function appendRuntimeJournalEntry(paths, entry) {
       ...entry.tool !== void 0 ? { tool: entry.tool } : {},
       ...entry.meta !== void 0 ? { meta: entry.meta } : {}
     };
-    await appendFile3(
+    await appendFile4(
       runtimeJournalPath(paths),
       JSON.stringify(line) + "\n",
       "utf8"
@@ -4612,9 +4784,9 @@ async function appendRuntimeJournalEntry(paths, entry) {
 }
 async function readRuntimeJournalTail(paths, limit) {
   const file = runtimeJournalPath(paths);
-  if (!existsSync13(file) || limit <= 0) return [];
+  if (!existsSync14(file) || limit <= 0) return [];
   try {
-    const raw = await readFile12(file, "utf8");
+    const raw = await readFile13(file, "utf8");
     const lines = raw.trim().split("\n").filter(Boolean);
     const parsed = [];
     for (const line of lines.slice(-limit)) {
@@ -4630,22 +4802,22 @@ async function readRuntimeJournalTail(paths, limit) {
 }
 
 // src/enforcement.ts
-import { mkdir as mkdir10, readdir as readdir4, readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import path16 from "path";
+import { mkdir as mkdir11, readdir as readdir4, readFile as readFile14, writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import path17 from "path";
 var BRIEFING_MARKER_TTL_MS = 12 * 60 * 60 * 1e3;
 var SESSION_RECAP_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 function enforcementDir(paths) {
-  return path16.join(paths.runtimeDir, "enforcement");
+  return path17.join(paths.runtimeDir, "enforcement");
 }
 function briefingMarkersDir(paths) {
-  return path16.join(enforcementDir(paths), "briefings");
+  return path17.join(enforcementDir(paths), "briefings");
 }
 function normalizeSessionId(sessionId) {
   return (sessionId?.trim() || "default").replace(/[^a-zA-Z0-9_.-]+/g, "-").slice(0, 120);
 }
 function briefingMarkerPath(paths, sessionId) {
-  return path16.join(briefingMarkersDir(paths), `${normalizeSessionId(sessionId)}.json`);
+  return path17.join(briefingMarkersDir(paths), `${normalizeSessionId(sessionId)}.json`);
 }
 async function writeBriefingMarker(paths, input) {
   const sessionId = normalizeSessionId(input.sessionId);
@@ -4670,8 +4842,8 @@ async function writeBriefingMarker(paths, input) {
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     root: paths.root
   };
-  await mkdir10(briefingMarkersDir(paths), { recursive: true });
-  await writeFile8(
+  await mkdir11(briefingMarkersDir(paths), { recursive: true });
+  await writeFile9(
     briefingMarkerPath(paths, marker.session_id),
     JSON.stringify(marker, null, 2) + "\n",
     "utf8"
@@ -4680,9 +4852,9 @@ async function writeBriefingMarker(paths, input) {
 }
 async function readSessionBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKER_TTL_MS) {
   const file = briefingMarkerPath(paths, sessionId);
-  if (!existsSync14(file)) return null;
+  if (!existsSync15(file)) return null;
   try {
-    const marker = JSON.parse(await readFile13(file, "utf8"));
+    const marker = JSON.parse(await readFile14(file, "utf8"));
     const created = Date.parse(marker.created_at);
     if (!Number.isFinite(created) || Date.now() - created > ttlMs) return null;
     return marker;
@@ -4694,18 +4866,18 @@ async function hasRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKER
   const now = Date.now();
   const candidates = [];
   const exact = briefingMarkerPath(paths, sessionId);
-  if (existsSync14(exact)) candidates.push(exact);
+  if (existsSync15(exact)) candidates.push(exact);
   try {
     const dir = briefingMarkersDir(paths);
     const files = await readdir4(dir);
     for (const file of files) {
-      if (file.endsWith(".json")) candidates.push(path16.join(dir, file));
+      if (file.endsWith(".json")) candidates.push(path17.join(dir, file));
     }
   } catch {
   }
   for (const file of new Set(candidates)) {
     try {
-      const marker = JSON.parse(await readFile13(file, "utf8"));
+      const marker = JSON.parse(await readFile14(file, "utf8"));
       const created = Date.parse(marker.created_at);
       if (Number.isFinite(created) && now - created <= ttlMs) return true;
     } catch {
@@ -4717,12 +4889,12 @@ async function readRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKE
   const now = Date.now();
   const candidates = [];
   const exact = briefingMarkerPath(paths, sessionId);
-  if (existsSync14(exact)) candidates.push(exact);
+  if (existsSync15(exact)) candidates.push(exact);
   try {
     const dir = briefingMarkersDir(paths);
     const files = await readdir4(dir);
     for (const file of files) {
-      if (file.endsWith(".json")) candidates.push(path16.join(dir, file));
+      if (file.endsWith(".json")) candidates.push(path17.join(dir, file));
     }
   } catch {
   }
@@ -4730,7 +4902,7 @@ async function readRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKE
   let freshestTs = 0;
   for (const file of new Set(candidates)) {
     try {
-      const marker = JSON.parse(await readFile13(file, "utf8"));
+      const marker = JSON.parse(await readFile14(file, "utf8"));
       const created = Date.parse(marker.created_at);
       if (!Number.isFinite(created) || now - created > ttlMs) continue;
       if (created > freshestTs) {
@@ -4780,15 +4952,15 @@ function isRetiredMemory(fm, body = "", now = /* @__PURE__ */ new Date()) {
 }
 
 // src/sensor-ledger.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync2 } from "fs";
-import { appendFile as appendFile4, mkdir as mkdir11, readFile as readFile14, rename, writeFile as writeFile9 } from "fs/promises";
-import path17 from "path";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync16, readFileSync as readFileSync2 } from "fs";
+import { appendFile as appendFile5, mkdir as mkdir12, readFile as readFile15, rename, writeFile as writeFile10 } from "fs/promises";
+import path18 from "path";
 var MAX_LINES = 1e4;
 var RETAINED_LINES = 8e3;
 var DAY_MS = 864e5;
 function sensorLedgerPath(paths) {
-  return path17.join(paths.runtimeDir, "enforcement", "sensor-ledger.ndjson");
+  return path18.join(paths.runtimeDir, "enforcement", "sensor-ledger.ndjson");
 }
 function isEvaluation(value) {
   if (!value || typeof value !== "object") return false;
@@ -4799,13 +4971,13 @@ async function appendSensorEvaluations(paths, evaluations) {
   if (evaluations.length === 0) return;
   try {
     const file = sensorLedgerPath(paths);
-    await mkdir11(path17.dirname(file), { recursive: true });
-    await appendFile4(file, evaluations.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
-    const raw = await readFile14(file, "utf8");
+    await mkdir12(path18.dirname(file), { recursive: true });
+    await appendFile5(file, evaluations.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+    const raw = await readFile15(file, "utf8");
     const lines = raw.split("\n").filter(Boolean);
     if (lines.length > MAX_LINES) {
       const temp = `${file}.${process.pid}.tmp`;
-      await writeFile9(temp, lines.slice(-RETAINED_LINES).join("\n") + "\n", "utf8");
+      await writeFile10(temp, lines.slice(-RETAINED_LINES).join("\n") + "\n", "utf8");
       await rename(temp, file);
     }
   } catch {
@@ -4814,9 +4986,9 @@ async function appendSensorEvaluations(paths, evaluations) {
 async function loadSensorLedger(paths, opts = {}) {
   try {
     const file = sensorLedgerPath(paths);
-    if (!existsSync15(file)) return [];
+    if (!existsSync16(file)) return [];
     const since = opts.since ? Date.parse(opts.since) : Number.NEGATIVE_INFINITY;
-    const raw = await readFile14(file, "utf8");
+    const raw = await readFile15(file, "utf8");
     const out = [];
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
@@ -4838,11 +5010,11 @@ function computeScopeHash(root, scopedFiles) {
   try {
     const files = [...new Set(scopedFiles.map((f) => f.replace(/\\/g, "/")))].sort();
     if (files.length === 0) return "";
-    const hash = createHash2("sha256");
+    const hash = createHash3("sha256");
     let included = 0;
     for (const rel of files) {
-      const abs = path17.resolve(root, rel);
-      if (!existsSync15(abs)) continue;
+      const abs = path18.resolve(root, rel);
+      if (!existsSync16(abs)) continue;
       try {
         hash.update(rel);
         hash.update("\0");
@@ -5576,8 +5748,8 @@ function normalizeFindingSeverity(raw) {
       return "info";
   }
 }
-function findingKey(tool, ruleId, path20) {
-  return `${tool}:${ruleId}:${path20}`;
+function findingKey(tool, ruleId, path21) {
+  return `${tool}:${ruleId}:${path21}`;
 }
 function coerceJson(input) {
   if (typeof input === "string") {
@@ -5611,8 +5783,8 @@ function parseSarif(input) {
       const physical = asRecord(location.physicalLocation);
       const artifact = asRecord(physical.artifactLocation);
       const region = asRecord(physical.region);
-      const path20 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
-      if (!path20) continue;
+      const path21 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
+      if (!path21) continue;
       const line = typeof region.startLine === "number" ? region.startLine : void 0;
       const snippet = typeof asRecord(region.snippet).text === "string" ? asRecord(region.snippet).text.trim() : void 0;
       findings.push({
@@ -5620,10 +5792,10 @@ function parseSarif(input) {
         ruleId,
         message: message.trim(),
         severity,
-        path: path20,
+        path: path21,
         ...line !== void 0 ? { line } : {},
         ...snippet ? { snippet } : {},
-        key: findingKey(tool, ruleId, path20)
+        key: findingKey(tool, ruleId, path21)
       });
     }
   }
@@ -5642,17 +5814,17 @@ function parseSonar(input) {
       (typeof issue.severity === "string" ? issue.severity : void 0) ?? impactSeverity
     );
     const component = typeof issue.component === "string" ? issue.component : "";
-    const path20 = componentToPath(component);
-    if (!path20) continue;
+    const path21 = componentToPath(component);
+    if (!path21) continue;
     const line = typeof issue.line === "number" ? issue.line : void 0;
     findings.push({
       tool: "sonar",
       ruleId,
       message,
       severity,
-      path: path20,
+      path: path21,
       ...line !== void 0 ? { line } : {},
-      key: findingKey("sonar", ruleId, path20)
+      key: findingKey("sonar", ruleId, path21)
     });
   }
   return findings;
@@ -5665,7 +5837,7 @@ function parseEslintJson(input, opts = {}) {
     const file = asRecord(fileRaw);
     const rawPath = typeof file.filePath === "string" ? file.filePath : "";
     if (!rawPath) continue;
-    const path20 = cwd && rawPath.startsWith(cwd) ? rawPath.slice(cwd.length) : rawPath;
+    const path21 = cwd && rawPath.startsWith(cwd) ? rawPath.slice(cwd.length) : rawPath;
     for (const msgRaw of asArray(file.messages)) {
       const msg = asRecord(msgRaw);
       const ruleId = typeof msg.ruleId === "string" && msg.ruleId ? msg.ruleId : "parse-error";
@@ -5677,9 +5849,9 @@ function parseEslintJson(input, opts = {}) {
         ruleId,
         message,
         severity,
-        path: path20,
+        path: path21,
         ...line !== void 0 ? { line } : {},
-        key: findingKey("eslint", ruleId, path20)
+        key: findingKey("eslint", ruleId, path21)
       });
     }
   }
@@ -6129,7 +6301,7 @@ function tallyHotFiles(paths, source = "agent") {
     if (!norm) continue;
     counts.set(norm, (counts.get(norm) ?? 0) + 1);
   }
-  return [...counts.entries()].map(([path20, changes]) => ({ path: path20, changes, source })).sort((a, b) => b.changes - a.changes);
+  return [...counts.entries()].map(([path21, changes]) => ({ path: path21, changes, source })).sort((a, b) => b.changes - a.changes);
 }
 function mergeHotFiles(a, b) {
   const merged = /* @__PURE__ */ new Map();
@@ -6149,21 +6321,21 @@ function mergeHotFiles(a, b) {
 }
 
 // src/eval-history.ts
-import { appendFile as appendFile5, mkdir as mkdir12, readFile as readFile15 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
-import path18 from "path";
+import { appendFile as appendFile6, mkdir as mkdir13, readFile as readFile16 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import path19 from "path";
 function evalHistoryPath(paths) {
-  return path18.join(paths.haiveDir, ".cache", "eval-history.jsonl");
+  return path19.join(paths.haiveDir, ".cache", "eval-history.jsonl");
 }
 async function appendEvalHistory(paths, entry) {
   const file = evalHistoryPath(paths);
-  await mkdir12(path18.dirname(file), { recursive: true });
-  await appendFile5(file, JSON.stringify(entry) + "\n", "utf8");
+  await mkdir13(path19.dirname(file), { recursive: true });
+  await appendFile6(file, JSON.stringify(entry) + "\n", "utf8");
 }
 async function loadEvalHistory(paths) {
   const file = evalHistoryPath(paths);
-  if (!existsSync16(file)) return [];
-  const raw = await readFile15(file, "utf8").catch(() => "");
+  if (!existsSync17(file)) return [];
+  const raw = await readFile16(file, "utf8").catch(() => "");
   const out = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -6506,12 +6678,12 @@ ${trimmed}`;
 }
 
 // src/handoff.ts
-import { writeFile as writeFile10, readFile as readFile16, stat as stat3 } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
-import path19 from "path";
+import { writeFile as writeFile11, readFile as readFile17, stat as stat3 } from "fs/promises";
+import { existsSync as existsSync18 } from "fs";
+import path20 from "path";
 var HANDOFF_FILENAME = "NEXT.md";
 function handoffFilePath(root) {
-  return path19.join(root, HANDOFF_FILENAME);
+  return path20.join(root, HANDOFF_FILENAME);
 }
 function buildHandoffMarkdown(data) {
   const at = (data.at ?? /* @__PURE__ */ new Date()).toISOString();
@@ -6560,18 +6732,18 @@ function buildHandoffMarkdown(data) {
 }
 async function writeSessionHandoff(root, data) {
   const file = handoffFilePath(root);
-  await writeFile10(file, buildHandoffMarkdown(data), "utf8");
+  await writeFile11(file, buildHandoffMarkdown(data), "utf8");
   return file;
 }
 async function readSessionHandoff(root) {
   const file = handoffFilePath(root);
-  if (!existsSync17(file)) return null;
-  const raw = await readFile16(file, "utf8").catch(() => "");
+  if (!existsSync18(file)) return null;
+  const raw = await readFile17(file, "utf8").catch(() => "");
   return raw.trim() ? raw : null;
 }
 async function handoffAgeMs(root, now = /* @__PURE__ */ new Date()) {
   const file = handoffFilePath(root);
-  if (!existsSync17(file)) return null;
+  if (!existsSync18(file)) return null;
   try {
     const s = await stat3(file);
     return Math.max(0, now.getTime() - s.mtimeMs);
@@ -6707,6 +6879,9 @@ export {
   DEFAULT_DORMANT_DAYS,
   DEFAULT_PRIORITY_SIGNALS,
   ENV_WORKAROUND_TAGS,
+  FRICTION_FIELD_MAX,
+  FRICTION_LOG_FILE,
+  FRICTION_STATE_FILE,
   GUESSABLE_THRESHOLD,
   HAIVE_DIR,
   HAIVE_OWNED_FILES,
@@ -6744,6 +6919,7 @@ export {
   anchorMatchesComponent,
   antiPatternGateParams,
   appendEvalHistory,
+  appendFrictionReport,
   appendPreventionEvent,
   appendProposedRetrievalCases,
   appendRuntimeJournalEntry,
@@ -6821,10 +6997,15 @@ export {
   findingBody,
   findingToDraft,
   firstMemoryOneLine,
+  formatFrictionIssue,
+  frictionFingerprint,
+  frictionLogPath,
+  frictionStatePath,
   gatePassedShas,
   generateBridges,
   getUsage,
   globToRegExp,
+  groupFriction,
   handoffAgeMs,
   handoffFilePath,
   hasPendingTestMarker,
@@ -6861,6 +7042,7 @@ export {
   loadConfig,
   loadConfigSync,
   loadEvalHistory,
+  loadFrictionState,
   loadMemoriesFromDir,
   loadMemoriesFromDirDetailed,
   loadMemory,
@@ -6879,6 +7061,8 @@ export {
   newMemoryId,
   normalizeFindingSeverity,
   normalizeFramework,
+  normalizeFrictionSummary,
+  normalizeKind,
   normalizeScaffoldStyle,
   normalizeSessionId,
   overallScore,
@@ -6907,6 +7091,7 @@ export {
   quarantineNote,
   queryCodeMap,
   rankMemoriesLexical,
+  readFrictionReports,
   readRecentBriefingMarker,
   readRuntimeJournalTail,
   readSessionHandoff,
@@ -6938,6 +7123,7 @@ export {
   runtimeJournalPath,
   saveCodeMap,
   saveConfig,
+  saveFrictionState,
   saveUsageIndex,
   scaffoldPostIncidentTest,
   scannableSensorTargets,
@@ -6952,6 +7138,7 @@ export {
   sensorSelfCheck,
   sensorTargetsFromDiff,
   serializeMemory,
+  setFrictionStatus,
   snapshotContract,
   specificityScore,
   stripPrivate,