@hiveai/core 0.15.0 → 0.18.0

package/dist/index.js

@@ -318,6 +318,16 @@ var STACK_PACK_TAG = "stack-pack";
 function isStackPackSeed(fm) {
   return Boolean(fm?.tags?.includes(STACK_PACK_TAG));
 }
+var ENV_WORKAROUND_TAGS = /* @__PURE__ */ new Set([
+  "dev-workflow",
+  "dev-env",
+  "hotswap",
+  "local-setup",
+  "tooling-debt"
+]);
+function isEnvWorkaroundMemory(fm) {
+  return Boolean(fm?.tags?.some((t) => ENV_WORKAROUND_TAGS.has(t)));
+}
 var MODULE_PATTERNS = [
   /^packages\/([^/]+)\//,
   /^apps\/([^/]+)\//,
@@ -790,6 +800,45 @@ function summarizeImpact(scores) {
   }
   return summary;
 }
+function recommendFeedbackAdjustment(fm, usage, options = {}) {
+  const rejectionThreshold = options.rejectionThreshold ?? 2;
+  const hasPositiveOutcome = usage.applied_count > 0 || usage.prevented_count > 0;
+  if (fm.sensor?.severity === "block" && usage.rejected_count >= 1) {
+    return {
+      action: "downgrade-block-sensor",
+      reason: "A human contested a blocking guardrail; downgrade it to warn so the gate stays helpful while the lesson is reviewed."
+    };
+  }
+  if (!hasPositiveOutcome && usage.rejected_count >= rejectionThreshold) {
+    return {
+      action: "deprecate-memory",
+      reason: `${usage.rejected_count} rejection(s) and no applied/prevented outcomes; deprecate until the lesson is refined.`
+    };
+  }
+  return { action: "none", reason: "No automatic adjustment needed." };
+}
+function applyFeedbackAdjustment(fm, adjustment, now = /* @__PURE__ */ new Date()) {
+  if (adjustment.action === "none") return fm;
+  const tags = [.../* @__PURE__ */ new Set([...fm.tags, "feedback-contested"])];
+  if (adjustment.action === "downgrade-block-sensor" && fm.sensor) {
+    return {
+      ...fm,
+      tags,
+      verified_at: now.toISOString(),
+      sensor: { ...fm.sensor, severity: "warn" }
+    };
+  }
+  if (adjustment.action === "deprecate-memory") {
+    return {
+      ...fm,
+      tags,
+      status: "deprecated",
+      stale_reason: adjustment.reason,
+      verified_at: now.toISOString()
+    };
+  }
+  return fm;
+}
 
 // src/prevention.ts
 import { appendFile, mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
@@ -855,6 +904,84 @@ function computeRecurrence(events) {
   rows.sort((a, b) => b.distinct_days - a.distinct_days || b.catches - a.catches);
   return { recurring_count: rows.length, top: rows };
 }
+function briefingProofLine(events, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const days = options.days ?? 30;
+  const since = now.getTime() - days * MS_PER_DAY2;
+  let count = 0;
+  for (const e of events) {
+    const t = Date.parse(e.at);
+    if (!Number.isFinite(t)) continue;
+    if (t >= since && t <= now.getTime()) count += 1;
+  }
+  if (count === 0) return null;
+  return `This harness prevented ${count} repeated mistake${count === 1 ? "" : "s"} in the last ${days} days.`;
+}
+function titleFromMemory(loaded) {
+  if (!loaded) return "";
+  for (const line of loaded.memory.body.split("\n")) {
+    const heading = /^#+\s*(.+)$/.exec(line.trim());
+    if (heading) return heading[1].trim().slice(0, 96);
+  }
+  for (const line of loaded.memory.body.split("\n")) {
+    const t = line.trim();
+    if (t) return t.replace(/^[-*]\s*/, "").slice(0, 96);
+  }
+  return "";
+}
+function sourceRank(source) {
+  return source === "anti-pattern" ? 0 : 1;
+}
+function summarizeCaughtForYou(events, memories, usage, options = {}) {
+  const until = options.now ?? /* @__PURE__ */ new Date();
+  const sinceMs = options.since === void 0 ? null : options.since instanceof Date ? options.since.getTime() : Date.parse(options.since);
+  const untilMs = until.getTime();
+  const byIdSource = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const t = Date.parse(e.at);
+    if (!Number.isFinite(t)) continue;
+    if (sinceMs !== null && Number.isFinite(sinceMs) && t < sinceMs) continue;
+    if (t > untilMs) continue;
+    const key = `${e.id}\0${e.source}`;
+    const current = byIdSource.get(key) ?? { id: e.id, source: e.source, catches: 0, last_at: e.at };
+    current.catches += 1;
+    if (e.at > current.last_at) current.last_at = e.at;
+    byIdSource.set(key, current);
+  }
+  const memoryById = new Map(memories.map((m) => [m.memory.frontmatter.id, m]));
+  const rows = [...byIdSource.values()].map((row) => {
+    const current = getUsage(usage, row.id).prevented_count;
+    const previous = Math.max(0, current - row.catches);
+    return {
+      id: row.id,
+      title: titleFromMemory(memoryById.get(row.id)) || row.id,
+      source: row.source,
+      catches: row.catches,
+      previous_count: previous,
+      current_count: current,
+      last_at: row.last_at
+    };
+  }).sort((a, b) => b.last_at.localeCompare(a.last_at) || sourceRank(a.source) - sourceRank(b.source)).slice(0, options.limit ?? 5);
+  return {
+    total_catches: [...byIdSource.values()].reduce((sum, row) => sum + row.catches, 0),
+    since: sinceMs !== null && Number.isFinite(sinceMs) ? new Date(sinceMs).toISOString() : null,
+    until: until.toISOString(),
+    rows
+  };
+}
+function renderCaughtForYou(summary) {
+  if (summary.total_catches === 0 || summary.rows.length === 0) return null;
+  const lines = [
+    `Caught for you: ${summary.total_catches} prevented repeat${summary.total_catches === 1 ? "" : "s"} this session.`
+  ];
+  for (const row of summary.rows) {
+    const gate = row.source === "anti-pattern" ? "Blocked" : "Caught";
+    lines.push(
+      `- ${gate}: ${row.title} (${row.id}). Prevention ${row.previous_count}->${row.current_count}.`
+    );
+  }
+  return lines.join("\n");
+}
 
 // src/context-throttle.ts
 import { createHash } from "crypto";
@@ -1687,7 +1814,8 @@ var DEFAULT_CONFIG = {
     scoreThreshold: 80,
     cleanupGeneratedArtifacts: true,
     toolProfile: "enforcement",
-    policyPacks: ["architecture", "gotchas", "security", "domain", "release"]
+    policyPacks: ["architecture", "gotchas", "security", "domain", "release"],
+    releaseBranch: "main"
   }
 };
 var AUTOPILOT_DEFAULTS = {
@@ -1715,7 +1843,8 @@ var AUTOPILOT_DEFAULTS = {
     scoreThreshold: 85,
     cleanupGeneratedArtifacts: true,
     toolProfile: "enforcement",
-    policyPacks: ["architecture", "gotchas", "security", "domain", "release"]
+    policyPacks: ["architecture", "gotchas", "security", "domain", "release"],
+    releaseBranch: "main"
   }
 };
 function antiPatternGateParams(gate) {
@@ -2833,11 +2962,24 @@ function briefingMarkerPath(paths, sessionId) {
   return path16.join(briefingMarkersDir(paths), `${normalizeSessionId(sessionId)}.json`);
 }
 async function writeBriefingMarker(paths, input) {
+  const sessionId = normalizeSessionId(input.sessionId);
+  const accumulate = input.accumulate ?? true;
+  let priorIds = [];
+  let priorFiles = [];
+  if (accumulate) {
+    const existing = await readSessionBriefingMarker(paths, sessionId);
+    if (existing) {
+      priorIds = existing.memory_ids ?? [];
+      priorFiles = existing.files ?? [];
+    }
+  }
+  const mergedIds = [.../* @__PURE__ */ new Set([...priorIds, ...input.memoryIds ?? []])];
+  const mergedFiles = [.../* @__PURE__ */ new Set([...priorFiles, ...input.files ?? []])];
   const marker = {
-    session_id: normalizeSessionId(input.sessionId),
+    session_id: sessionId,
     ...input.task?.trim() ? { task: input.task.trim() } : {},
-    ...input.memoryIds && input.memoryIds.length > 0 ? { memory_ids: [...new Set(input.memoryIds)] } : {},
-    ...input.files && input.files.length > 0 ? { files: [...new Set(input.files)] } : {},
+    ...mergedIds.length > 0 ? { memory_ids: mergedIds } : {},
+    ...mergedFiles.length > 0 ? { files: mergedFiles } : {},
     source: input.source,
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     root: paths.root
@@ -2850,6 +2992,18 @@ async function writeBriefingMarker(paths, input) {
   );
   return marker;
 }
+async function readSessionBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKER_TTL_MS) {
+  const file = briefingMarkerPath(paths, sessionId);
+  if (!existsSync14(file)) return null;
+  try {
+    const marker = JSON.parse(await readFile13(file, "utf8"));
+    const created = Date.parse(marker.created_at);
+    if (!Number.isFinite(created) || Date.now() - created > ttlMs) return null;
+    return marker;
+  } catch {
+    return null;
+  }
+}
 async function hasRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKER_TTL_MS) {
   const now = Date.now();
   const candidates = [];
@@ -3323,8 +3477,75 @@ function parseSonar(input) {
   }
   return findings;
 }
-function parseFindings(format, input) {
-  return format === "sonar" ? parseSonar(input) : parseSarif(input);
+function parseEslintJson(input, opts = {}) {
+  const docs = asArray(coerceJson(input));
+  const findings = [];
+  const cwd = opts.cwd ? opts.cwd.replace(/\/+$/, "") + "/" : "";
+  for (const fileRaw of docs) {
+    const file = asRecord(fileRaw);
+    const rawPath = typeof file.filePath === "string" ? file.filePath : "";
+    if (!rawPath) continue;
+    const path18 = 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";
+      const message = typeof msg.message === "string" ? msg.message.trim() : ruleId;
+      const severity = normalizeFindingSeverity(msg.severity === 2 ? "error" : "warning");
+      const line = typeof msg.line === "number" ? msg.line : void 0;
+      findings.push({
+        tool: "eslint",
+        ruleId,
+        message,
+        severity,
+        path: path18,
+        ...line !== void 0 ? { line } : {},
+        key: findingKey("eslint", ruleId, path18)
+      });
+    }
+  }
+  return findings;
+}
+var NPM_AUDIT_SEVERITY = {
+  critical: "blocker",
+  high: "critical",
+  moderate: "major",
+  low: "minor",
+  info: "info"
+};
+function parseNpmAudit(input) {
+  const doc = asRecord(coerceJson(input));
+  const vulns = asRecord(doc.vulnerabilities);
+  const findings = [];
+  for (const [name, vulnRaw] of Object.entries(vulns)) {
+    const vuln = asRecord(vulnRaw);
+    const sev = typeof vuln.severity === "string" ? vuln.severity.toLowerCase() : "info";
+    const severity = NPM_AUDIT_SEVERITY[sev] ?? "info";
+    const via = asArray(vuln.via);
+    const firstAdvisory = via.map(asRecord).find((v) => typeof v.title === "string");
+    const title = firstAdvisory && typeof firstAdvisory.title === "string" ? firstAdvisory.title : `Vulnerable dependency: ${name}`;
+    const range = typeof vuln.range === "string" ? ` (affected range: ${vuln.range})` : "";
+    findings.push({
+      tool: "npm-audit",
+      ruleId: name,
+      message: `${title}${range}`,
+      severity,
+      path: "package.json",
+      key: findingKey("npm-audit", name, "package.json")
+    });
+  }
+  return findings;
+}
+function parseFindings(format, input, opts = {}) {
+  switch (format) {
+    case "sonar":
+      return parseSonar(input);
+    case "eslint":
+      return parseEslintJson(input, opts);
+    case "npm-audit":
+      return parseNpmAudit(input);
+    default:
+      return parseSarif(input);
+  }
 }
 function normalizeUri(uri) {
   return uri.replace(/^file:\/\//, "").replace(/^\.\//, "");
@@ -3440,6 +3661,23 @@ function suggestGate(precision, rejections, currentGate) {
   }
   return null;
 }
+function nullableMetricDelta(baseline, current) {
+  if (baseline === null || current === null) return { baseline, current, delta: null };
+  return { baseline: round33(baseline), current: round33(current), delta: round33(current - baseline) };
+}
+function compareGatePrecision(baseline, current) {
+  const precision = nullableMetricDelta(baseline.precision, current.precision);
+  const rejections = nullableMetricDelta(baseline.rejections, current.rejections);
+  const falsePositivesIncreased = current.rejections > baseline.rejections;
+  const precisionRegressed = precision.delta !== null && precision.delta < 0;
+  return {
+    precision,
+    rejections,
+    false_positives_increased: falsePositivesIncreased,
+    precision_regressed: precisionRegressed,
+    regressed: falsePositivesIncreased || precisionRegressed
+  };
+}
 
 // src/dashboard.ts
 var MS_PER_DAY4 = 24 * 60 * 60 * 1e3;
@@ -3548,9 +3786,26 @@ function buildDashboard(memories, usage, options = {}) {
   );
   sensorRows.sort((a, b) => b.last_fired.localeCompare(a.last_fired));
   dormantRows.sort((a, b) => b.age_days - a.age_days);
+  const eventLog = options.preventionEvents ?? [];
+  const recurrence = computeRecurrence(eventLog);
   return {
     generated_at: now.toISOString(),
     inventory,
+    prevention: {
+      total_events: preventionEvents,
+      memories_with_catches: preventionRows.length,
+      top: preventionRows.sort((a, b) => b.prevented_count - a.prevented_count).slice(0, top),
+      trend: computePreventionTrend(eventLog, now),
+      recurrence: {
+        ...recurrence,
+        top: recurrence.top.slice(0, top)
+      }
+    },
+    gate_precision: computeGatePrecision(
+      eventLog,
+      usage,
+      options.antiPatternGate ?? "anchored"
+    ),
     impact: { ...summarizeImpact(impactScores), top: impactRows.slice(0, top) },
     sensors: {
       total: sensorTotal,
@@ -3572,21 +3827,6 @@ function buildDashboard(memories, usage, options = {}) {
       decaying,
       top_dormant: dormantRows.slice(0, top)
     },
-    prevention: {
-      total_events: preventionEvents,
-      memories_with_catches: preventionRows.length,
-      top: preventionRows.sort((a, b) => b.prevented_count - a.prevented_count).slice(0, top),
-      trend: computePreventionTrend(options.preventionEvents ?? [], now),
-      recurrence: {
-        ...computeRecurrence(options.preventionEvents ?? []),
-        top: computeRecurrence(options.preventionEvents ?? []).top.slice(0, top)
-      }
-    },
-    gate_precision: computeGatePrecision(
-      options.preventionEvents ?? [],
-      usage,
-      options.antiPatternGate ?? "anchored"
-    ),
     corpus: {
       memory_files: inventory.total,
       body_chars: bodyChars,
@@ -3759,6 +3999,7 @@ function planConflictResolution(a, b) {
 var REVERT_RE = /^Revert\s+"(.+)"\s*$/i;
 var FIXUP_RE = /^(?:fixup!|hotfix[:!]|fix[:!]\s*revert|revert\s+revert)/i;
 var URGENT_FIX_RE = /\b(hotfix|urgent fix|emergency fix|critical fix|broke production|broken build)\b/i;
+var WORKAROUND_RE = /\b(workaround|work around|hack(?:y|ish)?|band[- ]?aid|temporary fix|temp fix|quick fix|kludge|monkey[- ]?patch|stop[- ]?gap|FIXME|XXX)\b/i;
 function slugify(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "reverted-change";
 }
@@ -3776,6 +4017,9 @@ function proposeSeedsFromCommits(commits, limit = 20) {
     } else if (FIXUP_RE.test(subject) || URGENT_FIX_RE.test(subject)) {
       what = subject.replace(FIXUP_RE, "").trim() || subject;
       kind = "fixup";
+    } else if (WORKAROUND_RE.test(subject)) {
+      what = subject;
+      kind = "workaround";
     }
     if (!what || !kind) continue;
     const slug = slugify(what);
@@ -3784,7 +4028,7 @@ function proposeSeedsFromCommits(commits, limit = 20) {
     out.push({
       slug,
       what,
-      why_failed: kind === "revert" ? `This change was reverted in commit ${commit.sha} \u2014 it caused a regression and was backed out. Verify the root cause before re-attempting.` : `This area required an urgent fix (commit ${commit.sha}: "${subject}") \u2014 it shipped broken once. Treat changes here with extra care.`,
+      why_failed: kind === "revert" ? `This change was reverted in commit ${commit.sha} \u2014 it caused a regression and was backed out. Verify the root cause before re-attempting.` : kind === "workaround" ? `This area carries a known workaround/stop-gap (commit ${commit.sha}: "${subject}") \u2014 the proper fix is still owed. Understand why the workaround exists before changing it.` : `This area required an urgent fix (commit ${commit.sha}: "${subject}") \u2014 it shipped broken once. Treat changes here with extra care.`,
       paths: (commit.files ?? []).slice(0, 8),
       source_sha: commit.sha,
       kind
@@ -3794,6 +4038,75 @@ function proposeSeedsFromCommits(commits, limit = 20) {
   return out;
 }
 
+// src/seed.ts
+var JS_DETECTORS = [
+  ["nestjs", ["@nestjs/core"]],
+  ["nextjs", ["next"]],
+  ["remix", ["@remix-run/react", "@remix-run/node"]],
+  ["react", ["react"]],
+  ["express", ["express"]],
+  ["fastify", ["fastify"]],
+  ["prisma", ["@prisma/client", "prisma"]],
+  ["drizzle", ["drizzle-orm"]],
+  ["zustand", ["zustand"]],
+  ["redux", ["@reduxjs/toolkit", "redux"]],
+  ["reactquery", ["@tanstack/react-query", "react-query"]],
+  ["trpc", ["@trpc/server", "@trpc/client"]],
+  ["mongoose", ["mongoose"]],
+  ["graphql", ["@apollo/client", "@apollo/server", "apollo-server", "graphql"]],
+  ["vue", ["vue", "@vue/core"]],
+  ["tailwind", ["tailwindcss"]],
+  ["vite", ["vite"]],
+  ["sveltekit", ["@sveltejs/kit"]],
+  ["astro", ["astro"]],
+  ["typescript", ["typescript"]],
+  ["monorepo", ["turbo", "nx", "@nrwl/workspace", "@nx/workspace"]]
+];
+var PYTHON_DETECTORS = [
+  ["fastapi", /\bfastapi\b/i],
+  ["django", /\bdjango\b/i],
+  ["flask", /\bflask\b/i]
+];
+function detectFromPackageJson(deps) {
+  const detected = [];
+  for (const [stack, signals] of JS_DETECTORS) {
+    if (signals.some((s) => s in deps)) detected.push(stack);
+  }
+  if (detected.includes("nextjs") || detected.includes("remix")) {
+    return detected.filter((s) => s !== "react");
+  }
+  return detected;
+}
+function detectFromRequirementsTxt(content) {
+  return PYTHON_DETECTORS.filter(([, re]) => re.test(content)).map(([s]) => s);
+}
+function detectFromGoMod(content) {
+  return /^\s*module\s+\S/m.test(content) ? ["go"] : [];
+}
+function detectFromPomXml(content) {
+  return /org\.springframework|spring-boot/.test(content) ? ["spring"] : [];
+}
+function detectFromComposerJson(content) {
+  return /laravel\/framework|illuminate\//.test(content) ? ["laravel"] : [];
+}
+function detectFromGemfile(content) {
+  return /^\s*gem\s+["']rails["']/m.test(content) || /\brails\b/.test(content) ? ["rails"] : [];
+}
+function detectStacksFromManifests(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const add = (stacks) => stacks.forEach((s) => seen.add(s));
+  if (input.packageJsonDeps) add(detectFromPackageJson(input.packageJsonDeps));
+  if (input.requirementsTxt) add(detectFromRequirementsTxt(input.requirementsTxt));
+  if (input.goMod) add(detectFromGoMod(input.goMod));
+  if (input.pomXml) add(detectFromPomXml(input.pomXml));
+  if (input.composerJson) add(detectFromComposerJson(input.composerJson));
+  if (input.gemfile) add(detectFromGemfile(input.gemfile));
+  if (input.hasCsproj) add(["dotnet"]);
+  if (input.hasDockerfile) add(["docker"]);
+  if (input.hasTurboJson || input.hasNxJson) add(["monorepo"]);
+  return Array.from(seen);
+}
+
 // src/merge-memory.ts
 function safeParse(raw) {
   try {
@@ -3823,10 +4136,207 @@ function mergeMemoryVersions(ours, theirs) {
   if (cmp < 0) return { content: ours, winner: "ours", reason: `newer created_at (${ca})` };
   return { content: ours, winner: "ours", reason: "tie \u2014 kept ours" };
 }
+
+// src/recap.ts
+function isAutoRecap(body) {
+  return /Auto-captured session/i.test(body) || /\bEdited \d+ files? across \d+ tool calls?/i.test(body) || /\b\d+ tool calls?\b/i.test(body);
+}
+function compactAutoRecapBody(body, maxChars = 600) {
+  if (!isAutoRecap(body)) return body;
+  const goalMatch = body.match(/##+\s*Goal[^\n]*\n+([^\n]+)/i);
+  const callsMatch = body.match(/Auto-captured session \(([^)]+)\)/i);
+  const header = goalMatch?.[1]?.trim() ? `_${goalMatch[1].trim()}_` : callsMatch ? `_Auto-captured session (${callsMatch[1]})._` : "_Auto-captured session._";
+  const discMatch = body.match(/##+\s*Discoveries[^\n]*\n([\s\S]*?)(?=\n##+\s|\n*$)/i);
+  const discovery = discMatch?.[1]?.trim() ?? "";
+  const trivialDiscovery = discovery === "" || /^no (new memories|surprising)/i.test(discovery) || /No new memories saved this session\.?$/i.test(discovery);
+  if (trivialDiscovery) {
+    return `${header}
+
+_No notable discoveries captured. Run post_task / \`mem_session_end\` for a richer recap._`;
+  }
+  const trimmed = discovery.length > maxChars ? discovery.slice(0, maxChars) + "\u2026" : discovery;
+  return `${header}
+
+**Discoveries:**
+${trimmed}`;
+}
+
+// src/priority.ts
+var DEFAULT_PRIORITY_SIGNALS = {
+  type: "",
+  tags: [],
+  requiresHumanApproval: false,
+  directAnchor: false,
+  directSymbol: false,
+  exactTaskMatch: false,
+  strongSemantic: false,
+  usefulSemantic: false,
+  moduleOrDomainMatch: false,
+  tagTaskMatch: false
+};
+function prioritySignals(partial) {
+  return { ...DEFAULT_PRIORITY_SIGNALS, ...partial };
+}
+function classifyMemoryPriority(signals) {
+  const isNegative = signals.type === "attempt";
+  const isSkill2 = signals.type === "skill";
+  if (signals.requiresHumanApproval || signals.directAnchor || signals.directSymbol || isNegative && (signals.exactTaskMatch || signals.strongSemantic) || isSkill2 && (signals.exactTaskMatch || signals.strongSemantic)) {
+    return "must_read";
+  }
+  if (isStackPackSeed({ tags: signals.tags }) || isEnvWorkaroundMemory({ tags: signals.tags })) {
+    return "background";
+  }
+  if (isSkill2 || signals.moduleOrDomainMatch || signals.exactTaskMatch || signals.usefulSemantic || signals.tagTaskMatch) {
+    return "useful";
+  }
+  return "background";
+}
+function priorityRank(priority) {
+  return priority === "must_read" ? 3 : priority === "useful" ? 2 : 1;
+}
+
+// src/bridges.ts
+var BRIDGE_TARGET_PATH = {
+  claude: "CLAUDE.md",
+  cursor: ".cursor/rules/haive-memories.mdc",
+  cline: ".clinerules",
+  windsurf: ".windsurfrules",
+  continue: ".continuerules",
+  cody: ".sourcegraph/cody-rules.md",
+  zed: ".rules",
+  roo: ".roo/rules/haive.md",
+  gemini: "GEMINI.md",
+  aider: "CONVENTIONS.md",
+  agents: "AGENTS.md",
+  copilot: ".github/copilot-instructions.md"
+};
+var BRIDGE_TARGETS = Object.keys(BRIDGE_TARGET_PATH);
+var BRIDGE_MARKERS = {
+  memoriesStart: "<!-- haive:memories-start -->",
+  memoriesEnd: "<!-- haive:memories-end -->",
+  sensorsStart: "<!-- haive:sensors-start -->",
+  sensorsEnd: "<!-- haive:sensors-end -->"
+};
+function bridgeMemorySummary(body) {
+  const firstLine = body.split("\n").map((l) => l.replace(/^#+\s*/, "").trim()).find((l) => l.length > 0) ?? "";
+  const oneLine = firstLine.replace(/\s+/g, " ");
+  return oneLine.length > 140 ? oneLine.slice(0, 137) + "\u2026" : oneLine;
+}
+function prepareBridgeData(memories, sensors, opts) {
+  const max = opts?.maxMemories ?? 8;
+  const topMemories = memories.filter((m) => {
+    const s = m.frontmatter.status;
+    if (m.frontmatter.type === "session_recap") return false;
+    if (m.frontmatter.tags?.includes("stack-pack") || m.frontmatter.tags?.includes("seed")) return false;
+    return s === "validated" || s === "proposed";
+  }).sort((a, b) => {
+    const score = (m) => m.frontmatter.status === "validated" ? 2 : 1;
+    return score(b) - score(a);
+  }).slice(0, max).map((m) => ({
+    id: m.frontmatter.id,
+    scope: m.frontmatter.scope,
+    type: m.frontmatter.type,
+    summary: bridgeMemorySummary(m.body),
+    paths: m.frontmatter.anchor?.paths ?? []
+  }));
+  const blockSensors = sensors.filter((s) => s.severity === "block");
+  return { topMemories, blockSensors };
+}
+function renderMemoriesBlock(topMemories) {
+  const lines = [
+    BRIDGE_MARKERS.memoriesStart,
+    "<!-- AUTO-GENERATED by haive bridges sync \u2014 do not edit between these markers -->",
+    "<!-- Top memories \u2014 call get_briefing / mem_get for the full body. -->",
+    ""
+  ];
+  if (topMemories.length === 0) {
+    lines.push("_(no validated memories yet \u2014 run `haive sync` to populate)_");
+  } else {
+    for (const m of topMemories) {
+      const scopeNote = m.paths.length > 0 ? ` _(applies to: ${m.paths.slice(0, 4).join(", ")}${m.paths.length > 4 ? ", \u2026" : ""})_` : "";
+      lines.push(`- \`${m.id}\` (${m.scope}/${m.type}) \u2014 ${m.summary}${scopeNote}`);
+    }
+  }
+  lines.push("", BRIDGE_MARKERS.memoriesEnd);
+  return lines.join("\n");
+}
+function renderSensorsBlock(blockSensors) {
+  if (blockSensors.length === 0) return "";
+  const lines = [
+    BRIDGE_MARKERS.sensorsStart,
+    "<!-- AUTO-GENERATED by haive bridges sync \u2014 do not edit between these markers -->",
+    "",
+    "## Hard rules \u2014 hAIve block sensors",
+    "",
+    "The patterns below are blocked by the repo enforcement gate.",
+    "Introducing them will fail the pre-commit check (`haive enforce check`).",
+    ""
+  ];
+  for (const s of blockSensors) {
+    const pathNote = s.paths.length > 0 ? ` _(applies to: ${s.paths.join(", ")})_` : "";
+    lines.push(`- **${s.id}**${pathNote}: ${s.message}`);
+    if (s.pattern) lines.push(`  - Pattern: \`${s.pattern}\``);
+  }
+  lines.push("", BRIDGE_MARKERS.sensorsEnd);
+  return lines.join("\n");
+}
+var HAIVE_PREAMBLE = "This repo uses **[hAIve](https://github.com/Doucs91/hAIve)** for shared context and enforcement.\n\n**Before editing** for a goal: call `get_briefing` (task + files/symbols) to load ranked context.\n**When an approach fails**: call `mem_tried` right away.\n**Before closing**: run `haive enforce finish` and capture learnings via the `post_task` prompt.\n\nIf `get_briefing` returns `action_required`, surface each item to the developer and wait for\nexplicit confirmation before modifying any code.";
+function renderMarkdownBridge(topMemories, blockSensors, title) {
+  const parts = [
+    `# ${title}`,
+    "",
+    HAIVE_PREAMBLE,
+    "",
+    "## Memories",
+    "",
+    renderMemoriesBlock(topMemories)
+  ];
+  const sensorsBlock = renderSensorsBlock(blockSensors);
+  if (sensorsBlock) {
+    parts.push("", sensorsBlock);
+  }
+  return parts.join("\n") + "\n";
+}
+function renderCursorBridge(topMemories, blockSensors) {
+  const frontmatter = [
+    "---",
+    "description: hAIve shared memories & block sensors (auto-generated)",
+    "alwaysApply: true",
+    "---",
+    ""
+  ].join("\n");
+  return frontmatter + renderMarkdownBridge(topMemories, blockSensors, "hAIve rules (Cursor)");
+}
+var FORMATTERS = {
+  claude: (m, s) => renderMarkdownBridge(m, s, "CLAUDE.md \u2014 hAIve context"),
+  cursor: (m, s) => renderCursorBridge(m, s),
+  cline: (m, s) => renderMarkdownBridge(m, s, "hAIve rules (Cline)"),
+  windsurf: (m, s) => renderMarkdownBridge(m, s, "hAIve rules (Windsurf)"),
+  continue: (m, s) => renderMarkdownBridge(m, s, "hAIve rules (Continue)"),
+  cody: (m, s) => renderMarkdownBridge(m, s, "hAIve rules (Cody / Sourcegraph)"),
+  zed: (m, s) => renderMarkdownBridge(m, s, "hAIve rules (Zed)"),
+  roo: (m, s) => renderMarkdownBridge(m, s, "hAIve rules (Roo Code)"),
+  gemini: (m, s) => renderMarkdownBridge(m, s, "GEMINI.md \u2014 hAIve context"),
+  aider: (m, s) => renderMarkdownBridge(m, s, "CONVENTIONS.md \u2014 hAIve context (Aider)"),
+  agents: (m, s) => renderMarkdownBridge(m, s, "AGENTS.md \u2014 hAIve context"),
+  copilot: (m, s) => renderMarkdownBridge(m, s, "hAIve rules (GitHub Copilot)")
+};
+function generateBridges(memories, sensors, opts) {
+  const { topMemories, blockSensors } = prepareBridgeData(memories, sensors, opts);
+  const targets = opts?.targets ?? BRIDGE_TARGETS;
+  return targets.map((target) => ({
+    target,
+    path: BRIDGE_TARGET_PATH[target],
+    content: FORMATTERS[target](topMemories, blockSensors)
+  }));
+}
 export {
   AUTOPILOT_DEFAULTS,
   ActivationSchema,
   AnchorSchema,
+  BRIDGE_MARKERS,
+  BRIDGE_TARGETS,
+  BRIDGE_TARGET_PATH,
   BRIEFING_MARKER_TTL_MS,
   BRIEFING_PRESET_DEFAULTS,
   CHARS_PER_TOKEN,
@@ -3839,6 +4349,8 @@ export {
   DEFAULT_CONFIDENCE_THRESHOLDS,
   DEFAULT_CONFIG,
   DEFAULT_DORMANT_DAYS,
+  DEFAULT_PRIORITY_SIGNALS,
+  ENV_WORKAROUND_TAGS,
   GUESSABLE_THRESHOLD,
   HAIVE_DIR,
   MEMORIES_DIR,
@@ -3867,8 +4379,11 @@ export {
   appendPreventionEvent,
   appendRuntimeJournalEntry,
   appendUsageEvent,
+  applyFeedbackAdjustment,
+  bridgeMemorySummary,
   briefingMarkerPath,
   briefingMarkersDir,
+  briefingProofLine,
   buildCodeMap,
   buildCoverageIndex,
   buildDashboard,
@@ -3876,9 +4391,12 @@ export {
   buildFrontmatter,
   buildReport,
   bumpRead,
+  classifyMemoryPriority,
   codeMapPath,
   collectTimelineEntries,
+  compactAutoRecapBody,
   compareEvalReports,
+  compareGatePrecision,
   compareImpact,
   compileRegexSensor,
   computeEvalTrend,
@@ -3889,6 +4407,7 @@ export {
   configPath,
   contractLockPath,
   deriveConfidence,
+  detectStacksFromManifests,
   diffContract,
   diffHasDistinctiveOverlap,
   distinctiveCap,
@@ -3910,15 +4429,18 @@ export {
   findingBody,
   findingToDraft,
   firstMemoryOneLine,
+  generateBridges,
   getUsage,
   globToRegExp,
   hasRecentBriefingMarker,
   hashProjectContext,
   inferModulesFromPaths,
   isAutoPromoteEligible,
+  isAutoRecap,
   isCovered,
   isDecaying,
   isDistinctiveToken,
+  isEnvWorkaroundMemory,
   isFreshIsoDate,
   isGlobPath,
   isLikelyGuessable,
@@ -3944,15 +4466,20 @@ export {
   normalizeFindingSeverity,
   normalizeSessionId,
   overallScore,
+  parseEslintJson,
   parseFindings,
   parseMemory,
+  parseNpmAudit,
   parseSarif,
   parseSince,
   parseSonar,
   pathsOverlap,
   pickSnippetNeedle,
   planConflictResolution,
+  prepareBridgeData,
   preventionLogPath,
+  priorityRank,
+  prioritySignals,
   projectContextRecentlyEmitted,
   proposeSeedsFromCommits,
   pullCrossRepoSources,
@@ -3961,11 +4488,13 @@ export {
   readRecentBriefingMarker,
   readRuntimeJournalTail,
   readUsageEvents,
+  recommendFeedbackAdjustment,
   recordApplied,
   recordPrevention,
   recordProjectContextEmission,
   recordRejection,
   relPathFrom,
+  renderCaughtForYou,
   resolveBriefingBudget,
   resolveHaivePaths,
   resolveManifestFiles,
@@ -3989,6 +4518,7 @@ export {
   suggestGate,
   suggestSensorFromMemory,
   suggestTopicKey,
+  summarizeCaughtForYou,
   summarizeImpact,
   synthesizeSelfEvalCases,
   titleFromBody,