opencode-swarm 7.107.2 → 7.107.4

package/dist/cli/index-bq8kd9r9.js

@@ -0,0 +1,199 @@
+// @bun
+import {
+  countEntryContradictionsInWindow,
+  countEntryViolationsInWindow,
+  readKnowledgeEvents,
+  recordKnowledgeEvent
+} from "./index-kxm3bdjh.js";
+import {
+  jaccardBigram,
+  readKnowledge,
+  resolveHiveKnowledgePath,
+  resolveSwarmKnowledgePath,
+  transactKnowledge,
+  wordBigrams
+} from "./index-xmarctsf.js";
+import {
+  isActiveStatus
+} from "./index-bfwt3abw.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
+
+// src/hooks/knowledge-escalator.ts
+import { existsSync } from "fs";
+var NEAR_DUPLICATE_THRESHOLD = 0.6;
+var ESCALATION_WINDOW_DAYS = 30;
+var ESCALATION_THRESHOLD = 2;
+function isFullyEscalated(e) {
+  return e.directive_priority === "critical" && e.enforcement_mode === "enforce";
+}
+async function maybeEscalateOnViolation(directory, entryId, now = new Date) {
+  try {
+    let count = await countEntryViolationsInWindow(directory, entryId, ESCALATION_WINDOW_DAYS, now);
+    if (count < ESCALATION_THRESHOLD) {
+      try {
+        const allEntries = [];
+        allEntries.push(...await readKnowledge(resolveSwarmKnowledgePath(directory)));
+        const hivePath = resolveHiveKnowledgePath();
+        if (existsSync(hivePath)) {
+          allEntries.push(...await readKnowledge(hivePath));
+        }
+        const target = allEntries.find((e) => e.id === entryId);
+        if (target) {
+          const seen = new Set([entryId]);
+          const targetBigrams = wordBigrams(target.lesson);
+          for (const e of allEntries) {
+            if (seen.has(e.id))
+              continue;
+            seen.add(e.id);
+            if (jaccardBigram(targetBigrams, wordBigrams(e.lesson)) >= NEAR_DUPLICATE_THRESHOLD) {
+              count += await countEntryViolationsInWindow(directory, e.id, ESCALATION_WINDOW_DAYS, now);
+              if (count >= ESCALATION_THRESHOLD)
+                break;
+            }
+          }
+        }
+      } catch {}
+    }
+    if (count < ESCALATION_THRESHOLD) {
+      return { escalated: false, entryId, violationsInWindow: count };
+    }
+    const to = "critical";
+    const at = now.toISOString();
+    const state = {
+      outcome: { kind: "not_found" }
+    };
+    const mutate = (entries) => {
+      const entry = entries.find((e) => e.id === entryId);
+      if (!entry) {
+        state.outcome = { kind: "not_found" };
+        return null;
+      }
+      if (isFullyEscalated(entry)) {
+        state.outcome = { kind: "already" };
+        return null;
+      }
+      const from2 = entry.directive_priority ?? "medium";
+      const record = {
+        from: from2,
+        to,
+        reason: "repeat_violation",
+        at
+      };
+      entry.directive_priority = to;
+      entry.enforcement_mode = "enforce";
+      entry.escalation_history = [...entry.escalation_history ?? [], record];
+      entry.updated_at = at;
+      state.outcome = { kind: "escalated", from: from2 };
+      return entries;
+    };
+    await transactKnowledge(resolveSwarmKnowledgePath(directory), mutate);
+    if (state.outcome.kind === "not_found") {
+      const hivePath = resolveHiveKnowledgePath();
+      if (existsSync(hivePath)) {
+        await transactKnowledge(hivePath, mutate);
+      }
+    }
+    if (state.outcome.kind === "already") {
+      return {
+        escalated: false,
+        entryId,
+        violationsInWindow: count,
+        alreadyEscalated: true
+      };
+    }
+    if (state.outcome.kind === "not_found") {
+      return { escalated: false, entryId, violationsInWindow: count };
+    }
+    const from = state.outcome.from;
+    await recordKnowledgeEvent(directory, {
+      type: "escalation",
+      entry_id: entryId,
+      from,
+      to,
+      reason: "repeat_violation",
+      enforcement_mode: "enforce"
+    });
+    return {
+      escalated: true,
+      entryId,
+      from,
+      to,
+      violationsInWindow: count
+    };
+  } catch {
+    return { escalated: false, entryId };
+  }
+}
+var ESCALATION_DISPLAY_WINDOW_DAYS = 7;
+async function readRecentEscalations(directory, windowDays = ESCALATION_DISPLAY_WINDOW_DAYS, now = new Date) {
+  try {
+    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+    const events = await readKnowledgeEvents(directory);
+    const out = [];
+    for (const e of events) {
+      if (e.type !== "escalation")
+        continue;
+      const t = Date.parse(e.timestamp);
+      if (Number.isNaN(t) || t < cutoff)
+        continue;
+      out.push({
+        entry_id: e.entry_id,
+        from: e.from,
+        to: e.to,
+        reason: e.reason,
+        at: e.timestamp
+      });
+    }
+    out.sort((a, b) => a.at < b.at ? 1 : a.at > b.at ? -1 : 0);
+    return out;
+  } catch {
+    return [];
+  }
+}
+function buildEscalationBriefing(escalations, windowDays = ESCALATION_DISPLAY_WINDOW_DAYS) {
+  if (escalations.length === 0)
+    return null;
+  const lines = [`### Recently Escalated (last ${windowDays} days)`];
+  for (const e of escalations) {
+    lines.push(`- ${e.entry_id} (${e.from}\u2192${e.to}) reason=${e.reason}`);
+  }
+  return lines.join(`
+`);
+}
+async function escalateViolatedEntries(directory, entryIds, now = new Date) {
+  const out = [];
+  for (const id of [...new Set(entryIds)]) {
+    out.push(await maybeEscalateOnViolation(directory, id, now));
+  }
+  return out;
+}
+async function maybeQuarantineOnContradiction(directory, entryId, threshold, windowDays, now = new Date) {
+  try {
+    const count = await countEntryContradictionsInWindow(directory, entryId, windowDays, now);
+    if (count < threshold) {
+      return { quarantined: false, entryId, contradictionsInWindow: count };
+    }
+    const entries = await readKnowledge(resolveSwarmKnowledgePath(directory));
+    const entry = entries.find((e) => e.id === entryId);
+    if (!entry) {
+      return { quarantined: false, entryId, contradictionsInWindow: count };
+    }
+    if (!isActiveStatus(entry.status)) {
+      return {
+        quarantined: false,
+        entryId,
+        contradictionsInWindow: count,
+        alreadyInactive: true
+      };
+    }
+    const { quarantineEntry } = await import("./knowledge-validator-ez3ws8ef.js");
+    await quarantineEntry(directory, entryId, `repeat_contradiction: ${count} contradicted events in ${windowDays}d`, "auto");
+    return { quarantined: true, entryId, contradictionsInWindow: count };
+  } catch {
+    return { quarantined: false, entryId };
+  }
+}
+
+export { ESCALATION_WINDOW_DAYS, ESCALATION_THRESHOLD, maybeEscalateOnViolation, ESCALATION_DISPLAY_WINDOW_DAYS, readRecentEscalations, buildEscalationBriefing, escalateViolatedEntries, maybeQuarantineOnContradiction };