@a-company/paradigm 3.44.0 → 5.3.3

package/dist/chunk-GGMI6C2L.js

@@ -0,0 +1,1075 @@
+#!/usr/bin/env node
+import {
+  init_agent_loader,
+  loadAgentProfile,
+  loadAllAgentProfiles,
+  saveAgentProfile
+} from "./chunk-A2L4TSLZ.js";
+import {
+  init_journal_loader,
+  journal_loader_exports
+} from "./chunk-MCMOGQMU.js";
+import {
+  __esm,
+  __export,
+  __require,
+  __toCommonJS
+} from "./chunk-7N7GSU6K.js";
+
+// ../paradigm-mcp/src/utils/event-stream.ts
+import * as fs from "fs";
+import * as path from "path";
+function getStreamPath(rootDir) {
+  return path.join(rootDir, EVENTS_DIR, STREAM_FILE);
+}
+function generateEventId() {
+  const now = Date.now();
+  const rand = Math.floor(Math.random() * 9999).toString().padStart(4, "0");
+  return `ev-${now}-${rand}`;
+}
+function emitEvent(rootDir, event) {
+  const full = {
+    id: generateEventId(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...event
+  };
+  memoryStream.push(full);
+  if (memoryStream.length > DEFAULT_MAX_EVENTS) {
+    memoryStream = memoryStream.slice(-DEFAULT_MAX_EVENTS);
+  }
+  try {
+    const dir = path.join(rootDir, EVENTS_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    const streamPath = getStreamPath(rootDir);
+    fs.appendFileSync(streamPath, JSON.stringify(full) + "\n", "utf8");
+    pruneIfNeeded(streamPath);
+  } catch {
+  }
+  return full;
+}
+function pruneIfNeeded(streamPath) {
+  try {
+    const stat = fs.statSync(streamPath);
+    if (stat.size > 512 * 1024) {
+      const content = fs.readFileSync(streamPath, "utf8");
+      const lines = content.trim().split("\n");
+      if (lines.length > DEFAULT_MAX_EVENTS) {
+        const kept = lines.slice(-DEFAULT_MAX_EVENTS);
+        fs.writeFileSync(streamPath, kept.join("\n") + "\n", "utf8");
+      }
+    }
+  } catch {
+  }
+}
+function queryEvents(rootDir, opts) {
+  let events = loadEventsFromDisk(rootDir);
+  if (opts?.type) events = events.filter((e) => e.type === opts.type);
+  if (opts?.source) events = events.filter((e) => e.source === opts.source);
+  if (opts?.symbol) events = events.filter((e) => e.symbols?.includes(opts.symbol));
+  if (opts?.agent) events = events.filter((e) => e.agent === opts.agent);
+  if (opts?.since) events = events.filter((e) => e.timestamp >= opts.since);
+  events.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  if (opts?.limit) events = events.slice(0, opts.limit);
+  return events;
+}
+function loadEventsFromDisk(rootDir) {
+  const streamPath = getStreamPath(rootDir);
+  if (!fs.existsSync(streamPath)) return [...memoryStream];
+  try {
+    const content = fs.readFileSync(streamPath, "utf8");
+    const events = content.trim().split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+    return events;
+  } catch {
+    return [...memoryStream];
+  }
+}
+function scoreEventForAgent(event, agentId, attention) {
+  let symbolMatch = 0;
+  let pathMatch = 0;
+  let conceptMatch = 0;
+  let signalMatch = 0;
+  if (attention.symbols?.length && event.symbols?.length) {
+    for (const pattern of attention.symbols) {
+      for (const symbol of event.symbols) {
+        if (matchGlob(pattern, symbol)) {
+          symbolMatch = Math.max(symbolMatch, 1);
+        }
+      }
+    }
+  }
+  if (attention.paths?.length && event.path) {
+    for (const pattern of attention.paths) {
+      if (matchGlob(pattern, event.path)) {
+        pathMatch = 1;
+        break;
+      }
+    }
+  }
+  if (attention.concepts?.length) {
+    const eventText = [
+      event.context || "",
+      ...event.keywords || [],
+      event.type
+    ].join(" ").toLowerCase();
+    let matched = 0;
+    for (const concept of attention.concepts) {
+      if (eventText.includes(concept.toLowerCase())) {
+        matched++;
+      }
+    }
+    if (attention.concepts.length > 0) {
+      conceptMatch = matched / attention.concepts.length;
+    }
+  }
+  if (attention.signals?.length) {
+    for (const signal of attention.signals) {
+      if (signal.type === event.type) {
+        signalMatch = 1;
+        break;
+      }
+    }
+  }
+  const dimensions = [symbolMatch, pathMatch, conceptMatch, signalMatch].sort((a, b) => b - a);
+  const score = dimensions[0] * 0.5 + dimensions[1] * 0.2 + dimensions[2] * 0.15 + dimensions[3] * 0.15;
+  const threshold = attention.threshold ?? 0.6;
+  return {
+    agentId,
+    score,
+    breakdown: { symbolMatch, pathMatch, conceptMatch, signalMatch },
+    shouldNominate: score >= threshold,
+    quietReason: score < threshold ? "below-threshold" : void 0
+  };
+}
+function matchGlob(pattern, value) {
+  if (pattern === value) return true;
+  const regex = pattern.replace(/\*\*/g, "\xA7\xA7").replace(/\*/g, "[^/]*").replace(/§§/g, ".*");
+  try {
+    return new RegExp(`^${regex}$`).test(value);
+  } catch {
+    return false;
+  }
+}
+var EVENTS_DIR, STREAM_FILE, DEFAULT_MAX_EVENTS, memoryStream;
+var init_event_stream = __esm({
+  "../paradigm-mcp/src/utils/event-stream.ts"() {
+    "use strict";
+    EVENTS_DIR = ".paradigm/events";
+    STREAM_FILE = "stream.jsonl";
+    DEFAULT_MAX_EVENTS = 1e3;
+    memoryStream = [];
+  }
+});
+
+// ../paradigm-mcp/src/types/data-policy.ts
+var DEFAULT_DATA_POLICY;
+var init_data_policy = __esm({
+  "../paradigm-mcp/src/types/data-policy.ts"() {
+    "use strict";
+    DEFAULT_DATA_POLICY = {
+      version: "1.0",
+      default_ring: "project-locked",
+      observation: {
+        allow: ["src/**", ".paradigm/**", "portal.yaml"],
+        deny: [".env*", "**/*.key", "**/*.pem", "**/secrets/**"]
+      },
+      streams: {
+        work_log: {
+          ring: "project-locked",
+          allow_content: ["file_paths", "symbol_names", "outcome"],
+          deny_content: ["code_snippets", "file_contents", "diff_content"]
+        },
+        learning_journal: {
+          ring: "user-scoped",
+          allow_content: ["pattern_descriptions", "confidence_adjustments", "approach_descriptions"],
+          deny_content: ["code_snippets", "file_contents", "symbol_names_with_context"],
+          redaction: [
+            { pattern: "\\b[A-Z_]{2,}_KEY\\b" },
+            { pattern: "password|secret|token" }
+          ]
+        },
+        team_decisions: {
+          ring: "project-locked",
+          allow_content: ["rationale", "alternatives", "symbol_references"],
+          deny_content: ["implementation_details"]
+        }
+      },
+      upstream: {
+        ring: "creator-upstream",
+        allowed: ["task_type", "outcome", "helpfulness", "duration_bucket", "error_category"],
+        denied: ["code_of_any_kind", "file_paths", "symbol_names", "conversation_content", "user_identity"]
+      },
+      network: {
+        ring: "network-public",
+        opt_in: false,
+        if_opted_in: ["aggregated_task_success_rates", "anonymized_pattern_frequency"]
+      }
+    };
+  }
+});
+
+// ../paradigm-mcp/src/utils/data-policy-loader.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as yaml from "js-yaml";
+function loadDataPolicy(rootDir) {
+  const filePath = path2.join(rootDir, POLICY_FILE);
+  if (!fs2.existsSync(filePath)) {
+    return { ...DEFAULT_DATA_POLICY };
+  }
+  try {
+    const content = fs2.readFileSync(filePath, "utf8");
+    const userPolicy = yaml.load(content);
+    return mergePolicy(DEFAULT_DATA_POLICY, userPolicy);
+  } catch {
+    return { ...DEFAULT_DATA_POLICY };
+  }
+}
+function mergePolicy(base, override) {
+  const merged = { ...base };
+  if (override.version) merged.version = override.version;
+  if (override.default_ring) merged.default_ring = override.default_ring;
+  if (override.observation) {
+    merged.observation = {
+      allow: override.observation.allow || base.observation?.allow,
+      deny: [
+        ...base.observation?.deny || [],
+        ...override.observation.deny || []
+      ].filter((v, i, a) => a.indexOf(v) === i)
+      // deduplicate
+    };
+  }
+  if (override.streams) {
+    merged.streams = { ...base.streams };
+    for (const key of ["work_log", "learning_journal", "team_decisions"]) {
+      if (override.streams[key]) {
+        merged.streams[key] = {
+          ...base.streams?.[key],
+          ...override.streams[key],
+          deny_content: [
+            ...base.streams?.[key]?.deny_content || [],
+            ...override.streams[key]?.deny_content || []
+          ].filter((v, i, a) => a.indexOf(v) === i)
+        };
+      }
+    }
+  }
+  if (override.upstream) merged.upstream = { ...base.upstream, ...override.upstream };
+  if (override.network) merged.network = { ...base.network, ...override.network };
+  if (override.agent_overrides) merged.agent_overrides = { ...base.agent_overrides, ...override.agent_overrides };
+  if (override.deployment) merged.deployment = { ...base.deployment, ...override.deployment };
+  return merged;
+}
+function canObservePath(policy, filePath, agentId) {
+  if (agentId && policy.agent_overrides?.[agentId]?.observation) {
+    const agentObs = policy.agent_overrides[agentId].observation;
+    if (agentObs.deny?.some((p) => matchGlob2(p, filePath))) return false;
+  }
+  if (policy.observation?.deny?.some((p) => matchGlob2(p, filePath))) {
+    return false;
+  }
+  if (policy.observation?.allow?.length) {
+    return policy.observation.allow.some((p) => matchGlob2(p, filePath));
+  }
+  return true;
+}
+function filterContent(content, policy, stream) {
+  const streamRules = policy.streams?.[stream];
+  if (!streamRules) return { filtered: content, redacted: [] };
+  const redacted = [];
+  let result = content;
+  if (streamRules.redaction) {
+    for (const pattern of streamRules.redaction) {
+      try {
+        const regex = new RegExp(pattern.pattern, "gi");
+        const matches = result.match(regex);
+        if (matches) {
+          redacted.push(...matches);
+          result = result.replace(regex, pattern.replacement || "[REDACTED]");
+        }
+      } catch {
+      }
+    }
+  }
+  return { filtered: result, redacted };
+}
+function matchGlob2(pattern, value) {
+  if (pattern === value) return true;
+  const regex = pattern.replace(/\*\*/g, "\xA7\xA7").replace(/\*/g, "[^/]*").replace(/§§/g, ".*");
+  try {
+    return new RegExp(`^${regex}$`).test(value);
+  } catch {
+    return false;
+  }
+}
+var POLICY_FILE;
+var init_data_policy_loader = __esm({
+  "../paradigm-mcp/src/utils/data-policy-loader.ts"() {
+    "use strict";
+    init_data_policy();
+    POLICY_FILE = ".paradigm/data-policy.yaml";
+  }
+});
+
+// ../paradigm-mcp/src/utils/notebook-loader.ts
+var notebook_loader_exports = {};
+__export(notebook_loader_exports, {
+  addNotebookEntry: () => addNotebookEntry,
+  incrementApplied: () => incrementApplied,
+  loadNotebookEntries: () => loadNotebookEntries,
+  promoteFromLore: () => promoteFromLore,
+  searchNotebooks: () => searchNotebooks
+});
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os from "os";
+import * as yaml2 from "js-yaml";
+function loadNotebookEntries(agentId, rootDir, filter) {
+  const entries = /* @__PURE__ */ new Map();
+  const globalDir = path3.join(GLOBAL_NOTEBOOKS_DIR, agentId);
+  loadEntriesFromDir(globalDir, entries);
+  const projectDir = path3.join(rootDir, PROJECT_NOTEBOOKS_DIR, agentId);
+  loadEntriesFromDir(projectDir, entries);
+  let result = Array.from(entries.values());
+  if (filter?.concepts && filter.concepts.length > 0) {
+    const conceptSet = new Set(filter.concepts.map((c) => c.toLowerCase()));
+    result = result.filter(
+      (e) => e.concepts.some((c) => conceptSet.has(c.toLowerCase()))
+    );
+  }
+  if (filter?.tags && filter.tags.length > 0) {
+    const tagSet = new Set(filter.tags.map((t) => t.toLowerCase()));
+    result = result.filter(
+      (e) => e.tags.some((t) => tagSet.has(t.toLowerCase()))
+    );
+  }
+  return result.sort((a, b) => b.appliedCount - a.appliedCount);
+}
+function loadEntriesFromDir(dir, entries) {
+  if (!fs3.existsSync(dir)) return;
+  try {
+    const files = fs3.readdirSync(dir).filter(
+      (f) => f.startsWith(NOTEBOOK_PREFIX) && f.endsWith(NOTEBOOK_EXT)
+    );
+    for (const file of files) {
+      try {
+        const content = fs3.readFileSync(path3.join(dir, file), "utf-8");
+        const entry = yaml2.load(content);
+        if (entry?.id) {
+          entries.set(entry.id, entry);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function searchNotebooks(agentId, query, rootDir) {
+  const all = loadNotebookEntries(agentId, rootDir);
+  const q = query.toLowerCase();
+  return all.filter(
+    (e) => e.context.toLowerCase().includes(q) || e.snippet.toLowerCase().includes(q) || e.concepts.some((c) => c.toLowerCase().includes(q)) || e.tags.some((t) => t.toLowerCase().includes(q))
+  );
+}
+function addNotebookEntry(agentId, entry, scope, rootDir) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const conceptSlug = (entry.concepts[0] || "entry").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  const timestamp = Date.now().toString(36);
+  const id = `nb-${conceptSlug}-${timestamp}`;
+  const fullEntry = {
+    ...entry,
+    id,
+    appliedCount: 0,
+    created: now,
+    updated: now
+  };
+  const dir = scope === "global" ? path3.join(GLOBAL_NOTEBOOKS_DIR, agentId) : path3.join(rootDir || process.cwd(), PROJECT_NOTEBOOKS_DIR, agentId);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  const fileName = `${id}${NOTEBOOK_EXT}`;
+  const filePath = path3.join(dir, fileName);
+  const content = yaml2.dump(fullEntry, {
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+  fs3.writeFileSync(filePath, content, "utf-8");
+  return { entry: fullEntry, filePath };
+}
+async function promoteFromLore(agentId, loreEntryId, rootDir, scope = "global") {
+  const { loadLoreEntry } = await import("./lore-loader-7NO6N6FT.js");
+  const loreEntry = await loadLoreEntry(rootDir, loreEntryId);
+  if (!loreEntry) return null;
+  const concepts = [];
+  if (loreEntry.symbols_touched) {
+    for (const sym of loreEntry.symbols_touched) {
+      const clean = sym.replace(/^[#$^!~]/, "").toLowerCase();
+      concepts.push(clean);
+    }
+  }
+  let snippet = loreEntry.summary || "";
+  if (loreEntry.body) {
+    snippet += "\n\n" + loreEntry.body;
+  }
+  const provenance = {
+    source: "lore",
+    loreEntryId,
+    originProject: path3.basename(rootDir),
+    createdBy: agentId
+  };
+  return addNotebookEntry(
+    agentId,
+    {
+      context: loreEntry.title || `Promoted from ${loreEntryId}`,
+      snippet,
+      provenance,
+      confidence: loreEntry.confidence ?? 0.7,
+      concepts,
+      tags: loreEntry.tags || []
+    },
+    scope,
+    rootDir
+  );
+}
+function incrementApplied(agentId, entryId, rootDir) {
+  const projectDir = path3.join(rootDir, PROJECT_NOTEBOOKS_DIR, agentId);
+  const globalDir = path3.join(GLOBAL_NOTEBOOKS_DIR, agentId);
+  for (const dir of [projectDir, globalDir]) {
+    const filePath = path3.join(dir, `${entryId}${NOTEBOOK_EXT}`);
+    if (fs3.existsSync(filePath)) {
+      try {
+        const content = fs3.readFileSync(filePath, "utf-8");
+        const entry = yaml2.load(content);
+        if (entry) {
+          entry.appliedCount = (entry.appliedCount || 0) + 1;
+          entry.updated = (/* @__PURE__ */ new Date()).toISOString();
+          fs3.writeFileSync(filePath, yaml2.dump(entry, {
+            lineWidth: 120,
+            noRefs: true,
+            sortKeys: false
+          }), "utf-8");
+          return true;
+        }
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+var GLOBAL_NOTEBOOKS_DIR, PROJECT_NOTEBOOKS_DIR, NOTEBOOK_PREFIX, NOTEBOOK_EXT;
+var init_notebook_loader = __esm({
+  "../paradigm-mcp/src/utils/notebook-loader.ts"() {
+    "use strict";
+    GLOBAL_NOTEBOOKS_DIR = path3.join(os.homedir(), ".paradigm", "notebooks");
+    PROJECT_NOTEBOOKS_DIR = ".paradigm/notebooks";
+    NOTEBOOK_PREFIX = "nb-";
+    NOTEBOOK_EXT = ".yaml";
+  }
+});
+
+// ../paradigm-mcp/src/utils/nomination-engine.ts
+import * as fs4 from "fs";
+import * as os2 from "os";
+import * as path4 from "path";
+function generateNominationId() {
+  const now = Date.now();
+  const rand = Math.floor(Math.random() * 9999).toString().padStart(4, "0");
+  return `nom-${now}-${rand}`;
+}
+function generateDebateId() {
+  const now = Date.now();
+  const rand = Math.floor(Math.random() * 9999).toString().padStart(4, "0");
+  return `dbt-${now}-${rand}`;
+}
+function processEvent(rootDir, event) {
+  const profiles = loadAllAgentProfiles(rootDir);
+  const policy = loadDataPolicy(rootDir);
+  const scores = [];
+  for (const profile of profiles) {
+    if (!profile.attention) continue;
+    if (event.path && !canObservePath(policy, event.path, profile.id)) {
+      continue;
+    }
+    const score = scoreEventForAgent(event, profile.id, profile.attention);
+    if (score.shouldNominate) {
+      scores.push({ profile, score });
+    }
+  }
+  if (scores.length === 0) {
+    return { nominations: [], debates: [] };
+  }
+  const recentNominations = loadNominations(rootDir, { since: new Date(Date.now() - 3e4).toISOString() });
+  const deduped = scores.filter(({ profile }) => {
+    const recent = recentNominations.find(
+      (n) => n.agent === profile.id && n.brief === generateBrief(profile, event, { ...scores.find((s) => s.profile.id === profile.id).score })
+    );
+    return !recent;
+  });
+  if (deduped.length === 0) {
+    return { nominations: [], debates: [] };
+  }
+  const nominations = deduped.map(({ profile, score }) => {
+    const urgency = deriveUrgency(event, score);
+    const type = deriveNominationType(profile, event);
+    return {
+      id: generateNominationId(),
+      agent: profile.id,
+      relevance: score.score,
+      urgency,
+      type,
+      brief: generateBrief(profile, event, score),
+      triggered_by: [event.id],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      surfaced: false
+    };
+  });
+  persistNominations(rootDir, nominations);
+  const debates = detectDebates(rootDir, nominations);
+  if (debates.length > 0) {
+    persistDebates(rootDir, debates);
+  }
+  return { nominations, debates };
+}
+function deriveUrgency(event, score) {
+  if (event.severity === "critical") return "critical";
+  if (event.severity === "error") return "high";
+  if (event.type === "compliance-violation") return "high";
+  if (event.type === "error-encountered") return "high";
+  if (event.type === "gate-added" || event.type === "route-created") return "medium";
+  if (score.score >= 0.9) return "medium";
+  return "low";
+}
+function deriveNominationType(profile, event) {
+  const stance = profile.collaboration?.stance;
+  if (event.type === "compliance-violation" || event.type === "error-encountered") return "warning";
+  if (event.type === "gate-added" || event.type === "route-created") return "observation";
+  if (stance === "advisory") return "suggestion";
+  if (stance === "lead") return "suggestion";
+  if (stance === "observer") return "observation";
+  return "observation";
+}
+function generateBrief(profile, event, score) {
+  const role = profile.role || profile.id;
+  switch (event.type) {
+    case "gate-checked":
+      return `${role}: Gate check on ${event.symbols?.join(", ") || "route"} \u2014 verify gate coverage is complete`;
+    case "file-modified":
+      return `${role}: ${event.path || "File"} modified \u2014 review for ${profile.id === "security" ? "security implications" : profile.id === "tester" ? "test coverage" : profile.id === "reviewer" ? "code quality" : "consistency"}`;
+    case "compliance-violation":
+      return `${role}: Compliance violation detected \u2014 ${event.context || "check .purpose and portal.yaml coverage"}`;
+    case "route-created":
+      return `${role}: New route ${event.symbols?.join(", ") || ""} \u2014 ${profile.id === "security" ? "needs gate assignment in portal.yaml" : "review route structure"}`;
+    case "gate-added":
+      return `${role}: Gate ${event.symbols?.join(", ") || ""} added \u2014 ${profile.id === "security" ? "verify enforcement points" : "check downstream impact"}`;
+    case "decision-made":
+      return `${role}: Decision recorded \u2014 ${event.context?.slice(0, 80) || "review for alignment with project patterns"}`;
+    case "work-completed":
+      return `${role}: Work completed on ${event.symbols?.join(", ") || event.context?.slice(0, 40) || "task"} \u2014 review outcome`;
+    case "error-encountered":
+      return `${role}: Error detected \u2014 ${event.context?.slice(0, 80) || "investigate root cause"}`;
+    default: {
+      const matchDetail = score.breakdown.symbolMatch > 0 ? `symbol match on ${event.symbols?.join(", ") || "unknown"}` : score.breakdown.pathMatch > 0 ? `path ${event.path || "unknown"}` : event.context?.slice(0, 60) || event.type;
+      return `${role}: ${matchDetail}`;
+    }
+  }
+}
+function detectDebates(rootDir, newNominations) {
+  if (newNominations.length < 2) return [];
+  const debates = [];
+  const byEvent = /* @__PURE__ */ new Map();
+  for (const nom of newNominations) {
+    for (const eventId of nom.triggered_by) {
+      const group = byEvent.get(eventId) || [];
+      group.push(nom);
+      byEvent.set(eventId, group);
+    }
+  }
+  for (const [eventId, group] of byEvent) {
+    if (group.length < 2) continue;
+    const agents = new Set(group.map((n) => n.agent));
+    if (agents.size < 2) continue;
+    const types = new Set(group.map((n) => n.type));
+    const isConflicting = types.size > 1 && types.has("warning") && types.has("suggestion");
+    debates.push({
+      id: generateDebateId(),
+      topic: `Multiple agents responded to event ${eventId}`,
+      nominations: group.map((n) => n.id),
+      type: isConflicting ? "conflicting" : "complementary",
+      overlap_events: [eventId]
+    });
+  }
+  return debates;
+}
+function getNominationsPath(rootDir) {
+  return path4.join(rootDir, EVENTS_DIR2, NOMINATIONS_FILE);
+}
+function getDebatesPath(rootDir) {
+  return path4.join(rootDir, EVENTS_DIR2, DEBATES_FILE);
+}
+function persistNominations(rootDir, nominations) {
+  try {
+    const dir = path4.join(rootDir, EVENTS_DIR2);
+    fs4.mkdirSync(dir, { recursive: true });
+    const filePath = getNominationsPath(rootDir);
+    const lines = nominations.map((n) => JSON.stringify(n)).join("\n") + "\n";
+    fs4.appendFileSync(filePath, lines, "utf8");
+    pruneFile(filePath, MAX_NOMINATIONS);
+  } catch {
+  }
+}
+function persistDebates(rootDir, debates) {
+  try {
+    const dir = path4.join(rootDir, EVENTS_DIR2);
+    fs4.mkdirSync(dir, { recursive: true });
+    const filePath = getDebatesPath(rootDir);
+    const lines = debates.map((d) => JSON.stringify(d)).join("\n") + "\n";
+    fs4.appendFileSync(filePath, lines, "utf8");
+    pruneFile(filePath, MAX_DEBATES);
+  } catch {
+  }
+}
+function pruneFile(filePath, maxLines) {
+  try {
+    const content = fs4.readFileSync(filePath, "utf8");
+    const lines = content.trim().split("\n").filter((l) => l.trim());
+    if (lines.length > maxLines) {
+      const kept = lines.slice(-maxLines);
+      fs4.writeFileSync(filePath, kept.join("\n") + "\n", "utf8");
+    }
+  } catch {
+  }
+}
+function loadNominations(rootDir, filter) {
+  const filePath = getNominationsPath(rootDir);
+  if (!fs4.existsSync(filePath)) return [];
+  try {
+    const content = fs4.readFileSync(filePath, "utf8");
+    let nominations = content.trim().split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((n) => n !== null);
+    if (filter?.agent) nominations = nominations.filter((n) => n.agent === filter.agent);
+    if (filter?.urgency) nominations = nominations.filter((n) => n.urgency === filter.urgency);
+    if (filter?.surfaced !== void 0) nominations = nominations.filter((n) => n.surfaced === filter.surfaced);
+    if (filter?.pending_only) nominations = nominations.filter((n) => !n.engaged);
+    if (filter?.since) nominations = nominations.filter((n) => n.timestamp >= filter.since);
+    nominations.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    if (filter?.limit) nominations = nominations.slice(0, filter.limit);
+    return nominations;
+  } catch {
+    return [];
+  }
+}
+function loadDebates(rootDir) {
+  const filePath = getDebatesPath(rootDir);
+  if (!fs4.existsSync(filePath)) return [];
+  try {
+    const content = fs4.readFileSync(filePath, "utf8");
+    return content.trim().split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((d) => d !== null);
+  } catch {
+    return [];
+  }
+}
+function engageNomination(rootDir, nominationId, response) {
+  const filePath = getNominationsPath(rootDir);
+  if (!fs4.existsSync(filePath)) return false;
+  try {
+    const content = fs4.readFileSync(filePath, "utf8");
+    const lines = content.trim().split("\n");
+    let found = false;
+    const updated = lines.map((line) => {
+      try {
+        const nom = JSON.parse(line);
+        if (nom.id === nominationId) {
+          nom.engaged = true;
+          nom.response = response;
+          found = true;
+          return JSON.stringify(nom);
+        }
+        return line;
+      } catch {
+        return line;
+      }
+    });
+    if (found) {
+      fs4.writeFileSync(filePath, updated.join("\n") + "\n", "utf8");
+      if (response === "accepted" || response === "dismissed") {
+        const nom = JSON.parse(lines.find((l) => {
+          try {
+            return JSON.parse(l).id === nominationId;
+          } catch {
+            return false;
+          }
+        }));
+        const profile = loadAllAgentProfiles(rootDir).find((p) => p.id === nom.agent);
+        if (profile?.learning?.intrinsic?.feedback?.after_recommendation) {
+          emitEvent(rootDir, {
+            type: "work-completed",
+            source: "agent-action",
+            agent: nom.agent,
+            context: `Nomination ${nominationId} ${response} \u2014 feedback for learning`,
+            data: { nomination_id: nominationId, response }
+          });
+        }
+      }
+    }
+    return found;
+  } catch {
+    return false;
+  }
+}
+function resolveDebate(rootDir, debateId, chosenNominationId, reason) {
+  const filePath = getDebatesPath(rootDir);
+  if (!fs4.existsSync(filePath)) return false;
+  try {
+    const content = fs4.readFileSync(filePath, "utf8");
+    const lines = content.trim().split("\n");
+    let found = false;
+    const updated = lines.map((line) => {
+      try {
+        const debate = JSON.parse(line);
+        if (debate.id === debateId) {
+          debate.resolution = {
+            chosen: chosenNominationId,
+            reason,
+            resolved_by: "human",
+            resolved_at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          found = true;
+          const nonChosen = debate.nominations.filter((id) => id !== chosenNominationId);
+          for (const loserId of nonChosen) {
+            const loserNom = loadNominations(rootDir).find((n) => n.id === loserId);
+            if (loserNom) {
+              emitEvent(rootDir, {
+                type: "work-completed",
+                source: "agent-action",
+                agent: loserNom.agent,
+                context: `Debate ${debateId} resolved \u2014 nomination ${loserId} not chosen`,
+                data: { debate_id: debateId, chosen: chosenNominationId, reason }
+              });
+            }
+          }
+          return JSON.stringify(debate);
+        }
+        return line;
+      } catch {
+        return line;
+      }
+    });
+    if (found) {
+      fs4.writeFileSync(filePath, updated.join("\n") + "\n", "utf8");
+    }
+    return found;
+  } catch {
+    return false;
+  }
+}
+function processPendingEvents(rootDir) {
+  const lastProcessedPath = path4.join(rootDir, EVENTS_DIR2, ".last-processed");
+  let lastProcessedId = "";
+  try {
+    if (fs4.existsSync(lastProcessedPath)) {
+      lastProcessedId = fs4.readFileSync(lastProcessedPath, "utf8").trim();
+    }
+  } catch {
+  }
+  const streamPath = path4.join(rootDir, EVENTS_DIR2, "stream.jsonl");
+  if (!fs4.existsSync(streamPath)) return { processed: 0, nominations: [] };
+  let events = [];
+  try {
+    const content = fs4.readFileSync(streamPath, "utf8");
+    events = content.trim().split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+  } catch {
+    return { processed: 0, nominations: [] };
+  }
+  let startIdx = 0;
+  if (lastProcessedId) {
+    const idx = events.findIndex((e) => e.id === lastProcessedId);
+    if (idx >= 0) startIdx = idx + 1;
+  }
+  const pending = events.slice(startIdx);
+  if (pending.length === 0) return { processed: 0, nominations: [] };
+  const allNominations = [];
+  const toProcess = pending.slice(0, 50);
+  for (const event of toProcess) {
+    const { nominations } = processEvent(rootDir, event);
+    allNominations.push(...nominations);
+  }
+  const lastEvent = toProcess[toProcess.length - 1];
+  try {
+    fs4.mkdirSync(path4.join(rootDir, EVENTS_DIR2), { recursive: true });
+    fs4.writeFileSync(lastProcessedPath, lastEvent.id, "utf8");
+  } catch {
+  }
+  return { processed: toProcess.length, nominations: allNominations };
+}
+function emitAndProcess(rootDir, event, opts) {
+  const policy = loadDataPolicy(rootDir);
+  if (event.path && !canObservePath(policy, event.path)) {
+    const emitted2 = emitEvent(rootDir, event);
+    return { event: emitted2, nominations: [], debates: [] };
+  }
+  const emitted = emitEvent(rootDir, event);
+  if (opts?.skipNominations) {
+    return { event: emitted, nominations: [], debates: [] };
+  }
+  const { nominations, debates } = processEvent(rootDir, emitted);
+  if (nominations.length > 0) {
+    forwardNominationsToRelay(rootDir, nominations);
+  }
+  return { event: emitted, nominations, debates };
+}
+function adjustAttentionFromFeedback(rootDir, agentId) {
+  const profile = loadAgentProfile(rootDir, agentId);
+  if (!profile?.attention) {
+    return { adjusted: false, oldThreshold: 0.6, newThreshold: 0.6, reason: "No attention config" };
+  }
+  const oldThreshold = profile.attention.threshold ?? 0.6;
+  const nominations = loadNominations(rootDir, { agent: agentId });
+  const engaged = nominations.filter((n) => n.engaged);
+  if (engaged.length < 5) {
+    return { adjusted: false, oldThreshold, newThreshold: oldThreshold, reason: `Insufficient data (${engaged.length}/5 engaged nominations)` };
+  }
+  const accepted = engaged.filter((n) => n.response === "accepted").length;
+  const dismissed = engaged.filter((n) => n.response === "dismissed").length;
+  const acceptRate = accepted / engaged.length;
+  const dismissRate = dismissed / engaged.length;
+  let newThreshold = oldThreshold;
+  let reason = "No adjustment needed";
+  if (dismissRate > 0.6) {
+    newThreshold = Math.min(0.95, oldThreshold + 0.05);
+    reason = `High dismiss rate (${(dismissRate * 100).toFixed(0)}%) \u2014 raising threshold to reduce noise`;
+  } else if (acceptRate > 0.8) {
+    newThreshold = Math.max(0.2, oldThreshold - 0.05);
+    reason = `High accept rate (${(acceptRate * 100).toFixed(0)}%) \u2014 lowering threshold to contribute more`;
+  }
+  if (newThreshold === oldThreshold) {
+    return { adjusted: false, oldThreshold, newThreshold, reason };
+  }
+  profile.attention.threshold = newThreshold;
+  const projectPath = path4.join(rootDir, ".paradigm/agents", `${agentId}.agent`);
+  const scope = fs4.existsSync(projectPath) ? "project" : "global";
+  saveAgentProfile(agentId, profile, scope, rootDir);
+  emitEvent(rootDir, {
+    type: "work-completed",
+    source: "agent-action",
+    agent: agentId,
+    context: `Attention threshold adjusted: ${oldThreshold.toFixed(2)} \u2192 ${newThreshold.toFixed(2)} (${reason})`,
+    data: { old_threshold: oldThreshold, new_threshold: newThreshold, accept_rate: acceptRate, dismiss_rate: dismissRate }
+  });
+  return { adjusted: true, oldThreshold, newThreshold, reason };
+}
+function getNominationStats(rootDir, agentId) {
+  const nominations = loadNominations(rootDir, { agent: agentId });
+  const accepted = nominations.filter((n) => n.response === "accepted").length;
+  const dismissed = nominations.filter((n) => n.response === "dismissed").length;
+  const deferred = nominations.filter((n) => n.response === "deferred").length;
+  const pending = nominations.filter((n) => !n.engaged).length;
+  const engaged = accepted + dismissed + deferred;
+  return {
+    total: nominations.length,
+    accepted,
+    dismissed,
+    deferred,
+    pending,
+    acceptRate: engaged > 0 ? accepted / engaged : 0
+  };
+}
+function forwardNominationsToRelay(rootDir, nominations) {
+  if (nominations.length === 0) return;
+  const outboxDir = path4.join(os2.homedir(), ".paradigm", "score", "outbox");
+  if (!fs4.existsSync(outboxDir)) return;
+  try {
+    const outboxFile = path4.join(outboxDir, `nom-${Date.now()}.json`);
+    const message = {
+      type: "nomination_forward",
+      nominations: nominations.map((n) => ({ ...n })),
+      origin: detectLocalProject(rootDir),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs4.writeFileSync(outboxFile, JSON.stringify(message), "utf8");
+  } catch {
+  }
+}
+function detectLocalProject(rootDir) {
+  try {
+    const configPath = path4.join(rootDir, ".paradigm", "config.yaml");
+    if (fs4.existsSync(configPath)) {
+      const content = fs4.readFileSync(configPath, "utf8");
+      const match = content.match(/project:\s*(.+)/);
+      if (match) return match[1].trim();
+    }
+  } catch {
+  }
+  return path4.basename(rootDir);
+}
+function autoPromoteJournalEntries(rootDir, agentId) {
+  let loadJournalEntries;
+  let addNotebookEntry2;
+  try {
+    const journalMod = (init_journal_loader(), __toCommonJS(journal_loader_exports));
+    const notebookMod = (init_notebook_loader(), __toCommonJS(notebook_loader_exports));
+    loadJournalEntries = journalMod.loadJournalEntries;
+    addNotebookEntry2 = notebookMod.addNotebookEntry;
+  } catch {
+    return { promoted: 0, entries: [] };
+  }
+  const journal = loadJournalEntries(agentId, {
+    trigger: "pattern_discovered",
+    limit: 100
+  });
+  const promoted = [];
+  for (const entry of journal) {
+    if (entry.promoted_to_notebook) continue;
+    if ((entry.confidence_after ?? 0) < 0.8) continue;
+    try {
+      const { entry: nbEntry } = addNotebookEntry2(
+        agentId,
+        {
+          context: entry.pattern?.applies_when || entry.insight.slice(0, 80),
+          snippet: entry.pattern?.correct_approach || entry.insight,
+          concepts: entry.tags || [entry.pattern?.id || "learned-pattern"],
+          provenance: {
+            source: "journal-auto-promote",
+            sourceId: entry.id,
+            createdBy: agentId
+          }
+        },
+        "global",
+        rootDir
+      );
+      promoted.push({ journalId: entry.id, notebookId: nbEntry.id });
+      try {
+        const journalDir = path4.join(os2.homedir(), ".paradigm", "agents", agentId, "journal");
+        if (fs4.existsSync(journalDir)) {
+          const files = fs4.readdirSync(journalDir).filter((f) => f.endsWith(".yaml"));
+          for (const file of files) {
+            const filePath = path4.join(journalDir, file);
+            const content = fs4.readFileSync(filePath, "utf8");
+            if (content.includes(entry.id)) {
+              const updated = content.replace(
+                /promoted_to_notebook:.*$/m,
+                `promoted_to_notebook: "${nbEntry.id}"`
+              );
+              if (updated === content) {
+                const lines = content.trimEnd().split("\n");
+                lines.push(`promoted_to_notebook: "${nbEntry.id}"`);
+                fs4.writeFileSync(filePath, lines.join("\n") + "\n", "utf8");
+              } else {
+                fs4.writeFileSync(filePath, updated, "utf8");
+              }
+              break;
+            }
+          }
+        }
+      } catch {
+      }
+    } catch {
+    }
+  }
+  return { promoted: promoted.length, entries: promoted };
+}
+function loadSurfacingConfig(rootDir) {
+  const filePath = path4.join(rootDir, SURFACING_FILE);
+  const defaults = {
+    default_min_urgency: "low",
+    enable_debates: true
+  };
+  if (!fs4.existsSync(filePath)) return defaults;
+  try {
+    const yaml3 = __require("js-yaml");
+    const content = fs4.readFileSync(filePath, "utf8");
+    const parsed = yaml3.load(content);
+    return { ...defaults, ...parsed };
+  } catch {
+    return defaults;
+  }
+}
+function applySurfacingRules(nominations, config) {
+  const urgencyOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  const minUrgency = urgencyOrder[config.default_min_urgency || "low"] ?? 3;
+  return nominations.filter((n) => {
+    const nomUrgency = urgencyOrder[n.urgency] ?? 3;
+    if (config.preferences) {
+      const agentPref = config.preferences.find((p) => p.agent === n.agent);
+      if (agentPref) {
+        if (agentPref.always_show) return true;
+        if (agentPref.mute_unless?.length) {
+          const matchesMute = agentPref.mute_unless.some(
+            (condition) => n.urgency === condition || n.type === condition
+          );
+          if (!matchesMute) return false;
+        }
+        if (agentPref.min_urgency) {
+          const agentMin = urgencyOrder[agentPref.min_urgency] ?? 3;
+          return nomUrgency <= agentMin;
+        }
+      }
+    }
+    return nomUrgency <= minUrgency;
+  });
+}
+var EVENTS_DIR2, NOMINATIONS_FILE, DEBATES_FILE, MAX_NOMINATIONS, MAX_DEBATES, SURFACING_FILE;
+var init_nomination_engine = __esm({
+  "../paradigm-mcp/src/utils/nomination-engine.ts"() {
+    init_event_stream();
+    init_data_policy_loader();
+    init_agent_loader();
+    EVENTS_DIR2 = ".paradigm/events";
+    NOMINATIONS_FILE = "nominations.jsonl";
+    DEBATES_FILE = "debates.jsonl";
+    MAX_NOMINATIONS = 500;
+    MAX_DEBATES = 200;
+    SURFACING_FILE = ".paradigm/surfacing.yaml";
+  }
+});
+
+export {
+  queryEvents,
+  init_event_stream,
+  loadDataPolicy,
+  filterContent,
+  init_data_policy_loader,
+  loadNotebookEntries,
+  searchNotebooks,
+  addNotebookEntry,
+  promoteFromLore,
+  init_notebook_loader,
+  processEvent,
+  detectDebates,
+  persistNominations,
+  loadNominations,
+  loadDebates,
+  engageNomination,
+  resolveDebate,
+  processPendingEvents,
+  emitAndProcess,
+  adjustAttentionFromFeedback,
+  getNominationStats,
+  forwardNominationsToRelay,
+  autoPromoteJournalEntries,
+  loadSurfacingConfig,
+  applySurfacingRules,
+  init_nomination_engine
+};